@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.16

package/src/generated-file.ts

@@ -2,12 +2,25 @@
  * The generated-file class on TypeScript: every declaration in a file that marks itself
  * generated, below a directory an applied convention row names as generated, or minified,
  * is retained, because a generator owns the file and a deletion there is undone at the next
- * generation.
+ * generation. The same decision is each `generated` entry of the facts document.
  */
 
+import {
+  isIdentifier,
+  isImportDeclaration,
+  isPropertyAssignment,
+  isStringLiteralLikeNode,
+  isVariableStatement,
+  NodeFlags,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
-import { minified } from "./javascript-file.ts";
+import { minifiedBy } from "./javascript-file.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { bytewise } from "./text/compare.ts";
+import { satisfies } from "./version-range.ts";
 
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
@@ -24,9 +37,44 @@ const GENERATED_WORD = /\bgenerated\b/iu;
 /** The phrases a generator's notice asks a reader not to edit the file by. */
 const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
 
-/** The comments before a text's first token, a leading hashbang line skipped. */
-function leadingComments(text: string): readonly string[] {
-  const comments: string[] = [];
+/** What decided a file generated, as the facts document's `evidence` names it. */
+type GeneratedEvidence = "header" | "tag" | "notice" | "convention" | "minified";
+
+/** The generator row one generated file matches, with the version and the schema files its output states. */
+interface GeneratorMatch {
+  readonly row: string;
+  readonly version?: string;
+  readonly schemaFiles: readonly string[];
+}
+
+/** Why one file is generated, and which generator wrote it. */
+export interface GeneratedFact {
+  readonly evidence: GeneratedEvidence;
+  /** The 1-based line of the comment line that marks the file; 1 for a row or a minified file. */
+  readonly line: number;
+  /** The marking line's text, the convention row's name, or what decided the file minified. */
+  readonly detail: string;
+  readonly generator?: GeneratorMatch;
+}
+
+/** One line of a leading comment, with its 1-based line in the file. */
+interface CommentLine {
+  readonly text: string;
+  readonly line: number;
+}
+
+/** The comments before a text's first token, a leading hashbang line skipped, each as its lines. */
+function leadingComments(text: string): readonly (readonly CommentLine[])[] {
+  const comments: CommentLine[][] = [];
+  const lineAt = (offset: number): number =>
+    text.slice(0, offset).split(/\r\n|[\n\r\u2028\u2029]/u).length;
+  const lines = (from: number, to: number): CommentLine[] => {
+    const first = lineAt(from);
+    return text
+      .slice(from, to)
+      .split(/\r\n|[\n\r\u2028\u2029]/u)
+      .map((one, index) => ({ text: one, line: first + index }));
+  };
   let at = text.startsWith("\uFEFF") ? 1 : 0;
   if (text.startsWith("#!", at)) {
     const end = text.indexOf("\n", at);
@@ -39,14 +87,14 @@ function leadingComments(text: string): readonly string[] {
     if (text.startsWith("//", at)) {
       const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
       const stop = end === -1 ? text.length : at + end;
-      comments.push(text.slice(at, stop));
+      comments.push(lines(at, stop));
       at = stop;
     } else if (text.startsWith("/*", at)) {
       const end = text.indexOf("*/", at + 2);
       if (end === -1) {
         return comments;
       }
-      comments.push(text.slice(at, end + 2));
+      comments.push(lines(at, end + 2));
       at = end + 2;
     } else {
       return comments;
@@ -54,51 +102,201 @@ function leadingComments(text: string): readonly string[] {
   }
 }
 
-/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
-export function generatedByComment(text: string): string | undefined {
-  const comments = leadingComments(text);
-  if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
-    return "generated by the header line its leading comments hold";
+/** The mark one file's leading comments make it generated by, or undefined where they mark nothing. */
+export function generatedMark(text: string): Omit<GeneratedFact, "generator"> | undefined {
+  const lines = leadingComments(text).flat();
+  const header = lines.find((one) => HEADER_LINE.test(one.text));
+  if (header !== undefined) {
+    return { evidence: "header", line: header.line, detail: header.text };
+  }
+  const tag = lines.find((one) => GENERATED_TAG.test(one.text));
+  if (tag !== undefined) {
+    return { evidence: "tag", line: tag.line, detail: tag.text };
   }
-  if (comments.some((one) => GENERATED_TAG.test(one))) {
-    return "generated by the @generated tag its leading comments hold";
+  const [first] = lines;
+  if (first !== undefined && GENERATED_BY.test(first.text)) {
+    return { evidence: "notice", line: first.line, detail: first.text };
   }
-  const notice = comments.join("\n");
-  if (
-    GENERATED_BY.test(comments[0] ?? "") ||
-    (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))
-  ) {
-    return "generated by the notice its leading comments hold";
+  const notice = lines.map((one) => one.text).join("\n");
+  if (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice)) {
+    const marked = lines.find((one) => GENERATED_WORD.test(one.text) || KEEP_OUT.test(one.text));
+    return marked === undefined
+      ? undefined
+      : { evidence: "notice", line: marked.line, detail: marked.text };
+  }
+  return undefined;
+}
+
+/** What one form's first group captures, for each line the form matches. */
+function after(lines: readonly CommentLine[], form: RegExp): readonly string[] {
+  return lines.flatMap((one) => form.exec(one.text)?.[1] ?? []);
+}
+
+/**
+ * Where each plugin's output states its version and its schema files, as `references-ts.36`
+ * states: a plugin missing here states no version, and one with no schema form names none.
+ */
+const STATEMENTS: Readonly<Record<string, { version?: RegExp; schemaFiles?: RegExp }>> = {
+  "protoc-gen-es": {
+    version: /^\/\/ @generated by protoc-gen-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protoc-gen-connect-es": {
+    version: /^\/\/ @generated by protoc-gen-connect-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protobuf-ts": {
+    version: /^\/\/ @generated by protobuf-ts (\S+)/u,
+    schemaFiles: /^\/\/ @generated from protobuf file "([^"]+)"/u,
+  },
+  "ts-proto": {
+    version: /^\/\/\s+protoc-gen-ts_proto\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-grpc-web": {
+    version: /^\/\/\s+protoc-gen-grpc-web\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-js": { schemaFiles: /^\/\/ source: (.+)$/u },
+  "ts-protoc-gen": { schemaFiles: /^\/\/ file: (.+)$/u },
+};
+
+/** A ts-proto service path literal: `/<package>.<service>/<method>`. */
+const SERVICE_PATH = /^\/(?:\w+\.)+\w+\/\w+$/u;
+
+/** Whether one ts-proto file writes a service path, as `references-ts.36` reads one. */
+function writesServicePath(file: SourceFile): boolean {
+  const named = file.statements.some(
+    (statement) =>
+      isVariableStatement(statement) &&
+      (statement.declarationList.flags & NodeFlags.Const) !== 0 &&
+      statement.declarationList.declarations.some(
+        (one) =>
+          isIdentifier(one.name) &&
+          one.name.text.endsWith("ServiceName") &&
+          one.initializer !== undefined &&
+          isStringLiteralLikeNode(one.initializer),
+      ),
+  );
+  let found = named;
+  const visit = (node: Node): void => {
+    if (found) {
+      return;
+    }
+    if (
+      isPropertyAssignment(node) &&
+      isIdentifier(node.name) &&
+      node.name.text === "path" &&
+      isStringLiteralLikeNode(node.initializer) &&
+      SERVICE_PATH.test(node.initializer.text)
+    ) {
+      found = true;
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
+/** Whether one file imports a module by its specifier. */
+function imports(file: SourceFile, module: string): boolean {
+  return file.statements.some(
+    (statement) =>
+      isImportDeclaration(statement) &&
+      isStringLiteralLikeNode(statement.moduleSpecifier) &&
+      statement.moduleSpecifier.text === module,
+  );
+}
+
+/** The option sets the rows of `references-ts.36` name, by row; every other row's is met by any output. */
+const OPTION_SETS: Readonly<Record<string, (file: SourceFile) => boolean>> = {
+  "ts-proto-2-output-schema": (file) => imports(file, "ts-proto-descriptors"),
+  "ts-proto-2": writesServicePath,
+  "ts-proto-2-types": (file) => !writesServicePath(file),
+};
+
+/** The first generator row one file matches, in `generators.json`'s order, as `bindings.3` reads it. */
+export function generatorOf(file: SourceFile): GeneratorMatch | undefined {
+  const lines = leadingComments(file.text).flat();
+  for (const row of GENERATORS) {
+    const header = new RegExp(row.header, "u");
+    if (!lines.some((one) => header.test(one.text))) {
+      continue;
+    }
+    const statements = STATEMENTS[row.plugin] ?? {};
+    const [version] = statements.version === undefined ? [] : after(lines, statements.version);
+    if (
+      "versions" in row &&
+      (version === undefined ||
+        !satisfies(
+          version.replace(/^v/u, ""),
+          `>=${row.versions.min.replace(/^v/u, "")} <=${row.versions.max.replace(/^v/u, "")}`,
+        ))
+    ) {
+      continue;
+    }
+    if (OPTION_SETS[row.id]?.(file) === false) {
+      continue;
+    }
+    const schemaFiles =
+      statements.schemaFiles === undefined
+        ? []
+        : [
+            ...new Set(
+              after(lines, statements.schemaFiles).filter((one) => one.endsWith(".proto")),
+            ),
+          ].sort(bytewise);
+    return { row: row.id, ...(version === undefined ? {} : { version }), schemaFiles };
   }
   return undefined;
 }
 
 /**
- * Every own file of one project that is generated, by its path below the target root,
- * with the detail a retention in it names: its leading comments' mark, else the row
- * naming its directory as generated, else its minified text.
+ * Every own file of one project that is generated, by its path below the target root, with
+ * what decided it: its leading comments' mark, else the row naming its directory as
+ * generated, else its minified name or text; and the generator row it matches.
  */
 export function generatedFilesOf(
   files: SourceFiles,
   byRow: ReadonlyMap<string, string>,
-): ReadonlyMap<string, string> {
-  const found = new Map<string, string>();
+): ReadonlyMap<string, GeneratedFact> {
+  const found = new Map<string, GeneratedFact>();
   for (const [path, file] of files.byPath) {
     const row = byRow.get(path);
-    const detail =
-      generatedByComment(file.text) ??
+    const minified = row === undefined ? minifiedBy(file.fileName, file.text) : undefined;
+    const fact =
+      generatedMark(file.text) ??
       (row === undefined
-        ? minified(file.fileName, file.text)
-          ? "generated as a minified JavaScript file"
-          : undefined
-        : `generated below a directory the convention row ${row} names`);
-    if (detail !== undefined) {
-      found.set(path, detail);
+        ? minified === undefined
+          ? undefined
+          : { evidence: "minified" as const, line: 1, detail: minified }
+        : { evidence: "convention" as const, line: 1, detail: row });
+    if (fact === undefined) {
+      continue;
     }
+    const generator = generatorOf(file);
+    found.set(path, generator === undefined ? fact : { ...fact, generator });
   }
   return found;
 }
 
+/** The detail a retention in a generated file names, from what decided the file. */
+function retentionDetail(fact: GeneratedFact): string {
+  switch (fact.evidence) {
+    case "header":
+      return "generated by the header line its leading comments hold";
+    case "tag":
+      return "generated by the @generated tag its leading comments hold";
+    case "notice":
+      return "generated by the notice its leading comments hold";
+    case "convention":
+      return `generated below a directory the convention row ${fact.detail} names`;
+    case "minified":
+      return "generated as a minified JavaScript file";
+  }
+}
+
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const generated = input.generated;
@@ -106,9 +304,15 @@ export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evid
     return [];
   }
   return input.held.symbols.flatMap((symbol): Evidence[] => {
-    const detail = generated.get(symbol.position.path);
-    return symbol.kind === "file" || detail === undefined
+    const fact = generated.get(symbol.position.path);
+    return symbol.kind === "file" || fact === undefined
       ? []
-      : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
+      : [
+          {
+            id: symbol.id,
+            detail: retentionDetail(fact),
+            site: { path: symbol.position.path, line: 1, column: 1 },
+          },
+        ];
   });
 }

package/src/graph.ts

@@ -7,7 +7,7 @@
 
 import type { InventorySymbol, SymbolKind } from "./inventory.ts";
 import type { Reference } from "./references.ts";
-import type { Root, RootKind } from "./roots.ts";
+import type { Root, RootKind } from "./roots/root-set.ts";
 
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
@@ -39,8 +39,8 @@ const SWEPT: Readonly<Record<SymbolKind, boolean>> = {
 
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads what it loads and what its strings name, a runtime runs a test, setup or
- * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * tool reads what it loads and what its strings name, a runtime runs a test or setup
+ * file, a page's module script, a command, a script or a workflow step, the manifest
  * names what enters the package, an alias global stands for its export, an outside
  * declaration names a global interface merging into it, and an entry file, a configured root
  * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
@@ -61,8 +61,6 @@ const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "configuration-string": true,
   "bundler-entry": true,
   "test-runner": true,
-  "browser-tests": true,
-  worker: true,
   "html-entry": true,
   "workflow-step": true,
   "document-import": true,

package/src/index.ts

@@ -1,6 +1,6 @@
 export { run, SETTING_OPTIONS, type Writer } from "./run.ts";
 export type { DirectoryEntry, Host, PathKind, TemporaryDirectory } from "./host.ts";
-export { DECLINED_CONVENTIONS, type DeclinedConvention } from "./entry-point-gaps.ts";
+export { DECLINED_CONVENTIONS, type DeclinedConvention } from "./roots/entry-point-gaps.ts";
 export {
   byPosition,
   positionKey,

package/src/injection-container.ts

@@ -27,7 +27,7 @@ import {
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./configured-declarations.ts";
+} from "./roots/configured-declarations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { isParameterProperty, nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";

package/src/inventory/commonjs.ts

@@ -59,6 +59,7 @@ import {
   type DeclarationSource,
   type SymbolKind,
 } from "../inventory.ts";
+import { callsPlatformBy, lexicalBinding, writtenName, type BindingOf } from "../platform-calls.ts";
 import type { Component } from "../ref.ts";
 import { spellsNoBinding } from "../spelled-names.ts";
 import { unwrapped } from "../unwrap.ts";
@@ -67,13 +68,14 @@ import { unwrapped } from "../unwrap.ts";
  * The export table of a CommonJS file: the module value `module.exports` is assigned and
  * the properties written on it, read from the top-level unconditional statements in order,
  * as Node runs them (https://nodejs.org/api/modules.html#moduleexports). Each entry is
- * keyed by the node that writes it, which is the checker's declaration of the export where
- * it binds one, so the two name one subject. Any other write of the exports opens the
- * table: its entries are kept and the file is listed open.
+ * keyed by the node that writes it, the checker's declaration of the export where it binds
+ * one. Any other write of the exports opens the table: its entries are kept and the file is
+ * listed open. `declarationOf` reads a `require()` call through the file's own scopes.
  */
 export function commonJS(
   typeIsModule: (path: string) => boolean,
   resolved: Resolved,
+  declarationOf: (occurrence: Identifier) => Node | undefined,
 ): DeclarationSource {
   return {
     declare(file: SourceFile, owner: Building, into: Builder): void {
@@ -82,7 +84,12 @@ export function commonJS(
       }
       const bound = boundOccurrences(file, resolved);
       const free = (node: Node): boolean => !bound.has(node);
-      const table = readTable(file, free, topLevelDeclarations(file));
+      const table = readTable(
+        file,
+        free,
+        topLevelDeclarations(file),
+        lexicalBinding(declarationOf),
+      );
       const open = table.open || opens(file, free, table.modelled);
       for (const entry of table.entries.values()) {
         const record = into.declare(entry.node, owner, entry.kind, entry.name, {
@@ -267,6 +274,8 @@ interface Entry {
   readonly component: Component;
   readonly localName: string | undefined;
   readonly kind: SymbolKind;
+  /** The value written under the key, undefined for an accessor. */
+  readonly value: Node | undefined;
   /** The declaration of the file the module value names, which the export then exports. */
   readonly target?: Node;
   /** The class whose members the entry holds. */
@@ -279,6 +288,10 @@ interface Table {
   readonly open: boolean;
   /** Every write the scan read, which the opening walk then passes over. */
   readonly modelled: ReadonlySet<Node>;
+  /** The value the last assignment of `module.exports` writes, undefined where none does. */
+  readonly whole: Node | undefined;
+  /** Whether a member write opens the table, apart from a module value the table cannot read. */
+  readonly membersOpen: boolean;
 }
 
 const DEFAULT: Component = { text: "default", computed: false };
@@ -288,23 +301,34 @@ function readTable(
   file: SourceFile,
   isFree: (node: Node) => boolean,
   declarations: ReadonlyMap<string, Node>,
+  bindingOf: BindingOf,
 ): Table {
   const entries = new Map<string, Entry>();
   const modelled = new Set<Node>();
-  let open = false;
+  // Written inside the closures below, which the compiler's narrowing does not follow.
+  let open = false as boolean;
   let aliasing = true;
+  let whole: Node | undefined;
+  let wholeOpen = false;
   const free = (node: Node, name: string): boolean =>
     isIdentifier(node) && node.text === name && isFree(node);
   const isModuleExports = (node: Node): node is PropertyAccessExpression =>
     isPropertyAccessExpression(node) &&
     free(node.expression, "module") &&
     node.name.text === "exports";
-  const isRequire = (node: Node): boolean =>
-    isCallExpression(node) &&
-    free(node.expression, "require") &&
-    node.arguments.length === 1 &&
-    node.arguments[0] !== undefined &&
-    isLiteralText(node.arguments[0]);
+  const isRequire = (node: Node): boolean => {
+    if (!isCallExpression(node) || node.arguments.length !== 1) {
+      return false;
+    }
+    const [argument] = node.arguments;
+    const callee = writtenName(node.expression);
+    return (
+      argument !== undefined &&
+      isLiteralText(argument) &&
+      callee !== undefined &&
+      callsPlatformBy("require", callee, bindingOf)
+    );
+  };
 
   /** What a value written under one key declares. */
   const entryOf = (
@@ -314,7 +338,7 @@ function readTable(
     value: Node | undefined,
   ): Entry => {
     const held = value === undefined ? undefined : unwrapped(value);
-    const base = { node, name, component, localName: undefined };
+    const base = { node, name, component, localName: undefined, value };
     if (held === undefined) {
       return { ...base, kind: "variable" };
     }
@@ -365,6 +389,7 @@ function readTable(
   /** The module value one assignment writes, placed at the `exports` name it assigns. */
   const moduleValue = (node: BinaryExpression, name: Node): void => {
     entries.clear();
+    whole = node.right;
     const value = unwrapped(node.right);
     if (isRequire(value)) {
       return;
@@ -373,7 +398,7 @@ function readTable(
       value.properties.forEach(literalProperty);
       return;
     }
-    const base = { node, name, component: DEFAULT };
+    const base = { node, name, component: DEFAULT, value: node.right };
     const target = isIdentifier(value) ? declarations.get(value.text) : undefined;
     if (target !== undefined) {
       entries.set("default", { ...base, localName: undefined, kind: "export-alias", target });
@@ -389,7 +414,7 @@ function readTable(
         members: value,
       });
     } else {
-      open = true;
+      wholeOpen = true;
     }
   };
 
@@ -422,8 +447,18 @@ function readTable(
         }
       } else if (isModuleExports(left)) {
         modelled.add(expression);
-        moduleValue(expression, left.name);
-        aliasing = false;
+        const inner = unwrapped(expression.right);
+        const chained =
+          isBinaryExpression(inner) &&
+          inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+          free(inner.left, "exports")
+            ? inner
+            : undefined;
+        if (chained !== undefined) {
+          modelled.add(chained);
+        }
+        moduleValue(chained ?? expression, left.name);
+        aliasing = chained !== undefined;
       } else if (isPropertyAccessExpression(left) || isElementAccessExpression(left)) {
         const object = exportsObject(left.expression);
         const key = isPropertyAccessExpression(left) ? left.name : left.argumentExpression;
@@ -454,7 +489,57 @@ function readTable(
       }
     }
   }
-  return { entries, open, modelled };
+  return { entries, open: open || wholeOpen, modelled, whole, membersOpen: open };
+}
+
+/** One member a CommonJS file's module value holds, as {@link commonJSModuleValue} reads it. */
+interface WrittenMember {
+  readonly key: string;
+  /** The value written, undefined for an accessor. */
+  readonly value: Node | undefined;
+  /** The node that writes the member. */
+  readonly node: Node;
+}
+
+/** The module value a CommonJS file leaves once Node has run its top level. */
+export interface ModuleValue {
+  /** The value the last assignment of `module.exports` writes, where that is no object literal. */
+  readonly whole: Node | undefined;
+  /** The members written on the module value, an object literal assigned to `module.exports` among them. */
+  readonly members: readonly WrittenMember[];
+  /** Whether a write the table does not model may set any member. */
+  readonly open: boolean;
+}
+
+/**
+ * The module value one file leaves where Node runs it as CommonJS, read by the one table
+ * the inventory's export table reads, or undefined where the file writes module syntax.
+ * `declarationOf` names the declaration each name resolves to, undefined for none, as a
+ * lexical reading of a file outside every program answers it.
+ */
+export function commonJSModuleValue(
+  file: SourceFile,
+  declarationOf: (occurrence: Identifier) => Node | undefined,
+): ModuleValue | undefined {
+  if (writesModuleSyntax(file)) {
+    return undefined;
+  }
+  const free = (node: Node): boolean => {
+    const declaration = isIdentifier(node) ? declarationOf(node) : undefined;
+    return declaration === undefined || !bindsOwn(declaration, file);
+  };
+  const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+  const held = table.whole === undefined ? undefined : unwrapped(table.whole);
+  const members = [...table.entries.values()].flatMap((entry) =>
+    entry.component === DEFAULT && held !== undefined && !isObjectLiteralExpression(held)
+      ? []
+      : [{ key: entry.component.text, value: entry.value, node: entry.node }],
+  );
+  return {
+    whole: held === undefined || isObjectLiteralExpression(held) ? undefined : table.whole,
+    members,
+    open: table.membersOpen || opens(file, free, table.modelled),
+  };
 }
 
 /** Whether one node is `Object.defineProperty`. */

package/src/inventory/enumerate.ts

@@ -15,6 +15,7 @@ import { relativePath } from "../paths.ts";
 import { renderPosition } from "../position.ts";
 import { isAnswered, UNANSWERED } from "../query.ts";
 import type { Handle, ProjectView } from "../session.ts";
+import { declarationOf } from "../entries/static-module.ts";
 import { commonJS, type Resolved } from "./commonjs.ts";
 import { SYNTAX } from "./syntax.ts";
 
@@ -34,7 +35,7 @@ export function inventory<Brand>(
   const moduleOf = packageScope(host, targetRoot);
   const sources: readonly DeclarationSource[] = [
     SYNTAX,
-    commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project)),
+    commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project), declarationOf),
   ];
   const into = new Builder(targetRoot);
   for (const file of files) {