@hew-lang/sandbox-vm 0.9.3 → 0.10.0

package/dist/interpreter/v1/exec.js

@@ -1,4 +1,5 @@
 import { BrowserDirectories, } from "./browser-directory.js";
+import { encodingStorage, releaseEncoding } from "./encoding-storage.js";
 /// The `hew.sandbox.bytecode.v1` executor.
 ///
 /// The package is a projection of verified ownership SIR, so this executor
@@ -10,8 +11,8 @@ 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, stringValue, toJsonValue, } from "../values.js";
-import { runtimeTag } from "./package.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";
 import { selectedValue, collectionOperation, sharedOperation, } from "./value-operations.js";
@@ -22,8 +23,14 @@ import { DeterministicIds } from "../../scheduler/ids.js";
 import { Mt19937 } from "./mt19937.js";
 import { ShimFault, CODEC_REGISTRATION, decodeUtf8Checked, resolveExtern, resolveRuntime, resolveSuspension, } from "./shims.js";
 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;
@@ -119,6 +126,7 @@ class ExecutorV1 {
     tasks = new Map();
     completedTasks = 0;
     actorIdentity = 0n;
+    arenaIdentity = 0n;
     faultDebts = new Set();
     nextFaultDebt = 0;
     closingResources = new WeakSet();
@@ -128,6 +136,7 @@ class ExecutorV1 {
     terminating = false;
     rootFault = null;
     pkg;
+    managed;
     directories;
     semaphores;
     constructor(admission, trace, stdin, policy, options) {
@@ -136,12 +145,14 @@ class ExecutorV1 {
         this.options = options;
         const pkg = admission.bytecode;
         this.pkg = pkg;
+        this.managed = new ManagedLayouts(pkg.managed_types ?? [], (value, type) => this.managedRetained(value, type));
         this.directories = new BrowserDirectories(options.directoryRoots);
         this.scheduler = new FrameScheduler(trace, policy);
         this.semaphores = new Semaphores((nanos, ready) => this.scheduler.after(nanos, ready));
         this.ids = new DeterministicIds(trace.replay.seed);
         this.host = {
             argv: [...(options.argv ?? ["main.hew"])],
+            arenaInstanceId: () => this.arenaIdentity === 0x7fffffffffffffffn ? 0n : ++this.arenaIdentity,
             unixTimeMillis: () => this.trace.virtualTimeMs,
             monotonicTimeNanos: () => {
                 const millis = this.trace.virtualTimeMs;
@@ -189,6 +200,7 @@ class ExecutorV1 {
                     pending: null,
                     fault: null,
                     receiving: false,
+                    observers: new Set(),
                 });
                 return { kind: "stream", channelId: id };
             },
@@ -226,12 +238,13 @@ class ExecutorV1 {
         this.current = this.activate(this.functionAt(pkg.entry.function), [], null, null, undefined, null, {
             id: "actor:root",
             actor: null,
-            returned: (value) => {
+            returned: (value, released) => {
                 this.completeRoot();
                 this.trace.exitCode =
                     pkg.entry?.exit === "status" && value.kind === "i64"
                         ? Number(value.value)
                         : 0;
+                released();
             },
             failed: (fault) => {
                 this.rootFault = fault;
@@ -288,6 +301,7 @@ class ExecutorV1 {
         this.running = true;
         while (this.running) {
             const act = this.current;
+            act.context.activeFrame = act;
             act.context.cancel = (fault = { kind: "panic", message: "task cancelled", cancelled: true }) => {
                 if (this.scopeDeadline(act, fault) !== fault)
                     act.context.pendingCancellation ??= fault;
@@ -337,29 +351,42 @@ class ExecutorV1 {
             : parentContext;
         const env = new Map();
         for (const [at, param] of fn.params.entries()) {
-            env.set(param.value, ownedRef(args[at] ?? UNIT));
+            env.set(param.value, ownedRef(args[at] ?? UNIT, param.own === "owned" ? executionContext.actor?.budget : undefined, param.managed_type ?? undefined));
         }
         const places = new Map();
         const trivial = new Set();
+        const owned = new Set();
+        const managedTypes = new Map();
         const record = (value) => {
             if (value.own === "none")
                 trivial.add(value.value);
+            if (value.own === "owned")
+                owned.add(value.value);
+            if (value.managed_type != null)
+                managedTypes.set(value.value, value.managed_type);
         };
         fn.params.forEach(record);
         for (const block of fn.blocks) {
             block.params.forEach(record);
-            for (const op of block.ops) {
+            for (const op of staticOperations(block)) {
+                op.definitions?.forEach(record);
                 if ("dst" in op && op.dst != null && op.own === "none")
                     trivial.add(op.dst);
             }
             const term = block.term;
             if ("result" in term && term.result && term.result !== "never")
                 record(term.result);
+            if (term.op === "call" && term.handback)
+                record(term.handback);
             if (term.op === "switch.variant")
                 for (const arm of term.arms)
                     arm.fields.forEach(record);
         }
+        for (const [index, param] of fn.params.entries())
+            if (param.managed_type != null && args[index])
+                this.stampManaged(args[index], param.managed_type, executionContext.actor);
         return {
+            accountActor: executionContext.actor,
             rcOwner: fn.actor_construction
                 ? { blocks: new Set(), closed: false }
                 : (caller?.rcOwner ??
@@ -372,11 +399,17 @@ class ExecutorV1 {
             opIndex: 0,
             env,
             trivial,
+            owned,
+            managedTypes,
+            managedInputs: [],
+            managedCleanup: new Set(),
+            managedChildren: new Set(),
             scopes: new Map(),
             places,
             fault: null,
             parked: [],
             caller,
+            depth: caller ? caller.depth + 1 : 0,
             result,
             normal: normal ?? undefined,
             unwind,
@@ -414,7 +447,11 @@ class ExecutorV1 {
     }
     read(act, id) {
         try {
-            return readRef(this.refOf(act, id));
+            const value = readRef(this.refOf(act, id));
+            const type = act.managedTypes.get(id);
+            if (type != null)
+                this.stampManaged(value, type, act.context.actor);
+            return value;
         }
         catch (error) {
             throw new Error(`${act.fn.name} block ${act.block.id} value ${id}: ${error.message}`);
@@ -424,7 +461,416 @@ class ExecutorV1 {
         if (id === null || id === undefined) {
             return;
         }
-        act.env.set(id, ownedRef(value));
+        const type = act.managedTypes.get(id);
+        if (type != null)
+            this.stampManaged(value, type, act.context.actor);
+        const budget = act.owned.has(id) ? act.context.actor?.budget : undefined;
+        act.env.set(id, ownedRef(value, budget, type));
+    }
+    stampManaged(value, type, actor) {
+        const budget = actor?.budget;
+        this.managed.stamp(value, type);
+        if (value.kind === "rc" &&
+            !value.closed &&
+            value.cell?.owner &&
+            budget &&
+            !value.cell.managedLease) {
+            const row = this.managed.row(type);
+            if (row.kind !== "shared")
+                throw new Error("Rc has no canonical payload descriptor");
+            value.cell.managedPayload = row.payload;
+            value.cell.managedLease = budget.retain({
+                value: { kind: "rc", cell: value.cell, closed: false },
+                type,
+            });
+        }
+        if (value.kind === "task") {
+            const task = this.taskFor(value);
+            task.managedType = type;
+            task.handles.add(value);
+        }
+        if (value.kind === "stream" && !this.generatorStreams.has(value.channelId))
+            this.bindManagedStream(value, type, actor);
+        if (value.kind === "generator")
+            this.generatorFor(value).managedType = type;
+        if (value.kind === "encoding") {
+            value.prepareMutation = budget
+                ? (replacement, detached) => budget.checkMutation(value, replacement, detached)
+                : undefined;
+        }
+        else if (value.kind === "string") {
+            value.prepareGrowth = budget
+                ? (capacity, detached) => budget.checkStringGrowth(value, capacity, detached)
+                : undefined;
+        }
+        else if (value.kind === "map") {
+            value.prepareInsert = budget
+                ? (staged, slot, key, item, copyKey) => {
+                    const row = this.managed.row(type);
+                    if (row.kind !== "map" && row.kind !== "set")
+                        throw new Error("map has no canonical entry descriptor");
+                    const entries = new Map(staged.entries);
+                    entries.set(slot, {
+                        key: copyKey
+                            ? this.managed.copy(key, row.kind === "map" ? row.key : row.element)
+                            : key,
+                        value: item,
+                    });
+                    budget.checkMutation(value, { ...staged, entries });
+                }
+                : undefined;
+        }
+        else if (value.kind === "vector") {
+            value.prepareMutation = budget
+                ? (capacity, detached, appended) => {
+                    const row = this.managed.row(type);
+                    const storage = vectorStorage(value);
+                    let items = detached &&
+                        (row.kind === "vector" ||
+                            row.kind === "array" ||
+                            row.kind === "slice")
+                        ? vectorItems(value).map((item) => this.managed.copy(item, row.element))
+                        : vectorItems(value);
+                    if (appended?.length) {
+                        if (row.kind !== "vector" &&
+                            row.kind !== "array" &&
+                            row.kind !== "slice")
+                            throw new Error("vector append lacks its canonical element type");
+                        items = [
+                            ...items,
+                            ...appended.map((item) => this.managed.copy(item, row.element)),
+                        ];
+                    }
+                    budget.checkMutation(value, {
+                        ...value,
+                        items,
+                        offset: 0,
+                        length: undefined,
+                        storage: { ...storage, capacity, items, owners: 1 },
+                    }, detached);
+                }
+                : undefined;
+        }
+    }
+    frameManagedRoots(frame) {
+        const roots = [];
+        for (const [id, ref] of frame.env) {
+            const type = frame.managedTypes.get(id);
+            if (type != null && frame.owned.has(id) && liveRef(ref))
+                roots.push({ value: readRef(ref), type });
+        }
+        for (const [id, cell] of frame.places) {
+            const type = frame.fn.places[id]?.managed_type;
+            if (type != null && cell.valid)
+                roots.push({ value: cell.value, type });
+        }
+        for (const scope of frame.scopes.values())
+            for (const task of scope.tasks)
+                if (task.managedType != null)
+                    roots.push({
+                        value: { kind: "task", id: task.id },
+                        type: task.managedType,
+                    });
+        for (const lease of frame.managedInputs)
+            roots.push(...(lease.roots ?? []));
+        for (const cleanup of frame.managedCleanup)
+            roots.push(...cleanup.roots);
+        for (const child of frame.managedChildren)
+            roots.push(...this.frameManagedRoots(child.context.activeFrame ?? child));
+        if (frame.caller)
+            roots.push(...this.frameManagedRoots(frame.caller));
+        return roots;
+    }
+    bindManagedStream(value, type, actor) {
+        const row = this.managed.row(type);
+        if (row.kind !== "provider" ||
+            row.provider !== "stream" ||
+            value.kind !== "stream" ||
+            this.generatorStreams.has(value.channelId))
+            return;
+        const budget = actor?.budget;
+        this.pipes.bind(value, budget && actor
+            ? {
+                owner: actor,
+                acquire: (envelope) => {
+                    const lease = budget.retain({
+                        value: envelope.value,
+                        type: row.children[0],
+                        slots: true,
+                        identity: envelope,
+                    });
+                    return () => lease.release();
+                },
+                refused: () => this.failActorBudget(actor),
+            }
+            : undefined);
+    }
+    adoptManaged(root, actor) {
+        if (!this.managed.needsAdoption(root.type))
+            return;
+        this.managed.collect(root, new Map(), undefined, undefined, (value, type) => {
+            this.bindManagedStream(value, type, actor);
+            const row = this.managed.row(type);
+            if (value.kind === "rc" && value.cell && !value.closed) {
+                if (row.kind !== "shared")
+                    throw new Error("Rc has no canonical payload descriptor");
+                const cell = value.cell;
+                if (cell.owner !== actor.rcOwner && !cell.dying) {
+                    cell.owner?.blocks.delete(cell);
+                    cell.owner = actor.rcOwner;
+                    cell.managedPayload = row.payload;
+                    actor.rcOwner.blocks.add(cell);
+                    cell.managedLease = this.rehomeLease(cell.managedLease, actor.budget);
+                    if (!cell.managedLease && actor.budget)
+                        cell.managedLease = actor.budget.retain({ value, type });
+                }
+            }
+            else if (row.kind === "generator")
+                this.rehomeFrame(this.generatorFor(value).frame, actor);
+            else if (value.kind === "task")
+                this.rehomeTask(this.taskFor(value), actor);
+        }, (value, type) => {
+            const row = this.managed.row(type);
+            // Encoding trees and opaque host providers cannot contain receiving
+            // stream handles. This traversal changes queue ownership only;
+            // their payload accounting keeps its separate canonical visitor.
+            return row.kind === "provider" &&
+                ["json", "yaml", "toml", "opaque"].includes(row.provider)
+                ? { identity: value, bytes: 0n, children: [] }
+                : this.managedRetained(value, type);
+        });
+    }
+    rehomeLease(lease, budget) {
+        if (!lease?.roots)
+            return lease;
+        const replacement = this.retainRoots(lease.roots, budget);
+        lease.release();
+        return replacement;
+    }
+    retainRoots(roots, budget) {
+        // Unbounded frames keep typed ownership metadata for a later generator
+        // transfer, without building an allocation graph for an account.
+        return budget?.retainMany(roots) ?? { roots, release() { } };
+    }
+    retainCleanup(frame, roots) {
+        const cleanup = {
+            roots,
+            lease: this.retainRoots(roots, frame.accountActor?.budget),
+        };
+        frame.managedCleanup.add(cleanup);
+        return {
+            roots,
+            release: () => {
+                if (!frame.managedCleanup.delete(cleanup))
+                    return;
+                cleanup.lease.release();
+            },
+        };
+    }
+    rehomeTask(task, actor) {
+        const frame = task.frame?.context.activeFrame ?? task.frame;
+        if (task.budget === actor.budget && frame?.accountActor === actor)
+            return;
+        task.budget = actor.budget;
+        if (frame)
+            this.rehomeFrame(frame, actor);
+        task.managedLease = this.rehomeLease(task.managedLease, actor.budget);
+    }
+    rehomeFrame(frame, actor) {
+        if (frame.accountActor === actor)
+            return;
+        const previous = frame.accountActor;
+        frame.accountActor = actor;
+        frame.rcOwner = actor.rcOwner;
+        frame.context.actor = actor;
+        frame.context.id = actor.id;
+        const cells = new Set();
+        const rehome = (cell) => {
+            if (cells.has(cell))
+                return;
+            cells.add(cell);
+            cell.budget = actor.budget;
+            if (cell.valid && cell.type != null)
+                this.stampManaged(cell.value, cell.type, actor);
+            cell.lease = this.rehomeLease(cell.lease, actor.budget);
+            if (!cell.lease && cell.valid && cell.type != null)
+                cell.lease = actor.budget?.retain({
+                    value: cell.value,
+                    type: cell.type,
+                });
+        };
+        const ref = (value) => {
+            if (value.kind === "cell")
+                rehome(value.cell);
+            else
+                ref(value.parent);
+        };
+        for (const value of frame.env.values())
+            ref(value);
+        for (const cell of frame.places.values())
+            rehome(cell);
+        frame.managedInputs = frame.managedInputs.flatMap((lease) => {
+            const replacement = this.rehomeLease(lease, actor.budget);
+            return replacement ? [replacement] : [];
+        });
+        for (const cleanup of frame.managedCleanup)
+            cleanup.lease = this.rehomeLease(cleanup.lease, actor.budget);
+        for (const child of frame.managedChildren)
+            this.rehomeFrame(child.context.activeFrame ?? child, actor);
+        for (const scope of frame.scopes.values())
+            for (const task of scope.tasks)
+                this.rehomeTask(task, actor);
+        if (frame.caller)
+            this.rehomeFrame(frame.caller, actor);
+        previous?.budget?.changed();
+        actor.budget?.changed();
+    }
+    failActorBudget(actor) {
+        const fault = { kind: "trap", trap: "heap_exceeded" };
+        if (!actor.active)
+            this.crashActor(actor, fault);
+        else {
+            // A suspended turn owns its frame until authored unwind and lexical
+            // task drains finish. Admission must not retire its state underneath it.
+            actor.closing = true;
+            actor.crashing ??= fault;
+            actor.active.pendingCancellation ??= fault;
+            actor.active.cancel?.(fault);
+        }
+    }
+    managedRetained(value, type) {
+        const row = this.managed.row(type);
+        const typed = (value) => ({
+            value,
+            type: this.managed.type(value),
+        });
+        if (row.kind === "generator") {
+            const generator = this.generatorFor(value);
+            return {
+                identity: generator,
+                bytes: BigInt(row.payload_bytes),
+                children: [
+                    typed(generator.callable),
+                    ...this.frameManagedRoots(generator.frame),
+                ],
+            };
+        }
+        if (row.kind === "actor_call") {
+            const task = this.taskFor(value);
+            const reply = !task.taken && !task.fault && task.managedReply;
+            return {
+                identity: task,
+                bytes: reply ? this.managed.width(row.reply) : 0n,
+                children: reply ? [{ value: reply, type: row.reply }] : [],
+            };
+        }
+        if (row.kind !== "provider")
+            throw new Error("managed retained visitor received no provider");
+        switch (row.provider) {
+            case "json":
+            case "yaml":
+            case "toml": {
+                if (value.kind !== "encoding")
+                    throw new Error("managed encoding has no tree");
+                const retained = encodingStorage(value);
+                return {
+                    identity: retained,
+                    bytes: value.value === null ? 0n : retained.bytes,
+                    children: [],
+                };
+            }
+            case "task": {
+                const task = this.taskFor(value);
+                const reply = task.resultInitialized &&
+                    !task.taken &&
+                    !task.fault &&
+                    (!task.actorError || task.actorError === "Failed");
+                const children = task.frame && !task.done
+                    ? this.frameManagedRoots(task.frame.context.activeFrame ?? task.frame)
+                    : [];
+                if (task.callable?.kind === "closure" && !task.done)
+                    children.push(typed(task.callable));
+                if (reply)
+                    children.push({
+                        value: task.managedResult ?? task.value,
+                        type: row.children[0],
+                    });
+                return {
+                    identity: task,
+                    bytes: (task.invocationPending
+                        ? BigInt(row.invocation_slot_bytes ??
+                            (() => {
+                                throw new Error("task invocation has no canonical carrier width");
+                            })())
+                        : 0n) +
+                        this.managed.width(row.children[0]) +
+                        (task.memberBytes ?? 0n),
+                    children,
+                };
+            }
+            case "sink": {
+                if (value.kind !== "sink")
+                    throw new Error("typed sink has no endpoint");
+                const sender = this.senderEndpoints.get(value.channelId);
+                if (sender) {
+                    const children = [
+                        typed(sender.owner.sink),
+                        typed(sender.owner.encoder),
+                    ];
+                    return {
+                        identity: sender.owner,
+                        bytes: children.reduce((bytes, child) => bytes + this.managed.width(child.type), 0n),
+                        children,
+                    };
+                }
+                return {
+                    identity: this.pipes.managedRetained(value).identity,
+                    bytes: 0n,
+                    children: [],
+                };
+            }
+            case "stream": {
+                if (value.kind !== "stream")
+                    throw new Error("typed stream has no endpoint");
+                const adapter = this.generatorStreams.get(value.channelId);
+                if (adapter) {
+                    const generatorType = adapter.generator.managedType;
+                    if (generatorType == null)
+                        throw new Error("generator stream lacks its producer descriptor");
+                    const children = [
+                        {
+                            value: { kind: "generator", id: adapter.generator.id },
+                            type: generatorType,
+                        },
+                    ];
+                    if (adapter.pending)
+                        children.push({
+                            value: adapter.pending,
+                            type: row.children[0],
+                            slots: true,
+                            identity: adapter,
+                        });
+                    return {
+                        identity: adapter,
+                        bytes: this.managed.width(generatorType),
+                        children,
+                    };
+                }
+                const graph = this.pipes.managedRetained(value);
+                return {
+                    identity: graph.identity,
+                    bytes: 0n,
+                    children: graph.queued.map((item) => ({
+                        value: item.value,
+                        type: row.children[0],
+                        slots: true,
+                        identity: item,
+                    })),
+                };
+            }
+            default:
+                throw new HeapExceeded();
+        }
     }
     invalidate(act, id) {
         // A boundary's transfer of a trivial value has no ownership to end. SIR
@@ -476,11 +922,26 @@ class ExecutorV1 {
     /// and a borrow passes the live value.
     boundary(act, operand) {
         const value = this.read(act, operand.value);
+        const budget = act.context.actor?.budget;
+        const type = act.managedTypes.get(operand.value);
+        const transferable = act.context.generator || act.context.retainsTransferableFrame;
+        if (!budget && transferable && type != null)
+            this.managed.stampGraph({ value, type });
         switch (operand.decision) {
             case "copy":
-            case "snapshot":
-                return cloneValue(value);
+            case "snapshot": {
+                if (budget && type != null)
+                    budget.check([{ value: this.managed.copy(value, type), type }]);
+                const copy = cloneValue(value);
+                if (!budget && transferable && type != null)
+                    this.managed.stampGraph({ value: copy, type });
+                if (type != null)
+                    act.managedInputs.push(this.retainRoots([{ value: copy, type }], budget));
+                return copy;
+            }
             case "move":
+                if (type != null)
+                    act.managedInputs.push(this.retainRoots([{ value, type }], budget));
                 this.invalidate(act, operand.value);
                 return value;
             default:
@@ -489,6 +950,24 @@ class ExecutorV1 {
     }
     // ── instructions ─────────────────────────────────────────────────────────
     execute(act, op) {
+        try {
+            this.executeOperation(act, op);
+        }
+        finally {
+            switch (op.op) {
+                case "store.init":
+                case "store.assign":
+                case "load.take":
+                case "destructure":
+                case "variant.destructure":
+                case "destroy_value":
+                case "end_lifetime":
+                case "task_scope.close":
+                    act.context.actor?.budget?.changed();
+            }
+        }
+    }
+    executeOperation(act, op) {
         switch (op.op) {
             case "coverage.hit": {
                 const key = String(op.counter);
@@ -532,8 +1011,10 @@ class ExecutorV1 {
                 return;
             case "destroy_value": {
                 const value = this.read(act, op.value);
+                const type = act.managedTypes.get(op.value);
+                const cleanup = type == null ? undefined : this.retainCleanup(act, [{ value, type }]);
                 this.invalidate(act, op.value);
-                this.releaseOperation(act, value);
+                this.releaseOperation(act, value, () => cleanup?.release());
                 return;
             }
             case "begin_borrow":
@@ -543,20 +1024,34 @@ class ExecutorV1 {
             case "finish_linear_receiver":
                 return;
             case "alloc_place":
-                act.places.set(op.place, { value: UNIT, valid: false });
+                act.places.set(op.place, {
+                    value: UNIT,
+                    valid: false,
+                    budget: act.context.actor?.budget,
+                    type: act.fn.places[op.place]?.managed_type ?? undefined,
+                });
                 return;
             case "store.init":
                 writeRef(this.placeRef(act, op.place), this.read(act, op.value));
+                this.invalidate(act, op.value);
                 return;
             case "store.assign": {
                 const ref = this.placeRef(act, op.place);
                 const replacement = this.read(act, op.value);
                 const previous = liveRef(ref) ? readRef(ref) : UNIT;
+                const type = act.fn.places[op.place]?.managed_type;
+                const cleanup = type == null
+                    ? undefined
+                    : this.retainCleanup(act, [{ value: previous, type }]);
                 // Retire the old owner before invoking user close code. Publish the
                 // replacement after cleanup, including when close records a fault;
                 // the following cleanup.dispatch then drains the new owner once.
                 invalidateRef(ref);
-                this.releaseOperation(act, previous, () => writeRef(ref, replacement));
+                this.releaseOperation(act, previous, () => {
+                    writeRef(ref, replacement);
+                    this.invalidate(act, op.value);
+                    cleanup?.release();
+                });
                 return;
             }
             case "load.copy":
@@ -574,8 +1069,10 @@ class ExecutorV1 {
             case "end_lifetime": {
                 const ref = this.placeRef(act, op.place);
                 const value = liveRef(ref) ? readRef(ref) : UNIT;
+                const type = act.fn.places[op.place]?.managed_type;
+                const cleanup = type == null ? undefined : this.retainCleanup(act, [{ value, type }]);
                 invalidateRef(ref);
-                this.releaseOperation(act, value);
+                this.releaseOperation(act, value, () => cleanup?.release());
                 return;
             }
             case "tuple.make":
@@ -584,6 +1081,7 @@ class ExecutorV1 {
                     typeId: "",
                     fields: op.elements.map((id) => this.read(act, id)),
                 });
+                op.elements.forEach((id) => this.invalidate(act, id));
                 return;
             case "tuple.get":
                 this.define(act, op.dst, cloneValue(fieldsOf(this.read(act, op.tuple))[op.index] ?? UNIT));
@@ -595,6 +1093,7 @@ class ExecutorV1 {
                     shape: op.shape ?? undefined,
                     fields: op.fields.map((id) => this.read(act, id)),
                 });
+                op.fields.forEach((id) => this.invalidate(act, id));
                 return;
             case "aggregate.project_copy":
                 this.define(act, op.dst, cloneValue(fieldsOf(this.read(act, op.aggregate))[op.field] ?? UNIT));
@@ -616,14 +1115,19 @@ class ExecutorV1 {
                     elementType: "",
                     items: op.elements.map((id) => this.read(act, id)),
                 });
+                op.elements.forEach((id) => this.invalidate(act, id));
                 return;
-            case "array.repeat":
+            case "array.repeat": {
+                const seed = this.read(act, op.value);
+                const count = this.arrayRepeatLength(op);
                 this.define(act, op.dst, {
                     kind: "vector",
                     elementType: "",
-                    items: Array.from({ length: op.count ?? 0 }, () => cloneValue(this.read(act, op.value))),
+                    items: Array.from({ length: count }, (_, index) => index === 0 ? seed : cloneValue(seed)),
                 });
+                this.invalidate(act, op.value);
                 return;
+            }
             case "variant.make":
                 this.define(act, op.dst, {
                     kind: "enum",
@@ -632,6 +1136,7 @@ class ExecutorV1 {
                     tag: op.variant,
                     payload: op.fields.map((id) => this.read(act, id)),
                 });
+                op.fields.forEach((id) => this.invalidate(act, id));
                 return;
             case "variant.is":
                 this.define(act, op.dst, {
@@ -691,6 +1196,7 @@ class ExecutorV1 {
                         fields: op.fields.map((id) => this.read(act, id)),
                     },
                 });
+                op.fields.forEach((id) => this.invalidate(act, id));
                 return;
             }
             case "callable.coerce": {
@@ -716,6 +1222,7 @@ class ExecutorV1 {
                     vtable: op.vtable,
                     value: this.read(act, op.value),
                 });
+                this.invalidate(act, op.value);
                 return;
             // The registration reserves the free places the body reaches; the drain
             // order is already the CFG's, so there is nothing to record here.
@@ -771,9 +1278,12 @@ class ExecutorV1 {
                         id: task.id,
                     })),
                 }, () => {
-                    for (const task of group?.tasks ?? [])
-                        this.tasks.delete(task.id);
                     act.scopes.delete(op.scope);
+                    act.context.actor?.budget?.changed();
+                    for (const task of group?.tasks ?? [])
+                        task.scopeAlive = false;
+                    for (const task of group?.tasks ?? [])
+                        this.releaseTaskState(task);
                 });
                 return;
             }
@@ -786,7 +1296,10 @@ class ExecutorV1 {
                     actor: act.context.actor,
                     rcOwner: act.rcOwner,
                     requestDeadline: this.requestDeadline(act),
-                    returned: (value) => this.closeValueAsync(value, null, (fault) => this.finishGenerator(generator, fault), act.context.actor, act.rcOwner),
+                    returned: (value, released) => this.closeValueAsync(value, null, (fault) => {
+                        released();
+                        this.finishGenerator(generator, fault);
+                    }, act.context.actor, act.rcOwner),
                     failed: (fault) => this.finishGenerator(generator, fault),
                 };
                 const generator = {
@@ -807,8 +1320,9 @@ class ExecutorV1 {
                 const scope = act.scopes.get(op.scope);
                 if (!scope)
                     throw new Error("race has no task scope");
-                const members = op.members.map((operand) => {
-                    const member = this.taskFor(this.read(act, operand));
+                const memberValues = op.members.map((operand) => this.read(act, operand));
+                const members = op.members.map((operand, index) => {
+                    const member = this.taskFor(memberValues[index]);
                     this.invalidate(act, operand);
                     if (member.grouped)
                         throw new Error("race reuses a task handle");
@@ -817,7 +1331,8 @@ class ExecutorV1 {
                 });
                 if (!members.length)
                     throw new Error("race requires members");
-                const task = this.newTask();
+                const task = this.newTask(act.context.actor?.budget, act.managedTypes.get(op.dst), BigInt(op.member_slot_bytes) * BigInt(members.length), true);
+                task.members = memberValues;
                 scope.tasks.push(task);
                 let selected = false;
                 let winner = null;
@@ -839,6 +1354,9 @@ class ExecutorV1 {
                             winner = first;
                             value = first.value;
                             first.value = UNIT;
+                            first.taken = true;
+                            task.value = value;
+                            task.resultInitialized = true;
                         }
                     }
                     if (!cancelled) {
@@ -869,13 +1387,18 @@ class ExecutorV1 {
                         .filter((member) => member !== winner)
                         .map((member) => {
                         const result = member.value;
-                        member.value = UNIT;
                         return result;
                     });
                     this.closeValueAsync({ kind: "vector", elementType: "race result", items: losers }, this.faultText(failure), (closeFault) => {
+                        for (const member of members)
+                            if (member !== winner) {
+                                member.value = UNIT;
+                                member.taken = true;
+                            }
                         failure = combineFaults(failure, closeFault);
                         const finish = (releaseFault = null) => {
                             failure = combineFaults(failure, releaseFault);
+                            this.releaseRaceMembers(task);
                             this.settleTask(task, failure ? UNIT : value, failure);
                             for (const changed of [...scope.changed])
                                 changed();
@@ -941,8 +1464,9 @@ class ExecutorV1 {
                 const specialization = op.op === "task.invoke" && "specialization" in op.callee
                     ? op.callee.specialization
                     : null;
-                const task = this.newTask();
+                const task = this.newTask(act.context.actor?.budget, act.managedTypes.get(op.dst), 0n, true);
                 group.tasks.push(task);
+                let releaseReturn = () => { };
                 const settle = (value, fault) => {
                     if (task.done || task.finishing)
                         return;
@@ -955,6 +1479,7 @@ class ExecutorV1 {
                         if (!fault || (fault.kind === "panic" && fault.cancelled))
                             fault = closeFault ?? fault;
                         this.settleTask(task, value, fault);
+                        releaseReturn();
                         if (!task.grouped &&
                             fault &&
                             !(fault.kind === "panic" && fault.cancelled)) {
@@ -1008,9 +1533,11 @@ class ExecutorV1 {
                 const context = {
                     id: task.id,
                     actor: act.context.actor,
+                    retainsTransferableFrame: !!act.context.generator || act.context.retainsTransferableFrame,
                     rcOwner: act.rcOwner,
                     requestDeadline: this.requestDeadline(act),
-                    returned: (value) => {
+                    returned: (value, released) => {
+                        releaseReturn = released;
                         if (dynamicEntry?.receiver_handback &&
                             dynamicReceiver?.kind === "dyn") {
                             if (value.kind !== "record" || value.fields.length !== 2)
@@ -1039,6 +1566,9 @@ class ExecutorV1 {
                     },
                 };
                 const frame = this.activate(this.functionAt(calleeFunction(callable, specialization)), callable.kind === "closure" ? [callable.environment, ...args] : args, null, null, undefined, null, context);
+                task.frame = frame;
+                task.callable = callable;
+                task.invocationPending = true;
                 task.cancel = () => {
                     if (task.done || task.finishing)
                         return;
@@ -1052,6 +1582,8 @@ class ExecutorV1 {
                 this.scheduler.enqueue(task.id, () => {
                     if (task.done || task.finishing)
                         return;
+                    task.invocationPending = false;
+                    task.budget?.changed();
                     this.runFrame(frame);
                 });
                 this.trace.allocateId("task", task.id, act.context.id);
@@ -1091,7 +1623,43 @@ class ExecutorV1 {
     }
     // ── terminators ──────────────────────────────────────────────────────────
     terminate(act, term) {
+        const mutable = [
+            "runtime.call",
+            "extern.call",
+            "value.call",
+            "wire.codec",
+            "suspend",
+        ].includes(term.op);
+        if (mutable)
+            act.context.actor?.budget?.changed();
+        try {
+            this.terminateOperation(act, term);
+        }
+        finally {
+            if (mutable)
+                act.context.actor?.budget?.changed();
+        }
+    }
+    terminateOperation(act, term) {
         switch (term.op) {
+            case "materialize": {
+                const budget = act.context.actor?.budget;
+                try {
+                    if (term.operation.op === "array.repeat")
+                        this.arrayRepeatLength(term.operation);
+                    if (budget)
+                        this.prepareMaterialize(act, term.operation, budget);
+                }
+                catch (error) {
+                    if (!(error instanceof HeapExceeded))
+                        throw error;
+                    this.takeEdge(act, term.failure);
+                    return;
+                }
+                this.execute(act, term.operation);
+                this.takeEdge(act, term.normal);
+                return;
+            }
             case "goto":
                 this.takeEdge(act, term.edge);
                 return;
@@ -1107,6 +1675,11 @@ class ExecutorV1 {
                     throw new Error(`switch.variant has no arm for tag ${tag}`);
                 }
                 this.spread(act, payloadOf(scrutinee), arm.fields);
+                if (act.owned.has(term.scrutinee)) {
+                    this.invalidate(act, term.scrutinee);
+                    this.managed.retire(scrutinee);
+                    act.context.actor?.budget?.changed();
+                }
                 this.takeEdge(act, arm.edge);
                 return;
             }
@@ -1130,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`);
                     }
@@ -1247,12 +1826,30 @@ class ExecutorV1 {
                         return;
                     }
                     case "collection": {
+                        const receiverType = term.args[0] && act.managedTypes.get(term.args[0].value);
+                        const receiverLayout = receiverType == null ? undefined : this.managed.row(receiverType);
+                        const elementType = receiverLayout &&
+                            (receiverLayout.kind === "vector" ||
+                                receiverLayout.kind === "array")
+                            ? receiverLayout.element
+                            : undefined;
                         const args = term.args.map((operand) => this.boundary(act, operand));
-                        const iterator = collectionOperation(this.pkg, registration, args, term.callbacks ?? [], term.result_member_shapes?.[1] ?? term.result_shape);
+                        const iterator = collectionOperation(this.pkg, registration, args, term.callbacks ?? [], term.result_member_shapes?.[1] ?? term.result_shape, elementType);
                         this.runValueProgram(act, term, args, iterator);
                         return;
                     }
                     case "shared": {
+                        if (act.context.actor?.budget &&
+                            (registration.operation === "RcNew" ||
+                                registration.operation === "RcSet")) {
+                            const constructing = registration.operation === "RcNew";
+                            const operand = term.args[constructing ? 0 : 1];
+                            const type = act.managedTypes.get(operand.value);
+                            if (type == null)
+                                throw new Error("Rc payload lacks its typed descriptor");
+                            if (!this.checkRuntimePayload(act, term, constructing ? this.managed.width(type) : 0n, [{ value: this.read(act, operand.value), type }]))
+                                return;
+                        }
                         const args = term.args.map((operand) => this.boundary(act, operand));
                         this.runValueProgram(act, term, args, sharedOperation(registration.operation, args, act.rcOwner, term.shared_payload_type ?? "", (value) => this.variant(term.result_shape, value ? "OptionSome" : "OptionNone", value ? [value] : [])));
                         return;
@@ -1405,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;
@@ -1425,11 +2042,150 @@ class ExecutorV1 {
             }
         }
     }
+    /** Reserve the exact constructor/copy graph before any operand is consumed. */
+    arrayRepeatLength(op) {
+        const type = op.definitions?.[0]?.managed_type;
+        const row = type == null ? undefined : this.managed.row(type);
+        if (row?.kind !== "array")
+            throw new Error("array repeat lacks its canonical length");
+        const count = BigInt(row.length);
+        this.managed.width(row.element, count);
+        if (count > 0xffffffffn)
+            throw new HeapExceeded();
+        return Number(count);
+    }
+    prepareMaterialize(act, op, budget) {
+        const type = op.definitions?.[0]?.managed_type;
+        if (type == null)
+            throw new Error("materialization has no managed result descriptor");
+        const read = (id) => this.read(act, id);
+        const copy = (value) => this.managed.copy(value, type);
+        let value;
+        switch (op.op) {
+            case "const.str":
+                value = stringValue(this.pkg.strings[op.str] ?? "");
+                break;
+            case "const.bytes":
+                value = bytesValue(this.pkg.bytes[op.bytes] ?? []);
+                break;
+            case "copy_value":
+                value = copy(read(op.source));
+                break;
+            case "load.copy":
+                value = copy(readRef(this.placeRef(act, op.place)));
+                break;
+            case "tuple.get":
+                value = copy(fieldsOf(read(op.tuple))[op.index]);
+                break;
+            case "aggregate.project_copy":
+                value = copy(fieldsOf(read(op.aggregate))[op.field]);
+                break;
+            case "variant.project_copy":
+                value = copy(payloadOf(read(op.source))[op.field]);
+                break;
+            case "array.make":
+                value = {
+                    kind: "vector",
+                    elementType: "",
+                    items: op.elements.map(read),
+                };
+                break;
+            case "array.repeat": {
+                const count = this.arrayRepeatLength(op);
+                const row = this.managed.row(type);
+                if (row.kind !== "array")
+                    throw new Error("array repeat lacks its element descriptor");
+                const empty = [];
+                const storage = {
+                    items: empty,
+                    capacity: count,
+                    owners: 1,
+                    bytes: false,
+                    shareOnCopy: row.share_on_copy,
+                };
+                value = { kind: "vector", elementType: "", items: empty, storage };
+                budget.check([{ value, type }]);
+                const seed = read(op.value);
+                storage.items = Array.from({ length: count }, (_, index) => index ? this.managed.copy(seed, row.element) : seed);
+                value.items = storage.items;
+                break;
+            }
+            case "variant.make":
+                value = {
+                    kind: "enum",
+                    typeId: "",
+                    shape: op.shape,
+                    tag: op.variant,
+                    payload: op.fields.map(read),
+                };
+                break;
+            case "closure.make":
+                value = {
+                    kind: "closure",
+                    entries: this.closureAt(op.closure).entries,
+                    specialization: null,
+                    environment: {
+                        kind: "record",
+                        typeId: "",
+                        fields: op.fields.map(read),
+                    },
+                };
+                break;
+            case "dyn.make":
+                value = { kind: "dyn", vtable: op.vtable, value: read(op.value) };
+                break;
+            case "generator.make": {
+                const row = this.managed.row(type);
+                if (row.kind !== "generator")
+                    throw new Error("generator lacks its payload descriptor");
+                const callable = read(op.callable);
+                budget.checkPayload(BigInt(row.payload_bytes), [
+                    { value: callable, type: this.managed.type(callable) },
+                ]);
+                return;
+            }
+            case "task.spawn":
+            case "task.invoke":
+            case "task.race": {
+                const row = this.managed.row(type);
+                if (row.kind !== "provider" || row.provider !== "task")
+                    throw new Error("checked task lacks its canonical provider descriptor");
+                const carrier = op.op === "task.race"
+                    ? BigInt(op.member_slot_bytes) * BigInt(op.members.length)
+                    : BigInt(row.invocation_slot_bytes);
+                const children = [];
+                if (op.op === "task.invoke") {
+                    const operands = [...op.args];
+                    if ("receiver" in op.callee)
+                        operands.push(op.callee.receiver);
+                    for (const operand of operands) {
+                        const type = act.managedTypes.get(operand.value);
+                        if (type == null)
+                            throw new Error("task input lacks its canonical descriptor");
+                        const value = read(operand.value);
+                        children.push({
+                            value: operand.decision === "copy" || operand.decision === "snapshot"
+                                ? this.managed.copy(value, type)
+                                : value,
+                            type,
+                        });
+                    }
+                }
+                budget.checkPayload(this.managed.width(row.children[0]) + carrier, children);
+                return;
+            }
+            default:
+                throw new Error(`unexpected managed materialization ${op.op}`);
+        }
+        budget.check([{ value, type }]);
+    }
     takeEdge(act, edge) {
         // Read every argument before rebinding, so a block that branches to itself
         // with permuted parameters binds the incoming values, not the rebound ones.
         const args = edge.args.map((id) => this.refOf(act, id));
         const target = this.blockAt(act.fn, edge.to);
+        for (const lease of act.managedInputs.splice(0))
+            lease.release();
         for (const [at, param] of target.params.entries()) {
             act.env.set(param.value, args[at] ?? ownedRef(UNIT));
         }
@@ -1459,9 +2215,53 @@ class ExecutorV1 {
             throw error;
         });
     }
-    /// Run a runtime or extern shim. A fault it raises takes the call's `unwind`
-    /// edge so the cleanup the package names runs before the program ends.
+    /** Reserve typed runtime payload before construction or replacement. Refusal
+     * follows the call's existing input ownership and authored cleanup edge. */
+    checkRuntimePayload(act, term, bytes, children) {
+        const budget = act.context.actor?.budget;
+        if (!budget)
+            return true;
+        try {
+            budget.checkPayload(bytes, children);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof HeapExceeded))
+                throw error;
+            const fault = { kind: "trap", trap: "heap_exceeded" };
+            if (this.keepsInputs(term)) {
+                // No new payload exists and none of the consuming inputs has moved.
+                this.raiseFault(act, fault, term.unwind);
+                return false;
+            }
+            const consumed = term.args
+                .filter((operand) => operand.decision === "move")
+                .map((operand) => this.boundary(act, operand));
+            this.running = false;
+            this.closeValueAsync({ kind: "record", typeId: "", fields: consumed }, error.message, (cleanupFault) => {
+                this.raiseFault(act, combineFaults(fault, cleanupFault), term.unwind);
+                this.scheduler.enqueue(act.context.id, () => this.runFrame(act));
+            }, act.context.actor, act.rcOwner, act);
+            return false;
+        }
+    }
+    /// Run a runtime or extern shim through its authored fault continuation.
     callShim(act, term, shim) {
+        const family = term.op === "runtime.call"
+            ? this.pkg.runtime_families[term.family]?.family
+            : undefined;
+        const budget = act.context.actor?.budget;
+        if (budget &&
+            (family === "SinkFromEncoder" || family === "StreamFromGenerator")) {
+            const children = term.args.map((operand) => {
+                const type = act.managedTypes.get(operand.value);
+                if (type == null)
+                    throw new Error("stream adapter input lacks its typed descriptor");
+                return { value: this.read(act, operand.value), type };
+            });
+            if (!this.checkRuntimePayload(act, term, children.reduce((bytes, child) => bytes + this.managed.width(child.type), 0n), children))
+                return;
+        }
         const args = term.args.map((operand) => this.boundary(act, operand));
         // A call that hands back its updated receiver names its value's shape as
         // the pair's second member.
@@ -1477,9 +2277,13 @@ class ExecutorV1 {
             value = shim(this.host, args, shape, aggregate);
         }
         catch (error) {
-            if (error instanceof ShimFault) {
+            if (error instanceof ShimFault || error instanceof HeapExceeded) {
                 this.keepInputs(act, term, args);
-                this.raiseFault(act, { kind: "trap", trap: error.trap, message: error.message }, term.unwind);
+                this.raiseFault(act, {
+                    kind: "trap",
+                    trap: error instanceof HeapExceeded ? "heap_exceeded" : error.trap,
+                    message: error.message,
+                }, term.unwind);
                 return;
             }
             throw error;
@@ -1523,16 +2327,21 @@ class ExecutorV1 {
                 this.keepInputs(act, term, args);
                 this.raiseFault(act, fault, term.unwind);
                 resume();
-            }, act.context.actor, act.rcOwner);
+            }, act.context.actor, act.rcOwner, act);
         };
         const next = (value = UNIT) => {
             let step;
             try {
                 step = iterator.next(value);
+                act.context.actor?.budget?.changed();
             }
             catch (error) {
-                if (error instanceof ShimFault) {
-                    fail({ kind: "trap", trap: error.trap, message: error.message });
+                if (error instanceof ShimFault || error instanceof HeapExceeded) {
+                    fail({
+                        kind: "trap",
+                        trap: error instanceof HeapExceeded ? "heap_exceeded" : error.trap,
+                        message: error.message,
+                    });
                     return;
                 }
                 throw error;
@@ -1546,7 +2355,16 @@ class ExecutorV1 {
             }
             else if (step.value.kind === "release") {
                 const request = step.value;
+                const lease = act.context.actor?.budget ||
+                    act.context.generator ||
+                    act.context.retainsTransferableFrame
+                    ? this.retainCleanup(act, (request.retained ?? [request.value]).map((value) => ({
+                        value,
+                        type: request.retainedType ?? this.managed.type(value),
+                    })))
+                    : undefined;
                 this.closeValueAsync(request.value, this.pipeFault(act), (fault) => {
+                    lease?.release();
                     if (fault) {
                         if (term.op !== "runtime.call" || !term.releases_contents) {
                             fail(fault, request.onFault);
@@ -1557,11 +2375,11 @@ class ExecutorV1 {
                         act.fault ??= fault;
                     }
                     next();
-                }, act.context.actor, act.rcOwner);
+                }, act.context.actor, act.rcOwner, act);
             }
             else {
                 const request = step.value;
-                const child = this.invokeFrame(act.context.actor, request.callee, request.args, next, fail, act.rcOwner);
+                const child = this.invokeFrame(act.context.actor, request.callee, request.args, next, fail, act.rcOwner, false, act);
                 act.context.cancel = (fault) => child.cancel?.(fault);
             }
         };
@@ -1575,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;
@@ -1618,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();
@@ -1629,7 +2447,17 @@ class ExecutorV1 {
             throw new Error(`${term.op} with a "never" result cannot return in the sandbox`);
         }
         if (term.result && term.result !== "never") {
-            this.define(act, term.result.value, value);
+            try {
+                this.define(act, term.result.value, value);
+            }
+            catch (error) {
+                if (!(error instanceof HeapExceeded))
+                    throw error;
+                this.closeValueAsync(value, error.message, (fault) => {
+                    this.raiseFault(act, combineFaults({ kind: "trap", trap: "heap_exceeded" }, fault), "unwind" in term ? term.unwind : null);
+                }, act.context.actor, act.rcOwner);
+                return;
+            }
         }
         this.takeEdge(act, term.normal);
     }
@@ -1675,9 +2503,20 @@ class ExecutorV1 {
                 }
                 const cell = item.value;
                 const payload = cell.value;
+                let payloadLease;
+                if (actor?.budget && cell.managedPayload != null)
+                    payloadLease = actor.budget.retain({
+                        value: payload,
+                        type: cell.managedPayload,
+                        slots: true,
+                        identity: cell,
+                    });
+                cell.managedLease?.release();
+                cell.managedLease = undefined;
                 cell.value = UNIT;
                 blocks.delete(cell);
                 this.closeValueAsync(payload, this.faultText(firstFault), (fault) => {
+                    payloadLease?.release();
                     firstFault = combineFaults(firstFault, fault);
                     release();
                 }, actor, owner);
@@ -1724,7 +2563,39 @@ class ExecutorV1 {
         const caller = act.caller;
         if (!caller) {
             this.running = false;
-            act.context.returned(value);
+            let reply;
+            if (act.context.reply &&
+                act.context.actor?.budget &&
+                act.block.term.op === "return" &&
+                act.block.term.value) {
+                const type = act.managedTypes.get(act.block.term.value.value);
+                if (type == null)
+                    throw new Error("actor reply lacks its managed descriptor");
+                try {
+                    if (type != null)
+                        reply = act.context.actor.budget.retain({
+                            value,
+                            type,
+                            slots: true,
+                        });
+                }
+                catch (error) {
+                    if (!(error instanceof HeapExceeded))
+                        throw error;
+                    this.closeValueAsync(value, error.message, (fault) => {
+                        for (const lease of act.managedInputs.splice(0))
+                            lease.release();
+                        act.context.failed(combineFaults({ kind: "trap", trap: "heap_exceeded" }, fault));
+                    }, act.context.actor, act.rcOwner);
+                    return;
+                }
+            }
+            const inputs = act.managedInputs.splice(0);
+            act.context.returned(value, () => {
+                reply?.release();
+                for (const lease of inputs)
+                    lease.release();
+            });
             return;
         }
         if (!act.normal) {
@@ -1744,6 +2615,8 @@ class ExecutorV1 {
         }
         this.current = caller;
         this.takeEdge(caller, act.normal);
+        for (const lease of act.managedInputs.splice(0))
+            lease.release();
     }
     dynamicEntry(receiver, slot) {
         const table = this.pkg.vtables[receiver.vtable] ??
@@ -1792,6 +2665,8 @@ class ExecutorV1 {
         if (!caller) {
             this.running = false;
             act.context.failed(fault, handback);
+            for (const lease of act.managedInputs.splice(0))
+                lease.release();
             return;
         }
         if (!act.unwind) {
@@ -1811,6 +2686,8 @@ class ExecutorV1 {
         caller.fault = fault;
         this.current = caller;
         this.takeEdge(caller, act.unwind);
+        for (const lease of act.managedInputs.splice(0))
+            lease.release();
     }
     finishConsumedCallable(act, value, done) {
         const callable = act.consumedCallable;
@@ -1850,6 +2727,7 @@ class ExecutorV1 {
                 const generator = act.context.generator;
                 if (!generator || !generator.receive)
                     throw new Error("yield has no generator consumer");
+                generator.frame = act;
                 const value = this.boundary(act, term.inputs[0]);
                 const wake = this.park(act, term);
                 generator.resume = () => wake(UNIT);
@@ -1895,9 +2773,27 @@ class ExecutorV1 {
             case "StreamSend": {
                 const sink = this.boundary(act, term.inputs[0]);
                 const value = this.boundary(act, term.inputs[1]);
+                const type = act.managedTypes.get(term.inputs[1].value);
+                if (type == null)
+                    throw new Error("stream write lacks its typed input descriptor");
+                // The native operation owns one aligned input slot until accepted or
+                // terminal cleanup, independently of the receiving queue's slot.
                 const wake = this.park(act, term);
+                try {
+                    act.managedInputs.push(this.retainRoots([{ value, type, slots: true, identity: {} }], act.context.actor?.budget));
+                }
+                catch (error) {
+                    if (!(error instanceof HeapExceeded))
+                        throw error;
+                    const refused = { kind: "trap", trap: "heap_exceeded" };
+                    this.closeValueAsync(value, error.message, (fault) => wake(UNIT, combineFaults(refused, fault)), act.context.actor, act.rcOwner, act);
+                    return;
+                }
                 const cancel = act.context.cancel;
                 const stop = this.sendStream(sink, value, term.detail.park, act.context.actor, (status, fault) => {
+                    if (status === 0)
+                        for (const lease of act.managedInputs.splice(0))
+                            lease.release();
                     wake(UNIT, fault, status);
                 }, act.rcOwner);
                 act.context.cancel = (fault = { kind: "panic", message: "task cancelled", cancelled: true }) => {
@@ -1915,8 +2811,10 @@ class ExecutorV1 {
                     return;
                 }
                 let cancelWait = () => { };
-                const wake = this.park(act, term, () => cancelWait());
-                cancelWait = this.pipes.receive(stream, term.detail.park, (value, fault) => {
+                let releaseEnvelope = () => { };
+                const wake = this.park(act, term, () => cancelWait(), undefined, () => releaseEnvelope());
+                cancelWait = this.pipes.receive(stream, term.detail.park, (value, fault, released) => {
+                    releaseEnvelope = released ?? (() => { });
                     if (fault !== null)
                         wake(UNIT, { kind: "panic", message: fault });
                     else
@@ -1925,9 +2823,17 @@ class ExecutorV1 {
                 return;
             }
             case "Await": {
-                const task = this.taskFor(this.boundary(act, term.inputs[0]));
+                const handle = this.boundary(act, term.inputs[0]);
+                const task = this.taskFor(handle);
                 let unwatch = () => { };
-                const wake = this.park(act, term, () => unwatch());
+                let resultLease;
+                const wake = this.park(act, term, () => unwatch(), undefined, () => {
+                    resultLease?.release();
+                    task.handles.delete(handle);
+                    this.managed.retire(handle);
+                    task.budget?.changed();
+                    this.releaseTaskState(task);
+                });
                 const ready = () => {
                     if (!task.done) {
                         this.pendingActorWait(act, [task.actorTarget], false, "ask", (fault) => wake(UNIT, fault));
@@ -1937,7 +2843,9 @@ class ExecutorV1 {
                         wake(UNIT, task.fault);
                     else {
                         const value = task.value;
+                        resultLease = this.retainTaskResult(task, act.context.actor?.budget);
                         task.value = UNIT;
+                        task.taken = true;
                         wake(value);
                     }
                 };
@@ -1997,12 +2905,28 @@ class ExecutorV1 {
                 const wake = this.park(act, term, () => unwatch.forEach((remove) => remove()));
                 let cancelTimer;
                 const choose = () => {
-                    const ready = sources.flatMap((value, index) => {
-                        if (value.kind === "stream")
-                            return this.pipes.readable(value) ? [{ index, order: 0 }] : [];
-                        const task = this.taskFor(value);
-                        return task.done ? [{ index, order: task.completedAt }] : [];
-                    });
+                    const ready = [];
+                    for (const [index, value] of sources.entries()) {
+                        if (value.kind === "stream") {
+                            const adapter = this.generatorStreams.get(value.channelId);
+                            if (adapter)
+                                this.pollGeneratorStream(adapter);
+                            const readable = adapter
+                                ? adapter.pending !== null ||
+                                    adapter.generator.done ||
+                                    adapter.closed
+                                : this.pipes.readable(value);
+                            if (readable)
+                                ready.push({ index, order: 0 });
+                        }
+                        else {
+                            const task = this.taskFor(value);
+                            if (task.done)
+                                ready.push({ index, order: task.completedAt });
+                        }
+                        if (ready.length && term.detail.order !== "completion")
+                            break;
+                    }
                     if (term.detail.order === "completion")
                         ready.sort((a, b) => a.order - b.order);
                     if (ready[0]) {
@@ -2022,8 +2946,15 @@ class ExecutorV1 {
                     cancelTimer = this.scheduler.after(duration.value, () => wake({ kind: "i64", value: BigInt(sources.length) }));
                 }
                 sources.forEach((value) => {
-                    if (value.kind === "stream")
-                        unwatch.push(this.pipes.observe(value, choose));
+                    if (value.kind === "stream") {
+                        const adapter = this.generatorStreams.get(value.channelId);
+                        if (adapter) {
+                            adapter.observers.add(choose);
+                            unwatch.push(() => adapter.observers.delete(choose));
+                        }
+                        else
+                            unwatch.push(this.pipes.observe(value, choose));
+                    }
                     else {
                         const task = this.taskFor(value);
                         task.changed.push(choose);
@@ -2118,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;
@@ -2178,6 +3119,10 @@ class ExecutorV1 {
                 let cancelTimer = () => { };
                 const wake = this.park(act, term, () => cancelTimer());
                 cancelTimer = this.scheduler.after(nanos, () => wake(UNIT));
+                // Admission can publish a fault synchronously before this sleep parks.
+                // Deliver that latch after arming, so cancellation also removes the timer.
+                if (act.context.pendingCancellation)
+                    act.context.cancel?.(act.context.pendingCancellation);
                 return;
             }
             default: {
@@ -2203,13 +3148,30 @@ class ExecutorV1 {
                 message: `local actor wait cycle at ${operation}: ${path.map((actor) => actor.identity).join(" -> ")}`,
             });
     }
-    park(act, term, cleanup = () => { }, accepted = () => { }) {
+    park(act, term, cleanup = () => { }, accepted = () => { }, drained = () => { }) {
         this.running = false;
         act.context.parked = true;
         let pending = null;
+        let pendingLease;
         const resume = (value, fault = null, edge = 0) => {
             if (pending)
                 return false;
+            if (!fault &&
+                act.context.actor?.budget &&
+                term.result &&
+                term.result !== "never") {
+                const type = term.result.managed_type;
+                if (type == null)
+                    throw new Error("suspended result lacks its managed descriptor");
+                try {
+                    pendingLease = act.context.actor.budget.retain({ value, type });
+                }
+                catch (error) {
+                    if (!(error instanceof HeapExceeded))
+                        throw error;
+                    fault = { kind: "trap", trap: "heap_exceeded" };
+                }
+            }
             pending = { value, fault, edge };
             act.context.parked = false;
             if (act.context.actor?.active === act.context)
@@ -2236,6 +3198,8 @@ class ExecutorV1 {
                             throw new Error(`${term.kind} has no resume edge`);
                         this.takeEdge(act, edge);
                     }
+                    pendingLease?.release();
+                    drained();
                     this.runFrame(act);
                 };
                 // A close can arrive after readiness but before this frame runs. Keep
@@ -2440,7 +3404,16 @@ class ExecutorV1 {
                 adapter.waiting = undefined;
                 this.closeGenerator(generator, (closeFault) => cancel?.(closeFault ?? fault));
             };
-        if (adapter.receiving)
+        this.pollGeneratorStream(adapter);
+    }
+    /** Readiness drives the same producer as recv but leaves a published item
+     * retained until the winning receive. Losing observations only detach. */
+    pollGeneratorStream(adapter) {
+        const generator = adapter.generator;
+        if (adapter.receiving ||
+            adapter.pending !== null ||
+            generator.done ||
+            adapter.closed)
             return;
         adapter.receiving = true;
         generator.receive = (value, fault) => {
@@ -2457,6 +3430,8 @@ class ExecutorV1 {
                 waiting(value, fault);
             else
                 adapter.pending = value;
+            for (const changed of [...adapter.observers])
+                changed();
         };
         if (generator.started) {
             const resume = generator.resume;
@@ -2499,7 +3474,7 @@ class ExecutorV1 {
             act.fault = combineFaults(act.fault, fault);
             if (!synchronous)
                 this.scheduler.enqueue(act.context.id, () => this.runFrame(act));
-        }, act.context.actor, act.rcOwner);
+        }, act.context.actor, act.rcOwner, act);
         synchronous = false;
         if (!completed)
             this.running = false;
@@ -2537,7 +3512,7 @@ class ExecutorV1 {
         else
             generator.frame.context.cancel?.();
     }
-    closeValueAsync(value, fault, done, actor = this.current.context.actor, rcOwner = actor?.rcOwner ?? this.current.rcOwner) {
+    closeValueAsync(value, fault, done, actor = this.current.context.actor, rcOwner = actor?.rcOwner ?? this.current.rcOwner, retainedBy) {
         const pending = [value];
         let firstFault = null;
         const next = (failure = null) => {
@@ -2546,10 +3521,38 @@ class ExecutorV1 {
             // must disclose that failure instead of publishing a clean end.
             const currentFault = fault ?? this.faultText(actor?.crashing ?? firstFault);
             while (pending.length) {
-                const value = pending.pop();
+                const entry = pending.pop();
+                if ("managedRelease" in entry) {
+                    entry.managedRelease.release();
+                    continue;
+                }
+                if ("taskTaken" in entry) {
+                    entry.taskTaken.value = UNIT;
+                    entry.taskTaken.taken = true;
+                    entry.taskTaken.managedResult = undefined;
+                    entry.taskTaken.managedReply = undefined;
+                    continue;
+                }
+                if ("retire" in entry) {
+                    if (entry.retire.kind === "stream" &&
+                        !this.generatorStreams.has(entry.retire.channelId))
+                        this.pipes.finishClose(entry.retire);
+                    this.managed.retire(entry.retire);
+                    if (entry.retire.kind === "stream")
+                        this.generatorStreams.delete(entry.retire.channelId);
+                    actor?.budget?.changed();
+                    if (entry.retire.kind === "task") {
+                        const task = this.tasks.get(entry.retire.id);
+                        if (task)
+                            this.releaseTaskState(task);
+                    }
+                    continue;
+                }
+                const value = entry;
+                pending.push({ retire: value });
                 switch (value.kind) {
                     case "encoding":
-                        value.value = null;
+                        releaseEncoding(value);
                         break;
                     case "string":
                         value.release();
@@ -2558,6 +3561,21 @@ class ExecutorV1 {
                         if (!value.closed) {
                             value.closed = true;
                             if (value.cell && !value.cell.dying && --value.cell.refs === 0) {
+                                if (actor?.budget) {
+                                    const row = this.managed.row(this.managed.type(value));
+                                    if (row.kind !== "shared")
+                                        throw new Error("Rc has no canonical payload descriptor");
+                                    pending.push({
+                                        managedRelease: actor.budget.retain({
+                                            value: value.cell.value,
+                                            type: row.payload,
+                                            slots: true,
+                                            identity: value.cell,
+                                        }),
+                                    });
+                                }
+                                value.cell.managedLease?.release();
+                                value.cell.managedLease = undefined;
                                 value.cell.owner?.blocks.delete(value.cell);
                                 value.cell.owner = null;
                                 pending.push(value.cell.value);
@@ -2586,17 +3604,18 @@ class ExecutorV1 {
                         const resource = this.pkg.resources?.[value.resource];
                         if (resource?.kind !== "opaque")
                             throw new Error("opaque owner lost its selected close");
-                        this.invokeFrame(actor, resource.close, [value], () => next(), next, rcOwner);
+                        this.invokeFrame(actor, resource.close, [value], () => next(), next, rcOwner, false, retainedBy);
                         return;
                     }
                     case "task": {
                         // Dropping a handle does not cancel scoped work. Join drains the
                         // task, and scope close releases any result that was never taken.
                         const task = this.tasks.get(value.id);
-                        if (task?.done) {
+                        const owned = task?.handles.delete(value);
+                        if (task?.done && (!owned || !task.scopeAlive)) {
                             const result = task.value;
-                            task.value = UNIT;
-                            this.closeValueAsync(result, currentFault, (fault) => next(fault ?? (task.close ? task.fault : null)), actor, rcOwner);
+                            pending.push({ taskTaken: task });
+                            this.closeValueAsync(result, currentFault, (fault) => next(fault ?? (task.close ? task.fault : null)), actor, rcOwner, retainedBy);
                             return;
                         }
                         if (task?.close) {
@@ -2624,7 +3643,7 @@ class ExecutorV1 {
                             if (this.consumedResources.has(value))
                                 break;
                             if (!this.closingResources.has(value)) {
-                                this.invokeFrame(actor, resource.close, [value], () => next(), next, rcOwner);
+                                this.invokeFrame(actor, resource.close, [value], () => next(), next, rcOwner, false, retainedBy);
                                 return;
                             }
                             this.consumedResources.add(value);
@@ -2636,12 +3655,11 @@ class ExecutorV1 {
                         pending.push(...[...value.payload].reverse());
                         break;
                     case "vector":
-                        pending.push(...[...value.items].reverse());
+                        pending.push(...releaseVector(value).reverse());
                         break;
                     case "stream": {
                         const adapter = this.generatorStreams.get(value.channelId);
                         if (adapter) {
-                            this.generatorStreams.delete(value.channelId);
                             adapter.closed = true;
                             if (adapter.pending !== null)
                                 pending.push(adapter.pending);
@@ -2687,7 +3705,7 @@ class ExecutorV1 {
     }
     closeValue(value, fault) {
         if (value.kind === "encoding")
-            value.value = null;
+            releaseEncoding(value);
         if (value.kind === "host_resource")
             this.closeHostResource(value);
         if (value.kind === "string")
@@ -2703,11 +3721,34 @@ class ExecutorV1 {
             for (const field of value.payload)
                 this.closeValue(field, fault);
         else if (value.kind === "vector")
-            for (const item of value.items)
+            for (const item of releaseVector(value))
                 this.closeValue(item, fault);
+        else if (value.kind === "rc" && !value.closed) {
+            value.closed = true;
+            const cell = value.cell;
+            if (cell && !cell.dying && --cell.refs === 0) {
+                cell.dying = true;
+                this.closeValue(cell.value, fault);
+                cell.value = UNIT;
+                cell.managedLease?.release();
+                cell.managedLease = undefined;
+                cell.owner?.blocks.delete(cell);
+                cell.owner = null;
+            }
+        }
+        else if (value.kind === "weak" && !value.closed) {
+            value.closed = true;
+            value.cell.weak--;
+        }
+        this.managed.retire(value);
     }
-    newTask() {
+    newTask(budget, type, memberBytes = 0n, scopeAlive = false) {
         const task = {
+            handles: new Set(),
+            scopeAlive,
+            budget,
+            memberBytes,
+            managedType: type,
             id: this.ids.task(),
             grouped: false,
             done: false,
@@ -2720,8 +3761,44 @@ class ExecutorV1 {
             changed: [],
         };
         this.tasks.set(task.id, task);
+        if (budget) {
+            if (type == null)
+                throw new Error("task has no managed result descriptor");
+            const row = this.managed.row(type);
+            if (row.kind === "provider" && row.provider === "task")
+                task.managedLease = budget.retain({
+                    value: { kind: "task", id: task.id },
+                    type,
+                });
+        }
         return task;
     }
+    releaseTaskState(task) {
+        if (task.scopeAlive || task.handles.size || !this.tasks.has(task.id))
+            return;
+        this.releaseRaceMembers(task);
+        task.managedLease?.release();
+        task.managedLease = undefined;
+        this.tasks.delete(task.id);
+        task.budget?.changed();
+    }
+    releaseRaceMembers(task) {
+        const members = task.members;
+        if (!members)
+            return;
+        task.members = undefined;
+        task.memberBytes = 0n;
+        task.budget?.changed();
+        for (const value of members) {
+            if (value.kind !== "task")
+                continue;
+            const member = this.tasks.get(value.id);
+            member?.handles.delete(value);
+            this.managed.retire(value);
+            if (member)
+                this.releaseTaskState(member);
+        }
+    }
     taskFor(value) {
         if (value.kind !== "task")
             throw new Error(`expected a task, got ${value.kind}`);
@@ -2734,21 +3811,80 @@ class ExecutorV1 {
         if (task.done)
             return;
         task.done = true;
+        task.resultInitialized = true;
         task.value = value;
         task.fault = fault;
+        task.budget?.changed();
         task.completedAt = ++this.completedTasks;
         for (const changed of [...task.changed])
             changed();
     }
-    invokeFrame(actor, callable, args, returned, failed, rcOwner = actor?.rcOwner ?? null, inline = false) {
+    retainTaskResult(task, budget) {
+        if (!budget)
+            return undefined;
+        if (task.fault || (task.actorError && task.actorError !== "Failed"))
+            return undefined;
+        const row = task.managedType == null ? undefined : this.managed.row(task.managedType);
+        if (row?.kind === "actor_call")
+            return budget.retain({
+                value: task.managedResult,
+                type: row.completion,
+            });
+        if (!row || row.kind !== "provider" || row.children[0] == null)
+            throw new Error("task result lacks its canonical payload descriptor");
+        return budget.retain({
+            value: task.managedResult ?? task.value,
+            type: row.children[0],
+        });
+    }
+    managedCompletion(task, value, error, envelope) {
+        if (task.managedType == null ||
+            value === null ||
+            (error !== null && error !== "Failed"))
+            return undefined;
+        const provider = this.managed.row(task.managedType);
+        if (provider.kind !== "actor_call")
+            throw new Error("actor completion has no canonical provider descriptor");
+        const type = provider.completion;
+        const result = this.managed.row(type);
+        if (result.kind !== "variant")
+            throw new Error("actor completion has no canonical result cases");
+        const err = runtimeTag(this.pkg.variants[result.shape], "ResultErr");
+        const failure = this.managed.row(result.cases[err][0]);
+        if (failure.kind !== "variant")
+            throw new Error("actor completion has no canonical error cases");
+        if (!envelope)
+            throw new Error("actor completion lost its actual handler envelope");
+        return {
+            value: this.completion(result.shape, failure.shape, value, error),
+            reply: { value: envelope, type: provider.reply },
+        };
+    }
+    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,
+            retainsTransferableFrame: !!retainedBy?.context.generator ||
+                retainedBy?.context.retainsTransferableFrame,
             rcOwner,
-            returned,
-            failed: (fault) => failed(fault),
+            returned: (value, released) => {
+                retainedBy?.managedChildren.delete(frame);
+                returned(value);
+                released();
+            },
+            failed: (fault) => {
+                retainedBy?.managedChildren.delete(frame);
+                failed(fault);
+            },
         };
         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 }) => {
             cancelled = fault;
@@ -2840,6 +3976,7 @@ class ExecutorV1 {
                     mailbox: [],
                     timers: new Set(),
                     disposals: [],
+                    disposalLeases: [],
                     admission: [],
                     busy: true,
                     constructing: true,
@@ -2883,6 +4020,8 @@ class ExecutorV1 {
                             const retained = combineFaults(primary, stateFault);
                             this.sweepRcOwner(actor.rcOwner, actor, (sweepFault) => {
                                 actor.completed = true;
+                                actor.stateLease?.release();
+                                actor.stateLease = undefined;
                                 for (const closed of actor.closed.splice(0))
                                     closed();
                                 this.raiseFault(act, combineFaults(retained, sweepFault), term.unwind);
@@ -2919,6 +4058,24 @@ class ExecutorV1 {
                     else
                         started();
                 };
+                if (layout.max_heap_bytes != null) {
+                    actor.budget = new ManagedBudget(this.managed, BigInt(layout.max_heap_bytes), (root) => this.adoptManaged(root, actor));
+                    if (layout.state_type == null)
+                        throw new Error("limited actor state lacks a managed descriptor");
+                    try {
+                        actor.stateLease = actor.budget.retain({
+                            value: actor.state,
+                            type: layout.state_type,
+                            slots: true,
+                        });
+                    }
+                    catch (error) {
+                        if (!(error instanceof HeapExceeded))
+                            throw error;
+                        failed({ kind: "trap", trap: "heap_exceeded" });
+                        return;
+                    }
+                }
                 if (layout.init != null)
                     actor.active = this.invokeFrame(actor, layout.init, [actor.state, ...args.slice(supplied)], start, failed, actor.rcOwner, true);
                 else
@@ -3026,7 +4183,9 @@ class ExecutorV1 {
                         complete: (_value, _error, drained) => drained?.(null),
                     };
                     const status = this.admitActorMessage(actor, message);
-                    if (status === "full" || status === "closed") {
+                    if (status === "full" ||
+                        status === "closed" ||
+                        status === "trapped") {
                         actor.disposals.push(payload);
                         timer.discarded();
                         this.dispatchActor(actor);
@@ -3064,7 +4223,21 @@ class ExecutorV1 {
                         const handler = actor.layout.handlers.find((handler) => handler.message_id === operation.message && handler.streams);
                         if (!handler)
                             throw new Error("stream request has no producer handler");
+                        let managedLease;
+                        try {
+                            managedLease = this.acquireActorMessage(actor, handler, fields);
+                        }
+                        catch (error) {
+                            if (!(error instanceof HeapExceeded))
+                                throw error;
+                            this.crashActor(actor, { kind: "trap", trap: "heap_exceeded" }, handler);
+                            this.closeValue(payload, error.message);
+                            this.completeShim(act, term, UNIT);
+                            this.scheduler.enqueue(act.context.id, () => this.runFrame(act));
+                            return;
+                        }
                         actor.mailbox.push({
+                            managedLease,
                             caller,
                             handler,
                             payload: fields,
@@ -3085,8 +4258,29 @@ class ExecutorV1 {
                 return;
             }
             case "call_start": {
-                const task = this.newTask();
-                const cancelRequest = this.ask(operation.protocol, args, (value, error, closeFault) => {
+                const task = this.newTask(act.context.actor?.budget, term.result && term.result !== "never"
+                    ? (term.result.managed_type ?? undefined)
+                    : undefined);
+                const cancelRequest = this.ask(operation.protocol, args, (value, error, closeFault, envelope) => {
+                    const reply = this.managedCompletion(task, value, error, envelope);
+                    if (reply && !closeFault && act.context.actor?.budget) {
+                        try {
+                            act.context.actor.budget.checkPayload(this.managed.width(reply.reply.type), [reply.reply]);
+                        }
+                        catch (failure) {
+                            if (!(failure instanceof HeapExceeded))
+                                throw failure;
+                            task.actorError = "Trapped";
+                            this.settleTask(task, UNIT, {
+                                kind: "trap",
+                                trap: "heap_exceeded",
+                            });
+                            this.failActorBudget(act.context.actor);
+                            return false;
+                        }
+                    }
+                    task.managedResult = reply?.value;
+                    task.managedReply = reply?.reply.value;
                     task.actorError = error;
                     this.settleTask(task, value ?? UNIT, closeFault ?? null);
                     return true;
@@ -3108,8 +4302,20 @@ class ExecutorV1 {
                     throw new Error("actor completion taken before readiness");
                 act.fault ??= task.fault;
                 const value = task.value;
+                const lease = this.retainTaskResult(task, act.context.actor?.budget);
+                if (lease)
+                    act.managedInputs.push(lease);
                 task.value = UNIT;
-                this.completeShim(act, term, this.completion(term.result_shape, term.error_shape, value, task.actorError));
+                task.taken = true;
+                const result = task.managedResult ??
+                    this.completion(term.result_shape, term.error_shape, value, task.actorError);
+                task.managedResult = undefined;
+                task.managedReply = undefined;
+                this.completeShim(act, term, result);
+                task.handles.delete(args[0]);
+                this.managed.retire(args[0]);
+                task.budget?.changed();
+                this.releaseTaskState(task);
                 return;
             }
             case "submit": {
@@ -3162,6 +4368,15 @@ class ExecutorV1 {
                         complete: (_value, _error, drained) => drained?.(null),
                     };
                     const status = this.admitActorMessage(actor, message);
+                    if (status === "trapped") {
+                        this.closeValueAsync(payload, "actor heap limit exceeded", (fault) => {
+                            act.fault ??= fault;
+                            finish(this.variant(term.result_shape, "ResultErr", [
+                                this.variant(term.error_shape, "ActorErrorTrapped"),
+                            ]));
+                        }, act.context.actor, act.rcOwner);
+                        return;
+                    }
                     if (status === "full") {
                         if (operation.policy === "drop_newest") {
                             let settled = false;
@@ -3209,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;
@@ -3258,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: [],
@@ -3463,6 +4683,7 @@ class ExecutorV1 {
         let admitted = false;
         let closing = false;
         const owner = this.current.context.actor;
+        const sender = this.current;
         const rcOwner = this.current.rcOwner;
         const deadline = this.requestDeadline(this.current);
         let cancelTimer;
@@ -3471,11 +4692,12 @@ class ExecutorV1 {
             ? { kind: "Actor", identity: owner.identity }
             : { kind: "Task" };
         let receiver = null;
-        const finish = (value, error, drained) => {
+        const finish = (value, error, drained, envelope) => {
             const alreadySettled = settled;
             settled = true;
             cancelTimer?.();
-            if (alreadySettled || complete(value, error) === false) {
+            if (alreadySettled ||
+                complete(value, error, undefined, envelope) === false) {
                 // The finishing receiver still owns a reply that its caller no
                 // longer accepts. Its next turn must wait for this release.
                 this.closeValueAsync(value ?? UNIT, null, (fault) => {
@@ -3582,9 +4804,23 @@ class ExecutorV1 {
                 }
                 return;
             }
+            let managedLease;
+            try {
+                managedLease = this.acquireActorMessage(actor, handler, payload);
+            }
+            catch (error) {
+                if (!(error instanceof HeapExceeded))
+                    throw error;
+                this.failActorBudget(actor);
+                reject("Trapped");
+                return;
+            }
             admitted = true;
+            for (const lease of sender.managedInputs.splice(0))
+                lease.release();
             receiver = actor;
             message = {
+                managedLease,
                 caller,
                 handler,
                 payload,
@@ -3607,6 +4843,8 @@ class ExecutorV1 {
             if (index < 0)
                 return;
             receiver.mailbox.splice(index, 1);
+            message.managedLease?.release();
+            message.managedLease = undefined;
             admitted = false;
             for (const admit of receiver.admission.splice(0))
                 admit();
@@ -3634,13 +4872,56 @@ class ExecutorV1 {
                 closeRequest(done);
         };
     }
+    acquireActorMessage(actor, handler, payload) {
+        const params = this.functionAt(handler.callable).params.slice(1);
+        if (params.length !== payload.length)
+            throw new Error("typed message payload differs from its handler");
+        if (!actor.budget &&
+            !this.pipes.hasManagedReceivers &&
+            params.every((param) => param.managed_type == null ||
+                !this.managed.needsAdoption(param.managed_type)))
+            return undefined;
+        const roots = params.flatMap((param, index) => {
+            if (param.managed_type == null) {
+                if (!actor.budget)
+                    return [];
+                throw new Error("message parameter lacks its managed descriptor");
+            }
+            return [
+                {
+                    value: payload[index],
+                    type: param.managed_type,
+                    slots: true,
+                },
+            ];
+        });
+        if (actor.budget)
+            return actor.budget.retainMany(roots);
+        for (const root of roots)
+            this.adoptManaged(root, actor);
+        return undefined;
+    }
     admitActorMessage(actor, message) {
         if (!actor.alive || actor.closing)
             return "closed";
         const full = actor.layout.mailbox_capacity != null &&
             actor.mailbox.length >= actor.layout.mailbox_capacity;
         let declared = full ? actor.layout.overflow : null;
+        const acquire = () => {
+            try {
+                message.managedLease = this.acquireActorMessage(actor, message.handler, message.payload);
+            }
+            catch (error) {
+                if (!(error instanceof HeapExceeded))
+                    throw error;
+                this.failActorBudget(actor);
+                return false;
+            }
+            return true;
+        };
         const discard = (lost) => {
+            if (lost.managedLease)
+                actor.disposalLeases.push(lost.managedLease);
             actor.disposals.push({
                 kind: "record",
                 typeId: "",
@@ -3658,6 +4939,8 @@ class ExecutorV1 {
                     equals(queued.payload[key.param], message.payload[key.param]))
                 : -1;
             if (queued >= 0) {
+                if (!acquire())
+                    return "trapped";
                 const superseded = actor.mailbox[queued];
                 actor.mailbox[queued] = message;
                 discard(superseded);
@@ -3673,6 +4956,8 @@ class ExecutorV1 {
             ? actor.mailbox.findIndex((queued) => !queued.obligated)
             : -1;
         if (oldest >= 0) {
+            if (!acquire())
+                return "trapped";
             const [evicted] = actor.mailbox.splice(oldest, 1);
             actor.mailbox.push(message);
             discard(evicted);
@@ -3680,6 +4965,8 @@ class ExecutorV1 {
         }
         if (full)
             return "full";
+        if (!acquire())
+            return "trapped";
         actor.mailbox.push(message);
         this.trace.snapshot("actor.send", {
             actor_id: actor.id,
@@ -3772,7 +5059,9 @@ class ExecutorV1 {
         if (actor.disposals.length > 0) {
             actor.busy = true;
             const values = actor.disposals.splice(0);
+            const leases = actor.disposalLeases.splice(0);
             this.closeValueAsync({ kind: "vector", elementType: "message", items: values }, this.faultText(actor.crashing), (fault) => {
+                leases.forEach((lease) => lease.release());
                 actor.busy = false;
                 if (fault)
                     this.crashActor(actor, fault);
@@ -3816,6 +5105,8 @@ class ExecutorV1 {
                 return;
             }
             actor.mailbox.shift();
+            message.managedLease?.release();
+            message.managedLease = undefined;
             for (const admit of actor.admission.splice(0))
                 admit();
             if (message.requestDeadline !== undefined &&
@@ -3841,10 +5132,21 @@ class ExecutorV1 {
                 caller: message.caller,
                 requestDeadline: message.requestDeadline,
                 reply: message.reply,
-                returned: (value) => {
+                returned: (value, released) => {
                     unwatchStream();
                     actor.active = null;
+                    if (actor.crashing?.kind === "trap" &&
+                        actor.crashing.trap === "heap_exceeded") {
+                        const fault = actor.crashing;
+                        this.closeValueAsync(value, this.faultText(fault), (closeFault) => {
+                            released();
+                            this.crashActor(actor, combineFaults(fault, closeFault), message.handler);
+                            message.complete(null, "Trapped");
+                        }, actor, actor.rcOwner);
+                        return;
+                    }
                     const drained = (fault) => {
+                        released();
                         actor.busy = false;
                         if (fault)
                             this.crashActor(actor, fault, message.handler);
@@ -3859,7 +5161,7 @@ class ExecutorV1 {
                         const shape = this.pkg.variants[message.handler.result_shape];
                         if (shape?.cases[value.tag]?.name === "Err") {
                             if (message.reply)
-                                message.complete(value.payload[0] ?? UNIT, "Failed", drained);
+                                message.complete(value.payload[0] ?? UNIT, "Failed", drained, value);
                             else {
                                 this.crashActor(actor, {
                                     kind: "panic",
@@ -3870,11 +5172,11 @@ class ExecutorV1 {
                             }
                         }
                         else {
-                            message.complete(value.payload[0] ?? UNIT, null, drained);
+                            message.complete(value.payload[0] ?? UNIT, null, drained, value);
                         }
                     }
                     else {
-                        message.complete(value, null, drained);
+                        message.complete(value, null, drained, value);
                     }
                 },
                 failed: (fault) => {
@@ -3950,6 +5252,8 @@ class ExecutorV1 {
                             this.reportFault(actor.closingFault);
                         }
                         actor.completed = true;
+                        actor.stateLease?.release();
+                        actor.stateLease = undefined;
                         for (const wake of actor.closed.splice(0))
                             wake();
                         for (const admit of actor.admission.splice(0))
@@ -3983,11 +5287,15 @@ class ExecutorV1 {
                             kind: "enum",
                             typeId: this.variantName(actor.layout.crash_kind),
                             shape: actor.layout.crash_kind,
-                            tag: runtimeTag(this.pkg.variants[actor.layout.crash_kind], code === 214
-                                ? "CrashKindTimerOverdue"
-                                : code === 213
-                                    ? "CrashKindHandlerFailed"
-                                    : "CrashKindFault"),
+                            tag: runtimeTag(this.pkg.variants[actor.layout.crash_kind], code === 200
+                                ? "CrashKindHeapExceeded"
+                                : code === 214
+                                    ? "CrashKindTimerOverdue"
+                                    : code === 213
+                                        ? "CrashKindHandlerFailed"
+                                        : code === 215
+                                            ? "CrashKindStackOverflow"
+                                            : "CrashKindFault"),
                             payload: [],
                         },
                         stringValue(String(message)),
@@ -4169,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;
@@ -4233,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();
@@ -4249,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;
@@ -4372,6 +5705,10 @@ class ExecutorV1 {
     }
     drainMailbox(actor, fault, done) {
         const messages = actor.mailbox.splice(0);
+        const leases = [
+            ...actor.disposalLeases.splice(0),
+            ...messages.flatMap((message) => message.managedLease ? [message.managedLease] : []),
+        ];
         actor.drainingMailbox = true;
         this.closeValueAsync({
             kind: "vector",
@@ -4385,6 +5722,7 @@ class ExecutorV1 {
                 })),
             ],
         }, fault, (closeFault) => {
+            leases.forEach((lease) => lease.release());
             actor.drainingMailbox = false;
             for (const message of messages)
                 message.complete(null, "Dead");
@@ -4464,6 +5802,8 @@ class ExecutorV1 {
                         }
                         actor.completed = true;
                         actor.alive = false;
+                        actor.stateLease?.release();
+                        actor.stateLease = undefined;
                         actor.busy = false;
                         this.trace.snapshot(actor.terminating ? "actor.terminate" : "actor.stop", { actor_id: actor.id });
                         this.settleSupervisedEnd(actor, actor.closingFault
@@ -4570,14 +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"],
-    }[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)
@@ -4606,12 +5951,30 @@ function faultReport(fault, secondary = false) {
         (fault.secondary ?? []).map((next) => faultReport(next, true)).join(""));
 }
 // ── refs ────────────────────────────────────────────────────────────────────
-function ownedRef(value) {
-    return { kind: "cell", cell: { value, valid: true } };
+function ownedRef(value, budget, type) {
+    if (budget && type == null)
+        throw new Error("owned value has no managed descriptor");
+    return {
+        kind: "cell",
+        cell: {
+            value,
+            valid: true,
+            budget,
+            type,
+            lease: budget?.retain({ value, type: type }),
+        },
+    };
 }
 function writeRef(ref, value) {
     switch (ref.kind) {
         case "cell":
+            if (ref.cell.budget) {
+                if (ref.cell.type == null)
+                    throw new Error("owned place has no managed descriptor");
+                const lease = ref.cell.budget.retain({ value, type: ref.cell.type });
+                ref.cell.lease?.release();
+                ref.cell.lease = lease;
+            }
             ref.cell.value = value;
             ref.cell.valid = true;
             return;
@@ -4626,8 +5989,11 @@ function writeRef(ref, value) {
 /// Only a cell of its own can be ended; a projection lives as long as the
 /// storage it reaches through.
 function invalidateRef(ref) {
-    if (ref.kind === "cell")
+    if (ref.kind === "cell") {
         ref.cell.valid = false;
+        ref.cell.lease?.release();
+        ref.cell.lease = undefined;
+    }
     else
         writeRef(ref, UNIT);
 }
@@ -4734,11 +6100,7 @@ function truth(value) {
         : value.kind === "i64" && value.value !== 0n;
 }
 function bytesValue(bytes) {
-    return {
-        kind: "vector",
-        elementType: "u8",
-        items: bytes.map((byte) => ({ kind: "i64", value: BigInt(byte) })),
-    };
+    return byteVectorValue(bytes.map((byte) => ({ kind: "i64", value: BigInt(byte) })));
 }
 function renderMessage(value) {
     return value.kind === "string" ? value.value : canonical(value);
@@ -4758,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":
@@ -4798,12 +6160,18 @@ 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":
             return "index out of bounds";
         case "actor_refused":
             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
@@ -4853,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)) {
@@ -5038,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);
 }