@hew-lang/sandbox-vm 0.6.2 → 0.6.3

package/dist/interpreter/v1/shims.js

@@ -1,12 +1,8 @@
+import { DIRECTORY_OPERATIONS, } from "./browser-directory.js";
+import { executeCalendar } from "./calendar.js";
 import { charProperty, charCase } from "../unicode.js";
-/// The VM's runtime-family and extern shim table.
-///
-/// This table is the runtime-family admission authority: a package may name a
-/// runtime family or an extern symbol exactly when there is a shim here for it.
-/// A family or symbol with no entry is rejected at load, so there is no second
-/// reject list to keep in step with this one. `FileRead` is refused by its
-/// absence, and a `NativeIo` suspension by an operation missing from
-/// [`SUPPORTED_NATIVE_IO`].
+/// 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 { seededMt } from "./mt19937.js";
 /// A language-visible fault raised inside a shim. The executor routes it to the
@@ -19,127 +15,252 @@ export class ShimFault extends Error {
         this.name = "ShimFault";
     }
 }
-/// Resolve a declared runtime family to its shim, or `undefined` when the VM
-/// has none. Both the load-time validator and the executor go through here, so
-/// admission and execution can never disagree about what is implemented.
-export function resolveRuntimeShim(entry) {
+function ordinary(shim) {
+    return { kind: "ordinary", shim };
+}
+function refused(capability, native = false) {
+    return {
+        kind: "refused",
+        category: native ? "native_only" : "not_implemented",
+        capability,
+    };
+}
+function resumable(continuation) {
+    return { kind: "resumable", ...continuation };
+}
+/// A registered algorithm may still require a host-supplied Wasm bridge.
+export function registrationRefusal(registration, bridges) {
+    if (registration.kind === "refused")
+        return registration;
+    if (registration.kind === "directory" &&
+        registration.operation.action === "root" &&
+        !bridges.directoryRoots?.[registration.operation.access])
+        return {
+            ...refused(`directoryRoots.${registration.operation.access}`),
+            message: `This operation requires a host-supplied OPFS ${registration.operation.access} directory handle.`,
+        };
+    return "bridge" in registration &&
+        registration.bridge &&
+        typeof bridges[registration.bridge] !== "function"
+        ? refused(registration.bridge)
+        : null;
+}
+export const CODEC_REGISTRATION = {
+    kind: "resumable",
+    bridge: "codecBridge",
+};
+/// Each typed runtime identity has exactly one host disposition. An added Rust
+/// family or nested operation must acquire a disposition before TypeScript builds.
+export function resolveRuntime(entry) {
     switch (entry.family) {
         case "SupervisorPool":
-            return ["Len", "Member", "Get"].includes(String(entry.detail))
-                ? () => {
-                    throw new Error("SupervisorPool requires its resumable executor");
-                }
-                : undefined;
-        case "ActorCaller":
-        case "ActorRefusalLog":
-        case "StructuralFormat":
-            return () => {
-                throw new Error("StructuralFormat requires its resumable executor");
-            };
-        case "FileRead":
-            return entry.detail === "LastError" ? () => str("") : undefined;
+            return resumable({ handler: "supervisor_pool", operation: entry.detail });
         case "Print":
-            return printShim(entry.detail);
-        case "RcNew":
-        case "RcClone":
-        case "RcDowngrade":
-        case "WeakCloneRc":
-        case "WeakUpgradeRc":
-        case "RcGet":
-        case "RcIsUnique":
-        case "RcSet":
-        case "RcStrongCount":
-        case "RcWeakCount":
-            return () => {
-                throw new Error("shared operation requires its resumable executor");
-            };
-        case "Vector":
-            return ["Contains", "Set", "Clear"].includes(String(entry.detail))
-                ? () => {
-                    throw new Error("vector Contains requires its selected Eq executor");
+            return ordinary(printShim(entry.detail));
+        case "FileRead":
+            switch (entry.detail) {
+                case "HasError":
+                case "LastErrorKind":
+                case "LastErrno":
+                case "LastError": {
+                    const operation = entry.detail;
+                    return ordinary((host) => host.fileError(operation));
                 }
-                : VECTOR_SHIMS[detailName(entry.detail)];
+                default:
+                    return refused(`FileRead::${entry.detail}`, true);
+            }
+        case "AsyncIo":
+        case "Tcp":
+            return refused(`${entry.family}::${entry.detail}`, true);
+        case "Semaphore":
+        case "Service":
+        case "VecContainsScalar":
+        case "VecGet":
+        case "VecSliceRange":
+            return refused(`${entry.family}::${entry.detail}`);
+        case "Encoding":
+        case "VecScalar":
+            return refused(entry.family);
+        case "Vector":
+            switch (entry.detail) {
+                case "Contains":
+                case "Set":
+                case "Clear":
+                    return resumable({
+                        handler: "collection",
+                        family: "Vector",
+                        operation: entry.detail,
+                    });
+                case "Pop":
+                case "GetBorrow":
+                case "TakeFirst":
+                case "TakeAll":
+                case "Append":
+                    return refused(`Vector::${entry.detail}`);
+                default:
+                    return ordinary(VECTOR_SHIMS[entry.detail]);
+            }
         case "Array":
-            return entry.detail === "Set"
-                ? () => {
-                    throw new Error("array mutation requires its resumable executor");
+            switch (entry.detail) {
+                case "Set":
+                    return resumable({
+                        handler: "collection",
+                        family: "Vector",
+                        operation: entry.detail,
+                    });
+                case "Len":
+                case "Index":
+                case "IndexBorrow":
+                    return ordinary(VECTOR_SHIMS[entry.detail]);
+                default: {
+                    const exhaustive = entry;
+                    throw new Error(`unknown array operation ${String(exhaustive)}`);
                 }
-                : entry.detail === "IndexBorrow"
-                    ? (_host, args) => sequenceElement(args)
-                    : ["Len", "Index"].includes(String(entry.detail))
-                        ? VECTOR_SHIMS[detailName(entry.detail)]
-                        : undefined;
+            }
         case "Map":
+            return resumable({
+                handler: "collection",
+                family: "Map",
+                operation: entry.detail,
+            });
         case "Set":
-            return [
-                "New",
-                "Len",
-                "Index",
-                "Get",
-                "GetBorrow",
-                "ContainsKey",
-                "Contains",
-                "Insert",
-                "Remove",
-                "Clear",
-                "Keys",
-                "Values",
-                "Entries",
-                "Elements",
-            ].includes(detailName(entry.detail))
-                ? () => {
-                    throw new Error("collection operation requires its resumable executor");
-                }
-                : undefined;
+            return resumable({
+                handler: "collection",
+                family: "Set",
+                operation: entry.detail,
+            });
         case "MathIntrinsic":
-            return MATH_SHIMS[detailName(entry.detail)];
+            return ordinary(MATH_SHIMS[entry.detail]);
         case "FloatMethod":
-            return FLOAT_METHOD_SHIMS[detailName(entry.detail)];
+            return ordinary(FLOAT_METHOD_SHIMS[entry.detail]);
         case "IntMethod":
-            return intMethodShim(entry.detail);
+            return ordinary(intMethodShim(entry.detail));
         case "IntArith":
-            return intArithShim(entry.detail);
-        default:
-            return UNIT_FAMILY_SHIMS[entry.family];
+            return ordinary(intArithShim(entry.detail));
+        default: {
+            const registration = UNIT_FAMILIES[entry.family];
+            return typeof registration === "function"
+                ? ordinary(registration)
+                : registration;
+        }
+    }
+}
+export function resolveExtern(entry) {
+    if (Object.hasOwn(DIRECTORY_OPERATIONS, entry.symbol))
+        return {
+            kind: "directory",
+            operation: DIRECTORY_OPERATIONS[entry.symbol],
+        };
+    const registration = Object.hasOwn(EXTERN_SHIMS, entry.symbol)
+        ? EXTERN_SHIMS[entry.symbol]
+        : undefined;
+    if (typeof registration === "function")
+        return ordinary(registration);
+    return (registration ?? {
+        ...refused(entry.symbol, entry.native_capability != null),
+        description: entry.native_capability ?? undefined,
+    });
+}
+const SUSPENSION_ROUTES = {
+    GeneratorNext: "GeneratorNext",
+    Yield: "Yield",
+    Sleep: "Sleep",
+    Safepoint: "Safepoint",
+    Ask: "Ask",
+    Await: "Await",
+    Join: "Join",
+    Select: "Select",
+    StreamSend: "StreamSend",
+    StreamNext: "StreamNext",
+    NativeIo: "NativeIo",
+    Read: refused("Read", true),
+    Accept: refused("Accept", true),
+    SleepUntil: refused("SleepUntil"),
+    ServiceAcquire: refused("ServiceAcquire"),
+    SemaphoreAcquire: refused("SemaphoreAcquire"),
+    ActorSend: refused("ActorSend"),
+    RestartWait: refused("RestartWait"),
+    CallClosure: refused("CallClosure"),
+    Timeout: refused("Timeout"),
+    ScopeDeadline: refused("ScopeDeadline"),
+    Offload: refused("Offload"),
+};
+export function suspensionRefusal(kind) {
+    const route = SUSPENSION_ROUTES[kind];
+    return typeof route === "string" ? null : route;
+}
+function executableSuspension(term) {
+    return suspensionRefusal(term.kind) === null;
+}
+const NATIVE_IO_ROUTES = {
+    StdinReadLine: "StdinReadLine",
+    SinkFinish: "SinkFinish",
+    TcpRead: refused("NativeIo::TcpRead", true),
+    TcpWrite: refused("NativeIo::TcpWrite", true),
+    TcpAccept: refused("NativeIo::TcpAccept", true),
+    TcpConnect: refused("NativeIo::TcpConnect", true),
+    TcpConnectTimeout: refused("NativeIo::TcpConnectTimeout", true),
+    TlsConnect: refused("NativeIo::TlsConnect", true),
+    TlsRead: refused("NativeIo::TlsRead", true),
+    TlsWrite: refused("NativeIo::TlsWrite", true),
+    FileRead: "FileRead",
+    FileWrite: "FileWrite",
+};
+function nativeIoRefusal(operation) {
+    const route = NATIVE_IO_ROUTES[operation];
+    return typeof route === "string" ? null : route;
+}
+function executableNativeIo(term) {
+    return nativeIoRefusal(term.detail.operation) === null;
+}
+/// The executor handles exactly the resumable identities registered above.
+export function resolveSuspension(term) {
+    if (!executableSuspension(term))
+        return suspensionRefusal(term.kind);
+    if (term.kind === "NativeIo") {
+        if (!executableNativeIo(term))
+            return nativeIoRefusal(term.detail.operation);
+        return { kind: "resumable", term };
     }
+    return { kind: "resumable", term };
 }
-export function resolveExternShim(symbol) {
-    return EXTERN_SHIMS[symbol];
-}
-/// The suspend kinds a sequential package may carry. `NativeIo` is admitted
-/// per operation through [`SUPPORTED_NATIVE_IO`] instead.
-export const SUPPORTED_SUSPEND_KINDS = new Set([
-    "GeneratorNext",
-    "Yield",
-    "Sleep",
-    "Safepoint",
-    "Ask",
-    "Await",
-    "Join",
-    "Select",
-    "StreamSend",
-    "StreamNext",
-]);
-/// The VM serves replay standard input and in-memory sink closure.
-export const SUPPORTED_NATIVE_IO = new Set([
-    "StdinReadLine",
-    "SinkFinish",
-]);
 // ── families ────────────────────────────────────────────────────────────────
 /// `Print { kind, newline }`. The rendering follows the value's own
 /// representation: casts normalize an integer into its target range, so the
 /// declared `kind` never changes how a value prints.
 function printShim(detail) {
-    if (typeof detail !== "object" || detail === null) {
-        return undefined;
-    }
-    const newline = detail.newline === true;
+    const newline = detail.newline;
     return (host, args) => {
         host.writeStdout(newline ? `${renderStdout(arg(args, 0))}\n` : renderStdout(arg(args, 0)));
         return UNIT;
     };
 }
-const UNIT_FAMILY_SHIMS = {
+const UNIT_FAMILIES = {
+    TimestampNow: (host, _args, _variant, aggregate) => {
+        const millis = host.unixTimeMillis();
+        if (!Number.isFinite(millis))
+            throw new ShimFault("integer_overflow", "host wall clock is not finite");
+        const seconds = Math.floor(millis / 1000);
+        let nanos = Math.round((millis - seconds * 1000) * 1_000_000);
+        let whole = BigInt(seconds);
+        if (nanos === 1_000_000_000) {
+            whole += 1n;
+            nanos = 0;
+        }
+        if (whole < -(1n << 63n) ||
+            whole >= 1n << 63n ||
+            nanos < 0 ||
+            nanos >= 1_000_000_000)
+            throw new ShimFault("integer_overflow", "host wall clock exceeds timestamp range");
+        if (!aggregate || aggregate.builtin !== "Timestamp")
+            throw new TypeError("timestamp clock lacks its aggregate descriptor");
+        return {
+            kind: "record",
+            typeId: aggregate.name,
+            shape: aggregate.id,
+            fields: [int(whole), int(BigInt(nanos))],
+        };
+    },
     StderrWrite: (host, args) => {
         host.writeStderr(text(args, 0));
         return UNIT;
@@ -156,14 +277,8 @@ const UNIT_FAMILY_SHIMS = {
     StreamFromGenerator: (host, args) => host.generatorStream(arg(args, 0)),
     SinkFromEncoder: (host, args) => host.encoderSink(arg(args, 0), arg(args, 1)),
     SinkClone: (host, args) => host.cloneSink(arg(args, 0)),
-    SinkClose: (host, args) => {
-        host.closePipe(arg(args, 0));
-        return UNIT;
-    },
-    StreamClose: (host, args) => {
-        host.closePipe(arg(args, 0));
-        return UNIT;
-    },
+    SinkClose: resumable({ handler: "close" }),
+    StreamClose: resumable({ handler: "close" }),
     StringConcat: (_host, args) => str(`${text(args, 0)}${text(args, 1)}`),
     StringClone: (_host, args) => cloneValue(arg(args, 0)),
     StringEquals: (_host, args) => bool(text(args, 0) === text(args, 1)),
@@ -291,9 +406,7 @@ const UNIT_FAMILY_SHIMS = {
     CharFromI64: checkedChar,
     CharFromU64: checkedChar,
     CharToString: (_host, args) => str(renderStdout(arg(args, 0))),
-    BytesDecodeUtf8: () => {
-        throw new Error("UTF-8 decode requires its checked result carrier");
-    },
+    BytesDecodeUtf8: resumable({ handler: "utf8_decode" }),
     // TextDecoder replaces each maximal invalid subsequence with U+FFFD, as
     // native lossy decoding does.
     BytesDecodeUtf8Lossy: (_host, args) => str(decodeUtf8(arg(args, 0))),
@@ -388,6 +501,165 @@ const UNIT_FAMILY_SHIMS = {
             ],
         };
     },
+    ActorDemonitor: refused("ActorDemonitor"),
+    ActorLink: refused("ActorLink"),
+    ActorMonitor: refused("ActorMonitor"),
+    ActorCaller: resumable({ handler: "actor_caller" }),
+    ActorRefusalLog: resumable({ handler: "actor_refusal_log" }),
+    ActorUnlink: refused("ActorUnlink"),
+    AutoMutexAlloc: refused("AutoMutexAlloc"),
+    AutoMutexFree: refused("AutoMutexFree"),
+    AutoMutexLock: refused("AutoMutexLock"),
+    AutoMutexUnlock: refused("AutoMutexUnlock"),
+    DequePopFront: refused("DequePopFront"),
+    DequePopBack: refused("DequePopBack"),
+    CancelTokenIsRequested: refused("CancelTokenIsRequested"),
+    CancelTokenRelease: refused("CancelTokenRelease"),
+    CancelTokenRetain: refused("CancelTokenRetain"),
+    ActorRequestRelease: refused("ActorRequestRelease"),
+    ActorCallFree: refused("ActorCallFree"),
+    ActorRequestTake: refused("ActorRequestTake"),
+    DurationAbs: refused("DurationAbs"),
+    DurationHours: refused("DurationHours"),
+    DurationIsZero: refused("DurationIsZero"),
+    DurationMicros: refused("DurationMicros"),
+    DurationMillis: refused("DurationMillis"),
+    DurationMins: refused("DurationMins"),
+    DurationNanos: refused("DurationNanos"),
+    DurationSecs: refused("DurationSecs"),
+    DynBoxAlloc: refused("DynBoxAlloc"),
+    DynBoxFree: refused("DynBoxFree"),
+    HashMapContainsKeyLayout: refused("HashMapContainsKeyLayout"),
+    HashMapClearLayout: refused("HashMapClearLayout"),
+    HashMapCloneLayout: refused("HashMapCloneLayout"),
+    HashMapEntriesLayout: refused("HashMapEntriesLayout"),
+    HashMapFreeLayout: refused("HashMapFreeLayout"),
+    HashMapGetLayout: refused("HashMapGetLayout"),
+    HashMapInsertLayout: refused("HashMapInsertLayout"),
+    HashMapKeysLayout: refused("HashMapKeysLayout"),
+    HashMapLenLayout: refused("HashMapLenLayout"),
+    HashMapNew: refused("HashMapNew"),
+    HashMapNewWithLayout: refused("HashMapNewWithLayout"),
+    HashMapRemoveLayout: refused("HashMapRemoveLayout"),
+    HashMapValuesLayout: refused("HashMapValuesLayout"),
+    HashSetContainsLayout: refused("HashSetContainsLayout"),
+    HashSetClearLayout: refused("HashSetClearLayout"),
+    HashSetCloneLayout: refused("HashSetCloneLayout"),
+    HashSetFreeLayout: refused("HashSetFreeLayout"),
+    HashSetInsertLayout: refused("HashSetInsertLayout"),
+    HashSetIsEmptyLayout: refused("HashSetIsEmptyLayout"),
+    HashSetLenLayout: refused("HashSetLenLayout"),
+    HashSetNew: refused("HashSetNew"),
+    HashSetNewWithLayout: refused("HashSetNewWithLayout"),
+    HashSetRemoveLayout: refused("HashSetRemoveLayout"),
+    HashSetToVecLayout: refused("HashSetToVecLayout"),
+    InstantDurationSince: refused("InstantDurationSince"),
+    InstantElapsed: refused("InstantElapsed"),
+    InstantNow: refused("InstantNow"),
+    NodeAllowPeer: refused("NodeAllowPeer"),
+    NodeConnect: refused("NodeConnect"),
+    NodeId: refused("NodeId"),
+    NodeIdDisplay: refused("NodeIdDisplay"),
+    LocationNodeId: refused("LocationNodeId"),
+    LocationIncarnation: refused("LocationIncarnation"),
+    LocationDisplay: refused("LocationDisplay"),
+    NodeIdentityKey: refused("NodeIdentityKey"),
+    NodeLoadKeys: refused("NodeLoadKeys"),
+    NodeLookup: refused("NodeLookup"),
+    NodeRegister: refused("NodeRegister"),
+    NodeSetTransport: refused("NodeSetTransport"),
+    NodeShutdown: refused("NodeShutdown"),
+    NodeStart: refused("NodeStart"),
+    MetricCounterRegister: refused("MetricCounterRegister"),
+    MetricCounterInc: refused("MetricCounterInc"),
+    MetricCounterAdd: refused("MetricCounterAdd"),
+    MetricGaugeRegister: refused("MetricGaugeRegister"),
+    MetricGaugeSet: refused("MetricGaugeSet"),
+    MetricGaugeInc: refused("MetricGaugeInc"),
+    MetricGaugeDec: refused("MetricGaugeDec"),
+    MetricGaugeAdd: refused("MetricGaugeAdd"),
+    MetricHistogramRegister: refused("MetricHistogramRegister"),
+    MetricHistogramRegisterSimple: refused("MetricHistogramRegisterSimple"),
+    MetricHistogramRecord: refused("MetricHistogramRecord"),
+    MetricVecRegister: refused("MetricVecRegister"),
+    MetricVecWith: refused("MetricVecWith"),
+    ObserveReadU64: refused("ObserveReadU64"),
+    ObserveScrape: refused("ObserveScrape"),
+    ObserveSeries: refused("ObserveSeries"),
+    ObserveBarrier: refused("ObserveBarrier"),
+    RcClone: resumable({ handler: "shared", operation: "RcClone" }),
+    RcDowngrade: resumable({ handler: "shared", operation: "RcDowngrade" }),
+    RcDrop: refused("RcDrop"),
+    RcGet: resumable({ handler: "shared", operation: "RcGet" }),
+    RcIsUnique: resumable({ handler: "shared", operation: "RcIsUnique" }),
+    RcNew: resumable({ handler: "shared", operation: "RcNew" }),
+    RcSet: resumable({ handler: "shared", operation: "RcSet" }),
+    RcStrongCount: resumable({ handler: "shared", operation: "RcStrongCount" }),
+    RcWeakCount: resumable({ handler: "shared", operation: "RcWeakCount" }),
+    WeakCloneRc: resumable({ handler: "shared", operation: "WeakCloneRc" }),
+    WeakDropRc: refused("WeakDropRc"),
+    WeakUpgradeRc: resumable({ handler: "shared", operation: "WeakUpgradeRc" }),
+    RegexCapture: refused("RegexCapture"),
+    RegexCompile: refused("RegexCompile"),
+    RegexFreeCapture: refused("RegexFreeCapture"),
+    RegexHandle: refused("RegexHandle"),
+    RegexMatch: refused("RegexMatch"),
+    ReplyChannelCancel: refused("ReplyChannelCancel"),
+    ReplyChannelFree: refused("ReplyChannelFree"),
+    ReplyChannelNew: refused("ReplyChannelNew"),
+    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"),
+    StreamTryNextLayout: refused("StreamTryNextLayout"),
+    StreamTrySendLayout: refused("StreamTrySendLayout"),
+    StructuralFormat: resumable({ handler: "structural_format" }),
+    StringLines: refused("StringLines"),
+    ProcessExit: refused("ProcessExit"),
+    SupervisorDirectId: refused("SupervisorDirectId"),
+    SupervisorChildGet: refused("SupervisorChildGet"),
+    LocalPidSupervisorChildGet: refused("LocalPidSupervisorChildGet"),
+    SupervisorNestedGet: refused("SupervisorNestedGet"),
+    SupervisorPoolChildGet: refused("SupervisorPoolChildGet"),
+    LocalPidSupervisorPoolChildRefGet: refused("LocalPidSupervisorPoolChildRefGet"),
+    SupervisorPoolLen: refused("SupervisorPoolLen"),
+    SupervisorStop: refused("SupervisorStop"),
+    TlsAttachLocal: refused("TlsAttachLocal"),
+    WebSocketAttachLocal: refused("WebSocketAttachLocal"),
+    TaskFree: refused("TaskFree"),
+    GeneratorFree: refused("GeneratorFree"),
+    VecAppend: refused("VecAppend"),
+    VecClear: refused("VecClear"),
+    VecClone: refused("VecClone"),
+    VecCloneLayout: refused("VecCloneLayout"),
+    VecCloneOwned: refused("VecCloneOwned"),
+    VecContainsLayout: refused("VecContainsLayout"),
+    VecTakeAll: refused("VecTakeAll"),
+    VecContainsOwned: refused("VecContainsOwned"),
+    VecIsEmpty: refused("VecIsEmpty"),
+    VecJoinStr: refused("VecJoinStr"),
+    VecLen: refused("VecLen"),
+    VecNew: refused("VecNew"),
+    VecPopBool: refused("VecPopBool"),
+    VecPopLayout: refused("VecPopLayout"),
+    VecPopOwned: refused("VecPopOwned"),
+    VecPushBool: refused("VecPushBool"),
+    VecPushLayout: refused("VecPushLayout"),
+    VecPushOwned: refused("VecPushOwned"),
+    VecPushOwnedMove: refused("VecPushOwnedMove"),
+    VecRemoveAtBool: refused("VecRemoveAtBool"),
+    VecRemoveAtLayout: refused("VecRemoveAtLayout"),
+    VecRemoveAtOwned: refused("VecRemoveAtOwned"),
+    VecSetBool: refused("VecSetBool"),
+    VecSetLayout: refused("VecSetLayout"),
+    VecSetOwned: refused("VecSetOwned"),
+    VecSetOwnedMove: refused("VecSetOwnedMove"),
+    VtableDispatchPanicOnOob: refused("VtableDispatchPanicOnOob"),
 };
 const VECTOR_SHIMS = {
     New: () => ({ kind: "vector", elementType: "", items: [] }),
@@ -596,8 +868,6 @@ const FLOAT_METHOD_SHIMS = {
     },
     IsSignNegative: (_host, args) => bool(toBits(real(args, 0)) >> 63n === 1n),
 };
-/// The receiver width an `IntMethod`/`IntArith` detail names. The VM is a
-/// 64-bit target, so the pointer-sized widths are 64 bits wide.
 const INT_WIDTHS = {
     I8: { bits: 8, signed: true },
     I16: { bits: 16, signed: true },
@@ -610,15 +880,6 @@ const INT_WIDTHS = {
     U64: { bits: 64, signed: false },
     Usize: { bits: 64, signed: false },
 };
-/// `[op, width]`, as `RuntimeCallFamily` serializes a two-field variant.
-function intDetail(detail) {
-    if (!Array.isArray(detail) || detail.length !== 2) {
-        return undefined;
-    }
-    const [op, width] = detail;
-    const shape = typeof width === "string" ? INT_WIDTHS[width] : undefined;
-    return typeof op === "string" && shape ? [op, shape] : undefined;
-}
 function wrapTo(width, value) {
     return width.signed
         ? BigInt.asIntN(width.bits, value)
@@ -642,11 +903,8 @@ function popcount(value) {
 /// works on the receiver's unsigned bit pattern and the rotate amount is taken
 /// modulo the width.
 function intMethodShim(detail) {
-    const parsed = intDetail(detail);
-    if (!parsed) {
-        return undefined;
-    }
-    const [op, width] = parsed;
+    const [op, name] = detail;
+    const width = INT_WIDTHS[name];
     const bits = BigInt(width.bits);
     const unsigned = (args) => BigInt.asUintN(width.bits, integer(args, 0));
     const result = (pattern) => int(wrapTo(width, pattern));
@@ -703,30 +961,34 @@ function intMethodShim(detail) {
             return (_host, args) => rotate(args, true);
         case "RotateRight":
             return (_host, args) => rotate(args, false);
-        default:
-            return undefined;
+        default: {
+            const exhaustive = op;
+            throw new Error(`unknown integer operation ${String(exhaustive)}`);
+        }
     }
 }
 /// Non-trapping integer arithmetic at the receiver's width: wrapping keeps
 /// the low bits, saturating clamps to the width's bounds and checked answers
 /// `None` where native's overflow flag is set.
 function intArithShim(detail) {
-    const parsed = intDetail(detail);
-    if (!parsed) {
-        return undefined;
-    }
-    const [kind, width] = parsed;
+    const [kind, name] = detail;
+    const width = INT_WIDTHS[name];
     const [min, max] = intBounds(width);
+    const add = (x, y) => x + y;
+    const sub = (x, y) => x - y;
+    const mul = (x, y) => x * y;
     const operations = {
-        Add: (x, y) => x + y,
-        Sub: (x, y) => x - y,
-        Mul: (x, y) => x * y,
+        WrappingAdd: ["Wrapping", add],
+        WrappingSub: ["Wrapping", sub],
+        WrappingMul: ["Wrapping", mul],
+        SaturatingAdd: ["Saturating", add],
+        SaturatingSub: ["Saturating", sub],
+        SaturatingMul: ["Saturating", mul],
+        CheckedAdd: ["Checked", add],
+        CheckedSub: ["Checked", sub],
+        CheckedMul: ["Checked", mul],
     };
-    const mode = ["Wrapping", "Saturating", "Checked"].find((prefix) => kind.startsWith(prefix));
-    const apply = mode ? operations[kind.slice(mode.length)] : undefined;
-    if (!mode || !apply) {
-        return undefined;
-    }
+    const [mode, apply] = operations[kind];
     const exact = (args) => apply(wrapTo(width, integer(args, 0)), wrapTo(width, integer(args, 1)));
     switch (mode) {
         case "Wrapping":
@@ -766,6 +1028,27 @@ function bigMax(left, right) {
 }
 // ── externs ─────────────────────────────────────────────────────────────────
 const EXTERN_SHIMS = {
+    hew_path_separator: () => str("/"),
+    hew_calendar_format: {
+        kind: "ordinary",
+        bridge: "calendarBridge",
+        shim: (host, args, _variant, shape) => executeCalendar(host.calendarBridge, "hew_calendar_format", args, shape),
+    },
+    hew_calendar_parse: {
+        kind: "ordinary",
+        bridge: "calendarBridge",
+        shim: (host, args, _variant, shape) => executeCalendar(host.calendarBridge, "hew_calendar_parse", args, shape),
+    },
+    hew_calendar_components: {
+        kind: "ordinary",
+        bridge: "calendarBridge",
+        shim: (host, args, _variant, shape) => executeCalendar(host.calendarBridge, "hew_calendar_components", args, shape),
+    },
+    hew_calendar_from_parts: {
+        kind: "ordinary",
+        bridge: "calendarBridge",
+        shim: (host, args, _variant, shape) => executeCalendar(host.calendarBridge, "hew_calendar_from_parts", args, shape),
+    },
     hew_args_count: (host) => int(BigInt(host.argv.length)),
     // A native null managed string is canonical empty. Each result owns fresh
     // string storage; releasing it cannot change the host's supplied arguments.
@@ -904,9 +1187,6 @@ function pattern(host, value) {
     return value.kind === "string" ? value.value : renderStdout(value);
 }
 // ── operand helpers ─────────────────────────────────────────────────────────
-function detailName(detail) {
-    return typeof detail === "string" ? detail : "";
-}
 function arg(args, at) {
     return args[at] ?? UNIT;
 }