@chat-de-hp/site 0.3.3 → 0.3.5

package/dist/check-core.d.ts

@@ -0,0 +1,27 @@
+export type ConformanceRule = "annotations" | "fallbacks" | "seed" | "seed-schema";
+export type ConformanceViolation = {
+    /** CMS field slug, or collection slug for seed-schema violations. */
+    field: string;
+    /** Site-root-relative path, always POSIX-separated. */
+    file: string;
+    line: number;
+    message: string;
+    rule: ConformanceRule;
+};
+/**
+ * Reports conformance violations for a bounded set of site sources.
+ *
+ * The invariant behind the screenshot-editing fast path: a rendered CMS-backed
+ * value is annotated, or the build fails. See
+ * `plans/019-screenshot-site-editing.md` §7.
+ */
+export type ConformanceSource = {
+    file: string;
+    source: string;
+};
+export declare function checkSiteConformanceSources(options: {
+    files: AsyncIterable<ConformanceSource> | Iterable<ConformanceSource>;
+    maxViolations?: number;
+    seed: ConformanceSource;
+}): Promise<ConformanceViolation[]>;
+//# sourceMappingURL=check-core.d.ts.map

package/dist/check-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-core.d.ts","sourceRoot":"","sources":["../src/check-core.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,aAAa,GACb,WAAW,GACX,MAAM,GACN,aAAa,CAAC;AAElB,MAAM,MAAM,oBAAoB,GAAG;IACjC,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA2BF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,2BAA2B,CAAC,OAAO,EAAE;IACzD,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,iBAAiB,CAAC;CACzB,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAwBlC"}

package/dist/check-core.js

@@ -0,0 +1,638 @@
+export async function checkSiteConformanceSources(options) {
+    const seed = parseSeed(options.seed);
+    const violations = checkSeedSchema(seed);
+    if (seed.fields.size === 0) {
+        return sortViolations(violations);
+    }
+    for await (const file of options.files) {
+        violations.push(...checkAstroSource({
+            relativePath: file.file,
+            seed,
+            source: file.source,
+        }));
+        if (options.maxViolations !== undefined &&
+            violations.length >= options.maxViolations) {
+            return sortViolations(violations).slice(0, options.maxViolations);
+        }
+    }
+    return sortViolations(violations);
+}
+function checkSeedSchema(seed) {
+    const violations = seed.collections
+        .filter((collection) => collection.supportsDrafts && !collection.supportsRevisions)
+        .map((collection) => ({
+        field: collection.slug,
+        file: seed.file,
+        line: 1,
+        message: `Collection "${collection.slug}" enables "drafts" without "revisions". Add "revisions", or remove "drafts" and do not use the publish flow.`,
+        rule: "seed-schema",
+    }));
+    const collections = new Set(seed.collections.map((collection) => collection.slug));
+    const unknownCollections = new Set();
+    for (const provided of seed.provided) {
+        const separator = provided.indexOf(".");
+        const collection = provided.slice(0, separator);
+        const field = provided.slice(separator + 1);
+        if (!collections.has(collection)) {
+            if (!unknownCollections.has(collection)) {
+                unknownCollections.add(collection);
+                violations.push({
+                    field: collection,
+                    file: seed.file,
+                    line: 1,
+                    message: `Content collection "${collection}" has seed data but no matching collection is declared.`,
+                    rule: "seed-schema",
+                });
+            }
+            continue;
+        }
+        if (!seed.declared.has(provided)) {
+            violations.push({
+                field,
+                file: seed.file,
+                line: 1,
+                message: `Content field "${collection}.${field}" is provided but not declared in collection "${collection}".`,
+                rule: "seed-schema",
+            });
+        }
+    }
+    return violations;
+}
+function sortViolations(violations) {
+    return violations.sort((left, right) => left.file.localeCompare(right.file) ||
+        left.line - right.line ||
+        left.field.localeCompare(right.field));
+}
+function checkAstroSource(input) {
+    const { frontmatter, frontmatterLineOffset, template, templateLineOffset } = splitAstro(input.source);
+    const locals = collectLocals(frontmatter, input.seed);
+    const violations = [];
+    const renderedFields = new Set();
+    violations.push(...findFallbacks({
+        code: frontmatter,
+        lineOffset: frontmatterLineOffset,
+        opaque: locals.opaque,
+        relativePath: input.relativePath,
+        seed: input.seed,
+    }), ...findFallbacks({
+        code: template,
+        lineOffset: templateLineOffset,
+        opaque: locals.opaque,
+        relativePath: input.relativePath,
+        seed: input.seed,
+    }));
+    for (const render of findRenders({ locals, seed: input.seed, template })) {
+        renderedFields.add(`${render.collection}.${render.field}`);
+        if (render.annotated) {
+            continue;
+        }
+        violations.push({
+            field: render.field,
+            file: input.relativePath,
+            line: templateLineOffset + render.line,
+            message: `${render.collection}.${render.field} rendered without {...<entry>.edit.${render.field}}`,
+            rule: "annotations",
+        });
+    }
+    for (const rendered of renderedFields) {
+        if (input.seed.seeded.has(rendered)) {
+            continue;
+        }
+        const [, field = ""] = rendered.split(".");
+        violations.push({
+            field,
+            file: input.relativePath,
+            line: 1,
+            message: `${rendered} rendered but absent from seed`,
+            rule: "seed",
+        });
+    }
+    return violations;
+}
+/**
+ * Splits an `.astro` file into its frontmatter and template halves, keeping the
+ * template's 1-based line offset so reported lines match the real file.
+ */
+function splitAstro(source) {
+    const match = /^(---\r?\n)([\s\S]*?)\r?\n---[^\n]*\r?\n?/u.exec(source);
+    if (!match) {
+        return {
+            frontmatter: "",
+            frontmatterLineOffset: 0,
+            template: source,
+            templateLineOffset: 0,
+        };
+    }
+    const consumed = match[0];
+    return {
+        frontmatter: match[2] ?? "",
+        // The opening `---` line sits above the frontmatter body.
+        frontmatterLineOffset: countLines(match[1] ?? ""),
+        template: source.slice(consumed.length),
+        templateLineOffset: countLines(consumed),
+    };
+}
+function countLines(text) {
+    let lines = 0;
+    for (const character of text) {
+        if (character === "\n") {
+            lines += 1;
+        }
+    }
+    return lines;
+}
+const LEADING_MEMBER_CHAIN = /^\s*[A-Za-z_$][\w$]*((?:\s*\??\.\s*[A-Za-z_$][\w$]*)+)/u;
+const MEMBER_CHAIN_ONLY = /^\s*[A-Za-z_$][\w$]*(?:\s*\??\.\s*[A-Za-z_$][\w$]*)*\s*$/u;
+/**
+ * Classifies frontmatter locals. `const eyebrow = info.data.hero_eyebrow`
+ * aliases the field it carries. `const seo = getSeoMeta(post, {...})` is
+ * opaque: its properties are derived values, so `seo.title` colliding with a
+ * field slug is not a CMS read. A local that only *selects by* a field
+ * (`items.find((i) => i.is_featured)`) is neither — it carries an entry, not
+ * that field's value.
+ */
+function collectLocals(frontmatter, seed) {
+    const aliases = new Map();
+    const opaque = new Set();
+    const declaration = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/gu;
+    let match = declaration.exec(frontmatter);
+    while (match !== null) {
+        const name = match[1] ?? "";
+        const initializer = match[2] ?? "";
+        if (!(aliases.has(name) || opaque.has(name))) {
+            const field = leadingChainField(initializer, seed);
+            if (field) {
+                aliases.set(name, field);
+            }
+            else if (!(
+            // `const data = info.data` re-roots an entry, not a derived value.
+            (MEMBER_CHAIN_ONLY.test(initializer) ||
+                // Awaited initializers are entry/settings fetches; their fields count.
+                /\bawait\b/u.test(initializer) ||
+                firstFieldRead(initializer, seed)))) {
+                opaque.add(name);
+            }
+        }
+        match = declaration.exec(frontmatter);
+    }
+    return { aliases, opaque };
+}
+/**
+ * The CMS field read by `expression`'s leading member chain —
+ * `info.data.hero_title.split("…")` reads `hero_title`, while
+ * `items.find((i) => i.hero_title)` reads none: a field inside call arguments
+ * selects, it does not flow into the local.
+ */
+function leadingChainField(expression, seed) {
+    const chain = LEADING_MEMBER_CHAIN.exec(expression)?.[1] ?? "";
+    return firstFieldRead(chain, seed);
+}
+/**
+ * The root identifier of the member chain containing the property at `index`,
+ * or null when the chain hangs off something other than a plain identifier
+ * (`getEntry(x).title`, `rows[0].name`).
+ */
+function chainRootAt(code, index) {
+    let cursor = index - 1;
+    for (;;) {
+        while (cursor >= 0 && /\s/u.test(code[cursor] ?? "")) {
+            cursor -= 1;
+        }
+        if (code[cursor] !== ".") {
+            return null;
+        }
+        cursor -= 1;
+        if (code[cursor] === "?") {
+            cursor -= 1;
+        }
+        while (cursor >= 0 && /\s/u.test(code[cursor] ?? "")) {
+            cursor -= 1;
+        }
+        const end = cursor;
+        while (cursor >= 0 && /[\w$]/u.test(code[cursor] ?? "")) {
+            cursor -= 1;
+        }
+        if (cursor === end) {
+            return null;
+        }
+        const name = code.slice(cursor + 1, end + 1);
+        let before = cursor;
+        while (before >= 0 && /\s/u.test(code[before] ?? "")) {
+            before -= 1;
+        }
+        if (code[before] !== ".") {
+            return name;
+        }
+        cursor = before;
+    }
+}
+/** The first CMS field slug read by a property access in `expression`. */
+function firstFieldRead(expression, seed) {
+    for (const access of propertyAccesses(expression)) {
+        if (seed.fields.has(access.property)) {
+            return access.property;
+        }
+    }
+    return null;
+}
+/** Every `<expr>.<name>` / `<expr>?.<name>` property read in `code`. */
+function propertyAccesses(code) {
+    const accesses = [];
+    const pattern = /\??\.\s*([A-Za-z_$][\w$]*)/gu;
+    let match = pattern.exec(code);
+    while (match !== null) {
+        accesses.push({
+            index: match.index + match[0].length - (match[1]?.length ?? 0),
+            property: match[1] ?? "",
+        });
+        match = pattern.exec(code);
+    }
+    return accesses;
+}
+function findFallbacks(input) {
+    const violations = [];
+    // `<something>.<cms field> ?? <default>` — the default belongs in seed data.
+    const pattern = /\??\.\s*([A-Za-z_$][\w$]*)\s*\?\?/gu;
+    let match = pattern.exec(input.code);
+    while (match !== null) {
+        const field = match[1] ?? "";
+        const collections = input.seed.fields.get(field);
+        const root = chainRootAt(input.code, input.code.indexOf(field, match.index));
+        if (collections?.[0] && !(root && input.opaque.has(root))) {
+            violations.push({
+                field,
+                file: input.relativePath,
+                line: input.lineOffset + lineAt(input.code, match.index),
+                message: `${collections[0].collection}.${field} has a hardcoded ?? fallback; defaults belong in seed data`,
+                rule: "fallbacks",
+            });
+        }
+        match = pattern.exec(input.code);
+    }
+    return violations;
+}
+/**
+ * Finds each CMS-backed value rendered by the template and whether an
+ * annotation covers it — either on the element it renders in or on an ancestor
+ * wrapper, which is how a transformed value stays one target.
+ *
+ * Guard reads (`{price && …}`) only test the value, so like plain HTML
+ * attributes they are not renders; the render a guard protects is checked on
+ * its own. A genuinely unannotated render is always reported, even when the
+ * same field is annotated elsewhere in the file: each render site has to carry
+ * its own annotation for the routing rule to be honest about that element.
+ */
+function findRenders(input) {
+    const annotations = findAnnotations(input.template);
+    const renders = [];
+    const seen = new Set();
+    for (const expression of templateExpressions(input.template)) {
+        for (const read of fieldsRenderedBy(expression.code, {
+            ...input,
+            callbackLocals: expression.callbackLocals,
+        })) {
+            const collections = input.seed.fields.get(read.field);
+            const collection = collections?.[0]?.collection;
+            if (!collection || isGuardRead(expression.code, read.index)) {
+                continue;
+            }
+            // Offsets are absolute so an annotation on an ancestor covers the read.
+            const index = expression.index + read.index;
+            const line = lineAt(input.template, index);
+            const key = `${collection}.${read.field}:${line}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            renders.push({
+                annotated: isAnnotated({ annotations, field: read.field, index }),
+                collection,
+                field: read.field,
+                line,
+            });
+        }
+    }
+    return renders;
+}
+/**
+ * Whether the read at `index` only tests its value. True when what follows is a
+ * boolean operator or a ternary condition rather than the end of the
+ * expression, as in `{price && (…)}` or `{price ? … : …}`.
+ *
+ * Trailing property access is part of the read being tested, so
+ * `{image?.id && (…)}` is a guard on `image` just as `{image && (…)}` is.
+ */
+function isGuardRead(code, index) {
+    const rest = code
+        .slice(index)
+        .replace(/^[\w$]+/u, "")
+        .replace(/^(\??\.\s*[\w$]+)*\s*/u, "");
+    return /^(&&|\|\||\?[^.?])/u.test(rest);
+}
+/**
+ * CMS fields a rendered expression resolves to, directly or via an alias, each
+ * with the offset it is read at.
+ */
+function fieldsRenderedBy(code, input) {
+    const reads = [];
+    for (const access of propertyAccesses(code)) {
+        if (!input.seed.fields.has(access.property)) {
+            continue;
+        }
+        const root = chainRootAt(code, access.index);
+        if (root &&
+            (input.locals.opaque.has(root) ||
+                (input.callbackLocals.has(root) &&
+                    !isEntryDataFieldAccess(code, access.index)))) {
+            continue;
+        }
+        reads.push({ field: access.property, index: access.index });
+    }
+    for (const identifier of bareIdentifiers(code)) {
+        const aliased = input.locals.aliases.get(identifier.name);
+        if (aliased) {
+            reads.push({ field: aliased, index: identifier.index });
+        }
+    }
+    return reads;
+}
+/** Whether the field at `index` is read through an EmDash entry's `.data`. */
+function isEntryDataFieldAccess(code, index) {
+    return /\??\.\s*data\s*\??\.\s*$/u.test(code.slice(0, index));
+}
+/** Identifiers used on their own — not as `.property` and not as a call. */
+function bareIdentifiers(code) {
+    const identifiers = [];
+    const pattern = /(^|[^.\w$?])([A-Za-z_$][\w$]*)\s*(?![\w$(.])/gu;
+    let match = pattern.exec(code);
+    while (match !== null) {
+        identifiers.push({
+            index: match.index + (match[1]?.length ?? 0),
+            name: match[2] ?? "",
+        });
+        match = pattern.exec(code);
+    }
+    return identifiers;
+}
+/**
+ * Locates `{...<entry>.edit.<field>}` spreads and the span of the element each
+ * one annotates, so a wrapper annotation covers everything it contains.
+ */
+function findAnnotations(template) {
+    const annotations = [];
+    const pattern = /\{\s*\.\.\.\s*[\w$?.]*\bedit\??\.\s*([A-Za-z_$][\w$]*)\s*\}/gu;
+    let match = pattern.exec(template);
+    while (match !== null) {
+        const start = template.lastIndexOf("<", match.index);
+        if (start !== -1) {
+            annotations.push({
+                end: elementEnd(template, start),
+                field: match[1] ?? "",
+                start,
+            });
+        }
+        match = pattern.exec(template);
+    }
+    return annotations;
+}
+/**
+ * End offset of the element opening at `start`: the matching close tag when the
+ * element has one, otherwise the end of its self-closing/void tag.
+ */
+function elementEnd(template, start) {
+    const tagMatch = /^<\s*([A-Za-z][\w:.-]*)/u.exec(template.slice(start));
+    const tag = tagMatch?.[1];
+    const openTagEnd = template.indexOf(">", start);
+    if (!tag || openTagEnd === -1) {
+        return template.length;
+    }
+    if (template[openTagEnd - 1] === "/") {
+        return openTagEnd + 1;
+    }
+    const boundary = new RegExp(`<\\s*(/)?${escapeRegExp(tag)}(?=[\\s/>])`, "gu");
+    boundary.lastIndex = openTagEnd + 1;
+    let depth = 1;
+    let match = boundary.exec(template);
+    while (match !== null) {
+        depth += match[1] ? -1 : 1;
+        if (depth === 0) {
+            return match.index + match[0].length;
+        }
+        match = boundary.exec(template);
+    }
+    return template.length;
+}
+function escapeRegExp(value) {
+    return value.replaceAll(/[.*+?^${}()|[\]\\-]/gu, String.raw `\$&`);
+}
+function isAnnotated(input) {
+    return input.annotations.some((annotation) => annotation.field === input.field &&
+        input.index >= annotation.start &&
+        input.index < annotation.end);
+}
+/**
+ * `{...}` expressions in template position, including those nested inside
+ * markup an outer expression returns, and those passed as props to a component.
+ * Annotation spreads are skipped: only what the page actually renders counts.
+ *
+ * Nested expressions are visited separately rather than as part of their
+ * parent's text, so an identifier is only read where it is genuinely
+ * evaluated — an `aria-label` attribute is markup, not a render of `label`.
+ *
+ * A component prop (`<Image image={data.hero_image} />`) renders its value, so
+ * it counts. A plain HTML attribute (`href={mapUrl}`) does not: it carries
+ * metadata rather than visible content the customer would screenshot.
+ */
+function templateExpressions(template, offset = 0, callbackLocals = new Set()) {
+    const expressions = [];
+    let index = 0;
+    let componentTagDepth = 0;
+    let insideTag = false;
+    while (index < template.length) {
+        const character = template[index];
+        if (character === "<" && /[A-Za-z/]/u.test(template[index + 1] ?? "")) {
+            insideTag = true;
+            // Components are capitalized; lowercase names are HTML elements.
+            componentTagDepth = /^<\s*[A-Z]/u.test(template.slice(index, index + 3))
+                ? 1
+                : 0;
+            index += 1;
+            continue;
+        }
+        if (character === ">" && insideTag) {
+            insideTag = false;
+            componentTagDepth = 0;
+            index += 1;
+            continue;
+        }
+        if (character !== "{") {
+            index += 1;
+            continue;
+        }
+        if (insideTag) {
+            if (componentTagDepth > 0) {
+                const attributeEnd = matchingBrace(template, index);
+                const attributeBody = template.slice(index + 1, attributeEnd);
+                if (!isSpread(attributeBody)) {
+                    expressions.push({
+                        callbackLocals: callbackLocalsFor(attributeBody, callbackLocals),
+                        code: attributeBody,
+                        index: offset + index + 1,
+                    });
+                }
+                index = attributeEnd + 1;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        const end = matchingBrace(template, index);
+        const body = template.slice(index + 1, end);
+        if (!isSpread(body)) {
+            const bodyStart = offset + index + 1;
+            const markupAt = body.search(/<\s*[A-Za-z]/u);
+            if (markupAt === -1) {
+                expressions.push({
+                    callbackLocals: callbackLocalsFor(body, callbackLocals),
+                    code: body,
+                    index: bodyStart,
+                });
+            }
+            else {
+                // Everything before the markup is this expression's own code; the
+                // markup is a nested template scanned on its own terms.
+                const prefix = body.slice(0, markupAt);
+                const nestedCallbackLocals = callbackLocalsFor(prefix, callbackLocals);
+                expressions.push({
+                    callbackLocals: nestedCallbackLocals,
+                    code: prefix,
+                    index: bodyStart,
+                });
+                expressions.push(...templateExpressions(body.slice(markupAt), bodyStart + markupAt, nestedCallbackLocals));
+            }
+        }
+        index = end + 1;
+    }
+    return expressions;
+}
+function callbackLocalsFor(code, inherited) {
+    const introduced = arrowFunctionParameters(code);
+    if (introduced.size === 0) {
+        return inherited;
+    }
+    return new Set([...inherited, ...introduced]);
+}
+/** Simple identifier parameters introduced by arrows that return nested markup. */
+function arrowFunctionParameters(code) {
+    const parameters = new Set();
+    const pattern = /(?:^|[,(]\s*)(?:async\s+)?(?:\(\s*([A-Za-z_$][\w$]*(?:\s*,\s*[A-Za-z_$][\w$]*)*)\s*\)|([A-Za-z_$][\w$]*))\s*=>/gu;
+    let match = pattern.exec(code);
+    while (match !== null) {
+        const list = match[1] ?? match[2] ?? "";
+        for (const name of list.split(",")) {
+            const trimmed = name.trim();
+            if (trimmed) {
+                parameters.add(trimmed);
+            }
+        }
+        match = pattern.exec(code);
+    }
+    return parameters;
+}
+function isSpread(code) {
+    return code.trimStart().startsWith("...");
+}
+function matchingBrace(template, start) {
+    let depth = 0;
+    for (let index = start; index < template.length; index += 1) {
+        const character = template[index];
+        if (character === "{") {
+            depth += 1;
+        }
+        else if (character === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return template.length;
+}
+function lineAt(code, index) {
+    return countLines(code.slice(0, index)) + 1;
+}
+function parseSeed(source) {
+    const parsed = JSON.parse(source.source);
+    const seedCollections = [];
+    const declared = new Set();
+    const fields = new Map();
+    const provided = new Set();
+    const seeded = new Set();
+    if (!isRecord(parsed)) {
+        return {
+            collections: seedCollections,
+            declared,
+            fields,
+            file: source.file,
+            provided,
+            seeded,
+        };
+    }
+    const collections = Array.isArray(parsed.collections)
+        ? parsed.collections
+        : [];
+    for (const collection of collections) {
+        if (!(isRecord(collection) && typeof collection.slug === "string")) {
+            continue;
+        }
+        const collectionSlug = collection.slug;
+        const supports = Array.isArray(collection.supports)
+            ? collection.supports
+            : [];
+        seedCollections.push({
+            slug: collectionSlug,
+            supportsDrafts: supports.includes("drafts"),
+            supportsRevisions: supports.includes("revisions"),
+        });
+        const collectionFields = Array.isArray(collection.fields)
+            ? collection.fields
+            : [];
+        for (const field of collectionFields) {
+            if (!(isRecord(field) && typeof field.slug === "string")) {
+                continue;
+            }
+            const entries = fields.get(field.slug) ?? [];
+            entries.push({ collection: collectionSlug, slug: field.slug });
+            fields.set(field.slug, entries);
+            declared.add(`${collectionSlug}.${field.slug}`);
+        }
+    }
+    const content = isRecord(parsed.content) ? parsed.content : {};
+    for (const [collectionSlug, entries] of Object.entries(content)) {
+        if (!Array.isArray(entries)) {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!(isRecord(entry) && isRecord(entry.data))) {
+                continue;
+            }
+            for (const [slug, value] of Object.entries(entry.data)) {
+                provided.add(`${collectionSlug}.${slug}`);
+                if (value !== null && value !== undefined && value !== "") {
+                    seeded.add(`${collectionSlug}.${slug}`);
+                }
+            }
+        }
+    }
+    return {
+        collections: seedCollections,
+        declared,
+        fields,
+        file: source.file,
+        provided,
+        seeded,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/check.d.ts

@@ -1,20 +1,5 @@
-export type ConformanceRule = "annotations" | "fallbacks" | "seed";
-export type ConformanceViolation = {
-    /** CMS field slug the violation is about. */
-    field: string;
-    /** Site-root-relative path, always POSIX-separated. */
-    file: string;
-    line: number;
-    message: string;
-    rule: ConformanceRule;
-};
-/**
- * Reports conformance violations for one site root.
- *
- * The invariant behind the screenshot-editing fast path: a rendered CMS-backed
- * value is annotated, or the build fails. See
- * `plans/019-screenshot-site-editing.md` §7.
- */
+import { type ConformanceViolation } from "./check-core.js";
+export type { ConformanceRule, ConformanceSource, ConformanceViolation, } from "./check-core.js";
 export declare function checkSiteConformance(options: {
     root: string;
 }): Promise<ConformanceViolation[]>;

package/dist/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,WAAW,GAAG,MAAM,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG;IACjC,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAuBF;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAuBlC"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAWzB,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAKlC"}