novac 2.2.0 → 2.2.2

package/novac/src/core/nova_thread_worker.js

@@ -1,166 +0,0 @@
-/**
- * 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 });
-}