@hew-lang/sandbox-vm 0.9.3 → 0.10.0

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

@@ -1,7 +1,9 @@
-import type { TermV1, VariantShape, RuntimeVariantRole } from "./instructions.generated.js";
-export type { Own, BoundaryDecision, TrapName, SpanV1, BoundaryOperand, Edge, ValueDef, CallResult, OpV1, OpName, TermV1, TermName, SwitchArm, CheckedFailure, RequestShapes, ActorProtocol, ActorOperation, RuntimeFamilyEntry, AggregateShape, VariantCase, VariantShape, RuntimeVariantRole, ExternEntry, PlaceDecl, ValueCapability, ValueComponentCapabilities, ClosureShape, VtableShape, FunctionV1, BlockV1, EntryPlan, ActorShape, SupervisorShape, PackageV1, Resource, StructuralRecipe, } from "./instructions.generated.js";
+import type { TermV1, BlockV1, OpV1, VariantShape, RuntimeVariantRole } from "./instructions.generated.js";
+export type { Own, BoundaryDecision, TrapName, SpanV1, BoundaryOperand, Edge, ValueDef, CallResult, OpV1, OpName, TermV1, TermName, SwitchArm, CheckedFailure, RequestShapes, ActorProtocol, ActorOperation, RuntimeFamilyEntry, AggregateShape, VariantCase, VariantShape, RuntimeVariantRole, ExternEntry, PlaceDecl, ValueCapability, ValueComponentCapabilities, ClosureShape, VtableShape, FunctionV1, BlockV1, EntryPlan, ActorShape, SupervisorShape, PackageV1, Resource, StructuralRecipe, ManagedType, } from "./instructions.generated.js";
 export type Operand = number;
 export type CallShape = Pick<Extract<TermV1, {
     op: "call";
 }>, "args" | "result" | "normal" | "unwind" | "request_shapes">;
 export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;
+/** Static inventory includes a checked operation; execution follows its edge. */
+export declare function staticOperations(block: BlockV1): Iterable<OpV1>;

package/dist/interpreter/v1/package.js

@@ -7,3 +7,9 @@ export function runtimeTag(shape, role) {
         throw new Error(`variant shape ${shape.id} has no checked ${role} tag`);
     return tag;
 }
+/** Static inventory includes a checked operation; execution follows its edge. */
+export function* staticOperations(block) {
+    yield* block.ops;
+    if (block.term.op === "materialize")
+        yield block.term.operation;
+}

package/dist/interpreter/v1/pipes.d.ts

@@ -1,11 +1,22 @@
 import { type VmValue } from "../values.js";
 interface PendingRead {
-    complete(value: VmValue | null, fault: string | null): void;
+    complete(value: VmValue | null, fault: string | null, released?: () => void): void;
+}
+interface Envelope {
+    value: VmValue;
+    release?: () => void;
+}
+interface Receiver {
+    owner: object;
+    acquire(envelope: Envelope): () => void;
+    refused(): void;
 }
 export declare class Pipes {
     private readonly pairs;
     private readonly halves;
     private next;
+    private managedReceivers;
+    get hasManagedReceivers(): boolean;
     create(id: string, capacity: number): VmValue;
     freePair(pair: VmValue): void;
     extract(pair: VmValue, kind: "sink" | "stream"): VmValue;
@@ -14,6 +25,11 @@ export declare class Pipes {
     cloneSink(value: VmValue): VmValue;
     isClosed(value: VmValue): boolean;
     close(value: VmValue, fault?: string | null): VmValue[];
+    finishClose(value: VmValue): void;
+    /** Called only after ownership acquisition succeeds. The receiving half
+     * carries queued envelopes; producer aliases never acquire them. */
+    bind(value: VmValue, receiver?: Receiver): void;
+    private admit;
     peerClosed(value: VmValue): boolean;
     readable(value: VmValue): boolean;
     observe(value: VmValue, changed: () => void): () => void;
@@ -21,5 +37,12 @@ export declare class Pipes {
     receive(value: VmValue, park: boolean, complete: PendingRead["complete"]): () => void;
     private flush;
     private notify;
+    /** Only the unique receiving half owns admitted typed envelopes. */
+    managedRetained(value: VmValue): {
+        identity: object;
+        queued: readonly {
+            value: VmValue;
+        }[];
+    };
 }
 export {};

package/dist/interpreter/v1/pipes.js

@@ -1,9 +1,14 @@
+import { HeapExceeded } from "./managed-budget.js";
 /// The VM's one bounded pipe substrate. Selection observes readiness; only
 /// the winning receive removes an item. Values transfer without a snapshot.
 export class Pipes {
     pairs = new Map();
     halves = new Map();
     next = 0;
+    managedReceivers = 0;
+    get hasManagedReceivers() {
+        return this.managedReceivers !== 0;
+    }
     create(id, capacity) {
         this.pairs.set(id, {
             capacity,
@@ -65,11 +70,58 @@ export class Pipes {
         }
         else {
             half.pipe.readerOpen = false;
-            discarded.push(...half.pipe.queue.splice(0));
+            if (half.pipe.receiver)
+                this.managedReceivers--;
+            half.pipe.receiver = undefined;
+            for (const item of half.pipe.queue.splice(0)) {
+                discarded.push(item.value);
+                if (item.release)
+                    (half.retiring ??= []).push(item.release);
+            }
         }
         this.flush(half.pipe);
         return discarded;
     }
+    finishClose(value) {
+        if (value.kind !== "stream" && value.kind !== "sink")
+            return;
+        for (const release of this.halves
+            .get(value.channelId)
+            ?.retiring?.splice(0) ?? [])
+            release();
+    }
+    /** Called only after ownership acquisition succeeds. The receiving half
+     * carries queued envelopes; producer aliases never acquire them. */
+    bind(value, receiver) {
+        const half = this.get(value);
+        if (half.kind !== "stream" || half.pipe.receiver?.owner === receiver?.owner)
+            return;
+        this.managedReceivers += Number(!!receiver) - Number(!!half.pipe.receiver);
+        half.pipe.receiver = receiver;
+        for (const envelope of half.pipe.queue) {
+            const release = receiver?.acquire(envelope);
+            envelope.release?.();
+            envelope.release = release;
+        }
+    }
+    admit(pipe, value) {
+        const envelope = { value };
+        try {
+            envelope.release = pipe.receiver?.acquire(envelope);
+            return envelope;
+        }
+        catch (error) {
+            if (!(error instanceof HeapExceeded))
+                throw error;
+            // Acquisition is atomic. A refused recipient follows its existing
+            // checked failure path while the producer still owns the item.
+            pipe.readerOpen = false;
+            pipe.fault = "actor heap limit exceeded";
+            pipe.receiver?.refused();
+            this.flush(pipe);
+            return null;
+        }
+    }
     peerClosed(value) {
         return !this.get(value).pipe.readerOpen;
     }
@@ -94,11 +146,21 @@ export class Pipes {
             return () => { };
         }
         if (pipe.reading.length > 0) {
-            pipe.reading.shift().complete(item, null);
+            const envelope = this.admit(pipe, item);
+            if (!envelope) {
+                complete(1);
+                return () => { };
+            }
+            pipe.reading.shift().complete(item, null, envelope.release);
             complete(0);
         }
         else if (pipe.queue.length < pipe.capacity) {
-            pipe.queue.push(item);
+            const envelope = this.admit(pipe, item);
+            if (!envelope) {
+                complete(1);
+                return () => { };
+            }
+            pipe.queue.push(envelope);
             complete(0);
         }
         else if (!park) {
@@ -120,13 +182,21 @@ export class Pipes {
     receive(value, park, complete) {
         const pipe = this.get(value).pipe;
         if (pipe.queue.length > 0) {
-            complete(pipe.queue.shift(), null);
+            const envelope = pipe.queue.shift();
+            complete(envelope.value, null, envelope.release);
             this.flush(pipe);
         }
         else if (pipe.sending.length > 0) {
             const sender = pipe.sending.shift();
-            complete(sender.value, null);
-            sender.complete(0);
+            const envelope = this.admit(pipe, sender.value);
+            if (envelope) {
+                complete(sender.value, null, envelope.release);
+                sender.complete(0);
+            }
+            else {
+                complete(null, pipe.fault);
+                sender.complete(1);
+            }
         }
         else if (pipe.fault !== null ||
             pipe.sinks === 0 ||
@@ -155,11 +225,16 @@ export class Pipes {
             while (pipe.sending.length > 0 &&
                 (pipe.reading.length > 0 || pipe.queue.length < pipe.capacity)) {
                 const sender = pipe.sending.shift();
+                const envelope = this.admit(pipe, sender.value);
+                if (!envelope) {
+                    sender.complete(1);
+                    break;
+                }
                 const reader = pipe.reading.shift();
                 if (reader)
-                    reader.complete(sender.value, null);
+                    reader.complete(sender.value, null, envelope.release);
                 else
-                    pipe.queue.push(sender.value);
+                    pipe.queue.push(envelope);
                 sender.complete(0);
             }
         }
@@ -175,4 +250,12 @@ export class Pipes {
         for (const observer of [...pipe.observers])
             observer();
     }
+    /** Only the unique receiving half owns admitted typed envelopes. */
+    managedRetained(value) {
+        const half = this.get(value);
+        return {
+            identity: half.kind === "stream" ? half.pipe : half,
+            queued: half.open && half.kind === "stream" ? half.pipe.queue : [],
+        };
+    }
 }

package/dist/interpreter/v1/shims.d.ts

@@ -27,6 +27,7 @@ export interface ShimHost {
     writeStdout(text: string): void;
     writeStderr(text: string): void;
     prng: Mt19937;
+    arenaInstanceId(): bigint;
     regexPatterns: readonly string[];
     enumValue(shape: VariantShape, role: RuntimeVariantRole, payload: VmValue[]): VmValue;
 }

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, 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.
@@ -122,7 +122,6 @@ export function resolveRuntime(entry) {
                     });
                 case "GetBorrow":
                 case "TakeFirst":
-                case "Append":
                     return refused(`Vector::${entry.detail}`);
                 default:
                     return ordinary(VECTOR_SHIMS[entry.detail]);
@@ -295,13 +294,19 @@ const UNIT_FAMILIES = {
         host.writeStderr(text(args, 0));
         return UNIT;
     },
-    StringToBytes: (_host, args) => ({
-        kind: "vector",
-        elementType: "u8",
-        items: [...indexed(args, 0).encoded()].map((byte) => int(BigInt(byte))),
-    }),
+    StringToBytes: (_host, args) => byteVectorValue([...indexed(args, 0).encoded()].map((byte) => int(BigInt(byte)))),
     StringToUppercase: (_host, args) => str(text(args, 0).toUpperCase()),
     StringToLowercase: (_host, args) => str(text(args, 0).toLowerCase()),
+    StreamPipe: (host, args) => {
+        const pair = host.newPipe(Number(integer(args, 0)));
+        const fields = [
+            host.pipes.extract(pair, "sink"),
+            host.pipes.extract(pair, "stream"),
+            bool(true),
+        ];
+        host.pipes.freePair(pair);
+        return { kind: "record", typeId: "", fields };
+    },
     StreamPairSink: (host, args) => host.pipes.extract(arg(args, 0), "sink"),
     StreamPairStream: (host, args) => host.pipes.extract(arg(args, 0), "stream"),
     StreamFromGenerator: (host, args) => host.generatorStream(arg(args, 0)),
@@ -440,68 +445,68 @@ const UNIT_FAMILIES = {
     // TextDecoder replaces each maximal invalid subsequence with U+FFFD, as
     // native lossy decoding does.
     BytesDecodeUtf8Lossy: (_host, args) => str(decodeUtf8(arg(args, 0))),
-    BytesNew: () => ({ kind: "vector", elementType: "u8", items: [] }),
-    BytesIsEmpty: (_host, args) => bool(vec(args, 0).items.length === 0),
-    BytesLen: (_host, args) => int(BigInt(vec(args, 0).items.length)),
+    BytesNew: () => byteVectorValue([]),
+    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}`);
         }
         return cloneValue(items[at]);
     },
-    // A native bytes range shares the buffer; a VM value is never aliased, so
-    // a copy is observably the same.
+    // 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 byteVector(items.slice(start, end));
+        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 byteVector(items.slice(start));
+        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, 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));
         return target;
     },
     BytesClear: (_host, args) => {
         const target = vec(args, 0);
-        target.items.length = 0;
-        return target;
+        return clearByteVector(target);
     },
     BytesGet: (host, args, shape) => {
         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])])
@@ -511,7 +516,9 @@ const UNIT_FAMILIES = {
     // append, paired with the removed byte for a pop.
     BytesAppend: (_host, args) => {
         const target = vec(args, 0);
-        target.items.push(...vec(args, 1).items.map(cloneValue));
+        const added = vectorItems(vec(args, 1)).map(cloneValue);
+        mutableVector(target, vectorLength(target) + added.length);
+        target.items.push(...added);
         return target;
     },
     BytesPop: (host, args, shape) => {
@@ -519,6 +526,8 @@ const UNIT_FAMILIES = {
             throw new TypeError("BytesPop names no result shape to build its Option against");
         }
         const target = vec(args, 0);
+        if (vectorLength(target))
+            mutableVector(target);
         const last = target.items.pop();
         return {
             kind: "record",
@@ -645,9 +654,7 @@ const UNIT_FAMILIES = {
     ReplyPayloadFree: refused("ReplyPayloadFree"),
     ReplyWait: refused("ReplyWait"),
     SelectFirst: refused("SelectFirst"),
-    StreamChunks: refused("StreamChunks"),
     StreamForward: refused("StreamForward"),
-    StreamLines: refused("StreamLines"),
     StreamNextLayout: refused("StreamNextLayout"),
     StreamSendLayout: refused("StreamSendLayout"),
     StreamTake: refused("StreamTake"),
@@ -701,11 +708,12 @@ 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);
         [target.items[left], target.items[right]] = [
             target.items[right],
             target.items[left],
@@ -714,13 +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");
         }
         return {
             kind: "record",
             typeId: "",
-            fields: [target, target.items.pop()],
+            fields: [target, takeVectorEnd(target, true)],
         };
     },
     New: () => ({ kind: "vector", elementType: "", items: [] }),
@@ -729,69 +737,83 @@ const VECTOR_SHIMS = {
     // ownership decision SIR proved, so it moves in as it arrives.
     Push: (_host, args) => {
         const target = vec(args, 0);
+        mutableVector(target, vectorLength(target) + 1);
         target.items.push(arg(args, 1));
         return target;
     },
+    Append: (_host, args) => {
+        const target = vec(args, 0);
+        const added = [...vectorItems(vec(args, 1))];
+        if (added.length) {
+            mutableVector(target, vectorLength(target) + added.length, added);
+            target.items.push(...added.map(cloneValue));
+        }
+        return target;
+    },
     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)}`);
         }
-        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 {
-            kind: "vector",
-            elementType: "",
-            items: items.slice(start, end).map(cloneValue),
-        };
+        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 {
-            kind: "vector",
-            elementType: "",
-            items: items.slice(start).map(cloneValue),
-        };
+        return vectorSlice(items.slice(start));
     },
 };
+function vectorSlice(items) {
+    const result = {
+        kind: "vector",
+        elementType: "",
+        items: [],
+    };
+    mutableVector(result, items.length);
+    result.items.push(...items.map(cloneValue));
+    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 { kind: "vector", elementType: "u8", items: items.map(cloneValue) };
+    return byteVectorValue(items.map(cloneValue));
 }
 /// Whether `run` occurs in `items` starting at `at`.
 function runAt(items, run, at) {
@@ -1092,6 +1114,10 @@ function saturatingI64(value) {
 }
 // ── externs ─────────────────────────────────────────────────────────────────
 const EXTERN_SHIMS = {
+    hew_arena_instance_id_new: (host) => ({
+        kind: "i64",
+        value: host.arenaInstanceId(),
+    }),
     hew_semaphore_new: (host, args) => host.semaphores.create(integer(args, 0)),
     hew_semaphore_clone: (host, args) => host.semaphores.clone(arg(args, 0)),
     hew_semaphore_try_acquire: (host, args) => bool(host.semaphores.tryAcquire(arg(args, 0))),
@@ -1204,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];
@@ -1250,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) => {
@@ -294,7 +295,8 @@ export function admitPackage(pkg, bridges = {}) {
             };
         if (actor.exit != null || actor.down != null)
             return unavailable("actor.local_observation");
-        if (actor.max_heap_bytes != null)
+        if (actor.max_heap_bytes != null &&
+            (actor.state_type == null || !pkg.managed_types?.length))
             return unavailable("actor.heap_limit");
     }
     for (const supervisor of pkg.supervisors ?? []) {

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

@@ -12,6 +12,8 @@ export type ValueRequest = {
     kind: "release";
     value: VmValue;
     onFault?: VmValue;
+    retained?: readonly VmValue[];
+    retainedType?: number;
 };
 export type ValueProgram = Generator<ValueRequest, VmValue, VmValue>;
 /** Execute the exact checked plan, including every derived component selection.
@@ -25,4 +27,4 @@ export declare function sharedOperation(operation: Extract<RuntimeContinuation,
  * borrow their owners until every fallible callback has completed. */
 export declare function collectionOperation(pkg: PackageV1, request: Extract<RuntimeContinuation, {
     handler: "collection";
-}>, args: VmValue[], callbacks: number[], shape: number | null | undefined): ValueProgram;
+}>, args: VmValue[], callbacks: number[], shape: number | null | undefined, elementType?: number): ValueProgram;