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

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

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

package/dist/interpreter/v1/package.js

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

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

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

package/dist/interpreter/v1/pipes.js

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

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

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

package/dist/interpreter/v1/shims.js

@@ -4,7 +4,7 @@ import { executeEncoding } from "./encoding-values.js";
 import { charProperty, charCase } from "../unicode.js";
 /// Runtime implementations and their host execution registration. Admission and
 /// execution consume the same ordinary, resumable or refused disposition.
-import { UNIT, cloneValue, compareUtf8, stringValue, renderStdout, } from "../values.js";
+import { UNIT, byteVectorValue, clearByteVector, mutableVector, sliceByteVector, cloneValue, compareUtf8, stringValue, renderStdout, } from "../values.js";
 import { seededMt } from "./mt19937.js";
 /// A language-visible fault raised inside a shim. The executor routes it to the
 /// call's `unwind` edge, or ends the program when the call names none.
@@ -122,7 +122,6 @@ export function resolveRuntime(entry) {
                     });
                 case "GetBorrow":
                 case "TakeFirst":
-                case "Append":
                     return refused(`Vector::${entry.detail}`);
                 default:
                     return ordinary(VECTOR_SHIMS[entry.detail]);
@@ -295,13 +294,19 @@ const UNIT_FAMILIES = {
         host.writeStderr(text(args, 0));
         return UNIT;
     },
-    StringToBytes: (_host, args) => ({
-        kind: "vector",
-        elementType: "u8",
-        items: [...indexed(args, 0).encoded()].map((byte) => int(BigInt(byte))),
-    }),
+    StringToBytes: (_host, args) => byteVectorValue([...indexed(args, 0).encoded()].map((byte) => int(BigInt(byte)))),
     StringToUppercase: (_host, args) => str(text(args, 0).toUpperCase()),
     StringToLowercase: (_host, args) => str(text(args, 0).toLowerCase()),
+    StreamPipe: (host, args) => {
+        const pair = host.newPipe(Number(integer(args, 0)));
+        const fields = [
+            host.pipes.extract(pair, "sink"),
+            host.pipes.extract(pair, "stream"),
+            bool(true),
+        ];
+        host.pipes.freePair(pair);
+        return { kind: "record", typeId: "", fields };
+    },
     StreamPairSink: (host, args) => host.pipes.extract(arg(args, 0), "sink"),
     StreamPairStream: (host, args) => host.pipes.extract(arg(args, 0), "stream"),
     StreamFromGenerator: (host, args) => host.generatorStream(arg(args, 0)),
@@ -440,7 +445,7 @@ const UNIT_FAMILIES = {
     // TextDecoder replaces each maximal invalid subsequence with U+FFFD, as
     // native lossy decoding does.
     BytesDecodeUtf8Lossy: (_host, args) => str(decodeUtf8(arg(args, 0))),
-    BytesNew: () => ({ kind: "vector", elementType: "u8", items: [] }),
+    BytesNew: () => byteVectorValue([]),
     BytesIsEmpty: (_host, args) => bool(vec(args, 0).items.length === 0),
     BytesLen: (_host, args) => int(BigInt(vec(args, 0).items.length)),
     BytesContains: (_host, args) => {
@@ -455,20 +460,19 @@ const UNIT_FAMILIES = {
         }
         return cloneValue(items[at]);
     },
-    // A native bytes range shares the buffer; a VM value is never aliased, so
-    // a copy is observably the same.
+    // Nonempty views retain the exact original allocation and payload capacity.
     BytesSlice: (_host, args) => {
         const items = vec(args, 0).items;
         const start = index(args, 1);
         const end = index(args, 2);
         checkSliceBounds(start, end, items.length);
-        return byteVector(items.slice(start, end));
+        return sliceByteVector(vec(args, 0), start, end);
     },
     BytesSliceFrom: (_host, args) => {
         const items = vec(args, 0).items;
         const start = index(args, 1);
         checkSliceBounds(start, items.length, items.length);
-        return byteVector(items.slice(start));
+        return sliceByteVector(vec(args, 0), start, items.length);
     },
     BytesConcat: (_host, args) => byteVector([...vec(args, 0).items, ...vec(args, 1).items]),
     BytesStartsWith: (_host, args) => bool(runAt(vec(args, 0).items, vec(args, 1).items, 0)),
@@ -480,6 +484,7 @@ const UNIT_FAMILIES = {
     // A mutating call receives its receiver by `move` and returns it.
     BytesPush: (_host, args) => {
         const target = vec(args, 0);
+        mutableVector(target, target.items.length + 1);
         target.items.push(cloneValue(arg(args, 1)));
         return target;
     },
@@ -489,13 +494,13 @@ const UNIT_FAMILIES = {
         if (at < 0 || at >= target.items.length) {
             throw new ShimFault("vector_bounds", `bytes index ${at} out of bounds for length ${target.items.length}`);
         }
+        mutableVector(target);
         target.items[at] = cloneValue(arg(args, 2));
         return target;
     },
     BytesClear: (_host, args) => {
         const target = vec(args, 0);
-        target.items.length = 0;
-        return target;
+        return clearByteVector(target);
     },
     BytesGet: (host, args, shape) => {
         if (!shape) {
@@ -511,7 +516,9 @@ const UNIT_FAMILIES = {
     // append, paired with the removed byte for a pop.
     BytesAppend: (_host, args) => {
         const target = vec(args, 0);
-        target.items.push(...vec(args, 1).items.map(cloneValue));
+        const added = vec(args, 1).items.map(cloneValue);
+        mutableVector(target, target.items.length + added.length);
+        target.items.push(...added);
         return target;
     },
     BytesPop: (host, args, shape) => {
@@ -519,6 +526,8 @@ const UNIT_FAMILIES = {
             throw new TypeError("BytesPop names no result shape to build its Option against");
         }
         const target = vec(args, 0);
+        if (target.items.length)
+            mutableVector(target);
         const last = target.items.pop();
         return {
             kind: "record",
@@ -645,9 +654,7 @@ const UNIT_FAMILIES = {
     ReplyPayloadFree: refused("ReplyPayloadFree"),
     ReplyWait: refused("ReplyWait"),
     SelectFirst: refused("SelectFirst"),
-    StreamChunks: refused("StreamChunks"),
     StreamForward: refused("StreamForward"),
-    StreamLines: refused("StreamLines"),
     StreamNextLayout: refused("StreamNextLayout"),
     StreamSendLayout: refused("StreamSendLayout"),
     StreamTake: refused("StreamTake"),
@@ -706,6 +713,7 @@ const VECTOR_SHIMS = {
             right >= target.items.length) {
             throw new ShimFault("vector_bounds", "vector swap index out of bounds");
         }
+        mutableVector(target);
         [target.items[left], target.items[right]] = [
             target.items[right],
             target.items[left],
@@ -717,6 +725,7 @@ const VECTOR_SHIMS = {
         if (target.items.length === 0) {
             throw new ShimFault("vector_bounds", "pop from empty vector");
         }
+        mutableVector(target);
         return {
             kind: "record",
             typeId: "",
@@ -729,15 +738,26 @@ const VECTOR_SHIMS = {
     // ownership decision SIR proved, so it moves in as it arrives.
     Push: (_host, args) => {
         const target = vec(args, 0);
+        mutableVector(target, target.items.length + 1);
         target.items.push(arg(args, 1));
         return target;
     },
+    Append: (_host, args) => {
+        const target = vec(args, 0);
+        const added = [...vec(args, 1).items];
+        if (added.length) {
+            mutableVector(target, target.items.length + added.length, added);
+            target.items.push(...added.map(cloneValue));
+        }
+        return target;
+    },
     Remove: (_host, args) => {
         const target = vec(args, 0);
         const at = index(args, 1);
         if (at < 0 || at >= target.items.length) {
             throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${target.items.length}`);
         }
+        mutableVector(target);
         const [item] = target.items.splice(at, 1);
         return { kind: "record", typeId: "", fields: [target, item] };
     },
@@ -765,23 +785,25 @@ const VECTOR_SHIMS = {
         const start = index(args, 1);
         const end = index(args, 2);
         checkSliceBounds(start, end, items.length);
-        return {
-            kind: "vector",
-            elementType: "",
-            items: items.slice(start, end).map(cloneValue),
-        };
+        return vectorSlice(items.slice(start, end));
     },
     SliceFrom: (_host, args) => {
         const items = vec(args, 0).items;
         const start = index(args, 1);
         checkSliceBounds(start, items.length, items.length);
-        return {
-            kind: "vector",
-            elementType: "",
-            items: items.slice(start).map(cloneValue),
-        };
+        return vectorSlice(items.slice(start));
     },
 };
+function vectorSlice(items) {
+    const result = {
+        kind: "vector",
+        elementType: "",
+        items: [],
+    };
+    mutableVector(result, items.length);
+    result.items.push(...items.map(cloneValue));
+    return result;
+}
 function sequenceElement(args) {
     const items = vec(args, 0).items;
     const at = index(args, 1);
@@ -791,7 +813,7 @@ function sequenceElement(args) {
     return items[at];
 }
 function byteVector(items) {
-    return { kind: "vector", elementType: "u8", items: items.map(cloneValue) };
+    return byteVectorValue(items.map(cloneValue));
 }
 /// Whether `run` occurs in `items` starting at `at`.
 function runAt(items, run, at) {
@@ -1092,6 +1114,10 @@ function saturatingI64(value) {
 }
 // ── externs ─────────────────────────────────────────────────────────────────
 const EXTERN_SHIMS = {
+    hew_arena_instance_id_new: (host) => ({
+        kind: "i64",
+        value: host.arenaInstanceId(),
+    }),
     hew_semaphore_new: (host, args) => host.semaphores.create(integer(args, 0)),
     hew_semaphore_clone: (host, args) => host.semaphores.clone(arg(args, 0)),
     hew_semaphore_try_acquire: (host, args) => bool(host.semaphores.tryAcquire(arg(args, 0))),

package/dist/interpreter/v1/validate.js

@@ -294,7 +294,8 @@ export function admitPackage(pkg, bridges = {}) {
             };
         if (actor.exit != null || actor.down != null)
             return unavailable("actor.local_observation");
-        if (actor.max_heap_bytes != null)
+        if (actor.max_heap_bytes != null &&
+            (actor.state_type == null || !pkg.managed_types?.length))
             return unavailable("actor.heap_limit");
     }
     for (const supervisor of pkg.supervisors ?? []) {

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

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

package/dist/interpreter/v1/value-operations.js

@@ -1,4 +1,4 @@
-import { UNIT, cloneValue, compareUtf8, } from "../values.js";
+import { UNIT, mutableVector, cloneValue, compareUtf8, } from "../values.js";
 import { runtimeTag, } from "./package.js";
 import { ShimFault } from "./shims.js";
 import { actorIdentical } from "./actor-identity.js";
@@ -324,17 +324,20 @@ export function* sharedOperation(operation, args, owner, typeName, option) {
 /** Open-addressed collection operations preserve native callback ordering:
  * growth hashes occupied slots before probing the incoming key. Staged slots
  * borrow their owners until every fallible callback has completed. */
-export function* collectionOperation(pkg, request, args, callbacks, shape) {
+export function* collectionOperation(pkg, request, args, callbacks, shape, elementType) {
     const { family, operation } = request;
     if (family === "Vector") {
         const receiver = args[0];
         if (receiver?.kind !== "vector")
             throw new Error("vector operation has no vector");
         if (operation === "Clear") {
+            mutableVector(receiver);
             const items = receiver.items.splice(0);
             yield {
                 kind: "release",
                 value: { kind: "vector", elementType: receiver.elementType, items },
+                retained: items,
+                retainedType: elementType,
             };
             return receiver;
         }
@@ -344,10 +347,11 @@ export function* collectionOperation(pkg, request, args, callbacks, shape) {
                 throw new Error("vector mutation has no index");
             const at = Number(index.value);
             if (at < 0 || at >= receiver.items.length)
-                throw new ShimFault("vector_bounds", "vector index out of bounds");
+                throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${receiver.items.length}`);
+            mutableVector(receiver);
             const old = receiver.items[at];
             receiver.items[at] = args[2];
-            yield { kind: "release", value: old };
+            yield { kind: "release", value: old, retainedType: elementType };
             return receiver;
         }
         for (const item of receiver.items) {
@@ -377,6 +381,7 @@ export function* collectionOperation(pkg, request, args, callbacks, shape) {
         receiver.tombstones = new Set();
         yield {
             kind: "release",
+            retained: entries.flatMap((entry) => [entry.key, entry.value]),
             value: {
                 kind: "vector",
                 elementType: "",
@@ -389,15 +394,22 @@ export function* collectionOperation(pkg, request, args, callbacks, shape) {
         operation === "Values" ||
         operation === "Elements" ||
         operation === "Entries") {
-        return {
+        const result = {
             kind: "vector",
             elementType: "",
-            items: [...receiver.entries.values()].map(({ key, value }) => operation === "Values"
-                ? cloneValue(value)
-                : operation === "Entries"
-                    ? tuple(cloneValue(key), cloneValue(value))
-                    : cloneValue(key)),
+            items: [],
         };
+        const items = [...receiver.entries.values()].map(({ key, value }) => operation === "Values"
+            ? cloneValue(value)
+            : operation === "Entries"
+                ? tuple(cloneValue(key), cloneValue(value))
+                : cloneValue(key));
+        // Native snapshots push into an initially empty Vec, retaining its normal
+        // growth capacity. A later semantic clone may use exact live length.
+        mutableVector(result, items.length);
+        for (const item of items)
+            result.items.push(item);
+        return result;
     }
     let staged = receiver;
     if (operation === "Insert" &&
@@ -435,6 +447,7 @@ export function* collectionOperation(pkg, request, args, callbacks, shape) {
         return cloneValue(entry.value);
     }
     if (operation === "Insert") {
+        receiver.prepareInsert?.(staged, result.slot, entry?.key ?? args[1], family === "Set" ? UNIT : args[2], family !== "Set" && !entry);
         receiver.entries = staged.entries;
         receiver.capacity = staged.capacity;
         receiver.tombstones = staged.tombstones;

package/dist/interpreter/values.d.ts

@@ -1,6 +1,5 @@
 import type { JsonValue } from "./types.js";
 import { IndexedString } from "./strings.js";
-import type { EncodingNode, EncodingFormat } from "./v1/encoding-values.js";
 export { stringValue } from "./strings.js";
 /** One creator-owned membership list; payload destruction uses the ordinary VM release path. */
 export interface RcOwner {
@@ -8,6 +7,8 @@ export interface RcOwner {
     closed: boolean;
 }
 export interface RcCell {
+    managedLease?: import("./v1/managed-budget.js").ManagedLease;
+    managedPayload?: number;
     value: VmValue;
     refs: number;
     weak: number;
@@ -15,11 +16,25 @@ export interface RcCell {
     owner: RcOwner | null;
     typeName: string;
 }
-export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | {
-    kind: "encoding";
-    format: EncodingFormat;
-    value: EncodingNode | null;
-} | {
+/** The language payload allocation. JS arrays holding view metadata do not
+ * determine its capacity or identity. Bytes views retain this complete owner. */
+export interface VectorStorage {
+    items: VmValue[];
+    capacity: number;
+    owners: number;
+    bytes: boolean;
+    shareOnCopy: boolean;
+}
+export interface VmVector {
+    kind: "vector";
+    elementType: string;
+    items: VmValue[];
+    storage?: VectorStorage;
+    offset?: number;
+    closed?: boolean;
+    prepareMutation?: (capacity: number, detached: boolean, appended?: readonly VmValue[]) => void;
+}
+export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | import("./v1/encoding-storage.js").EncodingOwner | {
     kind: "rc";
     cell: RcCell | null;
     closed: boolean;
@@ -86,17 +101,14 @@ export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | {
     typeId: string;
     shape?: number;
     fields: VmValue[];
+    managedCaptures?: readonly number[];
 } | {
     kind: "enum";
     typeId: string;
     shape: number;
     tag: number;
     payload: VmValue[];
-} | {
-    kind: "vector";
-    elementType: string;
-    items: VmValue[];
-}
+} | VmVector
 /** A map or set owns its occupied slots. Selected Hash/Eq operations probe
  *  the table; tombstones preserve collision chains across removal. */
  | {
@@ -107,6 +119,9 @@ export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | {
     }>;
     capacity?: number;
     tombstones?: Set<number>;
+    prepareInsert?: (staged: Extract<VmValue, {
+        kind: "map";
+    }>, slot: string, key: VmValue, value: VmValue, copyKey: boolean) => void;
 }
 /** A trait object: the vtable the checker selected, and the value it wraps.
  *  A `dyn.call` resolves its method through `vtable`, never through the
@@ -115,6 +130,7 @@ export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | {
     kind: "dyn";
     vtable: number;
     value: VmValue;
+    managedPayload?: number;
 }
 /** A first-class function reference materialised by `const.function`.
  *  `id` is the bytecode function id (e.g. `"fn:my_handler"`).
@@ -135,10 +151,19 @@ export type VmValue = import("./v1/semaphores.js").SemaphoreHandle | {
     }>;
     specialization: number | null;
     environment: VmValue;
+    managedCaptures?: readonly number[];
 };
 export declare const UNIT: VmValue;
 export declare function compareUtf8(a: string, b: string): number;
 export declare function cloneValue(value: VmValue): VmValue;
+export declare function vectorStorage(value: VmVector): VectorStorage;
+export declare function byteVectorValue(items: VmValue[]): VmVector;
+export declare function sliceByteVector(value: VmVector, start: number, end: number): VmVector;
+/** Establish uniqueness before any mutation, preserving native capacity rules. */
+export declare function mutableVector(value: VmVector, needed?: number, appended?: readonly VmValue[]): VmVector;
+/** Consume one handle; only the last backing owner releases its elements. */
+export declare function releaseVector(value: VmVector): VmValue[];
+export declare function clearByteVector(value: VmVector): VmVector;
 export declare function valueFromLiteral(value: JsonValue): VmValue;
 export declare function renderF64(value: number): string;
 export declare function renderStdout(value: VmValue): string;