@hew-lang/sandbox-vm 0.6.1 → 0.6.3

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

@@ -8,8 +8,15 @@ export declare class FrameScheduler {
     private readonly replaySteps;
     private nextTicket;
     private replayIndex;
+    private readonly pendingHostOperations;
+    private hostReady;
+    submitHost<T>(id: string, operation: Promise<T>, completed: (result: T) => void, failed: (error: unknown) => void): void;
+    retireHost(): Promise<void>;
     constructor(trace: TraceBuilder, policy: "round_robin" | "chaos");
     enqueue(id: string, resume: () => void): void;
     after(nanos: bigint, wake: () => void): () => void;
-    run(): void;
+    hasRunnableWork(): boolean;
+    advanceSlice(): void;
+    private fireTimers;
+    run(): Promise<void>;
 }

package/dist/interpreter/v1/scheduler.js

@@ -10,6 +10,28 @@ export class FrameScheduler {
     replaySteps;
     nextTicket = 0;
     replayIndex = 0;
+    pendingHostOperations = new Set();
+    hostReady;
+    /// A host operation retains its borrowed inputs until its completion is queued.
+    /// Promise callbacks only enqueue work; frame execution stays in this scheduler.
+    submitHost(id, operation, completed, failed) {
+        let completion;
+        const deliver = (resume) => {
+            this.pendingHostOperations.delete(completion);
+            this.enqueue(id, resume);
+            this.hostReady?.();
+            this.hostReady = undefined;
+        };
+        completion = operation.then((result) => deliver(() => completed(result)), (error) => deliver(() => failed(error)));
+        this.pendingHostOperations.add(completion);
+    }
+    /// A terminal VM failure cannot execute more source instructions. Producers
+    /// still drain before their continuations and borrowed frame references retire.
+    async retireHost() {
+        await Promise.all(this.pendingHostOperations);
+        this.ready.length = 0;
+        this.timers.length = 0;
+    }
     constructor(trace, policy) {
         this.trace = trace;
         this.policy = policy;
@@ -42,19 +64,36 @@ export class FrameScheduler {
                 this.timers.splice(index, 1);
         };
     }
-    run() {
-        while (this.ready.length > 0 || this.timers.length > 0) {
-            if (this.ready.length === 0) {
+    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;
+            }
+        }
+    }
+    async run() {
+        while (this.ready.length > 0 ||
+            this.timers.length > 0 ||
+            this.pendingHostOperations.size > 0) {
+            if (this.ready.length === 0 && this.timers.length === 0) {
+                await new Promise((resolve) => {
+                    this.hostReady = resolve;
+                });
+            }
+            if (this.ready.length === 0 && this.timers.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

@@ -1,15 +1,22 @@
+import { type DirectoryOperation } from "./browser-directory.js";
 import type { Pipes } from "./pipes.js";
 import { type VmValue } from "../values.js";
 import { Mt19937 } from "./mt19937.js";
-import type { RuntimeFamilyEntry, RuntimeVariantRole, TrapName, VariantShape } from "./package.js";
+import type { AggregateShape, RuntimeFamilyEntry, RuntimeVariantRole, TrapName, VariantShape } from "./package.js";
 export declare class ShimFault extends Error {
     readonly trap: TrapName;
     constructor(trap: TrapName, message: string);
 }
 export interface ShimHost {
+    readonly argv: readonly string[];
+    unixTimeMillis(): number;
+    fileError(operation: "HasError" | "LastErrorKind" | "LastErrno" | "LastError"): VmValue;
+    calendarBridge?: (request: string) => 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;
@@ -17,8 +24,254 @@ export interface ShimHost {
     regexPatterns: readonly string[];
     enumValue(shape: VariantShape, role: RuntimeVariantRole, payload: VmValue[]): VmValue;
 }
-export type RuntimeShim = (host: ShimHost, args: VmValue[], shape: VariantShape | null) => VmValue;
-export declare function resolveRuntimeShim(entry: RuntimeFamilyEntry): RuntimeShim | undefined;
-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 type RuntimeShim = (host: ShimHost, args: VmValue[], shape: VariantShape | null, aggregate: AggregateShape | null) => VmValue;
+export type HostBridges = Pick<import("../types.js").RunOptions, "codecBridge" | "calendarBridge" | "directoryRoots">;
+type BridgeRequirement = "codecBridge" | "calendarBridge";
+export type DirectoryRegistration = {
+    kind: "directory";
+    operation: DirectoryOperation;
+};
+export type Refused = {
+    kind: "refused";
+    category: "native_only" | "not_implemented";
+    capability: string;
+    description?: string;
+    message?: string;
+};
+type Ordinary = {
+    kind: "ordinary";
+    shim: RuntimeShim;
+    bridge?: BridgeRequirement;
+};
+export type RuntimeContinuation = {
+    handler: "actor_caller" | "actor_refusal_log" | "structural_format" | "utf8_decode" | "close";
+} | {
+    handler: "supervisor_pool";
+    operation: Extract<RuntimeFamilyEntry, {
+        family: "SupervisorPool";
+    }>["detail"];
+} | ({
+    handler: "collection";
+} & ({
+    family: "Vector";
+    operation: "Contains" | "Set" | "Clear";
+} | {
+    family: "Map";
+    operation: Extract<RuntimeFamilyEntry, {
+        family: "Map";
+    }>["detail"];
+} | {
+    family: "Set";
+    operation: Extract<RuntimeFamilyEntry, {
+        family: "Set";
+    }>["detail"];
+})) | {
+    handler: "shared";
+    operation: Extract<RuntimeFamilyEntry["family"], "RcNew" | "RcClone" | "RcDowngrade" | "WeakCloneRc" | "WeakUpgradeRc" | "RcGet" | "RcIsUnique" | "RcSet" | "RcStrongCount" | "RcWeakCount">;
+};
+export type RuntimeRegistration = Ordinary | Refused | ({
+    kind: "resumable";
+} & RuntimeContinuation);
+export declare function registrationRefusal(registration: RuntimeRegistration | DirectoryRegistration | {
+    kind: "resumable";
+    bridge: BridgeRequirement;
+}, bridges: HostBridges): Refused | null;
+export declare const CODEC_REGISTRATION: {
+    readonly kind: "resumable";
+    readonly bridge: "codecBridge";
+};
+export declare function resolveRuntime(entry: RuntimeFamilyEntry): RuntimeRegistration;
+export declare function resolveExtern(entry: {
+    symbol: string;
+    native_capability?: string | null;
+}): Ordinary | Refused | DirectoryRegistration;
+type SuspendTerm = Extract<import("./package.js").TermV1, {
+    op: "suspend";
+}>;
+export declare function suspensionRefusal(kind: SuspendTerm["kind"]): Refused | null;
+type NativeIoTerm = Extract<SuspendTerm, {
+    kind: "NativeIo";
+}>;
+declare const NATIVE_IO_ROUTES: {
+    readonly StdinReadLine: "StdinReadLine";
+    readonly SinkFinish: "SinkFinish";
+    readonly TcpRead: Refused;
+    readonly TcpWrite: Refused;
+    readonly TcpAccept: Refused;
+    readonly TcpConnect: Refused;
+    readonly TcpConnectTimeout: Refused;
+    readonly TlsConnect: Refused;
+    readonly TlsRead: Refused;
+    readonly TlsWrite: Refused;
+    readonly FileRead: "FileRead";
+    readonly FileWrite: "FileWrite";
+};
+type ExecutableNativeIo = NativeIoTerm & {
+    detail: {
+        operation: Extract<(typeof NATIVE_IO_ROUTES)[keyof typeof NATIVE_IO_ROUTES], string>;
+    };
+};
+export declare function resolveSuspension(term: SuspendTerm): Refused | {
+    kind: "resumable";
+    term: ExecutableNativeIo;
+} | {
+    kind: "resumable";
+    term: ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Sleep";
+        detail?: null | null | null;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Await";
+        detail?: null | null | null;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Yield";
+        detail?: null | null | null;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "GeneratorNext";
+        detail?: null | null | null;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Safepoint";
+        detail: import("./instructions.generated.js").SafepointDetail;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Ask";
+        detail: import("./instructions.generated.js").AskDetail;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Join";
+        detail: import("./instructions.generated.js").JoinDetail;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "StreamSend";
+        detail: import("./instructions.generated.js").StreamSendDetail;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "StreamNext";
+        detail: import("./instructions.generated.js").StreamNextDetail;
+    }) | ({
+        span?: import("./instructions.generated.js").SpanV1 | null | null;
+    } & {
+        op: "suspend";
+        request_shapes?: import("./instructions.generated.js").RequestShapes | null | null;
+        result_shape?: number | null | null;
+        error_shape?: number | null | null;
+        inputs: Array<import("./instructions.generated.js").BoundaryOperand>;
+        result: import("./instructions.generated.js").CallResult;
+        resumes: Array<import("./instructions.generated.js").Edge>;
+        cancel: import("./instructions.generated.js").Edge | null;
+        unwind: import("./instructions.generated.js").Edge | null;
+    } & {
+        kind: "Select";
+        detail: import("./instructions.generated.js").SelectDetail;
+    });
+};
+export declare function decodeUtf8Checked(value: VmValue): {
+    value: string;
+} | {
+    validUpTo: number;
+    errorLen: number | null;
+};
+export {};