Execute yjs from insight script

app/ydoc-server-polyglot/build.mjs

@@ -13,9 +13,9 @@ const globals = {
 }
 
 const ctx = await esbuild.context({
-  outfile: 'dist/main.cjs',
+  outdir: 'dist',
   sourcemap: 'linked',
-  entryPoints: ['src/main.ts'],
+  entryPoints: ['src/main.ts', 'src/insight.ts'],
   bundle: true,
   platform: 'browser',
   define: {

app/ydoc-server-polyglot/package.json

@@ -10,13 +10,15 @@
   "main": "./dist/main.js",
   "scripts": {
     "compile": "node ./build.mjs build",
-    "start": "node ./dist/main.cjs",
+    "start": "node ./dist/main.js",
     "dev:watch": "node ./build.mjs watch",
     "lint": "eslint . --cache --max-warnings=0"
   },
   "dependencies": {
+    "y-websocket": "^1.5.0",
     "ydoc-server": "workspace:*",
-    "ydoc-shared": "workspace:*"
+    "ydoc-shared": "workspace:*",
+    "yjs": "^13.6.7"
   },
   "devDependencies": {
     "@fal-works/esbuild-plugin-global-externals": "^2.1.2",

app/ydoc-server-polyglot/src/insight.ts

@@ -0,0 +1,127 @@
+import { deserializeIdMap } from 'ydoc-server'
+import * as Ast from 'ydoc-shared/ast'
+import { splitFileContents } from 'ydoc-shared/ensoFile'
+import { DistributedProject, ModuleDoc } from 'ydoc-shared/yjsModel'
+import { WebsocketProvider } from 'y-websocket'
+import * as Y from 'yjs'
+
+interface SubdocsEvent {
+  loaded: Set<Y.Doc>
+  added: Set<Y.Doc>
+  removed: Set<Y.Doc>
+}
+
+print("Initializing Insight: " + JSON.stringify(insight));
+
+const PROJECT_NAME = 'NewProject1'
+const RETURN_VALUE_KEY = 'insight_return_value'
+
+//const doc = new ModuleDoc(new Y.Doc())
+const doc = new Y.Doc()
+const syncModule = new Ast.MutableModule(doc)
+let spanMap = null
+
+function attachProvider(url: string, room: string, doc: Y.Doc) {
+  print(`attachProvider ${url} ${room}`)
+  const provider = new WebsocketProvider(url, room, doc)
+  const onSync = () => doc.emit('sync', [true, doc])
+  const onDrop = () => doc.emit('sync', [false, doc])
+
+  const attachedSubdocs = new Map<Y.Doc, ReturnType<typeof attachProvider>>()
+
+  function onSubdocs(e: SubdocsEvent) {
+    e.loaded.forEach((subdoc) => {
+      attachedSubdocs.set(subdoc, attachProvider(url, subdoc.guid, subdoc))
+    })
+    e.removed.forEach((subdoc) => {
+      const subdocProvider = attachedSubdocs.get(subdoc)
+      attachedSubdocs.delete(subdoc)
+      if (subdocProvider != null) {
+        subdocProvider.dispose()
+      }
+    })
+  }
+
+  provider.on('sync', onSync)
+  provider.on('connection-close', onDrop)
+  provider.on('connection-error', onDrop)
+  doc.on('subdocs', onSubdocs)
+
+  function dispose() {
+    provider.disconnect()
+    provider.off('sync', onSync)
+    provider.off('connection-close', onDrop)
+    provider.off('connection-error', onDrop)
+    doc.off('subdocs', onSubdocs)
+    attachedSubdocs.forEach((subdocProvider) => {
+      subdocProvider.dispose()
+    })
+  }
+  return { provider, dispose }
+}
+
+const d = new Y.Doc()
+const project = new DistributedProject(d)
+//const provider = attachProvider('ws://[::1]:5976/project', 'index', d)
+
+function parseContents(contents: string, syncModule: Ast.MutableModule) {
+  const { code, idMapJson, metadataJson } = splitFileContents(contents)
+  const parsedIdMap = deserializeIdMap(idMapJson)
+
+  const { root, spans } = Ast.parseModuleWithSpans(code, syncModule)
+  syncModule.setRoot(root)
+  spanMap = spans
+
+  Ast.setExternalIds(syncModule, spans, parsedIdMap)
+  print(`[parseContents] idMap.entries=${parsedIdMap.entries()}`)
+}
+
+insight.on("source", function(ctx, frame) {
+  print(`[source] ctx.uri=${ctx.name}`)
+  if (ctx.name.includes(PROJECT_NAME)) {
+    print(`[source] MATCHED ctx=${JSON.stringify(ctx)}`)
+    parseContents(ctx.characters, syncModule)
+  }
+})
+
+function resultToString(result: any): string {
+  return '' + result;
+}
+
+/*
+  class IdMap {
+    private readonly rangeToExpr: Map<SourceRange, ExternalId>
+  }
+  interface SpanMap {
+    nodes: Map<NodeKey, Ast[]>
+    tokens: Map<TokenKey, Token>
+  }
+  type NodeKey = TokenKey = SourceRangeKey
+ */
+insight.on("return", function(ctx, frame) {
+  print(`[return] ctx='${JSON.stringify(ctx)}'`)
+  print(`[return] frame='${JSON.stringify(frame)}'`)
+  print(`[return] ctx.returnValue='${ctx.returnValue(frame)}'`)
+
+  const p = project
+  const result = ctx.returnValue(frame)
+  if (result && spanMap) {
+    const key = Ast.nodeKey(ctx.charIndex, ctx.charEndIndex - ctx.charIndex)
+    const asts = spanMap.nodes.get(key)
+    if (asts) {
+      const resultValue = resultToString(result)
+      for (const ast of asts) {
+        const editAst = syncModule.getVersion(ast)
+        if (editAst.widgetMetadata(RETURN_VALUE_KEY) !== resultValue) {
+          print(`[return] setWidgetMetadata ${ast.code()} : ${resultValue}`)
+          editAst.setWidgetMetadata(RETURN_VALUE_KEY, resultValue)
+        }
+      }
+    }
+  }
+}, {
+  expressions: true,
+  statements: false,
+  roots: false,
+  rootNameFilter: ".*main"
+})

app/ydoc-server-polyglot/tsconfig.json

@@ -1,7 +1,10 @@
 {
   "extends": "../../tsconfig.json",
   "include": ["src/**/*.ts"],
-  "references": [{ "path": "../ydoc-server" }],
+  "references": [
+    { "path": "../ydoc-server" },
+    { "path": "../ydoc-shared" },
+  ],
   "compilerOptions": {
     "composite": true,
     "noEmit": false,

app/ydoc-shared/src/ast/index.ts

@@ -2,7 +2,7 @@ import { reachable } from '../util/data/graph'
 import type { Module } from './mutableModule'
 import type { AstId } from './tree'
 
-export { spanMapToIdMap } from './idMap'
+export { nodeKey, spanMapToIdMap } from './idMap'
 export * from './mutableModule'
 export * from './parse'
 export { printWithSpans } from './print'

engine/common/src/main/java/org/enso/common/ContextFactory.java

@@ -10,6 +10,7 @@
 import org.enso.logging.config.LoggerSetup;
 import org.graalvm.polyglot.Context;
 import org.graalvm.polyglot.HostAccess;
+import org.graalvm.polyglot.io.IOAccess;
 import org.graalvm.polyglot.io.MessageTransport;
 import org.slf4j.event.Level;
 
@@ -165,6 +166,7 @@ public Context build() {
         Context.newBuilder()
             .allowExperimentalOptions(true)
             .allowAllAccess(true)
+            .allowIO(IOAccess.ALL)
             .allowHostAccess(allWithTypeMapping())
             .option(RuntimeOptions.STRICT_ERRORS, Boolean.toString(strictErrors))
             .option(RuntimeOptions.DISABLE_LINTING, Boolean.toString(disableLinting))
@@ -252,7 +254,7 @@ public Context build() {
   }
 
   private static HostAccess allWithTypeMapping() {
-    return HostAccess.newBuilder()
+    return HostAccess.newBuilder(HostAccess.EXPLICIT)
         .allowPublicAccess(true)
         .allowAllImplementations(true)
         .allowAllClassImplementations(true)

engine/language-server/src/main/scala/org/enso/languageserver/boot/MainModule.scala

@@ -316,6 +316,11 @@ class MainModule(serverConfig: LanguageServerConfig, logLevel: Level) {
     RuntimeOptions.JOB_PARALLELISM,
     Runtime.getRuntime.availableProcessors().toString
   )
+  if (System.getProperty("enso.dev.inspectPort") != null) {
+    val inspectPort = Integer.getInteger("enso.dev.inspectPort", 34567);
+    extraOptions.put("inspect", s":$inspectPort")
+    stdErr.attach(arr => System.out.write(arr))
+  }
 
   val builder = ContextFactory
     .create()

engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/EpbContext.java

@@ -11,6 +11,7 @@
 import java.util.concurrent.Executors;
 import java.util.function.Function;
 import java.util.logging.Level;
+import org.enso.ydoc.polyfill.ParserPolyfill;
 import org.enso.ydoc.polyfill.web.WebEnvironment;
 import org.graalvm.polyglot.Value;
 
@@ -86,6 +87,7 @@ public void log(Level level, String msg, Object... args) {
 
   final void initializePolyfill(Node node, TruffleContext ctx) {
     if (!polyfillInitialized) {
+      var parserPolyfill = new ParserPolyfill();
       polyfillInitialized = true;
       var exec = Executors.newSingleThreadScheduledExecutor();
       Function<URL, Value> eval =
@@ -99,6 +101,7 @@ final void initializePolyfill(Node node, TruffleContext ctx) {
             }
           };
       WebEnvironment.initialize(eval, exec);
+      parserPolyfill.initialize(eval);
     }
   }
 }

lib/java/ydoc-polyfill/src/main/java/org/enso/ydoc/polyfill/ParserPolyfill.java

@@ -8,6 +8,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.net.URL;
+import java.util.function.Function;
+
 public final class ParserPolyfill implements ProxyExecutable {
 
   private static final Logger log = LoggerFactory.getLogger(ParserPolyfill.class);
@@ -22,10 +25,17 @@ public final class ParserPolyfill implements ProxyExecutable {
   public ParserPolyfill() {}
 
   public void initialize(Context ctx) {
-    Source parserJs =
-        Source.newBuilder("js", ParserPolyfill.class.getResource(PARSER_JS)).buildLiteral();
+    Function<URL, Value> eval =
+        (url) -> {
+          var src = Source.newBuilder("js", url).buildLiteral();
+          return ctx.eval(src);
+        };
+    initialize(eval);
+  }
 
-    ctx.eval(parserJs).execute(this);
+  public void initialize(Function<URL, Value> eval) {
+    final Value fn = eval.apply(getClass().getResource(PARSER_JS));
+    fn.execute(this);
   }
 
   @Override