project-tiny-context-harness 0.8.13 → 0.8.16

package/dist/lib/long-task-paths.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { resolveInsideRepository } from "./long-task-workspace.js";
 export function parseRepositoryPattern(value, label = "repository_pattern") {
     const normalized = canonicalRepositoryPath(value, label, "pattern");
-    if (/[\[\]{}()]/u.test(normalized))
+    if (/[\[\]{}]/u.test(normalized))
         throw new Error(`unsupported_repository_pattern_syntax:${label}:${value}`);
     const segments = normalized.split("/").map((segment) => {
         if (segment === "**")

package/dist/lib/long-task-process-runtime-closure.js

@@ -110,62 +110,94 @@ function selectBinding(selected, scoped) {
 function argvAttributedRepositoryFiles(argv, cwd, bindings, targetRef) {
     const result = new Set();
     for (const argument of argv) {
-        const value = rootArgvPathValue(argument);
-        if (!value)
+        const classification = classifyRootArgvToken(argument);
+        if (classification.kind === "label")
             continue;
-        if (unsafeArgvPathValue(value))
-            fail("process_root_argv_unsafe", `${targetRef}:${argument}`);
-        const candidate = path.posix.join(cwd === "." ? "" : cwd, value);
+        if (classification.kind === "external_reference")
+            fail("process_root_argv_unsafe", `${targetRef}:${argument}:${classification.reason}`);
+        const candidate = path.posix.join(cwd === "." ? "" : cwd, classification.value);
         let normalized;
         try {
             normalized = normalizeRepositoryFile(candidate, "process_root_argv");
         }
         catch {
-            fail("process_root_argv_unsafe", `${targetRef}:${argument}`);
+            fail("process_root_argv_unsafe", `${targetRef}:${argument}:parent_escape`);
         }
         if (bindingsContaining(bindings, normalized).length)
             result.add(normalized);
     }
     return [...result].sort();
 }
-function rootArgvPathValue(argument) {
-    const parsedArgument = unwrapCompleteQuoteLayer(argument.replace(/\\/gu, "/"));
-    const portable = parsedArgument.value;
-    if (!portable)
-        return null;
-    // A compound shell command is not one finite argv file token. In
-    // particular, do not search inside it for a path-shaped substring.
-    if (!parsedArgument.quoted && /\s/u.test(portable))
-        return null;
-    // A single-letter slash switch is an argv label (for example cmd.exe /d),
-    // not a repository path. Longer slash-prefixed values remain absolute and
-    // fail closed below.
-    if (/^\/[A-Za-z?]$/u.test(portable))
-        return null;
-    if (!portable.startsWith("--"))
-        return portable;
-    const separator = portable.indexOf("=");
-    if (separator <= 2 || separator === portable.length - 1)
-        return null;
-    const parsedValue = unwrapCompleteQuoteLayer(portable.slice(separator + 1));
-    if (!parsedValue.value)
-        return null;
-    if (!parsedValue.quoted && /\s/u.test(parsedValue.value))
-        return null;
-    return parsedValue.value;
+function classifyRootArgvToken(argument) {
+    if (!argument)
+        return { kind: "label" };
+    if (hasUnsafeArgvControl(argument))
+        return externalArgvReference("unsupported_compound");
+    if (argument === "--")
+        return { kind: "label" };
+    if (argument.startsWith("--")) {
+        const assignment = /^--[A-Za-z0-9][A-Za-z0-9_-]*=(.*)$/u.exec(argument);
+        if (assignment) {
+            const value = assignment[1];
+            if (!value)
+                return { kind: "label" };
+            if (value.includes("="))
+                return externalArgvReference("unsupported_compound");
+            return classifyRootArgvValue(value);
+        }
+        if (/^--[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(argument))
+            return { kind: "label" };
+        return externalArgvReference("unsupported_compound");
+    }
+    if (/^-[A-Za-z0-9?]$/u.test(argument))
+        return { kind: "label" };
+    if (/^-\d+(?:\.\d+)?$/u.test(argument))
+        return { kind: "label" };
+    if (argument.startsWith("-") || argument.startsWith("@"))
+        return externalArgvReference("unsupported_compound");
+    if (argument.includes("="))
+        return externalArgvReference("unsupported_compound");
+    return classifyRootArgvValue(argument);
+}
+function classifyRootArgvValue(value) {
+    if (!value)
+        return { kind: "label" };
+    if (hasUnsafeArgvControl(value))
+        return externalArgvReference("unsupported_compound");
+    if (/["']/u.test(value))
+        return externalArgvReference("quote_ambiguous");
+    if (value.includes("\\"))
+        return externalArgvReference("platform_ambiguous");
+    if (/^\/[A-Za-z?]$/u.test(value))
+        return externalArgvReference("platform_ambiguous");
+    if (value.startsWith("/"))
+        return externalArgvReference("absolute");
+    if (/^[A-Za-z]:/u.test(value))
+        return externalArgvReference("drive_prefixed");
+    if (value.startsWith("@"))
+        return externalArgvReference("unsupported_compound");
+    if (hasUnsupportedArgvCompound(value))
+        return externalArgvReference("unsupported_compound");
+    if (/^node:\d+(?:\.\d+)?$/u.test(value))
+        return { kind: "label" };
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:/u.test(value))
+        return externalArgvReference("protocol_prefixed");
+    if (value.includes(":"))
+        return /^\d{1,4}:\d{1,4}$/u.test(value)
+            ? { kind: "label" }
+            : externalArgvReference("unsupported_compound");
+    return { kind: "repository_candidate", value };
+}
+function hasUnsafeArgvControl(value) {
+    return /[\u0000-\u001f\u007f]/u.test(value);
 }
-function unwrapCompleteQuoteLayer(value) {
-    const quote = value[0];
-    if ((quote === '"' || quote === "'") && value.at(-1) === quote)
-        return { value: value.slice(1, -1), quoted: true };
-    return { value, quoted: false };
+function hasUnsupportedArgvCompound(value) {
+    return (value.trim() !== value ||
+        value.startsWith("~") ||
+        !/^[\p{L}\p{N}._+,: /-]+$/u.test(value));
 }
-function unsafeArgvPathValue(value) {
-    return (/["']/u.test(value) ||
-        value.startsWith("/") ||
-        /^[A-Za-z]:\//u.test(value) ||
-        /^file:/iu.test(value) ||
-        /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(value));
+function externalArgvReference(reason) {
+    return { kind: "external_reference", reason };
 }
 function firstMatchingPattern(file, patterns) {
     return patterns.find((pattern) => matchesRepoPattern(file, pattern)) ?? null;

package/dist/lib/long-task-verifier-authority.js

@@ -37,6 +37,8 @@ function changedVerifierFiles(previous, next) {
         ...Object.keys(next.bundle_files),
     ]);
     const changed = [...files].filter((file) => previous.bundle_files[file] !== next.bundle_files[file]);
+    if (previous.bundle_sha256 !== next.bundle_sha256)
+        changed.push("<bundle>");
     if (previous.schema_sha256 !== next.schema_sha256)
         changed.push("<schema>");
     if (previous.hook_sha256 !== next.hook_sha256)

package/dist/lib/long-task-workspace-manifest.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceFingerprintV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function captureWorkspaceFingerprint(rootInput: string, excludedPrefixes?: string[]): Promise<WorkspaceFingerprintV2>;
+export declare function captureWorkspaceManifest(rootInput: string, workdirInput: string, _copyRoot?: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceManifestV2>;
+export declare function changedWorkspacePaths(baseline: WorkspaceManifestV2, current: WorkspaceManifestV2): string[];
+export declare function changedWorkspacePathsFromHead(rootInput: string, workdirInput: string, additionalExcludedWorkdirs?: string[]): Promise<string[]>;
+export declare function workspaceFingerprintExcludedPrefixes(root: string, workdirs: string[]): string[];
+export declare function workspaceSnapshotExcludedPrefixes(root: string, workdirs: string[]): string[];
+export declare function workspacePathExcluded(relative: string, excluded: string[]): boolean;

package/dist/lib/long-task-workspace-manifest.js

@@ -0,0 +1,173 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { gitBuffer, gitBufferInput, gitOutput, repoRelative, splitGitZero, } from "./long-task-git.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export async function captureWorkspaceFingerprint(rootInput, excludedPrefixes = []) {
+    const root = path.resolve(rootInput);
+    const indexTree = await gitOutput(root, ["write-tree"]);
+    const [head, headTree, staged, unstaged, statusBytes, untracked] = await Promise.all([
+        gitOutput(root, ["rev-parse", "HEAD"]),
+        gitOutput(root, ["rev-parse", "HEAD^{tree}"]),
+        gitBuffer(root, scopedDiffArgs(["diff", "--cached", "--binary", "--no-ext-diff"], excludedPrefixes)),
+        gitBuffer(root, scopedDiffArgs(["diff", "--binary", "--no-ext-diff"], excludedPrefixes)),
+        Promise.all([
+            gitBuffer(root, scopedDiffArgs(["diff", "--cached", "--raw", "-z", "-M"], excludedPrefixes)),
+            gitBuffer(root, scopedDiffArgs(["diff", "--raw", "-z", "-M"], excludedPrefixes)),
+        ]).then((rows) => Buffer.concat(rows)),
+        untrackedIdentity(root, excludedPrefixes),
+    ]);
+    const unsigned = {
+        head,
+        head_tree: headTree,
+        index_tree: indexTree,
+        staged_diff_sha256: sha256Hex(staged),
+        unstaged_diff_sha256: sha256Hex(unstaged),
+        untracked_sha256: untracked,
+        status_sha256: sha256Hex(statusBytes),
+    };
+    return {
+        ...unsigned,
+        identity: sha256Hex(canonicalValueJson(unsigned)),
+    };
+}
+export async function captureWorkspaceManifest(rootInput, workdirInput, _copyRoot, additionalExcludedWorkdirs = []) {
+    const root = path.resolve(rootInput);
+    const workdir = path.resolve(workdirInput);
+    const workdirRelative = repoRelative(root, workdir);
+    if (!workdirRelative)
+        throw new Error("long_task_workdir_must_not_be_repository_root");
+    const excluded = workspaceFingerprintExcludedPrefixes(root, [
+        workdir,
+        ...additionalExcludedWorkdirs,
+    ]);
+    const fingerprint = await captureWorkspaceFingerprint(root, excluded);
+    const [indexBytes, modifiedBytes, untrackedBytes] = await Promise.all([
+        gitBuffer(root, ["ls-files", "--stage", "-z"]),
+        gitBuffer(root, ["diff", "--name-only", "-z"]),
+        gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
+    ]);
+    const files = new Map();
+    for (const record of splitGitZero(indexBytes)) {
+        const tab = record.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const [modeText, objectId, stage] = record.slice(0, tab).split(" ");
+        const relative = record.slice(tab + 1).replace(/\\/gu, "/");
+        if (stage !== "0" || workspacePathExcluded(relative, excluded))
+            continue;
+        files.set(relative, {
+            path: relative,
+            mode: Number.parseInt(modeText, 8),
+            size: 0,
+            sha256: `git:${objectId}`,
+        });
+    }
+    const overlays = new Set([
+        ...splitGitZero(modifiedBytes),
+        ...splitGitZero(untrackedBytes),
+    ]);
+    const overlayNames = [...overlays]
+        .map((raw) => raw.replace(/\\/gu, "/"))
+        .filter((relative) => !workspacePathExcluded(relative, excluded));
+    const overlayInfo = new Map(await Promise.all(overlayNames.map(async (relative) => [
+        relative,
+        await stat(path.join(root, ...relative.split("/")), {
+            bigint: true,
+        }).catch(() => null),
+    ])));
+    const overlayHashes = await gitObjectIds(root, overlayNames.filter((relative) => overlayInfo.get(relative)?.isFile()));
+    for (const relative of overlayNames) {
+        const absolute = path.join(root, ...relative.split("/"));
+        const info = overlayInfo.get(relative);
+        if (!info?.isFile()) {
+            files.delete(relative);
+            continue;
+        }
+        const bytes = await readFile(absolute);
+        files.set(relative, {
+            path: relative,
+            mode: gitFileMode(Number(info.mode)),
+            size: bytes.length,
+            sha256: `git:${overlayHashes.get(relative)}`,
+        });
+    }
+    return {
+        repository_root: root,
+        git_head: fingerprint.head,
+        files: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
+        fingerprint,
+        snapshot_sha256: fingerprint.identity,
+    };
+}
+export function changedWorkspacePaths(baseline, current) {
+    const before = new Map(baseline.files.map((file) => [file.path, `${file.mode}:${file.sha256}`]));
+    const after = new Map(current.files.map((file) => [file.path, `${file.mode}:${file.sha256}`]));
+    return [...new Set([...before.keys(), ...after.keys()])]
+        .filter((file) => before.get(file) !== after.get(file))
+        .sort();
+}
+export async function changedWorkspacePathsFromHead(rootInput, workdirInput, additionalExcludedWorkdirs = []) {
+    const root = path.resolve(rootInput);
+    const workdir = path.resolve(workdirInput);
+    const excluded = workspaceFingerprintExcludedPrefixes(root, [
+        workdir,
+        ...additionalExcludedWorkdirs,
+    ]);
+    const [trackedBytes, untrackedBytes] = await Promise.all([
+        gitBuffer(root, scopedDiffArgs(["diff", "--name-only", "--no-renames", "--no-ext-diff", "-z", "HEAD"], excluded)),
+        gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
+    ]);
+    return [
+        ...new Set([...splitGitZero(trackedBytes), ...splitGitZero(untrackedBytes)]
+            .map((raw) => raw.replace(/\\/gu, "/"))
+            .filter((relative) => !workspacePathExcluded(relative, excluded))),
+    ].sort();
+}
+export function workspaceFingerprintExcludedPrefixes(root, workdirs) {
+    return [
+        ...workspaceSnapshotExcludedPrefixes(root, workdirs),
+        "project_context",
+    ].filter(Boolean);
+}
+export function workspaceSnapshotExcludedPrefixes(root, workdirs) {
+    return [
+        ...workdirs.map((workdir) => repoRelative(root, path.resolve(workdir))),
+        "tmp/ty-context/long-task-runs",
+    ].filter(Boolean);
+}
+export function workspacePathExcluded(relative, excluded) {
+    const normalized = relative.replace(/\\/gu, "/");
+    return (normalized.split("/").includes("node_modules") ||
+        excluded.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`)));
+}
+async function untrackedIdentity(root, excluded) {
+    const names = splitGitZero(await gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]))
+        .map((name) => name.replace(/\\/gu, "/"))
+        .filter((name) => !workspacePathExcluded(name, excluded))
+        .sort();
+    const hashes = await gitObjectIds(root, names);
+    const rows = names.map((name) => [
+        name,
+        hashes.get(name) ?? "missing",
+    ]);
+    return sha256Hex(canonicalValueJson(rows));
+}
+async function gitObjectIds(root, names) {
+    if (!names.length)
+        return new Map();
+    const output = await gitBufferInput(root, ["hash-object", "--stdin-paths"], Buffer.from(`${names.join("\n")}\n`, "utf8"));
+    const ids = output.toString("utf8").trim().split(/\r?\n/u);
+    return new Map(names.map((name, index) => [name, ids[index]]));
+}
+function scopedDiffArgs(base, excluded) {
+    return [
+        ...base,
+        "--",
+        ".",
+        ...excluded.map((prefix) => `:(exclude)${prefix}/**`),
+        ":(exclude)**/node_modules/**",
+    ];
+}
+function gitFileMode(mode) {
+    return mode & 0o111 ? 0o100755 : 0o100644;
+}

package/dist/lib/long-task-workspace-snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export interface WorkspaceSnapshotV2 {
+    root: string;
+    manifest: WorkspaceManifestV2;
+    preparation_ms: number;
+    dispose(): Promise<void>;
+}
+export declare function createWorkspaceSnapshot(rootInput: string, workdirInput: string, label: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceSnapshotV2>;

package/dist/lib/long-task-workspace-snapshot.js

@@ -0,0 +1,176 @@
+import { copyFile, mkdir, mkdtemp, readdir, rm, stat, symlink, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { GitCommandError, gitBuffer, gitEffectiveConfigGet, gitVoid, repoRelative, splitGitZero, } from "./long-task-git.js";
+import { captureWorkspaceFingerprint, captureWorkspaceManifest, workspaceFingerprintExcludedPrefixes, workspacePathExcluded, workspaceSnapshotExcludedPrefixes, } from "./long-task-workspace-manifest.js";
+const MAX_CHECKOUT_INDEX_ATTEMPTS = 2;
+export async function createWorkspaceSnapshot(rootInput, workdirInput, label, additionalExcludedWorkdirs = []) {
+    const started = performance.now();
+    const root = path.resolve(rootInput);
+    const workdir = path.resolve(workdirInput);
+    const fingerprintExcluded = workspaceFingerprintExcludedPrefixes(root, [
+        workdir,
+        ...additionalExcludedWorkdirs,
+    ]);
+    const snapshotExcluded = workspaceSnapshotExcludedPrefixes(root, [
+        workdir,
+        ...additionalExcludedWorkdirs,
+    ]);
+    const manifest = await captureWorkspaceManifest(root, workdir, undefined, additionalExcludedWorkdirs);
+    const before = manifest.fingerprint;
+    const temporary = await checkoutIndexIntoFreshRoot(root, label, before.identity, fingerprintExcluded);
+    try {
+        await overlayTrackedEolDifferences(root, temporary);
+        const [modified, untracked] = await Promise.all([
+            gitBuffer(root, ["diff", "--name-only", "-z"]),
+            gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
+        ]);
+        for (const raw of new Set([
+            ...splitGitZero(modified),
+            ...splitGitZero(untracked),
+        ])) {
+            const relative = raw.replace(/\\/gu, "/");
+            if (workspacePathExcluded(relative, snapshotExcluded))
+                continue;
+            const source = path.join(root, ...relative.split("/"));
+            const target = path.join(temporary, ...relative.split("/"));
+            const info = await stat(source).catch(() => null);
+            if (!info?.isFile()) {
+                await rm(target, { recursive: true, force: true });
+                continue;
+            }
+            await mkdir(path.dirname(target), { recursive: true });
+            await copyFile(source, target);
+        }
+        await removeExcludedSnapshotPaths(temporary, snapshotExcluded);
+        await linkDependencyTrees(root, temporary, [
+            workdir,
+            ...additionalExcludedWorkdirs,
+        ]);
+        const after = await captureWorkspaceFingerprint(root, fingerprintExcluded);
+        if (after.identity !== before.identity)
+            throw new Error("workspace_changed_during_snapshot");
+        return {
+            root: temporary,
+            manifest,
+            preparation_ms: performance.now() - started,
+            dispose: () => rm(temporary, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        await rm(temporary, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function checkoutIndexIntoFreshRoot(root, label, expectedFingerprint, fingerprintExcluded) {
+    for (let attempt = 1; attempt <= MAX_CHECKOUT_INDEX_ATTEMPTS; attempt += 1) {
+        const temporary = await mkdtemp(path.join(os.tmpdir(), `ty-context-${safe(label)}-`));
+        try {
+            await gitVoid(root, [
+                "checkout-index",
+                "--all",
+                "--force",
+                "--ignore-skip-worktree-bits",
+                `--prefix=${temporary.replace(/\\/gu, "/")}/`,
+            ]);
+            return temporary;
+        }
+        catch (error) {
+            await rm(temporary, { recursive: true, force: true });
+            if (!retryableUnclassifiedCheckout(error) ||
+                attempt === MAX_CHECKOUT_INDEX_ATTEMPTS)
+                throw error;
+            const current = await captureWorkspaceFingerprint(root, fingerprintExcluded);
+            if (current.identity !== expectedFingerprint)
+                throw new Error("workspace_changed_during_snapshot");
+        }
+    }
+    throw new Error("workspace_snapshot_checkout_attempts_exhausted");
+}
+function retryableUnclassifiedCheckout(error) {
+    return (error instanceof GitCommandError &&
+        error.exitCode === 1 &&
+        error.signal === null &&
+        error.stdoutBytes === 0 &&
+        error.stderrBytes === 0);
+}
+async function removeExcludedSnapshotPaths(snapshotRoot, excluded) {
+    for (const relative of excluded)
+        await rm(path.join(snapshotRoot, ...relative.split("/")), {
+            recursive: true,
+            force: true,
+        });
+    async function visit(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const target = path.join(directory, entry.name);
+            if (entry.isDirectory() && entry.name === "node_modules") {
+                await rm(target, { recursive: true, force: true });
+            }
+            else if (entry.isDirectory())
+                await visit(target);
+        }
+    }
+    await visit(snapshotRoot);
+}
+async function overlayTrackedEolDifferences(sourceRoot, snapshotRoot) {
+    const [raw, autocrlf] = await Promise.all([
+        gitBuffer(sourceRoot, ["ls-files", "--eol", "-z"]),
+        gitEffectiveConfigGet(sourceRoot, "core.autocrlf"),
+    ]);
+    for (const record of splitGitZero(raw)) {
+        const tab = record.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const metadata = record.slice(0, tab);
+        const relative = record.slice(tab + 1).replace(/\\/gu, "/");
+        const match = metadata.match(/^i\/(\S+)\s+w\/(\S+)\s+attr\/(.*)$/u);
+        if (!match)
+            continue;
+        const [, indexEol, worktreeEol, attributesRaw] = match;
+        const expected = checkoutEol(indexEol, attributesRaw.trim(), autocrlf);
+        if (worktreeEol === expected)
+            continue;
+        const source = path.join(sourceRoot, ...relative.split("/"));
+        const target = path.join(snapshotRoot, ...relative.split("/"));
+        const info = await stat(source).catch(() => null);
+        if (!info?.isFile())
+            continue;
+        await mkdir(path.dirname(target), { recursive: true });
+        await copyFile(source, target);
+    }
+}
+function checkoutEol(indexEol, attributes, autocrlf) {
+    const explicit = attributes.match(/(?:^|\s)eol=(lf|crlf)(?:\s|$)/u)?.[1];
+    if (explicit)
+        return explicit;
+    if (/(?:^|\s)-text(?:\s|$)/u.test(attributes))
+        return indexEol;
+    if (indexEol === "-text" || indexEol === "none")
+        return indexEol;
+    return autocrlf?.toLowerCase() === "true" ? "crlf" : indexEol;
+}
+async function linkDependencyTrees(sourceRoot, snapshotRoot, workdirs) {
+    const protectedWorkdirs = workdirs.map((workdir) => repoRelative(sourceRoot, workdir));
+    async function visit(directory, relative = "") {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const next = relative ? `${relative}/${entry.name}` : entry.name;
+            if (protectedWorkdirs.some((protectedWorkdir) => next === protectedWorkdir ||
+                next.startsWith(`${protectedWorkdir}/`)) ||
+                entry.name === ".git")
+                continue;
+            const source = path.join(directory, entry.name);
+            if (entry.isDirectory() && entry.name === "node_modules") {
+                const target = path.join(snapshotRoot, ...next.split("/"));
+                await mkdir(path.dirname(target), { recursive: true });
+                await rm(target, { recursive: true, force: true });
+                await symlink(source, target, process.platform === "win32" ? "junction" : "dir");
+            }
+            else if (entry.isDirectory())
+                await visit(source, next);
+        }
+    }
+    await visit(sourceRoot);
+}
+function safe(value) {
+    return value.replace(/[^A-Za-z0-9._-]/gu, "-").slice(0, 80);
+}

package/dist/lib/long-task-workspace.d.ts

@@ -1,26 +1,5 @@
 export { resolveInsideRepository } from "./repository-path-safety.js";
-import type { WorkspaceFingerprintV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export interface WorkspaceSnapshotV2 {
-    root: string;
-    manifest: WorkspaceManifestV2;
-    preparation_ms: number;
-    dispose(): Promise<void>;
-}
-export declare function repositoryRoot(start: string): Promise<string>;
-export declare function gitCommonDir(root: string): Promise<string>;
-export declare function captureWorkspaceFingerprint(rootInput: string, excludedPrefixes?: string[]): Promise<WorkspaceFingerprintV2>;
-export declare function captureWorkspaceManifest(rootInput: string, workdirInput: string, _copyRoot?: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceManifestV2>;
-export declare function createWorkspaceSnapshot(rootInput: string, workdirInput: string, label: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceSnapshotV2>;
-export declare function changedWorkspacePaths(baseline: WorkspaceManifestV2, current: WorkspaceManifestV2): string[];
-export declare function changedWorkspacePathsFromHead(rootInput: string, workdirInput: string, additionalExcludedWorkdirs?: string[]): Promise<string[]>;
-export declare function currentGitState(root: string): Promise<{
-    head: string;
-    tree: string;
-    dirty: string[];
-}>;
-export declare function currentGitTree(root: string): Promise<string>;
-export declare function gitPath(root: string, pathSpec: string): Promise<string>;
-export declare function gitConfigGet(root: string, name: string): Promise<string | null>;
-export declare function gitConfigSet(root: string, name: string, value: string): Promise<void>;
-export declare function gitConfigUnset(root: string, name: string): Promise<void>;
-export declare function repoRelative(rootInput: string, fileInput: string): string;
+export { currentGitState, currentGitTree, gitCommonDir, gitConfigGet, gitConfigSet, gitConfigUnset, gitPath, repoRelative, repositoryRoot, } from "./long-task-git.js";
+export { captureWorkspaceFingerprint, captureWorkspaceManifest, changedWorkspacePaths, changedWorkspacePathsFromHead, } from "./long-task-workspace-manifest.js";
+export { createWorkspaceSnapshot } from "./long-task-workspace-snapshot.js";
+export type { WorkspaceSnapshotV2 } from "./long-task-workspace-snapshot.js";