project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/context-move/context-move-literal-scan.js

@@ -0,0 +1,213 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { compareUtf8Paths, normalizeContextPath, } from "../context-catalog/catalog-paths.js";
+const MAX_FILES = 4096;
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+const MAX_MATCHES = 500;
+const SKIPPED_DIRECTORIES = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "coverage",
+    ".artifacts",
+    "tmp",
+]);
+const TEXT_EXTENSIONS = new Set([
+    ".md",
+    ".txt",
+    ".toml",
+    ".yaml",
+    ".yml",
+    ".json",
+    ".jsonc",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".rs",
+    ".go",
+    ".java",
+    ".kt",
+    ".sh",
+    ".ps1",
+    ".bat",
+    ".cmd",
+    ".xml",
+    ".html",
+    ".css",
+    ".scss",
+]);
+export async function scanStagedRepositoryForContextPath(input) {
+    const discovered = await discoverTextFiles(input.repository);
+    const paths = new Map();
+    const limits = new Set(discovered.limits);
+    for (const file of discovered.files) {
+        const existing = paths.get(file.path);
+        if (existing !== undefined && existing !== file.physical_path) {
+            limits.add(`path_unicode_collision:${file.path}`);
+            continue;
+        }
+        paths.set(file.path, file.physical_path);
+    }
+    for (const [file, bytes] of input.file_overrides) {
+        const logical = normalizeContextPath(file);
+        if (bytes === null)
+            paths.delete(logical);
+        else if (isTextCandidate(logical) && !paths.has(logical))
+            paths.set(logical, file);
+    }
+    const ordered = [...paths].sort(([left], [right]) => compareUtf8Paths(left, right));
+    if (ordered.length > MAX_FILES)
+        limits.add(`file_count>${MAX_FILES}`);
+    const matches = [];
+    let filesScanned = 0;
+    let bytesScanned = 0;
+    for (const [file, physicalFile] of ordered.slice(0, MAX_FILES)) {
+        const override = input.file_overrides.get(file);
+        let bytes;
+        try {
+            bytes =
+                override === undefined
+                    ? await readFile(path.join(input.repository, ...physicalFile.split("/")))
+                    : Buffer.from(override ?? []);
+        }
+        catch (error) {
+            limits.add(`read_failed:${file}:${message(error)}`);
+            continue;
+        }
+        if (bytes.length > MAX_FILE_BYTES) {
+            limits.add(`file_bytes>${MAX_FILE_BYTES}:${file}`);
+            continue;
+        }
+        if (bytesScanned + bytes.length > MAX_TOTAL_BYTES) {
+            limits.add(`total_bytes>${MAX_TOTAL_BYTES}`);
+            break;
+        }
+        bytesScanned += bytes.length;
+        filesScanned += 1;
+        let content;
+        try {
+            content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        catch {
+            continue;
+        }
+        for (const literal of literals(input.logical_context_path, input.physical_context_path)) {
+            let cursor = 0;
+            while ((cursor = content.indexOf(literal, cursor)) >= 0) {
+                if (!hasPathBoundaries(content, cursor, literal.length)) {
+                    cursor += Math.max(1, literal.length);
+                    continue;
+                }
+                const location = lineColumn(content, cursor);
+                matches.push({
+                    path: file,
+                    ...location,
+                    matched: literal,
+                    kind: file.toLowerCase().endsWith(".md")
+                        ? "markdown_non_link"
+                        : "code_or_config",
+                });
+                cursor += Math.max(1, literal.length);
+                if (matches.length >= MAX_MATCHES) {
+                    limits.add(`matches>=${MAX_MATCHES}`);
+                    break;
+                }
+            }
+            if (matches.length >= MAX_MATCHES)
+                break;
+        }
+        if (matches.length >= MAX_MATCHES)
+            break;
+    }
+    return {
+        complete: limits.size === 0,
+        files_scanned: filesScanned,
+        bytes_scanned: bytesScanned,
+        matches,
+        limits_exceeded: [...limits].sort(),
+    };
+}
+async function discoverTextFiles(repository) {
+    const result = [];
+    const limits = new Set();
+    let stopped = false;
+    async function visit(relative) {
+        if (stopped)
+            return;
+        const absolute = relative
+            ? path.join(repository, ...relative.split("/"))
+            : repository;
+        const entries = await readdir(absolute, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => compareUtf8Paths(left.name, right.name))) {
+            const child = relative ? `${relative}/${entry.name}` : entry.name;
+            if (SKIPPED_DIRECTORIES.has(entry.name) || child === ".codex/work")
+                continue;
+            if (entry.isSymbolicLink()) {
+                limits.add(`symlink_skipped:${child}`);
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await visit(child);
+            }
+            else if (entry.isFile() && isTextCandidate(child)) {
+                result.push({
+                    path: normalizeContextPath(child),
+                    physical_path: child,
+                });
+                if (result.length > MAX_FILES) {
+                    limits.add(`file_count>${MAX_FILES}`);
+                    stopped = true;
+                    return;
+                }
+            }
+        }
+    }
+    await visit("");
+    return { files: result, limits: [...limits] };
+}
+function isTextCandidate(file) {
+    const lower = file.toLowerCase();
+    const extension = path.posix.extname(lower);
+    return (TEXT_EXTENSIONS.has(extension) ||
+        ["makefile", "dockerfile"].includes(path.posix.basename(lower)));
+}
+function literals(logicalPath, physicalPath) {
+    const variants = [logicalPath, physicalPath].flatMap((contextPath) => {
+        const encoded = contextPath.split("/").map(encodeURIComponent).join("/");
+        const windows = contextPath.replaceAll("/", "\\");
+        return [
+            contextPath,
+            `/${contextPath}`,
+            windows,
+            `\\${windows}`,
+            encoded,
+            `/${encoded}`,
+        ];
+    });
+    return [...new Set(variants)]
+        .filter(Boolean)
+        .sort((left, right) => Buffer.byteLength(right, "utf8") - Buffer.byteLength(left, "utf8") ||
+        compareUtf8Paths(left, right));
+}
+function hasPathBoundaries(content, start, length) {
+    const before = start === 0 ? "" : content[start - 1];
+    const after = content[start + length] ?? "";
+    const pathCharacter = /[A-Za-z0-9_.%/\\-]/u;
+    return ((!before || !pathCharacter.test(before)) &&
+        (!after || !pathCharacter.test(after)));
+}
+function lineColumn(content, offset) {
+    const lines = content.slice(0, offset).split(/\r\n?|\n/u);
+    return {
+        line: lines.length,
+        column: Array.from(lines.at(-1) ?? "").length + 1,
+    };
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/context-move/context-move-live-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ContextCatalog } from "../context-catalog/catalog-types.js";
+import type { ContextMutationJournal } from "../context-mutation/mutation-types.js";
+export declare function validateLiveContextMove(repository: string, catalog: ContextCatalog, journal: ContextMutationJournal): Promise<void>;

package/dist/lib/context-move/context-move-live-validation.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { analyzeContextMarkdownCatalog } from "../context-markdown/context-markdown-analysis.js";
+import { resolveCatalogFile } from "../context-catalog/catalog-paths.js";
+import { assertProtectedRepositoryFile } from "../repository-path-safety.js";
+import { validateContextContentForRole } from "../validators.js";
+import { scanStagedRepositoryForContextPath } from "./context-move-literal-scan.js";
+import { issueSignatures } from "./context-move-reference-validation.js";
+export async function validateLiveContextMove(repository, catalog, journal) {
+    if (journal.operation_data.kind !== "move")
+        invalid("move_data_required");
+    const data = journal.operation_data;
+    const owners = catalog.registered_contexts.filter((entry) => entry.path === data.to_path);
+    if (owners.length !== 1 ||
+        owners[0].source !== data.owner_source ||
+        owners[0].role !== data.role ||
+        (owners[0].read_policy ?? null) !== data.read_policy ||
+        catalog.registered_contexts.some((entry) => entry.path === data.from_path))
+        invalid("live_move_owner_mismatch");
+    const targetFile = resolveCatalogFile(catalog, data.to_path);
+    if (!targetFile)
+        invalid("live_move_target_missing");
+    const target = await assertProtectedRepositoryFile(repository, targetFile.absolute_path, "context_mutation_moved_context");
+    const content = await readFile(target, "utf8");
+    const recoveryErrors = validateContextContentForRole(repository, data.to_path, content, data.role);
+    if (recoveryErrors.length)
+        invalid(`live_move_recovery:${recoveryErrors.join("|")}`);
+    const analysis = await analyzeContextMarkdownCatalog({
+        project_root: repository,
+        files: catalog.context_files,
+        long_line_threshold: Number.MAX_SAFE_INTEGER,
+    });
+    if (analysis.references.some((entry) => entry.target_path === data.from_path))
+        invalid("live_move_stale_markdown_reference");
+    if (!sameArray(issueSignatures(analysis), data.expected_reference_issues))
+        invalid("live_move_reference_issues_mismatch");
+    const scan = await scanStagedRepositoryForContextPath({
+        repository,
+        logical_context_path: data.from_path,
+        physical_context_path: journal.files.find((entry) => entry.path === data.from_path)
+            ?.physical_path ?? data.from_path,
+        file_overrides: new Map(),
+    });
+    if (!scan.complete)
+        invalid(`live_move_scan_incomplete:${scan.limits_exceeded.join("|")}`);
+    if (scan.matches.length)
+        invalid(`live_move_unresolved_literals:${scan.matches
+            .map((entry) => `${entry.path}:${entry.line}`)
+            .join(",")}`);
+}
+function sameArray(left, right) {
+    return (left.length === right.length &&
+        left.every((entry, index) => entry === right[index]));
+}
+function invalid(reason) {
+    throw new Error(`context_mutation_invalid:${reason}`);
+}

package/dist/lib/context-move/context-move-markdown-plan.d.ts

@@ -0,0 +1,22 @@
+export interface ContextMoveMarkdownPlan {
+    target_content: string;
+    updated_context_files: Map<string, string>;
+    references_updated: Array<{
+        source_path: string;
+        line: number;
+        column: number;
+        previous_destination: string;
+        next_destination: string;
+    }>;
+}
+export declare function planContextMoveMarkdown(input: {
+    files: ReadonlyMap<string, {
+        path: string;
+        physical_path: string;
+        content: string;
+    }>;
+    from_path: string;
+    to_path: string;
+    from_physical_path: string;
+    to_physical_path: string;
+}): ContextMoveMarkdownPlan;

package/dist/lib/context-move/context-move-markdown-plan.js

@@ -0,0 +1,39 @@
+import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
+import { patchMarkdownLinksForContextMove } from "../context-mutation/markdown-link-patch.js";
+export function planContextMoveMarkdown(input) {
+    const source = input.files.get(input.from_path);
+    if (source === undefined)
+        throw new Error(`context_move_source_content_missing:${input.from_path}`);
+    const updated = new Map();
+    const references = [];
+    let targetContent = source.content;
+    for (const [file, markdown] of [...input.files].sort(([left], [right]) => compareUtf8Paths(left, right))) {
+        const patch = patchMarkdownLinksForContextMove({
+            content: markdown.content,
+            source_path: file,
+            source_physical_path: markdown.physical_path,
+            from_path: input.from_path,
+            from_physical_path: input.from_physical_path,
+            to_path: input.to_path,
+            to_physical_path: input.to_physical_path,
+        });
+        const outputPath = file === input.from_path ? input.to_path : file;
+        if (file === input.from_path)
+            targetContent = patch.content;
+        else if (patch.content !== markdown.content)
+            updated.set(file, patch.content);
+        for (const change of patch.changes)
+            references.push({
+                source_path: outputPath,
+                line: change.line,
+                column: change.column,
+                previous_destination: change.previous_destination,
+                next_destination: change.next_destination,
+            });
+    }
+    return {
+        target_content: targetContent,
+        updated_context_files: updated,
+        references_updated: references,
+    };
+}

package/dist/lib/context-move/context-move-projection.d.ts

@@ -0,0 +1,3 @@
+import type { ContextFootprintState } from "../context-mutation/mutation-types.js";
+import type { ContextMoveResult } from "./context-move-types.js";
+export declare function contextMoveFootprintDiff(before: ContextFootprintState, after: ContextFootprintState): ContextMoveResult["default_footprint"];

package/dist/lib/context-move/context-move-projection.js

@@ -0,0 +1,11 @@
+import { sameMutationArray } from "../context-mutation/mutation-command-support.js";
+export function contextMoveFootprintDiff(before, after) {
+    return {
+        changed: before.bytes !== after.bytes ||
+            !sameMutationArray(before.paths, after.paths),
+        before,
+        after,
+        added: after.paths.filter((file) => !before.paths.includes(file)),
+        removed: before.paths.filter((file) => !after.paths.includes(file)),
+    };
+}

package/dist/lib/context-move/context-move-reference-validation.d.ts

@@ -0,0 +1,11 @@
+import type { ContextMarkdownCatalogAnalysis } from "../context-markdown/context-markdown-types.js";
+import type { ContextCatalog } from "../context-catalog/catalog-types.js";
+export declare function validateStagedContextMoveReferences(input: {
+    repository: string;
+    before_catalog: ContextCatalog;
+    after_catalog: ContextCatalog;
+    file_overrides: ReadonlyMap<string, Uint8Array | null>;
+    from_path: string;
+    to_path: string;
+}): Promise<string[]>;
+export declare function issueSignatures(analysis: ContextMarkdownCatalogAnalysis): string[];

package/dist/lib/context-move/context-move-reference-validation.js

@@ -0,0 +1,64 @@
+import { analyzeContextMarkdownCatalog } from "../context-markdown/context-markdown-analysis.js";
+import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
+import { mutationCatalogFailure } from "../context-mutation/mutation-command-support.js";
+export async function validateStagedContextMoveReferences(input) {
+    const before = await analyzeContextMarkdownCatalog({
+        project_root: input.repository,
+        files: input.before_catalog.context_files,
+        long_line_threshold: Number.MAX_SAFE_INTEGER,
+    });
+    const after = await analyzeContextMarkdownCatalog({
+        project_root: input.repository,
+        files: input.after_catalog.context_files,
+        long_line_threshold: Number.MAX_SAFE_INTEGER,
+        file_overrides: input.file_overrides,
+    });
+    const previousIssues = issueCounts(before, input.from_path, input.to_path);
+    const afterIssues = issueSignatures(after);
+    const additions = [];
+    for (const issue of afterIssues) {
+        const remaining = previousIssues.get(issue) ?? 0;
+        if (remaining === 0)
+            additions.push(issue);
+        else
+            previousIssues.set(issue, remaining - 1);
+    }
+    const stale = after.references.filter((reference) => reference.target_path === input.from_path);
+    if (stale.length)
+        mutationCatalogFailure(`staged Context move leaves explicit links targeting ${input.from_path}: ${stale
+            .map((entry) => `${entry.source_path}:${entry.line}`)
+            .join(", ")}`);
+    if (additions.length)
+        mutationCatalogFailure(`staged Context move introduces Markdown reference problems: ${additions.join("; ")}`);
+    return afterIssues;
+}
+export function issueSignatures(analysis) {
+    return analysis.references
+        .filter((entry) => entry.status !== "valid")
+        .map(referenceIssueSignature)
+        .sort(compareUtf8Paths);
+}
+function issueCounts(analysis, fromPath, toPath) {
+    const result = new Map();
+    for (const reference of analysis.references) {
+        if (reference.status === "valid")
+            continue;
+        const signature = referenceIssueSignature({
+            ...reference,
+            source_path: reference.source_path === fromPath ? toPath : reference.source_path,
+            target_path: reference.target_path === fromPath ? toPath : reference.target_path,
+        });
+        result.set(signature, (result.get(signature) ?? 0) + 1);
+    }
+    return result;
+}
+function referenceIssueSignature(reference) {
+    return JSON.stringify([
+        reference.source_path,
+        reference.kind,
+        reference.status,
+        reference.target_path,
+        reference.fragment,
+        reference.detail ?? null,
+    ]);
+}

package/dist/lib/context-move/context-move-render.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMoveResult } from "./context-move-types.js";
+export declare function renderContextMoveText(result: ContextMoveResult): string;

package/dist/lib/context-move/context-move-render.js

@@ -0,0 +1,24 @@
+export function renderContextMoveText(result) {
+    const lines = [
+        `Context move: ${result.from_path} -> ${result.to_path}`,
+        `State: ${result.applied ? "committed" : "dry-run"}`,
+        `Apply readiness: ${result.can_apply ? "ready" : "blocked"}`,
+        `Owner: ${result.owner.source}/${result.owner.role}`,
+        `Transaction: ${result.transaction.id}`,
+    ];
+    if (result.directories_created.length)
+        lines.push("Directories created on apply:", ...result.directories_created.map((entry) => `- ${entry}`));
+    lines.push("File plan:");
+    for (const file of result.files)
+        lines.push(`- ${file.action} ${file.path} (${file.before_bytes} -> ${file.after_bytes} bytes)`);
+    lines.push(`Manifest replacements: ${result.manifest.replacements.length}`, `Markdown references updated: ${result.links.references_updated.length}`, `Repository scan: ${result.scan.complete ? "complete" : "incomplete"}; ${result.scan.files_scanned} files, ${result.scan.bytes_scanned} bytes`);
+    if (result.unresolved.length) {
+        lines.push("Unresolved exact references (apply is refused):");
+        for (const entry of result.unresolved)
+            lines.push(`- ${entry.path}:${entry.line}:${entry.column} ${entry.kind}: ${entry.matched}`);
+    }
+    if (result.scan.limits_exceeded.length)
+        lines.push("Scan limits (apply is refused):", ...result.scan.limits_exceeded.map((entry) => `- ${entry}`));
+    lines.push(`Default footprint: ${result.default_footprint.before.path_count}/${result.default_footprint.before.bytes} -> ${result.default_footprint.after.path_count}/${result.default_footprint.after.bytes}`, "Dry-run is the default; --apply uses the CAS/journal transaction and has no force bypass.");
+    return `${lines.join("\n")}\n`;
+}

package/dist/lib/context-move/context-move-support.d.ts

@@ -0,0 +1,10 @@
+import type { CatalogRegisteredContext, ContextCatalog } from "../context-catalog/catalog-types.js";
+export declare function assertContextMoveEndpoints(catalog: ContextCatalog, fromPath: string, toPath: string): CatalogRegisteredContext;
+export declare function assertStagedContextMoveOwner(catalog: ContextCatalog, owner: CatalogRegisteredContext, from: string, to: string): void;
+export declare function missingContextMoveDirectories(repository: string, targetPath: string): Promise<string[]>;
+export declare function readContextMoveMarkdown(repository: string, catalog: ContextCatalog): Promise<Map<string, {
+    path: string;
+    physical_path: string;
+    content: string;
+}>>;
+export declare function renderContextMoveFileDiff(file: string, before: string, after: string): string;

package/dist/lib/context-move/context-move-support.js

@@ -0,0 +1,88 @@
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { assertCatalogStagedFilePath } from "../context-catalog/catalog-staged-path-safety.js";
+import { compareUtf8Paths } from "../context-catalog/catalog-paths.js";
+import { decodeMutationUtf8, mutationCatalogFailure, mutationIoFailure, mutationMessage, } from "../context-mutation/mutation-command-support.js";
+import { assertProtectedRepositoryFile } from "../repository-path-safety.js";
+export function assertContextMoveEndpoints(catalog, fromPath, toPath) {
+    const source = catalog.registered_contexts.filter((entry) => entry.path === fromPath);
+    if (source.length !== 1)
+        mutationCatalogFailure(`context move requires exactly one registered source: ${fromPath}`);
+    const folded = fold(toPath);
+    const collision = catalog.context_files.find((entry) => fold(entry.path) === folded);
+    if (collision)
+        mutationIoFailure(`context move target already exists: ${collision.path}`);
+    const registered = catalog.registered_contexts.find((entry) => fold(entry.path) === folded);
+    if (registered)
+        mutationCatalogFailure(`context move target is already registered: ${registered.path}`);
+    return source[0];
+}
+export function assertStagedContextMoveOwner(catalog, owner, from, to) {
+    const matches = catalog.registered_contexts.filter((entry) => entry.path === to);
+    if (matches.length !== 1 ||
+        matches[0].source !== owner.source ||
+        matches[0].role !== owner.role ||
+        (matches[0].read_policy ?? null) !== (owner.read_policy ?? null) ||
+        catalog.registered_contexts.some((entry) => entry.path === from))
+        mutationCatalogFailure("staged Context move changed owner metadata");
+}
+export async function missingContextMoveDirectories(repository, targetPath) {
+    const parent = path.posix.dirname(targetPath);
+    const directories = [];
+    let cursor = "";
+    for (const segment of parent.split("/")) {
+        cursor = cursor ? `${cursor}/${segment}` : segment;
+        const absolute = path.join(repository, ...cursor.split("/"));
+        const status = await lstat(absolute).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!status)
+            directories.push(cursor);
+        else if (!status.isDirectory() || status.isSymbolicLink())
+            mutationIoFailure(`context move target parent is unsafe: ${cursor}`);
+    }
+    const staged = new Set(directories);
+    try {
+        await assertCatalogStagedFilePath(repository, targetPath, staged, "context_move_target");
+    }
+    catch (error) {
+        mutationIoFailure(`context move target is unsafe: ${mutationMessage(error)}`, error);
+    }
+    return directories;
+}
+export async function readContextMoveMarkdown(repository, catalog) {
+    const result = new Map();
+    for (const file of [...catalog.context_files].sort((left, right) => compareUtf8Paths(left.path, right.path))) {
+        try {
+            const absolute = await assertProtectedRepositoryFile(repository, file.absolute_path, "context_move_markdown");
+            result.set(file.path, {
+                path: file.path,
+                physical_path: file.physical_path,
+                content: decodeMutationUtf8(await readFile(absolute), file.path),
+            });
+        }
+        catch (error) {
+            mutationIoFailure(`unable to read Context Markdown ${file.path}: ${mutationMessage(error)}`, error);
+        }
+    }
+    return result;
+}
+export function renderContextMoveFileDiff(file, before, after) {
+    if (before === after)
+        return "";
+    const previous = before.replace(/\r\n/gu, "\n").split("\n");
+    const next = after.replace(/\r\n/gu, "\n").split("\n");
+    return [
+        `--- ${file}`,
+        `+++ ${file}`,
+        "@@ exact byte replacement @@",
+        ...previous.map((line) => `-${line}`),
+        ...next.map((line) => `+${line}`),
+        "",
+    ].join("\n");
+}
+function fold(value) {
+    return value.normalize("NFC").toLocaleLowerCase("en-US");
+}

package/dist/lib/context-move/context-move-transaction-plan.d.ts

@@ -0,0 +1,24 @@
+import type { ContextMutationPlan, MutationFileState } from "../context-mutation/mutation-types.js";
+import type { CatalogRegisteredContext, ContextCatalog } from "../context-catalog/catalog-types.js";
+import type { ContextMoveFileProjection } from "./context-move-types.js";
+export declare function buildContextMoveTransactionPlan(input: {
+    repository: string;
+    owner: CatalogRegisteredContext;
+    normalized: {
+        from_path: string;
+        to_path: string;
+    };
+    directories: string[];
+    source_before: MutationFileState;
+    source_physical_path: string;
+    manifest_before: MutationFileState;
+    manifest_bytes: Buffer;
+    target_bytes: Buffer;
+    updated_files: ReadonlyMap<string, string>;
+    before_catalog: ContextCatalog;
+    after_catalog: ContextCatalog;
+    reference_issues: string[];
+}): Promise<{
+    plan: ContextMutationPlan;
+    projections: ContextMoveFileProjection[];
+}>;