anchor.diff:      type WarpOptions<'EndPoint when 'EndPoint : equality>(assembly, ?debug, ?rootDir, ?scripted) =
           let debug = defaultArg debug false
           let rootDir = defaultArg rootDir (Directory.GetCurrentDirectory())
  -        let scripted = defaultArg scripted false
  +        let scripted = defaultArg scripted true
   
           member this.Assembly = assembly
           member this.Debug = debug
  
positive.code:     open IntelliFactory.Core
      module FE = WebSharper.Compiler.FrontEnd
  
      let compile asm =
          let localDir = Directory.GetCurrentDirectory()
          let websharperDir = Path.GetDirectoryName typeof<Sitelet<_>>.Assembly.Location
          let fsharpDir = Path.GetDirectoryName typeof<option<_>>.Assembly.Location
          let loadPaths =
              [
                  localDir
                  websharperDir
                  fsharpDir
              ]
          let loader =
              let aR =
                  AssemblyResolver.Create()
                      .SearchDirectories(loadPaths)
                      .WithBaseDirectory(fsharpDir)
              FE.Loader.Create aR stderr.WriteLine
          let refs =
              [
                  for dll in Directory.EnumerateFiles(websharperDir, "*.dll") do
                      if Path.GetFileName(dll) <> "FSharp.Core.dll" then
                          yield dll
                  let dontRef (n: string) =
                      [
                          "FSharp.Compiler.Interactive.Settings,"
                          "FSharp.Compiler.Service,"
                          "FSharp.Core,"
                          "FSharp.Data.TypeProviders,"
                          "Mono.Cecil"
                          "mscorlib,"
                          "System."
                          "System,"
                      ] |> List.exists n.StartsWith
                  let rec loadRefs (asms: Assembly[]) (loaded: Map<string, Assembly>) =
                      let refs =
                          asms
                          |> Seq.collect (fun asm -> asm.GetReferencedAssemblies())
                          |> Seq.map (fun n -> n.FullName)
                          |> Seq.distinct
                          |> Seq.filter (fun n -> not (dontRef n || Map.containsKey n loaded))
                          |> Seq.choose (fun n ->
                              try Some (AppDomain.CurrentDomain.Load n)
                              with _ -> None)
                          |> Array.ofSeq
                      if Array.isEmpty refs then
                          loaded
                      else
                          (loaded, refs)
                          ||> Array.fold (fun loaded r -> Map.add r.FullName r loaded)
                          |> loadRefs refs
                  let asms =
                      AppDomain.CurrentDomain.GetAssemblies()
                      |> Array.append (AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies())
                      |> Array.filter (fun a -> not (dontRef a.FullName))
                  yield! asms
                  |> Array.map (fun asm -> asm.FullName, asm)
                  |> Map.ofArray
                  |> loadRefs asms
                  |> Seq.choose (fun (KeyValue(n, asm)) ->
                      try Some asm.Location
                      with :? NotSupportedException ->
                          // The dynamic assembly does not support `.Location`.
                          // No problem, if it's from the dynamic assembly then
                          // it doesn't incur a dependency anyway.
                          None)
              ]
              |> Seq.distinctBy Path.GetFileName
              |> Seq.map loader.LoadFile
              |> Seq.toList
          let opts = { FE.Options.Default with References = refs }
          let compiler = FE.Prepare opts (eprintfn "%O")
          compiler.Compile(<@ () @>, context = asm)
          |> Option.map (fun asm -> asm, refs)
  
      let outputFiles root (refs: Compiler.Assembly list) =
          let pc = PC.PathUtility.FileSystem(root)
  
negative.code: 
      let (+/) x y = Path.Combine(x, y)
  
      let outputFile root (asm: CompiledAssembly) =
          let dir = root +/ "Scripts" +/ "WebSharper"
          Directory.CreateDirectory(dir) |> ignore
          File.WriteAllText(dir +/ "WebSharper.EntryPoint.js", asm.ReadableJavaScript)
  