sfora-cli 0.9.0 → 0.11.0

package/dist/format/lint/rules/malformed-checklist.js

@@ -0,0 +1,65 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// Checkboxes that miss `CHECKBOX_RE` by one character.
+//
+// `- [] ship it`, `- [ x] ship it`, `- [x]ship it` — all three look like tasks
+// to a human and count as none to `checklistProgress`, so the card says 0/3
+// and nobody can see why.
+//
+// A HINT, the quietest of the four levels, and the only rule that sits there.
+// It is the level for "the render is exactly right and a derived number is
+// not": nothing on the page is missing or wrong — the line reads as the author
+// wrote it — and the only casualty is a progress count computed somewhere
+// else. Everything louder is reserved for bytes that do not reach the reader.
+//
+// Deliberately narrow. Only bullet lines, only brackets holding nothing but a
+// space or an `x`, and only when there is text after them — `- []` on its own
+// is someone who has typed two characters of a checkbox and is still going.
+import { CHECKBOX_RE } from "../../checklist.js";
+import { codeSpanMask, isSkippableLine, lineText } from "../lintSource.js";
+const RULE_ID = "sfora/malformed-checklist";
+const NEAR_MISS = /^(\s*[-*]\s+)\[([ \t]*[xX]?[ \t]*)\](.*)$/;
+export const malformedChecklistRule = {
+    id: RULE_ID,
+    run(ctx) {
+        const out = [];
+        for (let i = 0; i < ctx.lines.length; i++) {
+            if (isSkippableLine(ctx, i))
+                continue;
+            const line = lineText(ctx.lines, i);
+            if (CHECKBOX_RE.test(line))
+                continue;
+            const match = NEAR_MISS.exec(line);
+            if (!match)
+                continue;
+            const bullet = match[1];
+            const inner = match[2];
+            const rest = match[3];
+            if (rest.trim() === "")
+                continue;
+            // `- [x](https://…)` and `- [x][ref]` are links whose text happens to be
+            // one character, not checkboxes.
+            if (rest.startsWith("(") || rest.startsWith("["))
+                continue;
+            if (codeSpanMask(line)[bullet.length])
+                continue;
+            const checked = /[xX]/.test(inner);
+            const canonical = `${bullet}[${checked ? "x" : " "}] ${rest.trim()}`;
+            const from = ctx.lineStart(i);
+            out.push({
+                from,
+                to: from + line.length,
+                severity: "hint",
+                ruleId: RULE_ID,
+                message: "This isn't a task checkbox, so it won't be counted. Tasks are exactly `- [ ] ` or `- [x] `.",
+                fixes: [
+                    {
+                        label: "Fix the checkbox",
+                        edits: [{ from, to: from + line.length, insert: canonical }],
+                    },
+                ],
+            });
+        }
+        return out;
+    },
+};

package/dist/format/lint/rules/malformed-frontmatter.d.ts

@@ -0,0 +1,2 @@
+import type { LintRule } from "../types.js";
+export declare const malformedFrontmatterRule: LintRule;

package/dist/format/lint/rules/malformed-frontmatter.js

@@ -0,0 +1,98 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// The `---` block at the top of a document.
+//
+// Structure only — is the fence closed, is every line something the reader
+// will actually read. What the VALUES mean (a `status:` that is not a real
+// status, a missing required key) is schema validation, and it belongs to the
+// frontmatter schema, not here. The registry is the seam where that rule lands
+// when it exists.
+//
+// The bar for each mark is "sfora's own parser will drop this". `parseYaml`
+// (markdown/yaml.ts) keeps `key: value` and skips everything else, so a line
+// without a colon is not a style opinion — it is a line the document does not
+// have.
+import { lineText } from "../lintSource.js";
+const RULE_ID = "sfora/malformed-frontmatter";
+const KEY = /^([^:#]+):/;
+export const malformedFrontmatterRule = {
+    id: RULE_ID,
+    run(ctx) {
+        const block = ctx.frontmatter;
+        if (!block)
+            return [];
+        const openStart = ctx.lineStart(0);
+        if (block.close === -1) {
+            return [
+                {
+                    from: openStart,
+                    to: openStart + lineText(ctx.lines, 0).length,
+                    // The one error in sfora-law. Every other rule costs the author a
+                    // sentence, a link or a count; this one costs the document its
+                    // entire identity — no title, no status, no id, and a body that
+                    // starts with three dashes. Nothing downstream of the mark means
+                    // what it says.
+                    severity: "error",
+                    ruleId: RULE_ID,
+                    // No fix: where the block was meant to end is the author's
+                    // knowledge, and guessing turns their first paragraph into metadata.
+                    message: "This `---` block is never closed, so the whole file is read as body text.",
+                },
+            ];
+        }
+        const out = [];
+        const seen = new Map();
+        for (let i = block.open + 1; i < block.close; i++) {
+            const line = lineText(ctx.lines, i);
+            const text = line.trim();
+            if (text === "" || text.startsWith("#"))
+                continue;
+            const key = KEY.exec(text)?.[1]?.trim();
+            if (!key) {
+                const from = ctx.lineStart(i);
+                out.push({
+                    from,
+                    to: from + line.length,
+                    severity: "info",
+                    ruleId: RULE_ID,
+                    message: "Frontmatter is `key: value` lines — this one has no `:`, so it won't be read.",
+                });
+                continue;
+            }
+            // Only top-level keys can collide; an indented line belongs to the
+            // value above it.
+            if (line.startsWith(" ") || line.startsWith("\t"))
+                continue;
+            const first = seen.get(key);
+            if (first === undefined) {
+                seen.set(key, i);
+                continue;
+            }
+            const from = ctx.lineStart(i);
+            out.push({
+                from,
+                to: from + line.length,
+                severity: "warning",
+                ruleId: RULE_ID,
+                message: `\`${key}\` is set twice — this line wins, so line ${first + 1} is dead.`,
+                fixes: [
+                    {
+                        // The DEAD line is the one that goes. Removing the winning line
+                        // instead would quietly change what the document says, which is
+                        // not something a lint fix is allowed to do. The newline goes with
+                        // it so the block does not grow a blank row.
+                        label: `Remove the unused \`${key}\` on line ${first + 1}`,
+                        edits: [
+                            {
+                                from: ctx.lineStart(first),
+                                to: ctx.lineStart(first + 1),
+                                insert: "",
+                            },
+                        ],
+                    },
+                ],
+            });
+        }
+        return out;
+    },
+};

package/dist/format/lint/rules/malformed-structured-block.d.ts

@@ -0,0 +1,2 @@
+import type { LintRule } from "../types.js";
+export declare const malformedStructuredBlockRule: LintRule;

package/dist/format/lint/rules/malformed-structured-block.js

@@ -0,0 +1,134 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// ```status / ```board / ```chat / ```sheet blocks that will not render.
+//
+// The parsers in blocks/parsers.ts return null for anything that does not look
+// like their block, and the renderer's answer to null is "draw a plain code
+// fence". That contract is deliberate — a malformed block stays visible and
+// copyable — but it is also silent, so an author who mistyped a sheet just
+// sees their table as code and has to guess why.
+//
+// Two levels. The block as a whole failing is a warning on the opening fence.
+// A block that parses but drops individual lines is an info per dropped line:
+// those are the expensive ones, because the block renders and the missing row
+// is only noticed later.
+//
+// The dropped lines are the PARSERS' own accounting, not a second reading of
+// their grammars — `parseStructuredBlock` reports every line it consumed and
+// every one it did not, and `blocks/dropClosure.ts` says which of those an
+// author should hear about. A rule that re-derived "would this line render"
+// from a copy of the grammar is exactly how the two drift, and it had already
+// happened: a second `state:` line renders as a state-change marker, and this
+// rule used to tell the author it would not appear.
+//
+// AST-preferred: when a tree was injected, fences come from its `code` nodes,
+// which know the language and the extent without re-deriving either. The
+// fallback scan produces the same regions for the same document, and the
+// checks downstream are shared, so both paths say the same thing.
+import { isReportableDrop, isWholeLineDrop, } from "../../blocks/dropClosure.js";
+import { parseStructuredBlock } from "../../blocks/parsers.js";
+import { isStructuredMarkdownLanguage, } from "../../blocks/structured-block-schema.js";
+import { fencedRegions, lineText } from "../lintSource.js";
+const RULE_ID = "sfora/malformed-structured-block";
+export const malformedStructuredBlockRule = {
+    id: RULE_ID,
+    run(ctx) {
+        const out = [];
+        for (const region of structuredFences(ctx)) {
+            const lang = region.lang;
+            const parsed = parseStructuredBlock(lang, contentOf(ctx, region));
+            if (parsed.data === null) {
+                const line = lineText(ctx.lines, region.open);
+                out.push({
+                    from: ctx.lineStart(region.open),
+                    to: ctx.lineStart(region.open) + line.length,
+                    severity: "warning",
+                    ruleId: RULE_ID,
+                    message: `This \`${lang}\` block can't be read, so it renders as plain code. Check the block's format.`,
+                });
+                continue;
+            }
+            for (const drop of parsed.drops) {
+                if (!isWholeLineDrop(drop.reason) || !isReportableDrop(drop.reason)) {
+                    continue;
+                }
+                const i = region.contentStart + drop.line;
+                const raw = lineText(ctx.lines, i);
+                out.push({
+                    from: ctx.lineStart(i),
+                    to: ctx.lineStart(i) + raw.length,
+                    severity: "info",
+                    ruleId: RULE_ID,
+                    message: "This line won't appear in the rendered block.",
+                    ...fixFor(ctx, lang, i, raw, drop.text),
+                });
+            }
+        }
+        return out;
+    },
+};
+/**
+ * The one-shape repair for a dropped line, when there is one. Only offer it
+ * where it demonstrably works — re-running the parser over the candidate is
+ * cheaper than reasoning about the grammar, and it makes the fix its own
+ * proof. A sheet has no such shape: where the pipes go is the author's call.
+ */
+function fixFor(ctx, lang, line, raw, text) {
+    if (lang === "sheet")
+        return {};
+    const prefix = lang === "board" ? "- " : lang === "map" ? "- [ ] " : "- @";
+    const candidate = `${prefix}${text}`;
+    const retried = parseStructuredBlock(lang, candidate);
+    if (retried.data === null || retried.consumed.length === 0)
+        return {};
+    return {
+        fixes: [
+            {
+                label: `Prefix with "${prefix}"`,
+                edits: [
+                    {
+                        from: ctx.lineStart(line) + raw.indexOf(text),
+                        to: ctx.lineStart(line) + raw.indexOf(text) + text.length,
+                        insert: candidate,
+                    },
+                ],
+            },
+        ],
+    };
+}
+/** The fence's own text, dedented by the opening delimiter's indent. */
+function contentOf(ctx, region) {
+    const lines = [];
+    for (let i = region.contentStart; i < region.contentEnd; i++) {
+        lines.push(lineText(ctx.lines, i).slice(region.indent));
+    }
+    return lines.join("\n");
+}
+function structuredFences(ctx) {
+    const scanned = fenceScan(ctx).filter((region) => isStructuredMarkdownLanguage(region.lang));
+    if (!ctx.ast)
+        return scanned;
+    // With a tree, keep only the fences micromark also read as code blocks —
+    // the tree is the authority on what is a block and what is prose that looks
+    // like one (inside a list item's lazy continuation, say).
+    const codeLines = new Set();
+    collectCodeStarts(ctx.ast, codeLines);
+    return scanned.filter((region) => codeLines.has(region.open));
+}
+function collectCodeStarts(node, out) {
+    if (node.type === "code" && node.position) {
+        out.add(node.position.start.line - 1);
+    }
+    if (Array.isArray(node.children)) {
+        for (const child of node.children)
+            collectCodeStarts(child, out);
+    }
+}
+function fenceScan(ctx) {
+    const from = ctx.frontmatter === null
+        ? 0
+        : ctx.frontmatter.close === -1
+            ? ctx.lines.length
+            : ctx.frontmatter.close + 1;
+    return fencedRegions(ctx.lines, from);
+}

package/dist/format/lint/rules/malformed-wiki-link.d.ts

@@ -0,0 +1,2 @@
+import type { LintRule } from "../types.js";
+export declare const malformedWikiLinkRule: LintRule;

package/dist/format/lint/rules/malformed-wiki-link.js

@@ -0,0 +1,43 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// Wiki-link tokens that cannot mean anything, no matter what exists.
+//
+// Only unambiguous breaks: a token with no target at all, or a known prefix
+// with nothing after it. Two near misses are deliberately NOT flagged — an
+// unknown prefix (`[[x:1]]` is a perfectly good bare post id that happens to
+// contain a colon) and an unclosed `[[` (that is a person halfway through
+// typing a link, and a squiggle under the caret is a rude way to help).
+import { scanWikiTokens } from "../lintSource.js";
+import { WIKI_LINK_PREFIXES } from "../../wikiLinks.js";
+const RULE_ID = "sfora/malformed-wiki-link";
+export const malformedWikiLinkRule = {
+    id: RULE_ID,
+    run(ctx) {
+        const out = [];
+        for (const token of scanWikiTokens(ctx)) {
+            const prefix = WIKI_LINK_PREFIXES.find(([p]) => token.target === p)?.[0];
+            const message = token.target === ""
+                ? "This link has no target, so it renders as literal `[[…]]`."
+                : prefix
+                    ? `This link is just the \`${prefix}\` prefix — there is no id after it.`
+                    : null;
+            if (message === null)
+                continue;
+            out.push({
+                from: token.from,
+                to: token.to,
+                severity: "warning",
+                ruleId: RULE_ID,
+                message,
+                fixes: [removeToken(token.from, token.to, token.hasLabel ? token.label : "")],
+            });
+        }
+        return out;
+    },
+};
+function removeToken(from, to, label) {
+    return {
+        label: label ? `Remove link, keep "${label}"` : "Remove link",
+        edits: [{ from, to, insert: label }],
+    };
+}

package/dist/format/lint/rules/orphan-reference.d.ts

@@ -0,0 +1,2 @@
+import type { LintRule } from "../types.js";
+export declare const orphanReferenceRule: LintRule;

package/dist/format/lint/rules/orphan-reference.js

@@ -0,0 +1,87 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// `[text][ref]` with no `[ref]: …` definition anywhere in the document.
+//
+// A reference link whose definition is missing renders as literal brackets —
+// the one markdown failure mode that looks like a typo rather than a feature,
+// which is why it survives so many rounds of proofreading.
+//
+// Raw scan, not mdast: a tree has no node for an undefined reference. Remark
+// resolves what it can and leaves the rest as text, so the thing we are
+// looking for is precisely the thing the tree does not contain.
+//
+// Two neighbours stay silent. Shortcut references (`[ref]` alone) are never
+// flagged — `[sic]`, `[1]` and `[TODO]` are ordinary prose, and no amount of
+// context tells them apart from a link someone forgot to define. Unused
+// definitions are not flagged either: a stale definition costs nothing and
+// deleting one is not a fix a linter should suggest.
+import { codeSpanMask, isEscaped, isSkippableLine, lineText, } from "../lintSource.js";
+const RULE_ID = "sfora/orphan-reference";
+const DEFINITION = /^ {0,3}\[([^\]]+)\]:\s*\S/;
+const USAGE = /\[([^[\]]*)\]\[([^[\]]*)\]/g;
+/** Reference labels are matched case-insensitively, with runs of whitespace
+ *  collapsed — CommonMark's rules, not ours. */
+function fold(label) {
+    return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+export const orphanReferenceRule = {
+    id: RULE_ID,
+    run(ctx) {
+        const defined = definitions(ctx);
+        const out = [];
+        for (let i = 0; i < ctx.lines.length; i++) {
+            if (isSkippableLine(ctx, i))
+                continue;
+            const line = lineText(ctx.lines, i);
+            if (DEFINITION.test(line))
+                continue;
+            const mask = codeSpanMask(line);
+            USAGE.lastIndex = 0;
+            let m;
+            while ((m = USAGE.exec(line)) !== null) {
+                if (mask[m.index] || isEscaped(line, m.index))
+                    continue;
+                const text = m[1];
+                // `[text][]` is the collapsed form: the text IS the label.
+                const label = m[2].trim() === "" ? text : m[2];
+                if (label.trim() === "" || defined.has(fold(label)))
+                    continue;
+                // `![alt][ref]` is the image form — swallow the `!` too, or removing
+                // the brackets leaves a stray bang in the sentence.
+                const bang = m.index > 0 && line[m.index - 1] === "!" ? 1 : 0;
+                const from = ctx.lineStart(i) + m.index - bang;
+                out.push({
+                    from,
+                    to: ctx.lineStart(i) + m.index + m[0].length,
+                    severity: "warning",
+                    ruleId: RULE_ID,
+                    message: `No \`[${label.trim()}]:\` definition in this document, so these brackets render as-is.`,
+                    fixes: [
+                        {
+                            label: "Convert to plain text",
+                            edits: [
+                                {
+                                    from,
+                                    to: ctx.lineStart(i) + m.index + m[0].length,
+                                    insert: text,
+                                },
+                            ],
+                        },
+                    ],
+                });
+            }
+        }
+        return out;
+    },
+};
+function definitions(ctx) {
+    const out = new Set();
+    for (let i = 0; i < ctx.lines.length; i++) {
+        if (isSkippableLine(ctx, i))
+            continue;
+        const match = DEFINITION.exec(lineText(ctx.lines, i));
+        if (match)
+            out.add(fold(match[1]));
+    }
+    return out;
+}

package/dist/format/lint/severity.d.ts

@@ -0,0 +1,15 @@
+/** Most severe first. The order IS the rank. */
+export declare const LINT_SEVERITIES: readonly ["error", "warning", "info", "hint"];
+/**
+ * Nothing in sfora-law is an alarm. Even `error` only says "sfora will read
+ * this differently than you will" — the bytes on disk are always the user's to
+ * keep, and no rule here ever refuses a document.
+ */
+export type LintSeverity = (typeof LINT_SEVERITIES)[number];
+/** 0 for `error`, 3 for `hint`. Lower is more severe. */
+export declare function severityRank(severity: LintSeverity): number;
+/** Negative when `a` is more severe than `b`. Sorts most-severe-first. */
+export declare function compareSeverity(a: LintSeverity, b: LintSeverity): number;
+/** True when `severity` is at least as severe as `floor`. */
+export declare function atLeastAsSevere(severity: LintSeverity, floor: LintSeverity): boolean;
+export declare function isLintSeverity(value: unknown): value is LintSeverity;

package/dist/format/lint/severity.js

@@ -0,0 +1,50 @@
+// GENERATED by scripts/sync-format.mjs from packages/markdown/src — DO NOT EDIT.
+// Edit packages/markdown/src and re-run the sync (any sfora-cli build does it).
+// The four levels a sfora-law diagnostic can speak at, and what each one means.
+//
+// One level is not enough. Every rule in this directory answers the same
+// question — "will this byte sequence render as the author obviously meant it
+// to?" — but the ANSWERS differ in kind, and flattening them made the gutter
+// lie in both directions: an unclosed frontmatter fence, which costs a document
+// every field it claims to have, wore the same amber as a checkbox that renders
+// perfectly and is merely uncounted.
+//
+// The ladder is ordered by WHAT IS LOST, not by how loud the rule feels:
+//
+//   error    the document as a whole stops meaning what it says. Everything
+//            downstream of the mark is read as something else entirely.
+//   warning  something the author wrote will not render as they meant it. The
+//            bytes are there; the reading is wrong.
+//   info     something the author wrote is silently dropped. The render is not
+//            wrong, it is missing a piece, and nothing on screen says so.
+//   hint     the render is exactly right. Only a derived number — a progress
+//            count, an index — comes out different than the author expects.
+//
+// Every level has at least one rule standing on it (asserted in
+// `__tests__/lint.test.ts`), because a severity nothing emits is a severity
+// nobody has thought about.
+//
+// The names match LSP's `DiagnosticSeverity` and CodeMirror's `Severity`, in
+// that order, so the editor adapter is a lookup rather than a translation.
+/** Most severe first. The order IS the rank. */
+export const LINT_SEVERITIES = ["error", "warning", "info", "hint"];
+/** 0 for `error`, 3 for `hint`. Lower is more severe. */
+export function severityRank(severity) {
+    const index = LINT_SEVERITIES.indexOf(severity);
+    // An unknown string is treated as the quietest thing we have rather than as
+    // a crash: a diagnostic that arrived from an older copy of the package must
+    // still sort somewhere.
+    return index === -1 ? LINT_SEVERITIES.length : index;
+}
+/** Negative when `a` is more severe than `b`. Sorts most-severe-first. */
+export function compareSeverity(a, b) {
+    return severityRank(a) - severityRank(b);
+}
+/** True when `severity` is at least as severe as `floor`. */
+export function atLeastAsSevere(severity, floor) {
+    return severityRank(severity) <= severityRank(floor);
+}
+export function isLintSeverity(value) {
+    return (typeof value === "string" &&
+        LINT_SEVERITIES.includes(value));
+}

package/dist/format/lint/textEdits.d.ts

@@ -0,0 +1,86 @@
+import type { LintEdit, LintFix } from "./types.js";
+/** Why a list of edits cannot be applied as one atomic change. */
+export type LintEditRejection = {
+    reason: "inverted";
+    edit: LintEdit;
+} | {
+    reason: "out-of-range";
+    edit: LintEdit;
+} | {
+    reason: "overlap";
+    edit: LintEdit;
+    conflictsWith: LintEdit;
+};
+export type LintEditResult = {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    rejection: LintEditRejection;
+};
+/**
+ * True when two edits cannot both be applied to the same document state.
+ *
+ * Proper overlap is the obvious case. The second clause is the one that bites:
+ * two pure INSERTIONS at the same offset do not overlap by any interval test,
+ * yet the text they produce depends entirely on which goes first, and a fix
+ * whose output depends on sort stability is not a fix. Adjacency
+ * (`a.to === b.from`) is fine and stays allowed — that is two rules repairing
+ * neighbouring spans, which is exactly what fix-all is for.
+ */
+export declare function editsConflict(a: LintEdit, b: LintEdit): boolean;
+/**
+ * The application order. Descending by start, then by end, so an edit that
+ * starts later lands first and leaves every earlier offset untouched.
+ *
+ * This function is the reason the offsets in a fix mean anything. Sorting it
+ * the other way still "works" for a single-edit fix — which is most of them,
+ * which is how a bug here would hide — and quietly corrupts every multi-edit
+ * one.
+ */
+export declare function sortEditsForApply(edits: readonly LintEdit[]): LintEdit[];
+/**
+ * Can these edits compose over `source`? Returns the first reason they cannot,
+ * or null. Checked against the source the edits were DERIVED from — an edit
+ * checked against a document that has moved on is meaningless.
+ */
+export declare function checkEdits(source: string, edits: readonly LintEdit[]): LintEditRejection | null;
+/**
+ * Apply `edits` to `source` as one atomic change, or say why not.
+ *
+ * Never throws and never half-applies: on any rejection the caller gets the
+ * reason and the original text is untouched. Lint is a background nicety in a
+ * text editor; it is never allowed to be the reason a document is damaged.
+ */
+export declare function tryApplyEdits(source: string, edits: readonly LintEdit[]): LintEditResult;
+/**
+ * `tryApplyEdits` for callers that have already validated, or that would
+ * rather lose the fix than reason about a rejection. Returns `source`
+ * unchanged when the edits do not compose.
+ */
+export declare function applyEdits(source: string, edits: readonly LintEdit[]): string;
+/**
+ * True when every edit still describes the bytes it was computed against.
+ *
+ * The staleness question, factored out of the editor adapter. A fix's offsets
+ * point into the source a rule read; applying them to a document that has been
+ * typed into since is not a repair, it is corruption at a plausible-looking
+ * offset. Both the CodeMirror action and the batch path ask this before they
+ * commit.
+ */
+export declare function editsMatch(source: string, edits: readonly LintEdit[], expected: string): boolean;
+/** LSP's `Position`: zero-based line, zero-based UTF-16 offset within it. */
+export interface LintPosition {
+    line: number;
+    character: number;
+}
+/** LSP's `TextEdit`, for anything that talks over a wire instead of a buffer. */
+export interface LintTextEdit {
+    range: {
+        start: LintPosition;
+        end: LintPosition;
+    };
+    newText: string;
+}
+/** One fix's edits in LSP wire form, in the order LSP wants them (any). */
+export declare function fixToTextEdits(source: string, fix: LintFix): LintTextEdit[];