@hew-lang/sandbox-vm 0.10.0-rc1 → 0.10.0

package/dist/interpreter/v1/shims.js

@@ -4,7 +4,7 @@ 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.
-import { UNIT, byteVectorValue, clearByteVector, mutableVector, sliceByteVector, cloneValue, compareUtf8, stringValue, renderStdout, } from "../values.js";
+import { UNIT, byteVectorValue, clearByteVector, mutableVector, vectorItems, vectorLength, vectorElement, takeVectorEnd, sliceByteVector, cloneValue, compareUtf8, stringValue, 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.
@@ -446,14 +446,14 @@ const UNIT_FAMILIES = {
     // native lossy decoding does.
     BytesDecodeUtf8Lossy: (_host, args) => str(decodeUtf8(arg(args, 0))),
     BytesNew: () => byteVectorValue([]),
-    BytesIsEmpty: (_host, args) => bool(vec(args, 0).items.length === 0),
-    BytesLen: (_host, args) => int(BigInt(vec(args, 0).items.length)),
+    BytesIsEmpty: (_host, args) => bool(vectorLength(vec(args, 0)) === 0),
+    BytesLen: (_host, args) => int(BigInt(vectorLength(vec(args, 0)))),
     BytesContains: (_host, args) => {
         const byte = integer(args, 1);
-        return bool(vec(args, 0).items.some((item) => integer([item], 0) === byte));
+        return bool(vectorItems(vec(args, 0)).some((item) => integer([item], 0) === byte));
     },
     BytesIndex: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const at = index(args, 1);
         if (at < 0 || at >= items.length) {
             throw new ShimFault("vector_bounds", `bytes index ${at} out of bounds for length ${items.length}`);
@@ -462,37 +462,37 @@ const UNIT_FAMILIES = {
     },
     // Nonempty views retain the exact original allocation and payload capacity.
     BytesSlice: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const start = index(args, 1);
         const end = index(args, 2);
         checkSliceBounds(start, end, items.length);
         return sliceByteVector(vec(args, 0), start, end);
     },
     BytesSliceFrom: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const start = index(args, 1);
         checkSliceBounds(start, items.length, items.length);
         return sliceByteVector(vec(args, 0), start, items.length);
     },
-    BytesConcat: (_host, args) => byteVector([...vec(args, 0).items, ...vec(args, 1).items]),
-    BytesStartsWith: (_host, args) => bool(runAt(vec(args, 0).items, vec(args, 1).items, 0)),
+    BytesConcat: (_host, args) => byteVector([...vectorItems(vec(args, 0)), ...vectorItems(vec(args, 1))]),
+    BytesStartsWith: (_host, args) => bool(runAt(vectorItems(vec(args, 0)), vectorItems(vec(args, 1)), 0)),
     BytesEndsWith: (_host, args) => {
-        const items = vec(args, 0).items;
-        const run = vec(args, 1).items;
+        const items = vectorItems(vec(args, 0));
+        const run = vectorItems(vec(args, 1));
         return bool(runAt(items, run, items.length - run.length));
     },
     // A mutating call receives its receiver by `move` and returns it.
     BytesPush: (_host, args) => {
         const target = vec(args, 0);
-        mutableVector(target, target.items.length + 1);
+        mutableVector(target, vectorLength(target) + 1);
         target.items.push(cloneValue(arg(args, 1)));
         return target;
     },
     BytesSet: (_host, args) => {
         const target = vec(args, 0);
         const at = index(args, 1);
-        if (at < 0 || at >= target.items.length) {
-            throw new ShimFault("vector_bounds", `bytes index ${at} out of bounds for length ${target.items.length}`);
+        if (at < 0 || at >= vectorLength(target)) {
+            throw new ShimFault("vector_bounds", `bytes index ${at} out of bounds for length ${vectorLength(target)}`);
         }
         mutableVector(target);
         target.items[at] = cloneValue(arg(args, 2));
@@ -506,7 +506,7 @@ const UNIT_FAMILIES = {
         if (!shape) {
             throw new TypeError("BytesGet names no result shape to build its Option against");
         }
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const at = index(args, 1);
         return at >= 0 && at < items.length
             ? host.enumValue(shape, "OptionSome", [cloneValue(items[at])])
@@ -516,8 +516,8 @@ const UNIT_FAMILIES = {
     // append, paired with the removed byte for a pop.
     BytesAppend: (_host, args) => {
         const target = vec(args, 0);
-        const added = vec(args, 1).items.map(cloneValue);
-        mutableVector(target, target.items.length + added.length);
+        const added = vectorItems(vec(args, 1)).map(cloneValue);
+        mutableVector(target, vectorLength(target) + added.length);
         target.items.push(...added);
         return target;
     },
@@ -526,7 +526,7 @@ const UNIT_FAMILIES = {
             throw new TypeError("BytesPop names no result shape to build its Option against");
         }
         const target = vec(args, 0);
-        if (target.items.length)
+        if (vectorLength(target))
             mutableVector(target);
         const last = target.items.pop();
         return {
@@ -708,9 +708,9 @@ const VECTOR_SHIMS = {
         const left = index(args, 1);
         const right = index(args, 2);
         if (left < 0 ||
-            left >= target.items.length ||
+            left >= vectorLength(target) ||
             right < 0 ||
-            right >= target.items.length) {
+            right >= vectorLength(target)) {
             throw new ShimFault("vector_bounds", "vector swap index out of bounds");
         }
         mutableVector(target);
@@ -722,14 +722,13 @@ const VECTOR_SHIMS = {
     },
     Pop: (_host, args) => {
         const target = vec(args, 0);
-        if (target.items.length === 0) {
+        if (vectorLength(target) === 0) {
             throw new ShimFault("vector_bounds", "pop from empty vector");
         }
-        mutableVector(target);
         return {
             kind: "record",
             typeId: "",
-            fields: [target, target.items.pop()],
+            fields: [target, takeVectorEnd(target, true)],
         };
     },
     New: () => ({ kind: "vector", elementType: "", items: [] }),
@@ -738,15 +737,15 @@ const VECTOR_SHIMS = {
     // ownership decision SIR proved, so it moves in as it arrives.
     Push: (_host, args) => {
         const target = vec(args, 0);
-        mutableVector(target, target.items.length + 1);
+        mutableVector(target, vectorLength(target) + 1);
         target.items.push(arg(args, 1));
         return target;
     },
     Append: (_host, args) => {
         const target = vec(args, 0);
-        const added = [...vec(args, 1).items];
+        const added = [...vectorItems(vec(args, 1))];
         if (added.length) {
-            mutableVector(target, target.items.length + added.length, added);
+            mutableVector(target, vectorLength(target) + added.length, added);
             target.items.push(...added.map(cloneValue));
         }
         return target;
@@ -754,41 +753,41 @@ const VECTOR_SHIMS = {
     Remove: (_host, args) => {
         const target = vec(args, 0);
         const at = index(args, 1);
-        if (at < 0 || at >= target.items.length) {
-            throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${target.items.length}`);
+        if (at < 0 || at >= vectorLength(target)) {
+            throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${vectorLength(target)}`);
         }
-        mutableVector(target);
-        const [item] = target.items.splice(at, 1);
+        const item = at === 0
+            ? takeVectorEnd(target, false)
+            : mutableVector(target).items.splice(at, 1)[0];
         return { kind: "record", typeId: "", fields: [target, item] };
     },
     Get: (host, args, shape) => {
         if (!shape) {
             throw new TypeError("Vector::Get names no result shape to build its Option against");
         }
-        const items = vec(args, 0).items;
-        const at = index(args, 1);
-        return at >= 0 && at < items.length
-            ? host.enumValue(shape, "OptionSome", [cloneValue(items[at])])
+        const item = vectorElement(vec(args, 0), index(args, 1));
+        return item
+            ? host.enumValue(shape, "OptionSome", [cloneValue(item)])
             : host.enumValue(shape, "OptionNone", []);
     },
     Index: (_host, args) => cloneValue(sequenceElement(args)),
     IndexBorrow: (_host, args) => sequenceElement(args),
-    Len: (_host, args) => int(BigInt(vec(args, 0).items.length)),
+    Len: (_host, args) => int(BigInt(vectorLength(vec(args, 0)))),
     Join: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         return str(items
             .map((_, at) => indexed(items, at).value)
             .join(indexed(args, 1).value));
     },
     Slice: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const start = index(args, 1);
         const end = index(args, 2);
         checkSliceBounds(start, end, items.length);
         return vectorSlice(items.slice(start, end));
     },
     SliceFrom: (_host, args) => {
-        const items = vec(args, 0).items;
+        const items = vectorItems(vec(args, 0));
         const start = index(args, 1);
         checkSliceBounds(start, items.length, items.length);
         return vectorSlice(items.slice(start));
@@ -805,12 +804,13 @@ function vectorSlice(items) {
     return result;
 }
 function sequenceElement(args) {
-    const items = vec(args, 0).items;
+    const target = vec(args, 0);
     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}`);
+    const item = vectorElement(target, at);
+    if (!item) {
+        throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${vectorLength(target)}`);
     }
-    return items[at];
+    return item;
 }
 function byteVector(items) {
     return byteVectorValue(items.map(cloneValue));
@@ -1230,7 +1230,7 @@ const EXTERN_SHIMS = {
 export function decodeUtf8Checked(value) {
     if (value.kind !== "vector")
         throw new TypeError("UTF-8 input must be bytes");
-    const bytes = Uint8Array.from(value.items.map((item) => Number(integer([item], 0))));
+    const bytes = Uint8Array.from(vectorItems(value).map((item) => Number(integer([item], 0))));
     let at = 0;
     while (at < bytes.length) {
         const first = bytes[at];
@@ -1276,7 +1276,7 @@ function decodeUtf8(value) {
     if (value.kind !== "vector") {
         return renderStdout(value);
     }
-    return new TextDecoder().decode(Uint8Array.from(value.items.map((item) => (item.kind === "i64" ? Number(item.value) : 0))));
+    return new TextDecoder().decode(Uint8Array.from(vectorItems(value).map((item) => item.kind === "i64" ? Number(item.value) : 0)));
 }
 function compileRegex(host, args) {
     const source = pattern(host, arg(args, 0));

package/dist/interpreter/v1/structural.js

@@ -1,4 +1,4 @@
-import { renderStdout } from "../values.js";
+import { vectorItems, renderStdout } from "../values.js";
 /** A borrowed traversal. Display callbacks can suspend, so their callers retain
  * this stack and resume it with the returned string. No later sibling is read
  * after a callback fails. */
@@ -49,7 +49,9 @@ export class StructuralRenderer {
                 case "vector": {
                     if (value.kind !== "vector")
                         throw new Error("structural vector has no elements");
-                    this.sequence("[", "]", value.items.map((value) => [{ value, recipe: recipe.members[0] }]));
+                    this.sequence("[", "]", vectorItems(value).map((value) => [
+                        { value, recipe: recipe.members[0] },
+                    ]));
                     break;
                 }
                 case "map": {

package/dist/interpreter/v1/validate.js

@@ -210,7 +210,8 @@ export function admitPackage(pkg, bridges = {}) {
                 const supervisor = pkg.supervisors?.find((layout) => layout.id === id);
                 const config = term.args.length -
                     (supervisor?.children.some((child) => child.is_pool) ? 1 : 0) -
-                    (supervisor?.backoff ? 2 : 0);
+                    2 *
+                        (supervisor?.children.filter((child) => child.backoff).length ?? 0);
                 if (!supervisor ||
                     config < 0 ||
                     supervisor.children.some((child) => {

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

@@ -1,4 +1,4 @@
-import { UNIT, mutableVector, cloneValue, compareUtf8, } from "../values.js";
+import { UNIT, mutableVector, vectorItems, vectorLength, vectorElement, cloneValue, compareUtf8, } from "../values.js";
 import { runtimeTag, } from "./package.js";
 import { ShimFault } from "./shims.js";
 import { actorIdentical } from "./actor-identity.js";
@@ -109,13 +109,13 @@ export function* selectedValue(pkg, id, args) {
     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")));
+        const bytes = vectorItems(left).map((value) => Number(bits(value, "u8")));
         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")));
+                bytes.length === vectorLength(right) &&
+                bytes.every((value, i) => BigInt(value) === bits(vectorElement(right, i), "u8")));
         throw new Error("bytes ordering is outside the checked capability domain");
     }
     if (left.kind === "actor" || left.kind === "supervisor") {
@@ -151,7 +151,7 @@ export function* selectedValue(pkg, id, args) {
         selections = plan.variants?.[left.tag] ?? [];
     }
     else if (left.kind === "vector") {
-        fields = left.items;
+        fields = vectorItems(left);
         if (hash) {
             const elementSelection = components[0];
             if (!elementSelection)
@@ -160,9 +160,10 @@ export function* selectedValue(pkg, id, args) {
             vectorHashLength = fields.length;
         }
         else {
-            if (right?.kind !== "vector" || left.items.length !== right.items.length)
+            if (right?.kind !== "vector" ||
+                vectorLength(left) !== vectorLength(right))
                 return boolean(false);
-            others = right.items;
+            others = vectorItems(right);
             selections = fields.map(() => components[0]);
         }
     }
@@ -346,15 +347,15 @@ export function* collectionOperation(pkg, request, args, callbacks, shape, eleme
             if (index?.kind !== "i64")
                 throw new Error("vector mutation has no index");
             const at = Number(index.value);
-            if (at < 0 || at >= receiver.items.length)
-                throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${receiver.items.length}`);
+            if (at < 0 || at >= vectorLength(receiver))
+                throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${vectorLength(receiver)}`);
             mutableVector(receiver);
             const old = receiver.items[at];
             receiver.items[at] = args[2];
             yield { kind: "release", value: old, retainedType: elementType };
             return receiver;
         }
-        for (const item of receiver.items) {
+        for (const item of vectorItems(receiver)) {
             const equal = yield* selectedValue(pkg, callbacks[0], [item, args[1]]);
             if (equal.kind !== "bool")
                 throw new Error("Eq returned a non-boolean value");

package/dist/interpreter/values.d.ts

@@ -31,6 +31,8 @@ export interface VmVector {
     items: VmValue[];
     storage?: VectorStorage;
     offset?: number;
+    /** Normal Vec live length; absent for materialized vectors and byte views. */
+    length?: number;
     closed?: boolean;
     prepareMutation?: (capacity: number, detached: boolean, appended?: readonly VmValue[]) => void;
 }
@@ -156,12 +158,19 @@ export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | import("./v
 export declare const UNIT: VmValue;
 export declare function compareUtf8(a: string, b: string): number;
 export declare function cloneValue(value: VmValue): VmValue;
+/** The live range is header metadata; the backing keeps its full capacity. */
+export declare function vectorLength(value: VmVector): number;
+export declare function vectorElement(value: VmVector, index: number): VmValue | undefined;
+/** Materialize a view only for operations that already traverse its elements. */
+export declare function vectorItems(value: VmVector): VmValue[];
 export declare function vectorStorage(value: VmVector): VectorStorage;
 export declare function byteVectorValue(items: VmValue[]): VmVector;
 export declare function sliceByteVector(value: VmVector, start: number, end: number): VmVector;
 /** Establish uniqueness before any mutation, preserving native capacity rules. */
 export declare function mutableVector(value: VmVector, needed?: number, appended?: readonly VmValue[]): VmVector;
-/** Consume one handle; only the last backing owner releases its elements. */
+/** Move a normal Vec end in constant time, retaining its allocation identity. */
+export declare function takeVectorEnd(value: VmVector, back: boolean): VmValue;
+/** Consume one handle; only its remaining live elements need destruction. */
 export declare function releaseVector(value: VmVector): VmValue[];
 export declare function clearByteVector(value: VmVector): VmVector;
 export declare function valueFromLiteral(value: JsonValue): VmValue;

package/dist/interpreter/values.js

@@ -110,6 +110,21 @@ export function cloneValue(value) {
             };
     }
 }
+/** The live range is header metadata; the backing keeps its full capacity. */
+export function vectorLength(value) {
+    return value.length ?? value.items.length;
+}
+export function vectorElement(value, index) {
+    if (index < 0 || index >= vectorLength(value))
+        return undefined;
+    return value.items[(value.length === undefined ? 0 : (value.offset ?? 0)) + index];
+}
+/** Materialize a view only for operations that already traverse its elements. */
+export function vectorItems(value) {
+    return value.length === undefined
+        ? value.items
+        : value.items.slice(value.offset ?? 0, (value.offset ?? 0) + value.length);
+}
 export function vectorStorage(value) {
     if (value.closed)
         throw new Error("cannot read a released vector");
@@ -140,11 +155,11 @@ function cloneVector(value) {
     const storage = vectorStorage(value);
     // Native Vec clones discard an empty receiver's spare capacity. Bytes
     // clones retain their allocation even when the visible length is zero.
-    if (storage.bytes || (storage.shareOnCopy && value.items.length !== 0)) {
+    if (storage.bytes || (storage.shareOnCopy && vectorLength(value) !== 0)) {
         storage.owners++;
         return { ...value, storage, closed: false };
     }
-    const items = value.items.map(cloneValue);
+    const items = vectorItems(value).map(cloneValue);
     return {
         kind: "vector",
         elementType: value.elementType,
@@ -168,12 +183,12 @@ export function sliceByteVector(value, start, end) {
     };
 }
 /** Establish uniqueness before any mutation, preserving native capacity rules. */
-export function mutableVector(value, needed = value.items.length, appended) {
+export function mutableVector(value, needed = vectorLength(value), appended) {
     let storage = vectorStorage(value);
     let capacity = storage.capacity;
     const detached = storage.owners !== 1;
     if (detached && storage.bytes)
-        capacity = Math.max(value.items.length, 16);
+        capacity = Math.max(vectorLength(value), 16);
     if (needed > capacity) {
         if (storage.bytes)
             capacity = Math.max(Math.min(capacity * 2, 0xffffffff), needed, 16);
@@ -189,12 +204,24 @@ export function mutableVector(value, needed = value.items.length, appended) {
     if (detached || capacity !== storage.capacity || appended?.length)
         value.prepareMutation?.(capacity, detached, appended);
     if (detached) {
-        const items = value.items.map(cloneValue);
+        const items = vectorItems(value).map(cloneValue);
         storage.owners--;
         storage = { ...storage, items, capacity, owners: 1 };
         value.storage = storage;
         value.items = items;
         value.offset = 0;
+        value.length = undefined;
+    }
+    else if (!storage.bytes && value.length !== undefined) {
+        // A sole remaining view can reclaim its consumed prefix without
+        // changing the language allocation's identity or retained capacity.
+        if ((value.offset ?? 0) === 0)
+            value.items.length = value.length;
+        else
+            value.items = vectorItems(value);
+        storage.items = value.items;
+        value.offset = 0;
+        value.length = undefined;
     }
     if (capacity !== storage.capacity) {
         storage.capacity = capacity;
@@ -205,13 +232,42 @@ export function mutableVector(value, needed = value.items.length, appended) {
     }
     return value;
 }
-/** Consume one handle; only the last backing owner releases its elements. */
+/** Move a normal Vec end in constant time, retaining its allocation identity. */
+export function takeVectorEnd(value, back) {
+    const storage = vectorStorage(value);
+    const length = vectorLength(value);
+    if (length === 0)
+        throw new Error("cannot take an empty vector end");
+    if (storage.bytes) {
+        mutableVector(value);
+        return (back ? value.items.pop() : value.items.shift());
+    }
+    const start = value.offset ?? 0;
+    const index = start + (back ? length - 1 : 0);
+    const item = value.items[index];
+    // Managed/affine storage is unique. Clear its moved slot immediately so
+    // the backing cannot retain payload references after ownership transfers.
+    // Shared callback-free plain bytes remain readable by other headers.
+    if (storage.owners === 1)
+        value.items[index] = UNIT;
+    else if (!storage.shareOnCopy)
+        throw new Error("managed vector unexpectedly shares its backing");
+    value.offset = start + (back ? 0 : 1);
+    value.length = length - 1;
+    return item;
+}
+/** Consume one handle; only its remaining live elements need destruction. */
 export function releaseVector(value) {
     if (value.closed)
         return [];
     const storage = vectorStorage(value);
+    const items = --storage.owners === 0
+        ? storage.bytes
+            ? storage.items
+            : vectorItems(value)
+        : [];
     value.closed = true;
-    return --storage.owners === 0 ? storage.items : [];
+    return items;
 }
 export function clearByteVector(value) {
     const storage = vectorStorage(value);
@@ -370,7 +426,7 @@ export function renderStdout(value) {
                 payload: value.payload.map((field) => toJsonValue(field)),
             });
         case "vector":
-            return canonicalJson(value.items.map((item) => toJsonValue(item)));
+            return canonicalJson(vectorItems(value).map((item) => toJsonValue(item)));
         case "rc":
             return "Rc";
         case "weak":
@@ -428,7 +484,7 @@ export function toJsonValue(value) {
                 payload: value.payload.map(toJsonValue),
             };
         case "vector":
-            return value.items.map(toJsonValue);
+            return vectorItems(value).map(toJsonValue);
         case "rc":
             return "Rc";
         case "weak":

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hew-lang/sandbox-vm",
-  "version": "0.10.0-rc1",
+  "version": "0.10.0",
   "hewSource": {
-    "commit": "5672a4d39318d99785a863cd5002d33952eb269e",
-    "tag": "v0.10.0-rc1",
+    "commit": "75e14a2775f9af8fd77a6a907da277b2de666824",
+    "tag": "v0.10.0",
     "dirty": false
   },
   "description": "Deterministic TypeScript interpreter for the Hew educational sandbox",
@@ -21,7 +21,7 @@
     "cli/"
   ],
   "dependencies": {
-    "@hew-lang/wasm": "0.10.0-rc1"
+    "@hew-lang/wasm": "0.10.0"
   },
   "keywords": [
     "hew",