carveout 0.2.0 → 0.3.1

package/dist/src/extract.js

@@ -0,0 +1,31 @@
+/**
+ * `carveout/extract`: the stub extractor and the fixture compile a cut
+ * runs, for a platform that calls them itself (sandbox-factory's worker,
+ * whose `slice/*`, `compiler-config.ts` and `package-registry.ts` these
+ * were forked from; NOTICE.md lists where they differ now).
+ *
+ * - `extract/hash.ts`: `sha256`, `gitBlobId`, `gitFileMode`.
+ * - `extract/typescript.ts`: the boundary extractor and its parts
+ *   (`extractTypeScriptBoundary`, `boundedHost`, `extractionOptions`,
+ *   `filterDeclaration`, `sanitizeDeclaration`, `NODE_BUILTINS`,
+ *   `isNodeBuiltin`, `isScriptPath`, `isDataPath`, `declarationPathFor`).
+ * - `extract/fixture.ts`: `compileFixture`, `packageUses`,
+ *   `packageModules`, `packageShim`, `SHIM_PATH`, `UNTYPED_PACKAGE_OPTIONS`,
+ *   `UNTYPED_PACKAGE_CODES`, `DIAGNOSTICS_MAX`.
+ * - `extract/package-types.ts`: `npmPackageTypes` (npm, scripts off) and
+ *   the `PackageTypesFetcher` contract `analyse` takes.
+ * - `extract/compiler-config.ts`: `loadConfig`, `nearestCompilerOptions`,
+ *   `workspacePackages`, `workspaceModuleResolver`, `exportTarget`,
+ *   `pnpmWorkspacePatterns`.
+ * - `extract/package-registry.ts`: `packageRegistries`,
+ *   `isPublicRegistry`, `lockIntegrities`, `publicByIntegrity`.
+ *
+ * Only `npmPackageTypes` starts a process; `publicByIntegrity` reads the
+ * public registry over HTTPS.
+ */
+export * from "./extract/hash.js";
+export * from "./extract/typescript.js";
+export * from "./extract/fixture.js";
+export * from "./extract/package-types.js";
+export * from "./extract/compiler-config.js";
+export * from "./extract/package-registry.js";

package/dist/src/graph.d.ts

@@ -25,9 +25,12 @@ export declare const IGNORED_DIRECTORIES: readonly string[];
 export declare const GRAPH_FILES_MAX = 50000;
 /**
  * The checkout's files, `/`-separated and sorted: what Git tracks plus
- * untracked files it does not ignore, or every file outside Git.
+ * untracked files it does not ignore, or every file outside Git. With
+ * `git: false`, every file outside the ignored folders, and Git is not run.
  */
-export declare function listFiles(root: string): string[];
+export declare function listFiles(root: string, options?: {
+    readonly git?: boolean;
+}): string[];
 /**
  * The checkout's files a Vite glob's patterns match, as the bundler reads
  * them: relative to the importing file's folder, or to the root for a
@@ -54,6 +57,8 @@ export interface GraphOptions {
     readonly followWorkspaces?: boolean;
     /** Files read as if the checkout had none (the owner's acceptance tests). */
     readonly unseen?: readonly string[];
+    /** The checkout's files, as the caller lists them; by default `listFiles`. */
+    readonly files?: readonly string[];
 }
 /** What `walkGraph` takes: the walk's options and the graph's. */
 export type WalkOptions = ReachOptions & GraphOptions;

package/dist/src/graph.js

@@ -58,11 +58,14 @@ function walk(root, directory = "", into = []) {
 }
 /**
  * The checkout's files, `/`-separated and sorted: what Git tracks plus
- * untracked files it does not ignore, or every file outside Git.
+ * untracked files it does not ignore, or every file outside Git. With
+ * `git: false`, every file outside the ignored folders, and Git is not run.
  */
-export function listFiles(root) {
+export function listFiles(root, options = {}) {
     let listed;
     try {
+        if (options.git === false)
+            throw new Error("Git is not to be run.");
         listed = execFileSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] })
             .toString("utf8")
             .split("\0")
@@ -140,9 +143,9 @@ export function buildGraph(root, listed, options = {}) {
  */
 export function walkGraph(root, entryPoints, budget, options = {}) {
     const started = performance.now();
-    const { followWorkspaces, unseen, ...rest } = options;
+    const { followWorkspaces, unseen, files: listed, ...rest } = options;
     const hidden = new Set(unseen ?? []);
-    const files = listFiles(root).filter((file) => !hidden.has(file));
+    const files = (listed ?? listFiles(root)).filter((file) => !hidden.has(file));
     const graphOptions = followWorkspaces === undefined ? {} : { followWorkspaces };
     const builder = graphBuilder(root, files, performance.now() - started, graphOptions);
     const absoluteRoot = resolve(root);

package/dist/src/project/mock-runtime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The recording mock runtime every generated module and mock package
+ * imports (`carveout/mock.js`), and its declarations (`carveout/mock.d.ts`),
+ * as text. Pure: no Node module and no compiler.
+ */
+/** The runtime itself, written at the harness's `mock.js`. */
+export declare const MOCK_RUNTIME = "// The recording mock every generated module and package shares.\n//\n// A mock answers any property with another mock, any call with a mock and\n// records the call. It is not thenable, so awaiting one gives the mock\n// back, and it prints as [mock <name>]. Tests can install an implementation\n// for a path with mockImplementation() and read what was called with\n// recordedCalls(). Nothing here reaches a network or a credential.\nconst calls = [];\nconst implementations = new Map();\nconst fixtures = new Map();\nexport function recordedCalls() {\n  return calls.slice();\n}\n/** Clears recorded calls and installed implementations; fixtures stay. */\nexport function resetMocks() {\n  calls.length = 0;\n  implementations.clear();\n}\n/** @param {string} path such as \"module:lib/service.ts.createService\" */\nexport function mockImplementation(path, implementation) {\n  implementations.set(path, implementation);\n}\n/** The task's default behaviour for a path; mockImplementation() overrides it. */\nexport function fixture(path, implementation) {\n  fixtures.set(path, implementation);\n}\nexport function createMock(origin, name = origin) {\n  const target = function mock() {};\n  return new Proxy(target, {\n    get(_target, property) {\n      if (property === \"then\") return undefined;\n      if (property === Symbol.toPrimitive) return () => `[mock ${name}]`;\n      if (property === Symbol.iterator) return function* iterate() {};\n      if (property === \"toJSON\") return () => ({ mock: name });\n      if (typeof property === \"symbol\") return undefined;\n      return createMock(origin, `${name}.${property}`);\n    },\n    apply(_target, _self, args) {\n      calls.push({ name, args });\n      const implementation = implementations.get(name) ?? fixtures.get(name);\n      return implementation === undefined\n        ? createMock(origin, `${name}()`)\n        : implementation(...args);\n    },\n    construct(_target, args) {\n      calls.push({ name: `new ${name}`, args });\n      const implementation =\n        implementations.get(`new ${name}`) ?? fixtures.get(`new ${name}`);\n      return implementation === undefined\n        ? createMock(origin, `${name}#`)\n        : implementation(...args);\n    },\n    has() {\n      return true;\n    },\n  });\n}\n";
+/** Its declarations, written at the harness's `mock.d.ts`. */
+export declare const MOCK_RUNTIME_TYPES = "export interface RecordedCall {\n  readonly name: string;\n  readonly args: readonly unknown[];\n}\nexport function recordedCalls(): RecordedCall[];\nexport function resetMocks(): void;\nexport function mockImplementation(\n  path: string,\n  implementation: (...args: unknown[]) => unknown,\n): void;\nexport function fixture(\n  path: string,\n  implementation: (...args: any[]) => unknown,\n): void;\nexport function createMock(origin: string, name?: string): any;\n";

package/dist/src/project/mock-runtime.js

@@ -0,0 +1,81 @@
+/**
+ * The recording mock runtime every generated module and mock package
+ * imports (`carveout/mock.js`), and its declarations (`carveout/mock.d.ts`),
+ * as text. Pure: no Node module and no compiler.
+ */
+/** The runtime itself, written at the harness's `mock.js`. */
+export const MOCK_RUNTIME = `// The recording mock every generated module and package shares.
+//
+// A mock answers any property with another mock, any call with a mock and
+// records the call. It is not thenable, so awaiting one gives the mock
+// back, and it prints as [mock <name>]. Tests can install an implementation
+// for a path with mockImplementation() and read what was called with
+// recordedCalls(). Nothing here reaches a network or a credential.
+const calls = [];
+const implementations = new Map();
+const fixtures = new Map();
+export function recordedCalls() {
+  return calls.slice();
+}
+/** Clears recorded calls and installed implementations; fixtures stay. */
+export function resetMocks() {
+  calls.length = 0;
+  implementations.clear();
+}
+/** @param {string} path such as "module:lib/service.ts.createService" */
+export function mockImplementation(path, implementation) {
+  implementations.set(path, implementation);
+}
+/** The task's default behaviour for a path; mockImplementation() overrides it. */
+export function fixture(path, implementation) {
+  fixtures.set(path, implementation);
+}
+export function createMock(origin, name = origin) {
+  const target = function mock() {};
+  return new Proxy(target, {
+    get(_target, property) {
+      if (property === "then") return undefined;
+      if (property === Symbol.toPrimitive) return () => \`[mock \${name}]\`;
+      if (property === Symbol.iterator) return function* iterate() {};
+      if (property === "toJSON") return () => ({ mock: name });
+      if (typeof property === "symbol") return undefined;
+      return createMock(origin, \`\${name}.\${property}\`);
+    },
+    apply(_target, _self, args) {
+      calls.push({ name, args });
+      const implementation = implementations.get(name) ?? fixtures.get(name);
+      return implementation === undefined
+        ? createMock(origin, \`\${name}()\`)
+        : implementation(...args);
+    },
+    construct(_target, args) {
+      calls.push({ name: \`new \${name}\`, args });
+      const implementation =
+        implementations.get(\`new \${name}\`) ?? fixtures.get(\`new \${name}\`);
+      return implementation === undefined
+        ? createMock(origin, \`\${name}#\`)
+        : implementation(...args);
+    },
+    has() {
+      return true;
+    },
+  });
+}
+`;
+/** Its declarations, written at the harness's `mock.d.ts`. */
+export const MOCK_RUNTIME_TYPES = `export interface RecordedCall {
+  readonly name: string;
+  readonly args: readonly unknown[];
+}
+export function recordedCalls(): RecordedCall[];
+export function resetMocks(): void;
+export function mockImplementation(
+  path: string,
+  implementation: (...args: unknown[]) => unknown,
+): void;
+export function fixture(
+  path: string,
+  implementation: (...args: any[]) => unknown,
+): void;
+export function createMock(origin: string, name?: string): any;
+`;

package/dist/src/project/paths.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Paths inside a generated folder, as `/`-separated strings: pure, with no
+ * Node module and no compiler, so the pseudonyms entry (`carveout/pseudonyms`)
+ * can use them in a browser.
+ */
+export declare function dirnameOf(path: string): string;
+/** `../lib/service.js` from `src/app.ts` to `lib/service.ts`. */
+export declare function relativeSpecifier(fromFile: string, toFile: string): string;
+/** The emitted JavaScript path of a TypeScript source path. */
+export declare function runtimePath(path: string): string;

package/dist/src/project/paths.js

@@ -0,0 +1,35 @@
+/**
+ * Paths inside a generated folder, as `/`-separated strings: pure, with no
+ * Node module and no compiler, so the pseudonyms entry (`carveout/pseudonyms`)
+ * can use them in a browser.
+ */
+export function dirnameOf(path) {
+    const index = path.lastIndexOf("/");
+    return index === -1 ? "" : path.slice(0, index);
+}
+/** `../lib/service.js` from `src/app.ts` to `lib/service.ts`. */
+export function relativeSpecifier(fromFile, toFile) {
+    const from = dirnameOf(fromFile).split("/").filter(Boolean);
+    const to = toFile.split("/").filter(Boolean);
+    let common = 0;
+    while (common < from.length &&
+        common < to.length - 1 &&
+        from[common] === to[common])
+        common += 1;
+    const up = from.length - common;
+    const rest = to.slice(common).join("/");
+    const prefix = up === 0 ? "./" : "../".repeat(up);
+    return `${prefix}${runtimePath(rest)}`;
+}
+/** The emitted JavaScript path of a TypeScript source path. */
+export function runtimePath(path) {
+    if (path.endsWith(".d.ts"))
+        return `${path.slice(0, -5)}.js`;
+    if (path.endsWith(".mts"))
+        return `${path.slice(0, -4)}.mjs`;
+    if (path.endsWith(".cts"))
+        return `${path.slice(0, -4)}.cjs`;
+    if (path.endsWith(".tsx") || path.endsWith(".ts"))
+        return `${path.replace(/\.tsx?$/, "")}.js`;
+    return path;
+}

package/dist/src/project/project.d.ts

@@ -21,6 +21,9 @@ import { type VitestSettings } from "./vitest-config.js";
 import type { BoundaryContract, BoundarySymbol, SliceManifest } from "../slice/manifest.js";
 import { type Toolchain } from "./build.js";
 import { type PathClass, type ResolvedDependency } from "./provenance.js";
+import { MOCK_RUNTIME_TYPES } from "./mock-runtime.js";
+import { dirnameOf, relativeSpecifier, runtimePath } from "./paths.js";
+export { MOCK_RUNTIME_TYPES, dirnameOf, relativeSpecifier, runtimePath };
 export declare const HARNESS_DIR = "carveout";
 export declare const MOCKS_DIR = "carveout/packages";
 /** Mocks of modules that are no package (`virtual:build-info`), with the loader's map of them. */
@@ -194,11 +197,6 @@ export declare function runtimeKindOf(symbol: BoundarySymbol): "value" | "type"
  * it (harmless for a type), a test must not assert it.
  */
 export declare function guessedFromImport(symbol: BoundarySymbol): boolean;
-export declare function dirnameOf(path: string): string;
-/** `../lib/service.js` from `src/app.ts` to `lib/service.ts`. */
-export declare function relativeSpecifier(fromFile: string, toFile: string): string;
-/** The emitted JavaScript path of a TypeScript source path. */
-export declare function runtimePath(path: string): string;
 /** What `npm run dev` and `npm test` run once the project is built. */
 export declare const SANDBOX_RUN_ARGV: {
     readonly dev: readonly ["node", "--env-file=carveout.env", "--import=./carveout/assets.js", string];
@@ -219,7 +217,6 @@ export declare function enumMembers(declaration: string): {
     name: string;
     value: string | number;
 }[] | null;
-export declare const MOCK_RUNTIME_TYPES = "export interface RecordedCall {\n  readonly name: string;\n  readonly args: readonly unknown[];\n}\nexport function recordedCalls(): RecordedCall[];\nexport function resetMocks(): void;\nexport function mockImplementation(\n  path: string,\n  implementation: (...args: unknown[]) => unknown,\n): void;\nexport function fixture(\n  path: string,\n  implementation: (...args: any[]) => unknown,\n): void;\nexport function createMock(origin: string, name?: string): any;\n";
 /**
  * Module declarations for the specifiers a slice reads names of, each
  * exporting those names as values and types, as the worker writes them for

package/dist/src/project/project.js

@@ -26,6 +26,9 @@ import { TEST_PATH_PATTERN, isTestPath, testRunnerOf, } from "../slice/reach.js"
 import { GLOBAL_CALL_SOURCE, usesTestGlobals } from "./runner.js";
 import { scanSecrets, secretBlockers } from "./secrets.js";
 import { moduleSpecifiers, rewriteSpecifiers } from "../specifiers.js";
+import { MOCK_RUNTIME, MOCK_RUNTIME_TYPES } from "./mock-runtime.js";
+import { dirnameOf, relativeSpecifier, runtimePath } from "./paths.js";
+export { MOCK_RUNTIME_TYPES, dirnameOf, relativeSpecifier, runtimePath };
 export const HARNESS_DIR = "carveout";
 export const MOCKS_DIR = `${HARNESS_DIR}/packages`;
 /** Mocks of modules that are no package (`virtual:build-info`), with the loader's map of them. */
@@ -334,36 +337,6 @@ export function guessedFromImport(symbol) {
 // this pattern finds only the named bindings of an import, for the mock
 // packages' exports.
 const NAMED_IMPORT = /\bimport\s+(type\s+)?(?:[\w$]+\s*,\s*)?\{([^}]*)\}\s*from\s*['"]([^'"\n]+)['"]/g;
-export function dirnameOf(path) {
-    const index = path.lastIndexOf("/");
-    return index === -1 ? "" : path.slice(0, index);
-}
-/** `../lib/service.js` from `src/app.ts` to `lib/service.ts`. */
-export function relativeSpecifier(fromFile, toFile) {
-    const from = dirnameOf(fromFile).split("/").filter(Boolean);
-    const to = toFile.split("/").filter(Boolean);
-    let common = 0;
-    while (common < from.length &&
-        common < to.length - 1 &&
-        from[common] === to[common])
-        common += 1;
-    const up = from.length - common;
-    const rest = to.slice(common).join("/");
-    const prefix = up === 0 ? "./" : "../".repeat(up);
-    return `${prefix}${runtimePath(rest)}`;
-}
-/** The emitted JavaScript path of a TypeScript source path. */
-export function runtimePath(path) {
-    if (path.endsWith(".d.ts"))
-        return `${path.slice(0, -5)}.js`;
-    if (path.endsWith(".mts"))
-        return `${path.slice(0, -4)}.mjs`;
-    if (path.endsWith(".cts"))
-        return `${path.slice(0, -4)}.cjs`;
-    if (path.endsWith(".tsx") || path.endsWith(".ts"))
-        return `${path.replace(/\.tsx?$/, "")}.js`;
-    return path;
-}
 /** What `npm run dev` and `npm test` run once the project is built. */
 export const SANDBOX_RUN_ARGV = {
     dev: [
@@ -504,80 +477,6 @@ function mockRuntimeFor(modulePath, originalModule, symbols, blockers, stubText
         lines.push("export {};");
     return `${lines.join("\n")}\n`;
 }
-const MOCK_RUNTIME = `// The recording mock every generated module and package shares.
-//
-// A mock answers any property with another mock, any call with a mock and
-// records the call. It is not thenable, so awaiting one gives the mock
-// back, and it prints as [mock <name>]. Tests can install an implementation
-// for a path with mockImplementation() and read what was called with
-// recordedCalls(). Nothing here reaches a network or a credential.
-const calls = [];
-const implementations = new Map();
-const fixtures = new Map();
-export function recordedCalls() {
-  return calls.slice();
-}
-/** Clears recorded calls and installed implementations; fixtures stay. */
-export function resetMocks() {
-  calls.length = 0;
-  implementations.clear();
-}
-/** @param {string} path such as "module:lib/service.ts.createService" */
-export function mockImplementation(path, implementation) {
-  implementations.set(path, implementation);
-}
-/** The task's default behaviour for a path; mockImplementation() overrides it. */
-export function fixture(path, implementation) {
-  fixtures.set(path, implementation);
-}
-export function createMock(origin, name = origin) {
-  const target = function mock() {};
-  return new Proxy(target, {
-    get(_target, property) {
-      if (property === "then") return undefined;
-      if (property === Symbol.toPrimitive) return () => \`[mock \${name}]\`;
-      if (property === Symbol.iterator) return function* iterate() {};
-      if (property === "toJSON") return () => ({ mock: name });
-      if (typeof property === "symbol") return undefined;
-      return createMock(origin, \`\${name}.\${property}\`);
-    },
-    apply(_target, _self, args) {
-      calls.push({ name, args });
-      const implementation = implementations.get(name) ?? fixtures.get(name);
-      return implementation === undefined
-        ? createMock(origin, \`\${name}()\`)
-        : implementation(...args);
-    },
-    construct(_target, args) {
-      calls.push({ name: \`new \${name}\`, args });
-      const implementation =
-        implementations.get(\`new \${name}\`) ?? fixtures.get(\`new \${name}\`);
-      return implementation === undefined
-        ? createMock(origin, \`\${name}#\`)
-        : implementation(...args);
-    },
-    has() {
-      return true;
-    },
-  });
-}
-`;
-export const MOCK_RUNTIME_TYPES = `export interface RecordedCall {
-  readonly name: string;
-  readonly args: readonly unknown[];
-}
-export function recordedCalls(): RecordedCall[];
-export function resetMocks(): void;
-export function mockImplementation(
-  path: string,
-  implementation: (...args: unknown[]) => unknown,
-): void;
-export function fixture(
-  path: string,
-  implementation: (...args: any[]) => unknown,
-): void;
-export function createMock(origin: string, name?: string): any;
-`;
 /** Classes Node has and the ES libraries do not, read as both a value and a type. */
 const NODE_CLASSES = [
     "AbortController",

package/dist/src/pseudonyms/carry.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Carrying a change between a version's public names and the repository's:
+ * the reverse path merge-back needs (a submission, made in public names,
+ * as a patch on the repository at the pinned commit), and the forward path
+ * the CI judge needs (a pull request's files, in the repository's names,
+ * as a submission on the version).
+ *
+ * The build's transforms are token-for-token and never add or remove a
+ * line: the name table, import specifiers rewritten to the slice's layout,
+ * mocked packages and environment variables renamed. So a version's file
+ * and the repository's line up line by line, and a change carries by line:
+ *
+ * - A line the change kept is the other side's line at the same place,
+ *   byte for byte. A change that touches nothing carries to the original.
+ * - A line the change added is renamed token by token, first by what the
+ *   two originals' differing lines show the build renamed in this file
+ *   (an import specifier, a package, an environment variable), then by the
+ *   name table. It is refused unless renaming it back gives it again, so
+ *   new text holding a name the side it was written on never shows (the
+ *   repository's own names, in a contribution) cannot pass through.
+ * - A line the change added that imports the sandbox's harness (a mock, a
+ *   stub), which the repository does not have, is refused.
+ *
+ * Pure and platform-neutral: the worker reads the files, the API writes
+ * the pull request.
+ *
+ * Moved here verbatim from sandbox-factory's packages/core/src/sandbox/carry.ts
+ * (commit f31d780), on carveout's alias implementation (`aliases.ts`). One
+ * addition: `aliases` on `ReverseInput`, `ForwardInput` and `projectPathOf`,
+ * so a version built with an older renaming carries back under it
+ * (`ALIASES_V1`, `legacy.ts`).
+ */
+import { type AliasRule, type AliasedFile } from "./aliases.js";
+/**
+ * The renaming a version was built with: how a file is renamed under a
+ * table, and how a table is inverted. carveout's own by default
+ * (`CURRENT_ALIASES`); `ALIASES_V1` for a version the platform built before.
+ */
+export interface AliasImplementation {
+    readonly renameFile: (file: AliasedFile, rules: readonly AliasRule[]) => AliasedFile;
+    readonly invertAliasRules: (rules: readonly AliasRule[]) => AliasRule[];
+}
+/** carveout's renaming (`aliases.ts`). */
+export declare const CURRENT_ALIASES: AliasImplementation;
+/** One file a change touched, on both sides. */
+export interface CarriedFile {
+    /** Where the change was made, and where it lands. */
+    readonly fromPath: string;
+    readonly toPath: string;
+    /** The file before the change on each side; null for a new file. */
+    readonly fromOriginal: string | null;
+    readonly toOriginal: string | null;
+    /** The file after the change, on the side it was made. */
+    readonly edited: string;
+}
+export interface CarryRefusal {
+    /** The path the change was made at. */
+    readonly path: string;
+    readonly reason: string;
+}
+export interface CarriedChange {
+    /** Each changed file at its path on the other side, whole. */
+    readonly files: readonly {
+        readonly path: string;
+        readonly text: string;
+    }[];
+    readonly refused: readonly CarryRefusal[];
+}
+/** How a line of new text is renamed into the other side's names, and back. */
+export interface Renaming {
+    readonly to: (text: string, file: CarriedFile) => string;
+    readonly back: (text: string, file: CarriedFile) => string;
+    /** Whether a path, resolved on the side the change was made, is harness. */
+    readonly isHarness?: (path: string) => boolean;
+}
+/** Splits text into lines, each with its line ending. */
+export declare function linesOf(text: string): string[];
+/**
+ * A line as tokens: string literals whole (a template literal only without
+ * `${`), identifiers, runs of space, single characters. One pass, linear in
+ * the line: a quote that does not close on it is a character of its own.
+ */
+export declare function tokensOf(line: string): string[];
+/**
+ * What the two sides' originals show was renamed in this file: each token
+ * that differs where the lines otherwise line up, from one side to the
+ * other. A token renamed two ways is listed as ambiguous.
+ */
+export declare function learnedRenames(from: readonly string[], to: readonly string[]): {
+    renames: Map<string, string>;
+    ambiguous: Set<string>;
+};
+/**
+ * For each line of `b`, the line of `a` it keeps, or -1 for one the change
+ * added: a longest common subsequence, after the shared head and tail.
+ */
+export declare function keptLines(a: readonly string[], b: readonly string[]): number[];
+/** A relative specifier resolved against the importing file's folder. */
+export declare function resolveRelative(importer: string, specifier: string): string;
+/**
+ * The change carried to the other side, file by file, with what cannot be
+ * carried refused. A refused file is left out of `files`.
+ */
+export declare function carryChange(files: readonly CarriedFile[], renaming: Renaming): CarriedChange;
+export interface ReverseInput {
+    /** The submission's files, at their paths in the version's project. */
+    readonly submitted: readonly {
+        readonly path: string;
+        readonly text: string;
+    }[];
+    /** The version's public file at a project path; null for none. */
+    readonly publicText: (path: string) => string | null;
+    /** The repository's file at the pinned commit; null for none. */
+    readonly repositoryText: (path: string) => string | null;
+    /** The version's name table (`pseudonym.lunox`). */
+    readonly rules: readonly AliasRule[];
+    /** Repository path to project path, for each file the build moved. */
+    readonly renames: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
+    /** The version's harness files (mocks, stubs, tests), at project paths. */
+    readonly harness: readonly string[];
+    /** The renaming the version was built with; carveout's by default. */
+    readonly aliases?: AliasImplementation;
+}
+/**
+ * A submission, made in the version's public names, as whole files on the
+ * repository at the pinned commit: merge-back's reverse path.
+ */
+export declare function reverseSubmission(input: ReverseInput): CarriedChange;
+/**
+ * Where a repository file is in the version's project: where the build
+ * moved it, else where the name table's path rules put it.
+ */
+export declare function projectPathOf(path: string, renames: readonly {
+    readonly from: string;
+    readonly to: string;
+}[], rules: readonly AliasRule[], aliases?: AliasImplementation): string;
+export interface ForwardInput {
+    /** A change's files, at their repository paths. */
+    readonly changed: readonly {
+        readonly path: string;
+        readonly text: string;
+    }[];
+    readonly publicText: (path: string) => string | null;
+    readonly repositoryText: (path: string) => string | null;
+    readonly rules: readonly AliasRule[];
+    readonly renames: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
+    /** The renaming the version was built with; carveout's by default. */
+    readonly aliases?: AliasImplementation;
+}
+/**
+ * A change made in the repository's names, as whole files on the version's
+ * project: the CI judge's forward path. Only files the version has (or its
+ * paths name) are carried; the caller keeps to the editable ones.
+ */
+export declare function forwardChange(input: ForwardInput): CarriedChange;