@hew-lang/sandbox-vm 0.6.1 → 0.6.3

package/dist/interpreter/v1/shims.js

@@ -1,12 +1,9 @@
-/// 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`].
-import { UNIT, cloneValue, compareUtf8, renderStdout, } from "../values.js";
+import { DIRECTORY_OPERATIONS, } from "./browser-directory.js";
+import { executeCalendar } from "./calendar.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 { 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.
@@ -18,125 +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 ["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"
-                ? () => ({ kind: "string", value: "" })
-                : undefined;
+            return resumable({ handler: "supervisor_pool", operation: entry.detail });
         case "Print":
-            return printShim(entry.detail);
-        case "RcNew":
-        case "RcClone":
-        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",
-    "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;
@@ -144,51 +268,104 @@ const UNIT_FAMILY_SHIMS = {
     StringToBytes: (_host, args) => ({
         kind: "vector",
         elementType: "u8",
-        items: [...new TextEncoder().encode(text(args, 0))].map((byte) => int(BigInt(byte))),
-    }),
-    StringToUppercase: (_host, args) => ({
-        kind: "string",
-        value: text(args, 0).toUpperCase(),
-    }),
-    StringToLowercase: (_host, args) => ({
-        kind: "string",
-        value: text(args, 0).toLowerCase(),
+        items: [...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()),
     StreamPairSink: (host, args) => host.pipes.extract(arg(args, 0), "sink"),
     StreamPairStream: (host, args) => host.pipes.extract(arg(args, 0), "stream"),
-    SinkClone: (host, args) => host.pipes.cloneSink(arg(args, 0)),
-    SinkClose: (host, args) => {
-        host.closePipe(arg(args, 0));
-        return UNIT;
-    },
-    StreamClose: (host, args) => {
-        host.closePipe(arg(args, 0));
-        return UNIT;
-    },
+    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: resumable({ handler: "close" }),
+    StreamClose: resumable({ handler: "close" }),
     StringConcat: (_host, args) => str(`${text(args, 0)}${text(args, 1)}`),
-    StringClone: (_host, args) => str(text(args, 0)),
+    StringClone: (_host, args) => cloneValue(arg(args, 0)),
     StringEquals: (_host, args) => bool(text(args, 0) === text(args, 1)),
     StringCompare: (_host, args) => int(BigInt(compareUtf8(text(args, 0), text(args, 1)))),
-    StringContains: (_host, args) => bool(text(args, 0).includes(text(args, 1))),
+    StringStartsWith: (_host, args) => bool(text(args, 0).startsWith(text(args, 1))),
+    StringEndsWith: (_host, args) => bool(text(args, 0).endsWith(text(args, 1))),
+    StringContains: (_host, args) => bool(indexed(args, 0).find(indexed(args, 1)) !== undefined),
     StringTrim: (_host, args) => str(text(args, 0).replace(/^\p{White_Space}+|\p{White_Space}+$/gu, "")),
-    // Native string length counts codepoints, not bytes.
-    StringLen: (_host, args) => int(BigInt([...text(args, 0)].length)),
+    StringLen: (_host, args) => int(BigInt(indexed(args, 0).scalarLength)),
+    StringByteLen: (_host, args) => int(BigInt(indexed(args, 0).byteLength)),
     StringIndex: (_host, args) => {
-        const chars = [...text(args, 0)];
+        const value = indexed(args, 0);
         const at = index(args, 1);
-        if (at < 0 || at >= chars.length) {
-            throw new ShimFault("vector_bounds", `string index ${at} out of bounds for length ${chars.length}`);
-        }
-        return str(chars[at]);
+        const scalar = value.at(at);
+        if (scalar === undefined)
+            throw new ShimFault("vector_bounds", `string index ${at} out of bounds for length ${value.scalarLength}`);
+        return str(scalar);
+    },
+    StringGet: (host, args, shape) => {
+        if (!shape)
+            throw new TypeError("string get requires its Option shape");
+        const scalar = indexed(args, 0).at(index(args, 1));
+        return scalar === undefined
+            ? host.enumValue(shape, "OptionNone", [])
+            : host.enumValue(shape, "OptionSome", [str(scalar)]);
+    },
+    StringFind: (host, args, shape) => {
+        if (!shape)
+            throw new TypeError("string find requires its Option shape");
+        const found = indexed(args, 0).find(indexed(args, 1));
+        return found === undefined
+            ? host.enumValue(shape, "OptionNone", [])
+            : host.enumValue(shape, "OptionSome", [int(BigInt(found))]);
+    },
+    StringFindFrom: (host, args, shape) => {
+        if (!shape)
+            throw new TypeError("string find_from requires its Option shape");
+        const found = indexed(args, 0).find(indexed(args, 1), index(args, 2));
+        return found === undefined
+            ? host.enumValue(shape, "OptionNone", [])
+            : host.enumValue(shape, "OptionSome", [int(BigInt(found))]);
+    },
+    StringAppend: (_host, args) => indexed(args, 0).append(indexed(args, 1)),
+    StringPush: (_host, args) => indexed(args, 0).append(indexed(args, 1)),
+    StringClear: (_host, args) => {
+        indexed(args, 0).release();
+        return str("");
+    },
+    StringIsEmpty: (_host, args) => bool(indexed(args, 0).scalarLength === 0),
+    StringSplit: (_host, args) => {
+        const value = indexed(args, 0).value;
+        const separator = indexed(args, 1).value;
+        const parts = separator === "" ? Array.from(value) : value.split(separator);
+        return { kind: "vector", elementType: "string", items: parts.map(str) };
     },
-    StringIsEmpty: (_host, args) => bool(text(args, 0).length === 0),
     StringReplace: (_host, args) => str(text(args, 0).split(text(args, 1)).join(text(args, 2))),
-    // Native slicing is by codepoint and clamps rather than trapping.
-    StringSlice: (_host, args) => {
-        const chars = [...text(args, 0)];
-        const start = Math.min(Math.max(index(args, 1), 0), chars.length);
-        const end = Math.min(Math.max(index(args, 2), start), chars.length);
-        return str(chars.slice(start, end).join(""));
+    StringRepeat: (_host, args) => str(text(args, 0).repeat(Math.max(0, index(args, 1)))),
+    StringGetRange: (host, args, shape) => {
+        if (!shape)
+            throw new TypeError("string range get requires its Option shape");
+        const value = stringRange(args);
+        return value === undefined
+            ? host.enumValue(shape, "OptionNone", [])
+            : host.enumValue(shape, "OptionSome", [value]);
+    },
+    StringSliceRange: (_host, args) => {
+        const value = stringRange(args);
+        if (value === undefined)
+            throw new ShimFault("vector_bounds", "string range out of bounds");
+        return value;
+    },
+    StringSliceCodepoints: (_host, args) => {
+        const value = indexed(args, 0);
+        const start = index(args, 1);
+        const end = index(args, 2);
+        const sliced = value.slice(start, end);
+        if (!sliced)
+            throw new ShimFault("vector_bounds", `string slice ${start}..${end} out of bounds for length ${value.scalarLength}`);
+        return sliced;
+    },
+    StringSliceCodepointsFrom: (_host, args) => {
+        const value = indexed(args, 0);
+        const start = index(args, 1);
+        const sliced = value.slice(start, value.scalarLength);
+        if (!sliced)
+            throw new ShimFault("vector_bounds", `string slice ${start}.. out of bounds for length ${value.scalarLength}`);
+        return sliced;
     },
     I64ToString: (_host, args) => str(renderStdout(arg(args, 0))),
     U64ToString: (_host, args) => str(renderStdout(arg(args, 0))),
@@ -197,8 +374,39 @@ const UNIT_FAMILY_SHIMS = {
     U8ToString: (_host, args) => str(renderStdout(arg(args, 0))),
     BoolToString: (_host, args) => str(renderStdout(arg(args, 0))),
     F64ToString: (_host, args) => str(renderStdout(arg(args, 0))),
+    CharIsDigit: (_host, args) => bool(charProperty(text(args, 0), 0)),
+    CharIsLetter: (_host, args) => bool(charProperty(text(args, 0), 1)),
+    CharIsAlphanumeric: (_host, args) => bool(charProperty(text(args, 0), 2)),
+    CharIsWhitespace: (_host, args) => bool(charProperty(text(args, 0), 3)),
+    CharIsUpper: (_host, args) => bool(charProperty(text(args, 0), 4)),
+    CharIsLower: (_host, args) => bool(charProperty(text(args, 0), 5)),
+    CharIsPunctuation: (_host, args) => bool(charProperty(text(args, 0), 6)),
+    CharIsControl: (_host, args) => bool(charProperty(text(args, 0), 7)),
+    CharIsAscii: (_host, args) => bool(charProperty(text(args, 0), 8)),
+    CharLenUtf8: (_host, args) => int(BigInt(indexed(args, 0).byteLength)),
+    CharToUpper: (_host, args) => str(charCase(text(args, 0), "upper")),
+    CharToLower: (_host, args) => str(charCase(text(args, 0), "lower")),
+    CharToTitle: (_host, args) => str(charCase(text(args, 0), "title")),
+    CharToDigit: (host, args, shape) => {
+        if (!shape)
+            throw new TypeError("char to_digit requires its Option shape");
+        const radix = index(args, 1);
+        const scalar = text(args, 0).codePointAt(0);
+        const digit = scalar >= 48 && scalar <= 57
+            ? scalar - 48
+            : scalar >= 65 && scalar <= 90
+                ? scalar - 65 + 10
+                : scalar >= 97 && scalar <= 122
+                    ? scalar - 97 + 10
+                    : -1;
+        return radix < 2 || radix > 36 || digit < 0 || digit >= radix
+            ? host.enumValue(shape, "OptionNone", [])
+            : host.enumValue(shape, "OptionSome", [int(BigInt(digit))]);
+    },
+    CharFromI64: checkedChar,
+    CharFromU64: checkedChar,
     CharToString: (_host, args) => str(renderStdout(arg(args, 0))),
-    BytesDecodeUtf8: (_host, args) => str(decodeUtf8(arg(args, 0))),
+    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))),
@@ -293,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: [] }),
@@ -326,6 +693,12 @@ const VECTOR_SHIMS = {
     Index: (_host, args) => cloneValue(sequenceElement(args)),
     IndexBorrow: (_host, args) => sequenceElement(args),
     Len: (_host, args) => int(BigInt(vec(args, 0).items.length)),
+    Join: (_host, args) => {
+        const items = vec(args, 0).items;
+        return str(items
+            .map((_, at) => indexed(items, at).value)
+            .join(indexed(args, 1).value));
+    },
     Slice: (_host, args) => {
         const items = vec(args, 0).items;
         const start = index(args, 1);
@@ -495,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 },
@@ -509,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)
@@ -541,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));
@@ -602,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":
@@ -665,6 +1028,45 @@ 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.
+    hew_args_get: (host, args) => str(host.argv[index(args, 0)] ?? ""),
+    hew_actor_timer_cancel: (_host, args) => {
+        const timer = arg(args, 0);
+        if (timer.kind !== "timer" || timer.closed)
+            throw new Error("invalid timer handle");
+        timer.cancel();
+        return UNIT;
+    },
+    hew_actor_timer_release: (_host, args) => {
+        const timer = arg(args, 0);
+        if (timer.kind !== "timer" || timer.closed)
+            throw new Error("invalid timer handle");
+        timer.closed = true;
+        return UNIT;
+    },
     hew_msg_envelope_release: (host, args) => {
         host.releaseValue(arg(args, 0));
         return UNIT;
@@ -675,7 +1077,7 @@ const EXTERN_SHIMS = {
         host.pipes.freePair(arg(args, 0));
         return UNIT;
     },
-    hew_stream_last_error: () => ({ kind: "string", value: "" }),
+    hew_stream_last_error: () => str(""),
     hew_regex_new: (host, args) => compileRegex(host, args),
     hew_regex_clone: (_host, args) => cloneValue(arg(args, 0)),
     // Releasing a handle the VM traces by reference is nothing to do.
@@ -721,6 +1123,47 @@ const EXTERN_SHIMS = {
         return int(high <= low ? low : low + host.prng.randbelow(high - low));
     },
 };
+export function decodeUtf8Checked(value) {
+    if (value.kind !== "vector")
+        throw new TypeError("UTF-8 input must be bytes");
+    const bytes = Uint8Array.from(value.items.map((item) => Number(integer([item], 0))));
+    let at = 0;
+    while (at < bytes.length) {
+        const first = bytes[at];
+        if (first < 128) {
+            at++;
+            continue;
+        }
+        const width = first >= 194 && first <= 223
+            ? 2
+            : first >= 224 && first <= 239
+                ? 3
+                : first >= 240 && first <= 244
+                    ? 4
+                    : 0;
+        if (width === 0)
+            return { validUpTo: at, errorLen: 1 };
+        for (let offset = 1; offset < width; offset++) {
+            if (at + offset >= bytes.length)
+                return { validUpTo: at, errorLen: null };
+            const next = bytes[at + offset];
+            const lower = offset === 1 && first === 224
+                ? 160
+                : offset === 1 && first === 240
+                    ? 144
+                    : 128;
+            const upper = offset === 1 && first === 237
+                ? 159
+                : offset === 1 && first === 244
+                    ? 143
+                    : 191;
+            if (next < lower || next > upper)
+                return { validUpTo: at, errorLen: offset };
+        }
+        at += width;
+    }
+    return { value: new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes) };
+}
 /// `bytes` is a vector of byte values, so decoding walks its items.
 function decodeUtf8(value) {
     if (value.kind === "string") {
@@ -744,12 +1187,15 @@ 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;
 }
+function indexed(args, at) {
+    const value = arg(args, at);
+    if (value.kind !== "string")
+        throw new TypeError(`runtime call expected a string operand, got ${value.kind}`);
+    return value;
+}
 function text(args, at) {
     const value = arg(args, at);
     return value.kind === "string" ? value.value : renderStdout(value);
@@ -779,7 +1225,7 @@ function comparable(value) {
     return `${value.kind}:${renderStdout(value)}`;
 }
 function str(value) {
-    return { kind: "string", value };
+    return stringValue(value);
 }
 function bool(value) {
     return { kind: "bool", value };
@@ -787,3 +1233,29 @@ function bool(value) {
 function int(value) {
     return { kind: "i64", value };
 }
+function checkedChar(host, args, shape) {
+    if (!shape)
+        throw new TypeError("try_to_char requires its Option shape");
+    const value = integer(args, 0);
+    return value < 0n ||
+        value > 0x10ffffn ||
+        (value >= 0xd800n && value <= 0xdfffn)
+        ? host.enumValue(shape, "OptionNone", [])
+        : host.enumValue(shape, "OptionSome", [
+            str(String.fromCodePoint(Number(value))),
+        ]);
+}
+function stringRange(args) {
+    const value = indexed(args, 0);
+    const inclusive = arg(args, 3);
+    const openEnd = arg(args, 4);
+    if (inclusive.kind !== "bool" || openEnd.kind !== "bool")
+        throw new TypeError("string range flags must be bool");
+    const start = integer(args, 1);
+    const end = openEnd.value
+        ? BigInt(value.scalarLength)
+        : integer(args, 2) + (inclusive.value ? 1n : 0n);
+    if (start < 0n || end < start || end > BigInt(value.scalarLength))
+        return undefined;
+    return value.slice(Number(start), Number(end));
+}