@scriptc/compiler 0.2.3 → 0.2.5

package/dist/frontend/lowering/lower-builtins.d.ts

@@ -1,601 +0,0 @@
-import * as ts from "../ts7/adapter.js";
-import type { Lowerer } from "./lowerer.js";
-import { type BuiltinModuleFn } from "./surfaces.js";
-import { type IrExpr, type IrType, type SrcLoc } from "../../ir/ir.js";
-/** URL component assignment captures its receiver and RHS once, and yields
- * the original RHS after the setter performs string conversion. */
-export declare function lowerUrlAssignment(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr | null;
-/** timers/promises.setInterval(delay, value), the first Node API built on
- * the generic async-generator protocol. The supported form has an explicit
- * value and no AbortSignal options. It lowers to a generated typed async
- * generator whose loop awaits the existing promise timeout then yields the
- * retained value; creating the iterator remains lazy. */
-export declare function lowerTimersPromisesSetInterval(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, loc: SrcLoc): IrExpr | null;
-/** Resolves an identifier to a supported builtin-module IMPORT BINDING:
-   * a named import (through its alias, so `import { join as j }` matches)
-   * whose declaration is an ImportSpecifier under a supported builtin
-   * specifier — "fs"/"node:fs", "path"/"node:path", ... The SPECIFIER is
-   * the provenance: user code can only acquire these bindings by importing
-   * the module (preflight allowlists exactly these specifiers, and Node
-   * itself resolves bare builtin names to the builtin — no npm shadowing),
-   * and a same-named local or user function has a different symbol whose
-   * declaration is not an import specifier. Returns the CANONICAL module
-   * name and the EXPORTED member name (not the local alias). */
-export declare function builtinImportOf(lowerer: Lowerer, ident: ts.Identifier): {
-    module: string;
-    member: string;
-} | null;
-/** True for `const <name> = require("<builtin>").<member>` — the
-   * member-binding require import builtinImportOf resolves. Both
-   * declaration walks (lowerVarDecl, collectGlobals) skip these: like a
-   * named import, the binding is alias plumbing with no storage — call
-   * sites lower through the module tables, value uses fence per site. */
-export declare function builtinMemberRequireDecl(nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** The supported builtin module when `decl` destructures a builtin
-   * NAMESPACE binding (`const crypto = require('crypto'); const {
-   * createSign, sign: mySign } = crypto;` — test/common/crypto.js's
-   * idiom; the `import * as ns` form rides the same resolution). Pure
-   * alias plumbing: the bindings key the same tables as named imports
-   * (builtinImportOf's alias hop), so no storage and no statement exist —
-   * both declaration walks skip by this test. Plain identifier elements
-   * and renames only: a rest element needs the namespace VALUE and a
-   * default needs a missing-member probe — those keep the existing
-   * namespace-as-value fence. The direct-require initializer answers null
-   * here (its own arm already resolves it). */
-export declare function builtinNamespaceDestructureModuleOf(lowerer: Lowerer, decl: ts.VariableDeclaration): string | null;
-/** Strips the type-only wrappers the require pattern rides in typed
-   * code (`require("node:os") as typeof import("node:os")` — the
-   * fallback declarations answer `unknown`, so the cast IS the idiom),
-   * plus parens, legacy assertions, and non-null suffixes. */
-export declare function stripTypeCasts(e: ts.Expression): ts.Expression;
-/** True for `const require = createRequire(import.meta.url)` — the
-   * binding is compile-time plumbing (each call through it resolves per
-   * site) with no storage and no code; both declaration walks skip by
-   * this test. Top-level let/var bindings also qualify when preflight's
-   * shared proof rules out writes, escapes, and use before initialization. */
-export declare function createRequireBindingDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** The declaring source file when `callee` denotes a createRequire-made
-   * require: a stable binding over createRequire(import.meta.url) (the
-   * binding's own file anchors resolution) or the inline
-   * `createRequire(import.meta.url)(...)` spelling (the call's file).
-   * Null off the pattern, so call chains keep trying. */
-export declare function createRequireCalleeFileOf(lowerer: Lowerer, callee: ts.Expression): ts.SourceFile | null;
-/** The static require of `R("spec")` through a createRequire binding:
-   * the literal specifier plus the file anchoring relative resolution.
-   * Null when the callee is not a createRequire-made require; a matching
-   * callee with a non-literal (or missing) specifier answers spec null,
-   * so the call lowering fences by name instead of falling through to
-   * the generic call paths. */
-export declare function createRequireSpecOf(lowerer: Lowerer, call: ts.CallExpression): {
-    spec: string | null;
-    baseFile: ts.SourceFile;
-} | null;
-/** node:ffi is a checked native module value, so its require binding needs
- * storage even when the createRequire loader is named `require`. */
-export declare function isNativeFfiRequire(lowerer: Lowerer, expr: ts.Expression | undefined): boolean;
-/** True for `const fs = require("node:fs")` through a createRequire
-   * binding — a builtin namespace import in const clothing: alias
-   * plumbing with no storage (uses resolve through
-   * builtinNamespaceModuleOf's createRequire arm); both declaration
-   * walks skip by this test. */
-export declare function createRequireNamespaceDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** A statically compiled program module reached through a canonical
-   * createRequire binding. This is the ESM twin of an ordinary CommonJS
-   * require edge: the same project resolver, require-condition npm-static
-   * entry, module initializer, and export registrations own the target. */
-export declare function createRequireProgramModuleOf(lowerer: Lowerer, expr: ts.Expression | undefined): {
-    spec: string;
-    baseFile: ts.SourceFile;
-    dep: ts.SourceFile;
-} | null;
-/** True for a const identifier whose initializer is a createRequire call
-   * reaching a compiled program module. The binding is namespace/value
-   * alias plumbing; its declaration emits only the dependency's run-once
-   * initializer at the source position. */
-export declare function createRequireProgramModuleDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** node:module's two compiler-only calls. isBuiltin compares one evaluated
-   * string against the pinned Node 24 list (bare builtins also accept their
-   * node: spelling; prefix-only entries do not gain a bare alias).
-   * syncBuiltinESMExports is observably a no-op inside the static surface:
-   * builtin exports cannot be mutated, so its only supported behavior is
-   * evaluating no arguments and returning undefined. */
-export declare function lowerNodeModuleCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, loc: SrcLoc): IrExpr | null;
-/** `require("spec")` through a createRequire binding — the erasure per
-   * target. Builtins are reached here only OUTSIDE the const-namespace-
-   * binding shape (that declaration erases; member uses resolve through
-   * the namespace tables) and fence toward it. A relative .json document
-   * bakes: the file's text validates as JSON at compile time and the
-   * call lowers to json.parse over the baked literal — JSON.parse's
-   * checked-dynamic `unknown` stance, and exactly Node's value (require
-   * of JSON IS JSON.parse of the file; the per-call re-parse forgoes
-   * Node's module-cache identity, unobservable without mutation). A bare
-   * specifier NOTHING installed resolves compiles to Node's catchable
-   * MODULE_NOT_FOUND throw (the optional-dependency try/require
-   * pattern); an installed package loads through the island's
-   * require-condition entry under --dynamic (collectCreateRequires
-   * embedded it) and reports the requires-dynamic diagnostic in a static
-   * build. Null when the callee is not a createRequire require. */
-export declare function lowerCreateRequireCall(lowerer: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr | null;
-/** import.meta.resolve("literal") folds through the runtime-module
- * resolver, never TypeScript's declaration-file resolver. Relative and
- * URL-like names remain valid even when no file exists; bare packages use
- * Node's import-condition exports path. */
-export declare function lowerImportMetaResolveCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
-/** CommonJS require.resolve and require.resolve.paths for the ambient
- * wrapper or a supported createRequire binding. Results are build-time
- * constants; failures lower to Node's catchable error object. */
-export declare function lowerRequireResolveCall(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
-/** `constants.NGHTTP2_CANCEL` / `constants.SSL_OP_NO_TICKET` (any baked-
-   * constants spelling) → the literal; unknown members fence by name.
-   * Null when the receiver is not a baked constants object (the property
-   * chain keeps trying). */
-export declare function lowerBuiltinConstantsProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** Presence probes do not extract an unbound Performance method value. */
-export declare function lowerPerfHooksTypeof(lowerer: Lowerer, expression: ts.Expression): IrExpr | null;
-/** The node:perf_hooks spoke: `performance.now()` reads the runtime's
-   * monotonic clock anchored at process start — Node's timeOrigin for a
-   * compiled program, fractional milliseconds — and
-   * `performance.now.bind(performance)` (the mockable-clock idiom's
-   * getTimestamp) is the same clock as a plain () => number function
-   * value. Other members on the performance object fence by name; null
-   * for non-perf_hooks callees (the call chain keeps trying). */
-export declare function lowerPerfHooksCall(lowerer: Lowerer, expr: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** True for `const { NGHTTP2_CANCEL, ... } = http2.constants` (and the
-   * crypto.constants twin) — a plain object destructure (identifier
-   * elements, renames allowed, no rest/defaults/nesting) over a baked
-   * constants object whose every name is in its table. The declaration is
-   * alias plumbing with no storage (lowerVarDecl and collectGlobals both
-   * skip it); each USE reads its baked literal
-   * (builtinConstantBindingOf). */
-export declare function builtinConstantsDestructureDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** Resolves an identifier bound by a builtinConstantsDestructureDecl to
-   * its baked literal value. Null for every other binding. */
-export declare function builtinConstantBindingOf(lowerer: Lowerer, ident: ts.Identifier): IrExpr | null;
-export declare function lowerFsToUnixTimestampCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, loc: SrcLoc): IrExpr | null;
-/** The fs validation-ladder spoke (checked-dynamic lane, JS sources
- * only — TypeScript keeps its compile fences): implemented-namespace
- * calls whose misuse Node rejects with typed errors lower to fs.*Chk
- * libCalls that replicate the validation ladder over dyn values and
- * throw Node's exact ERR_INVALID_ARG_TYPE / ERR_INVALID_ARG_VALUE /
- * ERR_OUT_OF_RANGE — the honest tail (the real operation where one
- * exists, the compiler-rendered SC2020 fence otherwise) runs only
- * after every validation passes, exactly Node's order. Null when this
- * is not a claimed member/shape (the table or fence path stands). */
-export declare function lowerFsLadderCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, loc: SrcLoc): IrExpr | null;
-export declare function lowerBuiltinModuleCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, fn: BuiltinModuleFn, loc: SrcLoc): IrExpr;
-/** Reflect.ownKeys uses native computed-key reflection. Reflect.apply(target,
-   * thisArg, argsList) where the TARGET is a builtin
-   * rest-parameter table fn (path.join / path.resolve — test/common
-   * fixtures.js's fixturesPath forwards its rest args exactly this way):
-   * the packed libCall over a validated string[] extraction of argsList.
-   * The builtins ignore the receiver, so thisArg must be an effect-free
-   * spelling (`this`, an identifier, a unit literal) whose dropped
-   * evaluation is unobservable; every other Reflect.apply keeps the
-   * fence. Null when this isn't a supported Reflect call. */
-export declare function lowerReflectCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The child-process args list: one string[] value. An omitted list
-   * completes to an empty literal (Node's default); an array LITERAL
-   * builds element-wise (its contextual type is the optional parameter's
-   * `string[] | undefined`, which the generic literal path cannot map —
-   * the Set-seed situation exactly); everything else lowers as itself. */
-export declare function lowerChildArgsArg(lowerer: Lowerer, node: ts.Expression | undefined, loc: SrcLoc): IrExpr;
-/** `spawnSync(command, args?, options?)` → one cp.spawnSync /
-   * cp.spawnSyncOpts libCall. An omitted args list completes to an empty
-   * string[] literal (Node's default). The options argument must be an
-   * object LITERAL whose members are drawn from the honestly-implemented
-   * set: `encoding` (the "utf8"/"utf-8" literal — the runtime captures
-   * utf8 unconditionally, and the option flips @types/node's
-   * stdout/stderr to string), `timeout` (ms — killSignal fires at the
-   * deadline and the result carries error: ETIMEDOUT + the signal, never
-   * a throw: Node's spawnSync shape), `killSignal` (a signal-name
-   * literal, validated against Node's table), `stdio` (the "pipe"/
-   * "ignore"/"inherit" string form or a 3-tuple of those — non-piped
-   * outputs read "" where Node types them null, spawnSync's documented
-   * stance), and `windowsHide` (a POSIX no-op, evaluated for side
-   * effects). Everything else (shell, cwd, env, input, maxBuffer, ...)
-   * fences by name. The bare `{ encoding: "utf8" }` shape keeps its
-   * historical cp.spawnSync lowering. */
-export declare function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-/** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
-   * libCall. Computed options use native runtime normalization. Inline
-   * stdio accepts "ignore", "inherit", or "pipe" as the scalar,
-   * or the 3-tuple whose stdin pipe becomes child.stdin, stdout/stderr
-   * pipes become child.stdout/child.stderr, and output slots may also be
-   * number fds. Omitting stdio uses Node's default: all three piped. The
-   * other lowered
-   * members: `detached` (a boolean literal, inline or carried by the
-   * conditional spread `...(c ? { detached: true } : {})` in either
-   * orientation — POSIX_SPAWN_SETSID, the child gets its own session and
-   * process group like Node's), `env` (a
-   * REPLACEMENT environment, the exec-core pairs machinery), `cwd`, and
-   * `windowsHide` (a POSIX no-op). The bare `{ stdio: "ignore" }` shape
-   * keeps its historical cp.spawn lowering. */
-export declare function lowerSpawnCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-/** `fork(staticModulePath, args?, options?)` embeds the selected program
- * module and re-executes the native artifact with one private target id.
- * Node's default JSON IPC channel is always present. */
-export declare function lowerForkCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-/** `execFile(file[, args][, options], callback)` — the asynchronous callback
- * slice. The child starts immediately with stdin/stdout/stderr piped; the
- * runtime captures both outputs and invokes the error-first callback after
- * settlement. The callback may ignore a suffix of `(error, stdout,
- * stderr)`, but every declared parameter must have the Node shape. Inline
- * `encoding: "utf8"` and a pure numeric `maxBuffer` are accepted; the latter
- * is not enforced by the growing native capture, as
- * with the synchronous and promisified capture forms. Other options remain
- * fenced until their lifecycle can share this asynchronous core. */
-export declare function lowerExecFileCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-export declare function lowerExecSyncCall(lowerer: Lowerer, expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
-/** Compile-time util.promisify projections. The immutable result binding
-   * owns no runtime slot: calls rewrite to the target's promise lowering,
-   * while value uses remain explicit fences. Unsupported targets report at
-   * the declaration, where their identity is still visible. */
-export declare function isPromisifyCall(lowerer: Lowerer, init: ts.Expression): ts.CallExpression | null;
-/** Immutable aliases of table-backed builtin functions. The alias is a
- * compile-time call target, so direct calls keep the builtin's validated
- * lowering without materializing a JavaScript function object. Value
- * uses remain fenced until an escaping closure adapter exists. */
-export declare function registerBuiltinCallableAlias(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-export declare function registerPromisifiedBuiltinDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
-/** A call THROUGH a promisified-execFile binding:
-   * `execFileAsync(file, args?, options?)` → one call of the interned
-   * %execFileAsync helper — an ASYNC IR function (throw-becomes-rejection
-   * for free) that runs the exec core synchronously and returns
-   * `{ stdout, stderr }`, exactly Node's promisified execFile behind an
-   * already-settled promise (the fs/promises stance, divergence 23).
-   * Options are the exec-sync slice minus stdio (the async form always
-   * captures both streams, no echo): encoding must spell utf8, cwd/env/
-   * timeout lower, maxBuffer/windowsHide are accepted no-ops, killSignal
-   * only as its SIGTERM default. Rejections carry Node's async messages
-   * ("Command failed: <cmd>\n<stderr>" — the trailing newline is Node's —
-   * and "spawn <file> ENOENT" with .code); Node's numeric `.code` on a
-   * Command-failed rejection (the exit status) is NOT carried —
-   * SEMANTICS.md divergence 50's stance. */
-export declare function lowerExecFileAsyncCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-/** The interned `%execFileAsync` helper behind promisified-execFile
-   * calls: an ASYNC IR function (params: cmd, argv, cwd, hasEnv, envPairs,
-   * timeoutMs) whose body runs the may-throw cp.execCapture libCall — the
-   * async machinery turns a throw into the rejection, Node's promisified
-   * behavior — and returns the `{ stdout, stderr }` record built from the
-   * capture. One helper per program (the shape is fixed). */
-export declare function execFileAsyncHelper(lowerer: Lowerer, loc: SrcLoc): {
-    name: string;
-    shapeId: string;
-    envShapeId: string;
-};
-/** An `env` option object → the [k, v, ...] pairs array cp.execSync
-   * consumes. The value must be a record (an index-signature ProcessEnv
-   * snapshot — `{ ...process.env, X: y }` — or a plain string-map): its
-   * string-typed fields and, for index-signature shapes, overflow entries
-   * flatten in JS own-key order, undefined-armed values SKIPPED (Node
-   * drops undefined env entries). Reuses the interned overflow-keys/read
-   * machinery. */
-export declare function recordToEnvPairs(lowerer: Lowerer, node: ts.Expression): IrExpr;
-/** Method calls on diagnostics_channel Channel receivers:
- * publish(message), subscribe(fn), unsubscribe(fn) — over the f64
- * channel handle. The rest of the declared surface (bindStore,
- * runStores) fences member-qualified. Null for non-Channel receivers. */
-export declare function lowerDcChannelMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on AsyncLocalStorage receivers: run(store, fn, ...args),
- * exit(fn, ...args), getStore(), enterWith(store), disable() — over the
- * f64 store handle (als.* libCalls; values cross as dyn values). Null
- * for non-ALS receivers. */
-export declare function lowerAlsMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Property reads on Channel receivers: `.name` (the registration
- * string) and `.hasSubscribers` (the publish guard). Null for
- * non-Channel receivers and other members (the method fence owns them). */
-export declare function lowerDcChannelProperty(lowerer: Lowerer, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on TracingChannel receivers: subscribe/unsubscribe over
- * a dyn handlers object, traceSync/traceCallback through the runtime's
- * publish choreography (dc.tcTraceSync/dc.tcTraceCallback — fn, context,
- * thisArg, and the argument vector all cross as dyn values; context
- * defaults to a fresh `{}` and thisArg to undefined, Node's defaults),
- * and tracePromise through the reaction-fiber choreography
- * (dc.tcTracePromise — the result is the reaction promise, typed
- * promise<dyn> so .then/.catch chains ride the promise lowerings).
- * Null for non-TracingChannel receivers. */
-export declare function lowerDcTracingChannelMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Property reads on TracingChannel receivers: the five event channels
- * (`.start` … `.error` — Channel-typed f64 handles the Channel lowerings
- * take over) and `.hasSubscribers` (the five-channel disjunction). Null
- * for other members and non-TracingChannel receivers. */
-export declare function lowerDcTracingChannelProperty(lowerer: Lowerer, access: ts.PropertyAccessExpression): IrExpr | null;
-export declare function lowerReadlineMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** StringDecoder writes preserve pending bytes; end(input) performs the
- * final write and flushes the state. String input passes through unchanged. */
-export declare function lowerStringDecoderMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The interned %strdec helpers: write(d, chunk) returns the decoded
-   * complete prefix and re-buffers the trailing partial into the pending
-   * field; end(d) flushes it. Both thread the packed-f64 state through
-   * the pure strdec.* libCalls. */
-export declare function strdecHelper(lowerer: Lowerer, op: "write" | "end" | "endChunk" | "endString" | "writeString", shapeId: string, loc: SrcLoc): string;
-/** JSON parse produces checked-dynamic data; a native reviver walks it
- * bottom-up before any checked cast. Stringify without a callback keeps
- * its type-directed fast path. A function replacer boxes the input and
- * walks it before primitive normalization. Both paths share literal gap
- * rules, and callback failures use ordinary native exception unwinding. */
-export declare function lowerJsonMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The module specifier when `ident` is an import binding (named,
-   * default, or namespace) from a node BUILTIN module with no scriptc
-   * support — "child_process", "net", ... — or null. The coverage story's
-   * use-site half: preflight fenced the import line; statements using the
-   * binding poison with the same module-naming diagnostic. */
-export declare function fencedBuiltinImportOf(lowerer: Lowerer, ident: ts.Identifier): string | null;
-/** The composed crypto pattern: `randomBytes(n).toString(enc)` lowers
-   * as ONE string-producing libCall — the Buffer between the two calls
-   * never exists at runtime. Only literal "hex"/"base64" encodings lower
-   * (the runtime implements exactly those); wider forms fall through to
-   * the ordinary Buffer lowering. Null when this is not a toString on a
-   * crypto.randomBytes call. */
-export declare function lowerCryptoComposedCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The node:crypto utility and introspection statics. Hash/Hmac are real
-   * native handles; one-shot hashing, constant-time equality, random-fill/
-   * integer, and PBKDF2 share the same runtime primitives as the island.
-   * The name lists remain build-time constants. */
-export declare function lowerCryptoModuleCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
-    module: string;
-    member: string;
-}, loc: SrcLoc): IrExpr | null;
-/** Method calls on URL-typed receivers: `u.toString()` and `u.toJSON()` are Node's href
-   * serialization (the href getter's libCall). Everything else the lib
-   * declares fences member-qualified. Null for non-URL receivers. */
-export declare function lowerUrlMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `new URLSearchParams(init?)` — the WHATWG constructor's lowered init
-   * shapes: omitted / literal `undefined` (empty list), a string (parsed,
-   * one leading '?' strips), another URLSearchParams (snapshot copy — a
-   * `u.searchParams` argument included), a string[][] value (pairs;
-   * Node's ERR_INVALID_TUPLE TypeError on a non-pair row, thrown by the
-   * runtime), and an OBJECT LITERAL (each property appends in source
-   * order — folded to a sp.with chain at compile time; keys are the
-   * record-literal key forms, values coerce as strings). Tuple-typed pair
-   * arrays and unions keep named fences. */
-export declare function lowerSearchParamsNew(lowerer: Lowerer, expr: ts.NewExpression, loc: SrcLoc): IrExpr;
-/** Method calls on URLSearchParams-typed receivers — the WHATWG list
-   * surface over the runtime's decoded pairs. get answers `string | null`
-   * (the checker's own union; the runtime's +1-or-NULL builds the arms);
-   * has/delete take the value-aware second argument (an explicitly
-   * `undefined`-typed second argument means the name-only form, Node's
-   * treatment); forEach desugars to a synthesized index loop over the
-   * LIVE list (sp.size re-reads every pass — appends mid-walk are
-   * visited, deletes shift, the spec's index-based iteration).
-   * keys()/values()/entries() lower only in a for-of head (lower-stmts
-   * routes them before this table) — stored iterator objects keep the
-   * drain fence. Null for non-searchParams receivers. */
-export declare function lowerSearchParamsMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Calls on an fs/promises FileHandle. The promise-returning methods run
- * through the same synchronous descriptor primitives as fs.readSync /
- * writeSync, then settle so failures reject at await. read/write retain
- * the caller's buffer in the Node-shaped result record. */
-export declare function lowerFileHandleMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on Stats-typed receivers: isFile()/isDirectory()/
-   * isSymbolicLink() are pure reads on the stat snapshot (a followed
-   * statSync snapshot never answers true to isSymbolicLink — take
-   * lstatSync's, Node's own split). Everything else @types/node declares
-   * (mtime, mode, ...) fences member-qualified. Null for non-Stats
-   * receivers. */
-export declare function lowerStatsMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Calls on native crypto.Hash/Hmac handles. The handle survives locals,
-   * aliases, loops, and returns; update() retains and returns the receiver,
-   * digest() finalizes it, and Hash.copy() snapshots the incremental state. */
-export declare function lowerCryptoHashMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `Atomics.wait(int32Array, idx, expected, timeoutMs)` — the
-   * synchronous-sleep idiom (RouteStore's
-   * `Atomics.wait(sleepBuffer, 0, 0, ms)`): scriptc has no threads, so
-   * nothing can ever notify a waiter and the spec's behavior for every
-   * compilable program is exactly "compare, then sleep out the timeout"
-   * — "not-equal" when the element differs, a real nanosleep and
-   * "timed-out" otherwise ("ok" is unreachable). The timeout argument is
-   * REQUIRED: without it Node blocks until a notify that cannot exist
-   * here — a certain deadlock, fenced with that explanation. Every other
-   * Atomics member (notify has no one to wake; add/load/... — nothing
-   * races) fences member-qualified. Null for non-Atomics receivers. */
-export declare function lowerAtomicsCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The property-read extensions this spoke owns, tried BEFORE the
-   * lower-exprs intrinsic-property fallback (the lowerer's wrapper chains
-   * them): the widened numeric Stats snapshot and SpawnSyncReturns.signal
-   * (the termination signal's name as the call site's `Signals | null` union
-   * — null for a normal exit or spawn failure; a timeout kill reports its
-   * killSignal, Node's shape). Null for everything else, so the ordinary
-   * chain (and its fences) keeps going. */
-export declare function lowerBuiltinExtraProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-export declare function lowerChildMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on piped child-output stream receivers (child.stdout /
-   * child.stderr — the childStream kind): on/once("data" | "end").
-   * 'data' listeners take zero parameters, `(chunk: Buffer)`, or a
-   * `Buffer | string`-union chunk (the ngrok appendOutput shape — the
-   * runtime only ever fires Buffers; the compiler-emitted adapter wraps
-   * the chunk at the union's Buffer arm); 'end' listeners take none.
-   * Statement position only (Node returns the stream for chaining; here
-   * the result is void). Chained receivers (`child.stdout?.on(...)`)
-   * ride the optional-chain re-dispatch (chainBlocked). Everything else
-   * @types/node declares on Readable fences member-qualified. Null for
-   * non-stream receivers. */
-export declare function lowerChildStreamMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on a piped child stdin writer. Writes copy one string or
- * Uint8Array into the nonblocking runtime queue and return the backpressure
- * signal. end()/destroy() are statement-only, as are drain/finish/error
- * listener registrations; unsupported callbacks/encodings stay fenced. */
-export declare function lowerChildWriterMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on first-class process-stream receivers (procStream —
-   * a WritableStream-typed value like prefixStream's `output` param):
-   * write(data) with one string, dispatched at runtime onto the exact
-   * stdout/stderr write paths (the fd IS the value). Everything else
-   * @types/node declares on WritableStream fences member-qualified.
-   * Null for non-procStream receivers. */
-export declare function lowerProcStreamMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on FSWatcher receivers: close() — idempotent, statement
-   * position (Node returns void there too). Everything else @types/node
-   * declares (ref/unref, the EventEmitter surface) fences member-
-   * qualified. Null for non-watcher receivers. */
-export declare function lowerWatcherMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `.code` and `.cause` on an error-hierarchy receiver. The latter reads
-   * the hidden dyn slot installed by constructor options. The former is NodeJS.ErrnoException's
-   * member (the fallback declares the same shape): the runtime Error's
-   * code slot as `string | undefined` — the errno name where a throw site
-   * stamped one (fs, exec spawn/timeout, process.kill, the spawn 'error'
-   * event), undefined everywhere else. Stdlib provenance required (a user
-   * class's own `code` field takes the ordinary field paths — its
-   * declaration is not stdlib). Reads only: writes keep their fence (no
-   * compiled program constructs an errno error). Null for non-error
-   * receivers and non-stdlib members, so the chain keeps trying. */
-export declare function lowerErrorCodeProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** Stored stringify uses the same native serializer and keeps omitted roots
-   * as undefined. Other JSON method values retain a named refusal. */
-export declare function lowerJsonProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** `constants.X_OK` where `constants` is a named fs import: the access-
-   * mode bits bake as number literals (POSIX values — Node's own on the
-   * supported hosts). Other fs.constants members (COPYFILE_*, O_*) fence
-   * by name. Null for non-fs-constants receivers. */
-export declare function lowerFsConstantsProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** `process.stdin/stdout/stderr.isTTY` → isatty(3) on the stream's fd
-   * (a REAL boolean: Node's non-TTY streams expose `undefined` here — the
-   * documented divergence; truthiness tests, the actual usage, agree), and
-   * `process.stdout/stderr.columns/rows` → ioctl(TIOCGWINSZ) on the fd, with
-   * Node's non-TTY answer intact: the read is `number | undefined` and a
-   * non-TTY (or ioctl-refusing) stream yields the undefined arm. The
-   * receiver match sees through parens and as-casts to the SYMBOL —
-   * `(process.stderr as typeof process.stderr & { columns?: number })
-   * .columns` is the wild widening pattern (@types/node declares a plain
-   * `number`, so honest code casts the undefined possibility back in), and
-   * the cast changes the expression's TYPE, never the value. columns sites
-   * whose checker type does NOT admit undefined are fenced with that exact
-   * fix instead of lowering to a lie. Null for anything else, so the
-   * property chain keeps trying. */
-export declare function lowerProcessStreamProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** `process.argv` / `process.platform` / `process.pid` property READS
-   * lower to zero-arg libCalls (argv returns +1 on one interned array —
-   * identity and mutation semantics match Node's stable process.argv).
-   * `process.env` as a WHOLE value lowers to a fresh SNAPSHOT record —
-   * `{ [k: string]: string | undefined }` built over environ by the
-   * interned %env.snapshot helper: `{ ...process.env }`, Object.keys, and
-   * spawn-env flows all snapshot at the read, exactly what Node's own
-   * spread does (and nothing in a compiled program mutates environ between
-   * a snapshot and its use except process.env writes, which precede the
-   * read in source order). Method members referenced without a call are
-   * rejected specifically. Null for non-process receivers (the chain keeps
-   * trying other property lowerings). */
-export declare function lowerProcessProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** True iff `node` is THE ambient `process.env` object itself (the
-   * receiver of an env read). */
-export declare function isProcessEnv(lowerer: Lowerer, node: ts.Expression): boolean;
-/** The interned `string | undefined` union — the type every env read
-   * produces (withUndefinedArm interns [string, undefined] in canonical
-   * order, so the string arm's tag is 0 and the undefined arm's is 1,
-   * program-wide). */
-export declare function envValueType(lowerer: Lowerer): IrType;
-/** `d.isFile()` / `d.isDirectory()` / `d.isSymbolicLink()` on a Dirent-
-   * typed receiver (the interned record — provenance via the checker's
-   * Dirent symbol, the StringDecoder pattern): a read of the hidden
-   * %dtype field compared against libuv's UV_DIRENT code. Node's other
-   * type probes (isBlockDevice, ...) fence with the supported list. */
-export declare function lowerDirentMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `process.env.NAME` → the process.envGet intrinsic with a literal key
-   * (the element form lands in lowerElementAccess). getenv(3) at runtime:
-   * present wraps the string arm, absent yields the interned
-   * undefined-arm instance. Null for non-env receivers. */
-export declare function lowerProcessEnvGet(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** `process.exit(code)` / `process.cwd()` → libCall. The fallback
-   * declaration makes exit's code required; @types/node declares it
-   * optional. A bare `process.exit()` uses the current exitCode, or zero
-   * when unset. */
-export declare function lowerProcessMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Method calls on THE `Number` global: the predicate statics lower to
-   * plain C over f64 arguments; `Number.parseFloat`/`Number.parseInt` ARE
-   * the global parsers (the spec aliases them), so they get the same
-   * island lowering — engine execution under --dynamic, per-site SC2012
-   * without it (parseInt takes an explicit radix, like the global). Null
-   * for non-Number receivers. */
-export declare function lowerNumberStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The Date slice: statics plus read-only Date values backed by one
-   * TimeClip'd millisecond scalar. Construction lives in lowerNew;
-   * identity and mutating methods remain fenced. */
-export declare function lowerDateCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-type TextCodecCtor = {
-    cls: "TextDecoder" | "TextEncoder";
-    ctor: ts.NewExpression;
-};
-/** Box a codec's immutable encoding in an owned record. Unlike erased
- * aliases, this value can live in fields, arguments, and closure captures. */
-export declare function lowerTextCodecNew(lowerer: Lowerer, ctor: ts.NewExpression, cls: TextCodecCtor["cls"]): IrExpr;
-/** Inline codec calls avoid allocating a receiver; stored receivers use
-   * the owned record path above. decode is the runtime's WHATWG
-   * decode for every recognized static label (with BOM handling for the
-   * Unicode encodings); a zero-argument decode() is "" like the spec's.
-   * encode IS Buffer.from(s, "utf8") — ScrStr
-   * storage is well-formed UTF-8, so the bytes are identical (lone
-   * surrogates became U+FFFD at string construction, exactly what the
-   * spec's encoder emits). Null when this is neither supported form. */
-export declare function lowerTextCodecCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `String.fromCharCode/fromCodePoint(...codes)` on THE String global: every argument
-   * lowers as a number and packs into ONE f64[] array-literal argument
-   * (the path.join convention) — or ONE whole-array spread forwards the
-   * array itself. String.raw has its own template path below.
-   * Null for non-String receivers. */
-export declare function lowerStringStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `s.lastIndexOf(searchValue?, position?)` on string receivers, using UTF-16
-   * indices. An omitted search value searches for "undefined". Omitted or undefined positions clamp to the string's end;
-   * MAX_SAFE_INTEGER has the same effect for every representable string.
-   * Null for non-string receivers and other members. */
-export declare function lowerStringLastIndexOfCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `Promise.race([...])` on THE Promise global: the entries lower
-   * individually (the array never materializes — promise-element arrays
-   * have no representation) into a promise.race intrinsic; the result
-   * type is the checker's combined promise, and each entry's inner type
-   * must be that inner type, one of its union arms, or a sub-union of it
-   * (the backend's interned adapters wrap/re-tag fulfillments; a wider
-   * entry would need machinery that doesn't exist and fences).
-   * Promise.all/allSettled/any fence with the sequential-await hint;
-   * resolve/reject and the rest fall to the member fence. Null for
-   * non-Promise receivers. */
-export declare function lowerPromiseStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Property READS on THE `Number` global: the finite constants bake as
-   * number literals. NaN/POSITIVE_INFINITY/NEGATIVE_INFINITY and method
-   * members as values fall through to the member fence. Null for
-   * non-Number receivers. */
-export declare function lowerNumberStaticProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** `t.unref()` / `t.ref()` / `t.hasRef()` on a Timeout handle — loop-
-   * liveness bookkeeping over the numeric timer id (the handle is f64).
-   * unref/ref return the handle for chaining (Node); hasRef returns a
-   * bool. `refresh` and the rest of @types/node's Timeout surface fence.
-   * Null when the receiver isn't a Timeout handle. */
-export declare function lowerTimeoutMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `process.getuid?.()` — the optional call of an optional process
-   * method. On a POSIX target the member always exists, so the `?.` IS the
-   * call (the checker's undefined arm covers Windows, which scriptc does
-   * not target) and the honest result is the plain number. Intercepted
-   * BEFORE the optional-chain machinery: `process.getuid` has no value
-   * lowering for the chain to guard. Null when this isn't that shape. */
-export declare function lowerProcessOptionalMethodCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr | null;
-/** The interned `%env.snapshot` helper behind `process.env` as a VALUE: a
-   * fresh `{ [k: string]: string | undefined }` record built over environ —
-   * envPairs hands the [k0, v0, k1, v1, ...] strings in environ order and
-   * the helper keyed-writes each pair into the record's overflow map (JS
-   * own-key order follows insertion, exactly Node's Object.keys order over
-   * process.env). The target shape must be a pure index-signature record
-   * whose value slot is the `string | undefined` union (what ProcessEnv
-   * maps to); anything else answers null and the caller keeps its fence. */
-export declare function envSnapshotHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): string | null;
-export declare function isConsoleLog(lowerer: Lowerer, call: ts.CallExpression): boolean;
-/** The console member of a `console.<member>(...)` call, for the lowered
-   * set: "log"/"info"/"debug" (stdout — Node's info and debug ARE log
-   * under other names), and "error"/"warn" (both stderr — Node's warn IS
-   * error under another name; the output is identical). Provenance-checked
-   * like every stdlib global. Null for anything else (console.table, a
-   * user's own console binding, ...). */
-export declare function consoleCallMember(lowerer: Lowerer, call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
-export {};