@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.4

package/src/contextual-uses.ts

@@ -1,10 +1,11 @@
 /**
  * The uses contextual types make of the target's members, which no name node resolves to.
  * An object-literal property writes the member of its name on each constituent of the
- * literal's contextual type that declares one. A value reaching a position typed by another
- * object type reads each of its members that type declares, through array elements and
- * the parameters and results of functions and constructors too; a class instance there is
- * the interface-satisfaction class's evidence instead.
+ * literal's contextual type that declares one, and so does a property of a literal whose
+ * type is inferred, where a value of that type reaches such a position. A value reaching a
+ * position typed by another object type reads each of its members that type declares,
+ * through array elements and the parameters and results of functions and constructors
+ * too; a class instance there is the interface-satisfaction class's evidence instead.
  */
 
 import {
@@ -109,10 +110,12 @@ interface Checked {
   readonly source: Type;
   readonly targets: readonly Type[];
   /**
-   * Whether the source is declared outside the target, so code the analysis does not
-   * hold reads the members of the target's types it declares.
+   * What the source is: a type whose members the target declares, which the position
+   * reads; one declared outside the target, so code the analysis does not hold reads the
+   * members of the target's types it declares; or an object literal's own type, whose
+   * properties write the position's members of their names.
    */
-  readonly outside: boolean;
+  readonly sourceKind: "members" | "outside" | "literal";
 }
 
 /** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
@@ -287,6 +290,37 @@ export function contextualUses<Brand>(
     return members.length > 0 && members.every((member) => !member.own);
   };
 
+  const literalTypes = new Map<number, boolean>();
+  /**
+   * Whether an object type is an object literal's own, inferred where no contextual type
+   * names it: every member a property an object literal of the target writes.
+   */
+  const literalTyped = (part: Type): boolean => {
+    let known = literalTypes.get(part.id);
+    if (known === undefined) {
+      const members = [...membersOf(part).values()];
+      known =
+        members.length > 0 &&
+        members.every(
+          (member) =>
+            member.ids.length === 0 &&
+            member.declarations.length > 0 &&
+            member.declarations.every((handle) => literalProperty(handle) !== undefined),
+        );
+      literalTypes.set(part.id, known);
+    }
+    return known;
+  };
+  /** The name node of the object literal property one declaration handle names, if it is one. */
+  const literalProperty = (handle: NodeHandle): Node | undefined => {
+    const node = project.declarationAt(handle)?.node;
+    return node !== undefined &&
+      (isPropertyAssignment(node) || isShorthandPropertyAssignment(node)) &&
+      isObjectLiteralExpression(node.parent)
+      ? node.name
+      : undefined;
+  };
+
   const elements = new Map<number, Type | undefined>();
   /** The element type of an array type, read once per type. */
   const elementOf = (type: Type): Type | undefined => {
@@ -379,9 +413,11 @@ export function contextualUses<Brand>(
     const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
     for (const one of sources) {
       if (carries(one)) {
-        into.push({ source: one, targets, outside: false });
+        into.push({ source: one, targets, sourceKind: "members" });
       } else if (outside(one)) {
-        into.push({ source: one, targets, outside: true });
+        into.push({ source: one, targets, sourceKind: "outside" });
+      } else if (literalTyped(one)) {
+        into.push({ source: one, targets, sourceKind: "literal" });
       }
       const element = elementOf(one);
       const called = element === undefined ? callsOf(one) : [];
@@ -423,7 +459,7 @@ export function contextualUses<Brand>(
     }
     seen.add(type.id);
     return partsOf(type).some((part) => {
-      if (carries(part) || outside(part)) {
+      if (carries(part) || outside(part) || literalTyped(part)) {
         return true;
       }
       const element = elementOf(part);
@@ -444,6 +480,8 @@ export function contextualUses<Brand>(
     cap,
   );
   const reads: ContextualUse[] = [];
+  // A literal property writes a position's members once, however many values carry it there.
+  const carriedWrites = new Set<string>();
   sourced.forEach(({ flow, type }, index) => {
     const position = positions[index];
     if (position === undefined || !isAnswered(position)) {
@@ -452,10 +490,24 @@ export function contextualUses<Brand>(
     const checked: Checked[] = [];
     compared(type, position, checked, new Set());
     const ids = new Set<string>();
-    for (const { source, targets, outside: held } of checked) {
+    for (const { source, targets, sourceKind } of checked) {
       const tables = targets.map(membersOf);
       const sourceMembers = membersOf(source);
-      if (held) {
+      if (sourceKind === "literal") {
+        for (const [name, member] of sourceMembers) {
+          const written = [...new Set(tables.flatMap((table) => table.get(name)?.ids ?? []))];
+          for (const at of written.length === 0 ? [] : member.declarations) {
+            const node = literalProperty(at);
+            const key = `${at.path}#${String(at.index)}>${written.join(",")}`;
+            if (node !== undefined && !carriedWrites.has(key)) {
+              carriedWrites.add(key);
+              writes.push({ at: node, from: flow.from, ids: written });
+            }
+          }
+        }
+        continue;
+      }
+      if (sourceKind === "outside") {
         for (const table of tables) {
           for (const [name, member] of table) {
             if (sourceMembers.has(name)) {

package/src/convention-rows.ts

@@ -146,8 +146,8 @@ const SCRIPT = "{js,jsx,ts,tsx}";
 const MODULE = "{js,mjs,ts,mts}";
 const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
 const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
-/** The legacy configuration files of ESLint that hold JSON or a CommonJS module. */
-const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{js,cjs}"];
+/** The legacy configuration files of ESLint: JSON, YAML or a CommonJS module. */
+const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{yml,yaml}", ".eslintrc.{js,cjs}"];
 
 const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
 
@@ -209,6 +209,35 @@ const ANGULAR_PACKAGE_KEYS: readonly PackageKey[] = [
   "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
 
+/**
+ * The row of a code generator that writes its output below one directory its
+ * configuration's `property` sets, `fallback` where no configuration file sets it, so
+ * every file there is a generated file.
+ */
+function outputDirectoryRow(row: {
+  readonly name: string;
+  readonly package: string;
+  readonly range: string;
+  readonly files: readonly string[];
+  readonly property: string;
+  readonly fallback: string;
+}): ConventionRow {
+  return {
+    name: row.name,
+    package: row.package,
+    range: row.range,
+    entries: [],
+    generated: ["<output>"],
+    moves: [
+      {
+        id: "output",
+        defaults: [row.fallback],
+        readings: [{ property: row.property, files: row.files }],
+      },
+    ],
+  };
+}
+
 /**
  * The test runners and the assertion, mock and runner libraries whose import is test
  * evidence beside each runner a row reads test files for. Each applies whether or not a
@@ -299,6 +328,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     range: ">=4.0.0 <10.0.0",
     entries: [],
     moves: [],
+    packageKeys: [{ key: "parser", files: ESLINTRC }],
     prefixedNames: [
       { property: "plugins", files: ESLINTRC, prefix: "eslint-plugin" },
       { property: "extends", files: ESLINTRC, prefix: "eslint-plugin", marker: "plugin:" },
@@ -414,6 +444,14 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       { key: "oclif.hooks", directory: false },
     ],
   },
+  outputDirectoryRow({
+    name: "panda",
+    package: "@pandacss/dev",
+    range: ">=0.1.0 <2.0.0",
+    files: [`panda.config.${ANY_MODULE}`],
+    property: "outdir",
+    fallback: "styled-system",
+  }),
   {
     name: "parcel",
     package: "parcel",
@@ -481,6 +519,13 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "react-scripts",
+    package: "react-scripts",
+    range: ">=1.0.0 <6.0.0",
+    entries: [`src/index.${SCRIPT}`, "src/setupProxy.js", `src/setupTests.${SCRIPT}`],
+    moves: [],
+  },
   {
     name: "remix",
     package: "@remix-run/dev",

package/src/conventions.ts

@@ -66,6 +66,7 @@ import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from
 import type { SetupFailure } from "./setup-failure.ts";
 import type { SourceFiles } from "./source-files.ts";
 import { satisfies } from "./version-range.ts";
+import { yamlDocument } from "./yaml-document.ts";
 
 /** One manifest the analysis reads. */
 export interface ConventionManifest {
@@ -151,6 +152,13 @@ type ParseSource = (fileName: string, text: string) => SourceFile;
 
 const JSON_EXTENSION = ".json";
 
+/**
+ * A configuration file its tool reads as a YAML document, read as the JSON document it
+ * denotes. Its nodes' offsets are that JSON text's, so no move may read one: a failure's
+ * line would name the wrong line.
+ */
+const YAML_NAME = /\.ya?ml$/u;
+
 /** A configuration file with no extension that its tool reads as a JSON document. */
 const JSON_RC = /^\.[\w-]+rc$/u;
 
@@ -883,6 +891,14 @@ function readingFiles(
       } catch {
         continue;
       }
+      if (YAML_NAME.test(name)) {
+        const value = yamlDocument(text);
+        if (value !== undefined) {
+          const json = JSON.stringify(value);
+          found.push({ name, text: json, file: parse(`${path}${JSON_EXTENSION}`, json) });
+        }
+        continue;
+      }
       found.push({
         name,
         text,

package/src/dependencies.ts

@@ -48,7 +48,7 @@ import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
 import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
-import { workflowTokens } from "./workflow-steps.ts";
+import { workflowCommands, workflowTokens } from "./workflow-steps.ts";
 
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
@@ -871,6 +871,110 @@ function scriptTokensOf(manifest: Record<string, unknown>): ReadonlySet<string>
   return found;
 }
 
+/**
+ * The runtime flags whose value is a module loaded before the entry, as `--flag value` or
+ * `--flag=value`: https://nodejs.org/api/cli.html#--importmodule,
+ * https://nodejs.org/api/cli.html#--experimental-loadermodule,
+ * https://nodejs.org/api/cli.html#-r---require-module
+ */
+const PRELOAD_FLAGS: ReadonlySet<string> = new Set([
+  "--experimental-loader",
+  "--import",
+  "--loader",
+  "--require",
+  "-r",
+]);
+
+/**
+ * The programs that pass a preload flag to the runtime they start: Node itself, and the
+ * runners that forward Node's flags or read the same `--require`:
+ * https://mochajs.org/#-require-module-r-module, https://tsx.is/node-enhancement,
+ * https://typestrong.org/ts-node/docs/options#require,
+ * https://github.com/remy/nodemon#running-non-node-scripts
+ */
+const PRELOADING_PROGRAMS: ReadonlySet<string> = new Set([
+  "mocha",
+  "node",
+  "nodemon",
+  "ts-node",
+  "tsx",
+]);
+
+/** The programs that run the command after them, and an environment assignment before it. */
+const LAUNCHERS: ReadonlySet<string> = new Set(["cross-env", "env", "npx"]);
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
+
+/** The commands one script string runs, split at the shell's list and pipeline operators. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\||&/u;
+
+/**
+ * The command strings one manifest runs: each of its `scripts`, and the `exec` command of
+ * nodemon's configuration, in the manifest's `nodemonConfig` or the `nodemon.json` beside
+ * it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
+ */
+function manifestCommands(
+  host: Host,
+  dir: string,
+  manifest: Record<string, unknown>,
+): readonly string[] {
+  const scripts = manifest["scripts"];
+  const nodemon = [manifest["nodemonConfig"], readJSON(host, joinPath(dir, "nodemon.json"))?.value];
+  return [
+    ...(isRecord(scripts) ? Object.values(scripts) : []),
+    ...nodemon.map((config) => (isRecord(config) ? config["exec"] : undefined)),
+  ].filter((command): command is string => typeof command === "string");
+}
+
+/**
+ * The packages `scripts` preload by a runtime flag's bare module specifier, a flag
+ * counting only in a command whose program passes it to the runtime, and for Node only
+ * before the script it runs, whose own arguments come after it.
+ */
+function preloadsOf(scripts: readonly string[]): ReadonlySet<string> {
+  const found = new Set<string>();
+  for (const script of scripts) {
+    for (const command of script.split(COMMAND_SEPARATORS)) {
+      const tokens = scriptTokens(command);
+      let at = 0;
+      while (
+        at < tokens.length &&
+        (ASSIGNMENT.test(tokens[at] ?? "") || LAUNCHERS.has(tokens[at] ?? ""))
+      ) {
+        at += 1;
+      }
+      const path = tokens[at] ?? "";
+      const program = path.slice(path.lastIndexOf("/") + 1);
+      if (!PRELOADING_PROGRAMS.has(program)) {
+        continue;
+      }
+      for (at += 1; at < tokens.length; at += 1) {
+        const token = tokens[at] ?? "";
+        if (!token.startsWith("-")) {
+          if (program === "node") {
+            break;
+          }
+          continue;
+        }
+        const equals = token.indexOf("=");
+        const flag = equals < 0 ? token : token.slice(0, equals);
+        if (!PRELOAD_FLAGS.has(flag)) {
+          continue;
+        }
+        if (equals < 0) {
+          at += 1;
+        }
+        const value = equals < 0 ? tokens[at] : token.slice(equals + 1);
+        const name = value === undefined ? undefined : packageOfSpecifier(value);
+        if (name !== undefined) {
+          found.add(name);
+        }
+      }
+    }
+  }
+  return found;
+}
+
 /** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
 function isInside(path: string, dir: string): boolean {
   return dir === "" || path.startsWith(`${dir}/`);
@@ -966,6 +1070,7 @@ export function dependenciesOf(
     }
   }
   const workflow = new Set(workflowTokens(host, targetRoot));
+  const workflowPreloads = preloadsOf(workflowCommands(host, targetRoot));
   const declared: DeclaredDependency[] = [];
   const ran = new Set<string>();
   const peers = new Map<string, readonly string[]>();
@@ -976,12 +1081,16 @@ export function dependenciesOf(
       continue;
     }
     const tokens = scriptTokensOf(read.value);
+    const preloads = preloadsOf(manifestCommands(host, dir, read.value));
     for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
       const found = installedOf(host, dir, dependency.name);
       if (found === undefined && uninstalledHere.has(dir)) {
         continue;
       }
       declared.push(dependency);
+      if (preloads.has(dependency.name) || workflowPreloads.has(dependency.name)) {
+        ran.add(declarationKey(dependency));
+      }
       if (found === undefined) {
         continue;
       }

package/src/discover.ts

@@ -3,7 +3,7 @@ import type { Diagnostic } from "@typescript/native/sync";
 import { baseUrlPaths } from "./base-url.ts";
 import type { BuildConfiguration, ProjectConfiguration } from "./config.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { Scope } from "./scope.ts";
 import { SetupError } from "./setup-failure.ts";
 import type { Engine, ProjectDiagnostics } from "./session.ts";
@@ -347,55 +347,8 @@ function derivedId(targetRoot: string, configFile: string): string {
   return relativePath(targetRoot, configFile) ?? configFile;
 }
 
-/**
- * The code of a configuration whose `extends` chain returns to a configuration it already
- * passed. The parse reports it and returns, and a snapshot opened from it never answers:
- * https://github.com/microsoft/TypeScript/issues/64754
- */
-const CIRCULAR_EXTENDS = 18000;
-
 type Parsed = ReturnType<Engine["parseConfigFile"]>;
 
-/** The configuration files one parsed configuration's own `extends` names by path. */
-function extendedPaths(parsed: Parsed, configFile: string): readonly string[] {
-  const { raw } = parsed as { readonly raw?: unknown };
-  const named: unknown = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
-  return (Array.isArray(named) ? named : [named])
-    .filter((one): one is string => typeof one === "string")
-    .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
-    .map((one) => resolvePath(dirnamePath(configFile), one));
-}
-
-/**
- * The `extends` chain from `configFile` to the first configuration it reaches twice, each
- * link by path, or undefined where no chain written by path returns.
- */
-function extendsCycle(
-  engine: Engine,
-  configFile: string,
-  parsed: Parsed,
-): readonly string[] | undefined {
-  const walk = (chain: readonly string[], at: Parsed): readonly string[] | undefined => {
-    for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
-      if (chain.includes(next)) {
-        return [...chain, next];
-      }
-      let read: Parsed;
-      try {
-        read = engine.parseConfigFile(next);
-      } catch {
-        continue;
-      }
-      const cycle = walk([...chain, next], read);
-      if (cycle !== undefined) {
-        return cycle;
-      }
-    }
-    return undefined;
-  };
-  return walk([configFile], parsed);
-}
-
 /** The configuration files one parsed configuration's `references` name. */
 function referencesOf(parsed: Parsed): readonly string[] {
   // The parse answers a directory reference as the directory; the compiler reads a
@@ -406,51 +359,17 @@ function referencesOf(parsed: Parsed): readonly string[] {
   );
 }
 
-/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
-function circularity(engine: Engine, configFile: string, parsed: Parsed): string | undefined {
-  const chain = extendsCycle(engine, configFile, parsed);
-  if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
-    return undefined;
-  }
-  return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
-}
-
 /**
- * Why a configuration the `references` reach, transitively, cannot be opened, where one's
- * `extends` chain is circular: the compiler opens every referenced project with the one
- * that references it.
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. A snapshot that opens two configurations whose `extends` chains reach one such
+ * cycle panics (`OwnerCache.AddOwner: entry not found`, typescript 7.1.0-dev.20261014.1),
+ * so the analysis refuses one before any snapshot is asked to open it.
  */
-function referencedCircularity(
-  engine: Engine,
-  references: readonly string[],
-  visited: Set<string>,
-): string | undefined {
-  for (const reference of references) {
-    if (visited.has(reference)) {
-      continue;
-    }
-    visited.add(reference);
-    let parsed: Parsed;
-    try {
-      parsed = engine.parseConfigFile(reference);
-    } catch {
-      continue;
-    }
-    const reason =
-      circularity(engine, reference, parsed) ??
-      referencedCircularity(engine, referencesOf(parsed), visited);
-    if (reason !== undefined) {
-      return reason;
-    }
-  }
-  return undefined;
-}
+const CIRCULAR_EXTENDS = 18000;
 
 /**
- * The configuration files one configuration's `references` name, or why the compiler
- * cannot read the configuration: it throws, or its `extends` chain or that of a
- * configuration it references is circular, which the analysis refuses before any
- * snapshot is asked to open it.
+ * The configurations one configuration file's `references` name, or why it cannot be read:
+ * the compiler throws, or its parse reports the `extends` chain circular.
  */
 function readConfiguration(
   engine: Engine,
@@ -458,11 +377,12 @@ function readConfiguration(
 ): { readonly references: readonly string[] } | { readonly reason: string } {
   try {
     const parsed = engine.parseConfigFile(configFile);
-    const references = referencesOf(parsed);
-    const reason =
-      circularity(engine, configFile, parsed) ??
-      referencedCircularity(engine, references, new Set([configFile]));
-    return reason === undefined ? { references } : { reason };
+    const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
+    // The compiler leaves the message's `{0}` unfilled:
+    // https://github.com/microsoft/TypeScript/pull/64755
+    return circular === undefined
+      ? { references: referencesOf(parsed) }
+      : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
   } catch (error: unknown) {
     return { reason: error instanceof Error ? error.message : String(error) };
   }

package/src/entry-points.ts

@@ -14,7 +14,6 @@
 import {
   isArrayLiteralExpression,
   isAsExpression,
-  isBinaryExpression,
   isCallExpression,
   isExportAssignment,
   isIdentifier,
@@ -27,7 +26,6 @@ import {
   isPropertyAssignment,
   isSatisfiesExpression,
   isStringLiteral,
-  isTemplateExpression,
   SyntaxKind,
   type Node,
   type SourceFile,
@@ -40,6 +38,7 @@ import {
   type ParseFile,
 } from "./configuration-files.ts";
 import type { Selected } from "./conventions.ts";
+import { buildScriptEntries } from "./build-scripts.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
@@ -48,6 +47,7 @@ import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.ts";
 import { workflowEntries } from "./workflow-steps.ts";
 
 /** Which rule entered a file. */
@@ -56,6 +56,8 @@ export type EntryRule =
   | "configuration-file"
   /** A file a relative string of a configuration module or a JSON configuration file names. */
   | "configuration-string"
+  /** An entry a build script's bundler call names, whose exports the bundle exposes. */
+  | "bundler-entry"
   /** The test runner: its workspace configuration, its setup files and the test files. */
   | "test-runner"
   /** The test files below the browser-test runner's test directory. */
@@ -324,10 +326,7 @@ function configurationEntries(
     strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
   }
   for (const { file } of outside) {
-    strings(
-      dirnamePath(file.fileName),
-      moduleStrings(file).map((one) => one.text),
-    );
+    strings(dirnamePath(file.fileName), unselected(file));
   }
   return found;
 }
@@ -541,18 +540,6 @@ function workersOf<Brand>(
   return found;
 }
 
-/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-function leadingLiteral(node: Node): string | undefined {
-  const at = unwrapped(node);
-  if (isTemplateExpression(at)) {
-    return at.head.text;
-  }
-  if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
-    return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
-  }
-  return undefined;
-}
-
 /** Whether one call is `import.meta.glob(...)`. */
 function isMetaGlob(node: Node): boolean {
   if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
@@ -579,13 +566,8 @@ function computedImportsOf(file: SourceFile, files: SourceFiles): readonly Entry
   const dir = dirnamePath(file.fileName);
   const found: EntryPoint[] = [];
   const below = (prefix: string): void => {
-    const target = resolvePath(dir, prefix);
-    if (
-      !isModuleRelative(prefix) ||
-      !prefix.endsWith("/") ||
-      target === dir ||
-      relativePath(target, dir) !== undefined
-    ) {
+    const target = computedLoadDirectory(dir, prefix);
+    if (target === undefined) {
       return;
     }
     for (const candidate of files.byName.values()) {
@@ -680,6 +662,9 @@ export function entryPoints<Brand>(
       ...(names === undefined ? {} : { names }),
     });
   }
+  for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+    found.push({ file, rule: "bundler-entry", source, exports: true });
+  }
   for (const { file, source } of workflowEntries(host, targetRoot, files)) {
     found.push({ file, rule: "workflow-step", source, exports: true });
   }

package/src/exempt.ts

@@ -37,6 +37,8 @@ export interface Evidence {
   readonly whileLive?: string;
   /** Where the evidence is an implementation of interface methods, which and how. */
   readonly implementing?: Implementing;
+  /** Whether the evidence holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
 }
 
 /** What a detector reads of one project, while the project's view is open. */
@@ -193,12 +195,26 @@ export function evidenceRecords<Brand>(
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
         ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
+        ...(evidence.whileWritten === undefined ? {} : { whileWritten: evidence.whileWritten }),
       });
     }
   }
   return found;
 }
 
+/**
+ * The records that hold given the declarations a write the mode counts stores into: one
+ * that holds only while written holds where its declaration is among them.
+ */
+export function writtenRecords(
+  records: readonly Exemption[],
+  written: ReadonlySet<string>,
+): readonly Exemption[] {
+  return records.flatMap(({ whileWritten, ...record }) =>
+    whileWritten === undefined || written.has(record.id) ? [record] : [],
+  );
+}
+
 /** The records that hold under one mode, beside the evidence a production mode found in a test file. */
 export function heldRecords(records: readonly Exemption[], holding: Holding): Detected {
   const found: Exemption[] = [];