@hew-lang/sandbox-vm 0.6.1 → 0.6.3

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

@@ -1,647 +1,7 @@
-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" | "actor_refused";
-export interface SpanV1 {
-    start: number;
-    end: number;
-}
+import type { TermV1, VariantShape, RuntimeVariantRole } from "./instructions.generated.js";
+export type { Own, BoundaryDecision, TrapName, SpanV1, BoundaryOperand, Edge, ValueDef, CallResult, OpV1, OpName, TermV1, TermName, SwitchArm, CheckedFailure, RequestShapes, ActorProtocol, ActorOperation, RuntimeFamilyEntry, AggregateShape, VariantCase, VariantShape, RuntimeVariantRole, ExternEntry, PlaceDecl, ValueCapability, ValueComponentCapabilities, ClosureShape, VtableShape, FunctionV1, BlockV1, EntryPlan, ActorShape, SupervisorShape, PackageV1, Resource, StructuralRecipe, } from "./instructions.generated.js";
 export type Operand = number;
-export interface BoundaryOperand {
-    value: number;
-    decision: BoundaryDecision;
-}
-export interface Edge {
-    to: number;
-    args: Operand[];
-}
-export interface ValueDef {
-    value: number;
-    own: Own;
-}
-export type CallResult = null | "never" | ValueDef;
-export interface AggregateShape {
-    id: number;
-    name: string;
-    fields: string[];
-}
-export interface VariantCase {
-    name: string;
-    fields: string[];
-}
-export interface VariantShape {
-    id: number;
-    name: string;
-    cases: VariantCase[];
-    runtime_tags?: Partial<Record<RuntimeVariantRole, number>>;
-}
-export type RuntimeVariantRole = "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" | "SendErrorWriteTimedOut" | "DeliveryAccepted" | "DeliveryDiscarded" | "LinkErrorNoContext";
-export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;
-export interface RuntimeFamilyEntry {
-    id: number;
-    family: string;
-    detail?: unknown;
-}
-export interface ExternEntry {
-    id: number;
-    symbol: string;
-    native_capability?: string;
-}
-export type PlaceDecl = {
-    id: number;
-    origin: "local";
-} | {
-    id: number;
-    origin: "aggregate";
-    base: {
-        place: number;
-    } | {
-        value: number;
-    };
-    shape?: number;
-    field: number;
-} | {
-    id: number;
-    origin: "capture";
-    environment: number;
-    field: number;
-} | {
-    id: number;
-    origin: "actor_state";
-    environment: number;
-    field: number;
-    initialized: boolean;
-} | {
-    id: number;
-    origin: "runtime";
-};
-export interface ValueCapability {
-    id: number;
-    capability: "Eq" | "Hash" | "Less" | "LessEqual" | "Greater" | "GreaterEqual";
-    ty: string;
-    callable?: number;
-    components?: ValueComponentCapabilities[];
-    variants?: ValueComponentCapabilities[][];
-}
-export interface ValueComponentCapabilities {
-    selected: number;
-    ordering?: {
-        less: number;
-        less_equal: number;
-        greater: number;
-        greater_equal: number;
-    };
-}
-export interface ClosureShape {
-    id: number;
-    entries: Array<{
-        body: number;
-        specialization: number | null;
-    }>;
-    fields: number;
-}
-export interface VtableShape {
-    id: number;
-    slots: Array<{
-        slot: number;
-        method: string;
-        callee: number;
-        receiver: BoundaryDecision;
-        receiver_handback?: boolean;
-    }>;
-}
-export interface FunctionV1 {
-    id: number;
-    name: string;
-    params: ValueDef[];
-    entry: number;
-    places: PlaceDecl[];
-    blocks: BlockV1[];
-}
-export interface BlockV1 {
-    id: number;
-    params: ValueDef[];
-    ops: OpV1[];
-    term: TermV1;
-}
-interface OpBase {
-    own?: Own;
-    dst?: number | null;
-    span?: SpanV1 | null;
-}
-export type OpV1 = (OpBase & {
-    op: "coverage.hit";
-    counter: number;
-}) | (OpBase & {
-    op: "const.int";
-    dst: number;
-    value: string;
-    ty: string;
-}) | (OpBase & {
-    op: "const.bool";
-    dst: number;
-    value: boolean;
-}) | (OpBase & {
-    op: "const.float";
-    dst: number;
-    value?: number;
-    ty: string;
-    nonfinite?: "nan" | "inf" | "-inf";
-}) | (OpBase & {
-    op: "const.char";
-    dst: number;
-    value: string;
-}) | (OpBase & {
-    op: "const.unit";
-    dst: number;
-}) | (OpBase & {
-    op: "const.duration";
-    dst: number;
-    nanos: string;
-}) | (OpBase & {
-    op: "const.str";
-    dst: number;
-    str: number;
-}) | (OpBase & {
-    op: "const.bytes";
-    dst: number;
-    bytes: number;
-}) | (OpBase & {
-    op: "copy_value";
-    dst: number;
-    source: Operand;
-}) | (OpBase & {
-    op: "move";
-    dst: number;
-    source: Operand;
-}) | (OpBase & {
-    op: "fork";
-    dst: number;
-    source: Operand;
-}) | (OpBase & {
-    op: "destroy_value";
-    value: Operand;
-}) | (OpBase & {
-    op: "begin_borrow";
-    dst: number;
-    owner: Operand;
-}) | (OpBase & {
-    op: "end_borrow";
-    borrow: Operand;
-}) | (OpBase & {
-    op: "finish_linear_receiver";
-}) | (OpBase & {
-    op: "alloc_place";
-    place: number;
-}) | (OpBase & {
-    op: "store.init";
-    place: number;
-    value: Operand;
-}) | (OpBase & {
-    op: "store.assign";
-    place: number;
-    value: Operand;
-}) | (OpBase & {
-    op: "load.copy";
-    dst: number;
-    place: number;
-}) | (OpBase & {
-    op: "load.take";
-    dst: number;
-    place: number;
-}) | (OpBase & {
-    op: "load.borrow";
-    dst: number;
-    place: number;
-}) | (OpBase & {
-    op: "end_lifetime";
-    place: number;
-}) | (OpBase & {
-    op: "tuple.make";
-    dst: number;
-    elements: Operand[];
-}) | (OpBase & {
-    op: "tuple.get";
-    dst: number;
-    tuple: Operand;
-    index: number;
-}) | (OpBase & {
-    op: "aggregate.make";
-    dst: number;
-    shape: number;
-    fields: Operand[];
-}) | (OpBase & {
-    op: "aggregate.project_copy";
-    dst: number;
-    shape: number;
-    aggregate: Operand;
-    field: number;
-}) | (OpBase & {
-    op: "aggregate.project_borrow";
-    dst: number;
-    shape: number;
-    aggregate: Operand;
-    field: number;
-}) | (OpBase & {
-    op: "destructure";
-    shape: number | null;
-    aggregate: Operand;
-    results: number[];
-}) | (OpBase & {
-    op: "array.make";
-    dst: number;
-    elements: Operand[];
-}) | (OpBase & {
-    op: "array.repeat";
-    dst: number;
-    value: Operand;
-    count?: number;
-}) | (OpBase & {
-    op: "variant.make";
-    dst: number;
-    shape: number;
-    variant: number;
-    fields: Operand[];
-}) | (OpBase & {
-    op: "variant.is";
-    dst: number;
-    shape: number;
-    variant: number;
-    source: Operand;
-}) | (OpBase & {
-    op: "variant.project_copy";
-    dst: number;
-    shape: number;
-    variant: number;
-    source: Operand;
-    field: number;
-}) | (OpBase & {
-    op: "variant.project_borrow";
-    dst: number;
-    shape: number;
-    variant: number;
-    source: Operand;
-    field: number;
-}) | (OpBase & {
-    op: "variant.destructure";
-    shape: number;
-    variant: number;
-    source: Operand;
-    results: number[];
-}) | (OpBase & {
-    op: "unary";
-    dst: number;
-    unary_op: string;
-    value: Operand;
-    ty: string;
-}) | (OpBase & {
-    op: "binary";
-    dst: number;
-    binary_op: string;
-    lhs: Operand;
-    rhs: Operand;
-    ty: string;
-}) | (OpBase & {
-    op: "cast";
-    dst: number;
-    value: Operand;
-    from: string;
-    to: string;
-}) | (OpBase & {
-    op: "str.eq";
-    dst: number;
-    lhs: Operand;
-    rhs: Operand;
-}) | (OpBase & {
-    op: "bytes.eq";
-    dst: number;
-    lhs: Operand;
-    rhs: Operand;
-}) | (OpBase & {
-    op: "function.make";
-    dst: number;
-    callable: number;
-}) | (OpBase & {
-    op: "closure.make";
-    dst: number;
-    closure: number;
-    fields: Operand[];
-}) | (OpBase & {
-    op: "callable.coerce";
-    dst: number;
-    source: Operand;
-    specialization: number | null;
-}) | (OpBase & {
-    op: "dyn.make";
-    dst: number;
-    vtable: number;
-    value: Operand;
-}) | (OpBase & {
-    op: "register_defer";
-    defer: number;
-    scope: number;
-    dependencies: Operand[];
-}) | (OpBase & {
-    op: "generator.make";
-    dst: number;
-    closure: number;
-    callable: Operand;
-}) | (OpBase & {
-    op: "actor.ingress_adapter";
-}) | (OpBase & {
-    op: "stream.pipe";
-    capacity: number;
-    results: ValueDef[];
-}) | (OpBase & {
-    op: "task_scope.enter";
-    scope: number;
-    parent: number | null;
-    duration: Operand | null;
-}) | (OpBase & {
-    op: "task_scope.close";
-    scope: number;
-}) | (OpBase & {
-    op: "task.race";
-    dst: number;
-    scope: number;
-    members: Operand[];
-}) | (OpBase & {
-    op: "task.spawn";
-    dst: number;
-    scope: number;
-    callable: Operand;
-});
-export type OpName = OpV1["op"];
-interface TermBase {
-    span?: SpanV1 | null;
-}
-export interface SwitchArm {
-    variant: number;
-    fields: ValueDef[];
-    edge: Edge;
-}
-export interface CheckedFailure {
-    trap: TrapName;
-    edge: Edge;
-}
-export interface RequestShapes {
-    failure: number | null;
-    reason: number | null;
-    message: number | null;
-    request: number | null;
-}
-export interface CallShape {
-    args: BoundaryOperand[];
-    result: CallResult;
-    normal?: Edge;
-    unwind: Edge | null;
-    request_shapes?: RequestShapes;
-}
-export type TermV1 = (TermBase & {
-    op: "return";
-    value: BoundaryOperand | null;
-}) | (TermBase & {
-    op: "goto";
-    edge: Edge;
-}) | (TermBase & {
-    op: "branch";
-    condition: Operand;
-    then: Edge;
-    else: Edge;
-}) | (TermBase & {
-    op: "switch.variant";
-    shape: number;
-    scrutinee: Operand;
-    arms: SwitchArm[];
-}) | (TermBase & {
-    op: "checked.binary";
-    binary_op: string;
-    lhs: Operand;
-    rhs: Operand;
-    result: ValueDef;
-    normal: Edge;
-    failures: CheckedFailure[];
-    ty: string;
-}) | (TermBase & {
-    op: "unreachable";
-}) | (TermBase & CallShape & {
+export type CallShape = Pick<Extract<TermV1, {
     op: "call";
-    callee: number;
-    handback?: ValueDef | null;
-}) | (TermBase & CallShape & {
-    op: "indirect.call";
-    callee: BoundaryOperand;
-    specialization: number | null;
-}) | (TermBase & CallShape & {
-    op: "dyn.call";
-    receiver: BoundaryOperand;
-    slot: number;
-}) | (TermBase & CallShape & {
-    op: "value.call";
-    plan: number;
-}) | (TermBase & CallShape & {
-    op: "wire.codec";
-    codec: number;
-    format: number;
-    direction: "encode" | "decode" | "test_input";
-    decoded: {
-        shape: number;
-        ok: number;
-        error: number;
-        error_root: number;
-    } | null;
-    callbacks: Record<string, number[]>;
-}) | (TermBase & CallShape & {
-    op: "runtime.call";
-    family: number;
-    structural?: number | null;
-    callbacks?: number[];
-    releases_contents?: boolean;
-    keeps_inputs_on_failure?: boolean;
-    result_member_shapes?: Array<number | null>;
-    result_shape: number | null;
-}) | (TermBase & CallShape & {
-    op: "extern.call";
-    extern: number;
-    result_shape: number | null;
-}) | (TermBase & CallShape & {
-    op: "actor.call";
-    operation: ActorOperation;
-    submission_shapes?: {
-        success: number | null;
-        failure: number | null;
-        reason: number | null;
-    };
-    result_shape: number | null;
-    error_shape: number | null;
-}) | (TermBase & {
-    op: "panic";
-    message: BoundaryOperand;
-    assertion?: [BoundaryOperand, BoundaryOperand, BoundaryOperand] | null;
-    cleanup: Edge;
-}) | (TermBase & {
-    op: "trap";
-    trap: TrapName;
-}) | (TermBase & {
-    op: "checked_raise";
-    trap: TrapName;
-    cleanup: Edge;
-}) | (TermBase & {
-    op: "cleanup.dispatch";
-    normal: Edge;
-    fault: Edge;
-}) | (TermBase & {
-    op: "resume_unwind";
-    handback?: BoundaryOperand | null;
-}) | (TermBase & {
-    op: "enter_defer";
-    defer: number;
-    park: number;
-    body: Edge;
-}) | (TermBase & {
-    op: "finish_defer";
-    defer: number;
-    park: number;
-    next: Edge;
-}) | (TermBase & {
-    op: "recover_fault";
-    result_shape?: number | null;
-    result: ValueDef;
-    deadline_variant: number;
-    fault_variant: number;
-    normal: Edge;
-    unwind: Edge | null;
-}) | (TermBase & {
-    op: "suspend";
-    kind: string;
-    detail?: any;
-    request_shapes?: RequestShapes;
-    result_shape?: number | null;
-    error_shape?: number | null;
-    inputs: BoundaryOperand[];
-    result: CallResult;
-    resumes: Edge[];
-    cancel: Edge;
-    unwind: Edge | null;
-});
-export type TermName = TermV1["op"];
-export interface EntryPlan {
-    function: number;
-    exit: "unit" | "status";
-}
-export interface ActorProtocol {
-    actor: number;
-    message: number;
-    policy: "reject" | "wait" | "drop_newest";
-    sealed: boolean;
-}
-export type ActorOperation = {
-    op: "spawn" | "self_handle" | "stop" | "terminate" | "await_stopped" | "await_restarted";
-    actor: number;
-} | {
-    op: "call_start" | "call_take";
-    protocol: ActorProtocol;
-} | {
-    op: "submit";
-    actor: number;
-    policy: ActorProtocol["policy"];
-} | {
-    op: "stream_start";
-    actor: number;
-    message: number;
-} | {
-    op: "local_observation";
-    kind: string;
-} | {
-    op: "supervisor_spawn" | "stop" | "terminate" | "await_stopped" | "await_restarted";
-    supervisor: number;
-} | {
-    op: "supervisor_child" | "supervisor_pool_view";
-    supervisor: number;
-    child: number;
-    owner_is_role: boolean;
-};
-export interface ActorShape {
-    id: number;
-    state_fields: Array<{
-        mutable: boolean;
-        deferred: boolean;
-    }>;
-    init?: number;
-    start?: number;
-    stop: number[];
-    crash?: number;
-    crash_info?: number;
-    crash_action?: number;
-    exit?: number;
-    down?: number;
-    handlers: Array<{
-        name: string;
-        message_id: number;
-        callable: number;
-        params: number;
-        streams: boolean;
-        fallible: boolean;
-        result_shape: number | null;
-        every_ns?: number;
-    }>;
-    mailbox_capacity?: number;
-    overflow: string;
-    coalesce?: {
-        fallback: string;
-        keys: Array<{
-            message: number;
-            param: number;
-        }>;
-    };
-    max_heap_bytes?: number;
-}
-export interface SupervisorShape {
-    id: number;
-    strategy: string;
-    max_restarts: number;
-    window_secs: number;
-    children: Array<{
-        name: string;
-        role: {
-            actor: number;
-        } | {
-            supervisor: number;
-        };
-        restart: string;
-        stop_ns?: number | null;
-        pool_count?: number;
-        spawn: number;
-    }>;
-}
-export interface PackageV1 {
-    codecs?: string[];
-    resources?: Array<{
-        kind: string;
-        ty?: string;
-        shape?: number;
-        close?: number;
-        release?: string;
-    }>;
-    structural_render?: import("./structural.js").StructuralRecipe[];
-    schema_version: "hew.sandbox.bytecode.v1";
-    hew_version: string;
-    compiler_version: string;
-    profile: string;
-    entry?: EntryPlan;
-    strings: string[];
-    bytes: number[][];
-    regex_patterns: string[];
-    aggregates: AggregateShape[];
-    variants: VariantShape[];
-    runtime_families: RuntimeFamilyEntry[];
-    externs: ExternEntry[];
-    suspend_kinds: string[];
-    value_capabilities: ValueCapability[];
-    closures: ClosureShape[];
-    vtables: VtableShape[];
-    actors?: ActorShape[];
-    supervisors?: SupervisorShape[];
-    functions: FunctionV1[];
-}
-export declare function isPackageV1(input: unknown): input is PackageV1;
-export {};
+}>, "args" | "result" | "normal" | "unwind" | "request_shapes">;
+export declare function runtimeTag(shape: VariantShape, role: RuntimeVariantRole): number;

package/dist/interpreter/v1/package.js

@@ -1,9 +1,3 @@
-/// TypeScript shape of `hew.sandbox.bytecode.v1`, mirroring
-/// `bytecode/sandbox-bytecode-v1.schema.json` and `bytecode/opcodes-v1.md`.
-///
-/// The package is a projection of verified ownership SIR. Every fact here was
-/// proved by SIR verification, so the executor reads these fields; it does not
-/// re-derive them from a type, a name or a symbol spelling.
 export function runtimeTag(shape, role) {
     const tag = shape.runtime_tags?.[role];
     if (tag === undefined ||
@@ -13,9 +7,3 @@ export function runtimeTag(shape, role) {
         throw new Error(`variant shape ${shape.id} has no checked ${role} tag`);
     return tag;
 }
-export function isPackageV1(input) {
-    return (typeof input === "object" &&
-        input !== null &&
-        input.schema_version ===
-            "hew.sandbox.bytecode.v1");
-}

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);