sfora-cli 0.8.0 → 0.10.0

package/dist/format/lineGeometry.js

@@ -0,0 +1,324 @@
+// 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).
+// Line geometry: where the fences and the frontmatter are, and which bytes
+// never reach a reader at all.
+//
+// Lint built this first and is still its heaviest user, but it is not lint's
+// to own — a checkbox-looking line inside a fence is code to the reader, to
+// `checklistProgress`, and to every other tool that walks lines instead of the
+// tree. Those callers must not carry a second, subtly different idea of where
+// a fence starts, so the scan lives here and `lint/lintSource` re-exports it.
+//
+// The second half of the file is the NON-RENDERING MASK: one same-length
+// string in which every byte that does not render — fenced code, inline code
+// spans, HTML comments, raw `<pre>`/`<code>` — has been replaced by a space.
+// Substitution, never deletion, so offset N in the mask is offset N in the
+// source by construction and a line scanner and the parsed tree can never
+// disagree about which bytes are markdown. Every scanner in the package reads
+// it; there is no second copy.
+//
+// Pure line arithmetic: no parser, no dependencies. It ships in the CLI.
+// The optional BOM only ever occurs on the first line, and allowing it here is
+// not cosmetic: without it a file that opens with a fence has no fence at all,
+// and every rule that skips fenced code would walk straight into one.
+const FENCE_OPEN = /^?( {0,3})(`{3,}|~{3,})(.*)$/;
+/** The line without its trailing `\r`, so `$`-anchored rules work on CRLF. */
+export function lineText(lines, i) {
+    const raw = lines[i] ?? "";
+    return raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+}
+/**
+ * Frontmatter extent, or null. Only a document that OPENS with `---` has
+ * frontmatter — a `---` further down is a thematic break, and treating it as a
+ * fence would make every horizontal rule the start of a lint dead zone.
+ */
+export function frontmatterExtent(lines) {
+    if (lines.length === 0)
+        return null;
+    const first = lineText(lines, 0).replace(/^/, "");
+    if (first !== "---")
+        return null;
+    for (let i = 1; i < lines.length; i++) {
+        const text = lineText(lines, i).trimEnd();
+        if (text === "---" || text === "...")
+            return { open: 0, close: i };
+    }
+    return { open: 0, close: -1 }; // opened, never closed
+}
+/**
+ * Every fenced code block in the document, in order. `from` skips the
+ * frontmatter block, whose contents are not markdown either.
+ */
+export function fencedRegions(lines, from = 0) {
+    const regions = [];
+    for (let i = from; i < lines.length; i++) {
+        const match = FENCE_OPEN.exec(lineText(lines, i));
+        if (!match)
+            continue;
+        const delimiter = match[2];
+        const info = match[3];
+        // A backtick fence's info string may not contain a backtick — that rules
+        // out inline code like ```` ```a``` ```` opening a block.
+        if (delimiter.startsWith("`") && info.includes("`"))
+            continue;
+        const char = delimiter[0];
+        const closer = new RegExp(`^ {0,3}[${char}]{${delimiter.length},}[ \\t]*$`);
+        let close = lines.length - 1;
+        let closed = false;
+        for (let j = i + 1; j < lines.length; j++) {
+            if (closer.test(lineText(lines, j))) {
+                close = j;
+                closed = true;
+                break;
+            }
+        }
+        regions.push({
+            open: i,
+            close,
+            closed,
+            lang: info.trim().split(/\s+/)[0]?.toLowerCase() ?? "",
+            indent: match[1].length,
+            contentStart: i + 1,
+            contentEnd: closed ? close : lines.length,
+        });
+        i = close;
+    }
+    return regions;
+}
+/** True for every line covered by a fenced block, delimiters included. */
+export function fenceMask(lines, from = 0) {
+    const mask = new Array(lines.length).fill(false);
+    for (const region of fencedRegions(lines, from)) {
+        for (let i = region.open; i <= region.close; i++)
+            mask[i] = true;
+    }
+    return mask;
+}
+// ── The non-rendering mask ──────────────────────────────────────────────────
+/**
+ * One past the closing backtick run of the code span opening at `start`, or
+ * null when the run never closes.
+ *
+ * CommonMark wants the closing run to be EXACTLY as long as the opening one,
+ * which is why this is a scan and not an `indexOf`: in `` `a``b` `` the double
+ * run does not close the single, and a search for "one or more backticks"
+ * ends the span three characters early. An unterminated run opens nothing —
+ * a stray backtick must not swallow the rest of the line.
+ */
+function codeSpanEnd(text, start) {
+    let open = 0;
+    while (text[start + open] === "`")
+        open++;
+    if (open === 0)
+        return null;
+    let i = start + open;
+    while (i < text.length) {
+        if (text[i] !== "`") {
+            i++;
+            continue;
+        }
+        let run = 0;
+        while (text[i + run] === "`")
+            run++;
+        if (run === open)
+            return i + run;
+        i += run;
+    }
+    return null;
+}
+/**
+ * True where a line is inside an inline code span, delimiters included.
+ *
+ * Rules and parsers mask their matches against this so a token quoted as
+ * `` `[[c:1]]` `` — the way documentation talks ABOUT the grammar — is never
+ * read as using it, and so a pipe inside `` `a|b` `` is content rather than a
+ * cell boundary. Line-local by design: a code span cannot cross a blank line,
+ * and the callers hold one line at a time.
+ */
+export function codeSpanMask(line) {
+    const mask = new Array(line.length).fill(false);
+    let i = 0;
+    while (i < line.length) {
+        if (line[i] !== "`") {
+            i++;
+            continue;
+        }
+        const end = codeSpanEnd(line, i);
+        if (end === null) {
+            while (line[i] === "`")
+                i++;
+            continue;
+        }
+        for (let k = i; k < end; k++)
+            mask[k] = true;
+        i = end;
+    }
+    return mask;
+}
+/** The raw-text tag opening at `start`, or null. */
+function rawTextTagAt(line, start) {
+    if (line[start] !== "<")
+        return null;
+    const lower = line.slice(start, start + 6).toLowerCase();
+    for (const tag of ["pre", "code"]) {
+        if (!lower.startsWith(`<${tag}`))
+            continue;
+        // `<pre>`, `<pre/>`, `<pre class=…>` — but not `<precise`.
+        const boundary = line[start + tag.length + 1];
+        if (boundary === ">" || boundary === "/" || boundary === " " || boundary === "\t") {
+            return tag;
+        }
+    }
+    return null;
+}
+/** One past the `>` closing the tag that opens at `start`, or null. */
+function htmlTagEnd(line, start) {
+    let quote = null;
+    for (let i = start; i < line.length; i++) {
+        const char = line[i];
+        if (quote !== null) {
+            if (char === quote)
+                quote = null;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+        }
+        else if (char === ">") {
+            return i + 1;
+        }
+    }
+    return null;
+}
+/** One past `</pre>` / `</code>` at or after `start`, or null. */
+function rawTextCloseEnd(line, start, tag) {
+    const match = new RegExp(`</${tag}\\s*>`, "i").exec(line.slice(start));
+    return match === null ? null : start + match.index + match[0].length;
+}
+/**
+ * Blank one line's non-rendering spans, carrying `state` forward.
+ *
+ * Order matters: a backtick inside a comment is not a code span, and a `<!--`
+ * inside a code span is not a comment, so whichever construct opens first owns
+ * everything up to its own close. Left open at the end of the line, a comment
+ * or a raw tag keeps consuming into the lines below — which is what an
+ * unterminated `<!--` does to a reader too.
+ */
+function maskLine(raw, state) {
+    const chars = raw.split("");
+    const blank = (from, to) => {
+        for (let i = from; i < to; i++)
+            chars[i] = " ";
+    };
+    let i = 0;
+    while (i < raw.length) {
+        if (state.comment) {
+            const close = raw.indexOf("-->", i);
+            blank(i, close < 0 ? raw.length : close + 3);
+            if (close < 0)
+                break;
+            state.comment = false;
+            i = close + 3;
+            continue;
+        }
+        if (state.rawTag !== null) {
+            const end = rawTextCloseEnd(raw, i, state.rawTag);
+            blank(i, end ?? raw.length);
+            if (end === null)
+                break;
+            state.rawTag = null;
+            i = end;
+            continue;
+        }
+        const char = raw[i];
+        if (char === "`") {
+            const end = codeSpanEnd(raw, i);
+            if (end === null) {
+                while (raw[i] === "`")
+                    i++;
+                continue;
+            }
+            blank(i, end);
+            i = end;
+            continue;
+        }
+        if (char === "<") {
+            if (raw.startsWith("<!--", i)) {
+                // CommonMark 0.31 admits the two degenerate spellings `<!-->` and
+                // `<!--->` as complete comments. Without them the `-->` search runs
+                // off the end, the comment is read as unterminated, and everything
+                // after it in the document is masked on the strength of five bytes.
+                const short = raw.startsWith("<!--->", i)
+                    ? 6
+                    : raw.startsWith("<!-->", i)
+                        ? 5
+                        : 0;
+                if (short > 0) {
+                    blank(i, i + short);
+                    i += short;
+                    continue;
+                }
+                const close = raw.indexOf("-->", i + 4);
+                blank(i, close < 0 ? raw.length : close + 3);
+                state.comment = close < 0;
+                if (state.comment)
+                    break;
+                i = close + 3;
+                continue;
+            }
+            const tag = rawTextTagAt(raw, i);
+            if (tag !== null) {
+                const openEnd = htmlTagEnd(raw, i);
+                // An opening tag that runs past the end of the line: nothing after it
+                // on this line can be read with any confidence, so stop here.
+                if (openEnd === null)
+                    break;
+                const closeEnd = rawTextCloseEnd(raw, openEnd, tag);
+                blank(i, closeEnd ?? raw.length);
+                state.rawTag = closeEnd === null ? tag : null;
+                if (closeEnd === null)
+                    break;
+                i = closeEnd;
+                continue;
+            }
+        }
+        i++;
+    }
+    return chars.join("");
+}
+/**
+ * The non-rendering mask, line by line. Each returned line has exactly the
+ * length of the line it masks, so `masked[i][k]` and `lines[i][k]` are the
+ * same byte position.
+ *
+ * `from` skips a leading frontmatter block for the FENCE scan only, mirroring
+ * {@link fenceMask} — whether the frontmatter itself renders is the caller's
+ * question, and lint already answers it with `inFrontmatter`.
+ */
+export function maskNonRenderingLines(lines, from = 0) {
+    const fenced = fenceMask(lines, from);
+    const state = { comment: false, rawTag: null };
+    return lines.map((raw, i) => fenced[i] ? " ".repeat(raw.length) : maskLine(raw, state));
+}
+/**
+ * The whole source, masked. `masked.length === source.length` always: the two
+ * strings are the same document, one of them with the non-markdown blanked
+ * out, and every offset holds across both.
+ */
+export function maskNonRenderingContexts(source) {
+    return maskNonRenderingLines(source.split("\n")).join("\n");
+}
+/**
+ * True when the source span `[start, end)` holds bytes but no rendering ones —
+ * the predicate a consumer asks before trusting anything it found by scanning.
+ *
+ * A span that was blank to begin with is not "non-rendering", it is empty, and
+ * answering true for it would demote every piece of whitespace in the
+ * document.
+ */
+export function isNonRenderingRange(source, masked, start, end) {
+    if (end <= start)
+        return false;
+    if (source.slice(start, end).trim() === "")
+        return false;
+    return masked.slice(start, end).trim() === "";
+}

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

@@ -0,0 +1,20 @@
+/**
+ * sfora-law: the rules a sfora markdown document is held to, and the quick
+ * fixes that satisfy them.
+ *
+ * Not a style checker. Every rule answers one question — "will this byte
+ * sequence render as the author obviously meant it to?" — and every rule that
+ * cannot answer with certainty says nothing. There is no line length, no
+ * heading order, no trailing whitespace. Markdown is the user's file; lint is
+ * only allowed to point at places where sfora will read it differently than
+ * they will.
+ *
+ * The core is pure: no CodeMirror, no unified. Diagnostics carry absolute
+ * offsets and the editor adapter (src/components/notes/cm-lint.ts) translates
+ * them; an mdast tree, when one is wanted, is injected. That is what lets the
+ * same rules run in the CLI before an agent PUTs a file as run in the editor
+ * while a human types it.
+ */
+export * from "./types.js";
+export * from "./lintSource.js";
+export * from "./rules/index.js";

package/dist/format/lint/index.js

@@ -0,0 +1,22 @@
+// 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).
+/**
+ * sfora-law: the rules a sfora markdown document is held to, and the quick
+ * fixes that satisfy them.
+ *
+ * Not a style checker. Every rule answers one question — "will this byte
+ * sequence render as the author obviously meant it to?" — and every rule that
+ * cannot answer with certainty says nothing. There is no line length, no
+ * heading order, no trailing whitespace. Markdown is the user's file; lint is
+ * only allowed to point at places where sfora will read it differently than
+ * they will.
+ *
+ * The core is pure: no CodeMirror, no unified. Diagnostics carry absolute
+ * offsets and the editor adapter (src/components/notes/cm-lint.ts) translates
+ * them; an mdast tree, when one is wanted, is injected. That is what lets the
+ * same rules run in the CLI before an agent PUTs a file as run in the editor
+ * while a human types it.
+ */
+export * from "./types.js";
+export * from "./lintSource.js";
+export * from "./rules/index.js";

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

@@ -0,0 +1,36 @@
+import { type WikiLink } from "../wikiLinks.js";
+import type { LintContext, LintFix, LintSourceOptions, SforaDiagnostic } from "./types.js";
+export { codeSpanMask, fenceMask, fencedRegions, frontmatterExtent, isNonRenderingRange, lineText, maskNonRenderingContexts, maskNonRenderingLines, type FenceRegion, } from "../lineGeometry.js";
+/** Lines a prose rule must not look at: fences and the frontmatter block. */
+export declare function isSkippableLine(ctx: LintContext, i: number): boolean;
+/** True when a `[` at `index` is escaped as `\[`. */
+export declare function isEscaped(line: string, index: number): boolean;
+export interface ScannedWikiToken extends WikiLink {
+    lineIndex: number;
+    /** Absolute span of the whole `[[…]]` token. */
+    from: number;
+    to: number;
+}
+/**
+ * Every `[[…]]` token outside fences, frontmatter and inline code.
+ *
+ * The engine's `wikiLinkPattern()` is the grammar of a WELL-FORMED token: it
+ * needs a non-empty body and happily spans newlines. Lint needs the opposite
+ * on both counts — it has to see `[[]]` to complain about it, and a `[[` left
+ * open at the end of a line is someone mid-typing, not a link. So the span
+ * matcher is local and one line wide; the meaning of what is inside the
+ * brackets still comes from `parseWikiToken`, which owns the prefix table.
+ */
+export declare function scanWikiTokens(ctx: LintContext): ScannedWikiToken[];
+export declare function buildLintContext(source: string, opts?: LintSourceOptions): LintContext;
+/**
+ * Run the rules over a document. Diagnostics come back in document order; a
+ * rule that throws contributes none and does not take the others down with it.
+ */
+export declare function lintSource(source: string, opts?: LintSourceOptions): SforaDiagnostic[];
+/**
+ * Apply a fix to the source it was computed against. Edits are applied last
+ * one first so earlier offsets stay valid — the same reason the editor
+ * dispatches them as one transaction.
+ */
+export declare function applyLintFix(source: string, fix: LintFix): string;

package/dist/format/lint/lintSource.js

@@ -0,0 +1,154 @@
+// 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 sfora-law runner, plus the document geometry every rule shares.
+//
+// One pass builds a LintContext — line starts, the fence map, the frontmatter
+// extent — and each rule reads it. Nothing here throws: a parser that blows up
+// costs the AST, a rule that blows up costs that rule's diagnostics, and the
+// caller still gets a list. Lint is a background nicety in a text editor; it
+// is never allowed to be the reason a document will not open.
+import { codeSpanMask, fenceMask, frontmatterExtent, lineText, } from "../lineGeometry.js";
+import { MAX_PARSE_INPUT_BYTES } from "../parseWithFallback.js";
+import { parseWikiToken } from "../wikiLinks.js";
+import { SFORA_LINT_RULES } from "./rules/index.js";
+// The fence/frontmatter geometry moved to ../lineGeometry once a second
+// caller (checklist.ts) needed it, and `codeSpanMask` followed it there once a
+// third (blocks/parsers.ts) had hand-copied it. Re-exported so the rules — and
+// everything importing through lint/index, the Convex shim included — keep
+// their existing import path.
+export { codeSpanMask, fenceMask, fencedRegions, frontmatterExtent, isNonRenderingRange, lineText, maskNonRenderingContexts, maskNonRenderingLines, } from "../lineGeometry.js";
+/** Lines a prose rule must not look at: fences and the frontmatter block. */
+export function isSkippableLine(ctx, i) {
+    return ctx.inFence(i) || ctx.inFrontmatter(i);
+}
+/** True when a `[` at `index` is escaped as `\[`. */
+export function isEscaped(line, index) {
+    let slashes = 0;
+    for (let i = index - 1; i >= 0 && line[i] === "\\"; i--)
+        slashes++;
+    return slashes % 2 === 1;
+}
+/**
+ * Every `[[…]]` token outside fences, frontmatter and inline code.
+ *
+ * The engine's `wikiLinkPattern()` is the grammar of a WELL-FORMED token: it
+ * needs a non-empty body and happily spans newlines. Lint needs the opposite
+ * on both counts — it has to see `[[]]` to complain about it, and a `[[` left
+ * open at the end of a line is someone mid-typing, not a link. So the span
+ * matcher is local and one line wide; the meaning of what is inside the
+ * brackets still comes from `parseWikiToken`, which owns the prefix table.
+ */
+export function scanWikiTokens(ctx) {
+    const out = [];
+    for (let i = 0; i < ctx.lines.length; i++) {
+        if (isSkippableLine(ctx, i))
+            continue;
+        const line = lineText(ctx.lines, i);
+        const mask = codeSpanMask(line);
+        const re = /\[\[([^[\]\n]*)\]\]/g;
+        let m;
+        while ((m = re.exec(line)) !== null) {
+            if (mask[m.index] || isEscaped(line, m.index))
+                continue;
+            const from = ctx.lineStart(i) + m.index;
+            out.push({
+                ...parseWikiToken(m[1]),
+                lineIndex: i,
+                from,
+                to: from + m[0].length,
+            });
+        }
+    }
+    return out;
+}
+export function buildLintContext(source, opts = {}) {
+    const lines = source.split("\n");
+    const starts = new Array(lines.length);
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        starts[i] = offset;
+        offset += lines[i].length + 1;
+    }
+    const frontmatter = frontmatterExtent(lines);
+    const fenceScanFrom = frontmatter === null
+        ? 0
+        : frontmatter.close === -1
+            ? lines.length
+            : frontmatter.close + 1;
+    const fenced = fenceMask(lines, fenceScanFrom);
+    const fmEnd = frontmatter === null
+        ? -1
+        : frontmatter.close === -1
+            ? lines.length - 1
+            : frontmatter.close;
+    return {
+        source,
+        lines,
+        lineStart: (i) => starts[i] ?? source.length,
+        inFence: (i) => fenced[i] === true,
+        inFrontmatter: (i) => frontmatter !== null && i >= 0 && i <= fmEnd,
+        frontmatter,
+        ast: parseAstSafely(source, opts.parseAst),
+        resolveLink: opts.resolveLink,
+    };
+}
+// A throwing parser costs the AST and nothing else. The size cap is the same
+// one parseWithFallback uses: past it we are looking at a paste accident, and
+// no lint mark is worth parsing four megabytes on a keystroke.
+//
+// A leading BOM costs it too. `parseMarkdownAst` strips one before parsing, so
+// every offset in the tree it returns is one short of the source the rules
+// hold — and a rule that mixes the two paints its squiggle one character off.
+// A document that opens with a BOM is rare enough, and the AST optional
+// enough, that declining is the honest answer.
+function parseAstSafely(source, parseAst) {
+    if (!parseAst || source.length > MAX_PARSE_INPUT_BYTES)
+        return undefined;
+    if (source.charCodeAt(0) === 0xfeff)
+        return undefined;
+    try {
+        return parseAst(source);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Run the rules over a document. Diagnostics come back in document order; a
+ * rule that throws contributes none and does not take the others down with it.
+ */
+export function lintSource(source, opts = {}) {
+    const ctx = buildLintContext(source, opts);
+    const rules = opts.rules ?? SFORA_LINT_RULES;
+    const out = [];
+    for (const rule of rules) {
+        if (rule.needsAst && !ctx.ast)
+            continue;
+        try {
+            out.push(...rule.run(ctx));
+        }
+        catch {
+            // A broken rule is a missing mark, never a broken editor.
+        }
+    }
+    return out.sort((a, b) => a.from !== b.from
+        ? a.from - b.from
+        : a.to !== b.to
+            ? a.to - b.to
+            : a.ruleId.localeCompare(b.ruleId));
+}
+/**
+ * Apply a fix to the source it was computed against. Edits are applied last
+ * one first so earlier offsets stay valid — the same reason the editor
+ * dispatches them as one transaction.
+ */
+export function applyLintFix(source, fix) {
+    const edits = [...fix.edits].sort((a, b) => b.from - a.from);
+    let out = source;
+    for (const edit of edits) {
+        if (edit.from < 0 || edit.to > out.length || edit.from > edit.to)
+            continue;
+        out = out.slice(0, edit.from) + edit.insert + out.slice(edit.to);
+    }
+    return out;
+}

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

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

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

@@ -0,0 +1,45 @@
+// 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).
+// `[[c:42|Fix login]]` pointing at something that is not there.
+//
+// The whole rule turns on one asymmetry: a resolver that says `{exists: false}`
+// KNOWS the target is gone, while a resolver that returns `undefined` has not
+// looked yet (or does not recognize the prefix). Only the first is a
+// diagnostic. That is what keeps a freshly opened document from painting every
+// link dead for the half second before resolution lands.
+import { isSkippableLine, scanWikiTokens } from "../lintSource.js";
+export const brokenWikiLinkRule = {
+    id: "sfora/broken-wiki-link",
+    run(ctx) {
+        const resolve = ctx.resolveLink;
+        if (!resolve)
+            return [];
+        const out = [];
+        for (const token of scanWikiTokens(ctx)) {
+            // Empty and prefix-only targets are the malformed rule's business.
+            if (token.target === "" || token.id === "")
+                continue;
+            if (isSkippableLine(ctx, token.lineIndex))
+                continue;
+            if (resolve(token.target)?.exists !== false)
+                continue;
+            out.push({
+                from: token.from,
+                to: token.to,
+                severity: "warning",
+                ruleId: "sfora/broken-wiki-link",
+                message: `Nothing here links to \`${token.target}\` — it was deleted, or you don't have access.`,
+                // No "create the target" fix: this rule cannot know what the missing
+                // thing was meant to be, and inventing one would be a worse guess than
+                // leaving the sentence readable.
+                fixes: [
+                    {
+                        label: `Remove link, keep "${token.label}"`,
+                        edits: [{ from: token.from, to: token.to, insert: token.label }],
+                    },
+                ],
+            });
+        }
+        return out;
+    },
+};

package/dist/format/lint/rules/index.d.ts

@@ -0,0 +1,10 @@
+import { brokenWikiLinkRule } from "./broken-wiki-link.js";
+import { malformedCalloutRule } from "./malformed-callout.js";
+import { malformedChecklistRule } from "./malformed-checklist.js";
+import { malformedFrontmatterRule } from "./malformed-frontmatter.js";
+import { malformedStructuredBlockRule } from "./malformed-structured-block.js";
+import { malformedWikiLinkRule } from "./malformed-wiki-link.js";
+import { orphanReferenceRule } from "./orphan-reference.js";
+import type { LintRule } from "../types.js";
+export declare const SFORA_LINT_RULES: readonly LintRule[];
+export { brokenWikiLinkRule, malformedCalloutRule, malformedChecklistRule, malformedFrontmatterRule, malformedStructuredBlockRule, malformedWikiLinkRule, orphanReferenceRule, };

package/dist/format/lint/rules/index.js

@@ -0,0 +1,26 @@
+// 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 rule registry — sfora-law in the order its marks are read.
+//
+// Kept beside the rules rather than in lint/index.ts so the runner can import
+// it without the barrel importing the runner: one direction of dependency, no
+// module cycle, no half-initialized array at load time.
+//
+// Adding a rule is adding a file and a line here. Nothing else knows the list.
+import { brokenWikiLinkRule } from "./broken-wiki-link.js";
+import { malformedCalloutRule } from "./malformed-callout.js";
+import { malformedChecklistRule } from "./malformed-checklist.js";
+import { malformedFrontmatterRule } from "./malformed-frontmatter.js";
+import { malformedStructuredBlockRule } from "./malformed-structured-block.js";
+import { malformedWikiLinkRule } from "./malformed-wiki-link.js";
+import { orphanReferenceRule } from "./orphan-reference.js";
+export const SFORA_LINT_RULES = [
+    brokenWikiLinkRule,
+    malformedWikiLinkRule,
+    malformedCalloutRule,
+    malformedStructuredBlockRule,
+    orphanReferenceRule,
+    malformedChecklistRule,
+    malformedFrontmatterRule,
+];
+export { brokenWikiLinkRule, malformedCalloutRule, malformedChecklistRule, malformedFrontmatterRule, malformedStructuredBlockRule, malformedWikiLinkRule, orphanReferenceRule, };

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

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