@hew-lang/sandbox-vm 0.6.0-rc7 → 0.6.0

package/dist/interpreter/v1/exec.js

@@ -5,6 +5,7 @@
 /// where the package says `copy_value`, releases where it says `destroy_value`,
 /// follows the `unwind` edge the package names, and takes the failure edge a
 /// `checked.binary` names rather than trapping on its own.
+import { executeCodec } from "./codecs.js";
 import { TraceBuilder, runtimeFailure } from "../trace.js";
 import { UNIT, cloneValue, toJsonValue } from "../values.js";
 import { runtimeTag } from "./package.js";
@@ -69,7 +70,7 @@ export function runPackageV1(pkg, options = {}) {
         trace.reject(rejection);
         return trace.finish();
     }
-    const vm = new ExecutorV1(pkg, trace, StdinReader.fromReplay(replay.inputs), options.schedulerPolicy ?? "round_robin");
+    const vm = new ExecutorV1(pkg, trace, StdinReader.fromReplay(replay.inputs), options.schedulerPolicy ?? "round_robin", options);
     try {
         vm.run();
     }
@@ -85,6 +86,7 @@ class ExecutorV1 {
     pkg;
     trace;
     stdin;
+    options;
     current;
     host;
     scheduler;
@@ -103,10 +105,11 @@ class ExecutorV1 {
     running = false;
     rootComplete = false;
     rootFault = null;
-    constructor(pkg, trace, stdin, policy) {
+    constructor(pkg, trace, stdin, policy, options) {
         this.pkg = pkg;
         this.trace = trace;
         this.stdin = stdin;
+        this.options = options;
         this.scheduler = new FrameScheduler(trace, policy);
         this.ids = new DeterministicIds(trace.replay.seed);
         this.host = {
@@ -171,7 +174,8 @@ class ExecutorV1 {
             const act = this.current;
             while (act.opIndex < act.block.ops.length) {
                 const op = act.block.ops[act.opIndex++];
-                this.commitStep();
+                if (op.op !== "coverage.hit")
+                    this.commitStep();
                 try {
                     this.execute(act, op);
                 }
@@ -350,6 +354,11 @@ class ExecutorV1 {
     // ── instructions ─────────────────────────────────────────────────────────
     execute(act, op) {
         switch (op.op) {
+            case "coverage.hit": {
+                const key = String(op.counter);
+                this.trace.coverage[key] = (this.trace.coverage[key] ?? 0) + 1;
+                return;
+            }
             case "const.int":
                 this.define(act, op.dst, {
                     kind: "i64",
@@ -404,9 +413,19 @@ class ExecutorV1 {
                 act.places.set(op.place, { value: UNIT, valid: false });
                 return;
             case "store.init":
-            case "store.assign":
                 writeRef(this.placeRef(act, op.place), this.read(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;
+                // 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));
+                return;
+            }
             case "load.copy":
                 this.define(act, op.dst, cloneValue(readRef(this.placeRef(act, op.place))));
                 return;
@@ -634,6 +653,106 @@ class ExecutorV1 {
                 this.define(act, op.dst, { kind: "generator", id });
                 return;
             }
+            case "task.race": {
+                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));
+                    this.invalidate(act, operand);
+                    if (member.grouped)
+                        throw new Error("race reuses a task handle");
+                    member.grouped = true;
+                    return member;
+                });
+                if (!members.length)
+                    throw new Error("race requires members");
+                const task = this.newTask();
+                scope.tasks.push(task);
+                let selected = false;
+                let winner = null;
+                let value = UNIT;
+                let failure = null;
+                let cancelled = false;
+                const losersCancelled = new Set();
+                const ready = () => {
+                    if (task.done || task.finishing)
+                        return;
+                    if (!selected) {
+                        const first = members
+                            .filter((member) => member.done)
+                            .sort((a, b) => a.completedAt - b.completedAt)[0];
+                        if (!first)
+                            return;
+                        selected = true;
+                        if (!first.fault) {
+                            winner = first;
+                            value = first.value;
+                            first.value = UNIT;
+                        }
+                    }
+                    if (!cancelled) {
+                        cancelled = true;
+                        for (const member of members)
+                            if (!member.done) {
+                                losersCancelled.add(member);
+                                member.cancel();
+                            }
+                    }
+                    if (members.some((member) => !member.done))
+                        return;
+                    task.finishing = true;
+                    for (const member of members) {
+                        const index = member.changed.indexOf(ready);
+                        if (index >= 0)
+                            member.changed.splice(index, 1);
+                    }
+                    for (const member of [...members].sort((a, b) => a.completedAt - b.completedAt)) {
+                        if (member.fault &&
+                            !(member.fault.kind === "panic" &&
+                                member.fault.cancelled &&
+                                losersCancelled.has(member)))
+                            failure = combineFaults(failure, member.fault);
+                        member.fault = null;
+                    }
+                    const losers = members
+                        .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) => {
+                        failure = combineFaults(failure, closeFault);
+                        const finish = (releaseFault = null) => {
+                            failure = combineFaults(failure, releaseFault);
+                            this.settleTask(task, failure ? UNIT : value, failure);
+                            for (const changed of [...scope.changed])
+                                changed();
+                        };
+                        if (failure && winner)
+                            this.closeValueAsync(value, this.faultText(failure), finish, act.context.actor);
+                        else
+                            finish();
+                    }, act.context.actor);
+                };
+                task.cancel = () => {
+                    if (task.done || task.finishing)
+                        return;
+                    failure ??= {
+                        kind: "panic",
+                        message: "task cancelled",
+                        cancelled: true,
+                    };
+                    selected = true;
+                    ready();
+                };
+                for (const member of members)
+                    member.changed.push(ready);
+                this.define(act, op.dst, { kind: "task", id: task.id });
+                ready();
+                return;
+            }
             case "task.spawn": {
                 const group = act.scopes.get(op.scope);
                 if (!group)
@@ -656,7 +775,9 @@ class ExecutorV1 {
                         if (!fault || (fault.kind === "panic" && fault.cancelled))
                             fault = closeFault ?? fault;
                         this.settleTask(task, value, fault);
-                        if (fault && !(fault.kind === "panic" && fault.cancelled)) {
+                        if (!task.grouped &&
+                            fault &&
+                            !(fault.kind === "panic" && fault.cancelled)) {
                             for (const sibling of group.tasks)
                                 if (!sibling.done)
                                     sibling.cancel();
@@ -783,6 +904,8 @@ class ExecutorV1 {
                     ...term.args.map((operand) => this.boundary(act, operand)),
                 ];
                 this.current = this.activate(this.functionAt(entry.callee), args, act, term.result, term.normal, term.unwind);
+                if (entry.receiver_handback)
+                    this.current.erasedHandback = receiver;
                 return;
             }
             case "call": {
@@ -866,6 +989,11 @@ class ExecutorV1 {
                 this.callShim(act, term, shim);
                 return;
             }
+            case "wire.codec": {
+                const args = term.args.map((operand) => this.boundary(act, operand));
+                this.runValueProgram(act, term, args, executeCodec(this.pkg, term, args[0], this.options.codecBridge, this.options.propertyInput ?? []));
+                return;
+            }
             case "value.call": {
                 const args = term.args.map((operand) => this.boundary(act, operand));
                 this.runValueProgram(act, term, args, selectedValue(this.pkg, term.plan, args));
@@ -960,8 +1088,10 @@ class ExecutorV1 {
                 return;
             case "unreachable":
                 throw new Error(`${act.fn.name}: reached an unreachable endpoint`);
-            default:
-                throw new Error(`terminator ${term.op} has no sequential executor`);
+            default: {
+                const exhaustive = term;
+                throw new Error(`unhandled terminator: ${String(exhaustive)}`);
+            }
         }
     }
     takeEdge(act, edge) {
@@ -992,6 +1122,7 @@ class ExecutorV1 {
         }
         catch (error) {
             if (error instanceof ShimFault) {
+                this.keepInputs(act, term, args);
                 this.raiseFault(act, { kind: "trap", trap: error.trap, message: error.message }, term.unwind);
                 return;
             }
@@ -999,6 +1130,20 @@ class ExecutorV1 {
         }
         this.completeShim(act, term, value);
     }
+    /// A runtime call whose contract keeps its inputs on failure fails before
+    /// taking them, so each moved argument stays with the caller, whose unwind
+    /// edge stores it back.
+    keepsInputs(term) {
+        return term.op === "runtime.call" && term.keeps_inputs_on_failure === true;
+    }
+    keepInputs(act, term, args) {
+        if (!this.keepsInputs(term))
+            return;
+        term.args.forEach((operand, index) => {
+            if (operand.decision === "move")
+                this.define(act, operand.value, args[index]);
+        });
+    }
     runValueProgram(act, term, args, iterator) {
         this.running = false;
         let initial = true;
@@ -1010,10 +1155,16 @@ class ExecutorV1 {
                 this.scheduler.enqueue(act.context.id, () => this.runFrame(act));
         };
         const fail = (fault, extra = UNIT) => {
-            const owned = args.filter((_arg, index) => ["move", "copy", "snapshot"].includes(term.args[index].decision));
+            const kept = this.keepsInputs(term) ? ["move"] : [];
+            const owned = args.filter((_arg, index) => {
+                const decision = term.args[index].decision;
+                return (["move", "copy", "snapshot"].includes(decision) &&
+                    !kept.includes(decision));
+            });
             this.closeValueAsync({ kind: "vector", elementType: "", items: [...owned, extra] }, this.faultText(fault), (closeFault) => {
                 if (fault.kind === "panic" && fault.cancelled && closeFault)
                     fault = closeFault;
+                this.keepInputs(act, term, args);
                 this.raiseFault(act, fault, term.unwind);
                 resume();
             });
@@ -1116,6 +1267,13 @@ class ExecutorV1 {
         if (!act.normal) {
             throw new Error(`${act.fn.name}: returned from a call with a "never" result`);
         }
+        if (act.erasedHandback) {
+            if (value.kind !== "record" || value.fields.length !== 2) {
+                throw new Error(`${act.fn.name}: invalid erased receiver dual return`);
+            }
+            act.erasedHandback.value = value.fields[1];
+            value = value.fields[0];
+        }
         // The result is defined on the normal edge, like a block parameter, so it
         // is in scope for that edge's arguments.
         if (act.result && act.result !== "never") {
@@ -1166,12 +1324,15 @@ class ExecutorV1 {
         }
         // A failing `var self` method hands its receiver back, defined on the
         // unwind edge like a result on the normal edge.
-        if ((handback === null) !== !act.handback) {
+        if ((handback === null) !== !(act.handback || act.erasedHandback)) {
             throw new Error(`${act.fn.name}: receiver handback disagrees with its call`);
         }
         if (handback !== null && act.handback) {
             this.define(caller, act.handback.value, handback);
         }
+        if (handback !== null && act.erasedHandback) {
+            act.erasedHandback.value = handback;
+        }
         caller.fault = fault;
         this.current = caller;
         this.takeEdge(caller, act.unwind);
@@ -1305,11 +1466,10 @@ class ExecutorV1 {
                         return;
                     }
                     const failure = group.deadline ??
-                        group.tasks.find((task) => task.fault &&
+                        group.tasks.find((task) => !task.grouped &&
+                            task.fault &&
                             !(task.fault.kind === "panic" && task.fault.cancelled))?.fault;
-                    wake(UNIT, mode === "propagate_fault" || mode === "cancel_losers_after_fault"
-                        ? null
-                        : (failure ?? null));
+                    wake(UNIT, mode === "propagate_fault" ? null : (failure ?? null));
                 };
                 // Cancellation requests descendant cleanup; it cannot bypass the
                 // join barrier and let the parent retire their captured resources.
@@ -1380,7 +1540,12 @@ class ExecutorV1 {
                 return;
             }
             case "NativeIo": {
-                // Admission passed only `StdinReadLine`. The record is the raw line,
+                if (term.detail?.operation === "SinkFinish") {
+                    this.host.pipes.close(this.boundary(act, term.inputs[0]));
+                    this.park(act, term)(UNIT);
+                    return;
+                }
+                // Admission passed `StdinReadLine`. The record is the raw line,
                 // so the records concatenate to the stdin the program consumed.
                 const line = this.stdin.readLine() ?? new Uint8Array();
                 this.trace.recordReplayInput({ kind: "stdin", data: new TextDecoder().decode(line) }, false);
@@ -1608,6 +1773,7 @@ class ExecutorV1 {
     newTask() {
         const task = {
             id: this.ids.task(),
+            grouped: false,
             done: false,
             finishing: false,
             value: UNIT,
@@ -1715,6 +1881,7 @@ class ExecutorV1 {
                         fields: layout.state_fields.map((field) => field.deferred ? UNIT : (args[supplied++] ?? UNIT)),
                     },
                     mailbox: [],
+                    disposals: [],
                     admission: [],
                     busy: true,
                     alive: true,
@@ -1792,6 +1959,7 @@ class ExecutorV1 {
                             handler,
                             payload: fields,
                             reply: false,
+                            obligated: true,
                             complete: (_value, error, drained) => {
                                 if (error)
                                     this.closeValue(payload, error);
@@ -1871,13 +2039,13 @@ class ExecutorV1 {
                     }
                     const full = actor.layout.mailbox_capacity !== undefined &&
                         actor.mailbox.length >= actor.layout.mailbox_capacity;
-                    // The destination's declaration answers a full queue before the
-                    // sender's policy: a coalescing mailbox supersedes the queued
-                    // message with the same key, then its fallback or a declared
-                    // `drop_new` / `drop_old` resolves the rest. Either loss reports a
-                    // discard; only a declaration that refuses reaches the sender.
-                    // A discard completes in this turn unless an authored close
-                    // suspends: the sender keeps its turn, as it does natively.
+                    // Declared loss transfers cleanup to the receiver. Sender-selected
+                    // loss still closes the sender's unadmitted request in its own frame.
+                    const discardAtReceiver = (value, report) => {
+                        actor.disposals.push(value);
+                        this.dispatchActor(actor);
+                        finish(report);
+                    };
                     const discard = (value, report) => {
                         let settled = false;
                         let waiting = false;
@@ -1900,7 +2068,7 @@ class ExecutorV1 {
                     if (declared === "coalesce" && coalesce) {
                         const key = coalesce.keys.find((key) => key.message === handler.message_id);
                         const queued = key
-                            ? actor.mailbox.findIndex((message) => !message.reply &&
+                            ? actor.mailbox.findIndex((message) => !message.obligated &&
                                 message.handler.message_id === handler.message_id &&
                                 equals(message.payload[key.param], payload.fields[key.param]))
                             : -1;
@@ -1910,19 +2078,19 @@ class ExecutorV1 {
                                 ...superseded,
                                 payload: payload.fields,
                             };
-                            discard({ kind: "record", typeId: "", fields: superseded.payload }, accepted(true));
+                            discardAtReceiver({ kind: "record", typeId: "", fields: superseded.payload }, accepted(false));
                             return;
                         }
                         declared = coalesce.fallback;
                     }
                     if (declared === "drop_new") {
-                        discard(payload, accepted(true));
+                        discardAtReceiver(payload, accepted(true));
                         return;
                     }
                     // A queued completion call owes its caller a reply, so `drop_old`
                     // evicts only a one-way message and refuses when there is none.
                     const oldest = declared === "drop_old"
-                        ? actor.mailbox.findIndex((message) => !message.reply)
+                        ? actor.mailbox.findIndex((message) => !message.obligated)
                         : -1;
                     if (oldest >= 0) {
                         const [evicted] = actor.mailbox.splice(oldest, 1);
@@ -1930,10 +2098,11 @@ class ExecutorV1 {
                             handler,
                             payload: payload.fields,
                             reply: false,
+                            obligated: false,
                             complete: (_value, _error, drained) => drained?.(null),
                         });
                         this.dispatchActor(actor);
-                        discard({ kind: "record", typeId: "", fields: evicted.payload }, accepted(false));
+                        discardAtReceiver({ kind: "record", typeId: "", fields: evicted.payload }, accepted(false));
                         return;
                     }
                     if (full) {
@@ -1958,6 +2127,7 @@ class ExecutorV1 {
                         handler,
                         payload: payload.fields,
                         reply: false,
+                        obligated: false,
                         complete: (_value, _error, drained) => drained?.(null),
                     });
                     this.trace.snapshot("actor.send", {
@@ -2252,7 +2422,13 @@ class ExecutorV1 {
             }
             admitted = true;
             receiver = actor;
-            actor.mailbox.push({ handler, payload, complete: finish, reply: true });
+            actor.mailbox.push({
+                handler,
+                payload,
+                complete: finish,
+                reply: true,
+                obligated: true,
+            });
             this.trace.snapshot("actor.ask", {
                 actor_id: actor.id,
                 handler: handler.name,
@@ -2272,6 +2448,18 @@ class ExecutorV1 {
     dispatchActor(actor) {
         if (actor.busy || !actor.alive || actor.drainingMailbox)
             return;
+        if (actor.disposals.length > 0) {
+            actor.busy = true;
+            const values = actor.disposals.splice(0);
+            this.closeValueAsync({ kind: "vector", elementType: "message", items: values }, this.faultText(actor.crashing), (fault) => {
+                actor.busy = false;
+                if (fault)
+                    this.crashActor(actor, fault);
+                else
+                    this.dispatchActor(actor);
+            }, actor);
+            return;
+        }
         if (actor.terminating && actor.mailbox.length > 0) {
             this.drainMailbox(actor, this.faultText(actor.closingFault), (fault) => {
                 actor.closingFault = combineFaults(actor.closingFault, fault);
@@ -2649,11 +2837,14 @@ class ExecutorV1 {
         this.closeValueAsync({
             kind: "vector",
             elementType: "message",
-            items: messages.map((message) => ({
-                kind: "record",
-                typeId: "",
-                fields: message.payload,
-            })),
+            items: [
+                ...actor.disposals.splice(0),
+                ...messages.map((message) => ({
+                    kind: "record",
+                    typeId: "",
+                    fields: message.payload,
+                })),
+            ],
         }, fault, (closeFault) => {
             actor.drainingMailbox = false;
             for (const message of messages)
@@ -2906,8 +3097,6 @@ function sendErrorRole(reason) {
             return "SendErrorCancelled";
         case "VersionMismatch":
             return "SendErrorVersionMismatch";
-        case "Unauthorized":
-            return "SendErrorUnauthorized";
         case "Backpressure":
             return "SendErrorBackpressure";
         case "Dead":
@@ -3104,6 +3293,21 @@ function applyBinary(op, lhs, rhs, ty) {
             return { kind: "bool", value: truth(lhs) && truth(rhs) };
         case "Or":
             return { kind: "bool", value: truth(lhs) || truth(rhs) };
+        case "BitAnd":
+        case "BitOr":
+        case "BitXor":
+            // Both operands were already evaluated; bool operands stay bool.
+            if (lhs.kind === "bool" && rhs.kind === "bool") {
+                return {
+                    kind: "bool",
+                    value: op === "BitAnd"
+                        ? lhs.value && rhs.value
+                        : op === "BitOr"
+                            ? lhs.value || rhs.value
+                            : lhs.value !== rhs.value,
+                };
+            }
+            break;
         default:
             break;
     }

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

@@ -34,7 +34,7 @@ export interface VariantShape {
     cases: VariantCase[];
     runtime_tags?: Partial<Record<RuntimeVariantRole, number>>;
 }
-export type RuntimeVariantRole = "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorUnauthorized" | "SendErrorBackpressure" | "SendErrorDead" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
+export type RuntimeVariantRole = "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
 export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;
 export interface RuntimeFamilyEntry {
     id: number;
@@ -44,6 +44,7 @@ export interface RuntimeFamilyEntry {
 export interface ExternEntry {
     id: number;
     symbol: string;
+    native_capability?: string;
 }
 export type PlaceDecl = {
     id: number;
@@ -75,11 +76,20 @@ export type PlaceDecl = {
 };
 export interface ValueCapability {
     id: number;
-    capability: "Eq" | "Hash";
+    capability: "Eq" | "Hash" | "Less" | "LessEqual" | "Greater" | "GreaterEqual";
     ty: string;
     callable?: number;
-    components?: number[];
-    variants?: number[][];
+    components?: ValueComponentCapabilities[];
+    variants?: ValueComponentCapabilities[][];
+}
+export interface ValueComponentCapabilities {
+    selected: number;
+    ordering?: {
+        less: number;
+        less_equal: number;
+        greater: number;
+        greater_equal: number;
+    };
 }
 export interface ClosureShape {
     id: number;
@@ -93,6 +103,7 @@ export interface VtableShape {
         method: string;
         callee: number;
         receiver: BoundaryDecision;
+        receiver_handback?: boolean;
     }>;
 }
 export interface FunctionV1 {
@@ -115,6 +126,9 @@ interface OpBase {
     span?: SpanV1 | null;
 }
 export type OpV1 = (OpBase & {
+    op: "coverage.hit";
+    counter: number;
+}) | (OpBase & {
     op: "const.int";
     dst: number;
     value: string;
@@ -341,6 +355,11 @@ export type OpV1 = (OpBase & {
 }) | (OpBase & {
     op: "task_scope.close";
     scope: number;
+}) | (OpBase & {
+    op: "task.race";
+    dst: number;
+    scope: number;
+    members: Operand[];
 }) | (OpBase & {
     op: "task.spawn";
     dst: number;
@@ -414,12 +433,25 @@ export type TermV1 = (TermBase & {
 }) | (TermBase & CallShape & {
     op: "value.call";
     plan: number;
+}) | (TermBase & CallShape & {
+    op: "wire.codec";
+    codec: number;
+    format: number;
+    direction: "encode" | "decode" | "test_input";
+    decoded: {
+        shape: number;
+        ok: number;
+        error: number;
+        error_root: number;
+    } | null;
+    callbacks: Record<string, number[]>;
 }) | (TermBase & CallShape & {
     op: "runtime.call";
     family: number;
     structural?: number | null;
     callbacks?: number[];
     releases_contents?: boolean;
+    keeps_inputs_on_failure?: boolean;
     result_member_shapes?: Array<number | null>;
     result_shape: number | null;
 }) | (TermBase & CallShape & {
@@ -436,10 +468,6 @@ export type TermV1 = (TermBase & {
     };
     result_shape: number | null;
     error_shape: number | null;
-}) | (TermBase & CallShape & {
-    op: "wire.codec";
-    direction: string;
-    plan: number;
 }) | (TermBase & {
     op: "panic";
     message: BoundaryOperand;
@@ -498,7 +526,7 @@ export interface EntryPlan {
 export interface ActorProtocol {
     actor: number;
     message: number;
-    policy: "reject" | "wait" | "drop_newest" | "replace_latest";
+    policy: "reject" | "wait" | "drop_newest";
     sealed: boolean;
 }
 export type ActorOperation = {
@@ -558,7 +586,6 @@ export interface ActorShape {
         keys: Array<{
             message: number;
             param: number;
-            kind: string;
         }>;
     };
     max_heap_bytes?: number;
@@ -582,6 +609,7 @@ export interface SupervisorShape {
     }>;
 }
 export interface PackageV1 {
+    codecs?: string[];
     resources?: Array<{
         kind: string;
         ty?: string;