@scriptc/compiler 0.4.5 → 0.4.6

package/dist/diagnostics/codes.js

@@ -0,0 +1,159 @@
+/* Every SC diagnostic code, in one table.
+ *
+ * A code is claimed by adding its row here, in numeric order, before any
+ * site uses it. Two changes that claim the same code then either edit the
+ * same line (a merge conflict) or add the same key twice (TypeScript error
+ * TS1117), and codes.test.ts fails when a source file uses a code that has
+ * no row, uses a retired code, or when a row is out of order. The band of a
+ * code (its first digit) says what kind of diagnostic it is; diagnostic.ts
+ * documents the bands.
+ *
+ * Codes are part of scriptc's user-facing output and never change meaning:
+ * when a construct ships, its code moves to RETIRED_DIAGNOSTIC_CODES instead
+ * of being reused. RESERVED_DIAGNOSTIC_CODES holds codes that open work
+ * already uses, so other changes do not take them. */
+/** The active codes, with a short summary of what each reports. */
+export const DIAGNOSTIC_CODES = {
+    SC0001: "TypeScript error passed through",
+    SC0002: "project configuration incompatible with scriptc",
+    SC0003: "malformed imported JSON module",
+    SC0004: "TypeScript checker panic",
+    SC1010: "package imports outside the supported set",
+    SC1012: "default exports/imports (residual edges)",
+    SC1013: "namespace imports (residual edges)",
+    SC1014: "re-exports and export lists",
+    SC1015: "dynamic import()",
+    SC1016: "circular imports",
+    SC1020: "class expressions",
+    SC1030: "var declarations (residual forms)",
+    SC1031: "destructuring",
+    SC1040: "loose equality (== and !=)",
+    SC1042: "logical operators on mixed operand types",
+    SC1043: "comparing non-number, non-string values",
+    SC1045: "increment/decrement in expression position",
+    SC1050: "labeled break/continue",
+    SC1052: "for-in loops",
+    SC1062: "destructuring catch clause bindings",
+    SC1063: "this use of a catch binding",
+    SC1070: "async/await",
+    SC1071: "generators",
+    SC1080: "'this' outside a class method",
+    SC1090: "this syntax (generic construct fence)",
+    SC1100: "operations on 'unknown' values",
+    SC1101: "converting typed values to 'unknown'",
+    SC1110: "comptime evaluation failure",
+    SC1120: "regex feature outside the native engine",
+    SC2001: "type outside the compilable set",
+    SC2002: "record shape flow outside the width-copy rules",
+    SC2003: "union-to-union conversion outside the re-tagging rule",
+    SC2004: "use of a binding whose declaration did not compile",
+    SC2005: "generic call signature in a value's type",
+    SC2006: "index-signature object type outside the supported shape",
+    SC2007: "overloaded function type as a value",
+    SC2008: "intersection type with no lowering",
+    SC2009: "component type outside its container or function slot",
+    SC2010: "runtime JavaScript execution",
+    SC2011: "'any'-typed values and their operations",
+    SC2012: "standard-library form without native lowering",
+    SC2013: "npm package import or value without native lowering",
+    SC2020: "standard-library or @types/node surface with no lowering",
+    SC3001: "LLVM IR tier refusal",
+    SC3002: "target or capability refusal",
+    SC3003: "native helper installation or version failure",
+    SC3004: "native helper code-generation failure",
+    SC4001: "library profile malformed",
+    SC4002: "library export unresolved",
+    SC4003: "library export signature not mappable",
+    SC4004: "async or generator library export",
+    SC4005: "library graph reaches the event loop or ambient process state",
+    SC4007: "generic library export signature",
+    SC4008: "profile-fenced surface reached by a library",
+    SC4009: "contract sidecar projection failure",
+    SC4010: "tabled type declared at several sites",
+    SC4011: "conditional or mapped type producing a tabled type",
+    SC4012: "library inbound-bytes trap (runtime)",
+    SC4013: "library escaped exception trap (runtime)",
+    SC4014: "library range trap (runtime)",
+    SC4015: "library type trap (runtime)",
+    SC4016: "library syntax trap (runtime)",
+    SC4017: "library out-of-memory trap (runtime)",
+    SC4018: "library internal invariant trap (runtime)",
+    SC4019: "library other detected trap (runtime)",
+    SC4020: "npm package imported by a library is not statically eligible",
+    SC4021: "integer boundary: literal not representable",
+    SC4022: "integer boundary: value may not be whole",
+    SC4023: "integer boundary: value out of range",
+    SC4024: "host callback reference the profile cannot serve",
+    SC4025: "host callback invoked before registration (runtime)",
+    SC4026: "library re-entered from a host callback (runtime)",
+    SC5001: "FFI manifest malformed",
+    SC5002: "FFI binding is not an ambient function declaration",
+    SC5003: "FFI signature does not match its native ABI",
+    SC5004: "FFI native build failure",
+    SC6001: "divergence: width copy written or compared through",
+    SC6002: "divergence: observed object key order",
+    SC6003: "divergence: localeCompare outside the built-in collation",
+    SC6004: "divergence: cast to an unrelated class",
+    SC6101: "performance: likely-hot function with untyped values",
+    SC6102: "performance: declaration-typed boundary note",
+    SC6103: "performance: shape inference overlay report",
+    SC6104: "localized failure: slot held as a checked-dynamic value",
+    SC7001: "NoThrow contract on an async function or generator",
+    SC7002: "Int32 contract value not provably int32",
+    SC7003: "Int32 contract cannot be checked",
+    SC7004: "Immutable contract value may be referenced elsewhere",
+    SC7005: "Immutable contract cannot be checked",
+    SC7006: "Acyclic contract in an unchecked position",
+    SC7007: "Acyclic type can lie on a reference cycle",
+    SC7008: "ProgramLifetime class extends another class",
+    SC7009: "InlineArray field contract not kept",
+    SC8001: "package or module runs in a Node island (note)",
+    SC8002: "Node islands off for a package or module outside the native subset",
+    SC8003: "package marked native is outside the native subset",
+    SC8004: "unknown scriptc.packages or scriptc.nodeIslands configuration",
+    SC8005: "no usable libnode pack for a program that calls into Node.js",
+    SC8006: "Node island modules the build cannot collect",
+    SC8010: "value crossing a Node island boundary in a form without an exact copy",
+    SC8011: "native class extending a Node island class outside the supported forms",
+    SC8020: "stateful module duplicated across the Node island boundary",
+    SC8021: "Node island evaluation notes (deferred or at startup)",
+    SC8022: "island code extends a class of a compiled module",
+    SC8023: "Node island build failed; built natively with runtime fences",
+    SC8030: "type patch: no range covers the installed copy",
+    SC8031: "type patch: selector matches nothing",
+    SC8032: "type patch: declaration already has the type",
+    SC8033: "type patch: selector ambiguous or not patchable",
+    SC8101: "user JavaScript: constructor function",
+    SC8102: "user JavaScript: prototype mutation",
+    SC8103: "user JavaScript: shape mutation outside the checker's view",
+    SC8104: "user JavaScript: sloppy-mode semantics",
+    SC8105: "user JavaScript: builtin and global patching",
+    SC9001: "internal compiler error",
+    SC9002: "internal error trap in generated code",
+};
+/** Codes whose construct shipped or whose diagnostic was removed. Never
+ * reuse one: old output and documentation still name it. */
+export const RETIRED_DIAGNOSTIC_CODES = {
+    SC1011: "exports (shipped)",
+    SC1021: "arrow functions and closures (shipped)",
+    SC1022: "nested function declarations (shipped)",
+    SC1023: "object literals (shipped as records)",
+    SC1024: "arrays (shipped)",
+    SC1032: "multiple declarations in one statement (shipped)",
+    SC1033: "let without an initializer (shipped)",
+    SC1041: "bitwise operators (shipped)",
+    SC1051: "do-while loops (shipped)",
+    SC1060: "switch statements (shipped)",
+    SC1061: "exceptions (shipped)",
+    SC1121: "stateful g/y regex tests (shipped)",
+    SC2030: "npm embedding failure",
+    SC4006: "library export refusal (removed)",
+    SC6005: "Date strings outside the native parser's grammar",
+};
+/** Codes that open work already uses, so no other change claims them. When
+ * that work lands it moves its codes into DIAGNOSTIC_CODES; when it is
+ * abandoned, delete them here. */
+export const RESERVED_DIAGNOSTIC_CODES = {
+    SC8012: "Node islands (ni/* branches)",
+};
+//# sourceMappingURL=codes.js.map

package/dist/diagnostics/codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.js","sourceRoot":"","sources":["../../src/diagnostics/codes.ts"],"names":[],"mappings":"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"}

package/dist/diagnostics/codes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/diagnostics/codes.test.js

@@ -0,0 +1,78 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { DIAGNOSTIC_CODES, RESERVED_DIAGNOSTIC_CODES, RETIRED_DIAGNOSTIC_CODES } from "./codes.js";
+import { FENCE_CODES, UNSUPPORTED } from "./diagnostic.js";
+const here = import.meta.dirname;
+const packagesDir = join(here, "../../..");
+const codesSource = readFileSync(join(here, "codes.ts"), "utf8");
+function sourceFiles(dir) {
+    return readdirSync(dir, { recursive: true, withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".ts") && !e.name.endsWith(".test.ts"))
+        .map((e) => join(e.parentPath, e.name));
+}
+// Every non-test source file that can name a code.
+const sources = [
+    ...sourceFiles(join(packagesDir, "compiler/src")),
+    ...sourceFiles(join(packagesDir, "cli/src")),
+]
+    .filter((file) => file !== join(here, "codes.ts"))
+    .map((file) => ({ file: file.slice(packagesDir.length), text: readFileSync(file, "utf8") }));
+const active = new Set(Object.keys(DIAGNOSTIC_CODES));
+const retired = new Set(Object.keys(RETIRED_DIAGNOSTIC_CODES));
+const reserved = new Set(Object.keys(RESERVED_DIAGNOSTIC_CODES));
+/** The keys of one table in codes.ts, as written (duplicates included). */
+function writtenKeys(table) {
+    const start = codesSource.indexOf(`export const ${table} = {`);
+    const end = codesSource.indexOf("\n}", start);
+    return [...codesSource.slice(start, end).matchAll(/^ {2}(SC\d{4}):/gm)].map((m) => m[1]);
+}
+test.each(["DIAGNOSTIC_CODES", "RETIRED_DIAGNOSTIC_CODES", "RESERVED_DIAGNOSTIC_CODES"])("%s is written once per code, in numeric order", (table) => {
+    const keys = writtenKeys(table);
+    expect(keys.length).toBeGreaterThan(0);
+    expect(keys).toEqual([...new Set(keys)].toSorted());
+});
+test("a code is active, retired or reserved, never two of them", () => {
+    for (const code of retired)
+        expect(active.has(code) || reserved.has(code), code).toBe(false);
+    for (const code of reserved)
+        expect(active.has(code), code).toBe(false);
+});
+test("every code the sources name has a row in codes.ts", () => {
+    const missing = [];
+    for (const { file, text } of sources) {
+        for (const [code] of text.matchAll(/\bSC\d{4}\b/g)) {
+            if (!active.has(code) && !retired.has(code) && !reserved.has(code)) {
+                missing.push(`${code} (${file})`);
+            }
+        }
+    }
+    expect(missing, "claim each code in packages/compiler/src/diagnostics/codes.ts").toEqual([]);
+});
+test("no source produces a retired code", () => {
+    const produced = [];
+    for (const { file, text } of sources) {
+        for (const [, code] of text.matchAll(/["'`](SC\d{4})["'`]/g)) {
+            if (retired.has(code))
+                produced.push(`${code} (${file})`);
+        }
+    }
+    expect(produced).toEqual([]);
+});
+test("every active code is used by some source", () => {
+    const seen = new Set(sources.flatMap(({ text }) => text.match(/\bSC\d{4}\b/g) ?? []));
+    const unused = [...active].filter((code) => !seen.has(code));
+    expect(unused, "retire codes nothing produces any more").toEqual([]);
+});
+test("the construct tables only name active codes", () => {
+    for (const code of [...Object.keys(UNSUPPORTED), ...Object.keys(FENCE_CODES)]) {
+        expect(active.has(code), code).toBe(true);
+    }
+});
+test("every band in use is documented in diagnostic.ts", () => {
+    const header = readFileSync(join(here, "diagnostic.ts"), "utf8");
+    for (const band of new Set([...active].map((code) => code[2]))) {
+        expect(header, `SC${band}xxx`).toContain(`SC${band}xxx`);
+    }
+});
+//# sourceMappingURL=codes.test.js.map

package/dist/diagnostics/codes.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.test.js","sourceRoot":"","sources":["../../src/diagnostics/codes.test.ts"],"names":[],"mappings":"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"}

package/dist/diagnostics/diagnostic.d.ts

@@ -1,7 +1,8 @@
 import type { SrcLoc } from "../ir/ir.js";
+import type { DiagnosticCode } from "./codes.js";
 export type Milestone = "M1" | "M2" | "M3" | "M4" | "M5" | "later";
 export interface ScrDiagnostic {
-    code: `SC${number}`;
+    code: DiagnosticCode;
     message: string;
     loc: SrcLoc;
     milestone?: Milestone;
@@ -23,15 +24,60 @@ export interface ScrDiagnostic {
      * alone does not say it (a computed require(), a native addon, `with`).
      * Report-only: never part of the rendered message. */
     reason?: string;
+    /** Runtime fences only: the fenced site is in a module's top-level code
+     * (outside every function body), so it runs, and throws, when the module
+     * evaluates. Island selection treats such a fence like one that needs the
+     * runtime (scope-B NI-4). */
+    moduleInit?: true;
     /** A runtime fence in a module's top-level code, outside every function
      * and class member body: it throws when the module initializes, which is
      * program startup for a module the entry imports. */
     startup?: true;
+    /** Localized failure, report-only (stage L0): set where a type with no
+     * static lowering poisoned a slot (Lowerer.badType and the dyn class
+     * field policy). Never part of the rendered message. */
+    typeFailure?: TypeFailure;
+    /** Localized failure, report-only: the declaration this diagnostic
+     * rejected, as a failure-group key. Set when a reference flushes a
+     * deferred declaration's diagnostics, and on the diagnostics of a
+     * declaration statement whose bindings were blocked. */
+    rejects?: string;
+    /** Localized failure, report-only: the failure groups (rejected
+     * declarations, blocked statements) that the statement committing this
+     * diagnostic used. A cascade clears when every one of them would
+     * degrade instead of failing. */
+    cause?: readonly string[];
+}
+/** Where a type failure sits (localized-failure design §3.6): a
+ * declaration slot, a member of a declared type, or an expression's own
+ * type. */
+export type TypeFailureSlot = "field" | "param" | "return" | "local" | "global" | "loop" | "member" | "expression";
+/** Which badType branch (or policy fence) refused the type. */
+export type TypeFailureFamily = "node-types" | "fetch-ambient" | "enum-object" | "stdlib-index" | "index-signature" | "package" | "generic-signature" | "overloads" | "intersection" | "component" | "stdlib-nominal" | "record-member" | "unsupported" | "dyn-field-policy";
+/** A type failure's structured payload: what the commit points of the
+ * localized-failure design inspect (PoisonError.failure carries the same
+ * object). `degradable` is the §3.7 classification: a checked-dynamic slot
+ * would keep the program's meaning. */
+export interface TypeFailure {
+    slot: TypeFailureSlot;
+    /** The slot's name (`_customTools`, `listAll`, `x`), or the expression
+     * text for expression slots. */
+    name: string;
+    declaredType: string;
+    family: TypeFailureFamily;
+    degradable: boolean;
 }
 /** SC3002–SC3004 — native-helper target, installation, and execution
  * failures. These are ordinary build diagnostics: a missing optional package
  * or malformed LLVM input must never surface as an internal compiler error. */
 export declare function nativeCodegenDiag(code: "SC3002" | "SC3003" | "SC3004", message: string, file: string, hint?: string): ScrDiagnostic;
+/** SC8005 — the program calls into Node.js (@scriptc/node), and the build
+ * found no usable libnode pack to record into the binary. */
+export declare function nodeIslandNodeDiag(message: string, file: string): ScrDiagnostic;
+/** SC8006 — a Node island call whose modules the build cannot collect into
+ * the executable: a computed specifier, or a module of the program that
+ * loads others through computed specifiers. */
+export declare function nodeIslandModuleDiag(message: string, loc: SrcLoc): ScrDiagnostic;
 /** SC6001 — a value passed to (or declared as) a narrower record type is
  * copied field by field, and the program then writes through or compares
  * the copy: under Node it is the same object, so the write would be
@@ -53,12 +99,44 @@ export declare function unrelatedClassCastDivergenceDiag(source: string, target:
 /** SC8004 — an unknown key or value in `scriptc.packages` or
  * `scriptc.nodeIslands`. */
 export declare function projectConfigDiag(path: string, detail: string, hint: string, loc: SrcLoc): ScrDiagnostic;
+/** SC8011 — a native class extends a class owned by a Node island. Native
+ * subclasses of island classes are scope-B milestone NI-5b. */
+export declare function nativeSubclassOfIslandDiag(loc: SrcLoc, detail?: string): ScrDiagnostic;
+/** SC8020 — a stateful module the program compiles is duplicated across
+ * the Node island boundary (an explicit "duplicate", or a form NI-6 cannot
+ * share yet): each side has its own state. */
+export declare function sharedModuleDuplicatedDiag(module: string, why: string, loc: SrcLoc): ScrDiagnostic;
+/** SC8022 — island code extends a class of a module the program compiles.
+ * A native instance cannot take an island subclass's overrides, so the
+ * module is not owned by the program: a package runs in Node for both
+ * sides (the build retries with it as a Node island); a program module is
+ * refused. */
+export declare function sharedClassExtendedDiag(pkg: string | null, file: string, base: string, loc: SrcLoc): ScrDiagnostic;
 /** SC8002 — Node islands are off (or limited to marked islands) and an
  * npm package is outside the native subset. */
 export declare function nodeIslandsOffDiag(pkg: string, why: string, loc: SrcLoc): ScrDiagnostic;
 /** SC8002 — a user module is marked to run in a Node island while
  * Node islands are off. */
 export declare function nodeIslandsOffModuleDiag(file: string, source: "config" | "cli", loc: SrcLoc): ScrDiagnostic;
+/** SC8001 — a package runs in a Node island (a note, once per island in
+ * the build output). */
+export declare function nodeIslandNoteDiag(pkg: string, version: string | null, klass: string, reason: string, loc: SrcLoc): ScrDiagnostic;
+/** SC8010 — a value crosses an island boundary in a way NI-4 cannot keep
+ * exact yet (callbacks, native objects, remote promises). */
+export declare function nodeIslandBoundaryDiag(what: string, loc: SrcLoc): ScrDiagnostic;
+/** SC8023 — the build that ran fenced packages as Node islands failed, so
+ * the program was built natively with those runtime fences (each throws
+ * when reached). A warning on the native build, with the island build's
+ * first error. */
+export declare function nodeIslandRetryFailedDiag(packages: readonly string[], first: ScrDiagnostic, loc: SrcLoc): ScrDiagnostic;
+/** SC8030–SC8033 — a type patch (`scriptc.typePatches`) that did not
+ * apply as written: no range covers the installed copy (SC8030), its
+ * selector matches nothing (SC8031), the declaration already has the type
+ * (SC8032), or the selector is ambiguous or not patchable (SC8033).
+ * Warnings: the build goes on with the declarations it has. */
+export declare function typePatchDiag(code: "SC8030" | "SC8031" | "SC8032" | "SC8033", message: string, hint: string, loc: SrcLoc): ScrDiagnostic;
+/** True for the type patch warnings (SC8030–SC8033). */
+export declare function isTypePatchCode(code: string): boolean;
 /** SC8003 — a package marked "native" is outside the native subset. */
 export declare function nativePackageDiag(pkg: string, why: string, loc: SrcLoc): ScrDiagnostic;
 /** SC8101–SC8105 — an R2 object-model construct in the program's own
@@ -96,7 +174,7 @@ export declare const FENCE_CODES: Record<string, {
     name: string;
     status: "unsupported";
 }>;
-export declare function unsupportedDiag(code: keyof typeof UNSUPPORTED & `SC${number}`, loc: SrcLoc, featureOverride?: string, hintOverride?: string): ScrDiagnostic;
+export declare function unsupportedDiag(code: keyof typeof UNSUPPORTED & DiagnosticCode, loc: SrcLoc, featureOverride?: string, hintOverride?: string): ScrDiagnostic;
 export declare function tscPassthroughDiag(message: string, loc: SrcLoc): ScrDiagnostic;
 /** Node's package scope forces CommonJS, but the source contains a marker
  * that is legal only when the file is parsed as ESM (static import/export,
@@ -182,6 +260,13 @@ export declare function componentTypeDiag(typeText: string, detail: string, loc:
  * ambient "Cannot find name" — and never ICEs. `surface` names what was
  * used ('Symbol', 'Math.sumPrecise', 'new Date', 'string.normalize'). */
 export declare function noLoweringDiag(surface: string, loc: SrcLoc, hint?: string, viaNodeTypes?: boolean): ScrDiagnostic;
+/** A stdlib-global snapshot reached a site that needs its VALUE (an
+ * argument, a return, a stored field). The declaration emitted no storage
+ * — alias plumbing only serves member and call reads — and the global's
+ * own value has no lowering, so the read cannot resolve. Reported at the
+ * declaration, where the real cause sits; the use site carries the SC2004
+ * cascade. */
+export declare function stdlibSnapshotValueUseDiag(name: string, alias: string, typeText: string | undefined, loc: SrcLoc): ScrDiagnostic;
 /** A REACHED use of a part of the WebAssembly API scriptc does not
  * implement yet (SC2020): the streaming functions, Tag and Exception, the
  * classes as values. compile, instantiate, validate, the Module, Instance,
@@ -193,6 +278,12 @@ export declare function webAssemblyDiag(surface: string, loc: SrcLoc): ScrDiagno
 /** A resolved native addon needs Node's embedding ABI. The migration uses the
  * underlying native operation through an ordinary C ABI declaration. */
 export declare function nativeAddonDiag(specifier: string, loc: SrcLoc): ScrDiagnostic;
+/** A createRequire require or require.resolve call whose specifier is
+ * computed at run time, where the runtime resolves it like Node
+ * (scr_require.c). Coverage lists the call as deferred: a require whose
+ * specifier resolves to a module ends the program with this code, because
+ * the module graph is fixed at build time. */
+export declare function computedRequireDiag(surface: string, loc: SrcLoc): ScrDiagnostic;
 /** Records are monomorphic structs, so a value's shape must match the
  * expected shape exactly OR narrow through the width-copy family
  * (recordWidthPlan / the overflow capture: target fields copied off the
@@ -208,6 +299,14 @@ export declare function recordShapeMismatchDiag(expectedText: string, actualText
  * with no identical destination arm, where the value could not be
  * represented in the target union at all. */
 export declare function unionMismatchDiag(expectedText: string, actualText: string, loc: SrcLoc): ScrDiagnostic;
+/** An object literal that SPREADS union-typed sources (`{ ...base,
+ * ...override }` where each source is `A | B | C`) builds one field set per
+ * combination of source arms. A union of records cannot hold that: each arm
+ * carries its own field table, so naming one arm would drop the fields the
+ * other arms contributed (Node keeps every field). The refusal names the
+ * candidate arms, because the honest repair is an explicit annotation per
+ * source (or one open record type), never a guessed arm. */
+export declare function unionLiteralMismatchDiag(expectedText: string, arms: readonly string[], loc: SrcLoc): ScrDiagnostic;
 /** A use of a binding whose DECLARATION did not compile: the declaration
  * site already carries the real diagnostic (a fenced type, a blocked
  * signature, an unsupported binding form), and every later reference falls

package/dist/diagnostics/diagnostic.js

@@ -13,6 +13,27 @@ export function nativeCodegenDiag(code, message, file, hint) {
         ...(shown !== undefined ? { hint: shown } : {}),
     };
 }
+/** SC8005 — the program calls into Node.js (@scriptc/node), and the build
+ * found no usable libnode pack to record into the binary. */
+export function nodeIslandNodeDiag(message, file) {
+    return {
+        code: "SC8005",
+        message,
+        loc: { file, start: 0, end: 0 },
+        hint: "point SCRIPTC_LIBNODE or --libnode at a libnode pack (packages/libnode-common/build-pack.mjs assembles one) for Node.js >=24.13.1",
+    };
+}
+/** SC8006 — a Node island call whose modules the build cannot collect into
+ * the executable: a computed specifier, or a module of the program that
+ * loads others through computed specifiers. */
+export function nodeIslandModuleDiag(message, loc) {
+    return {
+        code: "SC8006",
+        message,
+        loc,
+        hint: "name the module with a string literal (a relative path or a package name); the build ships the modules it can see with the executable",
+    };
+}
 /* ── SC6xxx: divergences from Node (warnings) ─────────────────────────── */
 /** SC6001 — a value passed to (or declared as) a narrower record type is
  * copied field by field, and the program then writes through or compares
@@ -86,6 +107,44 @@ export function projectConfigDiag(path, detail, hint, loc) {
         hint,
     };
 }
+/** SC8011 — a native class extends a class owned by a Node island. Native
+ * subclasses of island classes are scope-B milestone NI-5b. */
+export function nativeSubclassOfIslandDiag(loc, detail) {
+    return {
+        code: "SC8011",
+        message: detail === undefined
+            ? "a native class cannot extend a class owned by a Node island yet (native subclasses of island classes)"
+            : `a native class extending a class owned by a Node island cannot have ${detail} yet`,
+        loc,
+        hint: "keep the subclass in Node: move it into the island module, or mark its module as a Node island; a registry shim of the package also lifts this",
+    };
+}
+/** SC8020 — a stateful module the program compiles is duplicated across
+ * the Node island boundary (an explicit "duplicate", or a form NI-6 cannot
+ * share yet): each side has its own state. */
+export function sharedModuleDuplicatedDiag(module, why, loc) {
+    return {
+        code: "SC8020",
+        message: `module '${module}' is duplicated across the Node island boundary although it is stateful: ${why}; the program and its islands each see their own copy`,
+        loc,
+        hint: 'remove "share": "duplicate" from its scriptc.packages entry to share one instance',
+    };
+}
+/** SC8022 — island code extends a class of a module the program compiles.
+ * A native instance cannot take an island subclass's overrides, so the
+ * module is not owned by the program: a package runs in Node for both
+ * sides (the build retries with it as a Node island); a program module is
+ * refused. */
+export function sharedClassExtendedDiag(pkg, file, base, loc) {
+    return {
+        code: "SC8022",
+        message: pkg !== null
+            ? `package '${pkg}' is shared with a Node island that extends its class '${base}': it runs in Node for both sides`
+            : `module '${file}' cannot be shared with a Node island that extends its class '${base}' (island subclasses of native classes)`,
+        loc,
+        hint: "move the subclass into the program, or mark the module as a Node island",
+    };
+}
 /** SC8002 — Node islands are off (or limited to marked islands) and an
  * npm package is outside the native subset. */
 export function nodeIslandsOffDiag(pkg, why, loc) {
@@ -106,6 +165,50 @@ export function nodeIslandsOffModuleDiag(file, source, loc) {
         hint: "allow Node islands (--node-islands=auto or explicit), or remove the marking",
     };
 }
+/** SC8001 — a package runs in a Node island (a note, once per island in
+ * the build output). */
+export function nodeIslandNoteDiag(pkg, version, klass, reason, loc) {
+    return {
+        code: "SC8001",
+        message: `package '${version === null ? pkg : `${pkg}@${version}`}' runs in a Node island: ${klass}: ${reason}`,
+        loc,
+        hint: "it runs in Node.js loaded into the program on first use; --node-islands=off makes this an error",
+    };
+}
+/** SC8010 — a value crosses an island boundary in a way NI-4 cannot keep
+ * exact yet (callbacks, native objects, remote promises). */
+export function nodeIslandBoundaryDiag(what, loc) {
+    return {
+        code: "SC8010",
+        message: `${what} cannot cross into or out of a Node island yet`,
+        loc,
+        hint: "pass primitives, strings, island objects or fresh object and array literals of those; callbacks, native objects and promises cross from NI-5 on",
+    };
+}
+/** SC8023 — the build that ran fenced packages as Node islands failed, so
+ * the program was built natively with those runtime fences (each throws
+ * when reached). A warning on the native build, with the island build's
+ * first error. */
+export function nodeIslandRetryFailedDiag(packages, first, loc) {
+    return {
+        code: "SC8023",
+        message: `running ${packages.map((p) => `'${p}'`).join(", ")} in Node islands failed to compile (${first.code} at ${first.loc.file}:${first.loc.start}: ${first.message}); built natively instead, where their runtime fences throw when reached`,
+        loc,
+        hint: "fix the island build's error, or mark the packages with --node-island=<pkg> to see every error",
+    };
+}
+/** SC8030–SC8033 — a type patch (`scriptc.typePatches`) that did not
+ * apply as written: no range covers the installed copy (SC8030), its
+ * selector matches nothing (SC8031), the declaration already has the type
+ * (SC8032), or the selector is ambiguous or not patchable (SC8033).
+ * Warnings: the build goes on with the declarations it has. */
+export function typePatchDiag(code, message, hint, loc) {
+    return { code, message, loc, hint };
+}
+/** True for the type patch warnings (SC8030–SC8033). */
+export function isTypePatchCode(code) {
+    return /^SC803[0-3]$/.test(code);
+}
 /** SC8003 — a package marked "native" is outside the native subset. */
 export function nativePackageDiag(pkg, why, loc) {
     return {
@@ -614,6 +717,26 @@ export function noLoweringDiag(surface, loc, hint, viaNodeTypes = false) {
                 : "the type checker sees the full standard library, but only the supported surface compiles (https://scriptc.dev/limitations)"),
     };
 }
+/** A stdlib-global snapshot reached a site that needs its VALUE (an
+ * argument, a return, a stored field). The declaration emitted no storage
+ * — alias plumbing only serves member and call reads — and the global's
+ * own value has no lowering, so the read cannot resolve. Reported at the
+ * declaration, where the real cause sits; the use site carries the SC2004
+ * cascade. */
+export function stdlibSnapshotValueUseDiag(name, alias, typeText, loc) {
+    // Name the requested type when it has a readable spelling; a structural
+    // dump of the global's own object type says less than the global itself.
+    const unholdable = typeText === undefined
+        ? "the global it names is not a value scriptc can hold"
+        : `a '${typeText}' is not a value scriptc can hold`;
+    return {
+        code: "SC2020",
+        message: `the stdlib-global snapshot '${name}' ('${alias}') cannot be used as a value: the declaration lowers to alias plumbing (no storage, no code), and ${unholdable}`,
+        loc,
+        milestone: "later",
+        hint: `read the members through the global directly ('${alias}.member') instead of passing '${name}' around as a value`,
+    };
+}
 /** A REACHED use of a part of the WebAssembly API scriptc does not
  * implement yet (SC2020): the streaming functions, Tag and Exception, the
  * classes as values. compile, instantiate, validate, the Module, Instance,
@@ -642,6 +765,20 @@ export function nativeAddonDiag(specifier, loc) {
         reason: "native-addon",
     };
 }
+/** A createRequire require or require.resolve call whose specifier is
+ * computed at run time, where the runtime resolves it like Node
+ * (scr_require.c). Coverage lists the call as deferred: a require whose
+ * specifier resolves to a module ends the program with this code, because
+ * the module graph is fixed at build time. */
+export function computedRequireDiag(surface, loc) {
+    return {
+        code: "SC2020",
+        message: `${surface} with a computed specifier resolves at run time; a require of a specifier that resolves to a module, such as a native addon, ends the program`,
+        loc,
+        milestone: "later",
+        hint: 'require("<static string literal>") compiles the module into the program; native addons need a replacement through native FFI (https://scriptc.dev/ffi#replacing-a-node-api-addon)',
+    };
+}
 /** Records are monomorphic structs, so a value's shape must match the
  * expected shape exactly OR narrow through the width-copy family
  * (recordWidthPlan / the overflow capture: target fields copied off the
@@ -675,6 +812,24 @@ export function unionMismatchDiag(expectedText, actualText, loc) {
         hint: "narrow the value to a SINGLE arm first (a discriminant check, or '!== undefined'/'!== null' for unit arms); a plain arm value widens into any union that contains it, and a whole union widens into any union whose arms include the source's",
     };
 }
+/** An object literal that SPREADS union-typed sources (`{ ...base,
+ * ...override }` where each source is `A | B | C`) builds one field set per
+ * combination of source arms. A union of records cannot hold that: each arm
+ * carries its own field table, so naming one arm would drop the fields the
+ * other arms contributed (Node keeps every field). The refusal names the
+ * candidate arms, because the honest repair is an explicit annotation per
+ * source (or one open record type), never a guessed arm. */
+export function unionLiteralMismatchDiag(expectedText, arms, loc) {
+    const named = arms.map((a) => `'${a}'`).join(", ");
+    return {
+        code: "SC2003",
+        message: `a spread merge over union-typed sources builds a value that can carry fields from several arms at once, so no single arm of '${expectedText}' can represent it` +
+            (arms.length > 0 ? ` (candidate arms: ${named})` : ""),
+        loc,
+        milestone: "later",
+        hint: "merge ONE arm per path (narrow every spread source to that same arm first — a discriminant switch or an assertion — so the spread builds a single record), or declare ONE open record type whose fields are all optional instead of a union of all-optional arms",
+    };
+}
 /** A use of a binding whose DECLARATION did not compile: the declaration
  * site already carries the real diagnostic (a fenced type, a blocked
  * signature, an unsupported binding form), and every later reference falls