@hew-lang/sandbox-vm 0.6.6 → 0.7.0

package/README.md

@@ -94,6 +94,11 @@ option. The Node test host loads that package automatically; in a source
 checkout, run `make wasm` to build `hew-wasm/pkg` first. An explicit
 `HEW_WASM_MODULE` module URL can select another build of the same package.
 
+JSON, TOML and YAML values use this same bridge for parsing and formatting.
+Their ordinary value operations execute in the VM, including independent copies,
+checked access, mutation and cleanup. The bridge preserves full-width JSON
+integers, YAML mapping keys and tags, and TOML datetimes using the native engines.
+
 UTC calendar operations also require the initialized `executeCalendar`
 export as `calendarBridge`. Both hosts use the shared Chrono calendar engine;
 the bridge preserves integer seconds and nanoseconds exactly.

package/dist/interpreter/parity-runner.js

@@ -50,9 +50,12 @@ try {
     let codecBridge;
     if (typeof bytecode === "object" &&
         bytecode !== null &&
-        "codecs" in bytecode &&
-        Array.isArray(bytecode.codecs) &&
-        bytecode.codecs.length) {
+        (("codecs" in bytecode &&
+            Array.isArray(bytecode.codecs) &&
+            bytecode.codecs.length) ||
+            ("runtime_families" in bytecode &&
+                Array.isArray(bytecode.runtime_families) &&
+                bytecode.runtime_families.some((entry) => entry?.family === "Encoding")))) {
         const local = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../hew-wasm/pkg/hew_wasm.js");
         const location = process.env.HEW_WASM_MODULE ?? pathToFileURL(local).href;
         const wasm = await import(location);

package/dist/interpreter/v1/encoding-values.d.ts

@@ -0,0 +1,8 @@
+import { type VmValue } from "../values.js";
+import type { EncodingOp, EncodingFormat } from "./instructions.generated.js";
+import type { ShimHost } from "./shims.js";
+/** Lossless positional bridge to each format's native Value. Null denotes an invalid
+ * handle; a live JSON or YAML null is ["null"]. Numeric text retains native kinds. */
+export type { EncodingFormat } from "./instructions.generated.js";
+export type EncodingNode = ["null"] | ["bool", boolean] | ["integer" | "float" | "string", string] | ["array", EncodingNode[]] | ["object", [string, EncodingNode][]] | ["mapping", [EncodingNode, EncodingNode][]] | ["tagged", string, EncodingNode] | ["datetime", string];
+export declare function executeEncoding(host: ShimHost, format: EncodingFormat, operation: EncodingOp, args: VmValue[]): VmValue;

package/dist/interpreter/v1/encoding-values.js

@@ -0,0 +1,215 @@
+import { cloneValue, compareUtf8, stringValue, UNIT, } from "../values.js";
+const owner = (format, value) => ({ kind: "encoding", format, value });
+const integer = (value) => ({
+    kind: "i64",
+    value: BigInt(value),
+});
+function checkedValue(arg, format) {
+    if (arg?.kind !== "encoding" || arg.format !== format)
+        throw new TypeError("encoding operation requires a matching format value");
+    return arg;
+}
+function text(arg) {
+    if (arg?.kind !== "string")
+        throw new TypeError("encoding operation requires a string");
+    return arg.value;
+}
+function number(arg) {
+    if (arg?.kind !== "i64")
+        throw new TypeError("encoding operation requires an integer");
+    return arg.value;
+}
+function equal(format, left, right) {
+    if (!left || !right || left[0] !== right[0])
+        return false;
+    switch (left[0]) {
+        case "null":
+            return true;
+        case "float":
+            return (float(left[1]) === float(right[1]) ||
+                (format === "Yaml" &&
+                    Number.isNaN(float(left[1])) &&
+                    Number.isNaN(float(right[1]))));
+        case "integer":
+            return BigInt(left[1]) === BigInt(right[1]);
+        case "datetime":
+        case "string":
+        case "bool":
+            return left[1] === right[1];
+        case "array": {
+            const items = right[1];
+            return (left[1].length === items.length &&
+                left[1].every((item, i) => equal(format, item, items[i])));
+        }
+        case "tagged":
+            return (left[1] === right[1] && equal(format, left[2], right[2]));
+        case "mapping": {
+            const entries = right[1];
+            return (left[1].length === entries.length &&
+                left[1].every(([key, child]) => {
+                    const entry = entries.find(([candidate]) => equal(format, key, candidate));
+                    return entry !== undefined && equal(format, child, entry[1]);
+                }));
+        }
+        case "object": {
+            const entries = new Map(right[1]);
+            return (left[1].length === entries.size &&
+                left[1].every(([key, child]) => equal(format, child, entries.get(key) ?? null)));
+        }
+    }
+}
+export function executeEncoding(host, format, operation, args) {
+    const owned = (node) => owner(format, node);
+    const value = (arg) => checkedValue(arg, format);
+    const copy = (node) => cloneValue(owned(node));
+    if (operation === "Parse" || operation === "Stringify") {
+        if (!host.codecBridge)
+            throw new Error("Encoding text operations require the hew-wasm executeCodec bridge");
+        const result = JSON.parse(host.codecBridge(JSON.stringify({
+            encoding_value: operation === "Parse"
+                ? { format, operation: "parse", text: text(args[0]) }
+                : { format, operation: "stringify", value: value(args[0]).value },
+        })));
+        if (result.failure)
+            throw new Error(result.failure);
+        host.encodingError(format, result.error ?? "");
+        return operation === "Parse"
+            ? owned(result.value ?? null)
+            : stringValue(result.text ?? "");
+    }
+    switch (operation) {
+        case "LastError":
+            return stringValue(host.encodingError(format));
+        case "ObjectNew":
+            return owned(format === "Yaml" ? ["mapping", []] : ["object", []]);
+        case "ArrayNew":
+            return owned(["array", []]);
+        case "FromNull":
+            return owned(["null"]);
+        case "FromString":
+            return owned(["string", text(args[0])]);
+        case "FromBool":
+            return owned(["bool", number(args[0]) !== 0n]);
+        case "FromInt":
+            return owned(["integer", BigInt.asIntN(64, number(args[0])).toString()]);
+        case "FromU64":
+            return owned(["integer", BigInt.asUintN(64, number(args[0])).toString()]);
+        case "FromFloat": {
+            const arg = args[0];
+            if (arg?.kind !== "f64")
+                throw new TypeError("encoding operation requires a float");
+            return owned(format !== "Json" || Number.isFinite(arg.value)
+                ? ["float", Object.is(arg.value, -0) ? "-0" : String(arg.value)]
+                : null);
+        }
+        case "Eq":
+            return integer(equal(format, value(args[0]).value, value(args[1]).value) ? 1 : 0);
+        case "Clone":
+            return copy(value(args[0]).value);
+        case "Free":
+            value(args[0]).value = null;
+            return UNIT;
+        default:
+            break;
+    }
+    const receiver = value(args[0]), node = receiver.value;
+    let scalar = node;
+    while (scalar?.[0] === "tagged")
+        scalar = scalar[2];
+    switch (operation) {
+        case "Type":
+            return integer(node?.[0] === "tagged" || node?.[0] === "datetime"
+                ? 7
+                : node?.[0] === "mapping"
+                    ? 6
+                    : node
+                        ? [
+                            "null",
+                            "bool",
+                            "integer",
+                            "float",
+                            "string",
+                            "array",
+                            "object",
+                        ].indexOf(node[0])
+                        : -1);
+        case "IntStatus":
+            return integer(node?.[0] === "integer"
+                ? BigInt(node[1]) <= (1n << 63n) - 1n
+                    ? 1
+                    : 0
+                : -1);
+        case "GetBool":
+            return integer(scalar?.[0] === "bool" && scalar[1] ? 1 : 0);
+        case "GetInt":
+            return integer(scalar?.[0] === "integer" && BigInt(scalar[1]) <= (1n << 63n) - 1n
+                ? BigInt(scalar[1])
+                : 0);
+        case "GetU64":
+            return integer(node?.[0] === "integer" && BigInt(node[1]) >= 0 ? BigInt(node[1]) : 0);
+        case "GetFloat":
+            return {
+                kind: "f64",
+                value: scalar?.[0] === "float" || scalar?.[0] === "integer"
+                    ? float(scalar[1])
+                    : 0,
+            };
+        case "GetString":
+            return stringValue(scalar?.[0] === "string" ? scalar[1] : "");
+        case "ArrayLen":
+            return integer(node?.[0] === "array" ? node[1].length : -1);
+        case "GetDatetime":
+            return stringValue(node?.[0] === "datetime" ? node[1] : "");
+        case "GetField":
+            return copy(node?.[0] === "object"
+                ? (node[1].find(([key]) => key === text(args[1]))?.[1] ?? null)
+                : node?.[0] === "mapping"
+                    ? (node[1].find(([key]) => key[0] === "string" && key[1] === text(args[1]))?.[1] ?? null)
+                    : null);
+        case "ArrayGet":
+            return copy(node?.[0] === "array"
+                ? (node[1][Number(BigInt.asIntN(32, number(args[1])))] ?? null)
+                : null);
+        case "ObjectKeys":
+            return owned(node?.[0] === "object"
+                ? ["array", node[1].map(([key]) => ["string", key])]
+                : node?.[0] === "mapping"
+                    ? ["array", node[1].map(([key]) => structuredClone(key))]
+                    : null);
+        case "ObjectSet": {
+            const child = value(args[2]), key = text(args[1]);
+            if (node?.[0] === "object" && child.value) {
+                const index = node[1].findIndex(([name]) => name === key);
+                if (index < 0) {
+                    node[1].push([key, child.value]);
+                    node[1].sort(([a], [b]) => compareUtf8(a, b));
+                }
+                else
+                    node[1][index] = [key, child.value];
+            }
+            if (node?.[0] === "mapping" && child.value) {
+                const index = node[1].findIndex(([name]) => name[0] === "string" && name[1] === key);
+                if (index < 0)
+                    node[1].push([["string", key], child.value]);
+                else
+                    node[1][index] = [["string", key], child.value];
+            }
+            child.value = null;
+            return receiver;
+        }
+        case "ArrayPush": {
+            const child = value(args[1]);
+            if (node?.[0] === "array" && child.value)
+                node[1].push(child.value);
+            child.value = null;
+            return receiver;
+        }
+    }
+}
+function float(text) {
+    return text === "inf" || text === "Infinity"
+        ? Infinity
+        : text === "-inf" || text === "-Infinity"
+            ? -Infinity
+            : Number(text);
+}

package/dist/interpreter/v1/exec.js

@@ -102,6 +102,7 @@ class ExecutorV1 {
     trace;
     stdin;
     options;
+    encodingErrors = {};
     current;
     host;
     scheduler;
@@ -140,6 +141,16 @@ class ExecutorV1 {
             argv: [...(options.argv ?? ["main.hew"])],
             unixTimeMillis: () => this.trace.virtualTimeMs,
             calendarBridge: options.calendarBridge,
+            codecBridge: options.codecBridge,
+            encodingError: (format, message) => {
+                const actor = this.current.context.actor;
+                const errors = actor
+                    ? (actor.encodingErrors ??= {})
+                    : this.encodingErrors;
+                if (message !== undefined)
+                    errors[format] = message;
+                return errors[format] ?? "";
+            },
             fileError: (operation) => {
                 const error = this.current.context.fileError;
                 switch (operation) {
@@ -2446,6 +2457,9 @@ class ExecutorV1 {
             while (pending.length) {
                 const value = pending.pop();
                 switch (value.kind) {
+                    case "encoding":
+                        value.value = null;
+                        break;
                     case "string":
                         value.release();
                         break;
@@ -2578,6 +2592,8 @@ class ExecutorV1 {
         this.directories.call(release.operation, [value]);
     }
     closeValue(value, fault) {
+        if (value.kind === "encoding")
+            value.value = null;
         if (value.kind === "host_resource")
             this.closeHostResource(value);
         if (value.kind === "string")

package/dist/interpreter/v1/shims.d.ts

@@ -1,4 +1,5 @@
 import { type DirectoryOperation } from "./browser-directory.js";
+import { type EncodingFormat } from "./encoding-values.js";
 import type { Pipes } from "./pipes.js";
 import { type VmValue } from "../values.js";
 import { Mt19937 } from "./mt19937.js";
@@ -12,6 +13,8 @@ export interface ShimHost {
     unixTimeMillis(): number;
     fileError(operation: "HasError" | "LastErrorKind" | "LastErrno" | "LastError"): VmValue;
     calendarBridge?: (request: string) => string;
+    codecBridge?: (request: string) => string;
+    encodingError?(format: EncodingFormat, message?: string): string;
     pipes?: Pipes;
     newPipe?(capacity: number): VmValue;
     generatorStream?(generator: VmValue): VmValue;

package/dist/interpreter/v1/shims.js

@@ -1,5 +1,6 @@
 import { DIRECTORY_OPERATIONS, } from "./browser-directory.js";
 import { executeCalendar } from "./calendar.js";
+import { executeEncoding } from "./encoding-values.js";
 import { charProperty, charCase } from "../unicode.js";
 /// Runtime implementations and their host execution registration. Admission and
 /// execution consume the same ordinary, resumable or refused disposition.
@@ -79,6 +80,18 @@ export function resolveRuntime(entry) {
         case "VecSliceRange":
             return refused(`${entry.family}::${entry.detail}`);
         case "Encoding":
+            return (entry.detail.op === "GetDatetime"
+                ? entry.detail.format === "Toml"
+                : entry.detail.format !== "Toml" ||
+                    !["GetU64", "IntStatus", "FromU64", "FromNull"].includes(entry.detail.op))
+                ? {
+                    kind: "ordinary",
+                    shim: (host, args) => executeEncoding(host, entry.detail.format, entry.detail.op, args),
+                    ...(entry.detail.op === "Parse" || entry.detail.op === "Stringify"
+                        ? { bridge: "codecBridge" }
+                        : {}),
+                }
+                : refused(`Encoding::${entry.detail.format}`);
         case "VecScalar":
             return refused(entry.family);
         case "Vector":

package/dist/interpreter/values.d.ts

@@ -1,5 +1,6 @@
 import type { JsonValue } from "./types.js";
 import { IndexedString } from "./strings.js";
+import type { EncodingNode, EncodingFormat } from "./v1/encoding-values.js";
 export { stringValue } from "./strings.js";
 /** One creator-owned membership list; payload destruction uses the ordinary VM release path. */
 export interface RcOwner {
@@ -15,6 +16,10 @@ export interface RcCell {
     typeName: string;
 }
 export type VmValue = {
+    kind: "encoding";
+    format: EncodingFormat;
+    value: EncodingNode | null;
+} | {
     kind: "rc";
     cell: RcCell | null;
     closed: boolean;

package/dist/interpreter/values.js

@@ -17,6 +17,8 @@ export function compareUtf8(a, b) {
 const I64_LITERAL_DECIMAL = /^(?:0|-?[1-9]\d*)$/;
 export function cloneValue(value) {
     switch (value.kind) {
+        case "encoding":
+            return { ...value, value: structuredClone(value.value) };
         case "rc":
             if (value.closed)
                 throw new Error("cannot copy a released Rc");
@@ -206,6 +208,8 @@ export function renderF64(value) {
 }
 export function renderStdout(value) {
     switch (value.kind) {
+        case "encoding":
+            return JSON.stringify(value.value);
         case "host_resource":
             return "FilesystemOwner";
         case "timer":
@@ -265,6 +269,8 @@ export function renderStdout(value) {
 }
 export function toJsonValue(value) {
     switch (value.kind) {
+        case "encoding":
+            return value.value;
         case "host_resource":
             return "FilesystemOwner";
         case "timer":

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hew-lang/sandbox-vm",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "hewSource": {
-    "commit": "e0b661d972fa8f97f46df73065a5e10d01900821",
-    "tag": "v0.6.6",
+    "commit": "89cb17bde678afd8b1cdbd791be97a0df393e882",
+    "tag": "v0.7.0",
     "dirty": false
   },
   "description": "Deterministic TypeScript interpreter for the Hew educational sandbox",
@@ -21,7 +21,7 @@
     "cli/"
   ],
   "dependencies": {
-    "@hew-lang/wasm": "0.6.6"
+    "@hew-lang/wasm": "0.7.0"
   },
   "keywords": [
     "hew",