@cplieger/deadset-ts 3.12.0 → 3.12.1

package/dist/src/graph.js

@@ -32,15 +32,15 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads, a runtime runs a test file, a setup file and a
- * worker, and a configured root asserts a caller. The other kinds only suppose a consumer
- * that imports what a manifest entry, a binary or an entry file exports, or names a
- * library's published API, so such a root is live under reachability alone.
+ * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
+ * worker and a command, the manifest names what enters the package, and an entry file, a
+ * configured root and a pattern assert a caller. A library's published API only supposes
+ * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
-    "entry-file": false,
-    "manifest-entry": false,
-    "manifest-binary": false,
+    "entry-file": true,
+    "manifest-entry": true,
+    "manifest-binary": true,
     "published-api": false,
     configured: true,
     pattern: true,

package/dist/src/roots.js

@@ -4,9 +4,8 @@
  *
  * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
  * that names a caller is live under reference counting as well, which the sweep
- * decides; a root that only supposes a consumer is not, so an exported declaration
- * something outside the program reaches is live under reachability and still a
- * candidate under reference counting.
+ * decides; the published API only supposes a consumer, so a published export is live
+ * under reachability and still a candidate under reference counting.
  */
 import { aliasChains } from "./alias-chain.js";
 import { entryPoints } from "./entry-points.js";
@@ -94,6 +93,7 @@ function childrenOf(held) {
  * is a root with everything its module exports: each name of the module's export
  * table, and where a name is a re-export, every link of the chain to the declaration
  * it carries, so a re-exported declaration is a root of the file that publishes it.
+ * In a library, what a published file exports is rooted by the published API alone.
  * A file a runtime executes without reading its exports, a test file or a worker, is
  * a root by itself.
  */
@@ -116,14 +116,19 @@ export function roots(project, held, targetRoot, options) {
         entered.push({ file, kind, source, exports });
     };
     const published = [];
-    const publishes = (entry) => entry.published &&
+    const publishes = (entry) => options.publishedAPI &&
+        entry.published &&
         (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
+    for (const entry of options.manifest.entries) {
+        if (publishes(entry)) {
+            published.push(...files.named(entry.path));
+        }
+    }
+    const publishedNames = new Set(published.map((file) => file.fileName));
     for (const entry of options.manifest.entries) {
         for (const file of files.named(entry.path)) {
-            enter(file, entry.role === "run" ? "manifest-binary" : "manifest-entry", entry.member, true);
-            if (options.publishedAPI && publishes(entry)) {
-                published.push(file);
-            }
+            const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
     }
     for (const pattern of options.entryFiles) {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.12.0",
+  "version": "3.12.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.12.0",
+  "version": "3.12.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/graph.ts

@@ -39,15 +39,15 @@ 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 the configuration it loads, a runtime runs a test file, a setup file and a
- * worker, and a configured root asserts a caller. The other kinds only suppose a consumer
- * that imports what a manifest entry, a binary or an entry file exports, or names a
- * library's published API, so such a root is live under reachability alone.
+ * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
+ * worker and a command, the manifest names what enters the package, and an entry file, a
+ * configured root and a pattern assert a caller. A library's published API only supposes
+ * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
-  "entry-file": false,
-  "manifest-entry": false,
-  "manifest-binary": false,
+  "entry-file": true,
+  "manifest-entry": true,
+  "manifest-binary": true,
   "published-api": false,
   configured: true,
   pattern: true,

package/src/roots.ts

@@ -4,9 +4,8 @@
  *
  * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
  * that names a caller is live under reference counting as well, which the sweep
- * decides; a root that only supposes a consumer is not, so an exported declaration
- * something outside the program reaches is live under reachability and still a
- * candidate under reference counting.
+ * decides; the published API only supposes a consumer, so a published export is live
+ * under reachability and still a candidate under reference counting.
  */
 
 import type { SourceFile } from "@typescript/native/unstable/ast";
@@ -23,9 +22,9 @@ import { sourceFilesOf } from "./source-files.ts";
 export type RootKind =
   /** A file `ts.entry_files` names, and what it exports. */
   | "entry-file"
-  /** A file the manifest names as an importable entry point, and what it exports. */
+  /** A file the manifest names as an importable entry point, and what it exports outside the published API. */
   | "manifest-entry"
-  /** A file the manifest names as a command, and what it exports. */
+  /** A file the manifest names as a command, and what it exports outside the published API. */
   | "manifest-binary"
   /** A declaration a consumer of a library target can name. */
   | "published-api"
@@ -168,6 +167,7 @@ function childrenOf(held: Inventory): ReadonlyMap<string, readonly InventorySymb
  * is a root with everything its module exports: each name of the module's export
  * table, and where a name is a re-export, every link of the chain to the declaration
  * it carries, so a re-exported declaration is a root of the file that publishes it.
+ * In a library, what a published file exports is rooted by the published API alone.
  * A file a runtime executes without reading its exports, a test file or a worker, is
  * a root by itself.
  */
@@ -198,14 +198,19 @@ export function roots<Brand>(
 
   const published: SourceFile[] = [];
   const publishes = (entry: ManifestEntry): boolean =>
+    options.publishedAPI &&
     entry.published &&
     (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
+  for (const entry of options.manifest.entries) {
+    if (publishes(entry)) {
+      published.push(...files.named(entry.path));
+    }
+  }
+  const publishedNames = new Set(published.map((file) => file.fileName));
   for (const entry of options.manifest.entries) {
     for (const file of files.named(entry.path)) {
-      enter(file, entry.role === "run" ? "manifest-binary" : "manifest-entry", entry.member, true);
-      if (options.publishedAPI && publishes(entry)) {
-        published.push(file);
-      }
+      const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+      enter(file, kind, entry.member, !publishedNames.has(file.fileName));
     }
   }
   for (const pattern of options.entryFiles) {