@scriptc/compiler 0.4.7 → 0.4.8

package/dist/executable/prepare.js

@@ -1,6 +1,6 @@
-import { realpathSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import { frontendDisposed } from "../frontend/dispose-hook.js";
-import { checkerPanicDiag, nodeIslandEntryPatchDiag, nodeIslandModuleNoteDiag, nodeIslandNoteDiag, nodeIslandPatchedReadDiag, nodeIslandStripDiag, nodeIslandRetryFailedDiag, npmStaticRefusalDiag, iceDiag, isCheckerPanic, stdioPatchAcrossIslandsDiag, } from "../diagnostics/diagnostic.js";
+import { checkerPanicDiag, nodeIslandEntryPatchDiag, nodeIslandEntryReadDiag, nodeIslandImplicitGlobalReadDiag, nodeIslandModuleNoteDiag, nodeIslandNoteDiag, nodeIslandReaderStripDiag, nodeIslandStripDiag, nodeIslandRetryFailedDiag, npmStaticRefusalDiag, nativePackageDiag, iceDiag, isCheckerPanic, stdioPatchAcrossIslandsDiag, } from "../diagnostics/diagnostic.js";
 import { validateModule } from "../ir/validate.js";
 import { checkContracts } from "../contracts/check.js";
 import { fenceSpeculativeWasiFunctions, moduleWasiUnavailableSurface, targetRefusalDiag, } from "../backend/target-diagnostics.js";
@@ -11,7 +11,7 @@ import { classifyDiagnostic, classifyMarker, isIslandReasonCode, } from "../node
 import { packageDirOf, packageVersionOf } from "../node-islands/origin.js";
 import { describe } from "../node-islands/summary.js";
 import { resolveBareModule } from "../frontend/resolve.js";
-import { isEsmFile } from "../frontend/lowering/lower-node-island.js";
+import { growIslandSet } from "../node-islands/growth.js";
 import { isJsSourceFileName } from "../frontend/tsc-codes.js";
 /** Release the parser/checker before native object generation begins.
  * `unitStore` keeps the lowered units of this build for the next one
@@ -50,6 +50,18 @@ export function prepareExecutableModule(entryPath, opts, ffi, buildPlatform, cre
     let disposed = false;
     let fenceGrown = null;
     const fenceSure = new Set();
+    // The growth inputs this build's frontend offers (node-islands/growth.ts).
+    // Built once: the frontend does not change inside a build, and its scan is
+    // a whole-program walk.
+    let growthInputs = null;
+    let growthBuilt = false;
+    const growthOf = () => {
+        if (!growthBuilt) {
+            growthInputs = islandGrowth(entryPath, opts, fe);
+            growthBuilt = true;
+        }
+        return growthInputs;
+    };
     // The frontend (and its tsgo server) is released as soon as lowering
     // ends — clang and the link never hold it open.
     try {
@@ -66,7 +78,8 @@ export function prepareExecutableModule(entryPath, opts, ffi, buildPlatform, cre
             // An import of a natively compiled package that preflight refuses
             // in the importer (a CommonJS namespace import) is that package's
             // refusal: it runs in a Node island instead.
-            const grown = preflightIslands(entryPath, opts, fe, lowerIslands);
+            const growth = growthOf();
+            const grown = growth === null ? null : growIslandSet(growth, lowerIslands, { preflight: fe.preflight });
             if (grown !== null) {
                 fe.dispose();
                 frontendDisposed();
@@ -99,7 +112,10 @@ export function prepareExecutableModule(entryPath, opts, ffi, buildPlatform, cre
             // Packages whose own modules refused to lower run in Node islands
             // too (the authoritative lowering, DESIGN.md §1.4): build again with
             // them as islands.
-            const grown = loweringIslands(entryPath, opts, fe, lowered.diagnostics, lowerIslands, fe.nodeIslandScan?.({ userJs: false }).edges);
+            const growth = growthOf();
+            const grown = growth === null
+                ? null
+                : growIslandSet(growth, lowerIslands, { diagnostics: lowered.diagnostics });
             // Sloppy user modules the lowering refused join the same retry
             // (DESIGN.md note 1 §3.2): one reload with every island at once,
             // never one round per module.
@@ -117,8 +133,12 @@ export function prepareExecutableModule(entryPath, opts, ffi, buildPlatform, cre
             // declare (interfaces, aliases such as `Static<T>`) are `any`, so its
             // diagnostics describe a program the island build does not compile:
             // there the packages' declarations type the user code.
-            const marked = retryFences
-                ? fenceIslands(entryPath, opts, fe, lowered, lowerIslands, false)
+            const marked = retryFences && growth !== null
+                ? growIslandSet(growth, lowerIslands, {
+                    diagnostics: lowered.diagnostics,
+                    fences: lowered.runtimeFences,
+                    fenceMode: "report",
+                })
                 : null;
             if (marked !== null) {
                 fe.dispose();
@@ -164,8 +184,18 @@ export function prepareExecutableModule(entryPath, opts, ffi, buildPlatform, cre
                 lowered.module.contracts = checked.contracts;
             contractWarnings = checked.warnings;
         }
-        if (retryFences)
-            fenceGrown = fenceIslands(entryPath, opts, fe, lowered, lowerIslands, true, fenceSure);
+        if (retryFences) {
+            const growth = growthOf();
+            fenceGrown =
+                growth === null
+                    ? null
+                    : growIslandSet(growth, lowerIslands, {
+                        diagnostics: lowered.diagnostics,
+                        fences: lowered.runtimeFences,
+                        fenceMode: "sure",
+                        sure: fenceSure,
+                    });
+        }
     }
     finally {
         if (!disposed) {
@@ -316,6 +346,32 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
     const scan = fe.nodeIslandScan({ userJs: policy.mode === "auto" });
     const moduleDecision = moduleIslands(entryPath, policy, scan);
     const modules = moduleDecision.modules;
+    // A sloppy write to an undeclared name creates a global — a sloppy-only
+    // semantic the native tier does not implement, so the module runs in
+    // Node (the user's policy, 2026-10-31). The checker decides this one, not
+    // the syntax pre-scan: a write target needs bindings, and its sloppiness
+    // depends on the enclosing function and file strictness. Preflight
+    // reports it as SC1091 carrying the R2.4 reason. The entry stays native
+    // (a whole-file island is a different feature), and a strict-mode write
+    // is an ordinary lowering gap, so neither joins here.
+    if (policy.mode === "auto") {
+        for (const d of fe.preflight) {
+            if (d.code !== "SC1091" || d.reason !== "implicit-global-write")
+                continue;
+            const file = d.loc.file;
+            if (modules.has(file) || sameFile(file, entryPath))
+                continue;
+            if (!isJsSourceFileName(file) || file.includes("/node_modules/"))
+                continue;
+            const reason = classifyDiagnostic(d, "refusal");
+            modules.set(file, {
+                file,
+                class: reason.class,
+                reason: describe(reason),
+                decision: "auto",
+            });
+        }
+    }
     // Modules the lowering refused keep their first reason (the reload no
     // longer compiles them).
     for (const [file, island] of lowerModules)
@@ -328,10 +384,12 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
     }
     for (const problem of moduleDecision.stripProblems)
         errors.push(nodeIslandStripDiag(problem.file, problem.construct, problem.loc));
-    // Who else must see the patch (H3.4): every non-islanded module that
-    // reads a patched member through the builtin's CommonJS object. An npm
-    // package joins the island set (a patch meant for it must reach it); a
-    // user module is SC8020, because native code cannot see the patch.
+    // Who else must see the patch (H3.4): every module that reads a patched
+    // member through the builtin's CommonJS object joins the island set, npm
+    // package or user module alike — the patch lives in the islands' Node, and
+    // only sharing the builtin shows the read the patch, as in Node. The entry
+    // stays native, and a user TypeScript module Node cannot strip cannot run
+    // in Node at all: both are SC8006.
     const patchedMembers = new Map();
     for (const m of scan.modules) {
         if (!modules.has(m.file))
@@ -344,6 +402,10 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
         }
     }
     const readerPackages = new Map();
+    // A package the build marks native stays native: a read that only an
+    // island could satisfy is SC8003, once per package and construct.
+    const forcedNativeReads = new Set();
+    const readerModules = new Map();
     if (policy.mode === "auto" && patchedMembers.size > 0) {
         for (const m of scan.modules) {
             if (modules.has(m.file))
@@ -353,6 +415,14 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
                 if (patchFile === undefined)
                     continue;
                 if (m.origin === "npm" && m.packageName !== null && m.packageDir !== null) {
+                    if (policy.forcedNative.has(m.packageName)) {
+                        const key = `${m.packageName}:${read.member}`;
+                        if (!forcedNativeReads.has(key)) {
+                            forcedNativeReads.add(key);
+                            errors.push(nativePackageDiag(m.packageName, `it reads '${read.member}' through the CommonJS ${builtinModuleOf(read.member)} object, which island module ${patchFile} patches; a native read cannot see the patch`, fe.npmImportSites.get(m.packageName) ?? read.loc));
+                        }
+                        continue;
+                    }
                     if (!readerPackages.has(m.packageName) && !refused.has(m.packageName))
                         readerPackages.set(m.packageName, {
                             packageDir: m.packageDir,
@@ -361,17 +431,74 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
                         });
                 }
                 else if (m.origin === "user") {
-                    errors.push(nodeIslandPatchedReadDiag(read.member, patchFile, read.loc));
+                    if (sameFile(m.file, entryPath)) {
+                        errors.push(nodeIslandEntryReadDiag(m.file, read.member, builtinModuleOf(read.member), patchFile, read.loc));
+                        continue;
+                    }
+                    if (m.stripProblem !== null) {
+                        errors.push(nodeIslandReaderStripDiag(m.file, read.member, patchFile, m.stripProblem.construct, m.stripProblem.loc));
+                        continue;
+                    }
+                    if (!readerModules.has(m.file))
+                        readerModules.set(m.file, { member: read.member, patchFile });
+                }
+            }
+        }
+    }
+    // Who else must see an implicit global (H3.4): a sloppy write creates the
+    // name on Node's global object when its island module runs, and native
+    // code has no global object to read it from. An npm package that reads
+    // the name joins the island set (its Node sees the global); a user module
+    // or the entry is SC8020.
+    const readerGlobals = new Map();
+    const createdGlobals = policy.mode === "auto" ? implicitGlobalWrites(fe, modules) : new Map();
+    if (createdGlobals.size > 0) {
+        for (const m of scan.modules) {
+            if (modules.has(m.file))
+                continue;
+            for (const read of m.globalReads) {
+                const writerFile = createdGlobals.get(read.name);
+                if (writerFile === undefined)
+                    continue;
+                if (m.origin === "npm" && m.packageName !== null && m.packageDir !== null) {
+                    if (policy.forcedNative.has(m.packageName)) {
+                        const key = `${m.packageName}:${read.name}`;
+                        if (!forcedNativeReads.has(key)) {
+                            forcedNativeReads.add(key);
+                            errors.push(nativePackageDiag(m.packageName, `it reads '${read.name}', which island module ${writerFile} creates as an implicit global; the native build has no global object, so the read cannot see it`, fe.npmImportSites.get(m.packageName) ?? read.loc));
+                        }
+                        continue;
+                    }
+                    if (!readerGlobals.has(m.packageName) && !refused.has(m.packageName))
+                        readerGlobals.set(m.packageName, {
+                            packageDir: m.packageDir,
+                            global: read.name,
+                            writerFile,
+                        });
+                }
+                else if (m.origin === "user") {
+                    errors.push(nodeIslandImplicitGlobalReadDiag(read.name, writerFile, read.loc));
                 }
             }
         }
     }
     if (errors.length > 0)
         return { packages: new Map(), modules: new Map(), notes: [], errors };
+    // A user module that reads a patched member runs in a Node island, so its
+    // read goes through the patched object exactly as in Node (H3.4).
+    for (const [file, reader] of readerModules) {
+        modules.set(file, {
+            file,
+            class: "object-model",
+            reason: `it reads '${reader.member}' through the CommonJS ${builtinModuleOf(reader.member)} object, which island module ${reader.patchFile} patches`,
+            decision: "auto",
+        });
+    }
     if (refused.size === 0 &&
         policy.forcedNode.size === 0 &&
         modules.size === 0 &&
-        readerPackages.size === 0)
+        readerPackages.size === 0 &&
+        readerGlobals.size === 0)
         return null;
     const report = buildNodeIslandReport({
         entry: entryPath,
@@ -450,6 +577,22 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
         });
         notes.push(nodeIslandNoteDiag(name, version, "object-model", reason, fe.npmImportSites.get(name) ?? { file: entryPath, start: 0, end: 0 }));
     }
+    // npm packages that read an implicit global an island module creates join
+    // the island set: the global lives on their Node's global object.
+    for (const [name, reader] of readerGlobals) {
+        if (packages.has(name))
+            continue;
+        const version = packageVersionOf(reader.packageDir);
+        const reason = `it reads '${reader.global}', the implicit global island module ${reader.writerFile} creates`;
+        packages.set(name, {
+            name,
+            version,
+            dir: reader.packageDir,
+            class: "object-model",
+            reason,
+        });
+        notes.push(nodeIslandNoteDiag(name, version, "object-model", reason, fe.npmImportSites.get(name) ?? { file: entryPath, start: 0, end: 0 }));
+    }
     for (const island of [...modules.values()].sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0))
         notes.push(nodeIslandModuleNoteDiag(island.file, island.class, island.reason, {
             file: island.file,
@@ -458,6 +601,29 @@ function decideNodeIslands(entryPath, opts, fe, lowerIslands, lowerModules) {
         }));
     return packages.size === 0 && modules.size === 0 ? null : { packages, modules, notes, errors };
 }
+/** The names the island modules' sloppy implicit-global writes create, each
+ * with the file that creates it. Preflight reports each write as an SC1091
+ * whose range is the write target. */
+function implicitGlobalWrites(fe, modules) {
+    const globals = new Map();
+    const sources = new Map();
+    for (const d of fe.preflight) {
+        if (d.code !== "SC1091" || d.reason !== "implicit-global-write")
+            continue;
+        const file = d.loc.file;
+        if (!modules.has(file))
+            continue;
+        let source = sources.get(file);
+        if (source === undefined) {
+            source = readFileSync(file, "utf8");
+            sources.set(file, source);
+        }
+        const name = source.slice(d.loc.start, d.loc.end);
+        if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) && !globals.has(name))
+            globals.set(name, file);
+    }
+    return globals;
+}
 /** The builtin module a patched member belongs to ("fs" of
  * "fs.readFileSync"). */
 function builtinModuleOf(member) {
@@ -484,84 +650,23 @@ function patchFileOf(patched, member) {
     }
     return undefined;
 }
-/** The island set grown by the npm packages whose own modules refused to
- * lower (`--node-islands=auto` only), or null when there are none. */
-function loweringIslands(entryPath, opts, fe, diagnostics, known, edges) {
-    const policy = nodeIslandPolicy(readProjectConfig(entryPath), opts.nodeIslands);
-    if (policy.mode !== "auto" || known.size > 16)
+/** The growth inputs this build's frontend offers the shared island-growth
+ * rules (node-islands/growth.ts), or null when the frontend holds no island
+ * scan: the rules then grow nothing. `npmStatic` keeps a `"auto"` request
+ * out: only an explicit list names the packages to keep native. */
+function islandGrowth(entryPath, opts, fe) {
+    const scan = fe.nodeIslandScan?.({ userJs: false });
+    if (scan === undefined)
         return null;
-    const compiled = new Set(fe.npmStatic.filter((e) => e.status === "static").map((e) => e.package));
-    const grown = new Map(known);
-    for (const d of diagnostics) {
-        // A use of a package outside the compiled module graph (an import()
-        // the frontend did not compile): that package runs in an island.
-        const named = d.code === "SC2013" ? /npm package '([^']+)'/.exec(d.message) : null;
-        if (named !== null) {
-            const name = named[1];
-            if (grown.has(name) || policy.forcedNative.has(name) || policy.unloaded.has(name))
-                continue;
-            const js = resolveBareModule(d.loc.file, name, "js-only") ??
-                resolveBareModule(d.loc.file, name, "js-only", "require");
-            const at = js === null ? null : packageDirOf(js.typesFile);
-            if (at === null || at.name !== name)
-                continue;
-            grown.set(name, {
-                name,
-                version: packageVersionOf(at.dir),
-                dir: at.dir,
-                class: "packaging",
-                reason: `${d.code}: ${d.message}`,
-            });
-            continue;
-        }
-        if (!isIslandReasonCode(d.code))
-            continue;
-        const at = packageDirOf(d.loc.file);
-        if (at === null || !compiled.has(at.name) || grown.has(at.name))
-            continue;
-        if (policy.forcedNative.has(at.name) || policy.unloaded.has(at.name))
-            continue;
-        const reason = classifyDiagnostic(d, "refusal");
-        grown.set(at.name, {
-            name: at.name,
-            version: packageVersionOf(at.dir),
-            dir: at.dir,
-            class: reason.class,
-            reason: describe(reason),
-        });
-    }
-    // A native ES module that imports an island CommonJS module would read
-    // its bindings from the module's exports object, where Node gives it the
-    // namespace its CommonJS facade builds (the lexed names, module.exports
-    // as the default): the importing package runs in the island too.
-    for (let added = edges !== undefined; added;) {
-        added = false;
-        for (const edge of edges) {
-            const name = edge.to;
-            if (!grown.has(name) || edge.fromDir === null || edge.shim)
-                continue;
-            const at = packageDirOf(edge.fromFile);
-            if (at === null || grown.has(at.name) || !compiled.has(at.name))
-                continue;
-            if (policy.forcedNative.has(at.name) || policy.unloaded.has(at.name))
-                continue;
-            if (!isEsmFile(edge.fromFile))
-                continue;
-            const target = resolveBareModule(edge.fromFile, name, "js-only") ??
-                resolveBareModule(edge.fromFile, name, "js-only", "require");
-            if (target === null || isEsmFile(target.typesFile))
-                continue;
-            grown.set(at.name, {
-                name: at.name,
-                version: packageVersionOf(at.dir),
-                dir: at.dir,
-                class: "packaging",
-                reason: `an ES module of the package imports the CommonJS island package '${name}'`,
-            });
-            added = true;
-        }
-    }
-    return grown.size === known.size ? null : grown;
+    return {
+        entry: entryPath,
+        policy: nodeIslandPolicy(readProjectConfig(entryPath), opts.nodeIslands),
+        scan,
+        npm: fe.npmStatic,
+        npmImportSites: fe.npmImportSites,
+        ...(Array.isArray(opts.npmStatic) ? { explicitNpmStatic: opts.npmStatic } : {}),
+        sourceTexts: () => fe.sourceTexts(),
+    };
 }
 /** The island modules grown by the lowering's refusals in user JavaScript
  * (`--node-islands=auto` only), or null when there are none: a sloppy
@@ -577,7 +682,8 @@ function loweringModules(entryPath, opts, diagnostics, known) {
         if (!isIslandReasonCode(d.code))
             continue;
         const file = d.loc.file;
-        // Packages run in Node through their own decision (loweringIslands).
+        // Packages run in Node through their own decision
+        // (node-islands/growth.ts).
         if (file.includes("/node_modules/") || packageDirOf(file) !== null)
             continue;
         if (!isJsSourceFileName(file) || sameFile(file, entryPath))
@@ -598,159 +704,4 @@ function loweringModules(entryPath, opts, diagnostics, known) {
     }
     return grown.size === known.size ? null : grown;
 }
-/** Preflight refusals at import statements of natively compiled npm
- * packages (`--node-islands=auto` only): those packages become islands. */
-function preflightIslands(entryPath, opts, fe, known) {
-    const policy = nodeIslandPolicy(readProjectConfig(entryPath), opts.nodeIslands);
-    if (policy.mode !== "auto" || known.size > 16)
-        return null;
-    const compiled = new Set(fe.npmStatic.filter((e) => e.status === "static").map((e) => e.package));
-    if (compiled.size === 0)
-        return null;
-    const texts = fe.sourceTexts();
-    const grown = new Map(known);
-    for (const d of fe.preflight) {
-        if (d.code !== "SC1013")
-            continue;
-        const text = texts.get(d.loc.file);
-        if (text === undefined)
-            continue;
-        // The import statement around the diagnostic: its module specifier.
-        const start = text.lastIndexOf("import", d.loc.start);
-        const end = text.indexOf(";", d.loc.end);
-        const stmt = text.slice(start < 0 ? d.loc.start : start, end < 0 ? text.length : end);
-        const m = /\bfrom\s*["']([^"']+)["']/.exec(stmt);
-        if (m === null)
-            continue;
-        const spec = m[1];
-        const name = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
-        if (!compiled.has(name) || grown.has(name))
-            continue;
-        if (policy.forcedNative.has(name) || policy.unloaded.has(name))
-            continue;
-        const site = fe.npmImportSites.get(name);
-        const jsEntry = site === undefined ? null : resolveBareModule(site.file, spec, "js-only");
-        const at = jsEntry === null ? null : packageDirOf(jsEntry.typesFile);
-        if (at === null)
-            continue;
-        grown.set(name, {
-            name,
-            version: packageVersionOf(at.dir),
-            dir: at.dir,
-            class: "gap",
-            reason: `${d.code}: ${d.message}`,
-        });
-    }
-    return grown.size === known.size ? null : grown;
-}
-/** Packages compiled natively with runtime fences (refusals deferred to the
- * operation that reaches them) that should run in islands instead: those
- * with a fence that surely fires (one in top-level module code, which runs
- * when the module evaluates) or that itself needs the runtime (R1). Other
- * fences stay deferred refusals until decision 8 (D6) retires them, so
- * typed packages like jose stay native. With `requireFence` false (after a
- * failed build) the package's island class by NI-2's report decides
- * instead: runtime (R1) or object-model (R2). `--node-islands=auto` only;
- * null for none. */
-function fenceIslands(entryPath, opts, fe, lowered, known, requireFence = true, sure) {
-    if (fe.nodeIslandScan === undefined)
-        return null;
-    if (requireFence && lowered.runtimeFences.length === 0)
-        return null;
-    const policy = nodeIslandPolicy(readProjectConfig(entryPath), opts.nodeIslands);
-    if (policy.mode !== "auto" || known.size > 32)
-        return null;
-    // An explicit --npm-static request keeps its package native.
-    const explicit = new Set(Array.isArray(opts.npmStatic) ? opts.npmStatic.map((n) => n.replace(/\.\.\.$/, "")) : []);
-    const compiled = new Set(fe.npmStatic
-        .filter((e) => e.status === "static" && !explicit.has(e.package))
-        .map((e) => e.package));
-    const fenced = new Map();
-    for (const d of lowered.runtimeFences) {
-        const at = packageDirOf(d.loc.file);
-        if (at === null || !compiled.has(at.name) || known.has(at.name))
-            continue;
-        if (policy.forcedNative.has(at.name) || policy.unloaded.has(at.name))
-            continue;
-        // A fence in top-level module code throws when the module evaluates:
-        // it counts like one that needs the runtime.
-        const runtime = d.moduleInit === true || classifyDiagnostic(d, "fence").class === "runtime";
-        fenced.set(at.name, (fenced.get(at.name) ?? false) || runtime);
-        if (runtime)
-            sure?.add(at.name);
-    }
-    if (requireFence && fenced.size === 0)
-        return null;
-    const scan = fe.nodeIslandScan({ userJs: false });
-    const report = buildNodeIslandReport({
-        entry: entryPath,
-        scan,
-        npm: fe.npmStatic,
-        diagnostics: lowered.diagnostics,
-        fences: lowered.runtimeFences,
-        policy,
-    });
-    const grown = new Map(known);
-    for (const island of report.islands) {
-        const runtimeFence = requireFence
-            ? fenced.get(island.package)
-            : (fenced.get(island.package) ?? false);
-        if (runtimeFence === undefined || island.path === null)
-            continue;
-        if (!compiled.has(island.package) || known.has(island.package))
-            continue;
-        if (policy.forcedNative.has(island.package) || policy.unloaded.has(island.package))
-            continue;
-        // With fences (requireFence), only fences that surely fire count: a
-        // gap fence inside a function body may never run (jose's typed paths
-        // stay native, DECISIONS.md 2026-10-21). After a failed build
-        // (!requireFence), the package's report class decides.
-        if (requireFence && !runtimeFence)
-            continue;
-        if (!runtimeFence && island.class !== "runtime" && island.class !== "object-model")
-            continue;
-        grown.set(island.package, {
-            name: island.package,
-            version: island.version,
-            dir: island.path,
-            class: island.class,
-            reason: island.reason,
-        });
-    }
-    // A native ES module that imports an island CommonJS module would read
-    // its bindings from the module's exports object, where Node gives it the
-    // namespace its CommonJS facade builds (the lexed names, module.exports
-    // as the default): the importing package runs in the island too.
-    for (let added = true; added;) {
-        added = false;
-        for (const edge of scan.edges) {
-            const name = edge.to;
-            if (!grown.has(name) || edge.fromDir === null || edge.shim)
-                continue;
-            const at = packageDirOf(edge.fromFile);
-            if (at === null || grown.has(at.name) || !compiled.has(at.name))
-                continue;
-            if (policy.forcedNative.has(at.name) || policy.unloaded.has(at.name))
-                continue;
-            if (!isEsmFile(edge.fromFile))
-                continue;
-            const target = resolveBareModule(edge.fromFile, name, "js-only") ??
-                resolveBareModule(edge.fromFile, name, "js-only", "require");
-            if (target === null || isEsmFile(target.typesFile))
-                continue;
-            grown.set(at.name, {
-                name: at.name,
-                version: packageVersionOf(at.dir),
-                dir: at.dir,
-                class: "packaging",
-                reason: `an ES module of the package imports the CommonJS island package '${name}'`,
-            });
-            // It goes wherever that island goes, the sure-fence retry included.
-            if (known.has(name) || sure?.has(name) === true)
-                sure?.add(at.name);
-            added = true;
-        }
-    }
-    return grown.size === known.size ? null : grown;
-}
 //# sourceMappingURL=prepare.js.map