@chat-de-hp/site 0.2.3 → 0.2.5

package/dist/annotation-middleware.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareHandler } from "astro";
+export declare const onRequest: MiddlewareHandler;
+export default onRequest;
+//# sourceMappingURL=annotation-middleware.d.ts.map

package/dist/annotation-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-middleware.d.ts","sourceRoot":"","sources":["../src/annotation-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAK/C,eAAO,MAAM,SAAS,EAAE,iBAiBvB,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/annotation-middleware.js

@@ -0,0 +1,20 @@
+import { runWithAnnotationMode } from "./internal/annotation-context.js";
+import { CHAT_DE_HP_ANNOTATION_MODE_HEADER } from "./runtime/contracts.js";
+export const onRequest = (context, next) => {
+    if (context.request.headers.get(CHAT_DE_HP_ANNOTATION_MODE_HEADER) !== "1") {
+        return next();
+    }
+    context.cache.set(false);
+    return runWithAnnotationMode(async () => {
+        const response = await next();
+        const headers = new Headers(response.headers);
+        headers.set("cache-control", "private, no-store");
+        headers.set("x-robots-tag", "noindex, nofollow");
+        return new Response(response.body, {
+            headers,
+            status: response.status,
+            statusText: response.statusText,
+        });
+    });
+};
+export default onRequest;

package/dist/astro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"astro.d.ts","sourceRoot":"","sources":["../src/astro.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,OAAO,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7D,QAAA,MAAM,sBAAsB,sNAkBlB,CAAC;AACX,KAAK,kBAAkB,GAAG,OAAO,CAC/B,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,EACvC,MAAM,kBAAkB,CACzB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,EAC5C,cAAc,CACf,GAAG;IACF,YAAY,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC5C,CAAC;AAOF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,EACxB,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CAiCpB"}
+{"version":3,"file":"astro.d.ts","sourceRoot":"","sources":["../src/astro.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,OAAO,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAKtD,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7D,QAAA,MAAM,sBAAsB,sNAkBlB,CAAC;AACX,KAAK,kBAAkB,GAAG,OAAO,CAC/B,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,EACvC,MAAM,kBAAkB,CACzB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,EAC5C,cAAc,CACf,GAAG;IACF,YAAY,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC5C,CAAC;AAOF,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,EACxB,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CAkCpB"}

package/dist/astro.js

@@ -3,6 +3,7 @@ import react from "@astrojs/react";
 import { d1, r2 } from "@emdash-cms/cloudflare";
 import { defineConfig } from "astro/config";
 import emdash from "emdash/astro";
+import { createAnnotationOnlyIntegration } from "./internal/annotation-integration.js";
 import { createApprovedAstroPlugins } from "./internal/astro-plugins.js";
 import { resolveSiteDefinition } from "./internal/registry.js";
 const SITE_ASTRO_OPTION_KEYS = [
@@ -52,6 +53,7 @@ export function createChatDeHpAstroConfig(site, options = {}) {
                 plugins: plugins,
                 storage: r2({ binding: "MEDIA" }),
             }),
+            createAnnotationOnlyIntegration(),
         ],
         output: "server",
     });

package/dist/check.d.ts

@@ -0,0 +1,21 @@
+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.
+ */
+export declare function checkSiteConformance(options: {
+    root: string;
+}): Promise<ConformanceViolation[]>;
+//# sourceMappingURL=check.d.ts.map

package/dist/check.d.ts.map

@@ -0,0 +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"}

package/dist/check.js

@@ -0,0 +1,576 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+const SOURCE_DIRECTORY = "src";
+const SEED_PATHS = ["seed/seed.json", "seed.json"];
+const IGNORED_DIRECTORIES = new Set([
+    ".chat-de-hp",
+    ".git",
+    "dist",
+    "node_modules",
+]);
+/**
+ * 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.
+ */
+export async function checkSiteConformance(options) {
+    const seed = await loadSeed(options.root);
+    if (seed.fields.size === 0) {
+        return [];
+    }
+    const violations = [];
+    for (const file of await astroFiles(join(options.root, SOURCE_DIRECTORY))) {
+        violations.push(...checkAstroSource({
+            relativePath: toPosix(relative(options.root, file)),
+            seed,
+            source: await readFile(file, "utf-8"),
+        }));
+    }
+    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)) {
+            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)) {
+            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;
+}
+/** 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) {
+    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({
+                        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({ 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.
+                expressions.push({
+                    code: body.slice(0, markupAt),
+                    index: bodyStart,
+                });
+                expressions.push(...templateExpressions(body.slice(markupAt), bodyStart + markupAt));
+            }
+        }
+        index = end + 1;
+    }
+    return expressions;
+}
+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;
+}
+async function loadSeed(root) {
+    const raw = await readSeedFile(root);
+    const parsed = JSON.parse(raw);
+    const fields = new Map();
+    const seeded = new Set();
+    if (!isRecord(parsed)) {
+        return { fields, 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 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);
+        }
+    }
+    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)) {
+                if (value !== null && value !== undefined && value !== "") {
+                    seeded.add(`${collectionSlug}.${slug}`);
+                }
+            }
+        }
+    }
+    return { fields, seeded };
+}
+async function readSeedFile(root) {
+    for (const candidate of SEED_PATHS) {
+        try {
+            return await readFile(join(root, candidate), "utf-8");
+        }
+        catch {
+            // Try the next supported seed location.
+        }
+    }
+    throw new Error(`Could not find seed data in ${root}. Expected ${SEED_PATHS.join(" or ")}.`);
+}
+async function astroFiles(directory) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRECTORIES.has(entry.name)) {
+                files.push(...(await astroFiles(path)));
+            }
+            continue;
+        }
+        if (entry.name.endsWith(".astro")) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toPosix(path) {
+    return sep === "/" ? path : path.split(sep).join("/");
+}