@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -1,7 +1,7 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import { BuiltinModuleFn } from "./surfaces.js";
-import { IrExpr, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrType, SrcLoc } from "../../ir/ir.js";
 /** 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
@@ -12,7 +12,7 @@ import { IrExpr, IrType, SrcLoc } from "../../ir/nodes.js";
    * 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(L: Lowerer, ident: ts.Identifier): {
+export declare function builtinImportOf(lowerer: Lowerer, ident: ts.Identifier): {
     module: string;
     member: string;
 } | null;
@@ -33,38 +33,31 @@ export declare function builtinMemberRequireDecl(nameNode: ts.Node, init: ts.Exp
    * 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(L: Lowerer, decl: ts.VariableDeclaration): string | null;
+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;
-/** The `createRequire(<base>)` call over the node:module import binding
-   * with a supported base — import.meta.url, import.meta.filename, or
-   * __filename, every spelling of "this file" — or null. The base never
-   * LOWERS (import.meta has no value representation): it only names the
-   * file whose directory anchors the returned require's relative
-   * resolution, and every supported spelling names the call's own file. */
-export declare function createRequireBaseCallOf(L: Lowerer, expr: ts.Expression): ts.CallExpression | null;
 /** 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. A reassignable (let/var) binding never matches — callers
    * gate on constness like the other alias decls. */
-export declare function createRequireBindingDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+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 CONST 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(L: Lowerer, callee: ts.Expression): ts.SourceFile | null;
+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(L: Lowerer, call: ts.CallExpression): {
+export declare function createRequireSpecOf(lowerer: Lowerer, call: ts.CallExpression): {
     spec: string | null;
     baseFile: ts.SourceFile;
 } | null;
@@ -73,7 +66,7 @@ export declare function createRequireSpecOf(L: Lowerer, call: ts.CallExpression)
    * plumbing with no storage (uses resolve through
    * builtinNamespaceModuleOf's createRequire arm); both declaration
    * walks skip by this test. */
-export declare function createRequireNamespaceDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+export declare function createRequireNamespaceDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
 /** `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
@@ -89,27 +82,12 @@ export declare function createRequireNamespaceDecl(L: Lowerer, nameNode: ts.Node
    * 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(L: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr | null;
-/** The module whose baked-constants OBJECT `node` denotes, or null — any
-   * of the spellings: `http2.constants`/`crypto.constants` through a
-   * namespace/require binding, a destructured or member-bound `constants`
-   * alias from the module, or `require("http2").constants` inline. The
-   * object itself never materializes; each member read bakes as its
-   * literal. */
-export declare function builtinConstantsModuleOf(L: Lowerer, node: ts.Expression): string | null;
+export declare function lowerCreateRequireCall(lowerer: Lowerer, call: ts.CallExpression, loc: SrcLoc): 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** True for any spelling of node:perf_hooks' `performance` object — the
-   * named import binding, a namespace/default-import member, the require
-   * twins (all through the shared builtin tables), or the GLOBAL Node
-   * exposes without any import (the module export and the global are one
-   * value; provenance-checked like console/process, so the bare
-   * identifier and the globalThis.performance member both land here and
-   * a user's own `performance` binding never does). */
-export declare function isPerfHooksPerformanceExpr(L: Lowerer, node: ts.Expression): boolean;
+export declare function lowerBuiltinConstantsProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): 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
@@ -117,7 +95,7 @@ export declare function isPerfHooksPerformanceExpr(L: Lowerer, node: ts.Expressi
    * 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(L: Lowerer, expr: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -125,10 +103,10 @@ export declare function lowerPerfHooksCall(L: Lowerer, expr: ts.CallExpression,
    * alias plumbing with no storage (lowerVarDecl and collectGlobals both
    * skip it); each USE reads its baked literal
    * (builtinConstantBindingOf). */
-export declare function builtinConstantsDestructureDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+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(L: Lowerer, ident: ts.Identifier): IrExpr | null;
+export declare function builtinConstantBindingOf(lowerer: Lowerer, ident: ts.Identifier): IrExpr | null;
 /** One builtin-module function call → its libCall. Completes the call to
    * the table's exact shape: variadicPack functions (path.join/resolve)
    * accept any arity — or ONE spread of a string[] — and pack the
@@ -142,7 +120,7 @@ export declare function builtinConstantBindingOf(L: Lowerer, ident: ts.Identifie
  * Node's exact ERR_INVALID_ARG_TYPE. The argument crosses as a dyn
  * value so the runtime renders the Received tail. Null when this is
  * not that call (the table fence stays for other shapes). */
-export declare function lowerFsToUnixTimestampCall(L: Lowerer, expr: ts.CallExpression, bi: {
+export declare function lowerFsToUnixTimestampCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
     module: string;
     member: string;
 }, loc: SrcLoc): IrExpr | null;
@@ -155,11 +133,11 @@ export declare function lowerFsToUnixTimestampCall(L: Lowerer, expr: ts.CallExpr
  * 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(L: Lowerer, expr: ts.CallExpression, bi: {
+export declare function lowerFsLadderCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
     module: string;
     member: string;
 }, loc: SrcLoc): IrExpr | null;
-export declare function lowerBuiltinModuleCall(L: Lowerer, expr: ts.CallExpression, bi: {
+export declare function lowerBuiltinModuleCall(lowerer: Lowerer, expr: ts.CallExpression, bi: {
     module: string;
     member: string;
 }, fn: BuiltinModuleFn, loc: SrcLoc): IrExpr;
@@ -171,13 +149,13 @@ export declare function lowerBuiltinModuleCall(L: Lowerer, expr: ts.CallExpressi
    * 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 Reflect.apply call. */
-export declare function lowerReflectApplyCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerReflectApplyCall(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(L: Lowerer, node: ts.Expression | undefined, loc: SrcLoc): IrExpr;
+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
@@ -194,7 +172,7 @@ export declare function lowerChildArgsArg(L: Lowerer, node: ts.Expression | unde
    * 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(L: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+export declare function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
 /** `spawn(command, args?, options)` → one cp.spawn / cp.spawnOpts
    * libCall. The options argument must be an object LITERAL with an
    * EXPLICIT stdio — "ignore" or "inherit" as the scalar, or the 3-tuple
@@ -210,8 +188,8 @@ export declare function lowerSpawnSyncCall(L: Lowerer, expr: ts.CallExpression,
    * 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(L: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-export declare function lowerExecSyncCall(L: Lowerer, expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
+export declare function lowerSpawnCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+export declare function lowerExecSyncCall(lowerer: Lowerer, expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
 /** `const execFileAsync = promisify(execFile)` — the ONE lowered
    * util.promisify shape. Returns true (and registers the declared symbol
    * so call sites lower and value uses fence) when `init` is a promisify
@@ -219,8 +197,8 @@ export declare function lowerExecSyncCall(L: Lowerer, expr: ts.CallExpression, s
    * over anything else fences HERE with the supported-target hint (the
    * declaration is where the target is visible). False for non-promisify
    * initializers, so the ordinary declaration paths apply. */
-export declare function isPromisifyCall(L: Lowerer, init: ts.Expression): ts.CallExpression | null;
-export declare function promisifiedExecFileDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+export declare function isPromisifyCall(lowerer: Lowerer, init: ts.Expression): ts.CallExpression | null;
+export declare function promisifiedExecFileDecl(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
@@ -235,14 +213,14 @@ export declare function promisifiedExecFileDecl(L: Lowerer, nameNode: ts.Node, i
    * 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(L: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+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(L: Lowerer, loc: SrcLoc): {
+export declare function execFileAsyncHelper(lowerer: Lowerer, loc: SrcLoc): {
     name: string;
     shapeId: string;
     envShapeId: string;
@@ -254,21 +232,21 @@ export declare function execFileAsyncHelper(L: Lowerer, loc: SrcLoc): {
    * 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(L: Lowerer, node: ts.Expression): IrExpr;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, access: ts.PropertyAccessExpression): IrExpr | null;
+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,
@@ -278,13 +256,13 @@ export declare function lowerDcChannelProperty(L: Lowerer, access: ts.PropertyAc
  * (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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, access: ts.PropertyAccessExpression): IrExpr | null;
-export declare function lowerReadlineMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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;
 /** Method calls on StringDecoder receivers: `d.write(chunk)` decodes the
    * complete prefix of pending+chunk and re-buffers the trailing partial
    * sequence; `d.end()` flushes the buffered partial as its replacement
@@ -292,12 +270,12 @@ export declare function lowerReadlineMethodCall(L: Lowerer, call: ts.CallExpress
    * interned %strdec helpers over the packed-f64 pending field. end(buf)
    * and the rest of @types/node's surface fence per member. Null for
    * non-decoder receivers. */
-export declare function lowerStringDecoderMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, op: "write" | "end", shapeId: string, loc: SrcLoc): string;
+export declare function strdecHelper(lowerer: Lowerer, op: "write" | "end", shapeId: string, loc: SrcLoc): string;
 /** `JSON.parse(text)` / `JSON.stringify(value)`.
    * - parse → a may-throw `libCall` producing a dyn value (the runtime JSON
    *   dyn); malformed input throws a catchable SyntaxError-shaped string.
@@ -315,20 +293,20 @@ export declare function strdecHelper(L: Lowerer, op: "write" | "end", shapeId: s
    *   rides the node to the backend's re-indenter. Function replacers and
    *   non-literal spaces stay fenced.
    * Null when this isn't a JSON member call. */
-export declare function lowerJsonMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, ident: ts.Identifier): string | null;
+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); everything else — including a
    * bare randomBytes(n) — fences with the Buffer story. Null when this
    * isn't a toString on a crypto.randomBytes call. */
-export declare function lowerCryptoComposedCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerCryptoComposedCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** The node:crypto introspection statics — build-time constants of the
    * compiled runtime, baked at the call site (the http2.constants stance
    * extended to calls): getFips() answers 0 (no FIPS provider can ever
@@ -340,14 +318,14 @@ export declare function lowerCryptoComposedCall(L: Lowerer, call: ts.CallExpress
    * that probes the list and then constructs a cipher fences at the
    * construction site, never here. Null for other members (the dispatch
    * keeps trying). */
-export declare function lowerCryptoModuleCall(L: Lowerer, expr: ts.CallExpression, bi: {
+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()` is 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -357,7 +335,7 @@ export declare function lowerUrlMethodCall(L: Lowerer, call: ts.CallExpression,
    * 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(L: Lowerer, expr: ts.NewExpression, loc: SrcLoc): IrExpr;
+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);
@@ -369,19 +347,19 @@ export declare function lowerSearchParamsNew(L: Lowerer, expr: ts.NewExpression,
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerStatsMethodCall(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
@@ -393,7 +371,7 @@ export declare function lowerStatsMethodCall(L: Lowerer, call: ts.CallExpression
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -401,7 +379,7 @@ export declare function lowerAtomicsCall(L: Lowerer, call: ts.CallExpression, ac
    * — 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerBuiltinExtraProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Method calls on ChildProcess receivers: `child.on("exit"|"error", cb)`
    * registers a listener with the event loop's child registry. The event
    * name must be one of the two terminal-event LITERALS; the callback
@@ -413,7 +391,7 @@ export declare function lowerBuiltinExtraProperty(L: Lowerer, expr: ts.PropertyA
    * lowerIntrinsicProperty). Everything else @types/node declares on
    * ChildProcess (stdout, once, ...) fences member-qualified. Null for
    * non-child receivers. */
-export declare function lowerChildMethodCall(L: Lowerer, call: ts.CallExpression, access: 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
@@ -425,33 +403,19 @@ export declare function lowerChildMethodCall(L: Lowerer, call: ts.CallExpression
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerChildStreamMethodCall(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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `fs.watch(path[, options][, listener])` → the fs.watch libCall
-   * (scr_watch.c — kqueue EVFILT_VNODE on the opened path; an unopenable
-   * path THROWS Node's fs error synchronously, the polling-fallback catch
-   * shape). The listener fires with "rename"/"change" and takes zero
-   * parameters or the eventType string — the filename parameter has no
-   * lowering (kqueue watches the inode, not the directory entry; you
-   * watched one path). The options record follows the options-record
-   * stance: persistent: true, recursive: false, and encoding: "utf8"
-   * state the lowered behavior and are accepted; persistent: false
-   * (a watcher that does NOT hold the loop), recursive: true (kqueue
-   * watches one inode), signal, and non-utf8 encodings fence by name;
-   * undocumented keys drop like Node. An open watcher keeps the loop
-   * alive until watcher.close(). */
-export declare function lowerFsWatchCall(L: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerWatcherMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `.code` on an error-hierarchy receiver — 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
@@ -461,16 +425,16 @@ export declare function lowerWatcherMethodCall(L: Lowerer, call: ts.CallExpressi
    * 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerErrorCodeProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** `JSON.parse` / `JSON.stringify` referenced without a call: rejected
    * specifically, like process methods as values. Null for non-JSON
    * receivers (the property chain keeps trying other lowerings). */
-export declare function lowerJsonProperty(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -485,7 +449,7 @@ export declare function lowerFsConstantsProperty(L: Lowerer, expr: ts.PropertyAc
    * 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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).
@@ -498,80 +462,44 @@ export declare function lowerProcessStreamProperty(L: Lowerer, expr: ts.Property
    * 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, node: ts.Expression): boolean;
+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(L: Lowerer): IrType;
-/** `os.networkInterfaces()` — getifaddrs(3) behind Node's exact result
-   * type. The libCall's type is the CALL SITE's mapped
-   * `NodeJS.Dict<NetworkInterfaceInfo[]>`: a pure index-signature record
-   * whose value is `Info[] | undefined`, Info the two-record union
-   * @types/node declares (IPv4: `scopeid?: number` — the undefined-armed
-   * union — and IPv6: `scopeid: number`; family literal types collapse to
-   * string in both). The emitter derives every shape/union/tag from that
-   * type, so the structure is verified HERE and anything else (an older
-   * @types/node, a user alias reshaping the result) fences honestly. Key
-   * and row order follow getifaddrs enumeration — Node itself guarantees
-   * no order (compare structurally). */
-/** `fs.readdirSync(path, { withFileTypes: true })` — Dirent rows: name +
-   * parentPath (the path argument as given, Node's own rule) + the hidden
-   * %dtype entry kind (libuv's UV_DIRENT encoding; DT_UNKNOWN falls back
-   * to lstat, Node's getDirents rule). The options literal is checked
-   * member-by-member; the result type must be the interned Dirent record
-   * array from types.ts — anything else (encoding: 'buffer', a user alias
-   * reshaping Dirent) fences honestly. */
-export declare function lowerFsReaddirTypesCall(L: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** querystring.parse / querystring.decode: the scan runs in the runtime
- * (scr_qs_parse_into fills the result dictionary's overflow map), so the
- * frontend completes sep/eq/maxKeys to Node's defaults and verifies the
- * call site's mapped result IS the ParsedUrlQuery dictionary — a pure
- * index-signature record over `string | string[]` (an undefined arm
- * tolerated: @types/node's Dict) — the networkInterfaces verification
- * stance. The default decoder is the one lowered decoder; a custom
- * decodeURIComponent option fences by name. */
-export declare function lowerQuerystringParseCall(L: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr;
-/** querystring.stringify / querystring.encode: the object crosses as a
- * dyn value (dynFrom — JSON-safe records and, in JS sources, dyn values
- * directly) and Node's encodeStringified rules run in the runtime
- * (scr_qs_stringify), so arrays expand to repeated keys and
- * null/undefined values are empty. The default encoder is the one
- * lowered encoder; a custom encodeURIComponent option fences by name. */
-export declare function lowerQuerystringStringifyCall(L: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr;
-export declare function lowerOsNetworkInterfacesCall(L: Lowerer, call: ts.CallExpression, loc: SrcLoc): IrExpr;
+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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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, and a bare `process.exit()` lowers as exit(0) — exactly
    * Node's behavior when process.exitCode was never set (setting exitCode
    * is fenced like every other unsupported process member, so "never set"
    * always holds in a compiled program). */
-export declare function lowerProcessMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerDateCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 type TextCodecCtor = {
     cls: "TextDecoder" | "TextEncoder";
     ctor: ts.NewExpression;
@@ -581,8 +509,8 @@ type TextCodecCtor = {
    * stable binding are recognized by textCodecReceiverOf below; any other
    * reached value use keeps the ordinary SC2020 representation fence. Both
    * declaration walks call this and independently gate on constness. */
-export declare function textCodecBindingClassOf(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): TextCodecCtor["cls"] | null;
-export declare function textCodecBindingDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+export declare function textCodecBindingClassOf(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): TextCodecCtor["cls"] | null;
+export declare function textCodecBindingDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
 /** The WHATWG encoder pair, COMPOSED or through an erasable const binding:
    * `new TextDecoder().decode(bytes)`, `new TextEncoder().encode(s)`, and
    * the idiomatic store-then-call equivalents. The codec object never
@@ -594,19 +522,19 @@ export declare function textCodecBindingDecl(L: Lowerer, nameNode: ts.Node, init
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerTextCodecCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `String.fromCharCode(...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. Other String statics (fromCodePoint, raw) fall through
    * to the member fence. Null for non-String receivers. */
-export declare function lowerStringStaticCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `s.lastIndexOf(needle)` on string receivers — a libCall (scr_lib.c)
-   * rather than a strIntrinsic, but the same UTF-16 index semantics as
+export declare function lowerStringStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+/** `s.lastIndexOf(needle)` on string receivers — a libCall rather than a
+   * strIntrinsic, but the same UTF-16 index semantics as
    * indexOf. The lib's fromIndex parameter has no lowering (Node clamps
    * it with ToIntegerOrInfinity; nothing in the corpus wants it) and
    * fences per site. Null for non-string receivers / other members. */
-export declare function lowerStringLastIndexOfCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -617,25 +545,25 @@ export declare function lowerStringLastIndexOfCall(L: Lowerer, call: ts.CallExpr
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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(L: Lowerer, expr: ts.CallExpression): IrExpr | null;
+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
@@ -644,13 +572,13 @@ export declare function lowerProcessOptionalMethodCall(L: Lowerer, expr: ts.Call
    * 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(L: Lowerer, shapeId: string, loc: SrcLoc): string | null;
-export declare function isConsoleLog(L: Lowerer, call: ts.CallExpression): boolean;
+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(L: Lowerer, call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
+export declare function consoleCallMember(lowerer: Lowerer, call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
 export {};