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

package/dist/interpreter/run-program.js

@@ -54,8 +54,10 @@ 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";
@@ -66,6 +68,8 @@ const TRAP_EXIT_CODES = {
     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/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 = "heap_exceeded" | "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/exec.js

@@ -11,7 +11,7 @@ import { executeCodec } from "./codecs.js";
 import { actorIdentical } from "./actor-identity.js";
 import { ActorWaits } from "./actor-waits.js";
 import { TraceBuilder, runtimeFailure } from "../trace.js";
-import { UNIT, cloneValue, releaseVector, byteVectorValue, vectorStorage, stringValue, toJsonValue, } from "../values.js";
+import { UNIT, cloneValue, releaseVector, byteVectorValue, vectorStorage, vectorItems, vectorLength, vectorElement, stringValue, toJsonValue, } from "../values.js";
 import { runtimeTag, staticOperations } from "./package.js";
 import { StructuralRenderer } from "./structural.js";
 import { timestampBinary } from "./timestamp.js";
@@ -26,6 +26,11 @@ import { AdmittedPackage } from "./validate.js";
 import { HeapExceeded, ManagedBudget, ManagedLayouts, } from "./managed-budget.js";
 const DEFAULT_STEP_BUDGET = 1_000_000;
 const DEFAULT_ACTOR_STOP_NS = 5_000_000_000;
+/// Deepest activation a task may reach below its root before a call fails
+/// with `StackOverflow`. HEW-SPEC-2026 §2.2 guarantees 10,000 frames. Twice
+/// that matches what a native stack admits for small frames and leaves an
+/// unbounded recursion failing well inside the default step budget.
+const MAX_FRAME_DEPTH = 20_000;
 /// Ends the run. The status is already recorded on the trace.
 class Halt extends Error {
     status;
@@ -404,6 +409,7 @@ class ExecutorV1 {
             fault: null,
             parked: [],
             caller,
+            depth: caller ? caller.depth + 1 : 0,
             result,
             normal: normal ?? undefined,
             unwind,
@@ -523,8 +529,8 @@ class ExecutorV1 {
                         (row.kind === "vector" ||
                             row.kind === "array" ||
                             row.kind === "slice")
-                        ? value.items.map((item) => this.managed.copy(item, row.element))
-                        : value.items;
+                        ? vectorItems(value).map((item) => this.managed.copy(item, row.element))
+                        : vectorItems(value);
                     if (appended?.length) {
                         if (row.kind !== "vector" &&
                             row.kind !== "array" &&
@@ -538,6 +544,8 @@ class ExecutorV1 {
                     budget.checkMutation(value, {
                         ...value,
                         items,
+                        offset: 0,
+                        length: undefined,
                         storage: { ...storage, capacity, items, owners: 1 },
                     }, detached);
                 }
@@ -1695,7 +1703,13 @@ class ExecutorV1 {
             case "checked.binary": {
                 const failure = checkedFailure(term.binary_op, this.read(act, term.lhs), this.read(act, term.rhs), term.ty);
                 if (failure) {
-                    const edge = term.failures.find((candidate) => candidate.trap === failure);
+                    // Earlier v1 packages fold the signed minimum by -1 into their
+                    // overflow edge, so they keep the IntegerOverflow trap their
+                    // compiler emitted.
+                    const edge = term.failures.find((candidate) => candidate.trap === failure) ??
+                        (failure === "signed_min_div_neg_one"
+                            ? term.failures.find((candidate) => candidate.trap === "integer_overflow")
+                            : undefined);
                     if (!edge) {
                         throw new Error(`checked.binary names no ${failure} edge`);
                     }
@@ -1988,6 +2002,26 @@ class ExecutorV1 {
                     tag: deadline ? term.deadline_variant : term.fault_variant,
                     payload: [stringValue(faultRecoveryMessage(fault))],
                 };
+                // Scope recovery must preserve the original fault even when the
+                // current actor cannot retain its diagnostic text. Preflight the same
+                // managed graph that completion will retain, then use the canonical
+                // empty string on refusal without publishing an uncharged owner.
+                const result = term.result?.value;
+                const type = result == null ? undefined : act.managedTypes.get(result);
+                const budget = result != null && act.owned.has(result)
+                    ? act.context.actor?.budget
+                    : undefined;
+                if (budget && type != null) {
+                    try {
+                        this.managed.stampGraph({ value, type });
+                        budget.check([{ value, type }]);
+                    }
+                    catch (error) {
+                        if (!(error instanceof HeapExceeded))
+                            throw error;
+                        value.payload[0] = stringValue("");
+                    }
+                }
                 act.fault = null;
                 if (act.context.actor)
                     act.context.actor.crashing = null;
@@ -2359,13 +2393,13 @@ class ExecutorV1 {
         if (operation === "Len") {
             this.completeShim(act, term, {
                 kind: "i64",
-                value: BigInt(view.items.length),
+                value: BigInt(vectorLength(view)),
             });
             return;
         }
         if (index?.kind !== "i64")
             throw new Error("pool operation has no index");
-        const value = view.items[Number(index.value)];
+        const value = vectorElement(view, Number(index.value));
         if (operation === "Get") {
             this.completeShim(act, term, this.variant(term.result_shape, value ? "OptionSome" : "OptionNone", value ? [value] : []));
             return;
@@ -2402,7 +2436,7 @@ class ExecutorV1 {
             }, (fault) => {
                 this.raiseFault(act, fault, term.unwind);
                 this.scheduler.enqueue(act.context.id, () => this.runFrame(act));
-            });
+            }, act.context.actor?.rcOwner ?? null, false, undefined, act);
             act.context.cancel = (fault) => callback.cancel?.(fault);
         };
         continueRendering();
@@ -3015,6 +3049,16 @@ class ExecutorV1 {
                 return;
             }
             case "Safepoint": {
+                // A function's entry safepoint is its stack check (HEW-SPEC-2026
+                // §2.2): past the frame limit the call fails with `StackOverflow`
+                // and its parameters follow the cancellation cleanup.
+                if (term.cancel &&
+                    act.depth > MAX_FRAME_DEPTH &&
+                    act.block.id === act.fn.entry) {
+                    act.fault = { kind: "trap", trap: "stack_overflow" };
+                    this.takeEdge(act, term.cancel);
+                    return;
+                }
                 if (act.context.pollSuppression) {
                     this.takeEdge(act, term.resumes[0]);
                     return;
@@ -3816,7 +3860,11 @@ class ExecutorV1 {
             reply: { value: envelope, type: provider.reply },
         };
     }
-    invokeFrame(actor, callable, args, returned, failed, rcOwner = actor?.rcOwner ?? null, inline = false, retainedBy) {
+    invokeFrame(actor, callable, args, returned, failed, rcOwner = actor?.rcOwner ?? null, inline = false, retainedBy, 
+    // The activation this frame runs on behalf of. Its depth carries on, so a
+    // recursion through runtime callbacks reaches the frame limit as a direct
+    // one does.
+    invoker = retainedBy) {
         const context = {
             id: actor?.id ?? "actor:root",
             actor,
@@ -3834,6 +3882,8 @@ class ExecutorV1 {
             },
         };
         const frame = this.activate(this.functionAt(callable), args, null, null, undefined, null, context);
+        if (invoker)
+            frame.depth = invoker.depth + 1;
         retainedBy?.managedChildren.add(frame);
         let cancelled = null;
         context.cancel = (fault = { kind: "panic", message: "task cancelled", cancelled: true }) => {
@@ -4374,27 +4424,32 @@ class ExecutorV1 {
                 if (isPool && count?.kind !== "i64")
                     throw new Error("pool construction has no count");
                 const configured = isPool ? args.slice(0, -1) : args;
-                const initial = layout.backoff
-                    ? configured[configured.length - 2]
-                    : undefined;
-                const maximum = layout.backoff
-                    ? configured[configured.length - 1]
-                    : undefined;
-                const backoff = initial?.kind === "i64" && maximum?.kind === "i64"
-                    ? { initial: initial.value, maximum: maximum.value }
-                    : null;
-                const validBackoff = !layout.backoff ||
-                    (backoff !== null &&
-                        backoff.initial > 0n &&
-                        backoff.maximum >= backoff.initial);
-                const config = layout.backoff ? configured.slice(0, -2) : configured;
+                // Config, then each backoff child's `(initial, maximum)` pair in
+                // declaration order.
+                const pairs = layout.children.filter((child) => child.backoff).length;
+                const config = configured.slice(0, configured.length - 2 * pairs);
+                let pair = config.length;
+                const declared = layout.children.map((child) => {
+                    if (!child.backoff)
+                        return null;
+                    const initial = configured[pair];
+                    const maximum = configured[pair + 1];
+                    pair += 2;
+                    return initial?.kind === "i64" && maximum?.kind === "i64"
+                        ? { initial: initial.value, maximum: maximum.value }
+                        : undefined;
+                });
+                const validBackoff = declared.every((backoff) => backoff === null ||
+                    (backoff !== undefined &&
+                        ((backoff.initial === 0n && backoff.maximum === 0n) ||
+                            (backoff.initial > 0n && backoff.maximum >= backoff.initial))));
                 if (!validBackoff ||
                     (count?.kind === "i64" &&
                         (count.value <= 0n || count.value > 2147483647n))) {
                     const fault = {
                         kind: "panic",
                         message: !validBackoff
-                            ? "supervisor backoff requires positive initial and maximum >= initial"
+                            ? "supervisor backoff requires positive initial and maximum >= initial, or both zero"
                             : "supervisor pool count must be between 1 and 2147483647",
                     };
                     this.running = false;
@@ -4423,7 +4478,7 @@ class ExecutorV1 {
                     teardownChild: null,
                     teardownCancelTimer: null,
                     restartTimes: [],
-                    backoff,
+                    backoffs: declared.flatMap((backoff) => Array.from({ length: members }, () => backoff ?? null)),
                     restartDelays: new Map(),
                     restartTimers: new Map(),
                     closed: [],
@@ -5238,7 +5293,9 @@ class ExecutorV1 {
                                     ? "CrashKindTimerOverdue"
                                     : code === 213
                                         ? "CrashKindHandlerFailed"
-                                        : "CrashKindFault"),
+                                        : code === 215
+                                            ? "CrashKindStackOverflow"
+                                            : "CrashKindFault"),
                             payload: [],
                         },
                         stringValue(String(message)),
@@ -5420,24 +5477,38 @@ class ExecutorV1 {
             return;
         }
         if (owner.restartBusy) {
-            owner.pendingRestarts.push({ child, debts });
+            owner.pendingRestarts.push({
+                child,
+                debts,
+                incarnation: owner.children[child] ?? null,
+            });
             return;
         }
         const now = this.trace.virtualTimeMs;
-        if (owner.backoff && debts.length > 0 && !delayElapsed) {
+        const backoff = owner.backoffs[child];
+        if (backoff && backoff.initial > 0n && debts.length > 0 && !delayElapsed) {
             const previous = owner.restartDelays.get(child);
             const healthy = previous?.publishedAt != null &&
                 now - previous.publishedAt >= owner.layout.window_secs * 1000;
-            const doubled = previous ? previous.delay * 2n : owner.backoff.initial;
+            const doubled = previous ? previous.delay * 2n : backoff.initial;
             const delay = !previous || healthy
-                ? owner.backoff.initial
-                : doubled < owner.backoff.maximum
+                ? backoff.initial
+                : doubled < backoff.maximum
                     ? doubled
-                    : owner.backoff.maximum;
+                    : backoff.maximum;
             owner.restartDelays.set(child, { delay, publishedAt: null });
             owner.recovering.add(child);
             owner.restartTimers.set(child, this.scheduler.after(delay, () => {
                 owner.restartTimers.delete(child);
+                // A group restart that already replaced this role recovered its
+                // fault; restarting again would tear down a healthy group and
+                // charge the budget twice.
+                if (owner.restartDelays.get(child)?.publishedAt != null) {
+                    for (const debt of debts)
+                        this.faultDebts.delete(debt);
+                    this.wakeRoles();
+                    return;
+                }
                 this.restartChild(owner, child, debts, true);
             }));
             return;
@@ -5484,11 +5555,16 @@ class ExecutorV1 {
             if (index === undefined) {
                 for (const debt of debts)
                     this.faultDebts.delete(debt);
-                for (const pending of owner.pendingRestarts.filter((pending) => affected.includes(pending.child))) {
+                // This group replaced a queued crash's incarnation, which recovers it.
+                // A replacement that crashed after its own publication still needs
+                // its restart.
+                const replaced = (pending) => affected.includes(pending.child) &&
+                    owner.children[pending.child] !== pending.incarnation;
+                for (const pending of owner.pendingRestarts.filter(replaced)) {
                     for (const debt of pending.debts)
                         this.faultDebts.delete(debt);
                 }
-                owner.pendingRestarts = owner.pendingRestarts.filter((pending) => !affected.includes(pending.child));
+                owner.pendingRestarts = owner.pendingRestarts.filter((pending) => !replaced(pending));
                 owner.restartBusy = false;
                 this.wakeRoles();
                 const pending = owner.pendingRestarts.shift();
@@ -5500,6 +5576,12 @@ class ExecutorV1 {
                 const delay = owner.restartDelays.get(index);
                 if (delay)
                     delay.publishedAt = this.trace.virtualTimeMs;
+                // The crashed role's replacement is the recovery that settles its
+                // fault, as natively; a later sibling's cancelled start does not
+                // reopen it.
+                if (index === child)
+                    for (const debt of debts)
+                        this.faultDebts.delete(debt);
                 start();
             }, () => {
                 owner.restartBusy = false;
@@ -5828,15 +5910,19 @@ function faultInfo(fault) {
             return [-2, "Deadline"];
         return [212, "UserPanic"];
     }
-    return {
-        integer_overflow: [201, "IntegerOverflow"],
-        divide_by_zero: [202, "DivideByZero"],
-        shift_out_of_range: [204, "ShiftOutOfRange"],
-        vector_bounds: [205, "IndexOutOfBounds"],
-        actor_refused: [-4, "Refused"],
-        heap_exceeded: [200, "HeapExceeded"],
-    }[fault.trap];
+    return TRAP_FAULTS[fault.trap];
 }
+/// The native exit reason each package trap reports, as code and name.
+const TRAP_FAULTS = {
+    integer_overflow: [201, "IntegerOverflow"],
+    divide_by_zero: [202, "DivideByZero"],
+    signed_min_div_neg_one: [203, "SignedMinDivNegOne"],
+    shift_out_of_range: [204, "ShiftOutOfRange"],
+    vector_bounds: [205, "IndexOutOfBounds"],
+    actor_refused: [-4, "Refused"],
+    heap_exceeded: [200, "HeapExceeded"],
+    stack_overflow: [215, "StackOverflow"],
+};
 function faultApplicationMessage(fault) {
     return fault.kind === "panic" &&
         (fault.cancelled || fault.deadline || fault.timerOverdue)
@@ -6034,7 +6120,7 @@ function toComparable(value) {
         case "enum":
             return [value.tag, value.payload.map(toComparable)];
         case "vector":
-            return value.items.map(toComparable);
+            return vectorItems(value).map(toComparable);
         case "rc":
             return "Rc";
         case "weak":
@@ -6074,6 +6160,8 @@ function trapMessage(trap) {
             return "integer overflow";
         case "divide_by_zero":
             return "divide by zero";
+        case "signed_min_div_neg_one":
+            return "signed minimum divided by -1";
         case "shift_out_of_range":
             return "shift amount out of range";
         case "vector_bounds":
@@ -6082,6 +6170,8 @@ function trapMessage(trap) {
             return "delivery refused by interceptor";
         case "heap_exceeded":
             return "actor heap limit exceeded";
+        case "stack_overflow":
+            return "stack overflow";
     }
 }
 /// The operand type the package records. `isize` and `usize` are 64-bit in the
@@ -6131,8 +6221,16 @@ function checkedFailure(op, lhs, rhs, ty) {
         return null;
     }
     const scalar = intTy(ty);
-    if ((op === "Divide" || op === "Modulo") && rhs.value === 0n) {
-        return "divide_by_zero";
+    if (op === "Divide" || op === "Modulo") {
+        if (rhs.value === 0n)
+            return "divide_by_zero";
+        // Both the quotient and the remainder of the signed minimum by -1 trap,
+        // although the remainder alone would be representable.
+        if (scalar.signed &&
+            rhs.value === -1n &&
+            lhs.value === -(1n << (scalar.bits - 1n))) {
+            return "signed_min_div_neg_one";
+        }
     }
     if ((op === "Shl" || op === "Shr") &&
         (rhs.value < 0n || rhs.value >= scalar.bits)) {
@@ -6316,8 +6414,8 @@ function equals(lhs, rhs) {
             lhs.payload.every((field, at) => equals(field, rhs.payload[at])));
     }
     if (lhs.kind === "vector" && rhs.kind === "vector") {
-        return (lhs.items.length === rhs.items.length &&
-            lhs.items.every((item, at) => equals(item, rhs.items[at])));
+        return (vectorLength(lhs) === vectorLength(rhs) &&
+            vectorItems(lhs).every((item, at) => equals(item, vectorElement(rhs, at))));
     }
     return canonical(lhs) === canonical(rhs);
 }

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

@@ -776,7 +776,7 @@ export type RuntimeCallFamily = {
 } | "VecRemoveAtBool" | "VecRemoveAtLayout" | "VecRemoveAtOwned" | "VecSetBool" | "VecSetLayout" | "VecSetOwned" | "VecSetOwnedMove" | {
     VecSliceRange: VecSliceElem;
 } | "VtableDispatchPanicOnOob";
-export type RuntimeVariantRole = "CrashKindFault" | "CrashKindHeapExceeded" | "CrashKindPartitionDetected" | "CrashKindHandlerFailed" | "CrashKindTimerOverdue" | "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorRefused" | "CallerActor" | "CallerTask" | "CallerTimer" | "CallerNode" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorMessageTooLarge" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorUnauthorized" | "SendErrorInvalidMessage" | "SendErrorMessageTooLarge" | "SendErrorTimedOut" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
+export type RuntimeVariantRole = "CrashKindFault" | "CrashKindHeapExceeded" | "CrashKindPartitionDetected" | "CrashKindHandlerFailed" | "CrashKindTimerOverdue" | "CrashKindStackOverflow" | "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorRefused" | "CallerActor" | "CallerTask" | "CallerTimer" | "CallerNode" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorMessageTooLarge" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorUnauthorized" | "SendErrorInvalidMessage" | "SendErrorMessageTooLarge" | "SendErrorTimedOut" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
 export type SafepointDetail = {
     budget: number;
 };
@@ -865,6 +865,11 @@ export type SupervisorChild = {
     stop_ns?: number | null;
     stop_config?: number | null;
     is_pool?: boolean;
+    /**
+     * Construction transfers this child's effective restart delay as an
+     * `(initial, maximum)` argument pair after the config, in declaration order.
+     */
+    backoff?: boolean;
     spawn: number;
 };
 export type SupervisorPoolOp = "Len" | "Member" | "Get";
@@ -873,7 +878,6 @@ export type SupervisorShape = {
     strategy: RestartStrategy;
     max_restarts: number;
     window_secs: number;
-    backoff?: boolean;
     children: Array<SupervisorChild>;
     startup_order?: Array<number>;
 };
@@ -1141,7 +1145,7 @@ export type TermV1 = {
 })));
 export type TimerSendPolicy = "reject" | "drop_newest";
 export type TimestampBinaryOp = "Add" | "Subtract";
-export type TrapName = "heap_exceeded" | "integer_overflow" | "divide_by_zero" | "shift_out_of_range" | "vector_bounds" | "actor_refused";
+export type TrapName = "heap_exceeded" | "integer_overflow" | "divide_by_zero" | "signed_min_div_neg_one" | "shift_out_of_range" | "vector_bounds" | "actor_refused" | "stack_overflow";
 export type ValueCapability = {
     id: number;
     capability: Capability;

package/dist/interpreter/v1/managed-budget.js

@@ -1,4 +1,4 @@
-import { vectorStorage } from "../values.js";
+import { vectorElement, vectorItems, vectorLength, vectorStorage, } from "../values.js";
 import { cloneEncoding } from "./encoding-storage.js";
 const U64_MAX = 0xffffffffffffffffn;
 export class HeapExceeded extends Error {
@@ -128,12 +128,14 @@ export class ManagedLayouts {
                 if (value.kind !== "vector")
                     throw new Error("managed copy has no sequence");
                 const storage = vectorStorage(value);
-                if (row.share_on_copy && value.items.length)
+                if (row.share_on_copy && vectorLength(value))
                     return value;
-                const items = value.items.map((item) => this.copy(item, row.element));
+                const items = vectorItems(value).map((item) => this.copy(item, row.element));
                 return {
                     ...value,
                     items,
+                    offset: 0,
+                    length: undefined,
                     storage: { ...storage, items, capacity: items.length, owners: 1 },
                 };
             }
@@ -274,7 +276,10 @@ export class ManagedLayouts {
                         throw new Error("managed sequence has no backing");
                     const storage = value.storage ?? vectorStorage(value);
                     if (storage.capacity)
-                        allocation(storage, this.width(row.element, storage.capacity), () => storage.items.forEach((item) => visit(item, row.element)));
+                        allocation(storage, this.width(row.element, storage.capacity), () => {
+                            for (let index = 0; index < vectorLength(value); index++)
+                                visit(vectorElement(value, index), row.element);
+                        });
                     return;
                 }
                 case "aggregate":