@scriptc/compiler 0.0.20 → 0.0.22

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

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr } from "../../ir/nodes.js";
+import { IrExpr, IrType } from "../../ir/nodes.js";
 import { IslandFnEntry } from "./surfaces.js";
 /** True iff the checker's type for this node maps to jsval ('any') —
    * the island test in front of every engine-op lowering (receivers,
@@ -43,8 +43,16 @@ export declare function requireDynamicApi(L: Lowerer, feature: string, node: ts.
    * symbol's declaration must live in the ambient file, so a user function
    * named `parseFloat` never matches. */
 export declare function islandGlobalFnOf(L: Lowerer, ident: ts.Identifier): IslandFnEntry | null;
-/** USER-code `fetch(url)` / `fetch(url, init)` — the island-backed ambient
-   * global (provenance, not the name: a user's own `fetch` never matches).
+/** USER-code `fetch(url)` / `fetch(url, init)` — the ambient global
+   * (provenance, not the name: a user's own `fetch` never matches).
+   *
+   * The static tier owns URL requests directly: scr_fetch_static runs
+   * over the native net/http/tls stack, consumes a checked-dynamic
+   * RequestInit object, and returns a promise of an opaque native
+   * Response handle. AbortSignal and readable Web Streams are native
+   * checked-dynamic handles too, so cancellation and streaming bodies
+   * stay engine-free.
+   *
    * The engine's own fetch executes (the same one embedded npm code calls —
    * scr_fetch.c over the native net/tls stack): the url marshals in (strings; template
    * results), an init OBJECT LITERAL builds natively in the island through
@@ -55,9 +63,93 @@ export declare function islandGlobalFnOf(L: Lowerer, ident: ts.Identifier): Isla
    * fiber like any await and resumes with the Response HANDLE. Member
    * reads/calls on the handle are engine ops; typed extraction happens at
    * the user's narrowing sites through the validated-exit machinery.
-   * Without --dynamic every call site is its own SC2012. Null for
-   * anything that isn't THE ambient fetch, so lowerCall keeps trying. */
+   * Null for anything that isn't THE ambient fetch, so lowerCall keeps
+   * trying. */
 export declare function lowerFetchCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** Static Response.json(): consume the native Response's readable body
+ * stream and parse its UTF-8 payload into the ordinary checked-dynamic
+ * JSON tree. Syntax and stream failures reject at await like the web API. */
+export declare function lowerStaticResponseCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+type StaticResponseAccess = ts.PropertyAccessExpression | ts.ElementAccessExpression;
+/** Constructor-object operations are distinct from Response instance
+ * methods. The inventory marks the former unsupported in both tiers; fence
+ * them explicitly so the generic call fallback cannot report SC1090 for
+ * Response.json while the other statics report SC2020. */
+export declare function fenceUnsupportedFetchConstructorMember(L: Lowerer, access: StaticResponseAccess): IrExpr | null;
+/** The adopted undici Response declaration is wider than the native static
+ * handle. Keep the supported fallback slice on checked-dynamic dispatch, but
+ * fence every other declared member before the generic dyn keyed-read/call
+ * paths can turn a missing handle operation into a runtime TypeError. */
+export declare function fenceStaticResponseMember(L: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+/** Response Headers are native checked-dynamic handles. Keep their exact
+ * supported method slice aligned with the compatibility census so newly
+ * observed Node members cannot fall through to a runtime missing-method
+ * error in an engine-free build. */
+export declare function fenceStaticHeadersMember(L: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+/** Object binding syntax reads members without constructing property-access
+ * nodes, so the ordinary Response/Headers/ReadableStream chokepoints never
+ * see it. Attribute those reads to the same inventory rows before generic
+ * dyn/jsval destructuring either reports SC1031 or admits an unsupported
+ * member in the dynamic tier. */
+export declare function fenceFetchObjectBinding(L: Lowerer, pattern: ts.ObjectBindingPattern): void;
+/** Assignment-position object destructuring is the same member-read form as
+ * a binding pattern, but its source type lives on the right-hand expression
+ * instead of the target AST. */
+export declare function fenceFetchObjectAssignment(L: Lowerer, target: ts.ObjectLiteralExpression, source: ts.Expression): void;
+/** Iteration syntax invokes Headers[Symbol.iterator] without constructing
+ * an element-access node, so the member chokepoint above never sees it.
+ * Keep engine-free builds on the same SC2020 profile row for for-of,
+ * array spread, and array destructuring. The dynamic tier uses the
+ * engine's iterator protocol and is intentionally allowed. */
+export declare function fenceStaticHeadersIteration(L: Lowerer, node: ts.Node): void;
+/** Dynamic element-spelled Headers iteration. Symbol.iterator uses the
+ * engine's GetIterator operation. A finite union of keys()/values()/entries()
+ * dispatches through fixed-name engine calls after evaluating the receiver
+ * and key once, preserving the method receiver and JavaScript evaluation
+ * order without trying to represent the union of method values. */
+export declare function lowerDynamicHeadersIteratorCall(L: Lowerer, call: ts.CallExpression, access: ts.ElementAccessExpression): IrExpr | null;
+/** Bracket-spelled calls on a profiled fetch/Web-stream handle. A call such
+ * as `headers["get"](name)` is still a method reference in JavaScript: the
+ * receiver must remain bound. Lower it before the generic callee-as-value
+ * path (which correctly fences bare method extraction), evaluating receiver,
+ * key, and arguments once in source order. Finite string-literal unions
+ * dispatch through fixed-name calls after the key value is captured. */
+export declare function lowerFetchElementMethodCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** `[...headers]` in the dynamic tier: Array.from runs inside the engine
+ * over the real Headers iterator, then the resulting pair array exits
+ * through the checker's declared array type. For Headers this is the
+ * spread algorithm's exact iterable snapshot. */
+export declare function lowerDynamicHeadersSpread(L: Lowerer, node: ts.Expression, type: IrType & {
+    kind: "array";
+}): IrExpr | null;
+/** The fallback ambient declaration intentionally exposes only the native
+ * stream slice, but @types/node adopts the complete WHATWG ReadableStream
+ * interface. Fence that wider surface before its checked-dynamic handle can
+ * fall through to a runtime missing-method error. */
+export declare function fenceStaticReadableStreamMember(L: Lowerer, access: StaticResponseAccess, use: "read" | "call"): IrExpr | null;
+export declare function lowerStaticFetchCompanionCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** Controller chunks and error reasons are dyn-handle calls, but unlike a
+ * general checked-dynamic boundary the Web Streams contract preserves their
+ * object identity for the reader/source callbacks that observe them. */
+export declare function lowerStaticReadableStreamControllerCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** `ReadableStream.cancel(reason)` and default-reader `cancel(reason)` pass
+ * the same reason object to the underlying source's cancel callback. Keep a
+ * live typed-reference capsule instead of the general dyn boundary's copy. */
+export declare function lowerStaticReadableStreamCancelCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** AbortSignal retains listener object identity for duplicate detection and
+ * removeEventListener(). Functions already box by closure identity; mutable
+ * record/array/bytes listeners need the same live capsule used by stream
+ * chunks so repeated crossings still denote one EventListener object. */
+export declare function lowerStaticAbortSignalListenerCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
+/** `new ReadableStream(source?)`. Static builds box the source record into
+ * the checked-dynamic tree; dynamic builds construct the island's Web
+ * stream directly so the returned handle composes with dynamic fetch. */
+export declare function lowerStaticReadableStreamNew(L: Lowerer, expr: ts.NewExpression): IrExpr | null;
+/** A static default reader's read() exits the native checked-dynamic
+ * transport into the checker's concrete chunk type. An exact chunk type
+ * preserves ReadableStream.from(array)'s element identity; structural
+ * widening keeps the compiler's ordinary copy-based width semantics. */
+export declare function lowerStaticReadableStreamReaderCall(L: Lowerer, call: ts.CallExpression): IrExpr | null;
 /** Dynamic `import(spec)` — the island's module system at a USER site.
    * Under --dynamic the call lowers to island.importDyn(key): the engine
    * loads the module (embedded npm graph, a shipped local .js/.mjs the
@@ -78,8 +170,10 @@ export declare function lowerDynamicImportCall(L: Lowerer, call: ts.CallExpressi
    * the JSON-safe copy-marshal). The same jsOp the 'any'-contextual
    * literal path emits, callable from lowerings that KNOW the literal is
    * island-bound (fetch's init) even when the contextual type is a union
-   * the generic path declines. Identifier AND string-literal keys — engine
-   * property names have no identifier restriction ("content-type"). */
+   * the generic path declines. Spelled and pure const-folded computed keys
+   * are admitted; engine property names have no identifier restriction. Plain
+   * spreads copy through the engine's CopyDataProperties operation in
+   * source order, including nested RequestInit/header dictionaries. */
 export declare function lowerIslandObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
 /** Method calls on the island-backed ambient surface: `Math.<fn>(...)`
    * (the engine's own Math object executes) and the number/string methods
@@ -113,3 +207,4 @@ export declare function npmMemberFence(L: Lowerer, access: ts.PropertyAccessExpr
    * npmPackageOf, also asked directly for import-alias bindings (whose
    * aliased symbol is the package's export). */
 export declare function npmPackageOfSymbol(L: Lowerer, sym: ts.Symbol | undefined): string | null;
+export {};