@hew-lang/sandbox-vm 0.10.0 → 0.11.0-rc3

package/README.md

@@ -61,6 +61,23 @@ A `sandbox_rejected` result includes rejection entries with `category`, `code`,
 checked traps, VM failures and step-budget exhaustion have distinct statuses.
 Consumers can offer explicit remote execution for native capabilities.
 
+## Crash details
+
+Actor callers and crash hooks receive the same originating `CrashInfo`, with
+owned kind, trap, message, site and trace fields. The VM captures up to 48 real
+Hew activations before unwind and folds consecutive identical functions into
+`StackFrame.repeat`. Distinct instruction sites remain separate. Diagnostic
+messages are bounded to 4096 UTF-8 bytes, including an explicit ` [truncated]`
+suffix when needed; oversized function names are omitted. Capture is always enabled; there is no VM trace-control
+option. Frames describe the failing execution rather than its observer.
+
+Current bytecode carries function names and byte-offset spans, but no source
+file and line table. `CrashInfo.site` and each frame's `site` are therefore
+`None`. A failure outside an executing Hew activation also has no trace.
+Diagnostic materialization respects the receiving actor's managed heap budget:
+it omits the trace first, then uses an empty message if necessary, preserving
+the original kind and trap when diagnostic storage cannot fit.
+
 ## Validation
 
 From the repository root:

package/dist/interpreter/v1/exec.js

@@ -21,6 +21,7 @@ import { Semaphores } from "./semaphores.js";
 import { FrameScheduler } from "./scheduler.js";
 import { DeterministicIds } from "../../scheduler/ids.js";
 import { Mt19937 } from "./mt19937.js";
+import { FAILURE_TEXT_LIMIT, FAILURE_TRUNCATED_SUFFIX, } from "./failure-limits.generated.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";
@@ -311,6 +312,7 @@ class ExecutorV1 {
                 if (op.op !== "coverage.hit")
                     this.commitStep();
                 try {
+                    act.instruction = op;
                     this.execute(act, op);
                 }
                 catch (error) {
@@ -325,6 +327,7 @@ class ExecutorV1 {
                 return;
             this.commitStep();
             try {
+                act.instruction = act.block.term;
                 this.terminate(act, act.block.term);
             }
             catch (error) {
@@ -725,8 +728,7 @@ class ExecutorV1 {
         previous?.budget?.changed();
         actor.budget?.changed();
     }
-    failActorBudget(actor) {
-        const fault = { kind: "trap", trap: "heap_exceeded" };
+    failActorBudget(actor, fault = { kind: "trap", trap: "heap_exceeded" }) {
         if (!actor.active)
             this.crashActor(actor, fault);
         else {
@@ -1944,6 +1946,7 @@ class ExecutorV1 {
                     message: renderMessage(message),
                     ...(assertion ? { assertion } : {}),
                 };
+                this.captureFault(act, act.fault);
                 if (act.context.actor)
                     act.context.actor.crashing ??= act.fault;
                 this.takeEdge(act, term.cleanup);
@@ -1951,6 +1954,7 @@ class ExecutorV1 {
             }
             case "checked_raise":
                 act.fault = { kind: "trap", trap: term.trap };
+                this.captureFault(act, act.fault);
                 if (act.context.actor)
                     act.context.actor.crashing ??= act.fault;
                 this.takeEdge(act, term.cleanup);
@@ -2644,6 +2648,7 @@ class ExecutorV1 {
     /// Raise a fault at a call site: enter the named unwind edge, or end the
     /// program when the call names none.
     raiseFault(act, fault, unwind) {
+        this.captureFault(act, fault);
         if (!unwind) {
             this.running = false;
             act.context.failed(fault);
@@ -2653,6 +2658,8 @@ class ExecutorV1 {
         this.takeEdge(act, unwind);
     }
     resumeUnwind(act, handback) {
+        if (act.fault)
+            this.captureFault(act, act.fault);
         if (this.finishConsumedCallable(act, null, () => this.resumeUnwind(act, handback)))
             return;
         if (this.finishConstruction(act, () => this.resumeUnwind(act, handback)))
@@ -2974,9 +2981,9 @@ class ExecutorV1 {
                 const wake = this.park(act, term);
                 let target;
                 let checkWait;
-                const cancelRequest = this.ask(protocol, inputs, (value, error, closeFault) => {
+                const cancelRequest = this.ask(protocol, inputs, (value, error, closeFault, _envelope, actorFault) => {
                     act.fault ??= closeFault ?? null;
-                    return wake(this.completion(term.result_shape, term.error_shape, value, error));
+                    return wake(this.completion(term.result_shape, term.error_shape, value, error, actorFault, act.accountActor?.budget));
                 }, term.request_shapes, (actor) => {
                     target = actor;
                     checkWait?.();
@@ -3056,6 +3063,7 @@ class ExecutorV1 {
                     act.depth > MAX_FRAME_DEPTH &&
                     act.block.id === act.fn.entry) {
                     act.fault = { kind: "trap", trap: "stack_overflow" };
+                    this.captureFault(act, act.fault);
                     this.takeEdge(act, term.cancel);
                     return;
                 }
@@ -3882,8 +3890,10 @@ class ExecutorV1 {
             },
         };
         const frame = this.activate(this.functionAt(callable), args, null, null, undefined, null, context);
-        if (invoker)
+        if (invoker) {
             frame.depth = invoker.depth + 1;
+            frame.traceCaller = invoker;
+        }
         retainedBy?.managedChildren.add(frame);
         let cancelled = null;
         context.cancel = (fault = { kind: "panic", message: "task cancelled", cancelled: true }) => {
@@ -3919,7 +3929,161 @@ class ExecutorV1 {
         }
         return value;
     }
-    completion(result, errorShape, value, error) {
+    /// Bytecode has real function identities but no file/line table. Capture
+    /// up to the native snapshot's 48 physical activations at the origin, before
+    /// unwind replaces them. The VM always captures available frames; it has no
+    /// environment-variable trace policy. Repeated frames retain their count.
+    captureFault(act, fault) {
+        const origin = fault.primary ?? fault;
+        if (origin.frames !== undefined)
+            return;
+        origin.frames = [];
+        let previous;
+        let previousInstruction;
+        let previousBlock;
+        let previousIndex;
+        for (let frame = act, count = 0; frame && count < 48; frame = frame.caller ?? frame.traceCaller ?? null, count++) {
+            if (!failureTextPrefix(frame.fn.name).complete) {
+                previous = undefined;
+                previousInstruction = undefined;
+                continue;
+            }
+            if (previous === frame.fn.id &&
+                frame.instruction !== undefined &&
+                previousInstruction === frame.instruction &&
+                previousBlock === frame.block.id &&
+                previousIndex === frame.opIndex)
+                origin.frames.at(-1).repeat++;
+            else
+                origin.frames.push({ function: frame.fn.name, repeat: 1 });
+            previous = frame.fn.id;
+            previousInstruction = frame.instruction;
+            previousBlock = frame.block.id;
+            previousIndex = frame.opIndex;
+        }
+    }
+    trappedError(errorShape, fault, budget) {
+        const row = (this.pkg.managed_types ?? []).find((row) => row.kind === "variant" && row.shape === errorShape);
+        if (!row || row.kind !== "variant")
+            throw new Error("actor error lacks its managed variant descriptor");
+        const tag = runtimeTag(this.pkg.variants[errorShape], "ActorErrorTrapped");
+        const type = row.cases[tag]?.[0];
+        if (type == null)
+            throw new Error("trapped actor completion lacks its crash payload descriptor");
+        return this.variant(errorShape, "ActorErrorTrapped", [
+            this.crashInfo(type, fault, budget),
+        ]);
+    }
+    crashInfo(type, fault, budget) {
+        const origin = fault.primary ?? fault;
+        const info = this.managed.row(type);
+        if (info.kind !== "aggregate" || info.fields.length !== 5)
+            throw new Error("crash payload lacks its five-field managed descriptor");
+        const variant = (type) => {
+            const row = this.managed.row(type);
+            if (row.kind !== "variant")
+                throw new Error("crash payload child is not a variant");
+            return row;
+        };
+        const option = (type, value) => this.variant(variant(type).shape, value === undefined ? "OptionNone" : "OptionSome", value === undefined ? [] : [value]);
+        const someType = (type) => {
+            const row = variant(type);
+            const child = row.cases[runtimeTag(this.pkg.variants[row.shape], "OptionSome")]?.[0];
+            if (child == null)
+                throw new Error("crash payload option lacks its child descriptor");
+            return child;
+        };
+        const aggregateShape = (type) => {
+            const row = this.managed.row(type);
+            if (row.kind !== "aggregate")
+                throw new Error("crash payload record lacks its descriptor");
+            const shape = row.shape;
+            if (shape == null)
+                throw new Error("crash payload record lacks its aggregate identity");
+            return shape;
+        };
+        const record = (type, fields) => {
+            const shape = aggregateShape(type);
+            return {
+                kind: "record",
+                typeId: this.aggregateName(shape),
+                shape,
+                fields,
+            };
+        };
+        const [kindType, trapType, , siteType, traceType] = info.fields;
+        const [code, reason] = faultInfo(origin);
+        const kind = this.variant(variant(kindType).shape, code === 200
+            ? "CrashKindHeapExceeded"
+            : code === 214
+                ? "CrashKindTimerOverdue"
+                : code === 213
+                    ? "CrashKindHandlerFailed"
+                    : code === 215
+                        ? "CrashKindStackOverflow"
+                        : "CrashKindFault");
+        const trap = variant(someType(trapType));
+        const trapTag = this.pkg.variants[trap.shape].cases.findIndex((item) => item.name === reason);
+        const trapValue = trapTag < 0
+            ? undefined
+            : {
+                kind: "enum",
+                typeId: this.variantName(trap.shape),
+                shape: trap.shape,
+                tag: trapTag,
+                payload: [],
+            };
+        const vector = this.managed.row(someType(traceType));
+        if (vector.kind !== "vector")
+            throw new Error("crash trace lacks its vector descriptor");
+        const frame = this.managed.row(vector.element);
+        if (frame.kind !== "aggregate" || frame.fields.length !== 3)
+            throw new Error("crash frame lacks its managed descriptor");
+        const frames = {
+            kind: "vector",
+            elementType: this.aggregateName(aggregateShape(vector.element)),
+            items: (origin.frames ?? []).map((item) => record(vector.element, [
+                stringValue(item.function),
+                option(frame.fields[1]),
+                { kind: "i64", value: BigInt(item.repeat) },
+            ])),
+        };
+        const value = record(type, [
+            kind,
+            option(trapType, trapValue),
+            stringValue(boundedFailureMessage(faultApplicationMessage(origin) ?? reason)),
+            option(siteType),
+            option(traceType, origin.frames === undefined ? undefined : frames),
+        ]);
+        if (value.kind !== "record")
+            throw new Error("crash payload is not a record");
+        // Diagnostics must not replace the original failure with an allocation
+        // failure. Drop trace storage first, then the message (site is unavailable).
+        for (const omit of [null, 4, 2]) {
+            if (omit === 4)
+                value.fields[4] = option(traceType);
+            if (omit === 2)
+                value.fields[2] = stringValue("");
+            try {
+                this.managed.stampGraph({ value, type });
+                budget?.check([{ value, type }]);
+                return value;
+            }
+            catch (error) {
+                if (!(error instanceof HeapExceeded))
+                    throw error;
+            }
+        }
+        return value;
+    }
+    completion(result, errorShape, value, error, fault, budget) {
+        if (error === "Trapped") {
+            if (!fault)
+                throw new Error("trapped actor completion lost its originating fault");
+            return this.variant(result, "ResultErr", [
+                this.trappedError(errorShape, fault, budget),
+            ]);
+        }
         return error
             ? this.variant(result, "ResultErr", [
                 this.variant(errorShape, actorErrorRole(error), (error === "Failed" || error === "Rejected") && value
@@ -4261,7 +4425,8 @@ class ExecutorV1 {
                 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 cancelRequest = this.ask(operation.protocol, args, (value, error, closeFault, envelope, actorFault) => {
+                    task.actorFault = actorFault;
                     const reply = this.managedCompletion(task, value, error, envelope);
                     if (reply && !closeFault && act.context.actor?.budget) {
                         try {
@@ -4270,12 +4435,12 @@ class ExecutorV1 {
                         catch (failure) {
                             if (!(failure instanceof HeapExceeded))
                                 throw failure;
+                            const fault = { kind: "trap", trap: "heap_exceeded" };
+                            this.captureFault(act, fault);
                             task.actorError = "Trapped";
-                            this.settleTask(task, UNIT, {
-                                kind: "trap",
-                                trap: "heap_exceeded",
-                            });
-                            this.failActorBudget(act.context.actor);
+                            task.actorFault = fault;
+                            this.settleTask(task, UNIT, fault);
+                            this.failActorBudget(act.context.actor, fault);
                             return false;
                         }
                     }
@@ -4308,7 +4473,7 @@ class ExecutorV1 {
                 task.value = UNIT;
                 task.taken = true;
                 const result = task.managedResult ??
-                    this.completion(term.result_shape, term.error_shape, value, task.actorError);
+                    this.completion(term.result_shape, term.error_shape, value, task.actorError, task.actorFault, act.accountActor?.budget);
                 task.managedResult = undefined;
                 task.managedReply = undefined;
                 this.completeShim(act, term, result);
@@ -4372,7 +4537,7 @@ class ExecutorV1 {
                         this.closeValueAsync(payload, "actor heap limit exceeded", (fault) => {
                             act.fault ??= fault;
                             finish(this.variant(term.result_shape, "ResultErr", [
-                                this.variant(term.error_shape, "ActorErrorTrapped"),
+                                this.trappedError(term.error_shape, actor.crashing ?? { kind: "trap", trap: "heap_exceeded" }, act.accountActor?.budget),
                             ]));
                         }, act.context.actor, act.rcOwner);
                         return;
@@ -4692,12 +4857,12 @@ class ExecutorV1 {
             ? { kind: "Actor", identity: owner.identity }
             : { kind: "Task" };
         let receiver = null;
-        const finish = (value, error, drained, envelope) => {
+        const finish = (value, error, drained, envelope, actorFault) => {
             const alreadySettled = settled;
             settled = true;
             cancelTimer?.();
             if (alreadySettled ||
-                complete(value, error, undefined, envelope) === false) {
+                complete(value, error, undefined, envelope, actorFault) === 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) => {
@@ -4733,7 +4898,7 @@ class ExecutorV1 {
                     waiter(fault);
             }, owner, rcOwner);
         };
-        const reject = (reason) => {
+        const reject = (reason, actorFault) => {
             if (settled || closing)
                 return;
             closeRequest((fault) => {
@@ -4741,7 +4906,7 @@ class ExecutorV1 {
                     return;
                 settled = true;
                 cancelTimer?.();
-                complete(null, reason, fault);
+                complete(null, reason, fault, undefined, actorFault);
             });
         };
         const attempt = () => {
@@ -4812,7 +4977,7 @@ class ExecutorV1 {
                 if (!(error instanceof HeapExceeded))
                     throw error;
                 this.failActorBudget(actor);
-                reject("Trapped");
+                reject("Trapped", actor.crashing ?? { kind: "trap", trap: "heap_exceeded" });
                 return;
             }
             admitted = true;
@@ -5141,7 +5306,7 @@ class ExecutorV1 {
                         this.closeValueAsync(value, this.faultText(fault), (closeFault) => {
                             released();
                             this.crashActor(actor, combineFaults(fault, closeFault), message.handler);
-                            message.complete(null, "Trapped");
+                            message.complete(null, "Trapped", undefined, undefined, fault);
                         }, actor, actor.rcOwner);
                         return;
                     }
@@ -5163,11 +5328,13 @@ class ExecutorV1 {
                             if (message.reply)
                                 message.complete(value.payload[0] ?? UNIT, "Failed", drained, value);
                             else {
-                                this.crashActor(actor, {
+                                const fault = {
                                     kind: "panic",
                                     handlerFailed: true,
                                     message: "unhandled declared handler failure",
-                                }, message.handler);
+                                };
+                                this.captureFault(frame, fault);
+                                this.crashActor(actor, fault, message.handler);
                                 return;
                             }
                         }
@@ -5196,7 +5363,7 @@ class ExecutorV1 {
                     }
                     else {
                         this.crashActor(actor, fault, message.handler);
-                        message.complete(null, "Trapped");
+                        message.complete(null, "Trapped", undefined, undefined, fault);
                     }
                 },
             });
@@ -5276,31 +5443,11 @@ class ExecutorV1 {
         };
         const runHook = () => {
             if (actor.layout.crash != null) {
-                const [code, reason] = faultInfo(fault);
-                const message = faultApplicationMessage(fault) ?? reason;
-                const info = {
-                    kind: "record",
-                    typeId: this.aggregateName(actor.layout.crash_info),
-                    shape: actor.layout.crash_info,
-                    fields: [
-                        {
-                            kind: "enum",
-                            typeId: this.variantName(actor.layout.crash_kind),
-                            shape: actor.layout.crash_kind,
-                            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)),
-                    ],
-                };
+                const type = this.functionAt(actor.layout.crash).params[1]
+                    ?.managed_type;
+                if (type == null)
+                    throw new Error("crash hook lacks its crash payload descriptor");
+                const info = this.crashInfo(type, fault, actor.budget);
                 let cancelTimer;
                 const complete = (action) => {
                     cancelTimer?.();
@@ -5850,6 +5997,7 @@ class ExecutorV1 {
         });
     }
     haltWithFault(fault) {
+        this.captureFault(this.current, fault);
         const isPanic = fault.kind === "panic";
         const status = isPanic ? "panic" : "trap";
         const trapKind = isPanic ? "panic" : fault.trap;
@@ -5866,6 +6014,25 @@ class ExecutorV1 {
         throw new Halt(status);
     }
 }
+/// Retain only bounded scratch space even when raw fault text or a compiler
+/// function name is much larger than the public diagnostic limit.
+function failureTextPrefix(text) {
+    const bytes = new Uint8Array(FAILURE_TEXT_LIMIT);
+    const { read, written } = new TextEncoder().encodeInto(text, bytes);
+    return { bytes: bytes.subarray(0, written), complete: read === text.length };
+}
+/// Match the owned native snapshot without changing raw fault reporting.
+/// The suffix counts inside the UTF-8 limit and never splits a character.
+function boundedFailureMessage(message) {
+    const { bytes, complete } = failureTextPrefix(message);
+    if (complete)
+        return message;
+    let end = Math.min(bytes.length, FAILURE_TEXT_LIMIT -
+        new TextEncoder().encode(FAILURE_TRUNCATED_SUFFIX).length);
+    while ((bytes[end] & 0xc0) === 0x80)
+        end--;
+    return (new TextDecoder().decode(bytes.subarray(0, end)) + FAILURE_TRUNCATED_SUFFIX);
+}
 function combineFaults(primary, secondary) {
     if (!primary)
         return secondary;

package/dist/interpreter/v1/failure-limits.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const FAILURE_TEXT_LIMIT = 4096;
+export declare const FAILURE_TRUNCATED_SUFFIX = " [truncated]";

package/dist/interpreter/v1/failure-limits.generated.js

@@ -0,0 +1,3 @@
+// Generated by scripts/gen-failure-kinds.py; do not edit.
+export const FAILURE_TEXT_LIMIT = 4096;
+export const FAILURE_TRUNCATED_SUFFIX = " [truncated]";

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

@@ -308,6 +308,10 @@ export type ManagedType = {
     element: number;
 } | {
     kind: "aggregate";
+    /**
+     * The canonical record shape when this layout represents a record.
+     */
+    shape?: number | null;
     fields: Array<number>;
 } | {
     kind: "variant";
@@ -749,7 +753,7 @@ export type RuntimeCallFamily = {
     IntArith: [IntArithKind, IntMethodWidth];
 } | {
     FloatMethod: FloatMethodOp;
-} | "NodeConnect" | "NodeId" | "NodeIdDisplay" | "LocationNodeId" | "LocationIncarnation" | "LocationDisplay" | "NodeIdentityKey" | "NodeLoadKeys" | "NodeLookup" | "NodeRegister" | "NodeSetTransport" | "NodeShutdown" | "NodeStart" | "MetricCounterRegister" | "MetricCounterInc" | "MetricCounterAdd" | "MetricGaugeRegister" | "MetricGaugeSet" | "MetricGaugeInc" | "MetricGaugeDec" | "MetricGaugeAdd" | "MetricHistogramRegister" | "MetricHistogramRegisterSimple" | "MetricHistogramRecord" | "MetricVecRegister" | "MetricVecWith" | "ObserveReadU64" | "ObserveScrape" | "ObserveSeries" | "ObserveBarrier" | "RcClone" | "RcDowngrade" | "RcDrop" | "RcGet" | "RcIsUnique" | "RcNew" | "RcSet" | "RcStrongCount" | "RcWeakCount" | "WeakCloneRc" | "WeakDropRc" | "WeakUpgradeRc" | "RegexCapture" | "RegexCompile" | "RegexFreeCapture" | "RegexHandle" | "RegexMatch" | "ReplyChannelCancel" | "ReplyChannelFree" | "ReplyChannelNew" | "ReplyPayloadFree" | "ReplyWait" | "SelectFirst" | "SinkClone" | "SinkClose" | "StreamClose" | "StreamForward" | "StreamPipe" | "StreamFromGenerator" | "SinkFromEncoder" | "StreamNextLayout" | "StreamPairSink" | "StreamPairStream" | "StreamSendLayout" | "StreamTake" | "StreamTryNextLayout" | "StreamTrySendLayout" | "CharIsDigit" | "CharIsLetter" | "CharIsAlphanumeric" | "CharIsWhitespace" | "CharIsUpper" | "CharIsLower" | "CharIsPunctuation" | "CharIsControl" | "CharIsAscii" | "CharToUpper" | "CharToLower" | "CharToTitle" | "CharLenUtf8" | "CharToDigit" | "CharFromI64" | "CharFromU64" | "StringGet" | "StringGetRange" | "StringSliceRange" | "StringAppend" | "StringPush" | "StringClear" | "StringFindFrom" | "StringByteLen" | "StringConcat" | "StringEquals" | "StringCompare" | "StringStartsWith" | "StringEndsWith" | "StringContains" | "StringIsEmpty" | "StructuralFormat" | "StringFind" | "StringIndex" | "StringLen" | "StringRepeat" | "StringReplace" | "StringClone" | "StringSplit" | "StringLines" | "StringSliceCodepoints" | "StringSliceCodepointsFrom" | "StringToLowercase" | "StringToBytes" | "StringToUppercase" | "StringTrim" | "U8ToString" | "I32ToString" | "I64ToString" | "U32ToString" | "U64ToString" | "F64ToString" | "CharToString" | {
+} | "NodeConnect" | "NodeId" | "NodeIdDisplay" | "LocationNodeId" | "LocationIncarnation" | "LocationDisplay" | "NodeIdentityKey" | "NodeLoadKeys" | "NodeLookup" | "NodeRegister" | "NodeSetTransport" | "NodeShutdown" | "NodeStart" | "MetricCounterRegister" | "MetricCounterInc" | "MetricCounterAdd" | "MetricGaugeRegister" | "MetricGaugeSet" | "MetricGaugeInc" | "MetricGaugeDec" | "MetricGaugeAdd" | "MetricHistogramRegister" | "MetricHistogramRegisterSimple" | "MetricHistogramRecord" | "MetricVecRegister" | "MetricVecWith" | "ObserveReadU64" | "ObserveScrape" | "ObserveSeries" | "ObserveBarrier" | "RcClone" | "RcDowngrade" | "RcDrop" | "RcGet" | "RcIsUnique" | "RcNew" | "RcSet" | "RcStrongCount" | "RcWeakCount" | "WeakCloneRc" | "WeakDropRc" | "WeakUpgradeRc" | "RegexCapture" | "RegexCompile" | "RegexFreeCapture" | "RegexHandle" | "RegexMatch" | "ReplyChannelCancel" | "ReplyChannelFree" | "ReplyChannelNew" | "ReplyPayloadFree" | "ReplyWait" | "SelectFirst" | "SinkClone" | "SinkClose" | "StreamClose" | "StreamForward" | "StreamPipe" | "StreamFromGenerator" | "SinkFromEncoder" | "StreamNextLayout" | "StreamPairSink" | "StreamPairStream" | "StreamSendLayout" | "StreamTake" | "StreamTryNextLayout" | "StreamTrySendLayout" | "CharIsDigit" | "CharIsLetter" | "CharIsAlphanumeric" | "CharIsWhitespace" | "CharIsUpper" | "CharIsLower" | "CharIsPunctuation" | "CharIsControl" | "CharIsAscii" | "CharToUpper" | "CharToLower" | "CharToTitle" | "CharLenUtf8" | "CharToDigit" | "CharFromI64" | "CharFromU64" | "StringGet" | "StringGetRange" | "StringSliceRange" | "StringAppend" | "StringPush" | "StringClear" | "StringAppendI64" | "StringAppendU64" | "StringAppendF64" | "StringAppendBool" | "StringAppendLiteral" | "StringFindFrom" | "StringByteLen" | "StringConcat" | "StringEquals" | "StringCompare" | "StringStartsWith" | "StringEndsWith" | "StringContains" | "StringIsEmpty" | "StructuralFormat" | "StringFind" | "StringIndex" | "StringLen" | "StringRepeat" | "StringReplace" | "StringClone" | "StringSplit" | "StringLines" | "StringSliceCodepoints" | "StringSliceCodepointsFrom" | "StringToLowercase" | "StringToBytes" | "StringToUppercase" | "StringTrim" | "U8ToString" | "I32ToString" | "I64ToString" | "U32ToString" | "U64ToString" | "F64ToString" | "CharToString" | {
     Print: {
         kind: PrintKind;
         newline: boolean;

package/dist/interpreter/v1/package-graph.js

@@ -54,6 +54,12 @@ export function validatePackageGraph(pkg) {
                 managedType(row.value);
                 break;
             case "aggregate":
+                if (row.shape != null) {
+                    const shape = at(pkg.aggregates, row.shape, "managed aggregate shape");
+                    require(shape.fields.length ===
+                        row.fields
+                            .length, "managed aggregate fields differ from its shape");
+                }
                 row.fields.forEach(managedType);
                 break;
             case "variant":