sfora-cli 0.8.0 → 0.10.0

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

@@ -0,0 +1,79 @@
+// 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).
+// `> [!WARN]` — a callout marker whose type does not exist.
+//
+// This one is worth a mark precisely because nothing visibly breaks: an
+// unrecognized marker falls back to an ordinary blockquote, so the author sees
+// quoted prose and assumes the callout "did not save". The mark says what
+// actually happened.
+//
+// Line-based on purpose. Callouts are a line grammar (see callout.ts), and
+// reading them off the mdast tree would only re-derive the same first line of
+// the same blockquote — with a chance of disagreeing with the reader, which is
+// the one thing a linter must never do.
+import { CALLOUT_TYPES, isCalloutType } from "../../callout.js";
+import { isSkippableLine, lineText } from "../lintSource.js";
+const RULE_ID = "sfora/malformed-callout";
+const QUOTED_MARKER = /^ {0,3}>[ \t]?[ \t]*(\[!([A-Za-z]+)\])/;
+const QUOTE_LINE = /^ {0,3}>/;
+/**
+ * What people write when they mean one of ours. A word maps to a single type
+ * or to nothing: `info` reads as both "note" and "tip" depending on who is
+ * writing, and a fix that guesses wrong silently changes the document's tone.
+ * Ambiguous words still get the diagnostic — just no one-click answer.
+ */
+const ALIASES = {
+    warn: ["warning"],
+    warnings: ["warning"],
+    error: ["caution"],
+    danger: ["caution"],
+    attention: ["important"],
+    info: ["note", "tip"],
+    hint: ["note", "tip"],
+};
+export const malformedCalloutRule = {
+    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);
+            const match = QUOTED_MARKER.exec(line);
+            if (!match)
+                continue;
+            // A marker only counts on the FIRST line of a blockquote; anywhere else
+            // it is prose that happens to contain brackets.
+            if (i > 0 && QUOTE_LINE.test(lineText(ctx.lines, i - 1)))
+                continue;
+            const keyword = match[2];
+            if (isCalloutType(keyword))
+                continue;
+            const markerStart = ctx.lineStart(i) + line.indexOf(match[1]);
+            const candidates = ALIASES[keyword.toLowerCase()] ?? [];
+            const fixes = candidates.length === 1
+                ? [
+                    {
+                        label: `Change to [!${candidates[0].toUpperCase()}]`,
+                        edits: [
+                            {
+                                from: markerStart,
+                                to: markerStart + match[1].length,
+                                insert: `[!${candidates[0].toUpperCase()}]`,
+                            },
+                        ],
+                    },
+                ]
+                : [];
+            out.push({
+                from: markerStart,
+                to: markerStart + match[1].length,
+                severity: "warning",
+                ruleId: RULE_ID,
+                message: `\`${keyword}\` isn't a callout type, so this renders as a plain quote. Try ${CALLOUT_TYPES.join(", ")}.`,
+                ...(fixes.length > 0 ? { fixes } : {}),
+            });
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,60 @@
+// 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. Info, not warning: the line still reads fine, it
+// just is not counted.
+//
+// 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: "info",
+                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,93 @@
+// 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,
+                    severity: "warning",
+                    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/types.d.ts

@@ -0,0 +1,80 @@
+import type { Root } from "mdast";
+/**
+ * Nothing in sfora-law is an "error". A rule that is not sure stays silent,
+ * and a rule that is sure still only says "this will not render the way you
+ * think" — the bytes on disk are always the user's to keep.
+ */
+export type LintSeverity = "error" | "warning" | "info";
+/** A replacement over the PRE-fix document. Offsets are absolute. */
+export interface LintEdit {
+    from: number;
+    to: number;
+    insert: string;
+}
+/**
+ * One quick fix. Its edits compose atomically — they are all applied against
+ * the same document state, so they must not overlap.
+ */
+export interface LintFix {
+    label: string;
+    edits: LintEdit[];
+}
+export interface SforaDiagnostic {
+    from: number;
+    to: number;
+    severity: LintSeverity;
+    /** Namespaced, e.g. `sfora/broken-wiki-link`. Stable — the UI keys off it. */
+    ruleId: string;
+    message: string;
+    fixes?: LintFix[];
+}
+/**
+ * What a link resolver tells us about a target. Structurally the same shape as
+ * the editor's `WikiLinkResolution`, restated here so the core does not import
+ * from the app.
+ */
+export interface LintLinkResolution {
+    exists: boolean;
+    title?: string | null;
+}
+export interface LintContext {
+    source: string;
+    /** `source` split on newlines. A trailing `\r` is left on the line. */
+    lines: string[];
+    /** Absolute offset of the first character of line `i`. */
+    lineStart: (i: number) => number;
+    /**
+     * True for a fenced code block's delimiters and everything between them.
+     * Rules never fire inside a fence: the bytes there are not markdown.
+     */
+    inFence: (lineIndex: number) => boolean;
+    /** True for the frontmatter fences and everything between them. */
+    inFrontmatter: (lineIndex: number) => boolean;
+    /** Line extents of the frontmatter block, or null when there is none. */
+    frontmatter: {
+        open: number;
+        close: number;
+    } | null;
+    /** Present only when a parser was injected AND it succeeded. */
+    ast?: Root;
+    /**
+     * SYNCHRONOUS cache lookup over the target as written, prefix included
+     * (`c:42`, not `42`). `undefined` means "unknown, still resolving" and is
+     * the signal to stay silent — only an explicit `{ exists: false }` is a
+     * broken link.
+     */
+    resolveLink?: (target: string) => LintLinkResolution | undefined;
+}
+export interface LintRule {
+    id: string;
+    /** When true the rule is skipped unless `ctx.ast` is present. */
+    needsAst?: boolean;
+    run(ctx: LintContext): SforaDiagnostic[];
+}
+export interface LintSourceOptions {
+    /** Defaults to the full registry, `SFORA_LINT_RULES`. */
+    rules?: readonly LintRule[];
+    /** Injected mdast parser — `parseMarkdownAst(source).root`. */
+    parseAst?: (source: string) => Root;
+    resolveLink?: LintContext["resolveLink"];
+}

package/dist/format/lint/types.js

@@ -0,0 +1,16 @@
+// 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 contracts sfora-law rules are written against.
+//
+// A rule is a pure function from a document to spans-with-messages. It gets a
+// prepared view of the source — lines, line starts, where the code fences and
+// the frontmatter block are — so no rule re-derives that geometry and no two
+// rules disagree about whether a line is inside a fence.
+//
+// Two things are deliberately absent. There is no CodeMirror here: diagnostics
+// carry absolute offsets, and the editor adapter
+// (src/components/notes/cm-lint.ts) translates. And there is no parser here:
+// the mdast tree is INJECTED by the caller (`parseAst` in LintSourceOptions),
+// so the lint core stays dependency-free and ships in the CLI tarball with the
+// rest of the engine. `import type { Root }` is erased at compile time.
+export {};

package/dist/format/markdown/dates.js

@@ -1,3 +1,5 @@
+// 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).
 // Date <-> frontmatter helpers. Timestamps are ms-epoch internally; on the wire
 // they're ISO-8601 (or date-only for coarse fields like a card due date).
 export function toISO(ms) {

package/dist/format/markdown/document.js

@@ -1,3 +1,5 @@
+// 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 Jekyll-style document shape shared by every entity: an optional YAML
 // frontmatter fence, an H1 title (first non-empty line), then the body.
 import { parseYaml } from "./yaml.js";

package/dist/format/markdown/index.js

@@ -1,3 +1,5 @@
+// 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).
 // Shared markdown core for the agent filesystem API (/v1/fs). One battle-tested
 // implementation of frontmatter/YAML, mention rendering, slugs, dates, and the
 // document (frontmatter + H1 + body) shape — consumed by postMarkdown,

package/dist/format/markdown/mentions.js

@@ -1,3 +1,5 @@
+// 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).
 // Canonical mention syntax shared by messages / posts / cards / notes:
 //   @[Display Name](memberId)
 // On the wire we render that to a human-readable @Name and keep the display

package/dist/format/markdown/slug.js

@@ -1,3 +1,5 @@
+// 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).
 // Slug + filename helpers shared by the markdown serializers.
 // kebab-case a title: lowercase, strip accents, collapse non-alphanumerics to
 // single hyphens, trim. Empty titles fall back to "untitled". Dedupe of

package/dist/format/markdown/yaml.js

@@ -1,3 +1,5 @@
+// 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).
 // Tiny YAML for markdown frontmatter: scalars + flat string arrays only.
 // Shared by the post / card / note serializers (see ./index). No Convex imports
 // — pure string transforms, safe to import from httpActions, internal Convex