@hew-lang/sandbox-vm 0.9.3 → 0.10.0

package/dist/interpreter/run-program.js

@@ -54,17 +54,22 @@ var SandboxExitCode;
     SandboxExitCode[SandboxExitCode["HeapExceeded"] = 200] = "HeapExceeded";
     SandboxExitCode[SandboxExitCode["IntegerOverflow"] = 201] = "IntegerOverflow";
     SandboxExitCode[SandboxExitCode["DivideByZero"] = 202] = "DivideByZero";
+    SandboxExitCode[SandboxExitCode["SignedMinDivNegOne"] = 203] = "SignedMinDivNegOne";
     SandboxExitCode[SandboxExitCode["ShiftOutOfRange"] = 204] = "ShiftOutOfRange";
     SandboxExitCode[SandboxExitCode["IndexOutOfBounds"] = 205] = "IndexOutOfBounds";
+    SandboxExitCode[SandboxExitCode["StackOverflow"] = 215] = "StackOverflow";
     SandboxExitCode[SandboxExitCode["ActorSendFailed"] = 206] = "ActorSendFailed";
     SandboxExitCode[SandboxExitCode["MachineDispatchUnreachable"] = 207] = "MachineDispatchUnreachable";
     SandboxExitCode[SandboxExitCode["ExhaustivenessFallthrough"] = 208] = "ExhaustivenessFallthrough";
 })(SandboxExitCode || (SandboxExitCode = {}));
 const TRAP_EXIT_CODES = {
+    heap_exceeded: SandboxExitCode.HeapExceeded,
     actor_refused: SandboxExitCode.InternalError,
     integer_overflow: SandboxExitCode.IntegerOverflow,
     shift_out_of_range: SandboxExitCode.ShiftOutOfRange,
     divide_by_zero: SandboxExitCode.DivideByZero,
+    signed_min_div_neg_one: SandboxExitCode.SignedMinDivNegOne,
+    stack_overflow: SandboxExitCode.StackOverflow,
     invalid_local: SandboxExitCode.InternalError,
     invalid_block: SandboxExitCode.InternalError,
     invalid_call: SandboxExitCode.InternalError,

package/dist/interpreter/strings.d.ts

@@ -1,5 +1,6 @@
 export declare class IndexedString {
     readonly kind = "string";
+    prepareGrowth?: (capacity: number, detached: boolean) => void;
     private storage;
     private constructor();
     static fromText(text: string): IndexedString;
@@ -7,6 +8,11 @@ export declare class IndexedString {
     get value(): string;
     get scalarLength(): number;
     get byteLength(): number;
+    /** The same UTF-8 backing retained by clones; indexing metadata is excluded. */
+    managedStorage(): {
+        identity: object;
+        capacity: number;
+    };
     encoded(): Uint8Array;
     clone(): IndexedString;
     release(): void;

package/dist/interpreter/strings.js

@@ -34,6 +34,7 @@ function newStorage(bytes, capacity = bytes.length) {
 }
 export class IndexedString {
     kind = "string";
+    prepareGrowth;
     storage;
     constructor(storage) {
         this.storage = storage;
@@ -55,6 +56,11 @@ export class IndexedString {
     get byteLength() {
         return this.live().byteLength;
     }
+    /** The same UTF-8 backing retained by clones; indexing metadata is excluded. */
+    managedStorage() {
+        const storage = this.live();
+        return { identity: storage, capacity: storage.bytes.length };
+    }
     encoded() {
         const storage = this.live();
         return storage.bytes.subarray(0, storage.byteLength);
@@ -162,6 +168,8 @@ export class IndexedString {
         const capacity = newLength > storage.bytes.length
             ? Math.max(newLength, storage.bytes.length * 2, 16)
             : storage.bytes.length;
+        if (storage.owners !== 1 || capacity !== storage.bytes.length)
+            this.prepareGrowth?.(capacity, storage.owners !== 1);
         if (storage.owners !== 1) {
             storage.owners--;
             storage = newStorage(this.encoded(), capacity);

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 = "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 TrapKind = import("./v1/package.js").TrapName | "invalid_local" | "invalid_block" | "invalid_call" | "invalid_enum_tag" | "invalid_record_field" | "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/browser-directory.js

@@ -1,4 +1,4 @@
-import { UNIT } from "../values.js";
+import { vectorItems, UNIT } from "../values.js";
 export const DIRECTORY_OPERATIONS = {
     hew_dir_open_read: {
         release: "hew_dir_read_close",
@@ -250,7 +250,7 @@ export class BrowserDirectories {
                 const data = args[1];
                 if (data?.kind !== "vector")
                     throw new Error("file write requires bytes");
-                const bytes = Uint8Array.from(data.items, (value) => {
+                const bytes = Uint8Array.from(vectorItems(data), (value) => {
                     if (value.kind !== "i64")
                         throw new Error("file write requires byte elements");
                     return Number(value.value);

package/dist/interpreter/v1/codecs.js

@@ -1,4 +1,4 @@
-import { UNIT, stringValue } from "../values.js";
+import { vectorItems, UNIT, stringValue } from "../values.js";
 import { runtimeTag } from "./package.js";
 import { collectionOperation } from "./value-operations.js";
 class DecodeFailure extends Error {
@@ -19,7 +19,7 @@ function fields(value) {
     if (value.kind === "record")
         return value.fields;
     if (value.kind === "vector")
-        return value.items;
+        return vectorItems(value);
     throw new Error(`codec aggregate received ${value.kind}`);
 }
 function toBridge(pkg, shape, id, value) {

package/dist/interpreter/v1/encoding-storage.d.ts

@@ -0,0 +1,33 @@
+import type { EncodingFormat, EncodingNode } from "./encoding-values.js";
+export interface EncodingStorage {
+    owners: number;
+    bytes?: bigint;
+    copyBytes?: bigint;
+    capacities?: unknown;
+    sharedCopy?: boolean;
+}
+export interface EncodingOwner {
+    kind: "encoding";
+    format: EncodingFormat;
+    value: EncodingNode | null;
+    storage?: EncodingStorage;
+    bridge?: (request: string) => string;
+    prepareMutation?: (replacement: EncodingOwner, detached: boolean) => void;
+}
+interface ManagedTree {
+    bytes: string;
+    copy_bytes: string;
+    shared_copy: boolean;
+    capacities: unknown;
+}
+export declare function extractEncoding(value: EncodingOwner, child: EncodingNode | null, path: number[]): EncodingOwner;
+export declare function encodingOwner(format: EncodingFormat, value: EncodingNode | null, bridge?: EncodingOwner["bridge"], managed?: ManagedTree): EncodingOwner;
+/** The native provider measures actual typed capacities. The VM retains this
+ * whole-tree backing; no JavaScript allocation estimate enters its charge. */
+export declare function encodingStorage(value: EncodingOwner): EncodingStorage;
+export declare function cloneEncoding(value: EncodingOwner, preview?: boolean): EncodingOwner;
+export declare function releaseEncoding(value: EncodingOwner): void;
+/** Stage the real provider operation before committing either consumed input.
+ * A refused copy-on-write detach leaves both trees and aliases unchanged. */
+export declare function mutateEncoding(value: EncodingOwner, operation: "array_push" | "object_set", child: EncodingOwner, key?: string): boolean;
+export {};

package/dist/interpreter/v1/encoding-storage.js

@@ -0,0 +1,113 @@
+import { HeapExceeded } from "./managed-budget.js";
+export function extractEncoding(value, child, path) {
+    if (!value.bridge || child === null)
+        return encodingOwner(value.format, structuredClone(child), value.bridge);
+    let capacities = encodingStorage(value).capacities;
+    for (const index of path)
+        capacities = Array.isArray(capacities) ? capacities[index] : undefined;
+    const result = encodingOwner(value.format, child, value.bridge);
+    storage(result).capacities = capacities;
+    return native(result, "clone");
+}
+export function encodingOwner(format, value, bridge, managed) {
+    return {
+        kind: "encoding",
+        format,
+        value,
+        bridge,
+        storage: {
+            owners: 1,
+            ...(managed
+                ? {
+                    bytes: BigInt(managed.bytes),
+                    copyBytes: BigInt(managed.copy_bytes),
+                    capacities: managed.capacities,
+                    sharedCopy: managed.shared_copy,
+                }
+                : {}),
+        },
+    };
+}
+function storage(value) {
+    return (value.storage ??= { owners: 1 });
+}
+function native(value, operation, fields = {}) {
+    if (!value.bridge)
+        throw new Error("managed encoding storage requires the native codec bridge");
+    const response = JSON.parse(value.bridge(JSON.stringify({
+        encoding_value: {
+            format: value.format,
+            operation,
+            value: value.value,
+            capacities: storage(value).capacities,
+            ...fields,
+        },
+    })));
+    if (response.failure) {
+        if (response.failure.includes("capacity overflow"))
+            throw new HeapExceeded();
+        throw new Error(response.failure);
+    }
+    return encodingOwner(value.format, response.value ?? null, value.bridge, response.managed);
+}
+/** The native provider measures actual typed capacities. The VM retains this
+ * whole-tree backing; no JavaScript allocation estimate enters its charge. */
+export function encodingStorage(value) {
+    const retained = storage(value);
+    if (value.value !== null && retained.bytes == null) {
+        const measured = native(value, "retain");
+        Object.assign(retained, measured.storage, { owners: retained.owners });
+    }
+    return retained;
+}
+export function cloneEncoding(value, preview = false) {
+    const retained = value.bridge && value.value !== null
+        ? encodingStorage(value)
+        : storage(value);
+    if (retained.sharedCopy ?? value.format === "Yaml") {
+        if (preview)
+            return value;
+        retained.owners++;
+        return { ...value, storage: retained, prepareMutation: undefined };
+    }
+    if (value.bridge && value.value !== null)
+        return native(value, "clone");
+    return encodingOwner(value.format, structuredClone(value.value), value.bridge);
+}
+export function releaseEncoding(value) {
+    if (value.value !== null)
+        storage(value).owners--;
+    value.value = null;
+}
+/** Stage the real provider operation before committing either consumed input.
+ * A refused copy-on-write detach leaves both trees and aliases unchanged. */
+export function mutateEncoding(value, operation, child, key) {
+    if (!value.bridge) {
+        if (value.format === "Yaml" && storage(value).owners > 1) {
+            storage(value).owners--;
+            value.value = structuredClone(value.value);
+            value.storage = { owners: 1 };
+        }
+        if (child.format === "Yaml" && storage(child).owners > 1) {
+            storage(child).owners--;
+            child.value = structuredClone(child.value);
+            child.storage = { owners: 1 };
+        }
+        return false;
+    }
+    const retained = encodingStorage(value);
+    const childStorage = encodingStorage(child);
+    const replacement = native(value, operation, {
+        detach: retained.sharedCopy && retained.owners > 1,
+        child: child.value,
+        child_capacities: childStorage.capacities,
+        key,
+        child_detach: childStorage.sharedCopy && childStorage.owners > 1,
+    });
+    value.prepareMutation?.(replacement, !!retained.sharedCopy && retained.owners > 1);
+    retained.owners--;
+    value.value = replacement.value;
+    value.storage = replacement.storage;
+    releaseEncoding(child);
+    return true;
+}

package/dist/interpreter/v1/encoding-values.js

@@ -1,5 +1,5 @@
 import { cloneValue, compareUtf8, stringValue, UNIT, } from "../values.js";
-const owner = (format, value) => ({ kind: "encoding", format, value });
+import { encodingOwner, extractEncoding, mutateEncoding, releaseEncoding, } from "./encoding-storage.js";
 const integer = (value) => ({
     kind: "i64",
     value: BigInt(value),
@@ -59,9 +59,8 @@ function equal(format, left, right) {
     }
 }
 export function executeEncoding(host, format, operation, args) {
-    const owned = (node) => owner(format, node);
+    const owned = (node) => encodingOwner(format, node, host.codecBridge);
     const value = (arg) => checkedValue(arg, format);
-    const copy = (node) => cloneValue(owned(node));
     if (operation === "Parse" || operation === "Stringify") {
         if (!host.codecBridge)
             throw new Error("Encoding text operations require the hew-wasm executeCodec bridge");
@@ -74,7 +73,7 @@ export function executeEncoding(host, format, operation, args) {
             throw new Error(result.failure);
         host.encodingError(format, result.error ?? "");
         return operation === "Parse"
-            ? owned(result.value ?? null)
+            ? encodingOwner(format, result.value ?? null, host.codecBridge, result.managed)
             : stringValue(result.text ?? "");
     }
     switch (operation) {
@@ -105,14 +104,15 @@ export function executeEncoding(host, format, operation, args) {
         case "Eq":
             return integer(equal(format, value(args[0]).value, value(args[1]).value) ? 1 : 0);
         case "Clone":
-            return copy(value(args[0]).value);
+            return cloneValue(value(args[0]));
         case "Free":
-            value(args[0]).value = null;
+            releaseEncoding(value(args[0]));
             return UNIT;
         default:
             break;
     }
-    const receiver = value(args[0]), node = receiver.value;
+    const receiver = value(args[0]);
+    let node = receiver.value;
     let scalar = node;
     while (scalar?.[0] === "tagged")
         scalar = scalar[2];
@@ -160,16 +160,20 @@ export function executeEncoding(host, format, operation, args) {
             return integer(node?.[0] === "array" ? node[1].length : -1);
         case "GetDatetime":
             return stringValue(node?.[0] === "datetime" ? node[1] : "");
-        case "GetField":
-            return copy(node?.[0] === "object"
-                ? (node[1].find(([key]) => key === text(args[1]))?.[1] ?? null)
+        case "GetField": {
+            const index = node?.[0] === "object"
+                ? node[1].findIndex(([key]) => key === text(args[1]))
                 : node?.[0] === "mapping"
-                    ? (node[1].find(([key]) => key[0] === "string" && key[1] === text(args[1]))?.[1] ?? null)
-                    : null);
-        case "ArrayGet":
-            return copy(node?.[0] === "array"
-                ? (node[1][Number(BigInt.asIntN(32, number(args[1])))] ?? null)
-                : null);
+                    ? node[1].findIndex(([key]) => key[0] === "string" && key[1] === text(args[1]))
+                    : -1;
+            return extractEncoding(receiver, index < 0 || (node?.[0] !== "object" && node?.[0] !== "mapping")
+                ? null
+                : node[1][index][1], node?.[0] === "mapping" ? [1, index, 1] : [index, 1]);
+        }
+        case "ArrayGet": {
+            const index = Number(BigInt.asIntN(32, number(args[1])));
+            return extractEncoding(receiver, node?.[0] === "array" ? (node[1][index] ?? null) : null, [1, index]);
+        }
         case "ObjectKeys":
             return owned(node?.[0] === "object"
                 ? ["array", node[1].map(([key]) => ["string", key])]
@@ -178,6 +182,9 @@ export function executeEncoding(host, format, operation, args) {
                     : null);
         case "ObjectSet": {
             const child = value(args[2]), key = text(args[1]);
+            if (mutateEncoding(receiver, "object_set", child, key))
+                return receiver;
+            node = receiver.value;
             if (node?.[0] === "object" && child.value) {
                 const index = node[1].findIndex(([name]) => name === key);
                 if (index < 0) {
@@ -194,14 +201,17 @@ export function executeEncoding(host, format, operation, args) {
                 else
                     node[1][index] = [["string", key], child.value];
             }
-            child.value = null;
+            releaseEncoding(child);
             return receiver;
         }
         case "ArrayPush": {
             const child = value(args[1]);
+            if (mutateEncoding(receiver, "array_push", child))
+                return receiver;
+            node = receiver.value;
             if (node?.[0] === "array" && child.value)
                 node[1].push(child.value);
-            child.value = null;
+            releaseEncoding(child);
             return receiver;
         }
     }