@hew-lang/sandbox-vm 0.6.0 → 0.6.1

package/dist/interpreter/run-program.js

@@ -59,6 +59,7 @@ var SandboxExitCode;
     SandboxExitCode[SandboxExitCode["ExhaustivenessFallthrough"] = 208] = "ExhaustivenessFallthrough";
 })(SandboxExitCode || (SandboxExitCode = {}));
 const TRAP_EXIT_CODES = {
+    actor_refused: SandboxExitCode.InternalError,
     integer_overflow: SandboxExitCode.IntegerOverflow,
     shift_out_of_range: SandboxExitCode.ShiftOutOfRange,
     divide_by_zero: SandboxExitCode.DivideByZero,

package/dist/interpreter/types.d.ts

@@ -2,7 +2,7 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;
 };
 export type SandboxBytecodePackage = import("./v1/package.js").PackageV1;
-export type TrapKind = "integer_overflow" | "shift_out_of_range" | "divide_by_zero" | "invalid_local" | "invalid_block" | "invalid_call" | "invalid_enum_tag" | "invalid_record_field" | "vector_bounds" | "string_bounds" | "regex_compile" | "capability_missing" | "budget_exhausted" | "panic" | "unsupported_instruction" | "internal_error";
+export type TrapKind = "actor_refused" | "integer_overflow" | "shift_out_of_range" | "divide_by_zero" | "invalid_local" | "invalid_block" | "invalid_call" | "invalid_enum_tag" | "invalid_record_field" | "vector_bounds" | "string_bounds" | "regex_compile" | "capability_missing" | "budget_exhausted" | "panic" | "unsupported_instruction" | "internal_error";
 export type RuntimeStatus = "ok" | "compile_error" | "sandbox_rejected" | "runtime_failure" | "budget_exhausted" | "panic" | "trap";
 export interface RuntimeFailure {
     kind: "panic" | "trap" | "budget_exhausted" | "unsupported" | "internal_error";

package/dist/interpreter/v1/exec.js

@@ -98,6 +98,7 @@ class ExecutorV1 {
     generators = new Map();
     tasks = new Map();
     completedTasks = 0;
+    actorIdentity = 0n;
     faultDebts = new Set();
     nextFaultDebt = 0;
     closingResources = new WeakSet();
@@ -550,7 +551,8 @@ class ExecutorV1 {
                 const shape = this.closureAt(op.closure);
                 this.define(act, op.dst, {
                     kind: "closure",
-                    body: shape.body,
+                    entries: shape.entries,
+                    specialization: null,
                     environment: {
                         kind: "record",
                         typeId: "",
@@ -559,12 +561,23 @@ class ExecutorV1 {
                 });
                 return;
             }
-            case "callable.coerce":
-                // A coercion only weakens the callable's proved capabilities; SIR
-                // refuses one that changes an argument, a result or a capture shape,
-                // so the value itself is unchanged.
-                this.define(act, op.dst, this.read(act, op.source));
+            case "callable.coerce": {
+                const callable = this.read(act, op.source);
+                if (op.specialization === null) {
+                    this.define(act, op.dst, callable);
+                }
+                else {
+                    if (callable.kind !== "closure" ||
+                        !callable.entries.some((entry) => entry.specialization === op.specialization)) {
+                        throw new Error("callable specialization has no checked invocation entry");
+                    }
+                    this.define(act, op.dst, {
+                        ...callable,
+                        specialization: op.specialization,
+                    });
+                }
                 return;
+            }
             case "dyn.make":
                 this.define(act, op.dst, {
                     kind: "dyn",
@@ -595,6 +608,9 @@ class ExecutorV1 {
                     const duration = this.read(act, op.duration);
                     if (duration.kind !== "i64")
                         throw new Error("scope duration is not a duration");
+                    group.expiresAt =
+                        this.trace.virtualTimeMs +
+                            Math.max(0, Number(duration.value) / 1_000_000);
                     group.cancelTimer = this.scheduler.after(duration.value, () => {
                         group.deadline = {
                             kind: "panic",
@@ -636,6 +652,7 @@ class ExecutorV1 {
                 const context = {
                     id,
                     actor: act.context.actor,
+                    requestDeadline: this.requestDeadline(act),
                     returned: (value) => this.closeValueAsync(value, null, (fault) => this.finishGenerator(generator, fault)),
                     failed: (fault) => this.finishGenerator(generator, fault),
                 };
@@ -791,6 +808,7 @@ class ExecutorV1 {
                 const context = {
                     id: task.id,
                     actor: act.context.actor,
+                    requestDeadline: this.requestDeadline(act),
                     returned: (value) => settle(value, null),
                     failed: (fault) => settle(UNIT, fault),
                 };
@@ -920,7 +938,7 @@ class ExecutorV1 {
                 // `self`. A plain function value carries none.
                 const callee = this.boundary(act, term.callee);
                 const args = term.args.map((operand) => this.boundary(act, operand));
-                this.current = this.activate(this.functionAt(calleeFunction(callee)), callee.kind === "closure" ? [callee.environment, ...args] : args, act, term.result, term.normal, term.unwind);
+                this.current = this.activate(this.functionAt(calleeFunction(callee, term.specialization)), callee.kind === "closure" ? [callee.environment, ...args] : args, act, term.result, term.normal, term.unwind);
                 return;
             }
             case "actor.call":
@@ -928,6 +946,38 @@ class ExecutorV1 {
                 return;
             case "runtime.call": {
                 const entry = this.pkg.runtime_families[term.family];
+                if (entry?.family === "ActorCaller") {
+                    const caller = act.context.caller ?? { kind: "Task" };
+                    const payload = [];
+                    if (caller.kind === "Actor") {
+                        const shape = this.pkg.variants[term.result_shape];
+                        const tag = runtimeTag(shape, "CallerActor");
+                        payload.push({
+                            kind: "record",
+                            typeId: shape.cases[tag].fields[0],
+                            fields: [{ kind: "i64", value: caller.identity }],
+                        });
+                    }
+                    this.completeShim(act, term, this.variant(term.result_shape, caller.kind === "Actor"
+                        ? "CallerActor"
+                        : caller.kind === "Timer"
+                            ? "CallerTimer"
+                            : "CallerTask", payload));
+                    return;
+                }
+                if (entry?.family === "ActorRefusalLog") {
+                    const [message, handler, reason] = term.args.map((argument) => this.boundary(act, argument));
+                    this.trace.snapshot("actor.delivery_refused", {
+                        actor_id: act.context.actor?.id ?? null,
+                        handler: toJsonValue(handler),
+                        message: toJsonValue(message),
+                        reason: toJsonValue(reason),
+                    });
+                    if (!act.context.reply)
+                        this.trace.writeStderr(`WARN actor.delivery_refused actor=${act.context.actor?.identity ?? 0n} handler=${asString(handler)} reason=${JSON.stringify(asString(reason))}\n`, null);
+                    this.completeShim(act, term, UNIT);
+                    return;
+                }
                 if (entry &&
                     (entry.family === "Map" ||
                         entry.family === "Set" ||
@@ -1866,6 +1916,9 @@ class ExecutorV1 {
     actorCall(act, term) {
         const args = term.args.map((arg) => this.boundary(act, arg));
         const operation = term.operation;
+        const caller = act.context.actor
+            ? { kind: "Actor", identity: act.context.actor.identity }
+            : { kind: "Task" };
         switch (operation.op) {
             case "spawn": {
                 const layout = this.pkg.actors?.find((actor) => actor.id === operation.actor);
@@ -1873,6 +1926,7 @@ class ExecutorV1 {
                     throw new Error(`actor layout ${operation.actor} is missing`);
                 let supplied = 0;
                 const actor = {
+                    identity: ++this.actorIdentity,
                     id: this.ids.actor(),
                     layout,
                     state: {
@@ -1956,6 +2010,7 @@ class ExecutorV1 {
                         if (!handler)
                             throw new Error("stream request has no producer handler");
                         actor.mailbox.push({
+                            caller,
                             handler,
                             payload: fields,
                             reply: false,
@@ -2076,6 +2131,7 @@ class ExecutorV1 {
                             const superseded = actor.mailbox[queued];
                             actor.mailbox[queued] = {
                                 ...superseded,
+                                caller,
                                 payload: payload.fields,
                             };
                             discardAtReceiver({ kind: "record", typeId: "", fields: superseded.payload }, accepted(false));
@@ -2095,6 +2151,7 @@ class ExecutorV1 {
                     if (oldest >= 0) {
                         const [evicted] = actor.mailbox.splice(oldest, 1);
                         actor.mailbox.push({
+                            caller,
                             handler,
                             payload: payload.fields,
                             reply: false,
@@ -2124,6 +2181,7 @@ class ExecutorV1 {
                         return;
                     }
                     actor.mailbox.push({
+                        caller,
                         handler,
                         payload: payload.fields,
                         reply: false,
@@ -2312,15 +2370,32 @@ class ExecutorV1 {
                 throw new Error(`actor operation ${operation.op} has no executor`);
         }
     }
+    requestDeadline(act) {
+        let deadline = act.context.requestDeadline;
+        for (let frame = act; frame; frame = frame.caller) {
+            for (const group of frame.scopes.values()) {
+                if (group.expiresAt !== undefined)
+                    deadline = Math.min(deadline ?? Infinity, group.expiresAt);
+            }
+        }
+        return deadline;
+    }
     ask(protocol, inputs, complete, shapes) {
         let settled = false;
         let admitted = false;
         let closing = false;
         const owner = this.current.context.actor;
+        const deadline = this.requestDeadline(this.current);
+        let cancelTimer;
+        let message;
+        const caller = owner
+            ? { kind: "Actor", identity: owner.identity }
+            : { kind: "Task" };
         let receiver = null;
         const finish = (value, error, drained) => {
             const alreadySettled = settled;
             settled = true;
+            cancelTimer?.();
             if (alreadySettled || complete(value, error) === false) {
                 // The finishing receiver still owns a reply that its caller no
                 // longer accepts. Its next turn must wait for this release.
@@ -2364,12 +2439,17 @@ class ExecutorV1 {
                 if (settled)
                     return;
                 settled = true;
+                cancelTimer?.();
                 complete(null, reason, fault);
             });
         };
         const attempt = () => {
             if (settled || closing)
                 return;
+            if (deadline !== undefined && deadline <= this.trace.virtualTimeMs) {
+                reject("TimedOut");
+                return;
+            }
             const role = "id" in target ? this.roles.get(target.id) : undefined;
             if (role && this.rolePending(role)) {
                 role.waiting.push(attempt);
@@ -2422,23 +2502,50 @@ class ExecutorV1 {
             }
             admitted = true;
             receiver = actor;
-            actor.mailbox.push({
+            message = {
+                caller,
                 handler,
                 payload,
                 complete: finish,
                 reply: true,
                 obligated: true,
-            });
+                requestDeadline: deadline,
+            };
+            actor.mailbox.push(message);
             this.trace.snapshot("actor.ask", {
                 actor_id: actor.id,
                 handler: handler.name,
             });
             this.dispatchActor(actor);
         };
+        const withdrawQueued = () => {
+            if (!message || !receiver)
+                return;
+            const index = receiver.mailbox.indexOf(message);
+            if (index < 0)
+                return;
+            receiver.mailbox.splice(index, 1);
+            admitted = false;
+            for (const admit of receiver.admission.splice(0))
+                admit();
+        };
+        if (deadline !== undefined) {
+            cancelTimer = this.scheduler.after(BigInt(Math.max(0, Math.round((deadline - this.trace.virtualTimeMs) * 1_000_000))), () => {
+                if (settled || closing)
+                    return;
+                withdrawQueued();
+                if (admitted)
+                    finish(null, "TimedOut");
+                else
+                    reject("TimedOut");
+            });
+        }
         attempt();
         return (done) => {
             const wasSettled = settled;
             settled = true;
+            cancelTimer?.();
+            withdrawQueued();
             if (admitted || (wasSettled && !closing))
                 done(null);
             else
@@ -2489,6 +2596,18 @@ class ExecutorV1 {
             }
             for (const admit of actor.admission.splice(0))
                 admit();
+            if (message.requestDeadline !== undefined &&
+                message.requestDeadline <= this.trace.virtualTimeMs) {
+                this.closeValueAsync({ kind: "record", typeId: "", fields: message.payload }, null, (fault) => {
+                    message.complete(null, "TimedOut");
+                    actor.busy = false;
+                    if (fault)
+                        this.crashActor(actor, fault);
+                    else
+                        this.dispatchActor(actor);
+                }, actor);
+                return;
+            }
             this.trace.snapshot("actor.receive", {
                 actor_id: actor.id,
                 handler: message.handler.name,
@@ -2496,6 +2615,9 @@ class ExecutorV1 {
             const frame = this.activate(this.functionAt(message.handler.callable), [actor.state, ...message.payload], null, null, undefined, null, {
                 id: actor.id,
                 actor,
+                caller: message.caller,
+                requestDeadline: message.requestDeadline,
+                reply: message.reply,
                 returned: (value) => {
                     actor.active = null;
                     const drained = (fault) => {
@@ -2533,7 +2655,14 @@ class ExecutorV1 {
                 failed: (fault) => {
                     actor.active = null;
                     actor.busy = false;
-                    if (fault.kind === "panic" && fault.cancelled) {
+                    if (fault.kind === "trap" &&
+                        fault.trap === "actor_refused" &&
+                        !fault.secondary?.length) {
+                        actor.crashing = null;
+                        message.complete(null, "Refused");
+                        this.dispatchActor(actor);
+                    }
+                    else if (fault.kind === "panic" && fault.cancelled) {
                         message.complete(null, "Dead");
                         this.dispatchActor(actor);
                     }
@@ -2975,8 +3104,10 @@ function combineFaults(primary, secondary) {
     // Reports own an immutable ordered view of original diagnostics. Faults can
     // be shared by a parked unwind, actor completion and multiple observers;
     // combining those views must neither duplicate nor mutate their graph.
-    const retained = primary.kind === "panic" && primary.cancelled
-        ? diagnostics.filter((fault) => !(fault.kind === "panic" && fault.cancelled))
+    const control = (fault) => (fault.kind === "panic" && fault.cancelled) ||
+        (fault.kind === "trap" && fault.trap === "actor_refused");
+    const retained = control(primary)
+        ? diagnostics.filter((fault) => !control(fault))
         : diagnostics;
     const [first, ...rest] = retained.length ? retained : diagnostics;
     return { ...first, primary: first, secondary: rest };
@@ -2994,6 +3125,7 @@ function faultInfo(fault) {
         divide_by_zero: [202, "DivideByZero"],
         shift_out_of_range: [204, "ShiftOutOfRange"],
         vector_bounds: [205, "IndexOutOfBounds"],
+        actor_refused: [-4, "Refused"],
     }[fault.trap];
 }
 function faultReport(fault, secondary = false) {
@@ -3063,6 +3195,8 @@ function actorErrorRole(reason) {
             return "ActorErrorFailed";
         case "Trapped":
             return "ActorErrorTrapped";
+        case "Refused":
+            return "ActorErrorRefused";
         case "Dead":
             return "ActorErrorDead";
         case "TimedOut":
@@ -3105,12 +3239,17 @@ function sendErrorRole(reason) {
             throw new Error(`unknown send error reason ${reason}`);
     }
 }
-function calleeFunction(value) {
+function calleeFunction(value, specialization = null) {
     switch (value.kind) {
         case "function":
             return Number(value.id);
-        case "closure":
-            return value.body;
+        case "closure": {
+            const selected = specialization ?? value.specialization;
+            const entry = value.entries.find((candidate) => candidate.specialization === selected);
+            if (!entry)
+                throw new Error("callable has no selected concrete invocation entry");
+            return entry.body;
+        }
         default:
             throw new TypeError(`indirect.call expected a callable value, got ${value.kind}`);
     }
@@ -3187,6 +3326,8 @@ function trapMessage(trap) {
             return "shift amount out of range";
         case "vector_bounds":
             return "index out of bounds";
+        case "actor_refused":
+            return "delivery refused by interceptor";
     }
 }
 /// The operand type the package records. `isize` and `usize` are 64-bit in the

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

@@ -1,6 +1,6 @@
 export type Own = "none" | "owned" | "guaranteed";
 export type BoundaryDecision = "borrow" | "borrow_mut" | "copy" | "move" | "snapshot";
-export type TrapName = "integer_overflow" | "divide_by_zero" | "shift_out_of_range" | "vector_bounds";
+export type TrapName = "integer_overflow" | "divide_by_zero" | "shift_out_of_range" | "vector_bounds" | "actor_refused";
 export interface SpanV1 {
     start: number;
     end: number;
@@ -34,7 +34,7 @@ export interface VariantShape {
     cases: VariantCase[];
     runtime_tags?: Partial<Record<RuntimeVariantRole, number>>;
 }
-export type RuntimeVariantRole = "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
+export type RuntimeVariantRole = "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorRefused" | "CallerActor" | "CallerTask" | "CallerTimer" | "CallerNode" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
 export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;
 export interface RuntimeFamilyEntry {
     id: number;
@@ -93,7 +93,10 @@ export interface ValueComponentCapabilities {
 }
 export interface ClosureShape {
     id: number;
-    body: number;
+    entries: Array<{
+        body: number;
+        specialization: number | null;
+    }>;
     fields: number;
 }
 export interface VtableShape {
@@ -326,6 +329,7 @@ export type OpV1 = (OpBase & {
     op: "callable.coerce";
     dst: number;
     source: Operand;
+    specialization: number | null;
 }) | (OpBase & {
     op: "dyn.make";
     dst: number;
@@ -426,6 +430,7 @@ export type TermV1 = (TermBase & {
 }) | (TermBase & CallShape & {
     op: "indirect.call";
     callee: BoundaryOperand;
+    specialization: number | null;
 }) | (TermBase & CallShape & {
     op: "dyn.call";
     receiver: BoundaryOperand;

package/dist/interpreter/v1/shims.js

@@ -6,7 +6,7 @@
 /// reject list to keep in step with this one. `FileRead` is refused by its
 /// absence, and a `NativeIo` suspension by an operation missing from
 /// [`SUPPORTED_NATIVE_IO`].
-import { UNIT, cloneValue, renderStdout } from "../values.js";
+import { UNIT, cloneValue, compareUtf8, renderStdout, } from "../values.js";
 import { seededMt } from "./mt19937.js";
 /// A language-visible fault raised inside a shim. The executor routes it to the
 /// call's `unwind` edge, or ends the program when the call names none.
@@ -29,6 +29,8 @@ export function resolveRuntimeShim(entry) {
                     throw new Error("SupervisorPool requires its resumable executor");
                 }
                 : undefined;
+        case "ActorCaller":
+        case "ActorRefusalLog":
         case "StructuralFormat":
             return () => {
                 throw new Error("StructuralFormat requires its resumable executor");
@@ -60,7 +62,11 @@ export function resolveRuntimeShim(entry) {
                 ? () => {
                     throw new Error("array mutation requires its resumable executor");
                 }
-                : undefined;
+                : entry.detail === "IndexBorrow"
+                    ? (_host, args) => sequenceElement(args)
+                    : ["Len", "Index"].includes(String(entry.detail))
+                        ? VECTOR_SHIMS[detailName(entry.detail)]
+                        : undefined;
         case "Map":
         case "Set":
             return [
@@ -162,6 +168,7 @@ const UNIT_FAMILY_SHIMS = {
     StringConcat: (_host, args) => str(`${text(args, 0)}${text(args, 1)}`),
     StringClone: (_host, args) => str(text(args, 0)),
     StringEquals: (_host, args) => bool(text(args, 0) === text(args, 1)),
+    StringCompare: (_host, args) => int(BigInt(compareUtf8(text(args, 0), text(args, 1)))),
     StringContains: (_host, args) => bool(text(args, 0).includes(text(args, 1))),
     StringTrim: (_host, args) => str(text(args, 0).replace(/^\p{White_Space}+|\p{White_Space}+$/gu, "")),
     // Native string length counts codepoints, not bytes.
@@ -316,14 +323,8 @@ const VECTOR_SHIMS = {
             ? host.enumValue(shape, "OptionSome", [cloneValue(items[at])])
             : host.enumValue(shape, "OptionNone", []);
     },
-    Index: (_host, args) => {
-        const items = vec(args, 0).items;
-        const at = index(args, 1);
-        if (at < 0 || at >= items.length) {
-            throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${items.length}`);
-        }
-        return cloneValue(items[at]);
-    },
+    Index: (_host, args) => cloneValue(sequenceElement(args)),
+    IndexBorrow: (_host, args) => sequenceElement(args),
     Len: (_host, args) => int(BigInt(vec(args, 0).items.length)),
     Slice: (_host, args) => {
         const items = vec(args, 0).items;
@@ -347,6 +348,14 @@ const VECTOR_SHIMS = {
         };
     },
 };
+function sequenceElement(args) {
+    const items = vec(args, 0).items;
+    const at = index(args, 1);
+    if (at < 0 || at >= items.length) {
+        throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${items.length}`);
+    }
+    return items[at];
+}
 function byteVector(items) {
     return { kind: "vector", elementType: "u8", items: items.map(cloneValue) };
 }

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

@@ -1,4 +1,4 @@
-import { UNIT, cloneValue } from "../values.js";
+import { UNIT, cloneValue, compareUtf8 } from "../values.js";
 import { runtimeTag, } from "./package.js";
 import { ShimFault } from "./shims.js";
 const OFFSET = 0xcbf29ce484222325n;
@@ -32,16 +32,6 @@ function orderingResult(capability, comparison) {
             return boolean(comparison >= 0);
     }
 }
-function compareBytes(left, right) {
-    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;
-}
 function scalarOrdering(left, right, ty, capability) {
     if (left.kind === "f64") {
         if (right?.kind !== "f64" ||
@@ -113,7 +103,7 @@ export function* selectedValue(pkg, id, args) {
             return boolean(false);
         if (equality)
             return boolean(left.value === right.value);
-        return orderingResult(ordering, compareBytes(new TextEncoder().encode(left.value), new TextEncoder().encode(right.value)));
+        return orderingResult(ordering, compareUtf8(left.value, right.value));
     }
     if (plan.ty === "bytes") {
         if (left.kind !== "vector")

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/package.json

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