@hew-lang/sandbox-vm 0.6.0 → 0.6.2

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

@@ -1,6 +1,6 @@
 export type Own = "none" | "owned" | "guaranteed";
 export type BoundaryDecision = "borrow" | "borrow_mut" | "copy" | "move" | "snapshot";
-export type TrapName = "integer_overflow" | "divide_by_zero" | "shift_out_of_range" | "vector_bounds";
+export type TrapName = "integer_overflow" | "divide_by_zero" | "shift_out_of_range" | "vector_bounds" | "actor_refused";
 export interface SpanV1 {
     start: number;
     end: number;
@@ -34,7 +34,7 @@ export interface VariantShape {
     cases: VariantCase[];
     runtime_tags?: Partial<Record<RuntimeVariantRole, number>>;
 }
-export type RuntimeVariantRole = "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
+export type RuntimeVariantRole = "CrashKindFault" | "CrashKindHeapExceeded" | "CrashKindPartitionDetected" | "CrashKindHandlerFailed" | "CrashKindTimerOverdue" | "OptionSome" | "OptionNone" | "ResultOk" | "ResultErr" | "ActorErrorRejected" | "ActorErrorFailed" | "ActorErrorTrapped" | "ActorErrorRefused" | "CallerActor" | "CallerTask" | "CallerTimer" | "CallerNode" | "ActorErrorDead" | "ActorErrorTimedOut" | "ActorErrorNodeNotRunning" | "ActorErrorRoutingFailed" | "ActorErrorEncodeFailed" | "ActorErrorConnectionDropped" | "ActorErrorPartition" | "SendErrorFull" | "SendErrorClosed" | "SendErrorPartition" | "SendErrorStaleRef" | "SendErrorLocalShutdown" | "SendErrorCancelled" | "SendErrorVersionMismatch" | "SendErrorBackpressure" | "SendErrorDead" | "SendErrorUnauthorized" | "SendErrorInvalidMessage" | "SendErrorTimedOut" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
 export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;
 export interface RuntimeFamilyEntry {
     id: number;
@@ -93,7 +93,10 @@ export interface ValueComponentCapabilities {
 }
 export interface ClosureShape {
     id: number;
-    body: number;
+    entries: Array<{
+        body: number;
+        specialization: number | null;
+    }>;
     fields: number;
 }
 export interface VtableShape {
@@ -107,6 +110,7 @@ export interface VtableShape {
     }>;
 }
 export interface FunctionV1 {
+    actor_construction?: boolean;
     id: number;
     name: string;
     params: ValueDef[];
@@ -326,6 +330,7 @@ export type OpV1 = (OpBase & {
     op: "callable.coerce";
     dst: number;
     source: Operand;
+    specialization: number | null;
 }) | (OpBase & {
     op: "dyn.make";
     dst: number;
@@ -365,6 +370,25 @@ export type OpV1 = (OpBase & {
     dst: number;
     scope: number;
     callable: Operand;
+}) | (OpBase & {
+    op: "task.invoke";
+    dst: number;
+    scope: number;
+    callee: {
+        direct: number;
+    } | {
+        mutable: number;
+        receiver: BoundaryOperand;
+        staged: boolean;
+    } | {
+        dyn: number;
+        method: string;
+        receiver: BoundaryOperand;
+    } | {
+        receiver: BoundaryOperand;
+        specialization: number | null;
+    };
+    args: BoundaryOperand[];
 });
 export type OpName = OpV1["op"];
 interface TermBase {
@@ -426,6 +450,7 @@ export type TermV1 = (TermBase & {
 }) | (TermBase & CallShape & {
     op: "indirect.call";
     callee: BoundaryOperand;
+    specialization: number | null;
 }) | (TermBase & CallShape & {
     op: "dyn.call";
     receiver: BoundaryOperand;
@@ -447,12 +472,17 @@ export type TermV1 = (TermBase & {
     callbacks: Record<string, number[]>;
 }) | (TermBase & CallShape & {
     op: "runtime.call";
+    shared_payload_type?: string;
     family: number;
     structural?: number | null;
     callbacks?: number[];
     releases_contents?: boolean;
     keeps_inputs_on_failure?: boolean;
     result_member_shapes?: Array<number | null>;
+    variant_result_shapes?: {
+        error: number;
+        error_len: number;
+    };
     result_shape: number | null;
 }) | (TermBase & CallShape & {
     op: "extern.call";
@@ -515,7 +545,7 @@ export type TermV1 = (TermBase & {
     inputs: BoundaryOperand[];
     result: CallResult;
     resumes: Edge[];
-    cancel: Edge;
+    cancel: Edge | null;
     unwind: Edge | null;
 });
 export type TermName = TermV1["op"];
@@ -530,6 +560,8 @@ export interface ActorProtocol {
     sealed: boolean;
 }
 export type ActorOperation = {
+    op: "identity";
+} | {
     op: "spawn" | "self_handle" | "stop" | "terminate" | "await_stopped" | "await_restarted";
     actor: number;
 } | {
@@ -543,6 +575,12 @@ export type ActorOperation = {
     op: "stream_start";
     actor: number;
     message: number;
+} | {
+    op: "timer_schedule";
+    actor: number;
+    message: number;
+    resource: number;
+    policy: "reject" | "drop_newest";
 } | {
     op: "local_observation";
     kind: string;
@@ -553,10 +591,10 @@ export type ActorOperation = {
     op: "supervisor_child" | "supervisor_pool_view";
     supervisor: number;
     child: number;
-    owner_is_role: boolean;
 };
 export interface ActorShape {
     id: number;
+    name: string;
     state_fields: Array<{
         mutable: boolean;
         deferred: boolean;
@@ -566,6 +604,7 @@ export interface ActorShape {
     stop: number[];
     crash?: number;
     crash_info?: number;
+    crash_kind?: number;
     crash_action?: number;
     exit?: number;
     down?: number;
@@ -604,7 +643,8 @@ export interface SupervisorShape {
         };
         restart: string;
         stop_ns?: number | null;
-        pool_count?: number;
+        stop_config?: number;
+        is_pool?: boolean;
         spawn: number;
     }>;
 }

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

@@ -12,6 +12,7 @@ export declare class Pipes {
     private half;
     private get;
     cloneSink(value: VmValue): VmValue;
+    isClosed(value: VmValue): boolean;
     close(value: VmValue, fault?: string | null): VmValue[];
     peerClosed(value: VmValue): boolean;
     readable(value: VmValue): boolean;

package/dist/interpreter/v1/pipes.js

@@ -29,10 +29,10 @@ export class Pipes {
             throw new Error("pipe pair does not exist");
         return this.half(pipe, kind);
     }
-    half(pipe, kind) {
+    half(pipe, kind, open = true) {
         const id = `pipe-half:${++this.next}`;
-        this.halves.set(id, { pipe, kind, open: true });
-        if (kind === "sink")
+        this.halves.set(id, { pipe, kind, open });
+        if (kind === "sink" && open)
             pipe.sinks += 1;
         return { kind, channelId: id };
     }
@@ -46,9 +46,12 @@ export class Pipes {
     }
     cloneSink(value) {
         const half = this.get(value);
-        if (!half.open || half.kind !== "sink")
-            throw new Error("cannot clone a closed sink");
-        return this.half(half.pipe, "sink");
+        if (half.kind !== "sink")
+            throw new Error("cannot clone a stream as a sink");
+        return this.half(half.pipe, "sink", half.open);
+    }
+    isClosed(value) {
+        return !this.get(value).open;
     }
     close(value, fault = null) {
         const half = this.get(value);

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

@@ -11,5 +11,8 @@ export declare class FrameScheduler {
     constructor(trace: TraceBuilder, policy: "round_robin" | "chaos");
     enqueue(id: string, resume: () => void): void;
     after(nanos: bigint, wake: () => void): () => void;
+    hasRunnableWork(): boolean;
+    advanceSlice(): void;
+    private fireTimers;
     run(): void;
 }

package/dist/interpreter/v1/scheduler.js

@@ -42,19 +42,29 @@ export class FrameScheduler {
                 this.timers.splice(index, 1);
         };
     }
+    hasRunnableWork() {
+        return this.ready.length > 0;
+    }
+    advanceSlice() {
+        this.trace.advanceVirtualClock(this.trace.replay.virtual_clock.tick_ms, null);
+        this.fireTimers();
+    }
+    fireTimers() {
+        for (let index = 0; index < this.timers.length;) {
+            if (this.timers[index].at <= this.trace.virtualTimeMs) {
+                this.timers.splice(index, 1)[0].wake();
+            }
+            else {
+                index += 1;
+            }
+        }
+    }
     run() {
         while (this.ready.length > 0 || this.timers.length > 0) {
             if (this.ready.length === 0) {
                 const next = Math.min(...this.timers.map((timer) => timer.at));
                 this.trace.advanceVirtualClock(next - this.trace.virtualTimeMs, null);
-                for (let index = 0; index < this.timers.length;) {
-                    if (this.timers[index].at <= next) {
-                        this.timers.splice(index, 1)[0].wake();
-                    }
-                    else {
-                        index += 1;
-                    }
-                }
+                this.fireTimers();
             }
             if (this.ready.length === 0)
                 continue;

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

@@ -7,9 +7,13 @@ export declare class ShimFault extends Error {
     constructor(trap: TrapName, message: string);
 }
 export interface ShimHost {
+    readonly argv: readonly string[];
     pipes?: Pipes;
     newPipe?(capacity: number): VmValue;
     closePipe?(value: VmValue): void;
+    generatorStream?(generator: VmValue): VmValue;
+    encoderSink?(sink: VmValue, encoder: VmValue): VmValue;
+    cloneSink?(sink: VmValue): VmValue;
     releaseValue?(value: VmValue): void;
     writeStdout(text: string): void;
     writeStderr(text: string): void;
@@ -22,3 +26,9 @@ export declare function resolveRuntimeShim(entry: RuntimeFamilyEntry): RuntimeSh
 export declare function resolveExternShim(symbol: string): RuntimeShim | undefined;
 export declare const SUPPORTED_SUSPEND_KINDS: ReadonlySet<string>;
 export declare const SUPPORTED_NATIVE_IO: ReadonlySet<string>;
+export declare function decodeUtf8Checked(value: VmValue): {
+    value: string;
+} | {
+    validUpTo: number;
+    errorLen: number | null;
+};

package/dist/interpreter/v1/shims.js

@@ -1,3 +1,4 @@
+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
@@ -6,7 +7,7 @@
 /// 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, renderStdout } from "../values.js";
+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.
@@ -24,23 +25,26 @@ export class ShimFault extends Error {
 export function resolveRuntimeShim(entry) {
     switch (entry.family) {
         case "SupervisorPool":
-            return ["Member", "Get"].includes(String(entry.detail))
+            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"
-                ? () => ({ kind: "string", value: "" })
-                : undefined;
+            return entry.detail === "LastError" ? () => str("") : undefined;
         case "Print":
             return printShim(entry.detail);
         case "RcNew":
         case "RcClone":
+        case "RcDowngrade":
+        case "WeakCloneRc":
+        case "WeakUpgradeRc":
         case "RcGet":
         case "RcIsUnique":
         case "RcSet":
@@ -60,7 +64,11 @@ export function resolveRuntimeShim(entry) {
                 ? () => {
                     throw new Error("array mutation requires its resumable executor");
                 }
-                : undefined;
+                : entry.detail === "IndexBorrow"
+                    ? (_host, args) => sequenceElement(args)
+                    : ["Len", "Index"].includes(String(entry.detail))
+                        ? VECTOR_SHIMS[detailName(entry.detail)]
+                        : undefined;
         case "Map":
         case "Set":
             return [
@@ -104,6 +112,7 @@ export const SUPPORTED_SUSPEND_KINDS = new Set([
     "GeneratorNext",
     "Yield",
     "Sleep",
+    "Safepoint",
     "Ask",
     "Await",
     "Join",
@@ -138,19 +147,15 @@ 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)),
+    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;
@@ -160,28 +165,92 @@ const UNIT_FAMILY_SHIMS = {
         return UNIT;
     },
     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)),
-    StringContains: (_host, args) => bool(text(args, 0).includes(text(args, 1))),
+    StringCompare: (_host, args) => int(BigInt(compareUtf8(text(args, 0), 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))),
@@ -190,8 +259,41 @@ 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: () => {
+        throw new Error("UTF-8 decode requires its checked result carrier");
+    },
     // TextDecoder replaces each maximal invalid subsequence with U+FFFD, as
     // native lossy decoding does.
     BytesDecodeUtf8Lossy: (_host, args) => str(decodeUtf8(arg(args, 0))),
@@ -316,15 +418,15 @@ const VECTOR_SHIMS = {
             ? host.enumValue(shape, "OptionSome", [cloneValue(items[at])])
             : host.enumValue(shape, "OptionNone", []);
     },
-    Index: (_host, args) => {
+    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;
-        const at = index(args, 1);
-        if (at < 0 || at >= items.length) {
-            throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${items.length}`);
-        }
-        return cloneValue(items[at]);
+        return str(items
+            .map((_, at) => indexed(items, at).value)
+            .join(indexed(args, 1).value));
     },
-    Len: (_host, args) => int(BigInt(vec(args, 0).items.length)),
     Slice: (_host, args) => {
         const items = vec(args, 0).items;
         const start = index(args, 1);
@@ -347,6 +449,14 @@ const VECTOR_SHIMS = {
         };
     },
 };
+function sequenceElement(args) {
+    const items = vec(args, 0).items;
+    const at = index(args, 1);
+    if (at < 0 || at >= items.length) {
+        throw new ShimFault("vector_bounds", `vector index ${at} out of bounds for length ${items.length}`);
+    }
+    return items[at];
+}
 function byteVector(items) {
     return { kind: "vector", elementType: "u8", items: items.map(cloneValue) };
 }
@@ -656,6 +766,24 @@ function bigMax(left, right) {
 }
 // ── externs ─────────────────────────────────────────────────────────────────
 const EXTERN_SHIMS = {
+    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;
@@ -666,7 +794,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.
@@ -712,6 +840,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") {
@@ -741,6 +910,12 @@ function detailName(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);
@@ -770,7 +945,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 };
@@ -778,3 +953,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));
+}