novac 2.1.1 → 2.2.0

package/novac/src/core/nova_thread_worker.js

@@ -0,0 +1,166 @@
+/**
+ * nova_thread_worker.js
+ * Spawned by Executor._initThread() via worker_threads.Worker.
+ *
+ * workerData shape:
+ *   executorPath   — absolute path to executor.js
+ *   scopeSnapshot  — structured-clone of the caller's scope variables
+ *                    (Nova class instances arrive as prototype-stripped plain
+ *                     objects; rehydrate() restores the right constructors)
+ *   fnNode         — structured-clone of the Nova AST function node to run
+ *   rawsrc         — original source string (for error messages)
+ *
+ * Message protocol (parentPort):
+ *
+ *   Worker → Main
+ *     { kind:'set',   name, value }   thread.set(name, val) — scope mutation
+ *     { kind:'print', text }          stdout relay
+ *     { kind:'msg',   value }         thread.send(val)
+ *     { kind:'done',  result }        normal exit
+ *     { kind:'error', message }       uncaught throw
+ *
+ *   Main → Worker
+ *     { kind:'msg', value }           t.send(val) from main side
+ */
+
+'use strict';
+const { parentPort, workerData, isMainThread } = require('worker_threads');
+
+// Guard: this file must only execute as a spawned Worker, never require()'d directly.
+if (isMainThread || !workerData) { module.exports = {}; return; }
+
+const { executorPath, scopeSnapshot, fnNode, rawsrc } = workerData;
+
+// ── load types from the same directory as executor ────────────────────────────
+const path   = require('path');
+const typesPath = path.join(path.dirname(executorPath), 'types.js');
+const {
+  NovaValue, NovaNumber, NovaString, NovaArray, NovaObject,
+  NovaBool, NovaNull, NovaRange, NovaStruct, NovaEnum,
+} = require(typesPath);
+
+// ── rehydrate ─────────────────────────────────────────────────────────────────
+// structured-clone strips prototypes but preserves own properties.
+// We reconstruct the right Nova class from the shape of what arrived.
+function rehydrate(v) {
+  if (v === null || v === undefined) return v;
+  const t = typeof v;
+  if (t === 'number' || t === 'string' || t === 'boolean') return v;
+  if (t !== 'object') return v;
+  if (Array.isArray(v)) return v.map(rehydrate);
+
+  // NovaBool / NovaNumber / NovaString / NovaNull — all have _v
+  if ('_v' in v) {
+    if (v._v === null)              return new NovaNull();
+    if (typeof v._v === 'boolean')  return new NovaBool(v._v);
+    if (typeof v._v === 'number')   return new NovaNumber(v._v);
+    if (typeof v._v === 'string')   return new NovaString(v._v);
+    return v._v; // fallback
+  }
+
+  // NovaRange — { start, end }
+  if ('start' in v && 'end' in v && Object.keys(v).length === 2)
+    return new NovaRange(v.start, v.end);
+
+  // NovaStruct — { typeName, inner: {} }
+  if ('typeName' in v && 'inner' in v && typeof v.inner === 'object' && !Array.isArray(v.inner)) {
+    const inner = {};
+    for (const [k, val] of Object.entries(v.inner)) inner[k] = rehydrate(val);
+    return new NovaStruct(v.typeName, inner);
+  }
+
+  // NovaArray — { inner: [] }
+  if ('inner' in v && Array.isArray(v.inner))
+    return new NovaArray(v.inner.map(rehydrate));
+
+  // NovaObject — { inner: {} }
+  if ('inner' in v && typeof v.inner === 'object' && !Array.isArray(v.inner)) {
+    const inner = {};
+    for (const [k, val] of Object.entries(v.inner)) inner[k] = rehydrate(val);
+    return new NovaObject(inner);
+  }
+
+  // Nova AST function node — plain object with kind:'function', args, body
+  // These pass through structured clone perfectly; return as-is.
+  if ('kind' in v) return v;
+
+  // Native JS functions were serialized to source strings by the main thread
+  // and tagged { __jsfn__: '<source>' }
+  if ('__jsfn__' in v) {
+    try { return eval('(' + v.__jsfn__ + ')'); } catch { return null; }
+  }
+
+  // generic plain object — recurse
+  const out = {};
+  for (const [k, val] of Object.entries(v)) out[k] = rehydrate(val);
+  return out;
+}
+
+// ── boot executor ─────────────────────────────────────────────────────────────
+const { Executor, Scope } = require(executorPath);
+const exe = new Executor(rawsrc || '');
+
+// relay stdout to main thread
+process.stdout.write = (text) => {
+  parentPort.postMessage({ kind: 'print', text: String(text) });
+  return true;
+};
+
+// ── hydrate scope ─────────────────────────────────────────────────────────────
+const workerScope = new Scope('thread', null, exe.globalScope);
+for (const [name, frozen] of Object.entries(scopeSnapshot || {})) {
+  workerScope.set(name, rehydrate(frozen));
+}
+
+// ── inbox for thread.recv() ───────────────────────────────────────────────────
+const inbox = [];
+let inboxWaker = null;
+parentPort.on('message', (msg) => {
+  if (msg.kind !== 'msg') return;
+  const val = rehydrate(msg.value);
+  if (inboxWaker) { const w = inboxWaker; inboxWaker = null; w(val); }
+  else inbox.push(val);
+});
+
+// ── thread control object exposed as 'thread' inside the worker ───────────────
+const threadObj = new NovaObject({
+  // Mutate a variable back in the main thread's scope (applied on join())
+  set: (name, value) => {
+    parentPort.postMessage({ kind: 'set', name: String(name), value });
+    workerScope.set(String(name), value);
+    return value;
+  },
+  // Non-blocking send to main
+  send: (value) => {
+    parentPort.postMessage({ kind: 'msg', value });
+    return value;
+  },
+  // Sync-blocking receive from main (Atomics.wait)
+  recv: () => {
+    if (inbox.length) return inbox.shift();
+    const sab  = new SharedArrayBuffer(8);
+    const flag = new Int32Array(sab);
+    let result;
+    inboxWaker = (v) => { result = v; Atomics.store(flag, 0, 1); Atomics.notify(flag, 0); };
+    Atomics.wait(flag, 0, 0);
+    return result;
+  },
+  print: (v) => {
+    parentPort.postMessage({ kind: 'print', text: exe.stringify(v) + '\n' });
+  },
+  id: require('worker_threads').threadId,
+});
+workerScope.set('thread', threadObj);
+
+// ── run ───────────────────────────────────────────────────────────────────────
+const rehydratedFn = rehydrate(fnNode);
+try {
+  const result = rehydratedFn && rehydratedFn.body
+    ? exe.runFunctionNode(rehydratedFn, workerScope, [])
+    : null;
+  // result goes back raw via structured clone — main side rehydrates it too
+  parentPort.postMessage({ kind: 'done', result });
+} catch (e) {
+  const msg = e && e.message ? e.message : String(e);
+  parentPort.postMessage({ kind: 'error', message: msg });
+}