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

package/dist/interpreter/values.js

@@ -1,4 +1,5 @@
 import { stringValue } from "./strings.js";
+import { cloneEncoding } from "./v1/encoding-storage.js";
 export { stringValue } from "./strings.js";
 export const UNIT = { kind: "unit" };
 const UTF8_ENCODER = new TextEncoder();
@@ -18,7 +19,7 @@ const I64_LITERAL_DECIMAL = /^(?:0|-?[1-9]\d*)$/;
 export function cloneValue(value) {
     switch (value.kind) {
         case "encoding":
-            return { ...value, value: structuredClone(value.value) };
+            return cloneEncoding(value);
         case "rc":
             if (value.closed)
                 throw new Error("cannot copy a released Rc");
@@ -69,6 +70,7 @@ export function cloneValue(value) {
                 kind: "record",
                 typeId: value.typeId,
                 shape: value.shape,
+                managedCaptures: value.managedCaptures,
                 fields: value.fields.map(cloneValue),
             };
         case "enum":
@@ -80,16 +82,13 @@ export function cloneValue(value) {
                 payload: value.payload.map(cloneValue),
             };
         case "vector":
-            return {
-                kind: "vector",
-                elementType: value.elementType,
-                items: value.items.map(cloneValue),
-            };
+            return cloneVector(value);
         case "dyn":
             return {
                 kind: "dyn",
                 vtable: value.vtable,
                 value: cloneValue(value.value),
+                managedPayload: value.managedPayload,
             };
         case "closure":
             return {
@@ -97,6 +96,7 @@ export function cloneValue(value) {
                 entries: value.entries,
                 specialization: value.specialization,
                 environment: cloneValue(value.environment),
+                managedCaptures: value.managedCaptures,
             };
         case "map":
             return {
@@ -110,6 +110,118 @@ export function cloneValue(value) {
             };
     }
 }
+export function vectorStorage(value) {
+    if (value.closed)
+        throw new Error("cannot read a released vector");
+    return (value.storage ??= {
+        items: value.items,
+        capacity: value.items.length,
+        owners: 1,
+        bytes: false,
+        shareOnCopy: false,
+    });
+}
+export function byteVectorValue(items) {
+    return {
+        kind: "vector",
+        elementType: "u8",
+        items,
+        storage: {
+            items,
+            capacity: items.length ? Math.max(items.length, 16) : 0,
+            owners: 1,
+            bytes: true,
+            shareOnCopy: true,
+        },
+        offset: 0,
+    };
+}
+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)) {
+        storage.owners++;
+        return { ...value, storage, closed: false };
+    }
+    const items = value.items.map(cloneValue);
+    return {
+        kind: "vector",
+        elementType: value.elementType,
+        items,
+        storage: { ...storage, items, capacity: items.length, owners: 1 },
+    };
+}
+export function sliceByteVector(value, start, end) {
+    const storage = vectorStorage(value);
+    if (!storage.bytes)
+        throw new Error("bytes slice has no bytes storage");
+    if (start === end)
+        return byteVectorValue([]);
+    storage.owners++;
+    return {
+        kind: "vector",
+        elementType: value.elementType,
+        items: value.items.slice(start, end),
+        storage,
+        offset: (value.offset ?? 0) + start,
+    };
+}
+/** Establish uniqueness before any mutation, preserving native capacity rules. */
+export function mutableVector(value, needed = value.items.length, 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);
+    if (needed > capacity) {
+        if (storage.bytes)
+            capacity = Math.max(Math.min(capacity * 2, 0xffffffff), needed, 16);
+        else {
+            capacity = capacity || 4;
+            while (capacity < needed)
+                capacity *= 2;
+        }
+    }
+    if (!Number.isSafeInteger(capacity) ||
+        (storage.bytes && capacity > 0xffffffff))
+        throw new Error("vector capacity overflow");
+    if (detached || capacity !== storage.capacity || appended?.length)
+        value.prepareMutation?.(capacity, detached, appended);
+    if (detached) {
+        const items = value.items.map(cloneValue);
+        storage.owners--;
+        storage = { ...storage, items, capacity, owners: 1 };
+        value.storage = storage;
+        value.items = items;
+        value.offset = 0;
+    }
+    if (capacity !== storage.capacity) {
+        storage.capacity = capacity;
+        value.offset = 0;
+    }
+    else if (storage.bytes && (value.offset ?? 0) + needed > capacity) {
+        value.offset = 0;
+    }
+    return value;
+}
+/** Consume one handle; only the last backing owner releases its elements. */
+export function releaseVector(value) {
+    if (value.closed)
+        return [];
+    const storage = vectorStorage(value);
+    value.closed = true;
+    return --storage.owners === 0 ? storage.items : [];
+}
+export function clearByteVector(value) {
+    const storage = vectorStorage(value);
+    storage.owners--;
+    const empty = byteVectorValue([]);
+    value.items = empty.items;
+    value.storage = empty.storage;
+    value.offset = 0;
+    return value;
+}
 export function valueFromLiteral(value) {
     const taggedI64 = taggedI64Literal(value);
     if (taggedI64 !== null) {

package/package.json

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