@hew-lang/sandbox-vm 0.6.0-rc7 → 0.6.1

package/dist/interpreter/v1/value-operations.js

@@ -1,5 +1,5 @@
-import { UNIT, cloneValue } from "../values.js";
-import { runtimeTag } from "./package.js";
+import { UNIT, cloneValue, compareUtf8 } from "../values.js";
+import { runtimeTag, } from "./package.js";
 import { ShimFault } from "./shims.js";
 const OFFSET = 0xcbf29ce484222325n;
 const PRIME = 0x100000001b3n;
@@ -20,6 +20,38 @@ function bytesHash(bytes) {
         state = mix(state, BigInt(byte));
     return state;
 }
+function orderingResult(capability, comparison) {
+    switch (capability) {
+        case "Less":
+            return boolean(comparison < 0);
+        case "LessEqual":
+            return boolean(comparison <= 0);
+        case "Greater":
+            return boolean(comparison > 0);
+        case "GreaterEqual":
+            return boolean(comparison >= 0);
+    }
+}
+function scalarOrdering(left, right, ty, capability) {
+    if (left.kind === "f64") {
+        if (right?.kind !== "f64" ||
+            Number.isNaN(left.value) ||
+            Number.isNaN(right.value))
+            return boolean(false);
+        return orderingResult(capability, left.value < right.value ? -1 : left.value > right.value ? 1 : 0);
+    }
+    if (!right || right.kind !== left.kind)
+        return boolean(false);
+    const signed = /^(?:i(?:8|16|32|64)|isize|duration)$/.test(ty);
+    const width = Number(ty.match(/^[iu](8|16|32|64)$/)?.[1] ?? 64);
+    const lhs = left.kind === "i64" && signed
+        ? BigInt.asIntN(width, left.value)
+        : bits(left, ty);
+    const rhs = right.kind === "i64" && signed
+        ? BigInt.asIntN(width, right.value)
+        : bits(right, ty);
+    return orderingResult(capability, lhs < rhs ? -1 : lhs > rhs ? 1 : 0);
+}
 function bits(value, ty) {
     switch (value.kind) {
         case "unit":
@@ -55,22 +87,35 @@ export function* selectedValue(pkg, id, args) {
     if (!left)
         throw new Error("selected value operation has no receiver");
     const hash = plan.capability === "Hash";
+    const equality = plan.capability === "Eq";
+    const ordering = plan.capability === "Less" ||
+        plan.capability === "LessEqual" ||
+        plan.capability === "Greater" ||
+        plan.capability === "GreaterEqual"
+        ? plan.capability
+        : undefined;
     if (plan.ty === "string") {
         if (left.kind !== "string")
             throw new Error("string capability has no string");
-        return hash
-            ? integer(bytesHash(new TextEncoder().encode(left.value)))
-            : boolean(right?.kind === "string" && left.value === right.value);
+        if (hash)
+            return integer(bytesHash(new TextEncoder().encode(left.value)));
+        if (right?.kind !== "string")
+            return boolean(false);
+        if (equality)
+            return boolean(left.value === right.value);
+        return orderingResult(ordering, compareUtf8(left.value, right.value));
     }
     if (plan.ty === "bytes") {
         if (left.kind !== "vector")
             throw new Error("bytes capability has no bytes");
         const bytes = left.items.map((value) => Number(bits(value, "u8")));
-        return hash
-            ? integer(bytesHash(bytes))
-            : boolean(right?.kind === "vector" &&
+        if (hash)
+            return integer(bytesHash(bytes));
+        if (equality)
+            return boolean(right?.kind === "vector" &&
                 bytes.length === right.items.length &&
                 bytes.every((value, i) => BigInt(value) === bits(right.items[i], "u8")));
+        throw new Error("bytes ordering is outside the checked capability domain");
     }
     const components = plan.components ?? [];
     let fields;
@@ -88,7 +133,11 @@ export function* selectedValue(pkg, id, args) {
     else if (left.kind === "enum") {
         if (hash)
             throw new Error("derived enum Hash is outside the checked capability domain");
-        if (right?.kind !== "enum" || left.tag !== right.tag)
+        if (right?.kind !== "enum")
+            return boolean(false);
+        if (ordering && left.tag !== right.tag)
+            return orderingResult(ordering, left.tag < right.tag ? -1 : 1);
+        if (left.tag !== right.tag)
             return boolean(false);
         fields = left.payload;
         others = right.payload;
@@ -104,13 +153,40 @@ export function* selectedValue(pkg, id, args) {
         selections = fields.map(() => components[0]);
     }
     else {
-        return hash
-            ? integer(bits(left, plan.ty))
-            : boolean(!!right && bits(left, plan.ty) === bits(right, plan.ty));
+        if (hash)
+            return integer(bits(left, plan.ty));
+        if (equality)
+            return boolean(!!right && bits(left, plan.ty) === bits(right, plan.ty));
+        return scalarOrdering(left, right, plan.ty, ordering);
     }
     let state = OFFSET;
     for (const [at, field] of fields.entries()) {
-        const result = yield* selectedValue(pkg, selections[at], hash ? [field] : [field, others[at]]);
+        const selection = selections[at];
+        if (!selection)
+            throw new Error("derived value operation lacks a component selection");
+        if (ordering) {
+            const selected = selection.ordering;
+            if (!selected)
+                throw new Error("derived ordering lacks exact component predicates");
+            const pair = [field, others[at]];
+            const less = yield* selectedValue(pkg, selected.less, pair);
+            if (less.kind !== "bool")
+                throw new Error("Less returned a non-boolean value");
+            if (less.value)
+                return boolean(ordering === "Less" || ordering === "LessEqual");
+            const greater = yield* selectedValue(pkg, selected.greater, pair);
+            if (greater.kind !== "bool")
+                throw new Error("Greater returned a non-boolean value");
+            if (greater.value)
+                return boolean(ordering === "Greater" || ordering === "GreaterEqual");
+            const comparable = yield* selectedValue(pkg, selected.less_equal, pair);
+            if (comparable.kind !== "bool")
+                throw new Error("LessEqual returned a non-boolean value");
+            if (!comparable.value)
+                return boolean(false);
+            continue;
+        }
+        const result = yield* selectedValue(pkg, selection.selected, hash ? [field] : [field, others[at]]);
         if (hash) {
             if (result.kind !== "i64")
                 throw new Error("Hash returned a non-integer value");
@@ -123,7 +199,11 @@ export function* selectedValue(pkg, id, args) {
                 return boolean(false);
         }
     }
-    return hash ? integer(state) : boolean(true);
+    if (hash)
+        return integer(state);
+    if (equality)
+        return boolean(true);
+    return boolean(ordering === "LessEqual" || ordering === "GreaterEqual");
 }
 function ordered(entries) {
     return new Map([...entries].sort(([a], [b]) => Number(a) - Number(b)));

package/dist/interpreter/values.d.ts

@@ -102,10 +102,15 @@ export type VmValue = {
  *  owned by the closure, so `cloneValue` clones it. */
  | {
     kind: "closure";
-    body: number;
+    entries: ReadonlyArray<{
+        body: number;
+        specialization: number | null;
+    }>;
+    specialization: number | null;
     environment: VmValue;
 };
 export declare const UNIT: VmValue;
+export declare function compareUtf8(a: string, b: string): number;
 export declare function cloneValue(value: VmValue): VmValue;
 export declare function valueFromLiteral(value: JsonValue): VmValue;
 export declare function renderF64(value: number): string;

package/dist/interpreter/values.js

@@ -1,4 +1,17 @@
 export const UNIT = { kind: "unit" };
+const UTF8_ENCODER = new TextEncoder();
+export function compareUtf8(a, b) {
+    const left = UTF8_ENCODER.encode(a);
+    const right = UTF8_ENCODER.encode(b);
+    const length = Math.min(left.length, right.length);
+    for (let i = 0; i < length; i++) {
+        if (left[i] < right[i])
+            return -1;
+        if (left[i] > right[i])
+            return 1;
+    }
+    return left.length < right.length ? -1 : left.length > right.length ? 1 : 0;
+}
 const I64_LITERAL_DECIMAL = /^(?:0|-?[1-9]\d*)$/;
 export function cloneValue(value) {
     switch (value.kind) {
@@ -61,7 +74,8 @@ export function cloneValue(value) {
         case "closure":
             return {
                 kind: "closure",
-                body: value.body,
+                entries: value.entries,
+                specialization: value.specialization,
                 environment: cloneValue(value.environment),
             };
         case "map":
@@ -226,7 +240,7 @@ export function renderStdout(value) {
         case "function":
             return value.id;
         case "closure":
-            return `closure:${value.body}`;
+            return `closure:${value.entries.find((entry) => entry.specialization === value.specialization)?.body ?? "generic"}`;
     }
 }
 export function toJsonValue(value) {
@@ -274,7 +288,7 @@ export function toJsonValue(value) {
         case "function":
             return value.id;
         case "closure":
-            return `closure:${value.body}`;
+            return `closure:${value.entries.find((entry) => entry.specialization === value.specialization)?.body ?? "generic"}`;
     }
 }
 /// A map renders as its entries in insertion order, each a `[key, value]` pair.

package/dist/interpreter/worker.js

@@ -12,14 +12,32 @@ worker.addEventListener("message", (event) => {
             return;
         }
         const { bytecode, options } = event.data;
-        const trace = runBytecode(bytecode, options);
-        worker.postMessage({ id, ok: true, trace, playground: buildPlaygroundState(trace) });
+        const trace = runBytecode(bytecode, {
+            ...options,
+            codecBridge: globalThis.__hewSandboxExecuteCodec,
+        });
+        worker.postMessage({
+            id,
+            ok: true,
+            trace,
+            playground: buildPlaygroundState(trace),
+        });
     }
     catch (error) {
         if (error instanceof BytecodeValidationError) {
-            worker.postMessage({ id, ok: false, error: "bytecode_validation", diagnostics: error.errors });
+            worker.postMessage({
+                id,
+                ok: false,
+                error: "bytecode_validation",
+                diagnostics: error.errors,
+            });
             return;
         }
-        worker.postMessage({ id, ok: false, error: "interpreter_error", message: String(error) });
+        worker.postMessage({
+            id,
+            ok: false,
+            error: "interpreter_error",
+            message: String(error),
+        });
     }
 });

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hew-lang/sandbox-vm",
-  "version": "0.6.0-rc7",
+  "version": "0.6.1",
   "hewSource": {
-    "commit": "f09d3403587d1cf1bc33d00444bc76ae96861c17",
-    "tag": "v0.6.0-rc7",
+    "commit": "6a446f773391f45d2c0ce0a799240b8b9afef54e",
+    "tag": "v0.6.1",
     "dirty": false
   },
   "description": "Deterministic TypeScript interpreter for the Hew educational sandbox",
@@ -17,8 +17,12 @@
     }
   },
   "files": [
-    "dist/"
+    "dist/",
+    "cli/"
   ],
+  "dependencies": {
+    "@hew-lang/wasm": "0.6.1"
+  },
   "keywords": [
     "hew",
     "sandbox",