@hew-lang/sandbox-vm 0.6.1 → 0.6.3

package/dist/interpreter/v1/value-operations.d.ts

@@ -1,6 +1,10 @@
-import { type VmValue } from "../values.js";
+import type { RuntimeContinuation } from "./shims.js";
+import { type VmValue, type RcOwner } from "../values.js";
 import { type PackageV1 } from "./package.js";
 export type ValueRequest = {
+    kind: "fault";
+    message: string;
+} | {
     kind: "call";
     callee: number;
     args: VmValue[];
@@ -13,8 +17,12 @@ export type ValueProgram = Generator<ValueRequest, VmValue, VmValue>;
 /** Execute the exact checked plan, including every derived component selection.
  * A user method yields to an ordinary VM frame and can suspend or fail. */
 export declare function selectedValue(pkg: PackageV1, id: number, args: VmValue[]): ValueProgram;
-export declare function sharedOperation(operation: string, args: VmValue[]): ValueProgram;
+export declare function sharedOperation(operation: Extract<RuntimeContinuation, {
+    handler: "shared";
+}>["operation"], args: VmValue[], owner: RcOwner | null, typeName: string, option: (value: VmValue | null) => VmValue): ValueProgram;
 /** Open-addressed collection operations preserve native callback ordering:
  * growth hashes occupied slots before probing the incoming key. Staged slots
  * borrow their owners until every fallible callback has completed. */
-export declare function collectionOperation(pkg: PackageV1, family: string, operation: string, args: VmValue[], callbacks: number[], shape: number | null | undefined): ValueProgram;
+export declare function collectionOperation(pkg: PackageV1, request: Extract<RuntimeContinuation, {
+    handler: "collection";
+}>, args: VmValue[], callbacks: number[], shape: number | null | undefined): ValueProgram;

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

@@ -1,6 +1,7 @@
-import { UNIT, cloneValue, compareUtf8 } from "../values.js";
+import { UNIT, cloneValue, compareUtf8, } from "../values.js";
 import { runtimeTag, } from "./package.js";
 import { ShimFault } from "./shims.js";
+import { actorIdentical } from "./actor-identity.js";
 const OFFSET = 0xcbf29ce484222325n;
 const PRIME = 0x100000001b3n;
 const integer = (value) => ({
@@ -81,7 +82,7 @@ export function* selectedValue(pkg, id, args) {
     const plan = pkg.value_capabilities[id];
     if (!plan)
         throw new Error(`selected value plan ${id} is missing`);
-    if (plan.callable !== undefined)
+    if (plan.callable != null)
         return yield { kind: "call", callee: plan.callable, args };
     const [left, right] = args;
     if (!left)
@@ -117,10 +118,16 @@ export function* selectedValue(pkg, id, args) {
                 bytes.every((value, i) => BigInt(value) === bits(right.items[i], "u8")));
         throw new Error("bytes ordering is outside the checked capability domain");
     }
+    if (left.kind === "actor" || left.kind === "supervisor") {
+        if (equality)
+            return boolean(actorIdentical(left, right));
+        throw new Error("actor capability is outside the checked equality domain");
+    }
     const components = plan.components ?? [];
     let fields;
     let others = [];
     let selections;
+    let vectorHashLength;
     if (left.kind === "record") {
         fields = left.fields;
         selections = components;
@@ -144,13 +151,20 @@ export function* selectedValue(pkg, id, args) {
         selections = plan.variants?.[left.tag] ?? [];
     }
     else if (left.kind === "vector") {
-        if (hash)
-            throw new Error("derived vector Hash is outside the checked capability domain");
-        if (right?.kind !== "vector" || left.items.length !== right.items.length)
-            return boolean(false);
         fields = left.items;
-        others = right.items;
-        selections = fields.map(() => components[0]);
+        if (hash) {
+            const elementSelection = components[0];
+            if (!elementSelection)
+                throw new Error("derived vector Hash lacks its checked element selection");
+            selections = fields.map(() => elementSelection);
+            vectorHashLength = fields.length;
+        }
+        else {
+            if (right?.kind !== "vector" || left.items.length !== right.items.length)
+                return boolean(false);
+            others = right.items;
+            selections = fields.map(() => components[0]);
+        }
     }
     else {
         if (hash)
@@ -159,7 +173,9 @@ export function* selectedValue(pkg, id, args) {
             return boolean(!!right && bits(left, plan.ty) === bits(right, plan.ty));
         return scalarOrdering(left, right, plan.ty, ordering);
     }
-    let state = OFFSET;
+    let state = vectorHashLength === undefined
+        ? OFFSET
+        : mix(OFFSET, BigInt(vectorHashLength));
     for (const [at, field] of fields.entries()) {
         const selection = selections[at];
         if (!selection)
@@ -247,15 +263,44 @@ function option(pkg, shape, value) {
         payload: value === undefined ? [] : [value],
     };
 }
-export function* sharedOperation(operation, args) {
-    if (operation === "RcNew")
-        return { kind: "rc", cell: { value: args[0], refs: 1 }, closed: false };
+export function* sharedOperation(operation, args, owner, typeName, option) {
+    if (operation === "RcNew") {
+        if (owner?.closed)
+            throw new Error("Rc allocation after actor cleanup quiesced");
+        const cell = {
+            value: args[0],
+            refs: 1,
+            weak: 0,
+            dying: false,
+            owner,
+            typeName,
+        };
+        owner?.blocks.add(cell);
+        return { kind: "rc", cell, closed: false };
+    }
     const receiver = args[0];
+    if (operation === "WeakCloneRc" || operation === "WeakUpgradeRc") {
+        if (receiver?.kind !== "weak" || receiver.closed)
+            throw new Error("shared operation has no live Weak");
+        if (operation === "WeakCloneRc")
+            return cloneValue(receiver);
+        if (receiver.cell.dying || receiver.cell.refs === 0)
+            return option(null);
+        receiver.cell.refs += 1;
+        return option({ kind: "rc", cell: receiver.cell, closed: false });
+    }
     if (receiver?.kind !== "rc" || receiver.closed)
         throw new Error("shared operation has no live Rc");
+    if (!receiver.cell || receiver.cell.dying) {
+        yield { kind: "fault", message: "Rc payload is being released" };
+        return UNIT;
+    }
     switch (operation) {
         case "RcClone":
             return cloneValue(receiver);
+        case "RcDowngrade":
+            receiver.cell.weak += 1;
+            return { kind: "weak", cell: receiver.cell, closed: false };
         case "RcGet":
             return cloneValue(receiver.cell.value);
         case "RcIsUnique":
@@ -263,21 +308,24 @@ export function* sharedOperation(operation, args) {
         case "RcStrongCount":
             return integer(BigInt(receiver.cell.refs));
         case "RcWeakCount":
-            return integer(0n);
+            return integer(BigInt(receiver.cell.weak));
         case "RcSet": {
             const old = receiver.cell.value;
             receiver.cell.value = args[1];
             yield { kind: "release", value: old };
             return UNIT;
         }
-        default:
-            throw new Error(`shared operation ${operation} has no executor`);
+        default: {
+            const exhaustive = operation;
+            throw new Error(`shared operation ${String(exhaustive)} has no executor`);
+        }
     }
 }
 /** Open-addressed collection operations preserve native callback ordering:
  * growth hashes occupied slots before probing the incoming key. Staged slots
  * borrow their owners until every fallible callback has completed. */
-export function* collectionOperation(pkg, family, operation, args, callbacks, shape) {
+export function* collectionOperation(pkg, request, args, callbacks, shape) {
+    const { family, operation } = request;
     if (family === "Vector") {
         const receiver = args[0];
         if (receiver?.kind !== "vector")
@@ -337,7 +385,10 @@ export function* collectionOperation(pkg, family, operation, args, callbacks, sh
         };
         return receiver;
     }
-    if (["Keys", "Values", "Elements", "Entries"].includes(operation)) {
+    if (operation === "Keys" ||
+        operation === "Values" ||
+        operation === "Elements" ||
+        operation === "Entries") {
         return {
             kind: "vector",
             elementType: "",
@@ -417,5 +468,6 @@ export function* collectionOperation(pkg, family, operation, args, callbacks, sh
             ? boolean(result.found)
             : option(pkg, shape, entry?.value));
     }
-    throw new Error(`collection operation ${operation} has no executor`);
+    const exhaustive = operation;
+    throw new Error(`collection operation ${String(exhaustive)} has no executor`);
 }

package/dist/interpreter/values.d.ts

@@ -1,10 +1,26 @@
 import type { JsonValue } from "./types.js";
+import { IndexedString } from "./strings.js";
+export { stringValue } from "./strings.js";
+/** One creator-owned membership list; payload destruction uses the ordinary VM release path. */
+export interface RcOwner {
+    blocks: Set<RcCell>;
+    closed: boolean;
+}
+export interface RcCell {
+    value: VmValue;
+    refs: number;
+    weak: number;
+    dying: boolean;
+    owner: RcOwner | null;
+    typeName: string;
+}
 export type VmValue = {
     kind: "rc";
-    cell: {
-        value: VmValue;
-        refs: number;
-    };
+    cell: RcCell | null;
+    closed: boolean;
+} | {
+    kind: "weak";
+    cell: RcCell;
     closed: boolean;
 } | {
     kind: "unit";
@@ -17,10 +33,7 @@ export type VmValue = {
 } | {
     kind: "f64";
     value: number;
-} | {
-    kind: "string";
-    value: string;
-} | {
+} | IndexedString | {
     kind: "actor";
     id: string;
 } | {
@@ -38,6 +51,15 @@ export type VmValue = {
 } | {
     kind: "task";
     id: string;
+} | {
+    kind: "host_resource";
+    resource: number;
+    owner: import("./v1/browser-directory.js").BrowserFsOwner;
+} | {
+    kind: "timer";
+    resource: number;
+    cancel(): void;
+    closed: boolean;
 } | {
     kind: "generator";
     id: string;

package/dist/interpreter/values.js

@@ -1,3 +1,5 @@
+import { stringValue } from "./strings.js";
+export { stringValue } from "./strings.js";
 export const UNIT = { kind: "unit" };
 const UTF8_ENCODER = new TextEncoder();
 export function compareUtf8(a, b) {
@@ -18,14 +20,24 @@ export function cloneValue(value) {
         case "rc":
             if (value.closed)
                 throw new Error("cannot copy a released Rc");
+            if (!value.cell || value.cell.dying)
+                return { kind: "rc", cell: null, closed: false };
             value.cell.refs += 1;
             return { kind: "rc", cell: value.cell, closed: false };
+        case "weak":
+            if (value.closed)
+                throw new Error("cannot copy a released Weak");
+            value.cell.weak += 1;
+            return { kind: "weak", cell: value.cell, closed: false };
+        case "host_resource":
+            throw new Error("a filesystem owner cannot be copied");
+        case "timer":
+            throw new Error("a timer cancellation handle cannot be copied");
         case "unit":
             return UNIT;
         case "bool":
         case "i64":
         case "f64":
-        case "string":
         case "actor":
         case "supervisor":
         case "monitor":
@@ -38,6 +50,8 @@ export function cloneValue(value) {
         case "duplex":
         case "function": // function values are immutable — identity clone
             return { ...value };
+        case "string":
+            return value.clone();
         case "regex":
             return {
                 kind: "regex",
@@ -106,9 +120,9 @@ export function valueFromLiteral(value) {
                 ? { kind: "i64", value: BigInt(value) }
                 : { kind: "f64", value };
         case "string":
-            return { kind: "string", value };
+            return stringValue(value);
         default:
-            return { kind: "string", value: canonicalJson(value) };
+            return stringValue(canonicalJson(value));
     }
 }
 function taggedI64Literal(value) {
@@ -192,6 +206,10 @@ export function renderF64(value) {
 }
 export function renderStdout(value) {
     switch (value.kind) {
+        case "host_resource":
+            return "FilesystemOwner";
+        case "timer":
+            return "Timer";
         case "unit":
             return "()";
         case "bool":
@@ -232,7 +250,9 @@ export function renderStdout(value) {
         case "vector":
             return canonicalJson(value.items.map((item) => toJsonValue(item)));
         case "rc":
-            return renderStdout(value.cell.value);
+            return "Rc";
+        case "weak":
+            return "Weak";
         case "map":
             return canonicalJson(mapEntriesJson(value));
         case "dyn":
@@ -245,6 +265,10 @@ export function renderStdout(value) {
 }
 export function toJsonValue(value) {
     switch (value.kind) {
+        case "host_resource":
+            return "FilesystemOwner";
+        case "timer":
+            return "Timer";
         case "unit":
             return null;
         case "bool":
@@ -280,7 +304,9 @@ export function toJsonValue(value) {
         case "vector":
             return value.items.map(toJsonValue);
         case "rc":
-            return toJsonValue(value.cell.value);
+            return "Rc";
+        case "weak":
+            return "Weak";
         case "map":
             return mapEntriesJson(value);
         case "dyn":

package/dist/interpreter/worker.js

@@ -3,18 +3,19 @@ import { buildPlaygroundState } from "./playground.js";
 import { runProgram } from "./run-program.js";
 import { BytecodeValidationError } from "./schema-validator.js";
 const worker = globalThis;
-worker.addEventListener("message", (event) => {
+worker.addEventListener("message", async (event) => {
     const { id } = event.data;
     try {
         if (event.data.kind === "run") {
-            const result = runProgram(event.data.source, event.data.stdin);
+            const result = await runProgram(event.data.source, event.data.stdin, undefined, event.data.options);
             worker.postMessage({ id, ok: true, result });
             return;
         }
         const { bytecode, options } = event.data;
-        const trace = runBytecode(bytecode, {
+        const trace = await runBytecode(bytecode, {
             ...options,
             codecBridge: globalThis.__hewSandboxExecuteCodec,
+            calendarBridge: globalThis.__hewSandboxExecuteCalendar,
         });
         worker.postMessage({
             id,

package/package.json

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