carveout 0.1.2 → 0.3.0

package/dist/src/pseudonyms/carry.js

@@ -0,0 +1,301 @@
+/**
+ * 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 { invertAliasRules, renameFile } from "./aliases.js";
+/** carveout's renaming (`aliases.ts`). */
+export const CURRENT_ALIASES = { renameFile, invertAliasRules };
+/** More than this many lines changed in one file, and added lines are not matched to kept ones. */
+const MATCH_CELLS = 4_000_000;
+/** Splits text into lines, each with its line ending. */
+export function linesOf(text) {
+    return text === "" ? [] : (text.match(/[^\n]*\n|[^\n]+$/g) ?? []);
+}
+/** Where a string literal opened at `start` closes, past its quote; -1 for none on the line. */
+function literalEnd(line, start) {
+    const quote = line[start];
+    for (let at = start + 1; at < line.length; at += 1) {
+        const char = line[at];
+        if (char === "\\")
+            at += 1;
+        else if (char === quote)
+            return at + 1;
+        else if (char === "\n" || (quote === "`" && char === "$"))
+            return -1;
+    }
+    return -1;
+}
+const IDENTIFIER_START = /[A-Za-z_$]/;
+const IDENTIFIER_PART = /[A-Za-z0-9_$]/;
+const SPACE = /\s/;
+/**
+ * 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 function tokensOf(line) {
+    const tokens = [];
+    // A quote that found no close cannot find one from further on: a later
+    // quote of its kind was either escaped in that scan, which then went on
+    // as a scan from it would, or would have closed it.
+    const unclosed = new Set();
+    let at = 0;
+    while (at < line.length) {
+        const char = line[at];
+        let end = at + 1;
+        if (char === '"' || char === "'" || char === "`") {
+            const close = unclosed.has(char) ? -1 : literalEnd(line, at);
+            if (close > 0)
+                end = close;
+            else
+                unclosed.add(char);
+        }
+        else if (IDENTIFIER_START.test(char))
+            while (end < line.length && IDENTIFIER_PART.test(line[end]))
+                end += 1;
+        else if (SPACE.test(char))
+            while (end < line.length && SPACE.test(line[end]))
+                end += 1;
+        tokens.push(line.slice(at, end));
+        at = end;
+    }
+    return tokens;
+}
+/**
+ * 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 function learnedRenames(from, to) {
+    const renames = new Map();
+    const ambiguous = new Set();
+    from.forEach((line, index) => {
+        const other = to[index];
+        if (other === undefined || other === line)
+            return;
+        const a = tokensOf(line);
+        const b = tokensOf(other);
+        if (a.length !== b.length)
+            return;
+        a.forEach((token, at) => {
+            const target = b[at];
+            if (token === target)
+                return;
+            const known = renames.get(token);
+            if (known === undefined)
+                renames.set(token, target);
+            else if (known !== target)
+                ambiguous.add(token);
+        });
+    });
+    return { renames, ambiguous };
+}
+/**
+ * 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 function keptLines(a, b) {
+    const kept = b.map(() => -1);
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head]) {
+        kept[head] = head;
+        head += 1;
+    }
+    let tail = 0;
+    while (tail < a.length - head &&
+        tail < b.length - head &&
+        a[a.length - 1 - tail] === b[b.length - 1 - tail]) {
+        kept[b.length - 1 - tail] = a.length - 1 - tail;
+        tail += 1;
+    }
+    const n = a.length - head - tail;
+    const m = b.length - head - tail;
+    if (n === 0 || m === 0 || (n + 1) * (m + 1) > MATCH_CELLS)
+        return kept;
+    const width = m + 1;
+    const length = new Int32Array((n + 1) * width);
+    for (let i = n - 1; i >= 0; i -= 1)
+        for (let j = m - 1; j >= 0; j -= 1)
+            length[i * width + j] =
+                a[head + i] === b[head + j]
+                    ? length[(i + 1) * width + j + 1] + 1
+                    : Math.max(length[(i + 1) * width + j], length[i * width + j + 1]);
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[head + i] === b[head + j]) {
+            kept[head + j] = head + i;
+            i += 1;
+            j += 1;
+        }
+        else if (length[(i + 1) * width + j] >=
+            length[i * width + j + 1])
+            i += 1;
+        else
+            j += 1;
+    }
+    return kept;
+}
+const IMPORT_SPECIFIER = /(?:\bfrom\s*|\bimport\s*\(?\s*|\brequire\s*\(\s*)(["'])(\.{1,2}\/[^"']*)\1/g;
+/** A relative specifier resolved against the importing file's folder. */
+export function resolveRelative(importer, specifier) {
+    const parts = importer.split("/").slice(0, -1);
+    for (const part of specifier.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..")
+            parts.pop();
+        else
+            parts.push(part);
+    }
+    return parts.join("/");
+}
+/**
+ * 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 function carryChange(files, renaming) {
+    const carried = [];
+    const refused = [];
+    for (const file of files) {
+        const refuse = (reason) => refused.push({ path: file.fromPath, reason });
+        if (file.edited === file.fromOriginal)
+            continue;
+        const from = linesOf(file.fromOriginal ?? "");
+        const to = linesOf(file.toOriginal ?? "");
+        if (from.length !== to.length) {
+            refuse("The version's copy of this file does not line up with the repository's, so the change cannot be carried.");
+            continue;
+        }
+        const { renames, ambiguous } = learnedRenames(from, to);
+        const back = new Map([...renames].map(([a, b]) => [b, a]));
+        const edited = linesOf(file.edited);
+        const kept = keptLines(from, edited);
+        const out = [];
+        const problems = new Set();
+        edited.forEach((line, index) => {
+            const keptAt = kept[index];
+            if (keptAt >= 0) {
+                out.push(to[keptAt]);
+                return;
+            }
+            const tokens = tokensOf(line);
+            if (tokens.some((token) => ambiguous.has(token))) {
+                problems.add("An added line uses a name the build renamed two ways in this file.");
+                return;
+            }
+            const renamed = renaming.to(tokens.map((token) => renames.get(token) ?? token).join(""), file);
+            const again = tokensOf(renaming.back(renamed, file))
+                .map((token) => back.get(token) ?? token)
+                .join("");
+            if (again !== line) {
+                problems.add("An added line holds a name the other side would read differently, so it does not map back.");
+                return;
+            }
+            if (renaming.isHarness !== undefined)
+                for (const match of line.matchAll(IMPORT_SPECIFIER))
+                    if (renaming.isHarness(resolveRelative(file.fromPath, match[2])))
+                        problems.add(`An added line imports ${match[2]}, part of the sandbox's harness, which the repository does not have.`);
+            out.push(renamed);
+        });
+        if (problems.size > 0) {
+            for (const problem of [...problems].sort())
+                refuse(problem);
+            continue;
+        }
+        carried.push({ path: file.toPath, text: out.join("") });
+    }
+    return {
+        files: carried.sort((a, b) => (a.path < b.path ? -1 : 1)),
+        refused,
+    };
+}
+/** A file's path without its script extension, for matching an import to it. */
+const stem = (path) => path.replace(/\.(?:[cm]?[jt]sx?|d\.ts)$/, "");
+/**
+ * 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 function reverseSubmission(input) {
+    const { renameFile, invertAliasRules } = input.aliases ?? CURRENT_ALIASES;
+    const inverse = invertAliasRules(input.rules);
+    const repositoryPathOf = new Map(input.renames.map(({ from, to }) => [to, from]));
+    const harness = new Set(input.harness.map(stem));
+    const files = input.submitted.map((file) => {
+        const toPath = repositoryPathOf.get(file.path) ??
+            renameFile({ path: file.path, text: "" }, inverse).path;
+        return {
+            fromPath: file.path,
+            toPath,
+            fromOriginal: input.publicText(file.path),
+            toOriginal: input.repositoryText(toPath),
+            edited: file.text,
+        };
+    });
+    return carryChange(files, {
+        to: (text, file) => renameFile({ path: file.toPath, text }, inverse).text,
+        back: (text, file) => renameFile({ path: file.toPath, text }, input.rules).text,
+        isHarness: (path) => harness.has(stem(path)),
+    });
+}
+/**
+ * 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 function projectPathOf(path, renames, rules, aliases = CURRENT_ALIASES) {
+    const { renameFile } = aliases;
+    return (renames.find((rename) => rename.from === path)?.to ??
+        renameFile({ path, text: "" }, rules).path);
+}
+/**
+ * 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 function forwardChange(input) {
+    const aliases = input.aliases ?? CURRENT_ALIASES;
+    const { renameFile } = aliases;
+    const inverse = aliases.invertAliasRules(input.rules);
+    const files = input.changed.map((file) => {
+        const toPath = projectPathOf(file.path, input.renames, input.rules, aliases);
+        return {
+            fromPath: file.path,
+            toPath,
+            fromOriginal: input.repositoryText(file.path),
+            toOriginal: input.publicText(toPath),
+            edited: file.text,
+        };
+    });
+    return carryChange(files, {
+        to: (text, file) => renameFile({ path: file.fromPath, text }, input.rules).text,
+        back: (text, file) => renameFile({ path: file.fromPath, text }, inverse).text,
+    });
+}

package/dist/src/pseudonyms/draft.js

@@ -23,7 +23,7 @@
  * find.
  */
 import { renameFile } from "./aliases.js";
-import { relativeSpecifier } from "../project/project.js";
+import { relativeSpecifier } from "../project/paths.js";
 import { termMatches } from "./vocabulary.js";
 /**
  * Placeholders, in the order tried: a term takes the first that no input

package/dist/src/pseudonyms/folder.js

@@ -26,7 +26,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { applyAliases, invertAliasRules, renameFile } from "./aliases.js";
 import { draftPseudonyms, restyle } from "./draft.js";
-import { emailNames, termMatches, termWords, tooCommonAlone, vocabularyLeaks, } from "./vocabulary.js";
+import { emailNames, scannedNames, termMatches, termWords, vocabularyLeaks, } from "./vocabulary.js";
 /** A package.json's fields that name its owner, or null when unreadable. */
 function manifestNames(path) {
     if (!existsSync(path))
@@ -155,39 +155,6 @@ function hostedNames(url) {
         names.push({ name: repo, kind: "name" });
     return names;
 }
-/** Affixes a handle wraps a name in: `lunoxhq`, `getlunox`, `lunoxapp`. */
-const HANDLE_PREFIXES = ["get", "try", "use", "join", "go", "hello", "meet"];
-const HANDLE_SUFFIXES = ["hq", "app", "apps", "inc", "io", "dev", "devs", "labs", "lab", "team", "co", "ai", "hub", "official", "corp", "tech", "studio", "group"];
-/**
- * More spellings an organization's or a person's name goes by: the stem of
- * a handle (`lunox` of `lunoxhq`), its words split at a digit (`web3 labs`
- * of `web3labs`), and its letters without accents (`lunox` of `Lunöx`).
- */
-function spellings(entry) {
-    const out = [entry];
-    const plain = entry.name.normalize("NFD").replace(/\p{M}/gu, "");
-    if (plain !== entry.name)
-        out.push({ ...entry, name: plain });
-    // Matched whole: its words alone (`web3`) are everyone's.
-    const split = plain.replace(/(\d)(\p{L})/gu, "$1 $2");
-    if (split !== plain)
-        out.push({ name: split, kind: "name" });
-    if (entry.kind === "organization") {
-        const word = plain.toLowerCase();
-        // A stem of letters alone, and not one everyone's code uses (`web3`).
-        const stem = (candidate) => {
-            if (candidate.length >= 4 && /^\p{L}+$/u.test(candidate) && !tooCommonAlone(candidate))
-                out.push({ name: candidate, kind: "organization" });
-        };
-        for (const prefix of HANDLE_PREFIXES)
-            if (word.startsWith(prefix))
-                stem(word.slice(prefix.length));
-        for (const suffix of HANDLE_SUFFIXES)
-            if (word.endsWith(suffix))
-                stem(word.slice(0, -suffix.length));
-    }
-    return out;
-}
 /** A Git setting of the checkout, or null. */
 function gitValue(repo, args) {
     try {
@@ -225,12 +192,7 @@ export function workspaceNames(repo, packageDirs, owner = []) {
     const mail = gitValue(repo, ["config", "user.email"]);
     if (mail !== null)
         names.push(...emailNames(mail));
-    // A name found, of one word the code calls its own things by, is not
-    // scanned for alone; the owner's own names always are.
-    return [
-        ...owner.map((name) => ({ name, kind: "organization" })),
-        ...found.filter((entry) => !tooCommonAlone(entry.name)),
-    ].flatMap(spellings);
+    return scannedNames(found, owner);
 }
 /**
  * The names written after a name the repository goes by, the way its

package/dist/src/pseudonyms/legacy/aliases-v1.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Alias rules: the private, bidirectional name table a sandbox version
+ * applies to copied source before it can leave the organization.
+ *
+ * A rule is an explicit pair with a kind and a scope. Rules are ordered,
+ * and applied in that order; they are validated as a set before any text
+ * is touched, because two rules that look harmless alone can interact (one
+ * rule's output is another's input, two rules share a target, two
+ * identifier or path names differ only by case). Application is
+ * deterministic and textual, bounded to identifier or path tokens so a name
+ * inside a longer identifier is never touched, and it is checked to be
+ * reversible: applying the inverse table to the output must give the input
+ * back byte for byte. A text rule matches its exact, case-sensitive
+ * characters and is inverted the same way, so two text rules that differ
+ * only by case are distinct and both hold. A
+ * transformation that cannot be mapped back is refused, never silently
+ * dropped. Redaction of implementation is not a rename and has no place
+ * here.
+ */
+export declare const ALIAS_KINDS: readonly ["identifier", "path", "text"];
+export type AliasKind = (typeof ALIAS_KINDS)[number];
+export interface AliasRule {
+    readonly before: string;
+    readonly after: string;
+    readonly kind: AliasKind;
+    /**
+     * Repository paths the rule applies to: a file, or a directory prefix.
+     * Empty means every file. Scoped rules let one name mean different
+     * things in different modules without a symbol table.
+     */
+    readonly paths: readonly string[];
+}
+export declare const ALIAS_PROBLEM_CODES: readonly ["empty", "identity", "invalid_identifier", "invalid_path", "duplicate_source", "duplicate_target", "chained", "casing_variant", "target_collision", "irreversible", "too_many", "unsupported_kind"];
+export type AliasProblemCode = (typeof ALIAS_PROBLEM_CODES)[number];
+export interface AliasProblem {
+    readonly code: AliasProblemCode;
+    /** Index into the rule list; null for a problem of the whole set. */
+    readonly rule: number | null;
+    readonly file: string | null;
+    readonly detail: string;
+}
+export declare const ALIAS_RULES_MAX = 500;
+export interface AliasValidation {
+    readonly ok: boolean;
+    readonly problems: readonly AliasProblem[];
+}
+/** Whether the set is well formed and free of interactions. */
+export declare function validateAliasRules(rules: readonly AliasRule[]): AliasValidation;
+export interface AliasedFile {
+    readonly path: string;
+    readonly text: string;
+}
+export interface AliasApplication {
+    readonly ok: boolean;
+    readonly files: readonly AliasedFile[];
+    /** Original path to aliased path, for every file whose path changed. */
+    readonly renames: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
+    readonly problems: readonly AliasProblem[];
+    /** Rule index to the number of replacements it made, for the record. */
+    readonly applied: readonly number[];
+}
+/**
+ * Applies the rules to the files and proves the result maps back. Problems
+ * refuse the whole application: a partially aliased candidate is worse
+ * than none, because it looks finished.
+ */
+export declare function applyAliases(files: readonly AliasedFile[], rules: readonly AliasRule[]): AliasApplication;
+/**
+ * A JSON value's string leaves, each as a file of its own, for aliasing a
+ * structure without touching its shape.
+ *
+ * Aliasing a serialized object as one text renames its keys too: a quote is
+ * a word boundary, so a rule `name → label` turned `"name":` into
+ * `"label":` and the object lost the field. Leaves alone keep every key,
+ * number and boolean as they were. Each is named `base#pointer`, and
+ * `withJsonLeaves` puts them back in the same order.
+ */
+export declare function jsonLeaves(base: string, value: unknown): AliasedFile[];
+/**
+ * `value` with its string leaves replaced by `texts`, in `jsonLeaves`'s
+ * order; a leaf with no text left keeps its own. A fresh value: the one
+ * given is not changed.
+ */
+export declare function withJsonLeaves<T>(value: T, texts: readonly string[]): T;
+/**
+ * The name a build gives its alias table among the private files it writes:
+ * `private/pseudonym.lunox`, beside the hidden tests.
+ */
+export declare const PSEUDONYMS_FILE = "pseudonym.lunox";
+export declare const PSEUDONYMS_SCHEMA_VERSION = 1;
+/** `pseudonym.lunox`: the table a version's public files were renamed by. */
+export interface PseudonymTable {
+    readonly schemaVersion: typeof PSEUDONYMS_SCHEMA_VERSION;
+    readonly rules: readonly AliasRule[];
+}
+/**
+ * One file renamed by the rules, without the checks `applyAliases` makes:
+ * for reading back a file already proved to map back, such as a public
+ * file in its private names under the inverse table. `file.path` is its
+ * repository path, which scoped rules are matched against.
+ */
+export declare function renameFile(file: AliasedFile, rules: readonly AliasRule[]): AliasedFile;
+/** The inverse table, as a contribution's import applies it. */
+export declare function invertAliasRules(rules: readonly AliasRule[]): AliasRule[];