@scriptc/compiler 0.2.10 → 0.3.1

package/dist/ir/ir.d.ts

@@ -275,8 +275,7 @@ export type IrType = {
 /** Heap, refcounted closure. `rest` marks a variadic function value.
  * `restAbi: "typed"` spells one trailing typed array in `params`; static
  * call sites pack their surplus arguments into it before `callValue`.
- * `restAbi: "jsval"` similarly spells one trailing engine array for an
- * island host callback. An absent `restAbi` is the legacy checked-dynamic
+ * An absent `restAbi` is the checked-dynamic
  * JS form: `params` stays the declared non-rest list and the lifted
  * function has one hidden trailing ScrDyn array filled by its boxed call
  * thunk. `argumentsAll` keeps that hidden ABI but fills it with every
@@ -288,7 +287,7 @@ export type IrType = {
     params: IrType[];
     ret: IrType;
     rest?: true;
-    restAbi?: "jsval" | "typed";
+    restAbi?: "typed";
     argumentsAll?: true;
 } | {
     kind: "object";
@@ -306,7 +305,7 @@ export type IrType = {
  * completion against C's one signature sound. Allowed in locals,
  * globals, params, returns, class/record fields, capture boxes, array
  * elements, Map VALUES, and union arms; fenced out of Map keys, Set
- * elements, JSON, jsval conversion, and ToString. Unknown slots retain
+ * elements, JSON, and ToString. Unknown slots retain
  * class identity and allow an exact typed constructor round trip. */
  | {
     kind: "classval";
@@ -354,16 +353,6 @@ export type IrType = {
  | {
     kind: "dyn";
 }
-/** An island value handle — the type of `any` under --dynamic. Runtime
- * representation is a refcounted cell (ScrJsval) owning one embedded-
- * engine value. It can live in locals, globals, parameters, returns,
- * arrays, class fields, and ambient AbortSignal/AbortController record
- * fields. Operations on jsval compile to engine calls (jsOp) with
- * JS-exact semantics; exits back to static types are validated (jsExit).
- * This kind exists only with the dynamic option. */
- | {
-    kind: "jsval";
-}
 /** A catch binding or its closure capture (never parameters, returns,
  * fields, arms or elements). The one global form is a module's recorded
  * evaluation error, written only from that module's catch binding and
@@ -429,9 +418,9 @@ declare const HANDLE_KIND_LIST: readonly ["stats", "fileHandle", "spawnRes", "ch
 export type HandleKind = (typeof HANDLE_KIND_LIST)[number];
 export declare const HANDLE_KINDS: IrKindSet<"child" | "childStream" | "childWriter" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
 /** The IR kinds represented as pointers in native code. */
-declare const POINTER_KIND_LIST: readonly ["string", "bigint", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "func", "object", "classval", "moduleNs", "record", "union", "dyn", "jsval", "caught", "promise", "generator"];
+declare const POINTER_KIND_LIST: readonly ["string", "bigint", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "func", "object", "classval", "moduleNs", "record", "union", "dyn", "caught", "promise", "generator"];
 export type PointerKind = (typeof POINTER_KIND_LIST)[number];
-export declare const POINTER_KINDS: IrKindSet<"array" | "bigint" | "bytes" | "caught" | "child" | "childStream" | "childWriter" | "classval" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "jsval" | "map" | "moduleNs" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
+export declare const POINTER_KINDS: IrKindSet<"array" | "bigint" | "bytes" | "caught" | "child" | "childStream" | "childWriter" | "classval" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "map" | "moduleNs" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
 /** Runtime RC symbol stem for each IR type kind. An empty stem means the
  * kind is scalar/unit or uses an emitted per-shape helper (object/record).
  * Keeping this exhaustive makes a new runtime handle kind a compile error
@@ -477,7 +466,6 @@ export declare const CHILDWRITER_T: IrType;
 export declare const PROCSTREAM_T: IrType;
 export declare const VOID: IrType;
 export declare const DYN: IrType;
-export declare const JSVAL: IrType;
 export declare const CAUGHT: IrType;
 export declare const UNDEFINED_T: IrType;
 export declare const NULL_T: IrType;
@@ -508,7 +496,7 @@ export declare function isSupportedMapKey(t: IrType, unionArms?: IrType[]): bool
 /** Set elements and Map keys share storage, equality and ownership rules. */
 export declare function isSupportedSetElem(t: IrType, unionArms?: IrType[]): boolean;
 /** The Map VALUE fence: scalars, supported native references and checked
- * values. Functions require checked-value boxing; jsval has no native slot.
+ * values. Functions require checked-value boxing.
  * Record/object/union values can point back at the map holding them, which
  * is exactly why ref-valued maps are cycle-capable (see the backend's
  * cycle analysis and docs/memory.md). Shared frontend/validator. */
@@ -544,7 +532,7 @@ export declare function typeEquals(a: IrType, b: IrType): boolean;
 export declare function isRefCounted(t: IrType): boolean;
 export interface IrModule {
     /** Bumped on any breaking IR change; serialize.ts refuses mismatches. */
-    irVersion: 15;
+    irVersion: 16;
     sourceFile: string;
     functions: IrFunction[];
     /** Class shapes. Constructors and methods are ordinary module functions
@@ -560,36 +548,6 @@ export interface IrModule {
      * per-file `%init.<i>` functions; ids live in a distinct "%g." namespace so
      * they can never collide with function-local ids. */
     globals?: IrGlobal[];
-    /** The embedded npm runtime graph (--dynamic builds with npm imports):
-     * every reached module's SOURCE, keyed by resolved path, plus the
-     * (importer, specifier) → target edges the island's module loader and
-     * require shim resolve against. Emitted as static strings — binaries
-     * never read node_modules at runtime. Edge targets are module keys or
-     * "node:*" builtins (island-shimmed). */
-    embedded?: {
-        /** `esm` (CommonJS modules only) is the synthesized ESM facade the
-         * island loader evaluates when an ES module imports the CJS file:
-         * default plus the named exports LEXED from the source at build time
-         * (cjs-lexer.ts — the compiler's port of Node's vendored CJS lexer). */
-        modules: {
-            key: string;
-            source: string;
-            format: "esm" | "cjs" | "json";
-            esm?: string;
-            /** Parsed/bound embedded source reaches the engine's global fetch. */
-            usesFetch?: true;
-        }[];
-        /** `kind` picks Node's "exports" condition set per CALL FORM: one
-         * (from, specifier) can name a dual package's ESM entry behind an
-         * "import" edge AND its CJS entry behind a "require" edge; "any"
-         * serves both lookups (relative files, builtins). */
-        edges: {
-            from: string;
-            specifier: string;
-            to: string;
-            kind: "any" | "import" | "require";
-        }[];
-    };
     /** Record shapes, in first-seen (`r0`, `r1`, ...) order. Fields are in
      * CANONICAL order (sorted by name) — the shape's identity; a `recordLit`'s
      * fields stay in source order (evaluation order) independently. The
@@ -1072,7 +1030,8 @@ export interface IrFunction {
      * completion verdict instead of a build-time-selected member. */
     asyncCycleCacheGlobal?: string;
     /** Generator (`function*` / `async function*`): the body runs on a fiber created SUSPENDED
-     * (nothing runs until the first `.next()`); `returnType` is the
+     * (nothing runs until the first `.next()`; backends may instead compile a
+     * synchronous body as a stackless coroutine with the same protocol); `returnType` is the
      * generator's TReturn (VOID when it carries no value — `return;`
      * completes with the undefined arm) while call sites receive the
      * generator type `{ async?, yieldT, retT: returnType, nextT }` from an emitted
@@ -1462,7 +1421,15 @@ export type IrArrIntrinsicMethod =
  * a value of an `isSortValuesElement` type; the comparator is invoked
  * with exactly its declared arity. Returns void; comparator exceptions
  * propagate and leave the snapshot unchanged. */
- | "sortValues" | "length"
+ | "sortValues"
+/** Internal stable comparator sort of a dense array in place: arguments
+ * are [comparator, owned]. Returns false, without calling the comparator,
+ * when the receiver has holes, storage-level undefined or sparse slots, or
+ * is published; the caller then sorts a compacted snapshot. Otherwise the
+ * receiver's values are sorted outside it and written back only after
+ * success, as the spec's sort writes them, and it returns true. `owned`
+ * (a boolean literal) marks a private copy no user code can reach. */
+ | "sortDense" | "length"
 /** Internal ToNumber(a[index]) for f64-backed arrays: one numeric index,
  * returning the stored number or NaN for a hole/undefined/missing key.
  * Borrows the receiver and never traps on missing values. */
@@ -1496,7 +1463,7 @@ export declare const MAY_THROW_ARR_METHODS: ReadonlySet<IrArrIntrinsicMethod>;
 /** Element types whose comparator sort can run in the runtime over raw
  * slots: numbers, and reference-counted values passed to the comparator by
  * pointer. Unions with an undefined arm order undefined last without a
- * comparator call, and checked or island values have their own ABI; those
+ * comparator call, and checked values have their own ABI; those
  * keep the IR sort helper. */
 export declare function isSortValuesElement(elem: IrType, unionArms?: readonly IrType[]): boolean;
 /** The Map method/property surface (mirrors ambient/scriptc.d.ts) plus the
@@ -1645,7 +1612,13 @@ export declare const MAY_THROW_BYTES_METHODS: ReadonlySet<IrBytesIntrinsicMethod
 export type IrRegexIntrinsicMethod = "test" | "match"
 /** exec uses the same string-first operands but keeps the g/y
  * lastIndex refusal, independently of global String.match iteration. */
- | "exec" | "lastIndex"
+ | "exec"
+/** exec whose result is read only by null tests and constant-index
+ * element reads: args[1] is a numeric literal whose bit k marks capture k
+ * as read (k < 53). Unmarked captures read as undefined and the result
+ * carries no index/input properties; the match, lastIndex transitions
+ * and null result are exec's. */
+ | "execGroups" | "lastIndex"
 /** `s.matchAll(re)` — every match as its honest string[] slice (match's
  * rule), drained EAGERLY into a fresh string[][]: the lazy iterator is
  * unobservable across the lowered surface (strings are immutable; the
@@ -1790,8 +1763,7 @@ export type IrExpr =
  * dyn asks its runtime kind. The other operand form is a UNION — the ARM
  * value's ToBoolean via a per-union interned helper (unit arms false;
  * f64/string/bool arms per-value; ref arms — arrays, records, objects,
- * functions, maps, sets, promises, ... — always true; jsval arms ask the
- * engine). Result is bool. */
+ * functions, maps, sets, promises, ... — always true). Result is bool. */
  | {
     kind: "toBool";
     operand: IrExpr;
@@ -2296,10 +2268,19 @@ export type IrExpr =
  * non-suspended generator marks it done and re-throws at the call site.
  * Sync generators return that record directly and propagate body errors
  * synchronously. Async generators return Promise<record>; requests queue,
- * and body errors reject the corresponding promise. */
+ * and body errors reject the corresponding promise.
+ *
+ * Three record-free modes serve the compiler's own drives of a sync
+ * generator (for-of, spread, yield*), which read only `done` and then the
+ * yielded value: `step` is a valueless next() answering `done` (BOOL;
+ * throws like next); `value` moves the yielded value out, typed as the
+ * yield channel (valid only right after a `step` that answered false;
+ * never throws); `close` is a valueless return() whose result is dropped
+ * (IteratorClose; VOID; throws like return). All three have a null
+ * `arg`. */
  | {
     kind: "genResume";
-    mode: "next" | "return" | "throw";
+    mode: "next" | "return" | "throw" | "step" | "value" | "close";
     gen: IrExpr;
     arg: IrExpr | null;
     type: IrType;
@@ -2307,11 +2288,17 @@ export type IrExpr =
 }
 /** Await a promise: parks the current fiber until it settles; a rejected
  * promise re-throws into the awaiter (may-throw seed). Result is the
- * promise's inner value (+1 for refcounted kinds). Only inside async fns. */
+ * promise's inner value (+1 for refcounted kinds). Only inside async fns.
+ * `adopt`: the operand of `return` in an async (non-generator) function.
+ * JS resolves the function's promise with the returned promise, which
+ * adopts its settlement through a then job: one microtask turn before
+ * the await proper. Any enclosing finally runs first, and a rejection
+ * leaves the function without reaching its catch handlers. */
  | {
     kind: "awaitExpr";
     value: IrExpr;
     type: IrType;
+    adopt?: true;
     loc: SrcLoc;
 }
 /** Await of a promise-or-absent union (`Promise<T> | undefined`, the
@@ -2594,23 +2581,6 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
-/** Island value → dyn conversion (`type` is always dyn; the operand
- * is always jsval): the jsval→dyn crossing — an 'any'-typed engine
- * value flowing into an 'unknown'/'object'/JS-residue slot wraps BY
- * REFERENCE as the checked-dynamic tree's SCR_DYN_JSVAL kind (scr_dyn_from_jsval).
- * Engine scalars (number/string/boolean/null/undefined) normalize to
- * the native dyn kinds at wrap time, so wrapped nodes only ever hold
- * engine objects/arrays/functions; typeof/truthiness/String()/=== on
- * the wrapped node route to the engine, un-armed dyn walks fence
- * loudly, and scr_jsval_from_dyn unwraps the SAME engine value back
- * (identity round trip). The operand is borrowed; the result is owned
- * (+1). Never throws. */
- | {
-    kind: "dynFromJsval";
-    value: IrExpr;
-    type: IrType;
-    loc: SrcLoc;
-}
 /** CALLING a dyn value — `fn(a, b)` where fn is checked-dynamic (an
  * implicit-any JS binding, a dyn record member, a dynKeyGet result).
  * Arguments are ALREADY dyn-typed (typed values box through dynFrom at
@@ -2823,8 +2793,7 @@ export type IrExpr =
  * 'FIRSTPROP' of 'SPELLING' …" when `firstProp` is set (V8 names the
  * pattern's first property) — and yields the value unchanged otherwise.
  * `spelling` is the RHS's compile-time source spelling. Value and type
- * are dyn (the dyn helper) or jsval (the island's prelude guard —
- * engine-thrown, catchable like every boundary throw). */
+ * are dyn; the helper throws a catchable error. */
  | {
     kind: "dynDestrCheck";
     value: IrExpr;
@@ -2837,10 +2806,7 @@ export type IrExpr =
  * it. Over a dyn value: arrays step by index, strings by code point,
  * Buffers by byte; everything else throws V8's exact "<desc> is not
  * iterable (cannot read property Symbol(Symbol.iterator))" TypeError.
- * Over an island (jsval) value the engine runs the REAL iterator
- * protocol (user iterables included, IteratorClose per spec) behind the
- * same V8 message for non-iterables. The result is a FRESH array (dyn
- * or engine, matching the operand) of exactly `count` elements
+ * The result is a fresh dyn array of exactly `count` elements
  * (undefined-padded past the end) — the empty pattern passes count 0
  * and uses only the validation. Value is borrowed; the result is owned
  * (+1). */
@@ -2924,6 +2890,22 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
+/** Identity union conversion: `value` (union `fromId`) currently holds
+ * one of `tags`, and each listed tag names an equal arm at the same index
+ * of the target union `unionId` (`type`). The result is the same value
+ * viewed as the target union: owned (+1), and for two tagged unions the
+ * very same box (unions are immutable and box identity is unobservable).
+ * The operand is therefore a whole-value use: it escapes through the
+ * result, so it can never be a stack box. Never throws. */
+ | {
+    kind: "unionRetype";
+    fromId: string;
+    unionId: string;
+    tags: number[];
+    value: IrExpr;
+    type: IrType;
+    loc: SrcLoc;
+}
 /** Strict identity comparison between a function arm of a union and a
  * function value with a potentially different static signature. This is
  * non-coercing: closures share one pointer representation, but the value
@@ -3193,144 +3175,7 @@ export type IrExpr =
     preserveRefs?: true;
     type: IrType;
     loc: SrcLoc;
-}
-/** Static → island marshal (--dynamic builds only). `value`'s type is
- * f64/string/bool (marshaled by value) or a JSON-safe composite
- * (record/array/union — marshaled as a DEEP COPY through the emitted
- * type-directed JSON serializer and the engine's JSON parser; the
- * aliasing divergence is documented in SEMANTICS.md). Result is an
- * owned (+1) jsval; the operand is borrowed. Never throws. */
- | {
-    kind: "jsMarshal";
-    value: IrExpr;
-    type: IrType;
-    loc: SrcLoc;
-}
-/** An operation on island values (--dynamic builds only), executed by
- * the embedded engine with JS-exact semantics (coercions come from
- * pinned prelude closures, not C reimplementations). `args` are
- * jsval-typed and borrowed. Result `type` per op: arithmetic
- * (add/sub/mul/div/mod/pow), unary neg/plus, getProp/getIdx,
- * callMethod/callFn/callFnThis/globalGet → jsval (+1); comparisons
- * (lt/le/gt/ge/eq/neq), truthy, not → bool; typeof, toStr → string (+1);
- * setProp/setIdx → void. `name` carries the property/method identifier
- * for getProp/setProp/callMethod/globalGet, absent otherwise. MAY THROW
- * (engine
- * exceptions bridge into the exception cell, catchably) — backends'
- * may-throw analyses must seed on every jsOp like a `throw`. */
- | {
-    kind: "jsOp";
-    op: IrJsOp;
-    name?: string;
-    args: IrExpr[];
-    type: IrType;
-    loc: SrcLoc;
-}
-/** Island → static validated exit (--dynamic builds only): `value` is
- * jsval-typed, `type` is the static target. STRICT for primitives (a
- * non-number refuses to exit as number — no coercion); composite
- * targets round-trip through the engine's JSON.stringify and the
- * existing dynCheck walker for the target (width-tolerant records,
- * path-annotated failures — identical semantics to `dyn as T`). MAY
- * THROW a catchable TypeError-shaped string. The operand is borrowed;
- * the result is owned (+1) for refcounted targets. */
- | {
-    kind: "jsExit";
-    value: IrExpr;
-    type: IrType;
-    loc: SrcLoc;
-}
-/** Island → static PROMISE bridge (--dynamic builds only): `value` is a
- * jsval whose declared type is Promise<T> (a package call's promise —
- * it lives in the engine); the result is a fresh pending static promise
- * the engine promise settles. `type` is promise-of-jsval (the settled
- * engine value crosses as a retained handle; typed uses exit like any
- * jsval) or promise-of-void (T mapped to void — nothing to carry).
- * Fulfillment wakes parked awaiters through the ready queue; rejection
- * crosses like a bridged exception (engine Errors become real static
- * Errors) and re-throws at the await or enters the unhandled ledger.
- * Bridging one engine promise twice makes two independent static
- * observers of the same settlement — semantically equivalent, slightly
- * redundant (SEMANTICS.md). Operand borrowed; result +1. MAY THROW
- * only on an engine-level surprise minting the subscription — backends
- * seed may-throw and emit the pending check like other island ops. */
- | {
-    kind: "jsBridgePromise";
-    value: IrExpr;
-    type: IrType;
-    loc: SrcLoc;
 };
-/** The island operation set. Grouped by result type — see the jsOp node
- * doc. A closed union: every member has a lowering rule in the frontend,
- * a validation rule, and a scr_jsval_* implementation in scr_island.c. */
-export type IrJsOp = "add" | "sub" | "mul" | "div" | "mod" | "pow" | "neg" | "plus" | "lt" | "le" | "gt" | "ge" | "eq" | "neq"
-/** `v instanceof C` where BOTH sides are island values (a package-
- * exported class as the RHS): the spec's InstanceofOperator in the
- * engine, Symbol.hasInstance included; a non-object RHS throws the
- * engine's own TypeError, bridged catchably. */
- | "instanceOf" | "truthy" | "not" | "typeof" | "toStr" | "getProp" | "setProp" | "getIdx" | "setIdx" | "callMethod" | "callFn"
-/** Calls an already-resolved island function with an explicit receiver.
- * Args are (callee, receiver, ...arguments); this preserves computed
- * method evaluation order without reading a getter twice. */
- | "callFnThis"
-/** Spread application on an island callee — `f(...pre, ...s)`, the
- * rest-forwarding idiom (`(...args) => g(...args)` under --dynamic).
- * Args are exactly (callee, pre, spread): `pre` is the engine array of
- * leading fixed arguments (jsOp arrLit), `spread` the spread source;
- * `name` carries the spread expression's source spelling (V8's nullish
- * spread-call TypeError spells it). The prelude helper uses REAL spread
- * syntax, so iterator protocols are the engine's own, with guards
- * front-running V8's exact spread-call TypeError texts. May throw. */
- | "callSpread"
-/** `new X(...)` where X is jsval-typed (package-declared classes):
- * JS_CallConstructor — args are the callee then the constructor
- * arguments, mirroring callFn. */
- | "construct"
-/** A member of the engine's global object by name (Math, parseFloat, ...)
- * — the receiver/callee for the island-backed ambient surface. Zero args;
- * `name` carries the global's identifier. May-throw for uniformity with
- * the other engine entries (the emitter's pending check runs after it). */
- | "globalGet"
-/** Island-native literals: an object literal / array literal whose
- * contextual type is `any` builds directly in the engine — objLit args
- * are alternating key/value jsvals (keys are marshaled strings), arrLit
- * args are the elements. Never throw. */
- | "objLit" | "arrLit"
-/** The engine-native TemplateStringsArray for an ISLAND TAG call: args
- * are 2n marshaled strings — n cooked then n raw — building a fresh
- * engine array whose `.raw` carries the raw spellings (tags dispatch on
- * it). Never throws. */
- | "tplStrings"
-/** Spread completion for an island-native object literal: copies
- * args[1]'s own enumerable properties onto args[0] (the spec's
- * CopyDataProperties — the engine's own Object.assign; null/undefined
- * sources spread nothing) and answers args[0] for chaining. May throw
- * (getters run). */
- | "objSpread"
-/** Accessor completion for an island-native object literal: defines a
- * GETTER property on args[0] (the object) — args are (obj, key string
- * marshal, getter function handle) — and answers the same object (the
- * chainable spelling: `defineGetter(objLit(...), k, f)`). The
- * self-referential doc-printer root-indent shape. Never throws. */
- | "defineGetter"
-/** The engine's own undefined / null as island values (zero args, never
- * throw): the unit arms of a union marshaling IN (`string | undefined`
- * into an 'any' slot — the undefined arm IS the engine undefined), and
- * conceptually the unit path of `x?.y` on 'any' (the emitter inlines
- * that one). */
- | "undefLit" | "nullLit"
-/** GetIterator over an island value — the for-of head over 'any' (the
- * engine's own protocol lookup; V8's not-iterable TypeError on refusal).
- * The loop drives next() through callMethod and reads value/done with
- * getProp/truthy. */
- | "iterNew"
-/** `o.name?.(...)` — the optional METHOD call on an island receiver: a
- * nullish member answers the engine's undefined, anything else calls
- * with `this = o` (JS-exact; non-callables throw in the engine). */
- | "optCallMethod";
-/** Result-type rule for each island op (the validator enforces it; the
- * frontend constructs nodes with exactly these). */
-export declare function jsOpResultKind(op: IrJsOp): "jsval" | "bool" | "string" | "void";
 /** True when a type is a union with an undefined arm — the optional-flavored
  * slot marker shared by the frontend (record literals may omit such fields)
  * and backends (JSON serializers DROP such fields when they hold undefined,
@@ -3360,60 +3205,9 @@ export declare function isJsonStringifySafeType(t: IrType, getRecord: (shapeId:
 /** A JSON-shaped container with unknown payloads needs the runtime JSON
  * traversal. Its declared structure can be boxed, but payloads may carry
  * omitted values, toJSON methods, or cycles. This predicate does not widen
- * the type-directed serializer, checked-island boundary, or root-undefined
+ * the type-directed serializer, checked-value boundary, or root-undefined
  * contract; callers must select the checked runtime traversal explicitly. */
 export declare function isJsonStringifyDynamicType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
-/** THE island boundary predicate: true when a static type can cross into
- * the island (jsMarshal — primitives by value, composites as deep JSON
- * copies) and back out (jsExit — strict primitive extraction, composites
- * through the dynCheck walker). Primitives are JSON-safe, so the rule
- * coincides with isJsonSafeType; it has its own name because the boundary
- * is its own concept — the frontend's implicit coercions, the explicit-cast
- * lowering, and the validator's jsMarshal/jsExit rules all ask this ONE
- * question, and the boundary rejection messages describe exactly this set. */
-export declare function canCrossIslandBoundary(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
-/** True for a closure type that can cross INTO the island as a host
- * function: every parameter jsval (the engine's arguments pass through as
- * handles — no per-type extraction exists inside a host call) and the
- * result jsval, void, or a primitive (which marshals back by value —
- * `(x) => x * 2` on an 'any' x infers a number return). Contextual typing
- * produces exactly this shape for callbacks passed to package APIs
- * (`.action((a, b) => ...)` against `(...args: any[]) => void`). Arity is
- * capped by the runtime's host-call argument buffer (scr_island.c). */
-export declare const MAX_ISLAND_CALLBACK_ARITY = 16;
-export declare function canMarshalFuncIntoIsland(t: IrType): boolean;
-/** Parameter types a TYPED closure may declare when it crosses INTO the
- * island as a host function: jsval params take the engine argument as a
- * handle (the all-'any' shape above); dyn params normalize scalars or retain
- * engine objects by reference. Every other admitted type converts
- * AT CALL TIME through the validated-exit machinery — strict primitives,
- * JSON round-trip composites (the dynCheck walker: width-tolerant records,
- * path-annotated failures). On top of the jsExit set, a bare `T | undefined`
- * union is admitted here — an absent or undefined engine argument takes the
- * undefined arm, exactly the missing-optional-field rule (and exactly the
- * commander case: `.action((text: string | undefined, opts) => ...)` sees
- * undefined when the command argument is omitted). */
-export declare function isIslandCallbackParamType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
-/** Classify a typed island callback's RETURN for adapter synthesis: sync
- * kinds marshal back by value ('void'|'jsval'|'f64'|'bool'|'string' — the
- * canMarshalFuncIntoIsland set), 'json' marshals a JSON-safe composite
- * through the type-directed serializer + engine parse (the jsMarshal
- * composite path — commander's option-argument collectors return arrays
- * this way), and a Promise of the by-value kinds wraps as an engine
- * promise settled when the scriptc promise settles (async callbacks —
- * the `.action(async ...)` case). Null for anything else (Promise of
- * composites: still fenced). */
-export declare function islandCallbackRet(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): {
-    async: boolean;
-    tag: "void" | "jsval" | "f64" | "bool" | "string" | "json" | "dyn";
-} | null;
-/** The TYPED extension of canMarshalFuncIntoIsland (a strict superset):
- * closures whose params are per-argument-convertible at call time
- * (isIslandCallbackParamType) and whose return classifies
- * (islandCallbackRet). Same arity cap — the runtime's host-call argument
- * buffer. Statically typed closure parameters stay fenced; unknown values
- * enter as checked-dynamic values and are validated at each typed use. */
-export declare function canMarshalTypedFuncIntoIsland(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
 /** The runtime HANDLE kinds that cross the checked-dynamic boundary as
  * the checked-dynamic tree's HANDLE kind (SCR_DYN_HANDLE): boxed by REFERENCE (identity —
  * stateful I/O objects never copy), unboxed by tag check, members
@@ -3470,23 +3264,3 @@ export declare function canBoxFuncIntoDyn(t: IrType, getRecord: (shapeId: string
  * dyn), return void, dyn, or dynCheckable (the adapter validates the dyn
  * result). */
 export declare function canAdaptDynFuncTo(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined, visiting?: Set<string>): boolean;
-/** The MARSHAL-direction boundary (jsMarshal): everything that can cross
- * out and back (canCrossIslandBoundary) plus qualifying closures — those
- * enter as host functions but never EXIT (jsExit keeps the narrower
- * predicate). */
-export declare function canMarshalIntoIsland(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
-/** The EXIT-direction boundary (jsExit): everything round-trippable
- * (canCrossIslandBoundary) plus BARE undefined/null-armed unions whose
- * data arms are all JSON-safe — the engine's undefined takes the
- * undefined arm before the JSON detour (JSON cannot spell undefined, and
- * bare undefined-armed unions are JSON-unsafe for exactly that reason),
- * null and data ride the round trip into the union's dynCheck. The
- * package-API shape `result.headers` : `Record<string, string> |
- * undefined` is the motivating case. */
-/** The static-promise→engine bridge's payload domain: the fulfillment
- * types a scriptc promise may deliver INTO the island as a real engine
- * thenable (scr_jsval_from_promise — the async-callback return bridge,
- * reused by promise VALUES crossing at jsvalIn edges and the island
- * Promise.all arm). Null = outside the domain (the boundary fence). */
-export declare function islandPromisePayloadTag(inner: IrType): "void" | "f64" | "bool" | "string" | "jsval" | "jsvalArr" | null;
-export declare function canExitIslandToType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;