@coana-tech/cli 15.0.1 → 15.0.2

package/repos/coana-tech/spar/runtime/dist/hints.js

@@ -0,0 +1,131 @@
+// Hint collection for approximate interpretation.
+// Adapted from Jelly's src/approx/hints.ts.
+// Save native functions before user code can overwrite them.
+const arrayFrom = Array.from.bind(Array);
+const arrayFlat = Array.prototype.flat;
+function flattenValues(map) {
+    return arrayFlat.call(arrayFrom(map.values()));
+}
+function mapArrayAddNoDuplicates(key, value, map, eq) {
+    let arr = map.get(key);
+    if (!arr) {
+        arr = [];
+        map.set(key, arr);
+    }
+    if (!arr.some(v => eq(v, value)))
+        arr.push(value);
+}
+function mapArraySize(map) {
+    let c = 0;
+    for (const v of map.values())
+        c += v.length;
+    return c;
+}
+export class Hints {
+    /**
+     * Names of modules (including eval code) that have been executed dynamically.
+     */
+    modules = [];
+    /**
+     * Map from module name to index in LocationJSON strings.
+     */
+    moduleIndex = new Map();
+    /**
+     * Functions that have been visited (either via module execution or by forced execution).
+     */
+    functions = new Set();
+    /**
+     * Read hints grouped by location of the read operation.
+     */
+    reads = new Map();
+    /**
+     * Write hints grouped by location of the write operation.
+     */
+    writes = new Map();
+    /**
+     * Require/import hints grouped by location of the require/import operation.
+     */
+    requires = new Map();
+    /**
+     * Eval/Function hints grouped by the location of the eval/Function operation.
+     */
+    evals = new Map();
+    addModule(m) {
+        let idx = this.moduleIndex.get(m);
+        if (idx !== undefined)
+            return idx;
+        idx = this.modules.length;
+        this.modules.push(m);
+        this.moduleIndex.set(m, idx);
+        return idx;
+    }
+    addFunction(f) {
+        this.functions.add(f);
+    }
+    addReadHint(h) {
+        mapArrayAddNoDuplicates(h.loc, h, this.reads, (v1, v2) => v1.prop === v2.prop && v1.valLoc === v2.valLoc && v1.valType === v2.valType);
+    }
+    addWriteHint(h) {
+        mapArrayAddNoDuplicates(h.loc, h, this.writes, (v1, v2) => v1.type === v2.type && v1.baseLoc === v2.baseLoc && v1.baseType === v2.baseType &&
+            v1.prop === v2.prop && v1.valLoc === v2.valLoc && v1.valType === v2.valType);
+    }
+    addRequireHint(h) {
+        mapArrayAddNoDuplicates(h.loc, h, this.requires, (v1, v2) => v1.str === v2.str);
+    }
+    addEvalHint(h) {
+        mapArrayAddNoDuplicates(h.loc, h, this.evals, (v1, v2) => v1.str === v2.str);
+    }
+    add(newHints) {
+        const moduleReindex = new Map();
+        for (const [i, s] of newHints.modules.entries())
+            moduleReindex.set(i, this.addModule(s));
+        const convert = (loc) => `${moduleReindex.get(parseInt(loc))}${loc.substring(loc.indexOf(":"))}`;
+        for (const f of newHints.functions)
+            this.addFunction(convert(f));
+        for (const { loc, prop, valLoc, valType } of newHints.reads) {
+            this.addReadHint({
+                loc: convert(loc),
+                prop,
+                valLoc: convert(valLoc),
+                valType
+            });
+        }
+        for (const { type, loc, baseLoc, baseType, prop, valLoc, valType } of newHints.writes) {
+            this.addWriteHint({
+                type,
+                loc: convert(loc),
+                baseLoc: convert(baseLoc),
+                baseType,
+                prop,
+                valLoc: convert(valLoc),
+                valType
+            });
+        }
+        for (const { loc, str } of newHints.requires)
+            this.addRequireHint({
+                loc: convert(loc),
+                str
+            });
+        for (const { loc, str } of newHints.evals)
+            this.addEvalHint({
+                loc: convert(loc),
+                str
+            });
+    }
+    toJSON() {
+        return {
+            modules: this.modules,
+            functions: arrayFrom(this.functions),
+            reads: flattenValues(this.reads),
+            writes: flattenValues(this.writes),
+            requires: flattenValues(this.requires),
+            evals: flattenValues(this.evals)
+        };
+    }
+    clearHints() {
+        this.reads.clear();
+        this.writes.clear();
+        this.requires.clear();
+        this.evals.clear();
+    }
+}

package/repos/coana-tech/spar/runtime/dist/hooks.js

@@ -0,0 +1,172 @@
+// ESM module loader hooks for approximate interpretation.
+// Adapted from Jelly's src/approx/hooks.ts.
+// Code transformation is requested directly from the Rust parent process,
+// bypassing the main thread to avoid deadlocks.
+//
+// IPC: writes transform requests to the IPC FIFO (shared with main thread),
+// reads responses from the hooks FIFO (dedicated channel from Rust parent).
+import Module, { createRequire } from "module";
+import { extname } from "path";
+import { WHITELISTED } from "./sandbox.js";
+import { fileURLToPath } from "url";
+import { openSync, readFileSync, readSync, realpathSync, writeSync } from "fs";
+const PREFIX = "_J$";
+let port2;
+/** Basedir for filtering modules. */
+let resolvedBasedir = "";
+/** File descriptor for writing to the IPC FIFO (Node.js → Rust). */
+let ipcFd;
+/** File descriptor for reading from the hooks FIFO (Rust → hooks). */
+let hooksFd;
+const responseBuffer = Buffer.alloc(65536);
+let responseLeftover = "";
+/**
+ * Synchronous line read from the hooks response FIFO.
+ */
+function readLineSync() {
+    while (true) {
+        const nlIdx = responseLeftover.indexOf('\n');
+        if (nlIdx !== -1) {
+            const line = responseLeftover.substring(0, nlIdx);
+            responseLeftover = responseLeftover.substring(nlIdx + 1);
+            return line;
+        }
+        const bytesRead = readSync(hooksFd, responseBuffer);
+        if (bytesRead === 0)
+            throw new Error("hooks response FIFO closed unexpectedly");
+        responseLeftover += responseBuffer.toString("utf8", 0, bytesRead);
+    }
+}
+/**
+ * Sends a JSON message to the Rust parent via the IPC FIFO.
+ */
+function sendToParent(msg) {
+    const json = JSON.stringify(msg) + '\n';
+    writeSync(ipcFd, json);
+}
+/**
+ * Requests code transformation from the Rust parent process.
+ * Synchronous: sends request on IPC FIFO, reads response from hooks FIFO.
+ */
+function requestTransform(file, source) {
+    sendToParent({ transform: file, source, sourceType: "module", hooks: true });
+    const line = readLineSync();
+    const resp = JSON.parse(line);
+    return resp.transformed;
+}
+/**
+ * Instruments an ESM module by requesting transformation from the Rust parent.
+ */
+function transformModule(filename, code) {
+    let resolvedFilename = filename;
+    try {
+        resolvedFilename = realpathSync(filename);
+    }
+    catch { }
+    if (!resolvedFilename.startsWith(resolvedBasedir)) {
+        log("verbose", `Ignoring module outside basedir: ${filename}`);
+        return "";
+    }
+    log("info", `Loading module ${filename} (${Math.ceil(code.length / 1024)}KB)`);
+    log("verbose", `Instrumenting ${filename}`);
+    const transformed = requestTransform(filename, code);
+    // Send code size metadata back to the main thread
+    port2.postMessage({ type: "metadata", codeSize: code.length });
+    return transformed;
+}
+/**
+ * Module hooks initialization.
+ * (Registered in approx.ts.)
+ */
+export async function initialize({ opts, port2: p2, ipcFifoPath, hooksFifoPath }) {
+    port2 = p2;
+    const basedir = opts.basedir;
+    try {
+        resolvedBasedir = realpathSync(basedir);
+    }
+    catch {
+        resolvedBasedir = basedir;
+    }
+    ipcFd = openSync(ipcFifoPath, "w");
+    hooksFd = openSync(hooksFifoPath, "r");
+}
+/**
+ * Module resolve hook.
+ */
+export async function resolve(specifier, context, nextResolve) {
+    if (context.parentURL === `file://${import.meta.dirname}/approx.js`)
+        context.parentURL = undefined; // approx.js is entry
+    log("verbose", `Resolving ${specifier}${context.parentURL ? ` from ${context.parentURL}` : " (entry)"}`);
+    const str = specifier.startsWith("node:") ? specifier.substring(5) : specifier;
+    if (Module.isBuiltin(str) && !WHITELISTED.has(str))
+        return {
+            format: "commonjs",
+            url: `node:${str}`, // signals to load hook that this is a sandboxed builtin
+            shortCircuit: true
+        };
+    // Simplified: no TypeScript module resolution (unlike Jelly)
+    return nextResolve(str);
+}
+/**
+ * Module loading hook.
+ */
+export async function load(url, context, nextLoad) {
+    try {
+        const ext = extname(url);
+        if ([".ts", ".tsx", ".mts", ".cts", ".jsx"].includes(ext))
+            context.format = "module";
+        else if (ext === "" && url.startsWith("file://")) {
+            try {
+                const content = readFileSync(fileURLToPath(url), "utf8");
+                if (content.startsWith("#!"))
+                    context.format = "commonjs";
+            }
+            catch { }
+        }
+        const sandboxedBuiltin = url.startsWith("node:");
+        log("verbose", `Loading ${url} (ESM loader, format: ${sandboxedBuiltin ? "sandboxed builtin" : context.format})`);
+        const res = await nextLoad(url, context); // TODO: fails with ERR_UNSUPPORTED_ESM_URL_SCHEME on https and http
+        if (sandboxedBuiltin) {
+            const m = url.substring(5);
+            log("verbose", `Intercepting import "${m}"`);
+            res.source = `const m = globalThis.${PREFIX}builtin["${m}"];`;
+            for (const p of Object.getOwnPropertyNames(require(m)))
+                res.source += `module.exports["${p}"] = m["${p}"];`;
+            return res;
+        }
+        if (res.format === "builtin" || res.format === "commonjs" || res.format === "json")
+            return res;
+        if (res.format !== "module")
+            log("warn", `Ignoring ${url} (format: ${res.format})`);
+        else if (!url.startsWith("file://"))
+            log("error", `Error: Unsupported URL scheme ${url}`);
+        else if (!(res.source instanceof Uint8Array))
+            log("error", `Error: Unexpected source type for ${url}`);
+        else {
+            const filename = fileURLToPath(url);
+            const source = new TextDecoder().decode(res.source);
+            const transformed = transformModule(filename, source);
+            return {
+                format: "module",
+                shortCircuit: true,
+                source: transformed
+            };
+        }
+    }
+    catch (err) {
+        log("error", `Suppressed exception at module load: ${err instanceof Error ? err.stack : err}`);
+    }
+    return {
+        format: "commonjs",
+        shortCircuit: true,
+        source: `module.exports = ${PREFIX}proxy`
+    };
+}
+/**
+ * TTY doesn't work for hooks thread, so logging is done via the approximate interpretation thread.
+ * Note: the logging from this thread is asynchronous so the messages may be written delayed to the log!
+ */
+function log(level, str) {
+    port2.postMessage({ type: "log", level, str });
+}
+const require = createRequire(import.meta.url);

package/repos/coana-tech/spar/runtime/dist/logger.js

@@ -0,0 +1,66 @@
+// Logger that writes to stdout (matching Jelly).
+// IPC uses dedicated FIFOs, so stdout is free for logging.
+import { openSync, truncateSync, writeSync } from "fs";
+const LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    verbose: 3,
+    debug: 4,
+};
+const COLORS = {
+    error: "\x1b[31m", // red
+    warn: "\x1b[33m", // yellow
+    verbose: "\x1b[32m", // green
+    debug: "\x1b[36m", // cyan
+};
+const RESET = "\x1b[0m";
+const WHITE = "\x1b[97m";
+const BOLD = "\x1b[1m";
+const CLEAR = "\x1b[0K";
+// Save stdout before sandboxing patches it.
+const stdout = process.stdout;
+let useColors = stdout.isTTY ?? false;
+let currentLevel = LEVELS.info;
+let logFd;
+function shouldLog(level) {
+    return (LEVELS[level] ?? 0) <= currentLevel;
+}
+function log(level, msg) {
+    if (shouldLog(level)) {
+        if (logFd !== undefined) {
+            writeSync(logFd, `${msg}\n`);
+        }
+        else {
+            const color = useColors ? (COLORS[level] ?? "") : "";
+            const reset = color ? RESET : "";
+            stdout.write(`${color}${msg}${reset}\n`);
+        }
+    }
+}
+const logger = {
+    get level() { return Object.entries(LEVELS).find(([_, v]) => v === currentLevel)?.[0] ?? "info"; },
+    set level(l) { currentLevel = LEVELS[l] ?? LEVELS.info; },
+    error: (msg) => log("error", msg),
+    warn: (msg) => log("warn", msg),
+    warning: (msg) => log("warn", msg),
+    info: (msg) => log("info", msg),
+    verbose: (msg) => log("verbose", msg),
+    debug: (msg) => log("debug", msg),
+    isInfoEnabled: () => shouldLog("info"),
+    isVerboseEnabled: () => shouldLog("verbose"),
+    isDebugEnabled: () => shouldLog("debug"),
+};
+export default logger;
+export function logToFile(path) {
+    truncateSync(path, 0);
+    logFd = openSync(path, "w");
+    useColors = false;
+}
+function writeStdOut(s) {
+    stdout.write(WHITE + BOLD + s.substring(0, stdout.columns) + RESET + CLEAR + "\r");
+}
+export function writeStdOutIfActive(s) {
+    if (!logFd && useColors && currentLevel === LEVELS.info)
+        writeStdOut(s);
+}

package/repos/coana-tech/spar/runtime/dist/options.js

@@ -0,0 +1,10 @@
+// Options received from the parent Rust process via argv[2].
+export const options = {
+    basedir: "",
+    loglevel: "info",
+    logfile: undefined,
+    printProgress: false,
+};
+export function setOptions(opts) {
+    Object.assign(options, opts);
+}

package/repos/coana-tech/spar/runtime/dist/proxy.js

@@ -0,0 +1,119 @@
+// Proxy objects for untracked values during approximate interpretation.
+// Copied from Jelly's src/approx/proxy.ts.
+const handler = {
+    get(target, p, receiver) {
+        switch (p) {
+            case "length":
+                if (receiver === theArgumentsProxy)
+                    return 10; // number of mock arguments provided at forced execution of functions
+                else
+                    return 1; // value for other array lengths
+            case Symbol.toPrimitive:
+                return function (hint) {
+                    switch (hint) {
+                        case "number":
+                            return 0;
+                        case "string":
+                            return "";
+                        case "default":
+                            return "0"; // TODO: appropriate value?
+                    }
+                };
+            case Symbol.iterator:
+                return function () {
+                    let index = 0;
+                    return {
+                        next: () => {
+                            if (index++ < 3)
+                                return { value: theProxy, done: false };
+                            else
+                                return { value: undefined, done: true };
+                        }
+                    };
+                };
+            // TODO: other standard symbols that should be modeled? see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
+            default:
+                const desc = Object.getOwnPropertyDescriptor(target, p);
+                if (desc && !desc.configurable && !desc.writable) // non-writable, non-configurable properties must return target value
+                    return target[p];
+                return theProxy;
+        }
+    },
+    set() {
+        return false; // if returning true, some native functions get stuck in proxy loop
+    },
+    has() {
+        return true;
+    },
+    apply() {
+        return theProxy;
+    },
+    construct() {
+        return theProxy;
+    },
+    defineProperty() {
+        return false;
+    },
+    deleteProperty() {
+        return true;
+    },
+    getOwnPropertyDescriptor(target, property) {
+        if (property === "prototype")
+            return Object.getOwnPropertyDescriptor(target, property);
+        return {
+            configurable: true,
+            enumerable: true,
+            value: theProxy,
+            writable: true
+        };
+    },
+    isExtensible() {
+        return true;
+    },
+    setPrototypeOf() {
+        return false;
+    }
+};
+export const theProxy = new Proxy(function theProxy() { }, handler);
+export const theArgumentsProxy = new Proxy([], handler);
+export function makeBaseProxy(target) {
+    if (!target || !(typeof target === "object" || typeof target === "function"))
+        return theProxy;
+    return new Proxy(target, {
+        get(target, prop, receiver) {
+            if (prop in target)
+                return Reflect.get(target, prop, receiver);
+            else {
+                const desc = Object.getOwnPropertyDescriptor(target, prop);
+                if (desc && !desc.configurable && !desc.writable) // non-writable, non-configurable properties must return target value
+                    return target[prop];
+                return theProxy;
+            }
+        },
+        has(_target, _prop) {
+            return true;
+        }
+    });
+}
+export function isProxy(x) {
+    return x === theProxy || x === theArgumentsProxy;
+}
+export function stdlibProxy(obj) {
+    return new Proxy(obj, {
+        get: function (target, prop) {
+            const desc = Object.getOwnPropertyDescriptor(target, prop);
+            if (desc && !desc.configurable && !desc.writable) // non-writable, non-configurable properties must return target value
+                return target[prop];
+            if (typeof desc?.value === "function")
+                return theProxy;
+            return desc?.value;
+        }
+    });
+}
+export function makeModuleProxy(target) {
+    return new Proxy(target, {
+        get(target, prop, _receiver) {
+            return prop === "constructor" ? theProxy : target[prop];
+        }
+    });
+}

package/repos/coana-tech/spar/runtime/dist/sandbox.js

@@ -0,0 +1,84 @@
+// Sandboxes global builtins for approximate interpretation.
+// Adapted from Jelly's src/approx/sandbox.ts.
+import Module from "module";
+import { theProxy } from "./proxy.js";
+/** Prefix for special global variables. */
+const PREFIX = "_J$";
+/**
+ * Names of the special _J$* globals that should be frozen. */
+const SPECIALS = new Set(["start", "pw", "dpr", "alloc", "init", "method", "comp", "new", "enter", "catch", "loop", "eval", "cr", "freeze", "fun", "require", "this"]
+    .map(s => PREFIX + s));
+/**
+ * Standard library modules that are not mocked.
+ */
+export const WHITELISTED = new Set([
+    "events", "buffer", "assert", "assert/strict", "constants", "crypto",
+    "string_decoder", "util", "util/types", "path", "url", "tty", "sys"
+]);
+/**
+ * Sandboxes global builtins.
+ */
+export function patchGlobalBuiltins() {
+    const emptyFunction = function () { };
+    const invokeCallbackWithArgs = function (cb, ...args) { cb(...args); };
+    const invokeCallbackWithArgs2 = function (cb, _c, ...args) { cb(...args); };
+    // replace globals
+    const g = globalThis;
+    g.clearImmediate = g.clearInterval = g.clearTimeout = g.fetch = emptyFunction;
+    g.setImmediate = g.queueMicrotask = invokeCallbackWithArgs;
+    g.setInterval = g.setTimeout = invokeCallbackWithArgs2;
+    // replace process.*
+    const p = process;
+    p.on = p.send = p.chdir = p.exit = p.reallyExit = p.abort = p.dlopen = p.kill = p.openStdin = p.binding = p._linkedBinding = p.removeAllListeners = p.removeListener = p.off = theProxy;
+    p.nextTick = invokeCallbackWithArgs;
+    for (const prop of ["stdin", "stdout", "stderr"])
+        Object.defineProperty(p, prop, { value: theProxy });
+    // replace console.*
+    const c = console;
+    for (const p of Object.getOwnPropertyNames(Object.getPrototypeOf(console)))
+        if (typeof c[p] === "function")
+            c[p] = emptyFunction;
+    c._stdout = c._stderr = theProxy;
+    // replace Error.*, Atomics.*, Module.*
+    Error.captureStackTrace = emptyFunction; // TODO: Error (parser writes to Error.prepareStackTrace)
+    Atomics.wait = Atomics.waitAsync = theProxy;
+    Module.register = function () { };
+    // replace Module._load
+    const realLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+        const result = realLoad.call(this, request, parent, isMain);
+        const name = request.startsWith("node:") ? request.substring(5) : request;
+        if (Module.isBuiltin(name) && !WHITELISTED.has(name))
+            return globalThis[PREFIX + "builtin"]?.[name] ?? theProxy;
+        return result;
+    };
+    // define typical test framework functions
+    g.describe = g.it = g.before = g.beforeAll = g.beforeEach = g.after = g.afterAll = g.afterEach = g.test = g.define = emptyFunction;
+    g.describe.skip = emptyFunction;
+    g.expect = theProxy;
+    // TODO: assign theProxy to all undeclared variables?
+    g.Worker = theProxy;
+    // DOM specific interface
+    g.window = g.document = theProxy;
+    // freeze objects and properties
+    for (const x of [
+        Array, ArrayBuffer, BigInt, Boolean, DataView, Date, Error, AggregateError, EvalError, RangeError, ReferenceError,
+        SyntaxError, TypeError, URIError, Intl, Int8Array, Uint8Array, Uint16Array, Int16Array, Uint32Array, Int32Array,
+        Float32Array, Float64Array, Uint8ClampedArray, BigUint64Array, BigInt64Array, FinalizationRegistry, JSON, Map,
+        Math, Number, Object, Promise, Proxy, Reflect, RegExp, Set, String, Symbol, WeakMap, WeakRef, WeakSet
+    ]) {
+        Object.freeze(x);
+        if ("prototype" in x)
+            Object.freeze(x.prototype);
+    }
+    Object.freeze(Function);
+    for (const p of ["apply", "bind", "call"]) // must allow overwriting toString at functions
+        Object.defineProperty(Function.prototype, p, { configurable: false, writable: false });
+    for (const p of ["globalThis", "global", "Infinity", "NaN", "undefined", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", ...SPECIALS, "$log"])
+        Object.defineProperty(g, p, { configurable: false, writable: false });
+    Object.freeze(Module._extensions);
+    Object.freeze(Module);
+    Object.freeze(Module.prototype);
+    Object.freeze(process);
+    Object.freeze(console);
+}

package/repos/coana-tech/spar/runtime/dist/types.js

@@ -0,0 +1,3 @@
+// Type definitions for IPC messages and hint data structures.
+// Based on Jelly's typings/hints.ts and misc/util.ts.
+export {};