@cplieger/deadset-ts 8.0.0-dev.8 → 8.0.0-dev.9

package/dist/src/{workspace-programs.js → load/workspace-programs.js}

@@ -7,24 +7,20 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
-import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, resolvePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { PRODUCT } from "./product.js";
+import { dirnamePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { PRODUCT } from "../product.js";
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 /**
- * The options a configuration's program is built with: its own, less the ones that
- * lay out an emitted program's inputs and outputs, and with `paths` read against the
- * effective `baseUrl` as {@link baseUrlPaths} states. The analysis emits nothing, and a
- * member's source is outside the importer's root directory by construction, which
- * the compiler refuses under such a layout.
+ * The options a configuration's program is built with: the plan's, less the ones that lay
+ * out an emitted program's inputs and outputs. The analysis emits nothing, and a member's
+ * source is outside the importer's root directory by construction, which the compiler
+ * refuses under such a layout.
  */
-function analysisOptions(parsed) {
-    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
-    const paths = baseUrlPaths(parsed.options);
-    const options = paths === undefined ? kept : { ...kept, paths };
-    return composite === true ? { ...options, declaration: true } : options;
+function analysisOptions(options) {
+    const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = options;
+    return composite === true ? { ...kept, declaration: true } : kept;
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -75,11 +71,12 @@ function configurationOf(engine, host, reading) {
     if (reason !== undefined) {
         return { kind: "unread", reason };
     }
-    const { options, projectReferences: references = [] } = reading.parsed;
+    const { options } = reading;
+    const references = reading.parsed.projectReferences ?? [];
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
-    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {
@@ -126,11 +123,11 @@ function configurationOf(engine, host, reading) {
             };
         }
     }
-    return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+    return { kind: "configuration", value };
 }
 /** The program one configuration is built as, under the answers it holds so far. */
 function programOf(engine, reading) {
-    const compilerOptions = analysisOptions(reading.parsed);
+    const compilerOptions = analysisOptions(reading.options);
     const references = reading.parsed.projectReferences ?? [];
     const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
     return {
@@ -217,6 +214,17 @@ function scan(engine, program, reading, resolver) {
     });
     return added;
 }
+function configurationText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+/** One configuration value as the snapshot holds it, beside the configuration it stands for. */
+export function writtenConfiguration(host, configFile, value) {
+    return {
+        kind: "configuration",
+        file: writtenPath(host, configFile),
+        text: configurationText(value),
+    };
+}
 /**
  * Answers the member imports of every reading `build` describes, round by round, all
  * the readings still adding answers built in one snapshot per round. A reading `build`
@@ -258,27 +266,14 @@ function readRounds(engine, readings, resolver, build) {
  * the rounds go on over each reading's configuration, which reads them, for the imports
  * only they make.
  */
-export function workspacePrograms(engine, host, configFiles, resolver) {
-    const readings = configFiles.flatMap((configFile) => {
-        let parsed;
-        try {
-            parsed = engine.parseConfigFile(configFile);
-        }
-        catch {
-            // A configuration that does not read is opened as a project, which states why.
-            return [];
-        }
-        return [
-            {
-                configFile,
-                parsed,
-                entries: [],
-                seen: new Set(),
-                bound: new Map(),
-                unresolved: [],
-            },
-        ];
-    });
+export function workspacePrograms(engine, host, configurations, resolver) {
+    const readings = configurations.map((configuration) => ({
+        ...configuration,
+        entries: [],
+        seen: new Set(),
+        bound: new Map(),
+        unresolved: [],
+    }));
     readRounds(engine, readings, resolver, (reading) => ({
         kind: "program",
         ...programOf(engine, reading),
@@ -286,7 +281,9 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
     if (engine.readsComponents) {
         readRounds(engine, readings, resolver, (reading) => {
             const one = configurationOf(engine, host, reading);
-            return one.kind === "configuration" ? one : undefined;
+            return one.kind === "configuration"
+                ? writtenConfiguration(host, reading.configFile, one.value)
+                : undefined;
         });
     }
     const programs = new Map();

package/dist/src/{workspace-resolution.js → load/workspace-resolution.js}

@@ -6,37 +6,17 @@
  * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
-import { gitIgnored } from "./git-ignore.js";
-import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
-import { satisfies } from "./version-range.js";
-import { isRecord } from "./json-document.js";
-import { INSTALLED_PACKAGES, MANIFEST, manifestAt } from "./fs/manifest.js";
+import { packageOfSpecifier } from "../dependencies.js";
+import { gitIgnored } from "../git-ignore.js";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { satisfies } from "../version-range.js";
+import { isRecord } from "../json-document.js";
+import { MANIFEST } from "../fs/manifest.js";
+import { dependencySpecifiers, installedPackage, manifestsAbove, } from "./module-lookup.js";
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
 const LEGACY_MEMBERS = ["types", "typings", "module", "main"];
-/** The dependency members a manifest declares other packages under. */
-const DEPENDENCY_MEMBERS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
-/** The package name a bare specifier names, or `undefined` for any other specifier. */
-export function packageNameOf(specifier) {
-    if (specifier === "" ||
-        specifier.startsWith(".") ||
-        specifier.startsWith("#") ||
-        isAbsolutePath(specifier) ||
-        specifier.includes(":")) {
-        return undefined;
-    }
-    const [first, second] = specifier.split("/");
-    if (specifier.startsWith("@")) {
-        return second === undefined || second === "" ? undefined : `${first ?? ""}/${second}`;
-    }
-    return first;
-}
 function inside(dir, path) {
     return relativePath(dir, path) !== undefined;
 }
@@ -139,46 +119,32 @@ function dependsOn(specifier, member, fromDir) {
 /** The member imports of one workspace, read from the members' sources. */
 export function workspaceResolver(host, workspace) {
     const links = new Map();
-    /** The directory `node_modules/<name>` names from one directory, links followed. */
+    /** The directory the package `name` installed for one directory is, links followed. */
     const linkedFrom = (name, dir) => {
         const key = `${name}\u0000${dir}`;
-        if (links.has(key)) {
-            return links.get(key);
-        }
-        const candidate = joinPath(dir, INSTALLED_PACKAGES, name);
-        let found;
-        if (host.kindOf(candidate) === "absent") {
-            const up = dirnamePath(dir);
-            found = up === dir ? undefined : linkedFrom(name, up);
-        }
-        else {
+        if (!links.has(key)) {
+            const installed = installedPackage(host, dir, name);
+            let found;
             try {
-                found = host.realPath(candidate);
+                found = installed === undefined ? undefined : host.realPath(installed);
             }
             catch {
                 found = undefined;
             }
+            links.set(key, found);
         }
-        links.set(key, found);
-        return found;
+        return links.get(key);
     };
     const root = workspace.members[0]?.dir;
     const ignored = root === undefined ? () => false : gitIgnored(host, root);
     const manifests = new Map();
     /** The nearest manifest at or above one directory, up to the workspace's root. */
     const nearestManifest = (dir) => {
-        if (manifests.has(dir)) {
-            return manifests.get(dir);
+        if (!manifests.has(dir)) {
+            const [nearest] = manifestsAbove(host, dir, root ?? dir);
+            manifests.set(dir, nearest);
         }
-        const manifest = manifestAt(host, dir);
-        const up = dirnamePath(dir);
-        const found = manifest !== undefined
-            ? { dir, manifest }
-            : up === dir || root === undefined || !inside(root, up)
-                ? undefined
-                : nearestManifest(up);
-        manifests.set(dir, found);
-        return found;
+        return manifests.get(dir);
     };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
@@ -194,11 +160,7 @@ export function workspaceResolver(host, workspace) {
         // A package below the root that no workspace lists depends on a member as a member does.
         const owner = scope ?? nearestManifest(fromDir);
         const manifest = owner?.manifest;
-        const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
-            const held = manifest?.[field];
-            const specifier = isRecord(held) ? held[name] : undefined;
-            return typeof specifier === "string" ? [specifier] : [];
-        });
+        const declared = (manifest === undefined ? [] : dependencySpecifiers(manifest, name)).filter((specifier) => typeof specifier === "string");
         const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
@@ -284,11 +246,11 @@ export function workspaceResolver(host, workspace) {
         workspace,
         sourceOf,
         names: (specifier) => {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             return name !== undefined && workspace.named.has(name);
         },
         resolve(specifier, fromDir, conditions, answered) {
-            const name = packageNameOf(specifier);
+            const name = packageOfSpecifier(specifier);
             const candidates = name === undefined ? undefined : workspace.named.get(name);
             if (name === undefined || candidates === undefined) {
                 return { kind: "default" };

package/dist/src/{workspace-run.js → load/workspace-run.js}

@@ -4,7 +4,7 @@
  * the files each configuration holds only for their references, and the entry points
  * the members' manifests name. A target in no workspace reads none of it.
  */
-import { relativePath } from "./paths.js";
+import { relativePath } from "../paths.js";
 import { findWorkspace, referenceOnlyIn } from "./workspace.js";
 import { memberEntries, targetManifestIn } from "./workspace-manifests.js";
 import { workspacePrograms, } from "./workspace-programs.js";
@@ -42,16 +42,17 @@ function unbuildableReason(reading, referenceOnly, targetRoot) {
  * The workspace the target at `targetRoot` sits in, read for the configurations named,
  * or `undefined` where the target sits in none.
  */
-export function workspaceRun(engine, host, targetRoot, configFiles, manifest) {
+export function workspaceRun(engine, host, targetRoot, configurations, manifest) {
     const workspace = findWorkspace(host, targetRoot, (configFile) => layoutOf(engine, configFile));
     if (workspace === undefined) {
         return undefined;
     }
     const resolver = workspaceResolver(host, workspace);
-    const read = workspacePrograms(engine, host, configFiles, resolver);
+    const read = workspacePrograms(engine, host, configurations, resolver);
     const readings = new Map(read.readings.map((reading) => [reading.configFile, reading]));
     const referenceOnly = (configFile, compiled = []) => referenceOnlyIn(workspace, new Set([...(readings.get(configFile)?.fileNames ?? []), ...compiled]));
     return {
+        workspace,
         programs: read.programs,
         componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) => componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }]),
         unbuildable: (configFile) => {

package/dist/src/{workspace.js → load/workspace.js}

@@ -1,20 +1,19 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
-import { DiscoveryError, isConfigFile } from "./discover.js";
+import { isConfigFile } from "./discover.js";
+import { failureExit } from "../failure.js";
 import { commonDirectory } from "./emit-map.js";
-import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { isRecord } from "./json-document.js";
-import { directoriesIn, filesIn, repositoryOf } from "./fs/tree.js";
-import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "./fs/manifest.js";
-import { braceExpanded, pathMatches, segmentMatches } from "./text/glob.js";
-import { yamlKey } from "./text/yaml.js";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { directoriesIn, filesIn, repositoryOf } from "../fs/tree.js";
+import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "../fs/manifest.js";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.js";
+import { yamlKey } from "../text/yaml.js";
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
 /** The patterns one directory declares a workspace with, or `undefined` where it declares none. */
 function declarationAt(host, dir) {
@@ -27,7 +26,7 @@ function declarationAt(host, dir) {
         const listed = read.kind === "value" ? read.value : undefined;
         if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
             const reason = read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
-            throw new DiscoveryError(`${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings`, []);
+            throw failureExit("no-program", `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`);
         }
         return { file: pnpm, patterns: listed };
     }
@@ -38,7 +37,7 @@ function declarationAt(host, dir) {
     const declared = manifest["workspaces"];
     const list = isRecord(declared) ? declared["packages"] : declared;
     if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-        throw new DiscoveryError(`${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`, []);
+        throw failureExit("no-program", `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`);
     }
     return { file: joinPath(dir, MANIFEST), patterns: list };
 }
@@ -201,9 +200,10 @@ function nearestDeclaration(host, targetRoot) {
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
-export function findWorkspace(host, targetRoot, parse) {
+export function findWorkspace(host, targetRoot, parse, known) {
     const declared = nearestDeclaration(host, targetRoot);
     if (declared === undefined) {
         return undefined;
@@ -212,6 +212,9 @@ export function findWorkspace(host, targetRoot, parse) {
         !namesDirectory(declared.root, declared.patterns, declared.highestPackage)) {
         return undefined;
     }
+    if (known?.root === declared.root) {
+        return known;
+    }
     const members = [];
     for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
         const manifest = manifestAt(host, dir);
@@ -249,6 +252,7 @@ export function findWorkspace(host, targetRoot, parse) {
         return found;
     };
     return {
+        root: declared.root,
         members,
         named,
         memberOf: (path) => {

package/dist/src/outside-tests.js

@@ -8,7 +8,7 @@
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
-import { emittedFrom } from "./emit-map.js";
+import { emittedFrom } from "./load/emit-map.js";
 import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
 import { renderPosition } from "./position.js";

package/dist/src/run.js

@@ -1,11 +1,11 @@
 import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.js";
 import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "./config.js";
-import { DiscoveryError, renderDiagnostic } from "./discover.js";
-import { readTargetDocument, TargetDocumentError } from "./fs/document.js";
+import { readTargetDocument } from "./fs/document.js";
 import { joinPath, resolvePath } from "./paths.js";
-import { readScope, ScopeError, scopeForDir } from "./scope.js";
-import { SetupError, setupLine } from "./setup-failure.js";
+import { renderDiagnostic } from "./load/diagnostics.js";
+import { FailureExit, failureLines, productFault } from "./failure.js";
+import { readScope, scopeForDir } from "./scope.js";
 import { UsageError } from "./usage.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
@@ -106,13 +106,8 @@ function documentAt(host, label) {
 function repositoryAt(host, target) {
     const label = joinPath(target, REPOSITORY_DOCUMENT);
     const root = resolvePath(host.workingDirectory(), target);
-    try {
-        const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label);
-        return text === undefined ? undefined : { text, label };
-    }
-    catch (error) {
-        throw error instanceof TargetDocumentError ? new UsageError(error.message) : error;
-    }
+    const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label, (named, reason) => new UsageError(`${named}: ${reason}`));
+    return text === undefined ? undefined : { text, label };
 }
 /**
  * The configuration sources one invocation carries: the repository configuration at
@@ -202,29 +197,28 @@ function invoke(verb, own, args, streams, openClient) {
         return refuse(error, streams.err);
     }
 }
-/** Turns one refusal into the exit code the Contract's table gives it. */
+/**
+ * Turns one refusal into the exit code the Contract's table gives it. An error no class names
+ * is a fault of this analyzer, printed with its stack for the maintainers it asks the user to
+ * report it to.
+ */
 function refuse(error, err) {
     if (error instanceof UsageError) {
         diagnose(err, error.message);
         err.write(USAGE);
         return EXIT_USAGE;
     }
-    if (error instanceof DiscoveryError) {
-        for (const diagnostic of error.diagnostics) {
-            err.write(`${renderDiagnostic(diagnostic)}\n`);
+    if (!(error instanceof FailureExit)) {
+        if (error instanceof Error && error.stack !== undefined) {
+            err.write(`${error.stack}\n`);
         }
-        diagnose(err, error.message);
-        return EXIT_FAILURE;
+        return refuse(productFault(`meets an error none of its classes names: ${message(error)}`), err);
     }
-    if (error instanceof SetupError) {
-        for (const failure of error.failures) {
-            err.write(`${setupLine(failure)}\n`);
-        }
-        return EXIT_FAILURE;
+    for (const diagnostic of error.diagnostics) {
+        err.write(`${renderDiagnostic(diagnostic)}\n`);
     }
-    if (error instanceof ScopeError || error instanceof TargetDocumentError) {
-        diagnose(err, error.message);
-        return EXIT_FAILURE;
+    for (const line of failureLines(error.failures)) {
+        err.write(`${line}\n`);
     }
-    throw error;
+    return EXIT_FAILURE;
 }

package/dist/src/scope.js

@@ -1,6 +1,8 @@
 import { SCOPE_SCHEMA } from "./contract/config.generated.js";
 import { dotted, locatedFault, placeIn, readStrict, StrictJSONError } from "./json-document.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { MARKERS } from "./load/discover.js";
+import { failureExit } from "./failure.js";
 import { message } from "./product.js";
 import { firstRefusal } from "./schema.js";
 import { UsageError } from "./usage.js";
@@ -14,23 +16,13 @@ const MAX_DOCUMENT_LENGTH = 1 << 20;
  * so a document past the bound is past it within these.
  */
 const MAX_DOCUMENT_BYTES = 3 * (MAX_DOCUMENT_LENGTH + 1);
-/**
- * A scope that cannot be read as one. It ends the run with the failure code: the run
- * could not learn what to analyze, so it produced no answer.
- */
-export class ScopeError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ScopeError";
-    }
-}
 function refusal(file, place, reason) {
-    return new ScopeError(`scope: ${file}: ${place === "" ? "" : `${place}: `}${reason}`);
+    return new UsageError(`scope: ${file}: ${place === "" ? "" : `${place}: `}${reason}`);
 }
 /**
  * Decodes the scope document at `file`, held to the Contract's scope schema, a relative
- * path resolved against the document's own directory. A document that cannot be read is
- * a usage error, one that is refused a scope error. `workspace` is read by Go consumers
+ * path resolved against the document's own directory. A document that cannot be read or is
+ * refused is a usage error, as any document the invocation names. `workspace` is read by Go consumers
  * alone: a TypeScript project resolves the target through its own compiler configuration.
  */
 export function readScope(host, file) {
@@ -43,7 +35,7 @@ export function readScope(host, file) {
         throw new UsageError(`scope: ${file}: ${message(error)}`);
     }
     if (text.length > MAX_DOCUMENT_LENGTH) {
-        throw new ScopeError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
+        throw new UsageError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
     }
     let value;
     try {
@@ -67,15 +59,15 @@ export function readScope(host, file) {
     });
     return { target: moduleOf(declared.target), consumers: (declared.consumers ?? []).map(moduleOf) };
 }
-/** The single-package scope one directory is, when no scope document is given. */
+/**
+ * The single-package scope one directory is, when no scope document is given. A target that is
+ * no directory holds no program.
+ */
 export function scopeForDir(host, dir) {
     const path = resolvePath(host.workingDirectory(), dir);
     const kind = host.kindOf(path);
-    if (kind === "absent") {
-        throw new ScopeError(`scope: ${path} does not exist`);
-    }
     if (kind !== "directory") {
-        throw new ScopeError(`scope: ${path} is not a directory`);
+        throw failureExit("no-program", `the target ${path} ${kind === "absent" ? "does not exist" : "is not a directory"}, so it holds no compiler configuration, no file named ${MARKERS.join(", ")}: name the directory that holds one`);
     }
     return { target: { id: "", path }, consumers: [] };
 }

package/dist/src/session.js

@@ -1,6 +1,5 @@
 import { API, SymbolFlags } from "@typescript/native/sync";
 import { componentLayer, mapperManifest } from "./component-layer.js";
-import { DiscoveryError } from "./discover.js";
 import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
 import { MANIFEST } from "./fs/manifest.js";
@@ -253,14 +252,13 @@ function projectsOf(snapshot, built, written) {
     return opened;
 }
 /**
- * Runs `visit` over every project the compiler configurations name, inside one never updated
- * snapshot of one client, and answers in their order. A configuration `programs` describes is
- * built as that program, or opened from the configuration it writes. One the snapshot holds
- * nothing for ends the run under `"refuse"` and is named in the result under `"record"`.
- * `first` runs over every opened project before the first visit and `last` after the last,
- * both while the client answers; the snapshot and the client are then released.
+ * Opens every project the compiler configurations name in one never updated snapshot of one
+ * client, and hands them to `use` while the client answers; the snapshot and the client are
+ * then released. A configuration `options.programs` describes is built as that program, or
+ * opened from the configuration it writes. One the snapshot holds nothing for has no view.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined, first = () => undefined) {
+export function openSession(engine, configFiles, options, use) {
+    const programs = options.programs ?? new Map();
     try {
         const built = [];
         const params = [];
@@ -282,30 +280,13 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
             const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
             const views = [];
-            const missing = [];
             for (const configFile of configFiles) {
                 const project = opened.get(configFile);
-                if (project === undefined) {
-                    if (unopened === "refuse") {
-                        throw new DiscoveryError(`${configFile} opened no project`, []);
-                    }
-                    missing.push(configFile);
-                    continue;
+                if (project !== undefined) {
+                    views.push(viewOf(project, configFile, engine, log));
                 }
-                views.push(viewOf(project, configFile, engine, log));
             }
-            first(views.map((view) => ({
-                configFile: view.configFile,
-                fileNames: () => view.ownSourceFiles().map((file) => file.fileName),
-            })));
-            const projects = views.map((view) => visit(view));
-            last();
-            return {
-                projects,
-                unopened: missing,
-                timing: engine.getTimingInfo(),
-                unanswered: log.questions,
-            };
+            return use({ views }, () => log.questions);
         }
         finally {
             snapshot.dispose();
@@ -315,3 +296,16 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
         engine.close();
     }
 }
+/**
+ * Runs `visit` over the project {@link openSession} opens for each configuration, and answers
+ * in their order; a configuration the snapshot opens nothing for throws before any visit.
+ */
+export function runSession(engine, configFiles, visit) {
+    return openSession(engine, configFiles, {}, (opened) => {
+        const unopened = configFiles.find((configFile) => !opened.views.some((view) => view.configFile === configFile));
+        if (unopened !== undefined) {
+            throw new Error(`${unopened} opened no project`);
+        }
+        return { projects: opened.views.map((view) => visit(view)), timing: engine.getTimingInfo() };
+    });
+}

package/dist/src/source-files.js

@@ -3,7 +3,7 @@
  * in a document or a string names one: as the file itself, or as a file the
  * compiler emits from it.
  */
-import { commonDirectory, emittedFrom } from "./emit-map.js";
+import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";