project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -0,0 +1,108 @@
+import { absentMutationFileState, captureMutationFileState, mutationFileStateFromBytes, mutationTemporaryPath, } from "../context-mutation/mutation-cas.js";
+import { contextCatalogIdentity, contextFootprintState, } from "../context-mutation/mutation-staged-fs.js";
+import { compareUtf8Paths, resolveCatalogFile, } from "../context-catalog/catalog-paths.js";
+import { mutationCatalogFailure } from "../context-mutation/mutation-command-support.js";
+import { canonicalValueJson, sha256Hex } from "../strict-codec.js";
+const MANIFEST_PATH = "project_context/context.toml";
+export async function buildContextMoveTransactionPlan(input) {
+    const raw = [];
+    raw.push({
+        path: input.normalized.to_path,
+        physical_path: input.normalized.to_path,
+        before: absentMutationFileState(),
+        after: mutationFileStateFromBytes(input.target_bytes, input.source_before.mode),
+    });
+    for (const [file, content] of [...input.updated_files].sort(([left], [right]) => compareUtf8Paths(left, right))) {
+        const catalogFile = resolveCatalogFile(input.before_catalog, file);
+        if (!catalogFile)
+            mutationCatalogFailure(`Context move reference source is absent from the Catalog: ${file}`);
+        const before = await captureMutationFileState(input.repository, catalogFile.physical_path);
+        raw.push({
+            path: file,
+            physical_path: catalogFile.physical_path,
+            before,
+            after: mutationFileStateFromBytes(Buffer.from(content, "utf8"), before.mode),
+        });
+    }
+    raw.push({
+        path: MANIFEST_PATH,
+        physical_path: MANIFEST_PATH,
+        before: input.manifest_before,
+        after: mutationFileStateFromBytes(input.manifest_bytes, input.manifest_before.mode),
+    });
+    raw.push({
+        path: input.normalized.from_path,
+        physical_path: input.source_physical_path,
+        before: input.source_before,
+        after: absentMutationFileState(),
+    });
+    const afterFootprint = contextFootprintState(input.after_catalog);
+    const operationData = {
+        kind: "move",
+        ...input.normalized,
+        owner_source: input.owner.source,
+        role: input.owner.role,
+        read_policy: input.owner.read_policy ?? null,
+        expected_reference_issues: input.reference_issues,
+        expected_default_paths: afterFootprint.paths,
+        expected_default_bytes: afterFootprint.bytes,
+    };
+    const beforeIdentity = contextCatalogIdentity(input.before_catalog);
+    const afterIdentity = contextCatalogIdentity(input.after_catalog);
+    const transactionId = sha256Hex(canonicalValueJson({
+        operation: "move",
+        catalog_before_identity: beforeIdentity,
+        catalog_after_identity: afterIdentity,
+        directories: input.directories,
+        files: raw.map((entry, commit_order) => ({
+            path: entry.path,
+            physical_path: entry.physical_path,
+            before_sha256: entry.before.sha256,
+            after_sha256: entry.after.sha256,
+            commit_order,
+        })),
+        operation_data: operationData,
+    }));
+    const files = raw.map((entry, commitOrder) => ({
+        ...entry,
+        commit_order: commitOrder,
+        temporary_path: mutationTemporaryPath(entry.physical_path, transactionId, commitOrder),
+        temporary_state: null,
+        published_before: null,
+        published_after: null,
+    }));
+    return {
+        plan: {
+            transaction_id: transactionId,
+            operation: "move",
+            catalog_before_identity: beforeIdentity,
+            catalog_after_identity: afterIdentity,
+            directories: input.directories.map((directory) => ({
+                path: directory,
+                before_exists: false,
+            })),
+            files,
+            operation_data: operationData,
+        },
+        projections: files.map(fileProjection),
+    };
+}
+function fileProjection(change) {
+    return {
+        path: change.path,
+        action: !change.before.exists
+            ? "create"
+            : !change.after.exists
+                ? "delete"
+                : "update",
+        before_sha256: change.before.sha256,
+        after_sha256: change.after.sha256,
+        before_bytes: byteLength(change.before),
+        after_bytes: byteLength(change.after),
+    };
+}
+function byteLength(state) {
+    return state.bytes_base64 === null
+        ? 0
+        : Buffer.from(state.bytes_base64, "base64").length;
+}

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

@@ -0,0 +1,74 @@
+import type { ContextRole } from "../context-catalog/catalog-portable-contract.js";
+import type { ContextFootprintState } from "../context-mutation/mutation-types.js";
+import type { ContextMoveLiteralMatch } from "./context-move-literal-scan.js";
+export interface ContextMoveInput {
+    project_root: string;
+    from_path: string;
+    to_path: string;
+    apply?: boolean;
+}
+export interface ContextMoveFileProjection {
+    path: string;
+    action: "create" | "update" | "delete";
+    before_sha256: string | null;
+    after_sha256: string | null;
+    before_bytes: number;
+    after_bytes: number;
+}
+export interface ContextMoveResult {
+    schema_version: 1;
+    operation: "move";
+    applied: boolean;
+    can_apply: boolean;
+    from_path: string;
+    to_path: string;
+    owner: {
+        source: "area" | "context";
+        role: ContextRole;
+        read_policy: string | null;
+    };
+    directories_created: string[];
+    files: ContextMoveFileProjection[];
+    manifest: {
+        path: "project_context/context.toml";
+        replacements: Array<{
+            kind: "owner" | "default_child";
+            previous_literal: string;
+            next_literal: string;
+        }>;
+    };
+    links: {
+        files_changed: string[];
+        references_updated: Array<{
+            source_path: string;
+            line: number;
+            column: number;
+            previous_destination: string;
+            next_destination: string;
+        }>;
+    };
+    unresolved: ContextMoveLiteralMatch[];
+    scan: {
+        complete: boolean;
+        files_scanned: number;
+        bytes_scanned: number;
+        limits_exceeded: string[];
+    };
+    default_footprint: {
+        changed: boolean;
+        before: ContextFootprintState;
+        after: ContextFootprintState;
+        added: string[];
+        removed: string[];
+    };
+    catalog: {
+        before_identity: string;
+        after_identity: string;
+    };
+    diagnostics: string[];
+    transaction: {
+        id: string;
+        state: "dry-run" | "committed";
+        journal_present: false;
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { ContextMutationPlan } from "../context-mutation/mutation-types.js";
+import type { ContextMoveInput, ContextMoveResult } from "./context-move-types.js";
+export interface PlannedContextMove {
+    plan: ContextMutationPlan;
+    result: ContextMoveResult;
+}
+export declare function moveContext(input: ContextMoveInput): Promise<ContextMoveResult>;
+export declare function planContextMove(input: ContextMoveInput): Promise<PlannedContextMove>;

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

@@ -0,0 +1,181 @@
+import { captureMutationFileState } from "../context-mutation/mutation-cas.js";
+import { resolveCatalogFile } from "../context-catalog/catalog-paths.js";
+import { assertMutationCatalogValid, assertNoUnfinishedContextMutation, decodeMutationUtf8, loadMutationCatalog, mutationCatalogFailure, mutationIoFailure, mutationMessage, mutationStateBytes, } from "../context-mutation/mutation-command-support.js";
+import { executeContextMutationPlan } from "../context-mutation/mutation-commit.js";
+import { replaceContextManifestPath, } from "../context-mutation/manifest-lossless-patch.js";
+import { contextFootprintState, stagedFileOverrides, } from "../context-mutation/mutation-staged-fs.js";
+import { validateContextContentForRole } from "../validators.js";
+import { normalizeContextMoveInput } from "./context-move-input.js";
+import { scanStagedRepositoryForContextPath } from "./context-move-literal-scan.js";
+import { planContextMoveMarkdown } from "./context-move-markdown-plan.js";
+import { contextMoveFootprintDiff } from "./context-move-projection.js";
+import { validateStagedContextMoveReferences } from "./context-move-reference-validation.js";
+import { assertContextMoveEndpoints, assertStagedContextMoveOwner, missingContextMoveDirectories, readContextMoveMarkdown, } from "./context-move-support.js";
+import { buildContextMoveTransactionPlan } from "./context-move-transaction-plan.js";
+import { CliCommandError } from "../cli-exit.js";
+import { assertSupportedSchema } from "../schema-guard.js";
+const MANIFEST_PATH = "project_context/context.toml";
+export async function moveContext(input) {
+    if (input.apply)
+        await assertSupportedSchema(input.project_root, "context move");
+    const planned = await planContextMove(input);
+    if (!input.apply)
+        return planned.result;
+    // Preserve the established fail-fast diagnostic before evaluating a
+    // potentially inapplicable move. executeContextMutationPlan repeats this
+    // guard while holding the shared Authority interlock to close the race.
+    if (!planned.result.can_apply)
+        mutationCatalogFailure("context move cannot apply until every reported unresolved reference and scan limit is cleared");
+    try {
+        await executeContextMutationPlan(input.project_root, planned.plan);
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        mutationIoFailure(`context move transaction stopped: ${mutationMessage(error)}; inspect recovery with ty-context context transaction status`, error);
+    }
+    return {
+        ...planned.result,
+        applied: true,
+        transaction: { ...planned.result.transaction, state: "committed" },
+    };
+}
+export async function planContextMove(input) {
+    const normalized = normalizeContextMoveInput(input);
+    await assertNoUnfinishedContextMutation(input.project_root);
+    const beforeCatalog = await loadMutationCatalog(input.project_root);
+    assertMutationCatalogValid(beforeCatalog, "context move requires a valid Catalog");
+    const owner = assertContextMoveEndpoints(beforeCatalog, normalized.from_path, normalized.to_path);
+    const sourceFile = resolveCatalogFile(beforeCatalog, normalized.from_path);
+    if (!sourceFile)
+        mutationIoFailure(`context move source is missing: ${normalized.from_path}`);
+    const directories = await missingContextMoveDirectories(input.project_root, normalized.to_path);
+    const markdown = await readContextMoveMarkdown(input.project_root, beforeCatalog);
+    const markdownPlan = planContextMoveMarkdown({
+        files: markdown,
+        ...normalized,
+        from_physical_path: sourceFile.physical_path,
+        to_physical_path: normalized.to_path,
+    });
+    const sourceBefore = await captureMutationFileState(input.project_root, sourceFile.physical_path);
+    if (!sourceBefore.exists || sourceBefore.mode === null)
+        mutationIoFailure(`context move source is missing: ${normalized.from_path}`);
+    const sourceText = decodeMutationUtf8(mutationStateBytes(sourceBefore), normalized.from_path);
+    if (sourceText !== markdown.get(normalized.from_path)?.content)
+        mutationIoFailure("Context source changed while planning move");
+    const manifestBefore = await captureMutationFileState(input.project_root, MANIFEST_PATH);
+    if (!manifestBefore.exists || manifestBefore.mode === null)
+        mutationCatalogFailure("project_context/context.toml is missing");
+    const manifestText = decodeMutationUtf8(mutationStateBytes(manifestBefore), MANIFEST_PATH);
+    if (manifestText !== beforeCatalog.manifest_content)
+        mutationIoFailure("Context Catalog changed while planning move");
+    const manifestPatch = patchManifest(manifestText, normalized.from_path, normalized.to_path);
+    const targetBytes = Buffer.from(markdownPlan.target_content, "utf8");
+    const manifestBytes = Buffer.from(manifestPatch.content, "utf8");
+    const overrides = stagedFileOverrides([
+        [normalized.from_path, null],
+        [normalized.to_path, targetBytes],
+        [MANIFEST_PATH, manifestBytes],
+        ...[...markdownPlan.updated_context_files].map(([file, content]) => [file, Buffer.from(content, "utf8")]),
+    ]);
+    const directorySet = new Set(directories);
+    const afterCatalog = await loadMutationCatalog(input.project_root, overrides, directorySet);
+    assertMutationCatalogValid(afterCatalog, "staged Context move is invalid");
+    assertStagedContextMoveOwner(afterCatalog, owner, normalized.from_path, normalized.to_path);
+    const recoveryErrors = validateContextContentForRole(input.project_root, normalized.to_path, markdownPlan.target_content, owner.role);
+    if (recoveryErrors.length)
+        mutationCatalogFailure(`moved Context is not recoverable: ${recoveryErrors.join("; ")}`);
+    const referenceIssues = await validateStagedContextMoveReferences({
+        repository: input.project_root,
+        before_catalog: beforeCatalog,
+        after_catalog: afterCatalog,
+        file_overrides: overrides,
+        ...normalized,
+    });
+    const scan = await scanStagedRepositoryForContextPath({
+        repository: input.project_root,
+        logical_context_path: normalized.from_path,
+        physical_context_path: sourceFile.physical_path,
+        file_overrides: overrides,
+    });
+    const built = await buildContextMoveTransactionPlan({
+        repository: input.project_root,
+        owner,
+        normalized,
+        directories,
+        source_before: sourceBefore,
+        source_physical_path: sourceFile.physical_path,
+        manifest_before: manifestBefore,
+        manifest_bytes: manifestBytes,
+        target_bytes: targetBytes,
+        updated_files: markdownPlan.updated_context_files,
+        before_catalog: beforeCatalog,
+        after_catalog: afterCatalog,
+        reference_issues: referenceIssues,
+    });
+    const beforeFootprint = contextFootprintState(beforeCatalog);
+    const afterFootprint = contextFootprintState(afterCatalog);
+    const canApply = scan.complete && scan.matches.length === 0;
+    return {
+        plan: built.plan,
+        result: {
+            schema_version: 1,
+            operation: "move",
+            applied: false,
+            can_apply: canApply,
+            ...normalized,
+            owner: {
+                source: owner.source,
+                role: owner.role,
+                read_policy: owner.read_policy ?? null,
+            },
+            directories_created: directories,
+            files: built.projections,
+            manifest: {
+                path: MANIFEST_PATH,
+                replacements: manifestPatch.replacements.map((entry) => ({
+                    kind: entry.kind,
+                    previous_literal: entry.previous_literal,
+                    next_literal: entry.next_literal,
+                })),
+            },
+            links: {
+                files_changed: [
+                    ...new Set(markdownPlan.references_updated.map((entry) => entry.source_path)),
+                ],
+                references_updated: markdownPlan.references_updated,
+            },
+            unresolved: scan.matches,
+            scan: {
+                complete: scan.complete,
+                files_scanned: scan.files_scanned,
+                bytes_scanned: scan.bytes_scanned,
+                limits_exceeded: scan.limits_exceeded,
+            },
+            default_footprint: contextMoveFootprintDiff(beforeFootprint, afterFootprint),
+            catalog: {
+                before_identity: built.plan.catalog_before_identity,
+                after_identity: built.plan.catalog_after_identity,
+            },
+            diagnostics: [
+                ...afterCatalog.diagnostics
+                    .filter((entry) => entry.severity === "warning")
+                    .map((entry) => entry.message),
+                ...scan.limits_exceeded.map((entry) => `move scan incomplete: ${entry}`),
+            ],
+            transaction: {
+                id: built.plan.transaction_id,
+                state: "dry-run",
+                journal_present: false,
+            },
+        },
+    };
+}
+function patchManifest(content, from, to) {
+    try {
+        return replaceContextManifestPath(content, from, to);
+    }
+    catch (error) {
+        mutationCatalogFailure(`Manifest cannot be patched losslessly: ${mutationMessage(error)}`, error);
+    }
+}

package/dist/lib/context-mutation/manifest-lossless-patch.d.ts

@@ -0,0 +1,28 @@
+import type { ContextRole } from "../context-catalog/catalog-portable-contract.js";
+export interface ManifestContextBlockInput {
+    path: string;
+    role: ContextRole;
+    read_policy: string;
+    read_when?: string;
+    triggers?: string[];
+    default_children?: string[];
+}
+export interface ManifestAppendResult {
+    content: string;
+    inserted_block: string;
+    line_ending: "lf" | "crlf";
+}
+export interface ManifestPathReplacementResult {
+    content: string;
+    previous_literal: string;
+    next_literal: string;
+    range: [number, number];
+    replacements: Array<{
+        kind: "owner" | "default_child";
+        previous_literal: string;
+        next_literal: string;
+        range: [number, number];
+    }>;
+}
+export declare function appendContextManifestBlock(manifestContent: string, input: ManifestContextBlockInput): ManifestAppendResult;
+export declare function replaceContextManifestPath(manifestContent: string, fromPathInput: string, toPathInput: string): ManifestPathReplacementResult;

package/dist/lib/context-mutation/manifest-lossless-patch.js

@@ -0,0 +1,219 @@
+import { getStaticTOMLValue, parseTOML } from "toml-eslint-parser";
+import { normalizeContextPath } from "../context-catalog/catalog-paths.js";
+export function appendContextManifestBlock(manifestContent, input) {
+    parseManifest(manifestContent);
+    const eol = manifestLineEnding(manifestContent);
+    const block = renderContextBlock(input, eol);
+    const separator = appendSeparator(manifestContent, eol);
+    const content = `${manifestContent}${separator}${block}`;
+    parseManifest(content);
+    return {
+        content,
+        inserted_block: block,
+        line_ending: eol === "\r\n" ? "crlf" : "lf",
+    };
+}
+export function replaceContextManifestPath(manifestContent, fromPathInput, toPathInput) {
+    const ast = parseManifest(manifestContent);
+    const fromPath = normalizeContextPath(fromPathInput);
+    const toPath = normalizeContextPath(toPathInput);
+    const owners = [];
+    const children = [];
+    for (const node of ast.body[0].body) {
+        if (node.type === "TOMLKeyValue" && staticKey(node) === "default_files") {
+            if (node.value.type !== "TOMLArray")
+                invalid("default_files_array_required");
+            for (const element of node.value.elements)
+                collectExactString(element, fromPath, children);
+            continue;
+        }
+        if (node.type !== "TOMLTable" ||
+            node.kind !== "array" ||
+            node.key.keys.length !== 1)
+            continue;
+        const table = getStaticTOMLValue(node.key)[0];
+        if (table !== "context" && table !== "areas")
+            continue;
+        const ownerKey = table === "context" ? "path" : "context";
+        const ownerValues = node.body.filter((entry) => staticKey(entry) === ownerKey);
+        if (ownerValues.length !== 1)
+            invalid(`${table}_owner_path_key_not_unique`);
+        collectExactString(ownerValues[0].value, fromPath, owners);
+        if (table !== "context")
+            continue;
+        for (const entry of node.body) {
+            if (staticKey(entry) !== "default_children")
+                continue;
+            if (entry.value.type !== "TOMLArray")
+                invalid("default_children_array_required");
+            for (const element of entry.value.elements)
+                collectExactString(element, fromPath, children);
+        }
+    }
+    if (owners.length === 0)
+        invalid(`context_path_not_found:${fromPath}`);
+    if (owners.length !== 1)
+        invalid(`context_path_ambiguous:${fromPath}`);
+    const values = [
+        ...owners.map((value) => ({ kind: "owner", value })),
+        ...children.map((value) => ({ kind: "default_child", value })),
+    ];
+    for (const { value } of values)
+        if (value.style !== "basic" || value.multiline)
+            invalid(`context_path_literal_unsupported:${fromPath}`);
+    const nextLiteral = tomlBasicString(toPath);
+    const replacements = values.map(({ kind, value }) => ({
+        kind,
+        previous_literal: manifestContent.slice(value.range[0], value.range[1]),
+        next_literal: nextLiteral,
+        range: [value.range[0], value.range[1]],
+    }));
+    let content = manifestContent;
+    for (const replacement of [...replacements].sort((left, right) => right.range[0] - left.range[0]))
+        content = `${content.slice(0, replacement.range[0])}${replacement.next_literal}${content.slice(replacement.range[1])}`;
+    const reparsed = parseManifest(content);
+    if (!manifestHasExactOwnerPath(reparsed, toPath) ||
+        manifestHasExactManifestPath(reparsed, fromPath))
+        invalid(`context_path_replacement_unverified:${toPath}`);
+    const primary = replacements.find((entry) => entry.kind === "owner");
+    return {
+        content,
+        previous_literal: primary.previous_literal,
+        next_literal: nextLiteral,
+        range: primary.range,
+        replacements,
+    };
+}
+function staticKey(entry) {
+    return entry.key.keys.length === 1
+        ? getStaticTOMLValue(entry.key)[0]
+        : undefined;
+}
+function collectExactString(value, expected, output) {
+    if (value.type === "TOMLValue" &&
+        value.kind === "string" &&
+        normalizeContextPath(value.value) === expected)
+        output.push(value);
+}
+function renderContextBlock(input, eol) {
+    const lines = [
+        "[[context]]",
+        `path = ${tomlBasicString(input.path)}`,
+        `role = ${tomlBasicString(input.role)}`,
+        `read_policy = ${tomlBasicString(input.read_policy)}`,
+    ];
+    if (input.read_when)
+        lines.push(`read_when = ${tomlBasicString(input.read_when)}`);
+    if (input.triggers?.length)
+        lines.push(`triggers = ${tomlStringArray(input.triggers)}`);
+    if (input.default_children?.length)
+        lines.push(`default_children = ${tomlStringArray(input.default_children)}`);
+    return `${lines.join(eol)}${eol}`;
+}
+function parseManifest(content) {
+    if (content.charCodeAt(0) === 0xfeff)
+        invalid("bom_not_allowed");
+    try {
+        return parseTOML(content, { tomlVersion: "1.0" });
+    }
+    catch (error) {
+        invalid(`parse_failed:${message(error)}`);
+    }
+}
+function manifestLineEnding(content) {
+    const withoutCrLf = content.replaceAll("\r\n", "");
+    if (withoutCrLf.includes("\r"))
+        invalid("bare_cr_not_supported");
+    if (content.includes("\r\n") && withoutCrLf.includes("\n"))
+        invalid("mixed_line_endings_not_supported");
+    return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function appendSeparator(content, eol) {
+    if (content.length === 0)
+        return "";
+    if (content.endsWith(`${eol}${eol}`))
+        return "";
+    if (content.endsWith(eol))
+        return eol;
+    return `${eol}${eol}`;
+}
+function tomlStringArray(values) {
+    return `[${values.map(tomlBasicString).join(", ")}]`;
+}
+function tomlBasicString(value) {
+    let result = '"';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (character === "\\")
+            result += "\\\\";
+        else if (character === '"')
+            result += '\\"';
+        else if (character === "\b")
+            result += "\\b";
+        else if (character === "\t")
+            result += "\\t";
+        else if (character === "\n")
+            result += "\\n";
+        else if (character === "\f")
+            result += "\\f";
+        else if (character === "\r")
+            result += "\\r";
+        else if (codePoint < 0x20 || codePoint === 0x7f)
+            result += `\\u${codePoint.toString(16).padStart(4, "0")}`;
+        else
+            result += character;
+    }
+    return `${result}"`;
+}
+function manifestHasExactOwnerPath(ast, expected) {
+    return ast.body[0].body.some((node) => {
+        if (node.type !== "TOMLTable" ||
+            node.kind !== "array" ||
+            node.key.keys.length !== 1 ||
+            !["context", "areas"].includes(String(getStaticTOMLValue(node.key)[0])))
+            return false;
+        const table = getStaticTOMLValue(node.key)[0];
+        const key = table === "context" ? "path" : "context";
+        return node.body.some((entry) => entry.key.keys.length === 1 &&
+            getStaticTOMLValue(entry.key)[0] === key &&
+            entry.value.type === "TOMLValue" &&
+            entry.value.kind === "string" &&
+            normalizeContextPath(entry.value.value) === expected);
+    });
+}
+function manifestHasExactManifestPath(ast, expected) {
+    for (const node of ast.body[0].body) {
+        if (node.type === "TOMLKeyValue" &&
+            staticKey(node) === "default_files" &&
+            containsExactString(node.value, expected))
+            return true;
+        if (node.type !== "TOMLTable" ||
+            node.kind !== "array" ||
+            node.key.keys.length !== 1)
+            continue;
+        const table = getStaticTOMLValue(node.key)[0];
+        if (table !== "context" && table !== "areas")
+            continue;
+        for (const entry of node.body) {
+            const key = staticKey(entry);
+            if ((key === (table === "context" ? "path" : "context") ||
+                (table === "context" && key === "default_children")) &&
+                containsExactString(entry.value, expected))
+                return true;
+        }
+    }
+    return false;
+}
+function containsExactString(value, expected) {
+    if (value.type === "TOMLArray")
+        return value.elements.some((element) => containsExactString(element, expected));
+    return (value.type === "TOMLValue" &&
+        value.kind === "string" &&
+        normalizeContextPath(value.value) === expected);
+}
+function invalid(reason) {
+    throw new Error(`context_manifest_patch_invalid:${reason}`);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/context-mutation/markdown-link-patch.d.ts

@@ -0,0 +1,34 @@
+import { type MarkdownDestinationKind } from "./markdown-link-spans.js";
+export interface MarkdownLinkChange {
+    kind: MarkdownDestinationKind;
+    line: number;
+    column: number;
+    previous_destination: string;
+    next_destination: string;
+    target_before: string;
+    target_after: string;
+    range: [number, number];
+}
+export interface MarkdownLocalReference {
+    kind: MarkdownDestinationKind;
+    line: number;
+    column: number;
+    destination: string;
+    target_path: string | null;
+    status: "local" | "invalid" | "outside";
+    detail?: string;
+}
+export interface MarkdownLinkPatchResult {
+    content: string;
+    changes: MarkdownLinkChange[];
+    references: MarkdownLocalReference[];
+}
+export declare function patchMarkdownLinksForContextMove(input: {
+    content: string;
+    source_path: string;
+    source_physical_path: string;
+    from_path: string;
+    from_physical_path: string;
+    to_path: string;
+    to_physical_path: string;
+}): MarkdownLinkPatchResult;