sfora-cli 0.10.0 → 0.11.0

package/dist/format/lint/frontmatterSchema.js

@@ -0,0 +1,660 @@
+// 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).
+// What a document's frontmatter is allowed to say, checked.
+//
+// The last of the four partial rows in the parity charter's §2.1 that was a
+// CAPABILITY gap rather than a decision (card #299): open-knowledge validates
+// frontmatter against JSON Schema — Ajv, four dialects, per-key line anchoring,
+// path-scoped, off by default (`ok/core/markdown/lint/frontmatter-validate.ts`,
+// `okf-frontmatter/registry.ts`) — and sfora parsed frontmatter and never
+// checked a byte of it. This module is sfora's half of that row.
+//
+// ---------------------------------------------------------------------------
+// WHY NOT AJV
+// ---------------------------------------------------------------------------
+//
+// Two reasons, and the second is the one that decides it.
+//
+// The lint core carries no third-party import at all. It is copied verbatim
+// into the published CLI (`packages/sfora/scripts/sync-format.mjs`), so a
+// dependency here is a dependency in the tarball, and the same rules have to
+// run in a Convex mutation, in the editor and in the CLI. `appliesTo.ts` made
+// exactly this trade already, for exactly this reason, and hand-rolled a glob
+// dialect rather than take picomatch.
+//
+// The deciding reason is the VALUE MODEL. Sfora's frontmatter parser
+// (`markdown/yaml.ts`) is a tiny YAML: `key: scalar` and `key: [a, b, c]`,
+// nothing else, and every value it produces is a `string` or a `string[]`.
+// There is no `true`, no `42`, no nested map — not because the parser is
+// unfinished but because that is the shape every sfora fs surface writes. So a
+// general JSON-Schema engine would spend its whole vocabulary on shapes this
+// document model cannot hold, and — much worse — would report `type: "number"`
+// failures on every numeric field in every sfora document, because `42` arrives
+// as `"42"`. Ajv would be confidently wrong here, at volume.
+//
+// What this module does instead: read the JSON Schema an author wrote, and
+// interpret it AGAINST SFORA'S VALUE MODEL. A `type: "number"` is satisfied by
+// a string that spells a number, because that is what a number looks like in
+// this document format. That is a real, stateable semantics rather than a
+// subset with holes in it, and {@link SUPPORTED_KEYWORDS} is the whole of it.
+//
+// ---------------------------------------------------------------------------
+// NOTHING IS SILENTLY IGNORED
+// ---------------------------------------------------------------------------
+//
+// The failure mode a validator has is the one `config.ts` already names: a
+// setting that quietly does nothing, so the document comes back clean and the
+// author believes they are covered. A schema keyword this module does not
+// implement is therefore REPORTED — {@link lintFrontmatterSchemas} is the
+// schema's own linter, the same shape as `lintLintConfig`, and it is what makes
+// "supported subset" a promise instead of an excuse.
+//
+// ---------------------------------------------------------------------------
+// AND IT IS OFF UNTIL A WORKSPACE TURNS IT ON
+// ---------------------------------------------------------------------------
+//
+// No schema ships enabled. `LintConfig.frontmatterSchemas` is empty until a
+// workspace declares one, and a declaration carries the document kind it is
+// for and the paths it applies to. Open-knowledge defaults its whole lint stack
+// to off for the same reason (`ok/core/markdown/lint/plugins.ts:103-108`): a
+// rule about what a document MUST contain is a house rule, and houses differ.
+import { parseYaml } from "../markdown/yaml.js";
+import { compileAppliesTo } from "./appliesTo.js";
+import { isLintSeverity } from "./severity.js";
+/* ------------------------------------------------------------------------- */
+/* The schema dialect                                                        */
+/* ------------------------------------------------------------------------- */
+/**
+ * Every keyword this module reads, and what it does with it.
+ *
+ * The list is exported because it is the contract: {@link lintFrontmatterSchemas}
+ * reports anything outside it, and the test that keeps the two honest reads
+ * this object rather than a second copy of the list.
+ *
+ * `annotation` keywords are read by nobody and reported by nobody — they are
+ * documentation, and a schema that carries a `description` for its agents is
+ * doing the right thing.
+ */
+export const SUPPORTED_KEYWORDS = {
+    $schema: "annotation",
+    $id: "annotation",
+    title: "annotation",
+    description: "annotation",
+    examples: "annotation",
+    default: "annotation",
+    type: "constraint",
+    properties: "constraint",
+    required: "constraint",
+    additionalProperties: "constraint",
+    enum: "constraint",
+    const: "constraint",
+    pattern: "constraint",
+    format: "constraint",
+    minLength: "constraint",
+    maxLength: "constraint",
+    items: "constraint",
+    minItems: "constraint",
+    maxItems: "constraint",
+    uniqueItems: "constraint",
+};
+/**
+ * The `format` values that mean something here.
+ *
+ * Deliberately five, and deliberately the five a sfora frontmatter block
+ * actually holds — a date, a timestamp, a link, an address, a slug. A `format`
+ * outside this set is reported rather than ignored, which is the whole policy
+ * of this file in one line.
+ */
+export const SUPPORTED_FORMATS = [
+    "date",
+    "date-time",
+    "uri",
+    "email",
+    "slug",
+];
+/**
+ * The declarations that apply to `path`.
+ *
+ * Fail-CLOSED where `scopeAdmits` fails open, and the asymmetry is deliberate.
+ * A scoped RULE narrows something that would otherwise run everywhere, so a
+ * document whose path we do not know keeps the rule (see `config.ts`). A
+ * frontmatter schema is the opposite: it exists only for a kind of document,
+ * and running a `decision` schema over an unknown document would report a
+ * missing `status` on a chat message. Silence is the cheaper failure here, and
+ * a declaration with NO `appliesTo` still runs on everything, which is the door
+ * for a workspace that means it.
+ */
+export function selectFrontmatterSchemas(declarations, path) {
+    if (!declarations || declarations.length === 0)
+        return [];
+    const out = [];
+    for (const declaration of declarations) {
+        const scope = compileAppliesTo(declaration.appliesTo);
+        if (scope.matchesEverything || scope.matches(path)) {
+            out.push({ declaration, scope });
+        }
+    }
+    return out;
+}
+/**
+ * The default level for each kind of violation, in the vocabulary of
+ * ./severity's ladder — which is ordered by WHAT THE DOCUMENT LOSES.
+ *
+ * `missing` and `invalid` are both `warning`: the bytes are there, and what
+ * they say is not what the workspace will read. `unknown` is `info`: the
+ * author wrote something, it renders, and nothing will ever look at it —
+ * which is the ladder's definition of `info` word for word.
+ *
+ * Nothing here is `error`. `error` on this ladder means the document as a whole
+ * stops meaning what it says, and the one rule that claims it (an unclosed
+ * `---` fence) earns it. A `status:` the schema does not recognise costs the
+ * document one field, not its identity, and a validator that shouted would
+ * teach people to turn the validator off.
+ */
+const DEFAULT_SEVERITY = {
+    missing: "warning",
+    invalid: "warning",
+    unknown: "info",
+};
+function severityFor(declaration, kind) {
+    const declared = declaration.severity;
+    if (declared !== undefined && isLintSeverity(declared))
+        return declared;
+    return DEFAULT_SEVERITY[kind];
+}
+/** `["a", "b"]` -> `` `a`, `b` ``, the one spelling every message uses. */
+function list(values) {
+    return values.map((value) => `\`${String(value)}\``).join(", ");
+}
+const FORMAT_TEST = {
+    // Calendar-shaped rather than calendar-correct: `2026-02-31` passes. A lint
+    // rule that rejected a real date because February is short would be arguing
+    // about a timezone, and this one is about a field being a date at all.
+    date: (value) => /^\d{4}-\d{2}-\d{2}$/.test(value),
+    "date-time": (value) => /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:?\d{2})?$/.test(value),
+    // A scheme and something after it. Not a URL parser: `new URL` would accept
+    // `a:b` and reject a bare `example.com`, and neither answer helps an author.
+    uri: (value) => /^[a-z][a-z0-9+.-]*:\/\/\S+$|^[a-z][a-z0-9+.-]*:\S+$/i.test(value),
+    email: (value) => /^[^\s@]+@[^\s@.]+\.[^\s@]+$/.test(value),
+    slug: (value) => /^[a-z0-9]+(-[a-z0-9]+)*$/.test(value),
+};
+/**
+ * Does `value` spell a `type`?
+ *
+ * THE WHOLE INTERPRETATION LIVES HERE. Frontmatter values arrive as strings
+ * because `markdown/yaml.ts` produces strings; a schema that says `number`
+ * means "a number is written here", and this is where those two facts meet.
+ * `integer`, `number` and `boolean` are checked against the SPELLING; `string`
+ * accepts any scalar; `array` accepts the one list form the parser produces.
+ */
+function matchesType(value, type) {
+    const isArray = Array.isArray(value);
+    switch (type) {
+        case "array":
+            return isArray;
+        case "string":
+            return !isArray;
+        case "number":
+            return !isArray && value.trim() !== "" && Number.isFinite(Number(value));
+        case "integer":
+            return !isArray && /^[+-]?\d+$/.test(value.trim());
+        case "boolean":
+            return !isArray && /^(true|false)$/i.test(value.trim());
+        case "object":
+            // Sfora's frontmatter has no nested maps at all, so a schema asking for
+            // one is asking for something this format cannot hold. Reported by
+            // `lintFrontmatterSchemas` as an unsupported type rather than failed
+            // here on every document.
+            return false;
+        case "null":
+            return !isArray && value.trim() === "";
+        default:
+            return true;
+    }
+}
+/** The article-free noun a message uses for a type. */
+function typeWord(type) {
+    return type === "array" ? "a list" : `a ${type}`;
+}
+/** Read one property schema into the checks it asks for, in report order. */
+function constraintsOf(property) {
+    const out = [];
+    const type = property.type;
+    if (typeof type === "string") {
+        out.push({
+            keyword: "type",
+            check: (value) => matchesType(value, type)
+                ? null
+                : `must be ${typeWord(type)}, and this is ${Array.isArray(value) ? "a list" : `\`${value}\``}`,
+        });
+    }
+    const constValue = property.const;
+    if (constValue !== undefined) {
+        const expected = String(constValue);
+        out.push({
+            keyword: "const",
+            check: (value) => !Array.isArray(value) && value === expected
+                ? null
+                : `must be \`${expected}\``,
+            suggest: () => expected,
+        });
+    }
+    const allowed = property.enum;
+    if (Array.isArray(allowed)) {
+        const spellings = allowed.map(String);
+        out.push({
+            keyword: "enum",
+            check: (value) => !Array.isArray(value) && spellings.includes(value)
+                ? null
+                : `must be one of ${list(spellings)}`,
+            // The near miss, and only the near miss. An author who typed `Shipped`
+            // for `shipped` gets a one-click fix; an author who typed something else
+            // entirely gets the list and no guess, because a validator that puts
+            // words in a document is worse than one that points at a line.
+            suggest: (value) => Array.isArray(value)
+                ? undefined
+                : spellings.find((candidate) => candidate.toLowerCase() === value.trim().toLowerCase()),
+        });
+    }
+    const pattern = property.pattern;
+    if (typeof pattern === "string") {
+        let re = null;
+        try {
+            re = new RegExp(pattern);
+        }
+        catch {
+            // Reported by `lintFrontmatterSchemas`. Refusing every document because
+            // the SCHEMA is broken would blame the wrong author.
+            re = null;
+        }
+        if (re) {
+            const test = re;
+            out.push({
+                keyword: "pattern",
+                check: (value) => !Array.isArray(value) && test.test(value)
+                    ? null
+                    : `must match \`${pattern}\``,
+            });
+        }
+    }
+    const format = property.format;
+    if (typeof format === "string" && format in FORMAT_TEST) {
+        const test = FORMAT_TEST[format];
+        out.push({
+            keyword: "format",
+            check: (value) => !Array.isArray(value) && test(value) ? null : `must be a ${format}`,
+        });
+    }
+    const minLength = property.minLength;
+    if (typeof minLength === "number") {
+        out.push({
+            keyword: "minLength",
+            check: (value) => !Array.isArray(value) && value.length >= minLength
+                ? null
+                : `must be at least ${minLength} characters`,
+        });
+    }
+    const maxLength = property.maxLength;
+    if (typeof maxLength === "number") {
+        out.push({
+            keyword: "maxLength",
+            check: (value) => !Array.isArray(value) && value.length <= maxLength
+                ? null
+                : `must be at most ${maxLength} characters`,
+        });
+    }
+    const minItems = property.minItems;
+    if (typeof minItems === "number") {
+        out.push({
+            keyword: "minItems",
+            check: (value) => Array.isArray(value) && value.length >= minItems
+                ? null
+                : `must list at least ${minItems}`,
+        });
+    }
+    const maxItems = property.maxItems;
+    if (typeof maxItems === "number") {
+        out.push({
+            keyword: "maxItems",
+            check: (value) => Array.isArray(value) && value.length <= maxItems
+                ? null
+                : `must list at most ${maxItems}`,
+        });
+    }
+    if (property.uniqueItems === true) {
+        out.push({
+            keyword: "uniqueItems",
+            check: (value) => !Array.isArray(value) || new Set(value).size === value.length
+                ? null
+                : "must not repeat an entry",
+        });
+    }
+    const items = property.items;
+    if (isSchemaObject(items)) {
+        const inner = constraintsOf(items);
+        out.push({
+            keyword: "items",
+            check: (value) => {
+                if (!Array.isArray(value))
+                    return null;
+                for (const entry of value) {
+                    for (const constraint of inner) {
+                        const failure = constraint.check(entry);
+                        if (failure)
+                            return `has an entry that ${failure}`;
+                    }
+                }
+                return null;
+            },
+        });
+    }
+    return out;
+}
+function isSchemaObject(value) {
+    return (typeof value === "object" && value !== null && !Array.isArray(value));
+}
+/**
+ * Check one document's frontmatter against every schema declared for it.
+ *
+ * `data` is what `markdown/yaml.ts` read, so this function grades the values
+ * SFORA WILL ACTUALLY USE rather than a second reading of the same bytes. That
+ * matters more than it sounds: a key the tiny YAML drops (no colon, a nested
+ * map) is a key the workspace does not have, and a validator that read it with
+ * a fuller parser would pass a document whose `status` no consumer can see.
+ * The structural half of that — telling the author their line was dropped —
+ * belongs to `malformed-frontmatter`, which is why this rule stays silent about
+ * it instead of saying the same thing twice.
+ */
+export function validateFrontmatter(data, schemas) {
+    const out = [];
+    for (const { declaration } of schemas) {
+        const { schema, kind } = declaration;
+        const properties = isSchemaObject(schema.properties) ? schema.properties : {};
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const name of required) {
+            if (typeof name !== "string")
+                continue;
+            if (name in data)
+                continue;
+            const property = isSchemaObject(properties[name])
+                ? properties[name]
+                : undefined;
+            // The suggestion goes in the SENTENCE, not into a fix. Where a key
+            // belongs inside a metadata block is the author's ordering, and a
+            // validator that writes a line into a document it is only supposed to
+            // grade has stopped being a linter — so a schema that names one obvious
+            // value says so, and the author types it.
+            const only = onlyValueOf(property);
+            out.push({
+                kind: "missing",
+                key: name,
+                documentKind: kind,
+                keyword: "required",
+                severity: severityFor(declaration, "missing"),
+                message: only === undefined
+                    ? `A \`${kind}\` document needs \`${name}\` in its frontmatter.`
+                    : `A \`${kind}\` document needs \`${name}\` in its frontmatter — the schema allows \`${only}\`.`,
+            });
+        }
+        for (const [name, raw] of Object.entries(data)) {
+            const property = properties[name];
+            if (!isSchemaObject(property)) {
+                if (schema.additionalProperties === false) {
+                    out.push({
+                        kind: "unknown",
+                        key: name,
+                        documentKind: kind,
+                        keyword: "additionalProperties",
+                        severity: severityFor(declaration, "unknown"),
+                        message: `Nothing reads \`${name}\` on a \`${kind}\` document — it is not in the schema.`,
+                    });
+                }
+                continue;
+            }
+            for (const constraint of constraintsOf(property)) {
+                const failure = constraint.check(raw);
+                if (failure === null)
+                    continue;
+                const suggestion = constraint.suggest?.(raw);
+                out.push({
+                    kind: "invalid",
+                    key: name,
+                    documentKind: kind,
+                    keyword: constraint.keyword,
+                    severity: severityFor(declaration, "invalid"),
+                    message: `On a \`${kind}\` document, \`${name}\` ${failure}.`,
+                    ...(suggestion === undefined ? {} : { suggestion }),
+                });
+                // One complaint per key per schema. An author who wrote `Shipped`
+                // where the enum wants `shipped` does not need to be told separately
+                // that it also failed a `pattern` derived from the same list.
+                break;
+            }
+        }
+    }
+    return out;
+}
+/** The one value a missing key could obviously take, when the schema names it. */
+function onlyValueOf(property) {
+    if (!property)
+        return undefined;
+    if (property.const !== undefined)
+        return String(property.const);
+    if (property.default !== undefined && !Array.isArray(property.default)) {
+        return String(property.default);
+    }
+    if (Array.isArray(property.enum) && property.enum.length === 1) {
+        return String(property.enum[0]);
+    }
+    return undefined;
+}
+/**
+ * Read a frontmatter block's key lines.
+ *
+ * Same reading as `parseYaml` — a top-level `key:` and nothing indented — so
+ * the line a mark lands on is the line the value came from. Duplicate keys
+ * resolve to the FIRST occurrence, which is where `malformed-frontmatter`
+ * already points its own duplicate mark, so the two rules agree about which
+ * line a key is on.
+ */
+export function frontmatterKeyLines(lines, block) {
+    const out = new Map();
+    for (let i = block.open + 1; i < block.close; i++) {
+        const raw = lines[i] ?? "";
+        if (raw.startsWith(" ") || raw.startsWith("\t"))
+            continue;
+        const text = raw.trim();
+        if (text === "" || text.startsWith("#"))
+            continue;
+        const colon = text.indexOf(":");
+        if (colon <= 0)
+            continue;
+        const key = text.slice(0, colon).trim();
+        if (key === "" || out.has(key))
+            continue;
+        out.set(key, i);
+    }
+    return out;
+}
+/** The block's body, for `parseYaml`. */
+export function frontmatterBody(lines, block) {
+    return lines.slice(block.open + 1, block.close).join("\n");
+}
+/** Read a document's frontmatter the way sfora reads it. */
+export function readFrontmatter(lines, block) {
+    return parseYaml(frontmatterBody(lines, block));
+}
+/* ------------------------------------------------------------------------- */
+/* The schema's own linter                                                   */
+/* ------------------------------------------------------------------------- */
+export const FRONTMATTER_SCHEMA_RULE_IDS = {
+    unknownKeyword: "sfora/schema-unknown-keyword",
+    unsupportedType: "sfora/schema-unsupported-type",
+    unsupportedFormat: "sfora/schema-unsupported-format",
+    invalidPattern: "sfora/schema-invalid-pattern",
+    invalidSeverity: "sfora/schema-invalid-severity",
+    invalidGlob: "sfora/schema-invalid-glob",
+    suspiciousGlob: "sfora/schema-suspicious-glob",
+    requiredNotDeclared: "sfora/schema-required-not-declared",
+    emptyKind: "sfora/schema-no-kind",
+};
+/**
+ * Types {@link matchesType} can answer for. `object` is deliberately absent.
+ *
+ * Exported for the same reason {@link SUPPORTED_FORMATS} is: it is a promise
+ * about behaviour, and its test drives the spelling each type accepts off this
+ * list rather than off a second copy of it. A type added here without a reading
+ * in `matchesType` fails that test.
+ */
+export const SUPPORTED_TYPES = [
+    "string",
+    "array",
+    "number",
+    "integer",
+    "boolean",
+    "null",
+];
+/**
+ * Read the declarations back and report every part of them that will silently
+ * do nothing.
+ *
+ * This is the promise that makes a supported SUBSET honest. An author writes a
+ * schema, this module reads the keywords it knows, and without this function
+ * every keyword it does not know would be a constraint the author believes is
+ * being enforced and that nothing enforces. `config.ts` calls that "the worst
+ * thing a linter can do, because the symptom is a clean document"; a validator
+ * has the same failure mode one layer up.
+ */
+export function lintFrontmatterSchemas(declarations) {
+    const out = [];
+    if (!declarations)
+        return out;
+    declarations.forEach((declaration, index) => {
+        if (typeof declaration.kind !== "string" || declaration.kind.trim() === "") {
+            out.push({
+                severity: "warning",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.emptyKind,
+                message: "This schema has no `kind`, so its marks cannot say which kind of document they are about.",
+                at: [index, "kind"],
+            });
+        }
+        const severity = declaration.severity;
+        if (severity !== undefined && !isLintSeverity(severity)) {
+            out.push({
+                severity: "warning",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.invalidSeverity,
+                message: `\`${String(severity)}\` is not a severity, so this schema reports at its defaults.`,
+                at: [index, "severity"],
+            });
+        }
+        const compiled = compileAppliesTo(declaration.appliesTo);
+        const patterns = declaration.appliesTo === undefined
+            ? []
+            : typeof declaration.appliesTo === "string"
+                ? [declaration.appliesTo]
+                : [...declaration.appliesTo];
+        for (const bad of compiled.invalid) {
+            out.push({
+                severity: "warning",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.invalidGlob,
+                message: `\`${bad.pattern}\` is not a usable path pattern (${bad.detail}), so this schema runs on nothing.`,
+                at: [index, "appliesTo", ...indexOf(patterns, bad.pattern)],
+            });
+        }
+        for (const doubt of compiled.suspicious) {
+            const hint = doubt.suggestion ? ` Did you mean \`${doubt.suggestion}\`?` : "";
+            out.push({
+                severity: "warning",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.suspiciousGlob,
+                message: `\`${doubt.pattern}\` does not look like a document path (${doubt.reason}).${hint}`,
+                at: [index, "appliesTo", ...indexOf(patterns, doubt.pattern)],
+            });
+        }
+        const schema = declaration.schema;
+        if (!isSchemaObject(schema))
+            return;
+        const at = [index, "schema"];
+        reportKeywords(schema, at, out);
+        const properties = isSchemaObject(schema.properties) ? schema.properties : {};
+        for (const [name, property] of Object.entries(properties)) {
+            if (!isSchemaObject(property))
+                continue;
+            reportProperty(property, [...at, "properties", name], out);
+        }
+        // A `required` key with no `properties` entry is the quietest hole of all:
+        // the presence check runs, and every constraint the author thinks they
+        // wrote for that key is somewhere else entirely.
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        required.forEach((name, i) => {
+            if (typeof name !== "string")
+                return;
+            if (name in properties)
+                return;
+            out.push({
+                severity: "info",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.requiredNotDeclared,
+                message: `\`${name}\` is required but has no entry under \`properties\`, so only its presence is checked.`,
+                at: [...at, "required", i],
+            });
+        });
+    });
+    return out;
+}
+function reportKeywords(schema, at, out) {
+    for (const keyword of Object.keys(schema)) {
+        if (keyword in SUPPORTED_KEYWORDS)
+            continue;
+        out.push({
+            severity: "warning",
+            ruleId: FRONTMATTER_SCHEMA_RULE_IDS.unknownKeyword,
+            message: `\`${keyword}\` is not a keyword sfora checks, so it constrains nothing. Supported: ${list(Object.keys(SUPPORTED_KEYWORDS).filter((name) => SUPPORTED_KEYWORDS[name] === "constraint"))}.`,
+            at: [...at, keyword],
+        });
+    }
+}
+function reportProperty(property, at, out) {
+    reportKeywords(property, at, out);
+    const type = property.type;
+    if (typeof type === "string" &&
+        !SUPPORTED_TYPES.includes(type)) {
+        out.push({
+            severity: "warning",
+            ruleId: FRONTMATTER_SCHEMA_RULE_IDS.unsupportedType,
+            message: type === "object"
+                ? "Sfora frontmatter holds scalars and flat lists, so an `object` property can never be satisfied."
+                : `\`${type}\` is not a type sfora checks. Supported: ${list(SUPPORTED_TYPES)}.`,
+            at: [...at, "type"],
+        });
+    }
+    const format = property.format;
+    if (typeof format === "string" && !(format in FORMAT_TEST)) {
+        out.push({
+            severity: "warning",
+            ruleId: FRONTMATTER_SCHEMA_RULE_IDS.unsupportedFormat,
+            message: `\`${format}\` is not a format sfora checks, so it constrains nothing. Supported: ${list(SUPPORTED_FORMATS)}.`,
+            at: [...at, "format"],
+        });
+    }
+    const pattern = property.pattern;
+    if (typeof pattern === "string") {
+        try {
+            new RegExp(pattern);
+        }
+        catch (err) {
+            out.push({
+                severity: "warning",
+                ruleId: FRONTMATTER_SCHEMA_RULE_IDS.invalidPattern,
+                message: `\`${pattern}\` is not a usable regular expression (${err instanceof Error ? err.message : String(err)}), so it constrains nothing.`,
+                at: [...at, "pattern"],
+            });
+        }
+    }
+    const items = property.items;
+    if (isSchemaObject(items))
+        reportProperty(items, [...at, "items"], out);
+}
+/** `["appliesTo", 2]`, or just the tail when the pattern is not found. */
+function indexOf(patterns, pattern) {
+    const index = patterns.findIndex((p) => p.trim() === pattern.trim());
+    return index === -1 ? [] : [index];
+}