@scriptc/compiler 0.0.21 → 0.0.22

package/dist/frontend/types.js

@@ -6,13 +6,28 @@ import { accessorSlotProp } from "../ir/nodes.js";
 // helper interning); re-exported here so frontend call sites keep their
 // import path.
 export { typeKey };
-/** The island-backed ambient TYPE names of the fetch slice: standard-
- * library interfaces whose VALUES live in the embedded engine (the
- * engine's fetch mints the Response; AbortSignal.timeout mints the
- * signal), so under --dynamic they map to island handles (jsval) exactly
- * like npm-declared types. Checked with declaration provenance in mapType;
- * consumed by the lowerer's badType for the static-build wording. */
-export const ISLAND_AMBIENT_TYPES = ["Response", "RequestInit", "AbortSignal", "Headers"];
+/** The ambient TYPE names of the fetch slice. Under --dynamic their
+ * values live in the embedded engine and map to island handles (jsval).
+ * Static fetch gives Response, RequestInit, AbortSignal, response
+ * Headers, and the readable Web Streams slice native checked-dynamic
+ * handle representations. The Headers constructor itself remains
+ * dynamic-only even though response.headers is native.
+ * Declaration provenance is checked in mapType so user types with the
+ * same names keep their ordinary structural representation. */
+export const ISLAND_AMBIENT_TYPES = [
+    "Response",
+    "RequestInit",
+    "Event",
+    "EventTarget",
+    "AbortSignal",
+    "Headers",
+    "ReadableStream",
+    "ReadableStreamDefaultReader",
+    "ReadableStreamDefaultController",
+    "ReadableStreamReadResult",
+    "ReadableStreamReadValueResult",
+    "ReadableStreamReadDoneResult",
+];
 /** The frontend's record-shape interner. Records are monomorphic structural
  * shapes: fields sorted by name form the canonical identity, and two types
  * with the same canonical field list share one shapeId (and later one C
@@ -729,17 +744,19 @@ function mapTypeInner(type, ctx) {
     // rule fires only when the type's own identity is declaration-file-
     // declared — interfaces, classes, type literals, and aliases from the
     // .d.ts. The standard library's declaration files are carved out (their
-    // surfaces have static lowerings), and the program's own compiled
-    // modules are never declaration files. Without --dynamic it stays
-    // unmapped; badType reports the per-package requires-dynamic diagnostic
-    // for node_modules types and the generic story otherwise.
+    // surfaces have static lowerings), as are declarations explicitly mapped
+    // by --external-types: those describe project-owned structural data while
+    // the Lowerer fences their imported runtime bindings. The program's own
+    // compiled modules are never declaration files. Without --dynamic this
+    // stays unmapped; badType reports the per-package requires-dynamic
+    // diagnostic for node_modules types and the generic story otherwise.
     const npmSym = widened.getAliasSymbol() ?? widened.getSymbol();
     const npmDecls = npmSym ? checker.declarationsOf(npmSym) : undefined;
     if (npmDecls &&
         npmDecls.length > 0 &&
         npmDecls.every((d) => {
             const sf = d.getSourceFile();
-            return sf.isDeclarationFile && !ctx.isStdlibFile(sf);
+            return sf.isDeclarationFile && !ctx.isStdlibFile(sf) && !ctx.isExternalTypeFile(sf);
         })) {
         return ctx.dynamic ? JSVAL : null;
     }
@@ -1188,23 +1205,57 @@ function mapTypeInner(type, ctx) {
     // read has its own lowering (errno/syscall/path stay per-member fences).
     if (isStdlibInterface("ErrnoException"))
         return { kind: "object", className: "%Error" };
-    // The fetch ambient slice (Response, RequestInit, AbortSignal): island-
-    // backed ambient TYPES — the values behind them live in the embedded
-    // engine (fetch's Response, AbortSignal.timeout's signal), so under
-    // --dynamic they map to island handles exactly like npm-declared types,
-    // and every operation on them rides the engine ops with validated exits
-    // at typed boundaries. Provenance, not names: a user's own `interface
-    // Response` maps as a record like any other. Without the flag they stay
-    // unmapped; the use sites report the per-site requires-dynamic story
-    // (the fetch/AbortSignal.timeout lowerings' SC2012, badType's naming
-    // for a bare value of the type).
+    // The fetch ambient slice: under --dynamic these are island handles
+    // exactly like npm-declared types. Static fetch has one deliberately
+    // narrower native representation: Response is an opaque checked-
+    // dynamic capsule consumed only by the Response method lowerings, and
+    // RequestInit is a checked-dynamic options object consumed by native
+    // fetch. AbortSignal, response Headers, and the readable Web Streams
+    // slice are native handles carried by that same checked-dynamic
+    // representation. Provenance, not names: a user's own `interface
+    // Response` maps as a record like any other.
     // Interface OR class declarations (the shipped fallback declares
     // interfaces; @types/node's undici-types declares Response as a class).
+    {
+        const alias = widened.getAliasSymbol();
+        if (!ctx.dynamic &&
+            alias?.name === "ReadableStreamReadResult" &&
+            checker.declarationsOf(alias).some((d) => ts.isTypeAliasDeclaration(d) &&
+                ctx.isStdlibFile(d.getSourceFile()))) {
+            const elemTs = widened.getAliasTypeArguments()?.[0];
+            const elem = elemTs && elemTs.flags & ts.TypeFlags.Any
+                ? DYN
+                : elemTs
+                    ? mapType(elemTs, ctx)
+                    : null;
+            if (!elem)
+                return null;
+            return genResultRecord(elem, VOID, ctx.shapes, ctx.unions);
+        }
+    }
+    if (!ctx.dynamic &&
+        psym &&
+        (psym.name === "ReadableStreamReadValueResult" ||
+            psym.name === "ReadableStreamReadDoneResult") &&
+        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()))) {
+        const elemTs = checker.getTypeArguments(widened)[0];
+        const elem = elemTs && elemTs.flags & ts.TypeFlags.Any
+            ? DYN
+            : elemTs
+                ? mapType(elemTs, ctx)
+                : null;
+        if (!elem)
+            return null;
+        return genResultRecord(elem, VOID, ctx.shapes, ctx.unions);
+    }
     if (psym &&
         ISLAND_AMBIENT_TYPES.includes(psym.name) &&
+        !(psym.name === "ReadableStream" &&
+            checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS"))) &&
         checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()))) {
-        return ctx.dynamic ? JSVAL : null;
+        return ctx.dynamic ? JSVAL : DYN;
     }
     // ReadonlyMap/ReadonlySet are the SAME runtime values as Map/Set — the
     // readonly-ness is a checker-only view (no mutating members on the
@@ -2576,15 +2627,17 @@ function isMappedShape(t) {
         (t.objectFlags & ts.ObjectFlags.Mapped) !== 0);
 }
 /** The record path's provenance fence. Declared shapes (object literals,
- * interfaces, type literals) must come from user code, never a .d.ts — the
- * empty ambient interfaces (Object, Function, Boolean, ...) exist only to
+ * interfaces, type literals) must come from user code or an explicitly
+ * mapped external type surface, never an arbitrary .d.ts — the empty
+ * ambient interfaces (Object, Function, Boolean, ...) exist only to
  * satisfy tsc and must not become zero-field records. Checker-COMPUTED
  * shapes (mapped-type results, intersections) have no user declaration to
  * point at: mapped types pass here and get per-MEMBER provenance in the
  * field walk instead; an intersection passes when every part is itself an
  * ordinary provenance-passing object type (class parts keep their nominal
  * identity and never flatten into a struct). */
-function recordProvenanceOk(t, checker) {
+function recordProvenanceOk(t, ctx) {
+    const { checker } = ctx;
     if (t.isIntersectionType()) {
         return t.getTypes().every((part) => {
             const partSym = part.getSymbol();
@@ -2592,7 +2645,7 @@ function recordProvenanceOk(t, checker) {
                 !(partSym && partSym.flags & ts.SymbolFlags.Class) &&
                 checker.getCallSignatures(part).length === 0 &&
                 checker.getConstructSignatures(part).length === 0 &&
-                recordProvenanceOk(part, checker);
+                recordProvenanceOk(part, ctx);
         });
     }
     if (isMappedShape(t))
@@ -2601,7 +2654,10 @@ function recordProvenanceOk(t, checker) {
     const decls = tSym ? checker.declarationsOf(tSym) : undefined;
     if (!decls || decls.length === 0)
         return false;
-    return !decls.some((d) => d.getSourceFile().isDeclarationFile);
+    return !decls.some((d) => {
+        const sf = d.getSourceFile();
+        return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+    });
 }
 /** A GENERIC-callable member type (`m<T>(x: T): T` / `f: <T>(x: T) => T` in
  * an object type): pure function-shaped — call signatures only, every one
@@ -2793,7 +2849,7 @@ function mapRecordTypeInner(widened, ctx) {
         !widened.isIntersectionType() &&
         indexValue === undefined &&
         checker.getPropertiesOfType(widened).length === 0;
-    if (!recordProvenanceOk(widened, checker) && !pureIndexShape && !anonymousEmpty)
+    if (!recordProvenanceOk(widened, ctx) && !pureIndexShape && !anonymousEmpty)
         return null;
     // Checker-computed shapes (no user declaration) need two extra fences in
     // the member walk below; see the comments there.
@@ -2895,7 +2951,11 @@ function mapRecordTypeInner(widened, ctx) {
             // lib interface (`Readonly<Date>`) is still the lib's type world, not
             // a data shape. Synthesized members (a literal-key Record's) have no
             // declarations and pass.
-            if (computed && checker.declarationsOf(p).some((d) => d.getSourceFile().isDeclarationFile)) {
+            if (computed &&
+                checker.declarationsOf(p).some((d) => {
+                    const sf = d.getSourceFile();
+                    return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+                })) {
                 return null;
             }
             const fieldTs = checker.getTypeOfSymbol(p);
@@ -3192,7 +3252,11 @@ export function describeRecordMemberBlocker(widened, ctx) {
         // Computed shapes over LIBRARY members (`Readonly<Date>`): the record
         // fence there is per-member PROVENANCE (mapRecordTypeInner's rule), not
         // any one member's type — that story stays with the residual fence.
-        if (computed && checker.declarationsOf(p).some((d) => d.getSourceFile().isDeclarationFile)) {
+        if (computed &&
+            checker.declarationsOf(p).some((d) => {
+                const sf = d.getSourceFile();
+                return sf.isDeclarationFile && !ctx.isExternalTypeFile(sf);
+            })) {
             return null;
         }
         const fieldTs = checker.getTypeOfSymbol(p);