project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,180 @@
+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 { assertContextMutationOutsideActiveLongTask, contextMutationAffectedPaths, } from "../context-mutation/mutation-long-task-guard.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";
+const MANIFEST_PATH = "project_context/context.toml";
+export async function moveContext(input) {
+    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.
+    await assertContextMutationOutsideActiveLongTask(input.project_root, contextMutationAffectedPaths(planned.plan));
+    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,208 @@
+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 !== "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 !== "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;

package/dist/lib/context-mutation/markdown-link-patch.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { markdownDestinationSpans, } from "./markdown-link-spans.js";
+export function patchMarkdownLinksForContextMove(input) {
+    const changes = [];
+    const references = [];
+    for (const span of markdownDestinationSpans(input.content)) {
+        const resolved = resolveLocalDestination(span.destination, input.source_path, input.source_physical_path);
+        if (resolved.status === "ignored")
+            continue;
+        if (resolved.status !== "local") {
+            references.push({
+                kind: span.kind,
+                line: span.line,
+                column: span.column,
+                destination: span.destination,
+                target_path: null,
+                status: resolved.status,
+                detail: resolved.detail,
+            });
+            continue;
+        }
+        references.push({
+            kind: span.kind,
+            line: span.line,
+            column: span.column,
+            destination: span.destination,
+            target_path: resolved.target_path,
+            status: "local",
+        });
+        const sourceMoves = input.source_path === input.from_path;
+        if (sourceMoves && input.source_physical_path !== input.from_physical_path)
+            throw new Error("context_move_source_physical_path_mismatch");
+        const targetMoves = resolved.target_path === input.from_path;
+        if (!targetMoves && !(sourceMoves && resolved.style === "relative"))
+            continue;
+        const targetAfter = targetMoves ? input.to_path : resolved.target_path;
+        const sourcePhysicalAfter = sourceMoves
+            ? input.to_physical_path
+            : input.source_physical_path;
+        const targetPhysicalAfter = targetMoves
+            ? input.to_physical_path
+            : resolved.physical_target_path;
+        const next = renderDestination(resolved, sourcePhysicalAfter, targetPhysicalAfter);
+        if (next === span.destination)
+            continue;
+        changes.push({
+            kind: span.kind,
+            line: span.line,
+            column: span.column,
+            previous_destination: span.destination,
+            next_destination: next,
+            target_before: resolved.target_path,
+            target_after: targetAfter,
+            range: [span.start, span.end],
+        });
+    }
+    let content = input.content;
+    for (const change of [...changes].sort((left, right) => right.range[0] - left.range[0]))
+        content = `${content.slice(0, change.range[0])}${change.next_destination}${content.slice(change.range[1])}`;
+    return { content, changes, references };
+}
+function resolveLocalDestination(destination, sourcePath, sourcePhysicalPath) {
+    if (!destination ||
+        destination.startsWith("#") ||
+        destination.startsWith("//") ||
+        /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(destination))
+        return { status: "ignored" };
+    const boundary = firstBoundary(destination);
+    const rawPath = destination.slice(0, boundary);
+    const suffix = destination.slice(boundary);
+    const windows = rawPath.includes("\\") && !rawPath.includes("/");
+    const markdownDecoded = windows
+        ? rawPath.replaceAll("\\", "/")
+        : rawPath.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/gu, "$1");
+    let decoded;
+    try {
+        decoded = decodeURIComponent(markdownDecoded).replaceAll("\\", "/");
+    }
+    catch {
+        return { status: "invalid", detail: "invalid URL encoding" };
+    }
+    const style = decoded.startsWith("/")
+        ? "root"
+        : decoded.startsWith("project_context/")
+            ? "repository"
+            : "relative";
+    const logicalCandidate = style === "root"
+        ? decoded.slice(1)
+        : style === "repository"
+            ? decoded
+            : path.posix.join(path.posix.dirname(sourcePath), decoded);
+    const physicalCandidate = style === "root"
+        ? decoded.slice(1)
+        : style === "repository"
+            ? decoded
+            : path.posix.join(path.posix.dirname(sourcePhysicalPath), decoded);
+    const normalized = path.posix.normalize(logicalCandidate).normalize("NFC");
+    const physicalNormalized = path.posix.normalize(physicalCandidate);
+    if (!normalized ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        path.posix.isAbsolute(normalized))
+        return { status: "outside", detail: "destination escapes repository" };
+    if (!physicalNormalized ||
+        physicalNormalized === ".." ||
+        physicalNormalized.startsWith("../") ||
+        path.posix.isAbsolute(physicalNormalized))
+        return { status: "outside", detail: "destination escapes repository" };
+    return {
+        status: "local",
+        target_path: normalized,
+        physical_target_path: physicalNormalized,
+        style,
+        suffix,
+        encoded: /%[0-9A-Fa-f]{2}/u.test(rawPath),
+        windows,
+        explicit_dot: decoded.startsWith("./"),
+    };
+}
+function renderDestination(original, sourcePhysicalAfter, targetPhysicalAfter) {
+    let rendered = original.style === "root"
+        ? `/${targetPhysicalAfter}`
+        : original.style === "repository"
+            ? targetPhysicalAfter
+            : path.posix.relative(path.posix.dirname(sourcePhysicalAfter), targetPhysicalAfter);
+    if (!rendered)
+        rendered = path.posix.basename(targetPhysicalAfter);
+    if (original.explicit_dot &&
+        original.style === "relative" &&
+        !rendered.startsWith("."))
+        rendered = `./${rendered}`;
+    if (original.encoded || /[\s<>()]/u.test(rendered))
+        rendered = rendered.split("/").map(encodeURIComponent).join("/");
+    if (original.windows)
+        rendered = rendered.replaceAll("/", "\\");
+    return `${rendered}${original.suffix}`;
+}
+function firstBoundary(value) {
+    const hash = value.indexOf("#");
+    const query = value.indexOf("?");
+    const candidates = [hash, query].filter((entry) => entry >= 0);
+    return candidates.length ? Math.min(...candidates) : value.length;
+}

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

@@ -0,0 +1,10 @@
+export type MarkdownDestinationKind = "inline" | "image" | "definition" | "angle";
+export interface MarkdownDestinationSpan {
+    kind: MarkdownDestinationKind;
+    destination: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+}
+export declare function markdownDestinationSpans(content: string): MarkdownDestinationSpan[];