astroidjs 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+/** Thrown when a `defineAstroid` config violates an invariant (no brands, a
+ *  duplicate brand key, …). */
+export declare class AstroidConfigError extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Typed errors for the Astroid config surface, mirroring Louise's own error
+// classes (louise-toolkit/errors) so a bad config throws something recognizable
+// rather than a bare Error.
+/** Thrown when a `defineAstroid` config violates an invariant (no brands, a
+ *  duplicate brand key, …). */
+export class AstroidConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AstroidConfigError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./config.js";
+export * from "./errors.js";
+export * from "./project/index.js";
+export * from "./schema/index.js";
+export * from "./worker/index.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// astroidjs — the opinionated meta-framework over Louise Toolkit + Astro.
+// Public entry. The configuration surface (`defineAstroid`) is the first
+// inhabitant; the generator, theme system, and section library follow.
+export * from "./config.js";
+export * from "./errors.js";
+export * from "./project/index.js";
+export * from "./schema/index.js";
+export * from "./worker/index.js";

package/dist/project/generate.d.ts

@@ -0,0 +1,26 @@
+import type { AstroidConfig } from "../config.js";
+/** A generated file: a project-root-relative POSIX path + its full contents. */
+export interface GeneratedFile {
+    /** Path relative to the project root, POSIX-separated (e.g. `"src/worker.ts"`). */
+    path: string;
+    contents: string;
+}
+/**
+ * The regenerated trio — the files that are a pure function of the Astroid config
+ * and carry a "do not hand-edit" banner. `astroid generate` writes exactly these,
+ * and `astroid doctor` regenerates them in-memory to diff against disk. Scaffold-
+ * once files (wrangler.jsonc, astro.config, auth.ts) are NOT here by design.
+ */
+export declare function generateAstroidProject(config: AstroidConfig): GeneratedFile[];
+/**
+ * Generate a floor `wrangler.jsonc` from the config: the Worker name + editable
+ * bindings a baseline Louise site needs (D1, R2 media, the rate-limit + autosave
+ * KV, Cloudflare Images), custom-domain routes from `hosts`, and the `vars` the
+ * media route + editor read. Binding ids are placeholders — real ids are filled by
+ * `wrangler … create` (or, later, `astroid deploy`); `astroid doctor` flags any
+ * still-unresolved placeholder.
+ *
+ * This is a SCAFFOLD-ONCE file: emitted by `create-astroid`, then owned by the
+ * developer. It is intentionally not part of {@link generateAstroidProject}.
+ */
+export declare function generateAstroidWrangler(config: AstroidConfig): string;

package/dist/project/generate.js

@@ -0,0 +1,110 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Project generation — the config → files layer the `astroid` CLI writes.
+//
+// Two tiers of generated file, deliberately kept apart:
+//
+//   1. The REGENERATED trio (`generateAstroidProject`) — `src/schema.ts`,
+//      `src/worker.ts`, `src/middleware.ts`. Pure functions of the config, marked
+//      "do not hand-edit". `astroid generate` (and `dev`/`build`) rewrite these on
+//      every run, and `astroid doctor` diffs them to catch drift.
+//
+//   2. The SCAFFOLD-ONCE files (`generateAstroidWrangler`, …) — `wrangler.jsonc`
+//      and friends. `create-astroid` writes them once; the developer then owns
+//      them (fills real binding ids, secrets, account). `astroid generate` must
+//      NEVER clobber them, or it would wipe provisioned ids — so they live in a
+//      separate function the regenerate path doesn't call.
+import { generateAstroidSchema } from "../schema/generate.js";
+import { generateAstroidMiddleware, generateAstroidWorker } from "../worker/generate.js";
+/**
+ * The regenerated trio — the files that are a pure function of the Astroid config
+ * and carry a "do not hand-edit" banner. `astroid generate` writes exactly these,
+ * and `astroid doctor` regenerates them in-memory to diff against disk. Scaffold-
+ * once files (wrangler.jsonc, astro.config, auth.ts) are NOT here by design.
+ */
+export function generateAstroidProject(config) {
+    return [
+        { path: "src/schema.ts", contents: generateAstroidSchema(config) },
+        { path: "src/worker.ts", contents: generateAstroidWorker(config) },
+        { path: "src/middleware.ts", contents: generateAstroidMiddleware(config) },
+    ];
+}
+// Pinned compatibility date for the emitted Worker. A literal (Astroid's
+// generators are pure — no `Date.now()`), bumped deliberately when the runtime
+// baseline moves; matches the reference site's wrangler.jsonc.
+const COMPATIBILITY_DATE = "2026-06-20";
+/**
+ * Generate a floor `wrangler.jsonc` from the config: the Worker name + editable
+ * bindings a baseline Louise site needs (D1, R2 media, the rate-limit + autosave
+ * KV, Cloudflare Images), custom-domain routes from `hosts`, and the `vars` the
+ * media route + editor read. Binding ids are placeholders — real ids are filled by
+ * `wrangler … create` (or, later, `astroid deploy`); `astroid doctor` flags any
+ * still-unresolved placeholder.
+ *
+ * This is a SCAFFOLD-ONCE file: emitted by `create-astroid`, then owned by the
+ * developer. It is intentionally not part of {@link generateAstroidProject}.
+ */
+export function generateAstroidWrangler(config) {
+    const key = config.key;
+    const mediaBase = config.deploy?.mediaBase ?? "/media";
+    const hosts = config.hosts ?? [];
+    const primaryHost = hosts[0];
+    const lines = [];
+    const p = (s = "") => lines.push(s);
+    p("{");
+    p('  "$schema": "node_modules/wrangler/config-schema.json",');
+    p("  // The Cloudflare Worker name — also the default *.workers.dev subdomain.");
+    p(`  "name": ${JSON.stringify(key)},`);
+    p("  // Pin your account so deploys don't prompt (or set CLOUDFLARE_ACCOUNT_ID).");
+    p('  // "account_id": "<your-cloudflare-account-id>",');
+    p(`  "compatibility_date": ${JSON.stringify(COMPATIBILITY_DATE)},`);
+    p('  "compatibility_flags": ["nodejs_compat"],');
+    p("  // @astrojs/cloudflare builds this entry and wires the static assets under dist/.");
+    p('  "main": "src/worker.ts",');
+    if (primaryHost) {
+        p("  // Custom domains this Worker serves (from your defineAstroid `hosts`).");
+        p('  "routes": [');
+        for (const host of hosts) {
+            p(`    { "pattern": ${JSON.stringify(host)}, "custom_domain": true },`);
+        }
+        p("  ],");
+    }
+    else {
+        p("  // No `hosts` in your config → deploys to <name>.workers.dev. Add a");
+        p('  // "routes" block with a custom_domain pattern to serve a real domain.');
+    }
+    p("  // D1 holds pages / site_settings / media / inquiries (schema in src/schema.ts,");
+    p("  // migrations in ./migrations). Create it: `wrangler d1 create <name>`.");
+    p('  "d1_databases": [');
+    p("    {");
+    p('      "binding": "DB",');
+    p(`      "database_name": ${JSON.stringify(key)},`);
+    p('      "database_id": "<run: wrangler d1 create ' + key + '>",');
+    p('      "migrations_dir": "migrations",');
+    p("    },");
+    p("  ],");
+    p("  // R2 bucket for uploaded media, streamed back through the Worker at MEDIA_URL");
+    p("  // (no public bucket). Create it: `wrangler r2 bucket create <name>-media`.");
+    p(`  "r2_buckets": [{ "binding": "MEDIA", "bucket_name": ${JSON.stringify(`${key}-media`)} }],`);
+    p("  // Cloudflare Images: the media route reads upload dimensions + backs server-");
+    p("  // side re-encode. Also @astrojs/cloudflare's production image service.");
+    p('  "images": { "binding": "IMAGES" },');
+    p("  // KV: RL = the security rate limiter; DRAFTS = the autosave write-buffer.");
+    p("  // Create each: `wrangler kv namespace create <RL|DRAFTS>`.");
+    p('  "kv_namespaces": [');
+    p('    { "binding": "RL", "id": "<run: wrangler kv namespace create RL>" },');
+    p('    { "binding": "DRAFTS", "id": "<run: wrangler kv namespace create DRAFTS>" },');
+    p("  ],");
+    p("  // Public base for media URLs; same-origin keeps media self-contained. Read off");
+    p("  // the runtime env by the framework-agnostic media route, so it stays a `var`.");
+    p('  "vars": {');
+    p(`    "MEDIA_URL": ${JSON.stringify(mediaBase)},`);
+    p(`    "SITE_URL": ${JSON.stringify(primaryHost ? `https://${primaryHost}` : `https://${key}.workers.dev`)},`);
+    p('    // The editor allowlist / owner. Wire this into your auth seam (src/auth.ts).');
+    p('    "OWNER_EMAIL": "",');
+    p("  },");
+    p('  "observability": { "enabled": true },');
+    p("}");
+    p();
+    return lines.join("\n");
+}

package/dist/project/index.d.ts

@@ -0,0 +1 @@
+export * from "./generate.js";

package/dist/project/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Project generation — config → the files the `astroid` CLI writes (the
+// regenerated schema/worker/middleware trio + the scaffold-once wrangler.jsonc).
+export * from "./generate.js";

package/dist/schema/collections.d.ts

@@ -0,0 +1,20 @@
+import { type CollectionConfig, type ContentConfig } from "louise-toolkit/content";
+import type { AstroidConfig } from "../config.js";
+/**
+ * The opinionated `pages` collection — the EDITABLE page fields, versioned
+ * drafts, and full-text search. Keyed to the same names as Louise's `pagesColumns`
+ * so a publish's `.set()` maps straight onto the physical columns; bookkeeping
+ * columns (`id`/`status`/timestamps/`publishedVersionId`) live on the table via
+ * `pagesColumns`, never here — matching the site's `pages-collection.ts`.
+ *
+ * Validated by `defineCollection` at build time, so a malformed field shape throws
+ * here rather than at codegen.
+ */
+export declare function astroidPagesCollection(config: AstroidConfig): CollectionConfig;
+/**
+ * The Louise `ContentConfig` for an Astroid project. Today: the `pages`
+ * collection. Archetype- and module-specific collections (e.g. a portfolio
+ * `gallery`) layer in here as they land — this is the single place that maps
+ * brand config down to Louise content.
+ */
+export declare function astroidContentConfig(config: AstroidConfig): ContentConfig;

package/dist/schema/collections.js

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Astroid → Louise content mapping. This is the opinionated seam: given an
+// Astroid project config, derive the Louise `CollectionConfig`(s) a site needs.
+// Astroid decides WHICH collections and fields exist (its opinions); Louise's
+// codegen decides HOW they become D1 tables. Dependency flows one way — this
+// imports `louise-toolkit/content`, never the reverse.
+import { defineCollection, } from "louise-toolkit/content";
+import { sanitizeRichHtml } from "louise-toolkit/security";
+/**
+ * The opinionated `pages` collection — the EDITABLE page fields, versioned
+ * drafts, and full-text search. Keyed to the same names as Louise's `pagesColumns`
+ * so a publish's `.set()` maps straight onto the physical columns; bookkeeping
+ * columns (`id`/`status`/timestamps/`publishedVersionId`) live on the table via
+ * `pagesColumns`, never here — matching the site's `pages-collection.ts`.
+ *
+ * Validated by `defineCollection` at build time, so a malformed field shape throws
+ * here rather than at codegen.
+ */
+export function astroidPagesCollection(config) {
+    // The `body` is rich HTML edited in place (`<Editable type="richtext">`) and
+    // staged as a draft, so sanitize it on every write — never store raw HTML. A
+    // pasted `<img>` pointing off-origin (a hotlink) is dropped: body images must
+    // live in the media library. Mirrors the reference site's pages-collection hook.
+    const mediaBase = config.deploy?.mediaBase ?? "/media";
+    const fields = {};
+    fields.slug = { type: "text", required: true };
+    fields.title = { type: "text", required: true };
+    // Sanitized rich HTML (a string), not TipTap JSON — matches `pagesColumns.body`.
+    fields.body = { type: "text" };
+    fields.seoTitle = { type: "text" };
+    fields.seoDescription = { type: "text" };
+    fields.ogImage = { type: "text" };
+    fields.noindex = { type: "checkbox" };
+    fields.sortOrder = { type: "number" };
+    // Structured page-builder blocks (the editable home) — deep-validated against
+    // the section catalog on write in a later slice.
+    fields.sections = { type: "json" };
+    return defineCollection({
+        slug: "pages",
+        fields,
+        hooks: {
+            beforeChange: [
+                ({ data }) => {
+                    if (typeof data.body === "string") {
+                        return { ...data, body: sanitizeRichHtml(data.body, { mediaBase }) };
+                    }
+                    return data;
+                },
+            ],
+        },
+        versions: { drafts: true },
+        search: { fields: ["title", "body", "sections"] },
+    });
+}
+/**
+ * The Louise `ContentConfig` for an Astroid project. Today: the `pages`
+ * collection. Archetype- and module-specific collections (e.g. a portfolio
+ * `gallery`) layer in here as they land — this is the single place that maps
+ * brand config down to Louise content.
+ */
+export function astroidContentConfig(config) {
+    return { collections: [astroidPagesCollection(config)] };
+}

package/dist/schema/framework.d.ts

@@ -0,0 +1,13 @@
+import type { AstroidConfig } from "../config.js";
+/** A ready-made table Astroid re-exports from `louise-toolkit/db`. */
+export type AstroidFrameworkTable = "inquiries" | "media" | "siteSettings";
+/** True when the site captures inquiries — a contact section or a
+ *  wholesale-inquiry module. Shared by table selection (here) and route selection
+ *  (the worker route plan). */
+export declare function capturesInquiries(config: AstroidConfig): boolean;
+/**
+ * The framework tables this project needs, sorted alphabetically (so the emitted
+ * import/export lists are stable). `media` + `siteSettings` always; `inquiries`
+ * when a brand captures them.
+ */
+export declare function astroidFrameworkTables(config: AstroidConfig): AstroidFrameworkTable[];

package/dist/schema/framework.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Which ready-made Louise tables (louise-toolkit/db) an Astroid project needs.
+// Astroid re-exports these rather than redefining them, so the core content
+// tables never drift from Louise. `media` and `siteSettings` are universal;
+// `inquiries` is pulled in only when a brand actually captures inquiries (a
+// contact section, or a wholesale-inquiry module).
+/** True when the site captures inquiries — a contact section or a
+ *  wholesale-inquiry module. Shared by table selection (here) and route selection
+ *  (the worker route plan). */
+export function capturesInquiries(config) {
+    const wantsWholesale = (mods) => (mods ?? []).includes("wholesaleInquiry");
+    return ((config.sections ?? []).includes("contact") ||
+        wantsWholesale(config.modules) ||
+        wantsWholesale(config.portal?.features));
+}
+/**
+ * The framework tables this project needs, sorted alphabetically (so the emitted
+ * import/export lists are stable). `media` + `siteSettings` always; `inquiries`
+ * when a brand captures them.
+ */
+export function astroidFrameworkTables(config) {
+    const tables = ["media", "siteSettings"];
+    if (capturesInquiries(config))
+        tables.push("inquiries");
+    return tables.sort();
+}

package/dist/schema/generate.d.ts

@@ -0,0 +1,8 @@
+import type { AstroidConfig } from "../config.js";
+/**
+ * Generate the TypeScript source of a site's Drizzle schema from an Astroid
+ * config. The output is a drop-in replacement for the hand-written `schema.ts`:
+ * a `pages` table composed from `pagesColumns`, a `pages_versions` snapshot
+ * table, and the re-exported framework tables the config selects.
+ */
+export declare function generateAstroidSchema(config: AstroidConfig): string;

package/dist/schema/generate.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// generateAstroidSchema — emit the Drizzle schema source (a site's `schema.ts`)
+// from an Astroid config. This is the boilerplate every Louise site hand-writes:
+// compose the framework `pagesColumns` into a `pages` table, add the versions
+// table + publish pointer, and re-export the ready-made framework tables. Astroid
+// generates it, driven by the single-brand config.
+//
+// Pure string generation, mirroring louise-toolkit/content's own
+// `generateSchemaSource`: the caller (the Astroid CLI, a later slice) writes the
+// result to disk and formats it. Import ordering matches the site's schema.ts so
+// a formatter never re-flags the generated file.
+import { astroidFrameworkTables } from "./framework.js";
+/**
+ * Generate the TypeScript source of a site's Drizzle schema from an Astroid
+ * config. The output is a drop-in replacement for the hand-written `schema.ts`:
+ * a `pages` table composed from `pagesColumns`, a `pages_versions` snapshot
+ * table, and the re-exported framework tables the config selects.
+ */
+export function generateAstroidSchema(config) {
+    const framework = astroidFrameworkTables(config); // sorted
+    // pagesColumns is spread into `pages`; the framework tables are re-exported.
+    // One import brings them all in (matching the site) so nothing is unused.
+    const dbImports = [...framework, "pagesColumns"].sort();
+    return [
+        "// Generated by astroidjs — do not hand-edit.",
+        "// Source: your defineAstroid config.",
+        'import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";',
+        'import { collectionVersionsTable, type JsonValue } from "louise-toolkit/content";',
+        `import { ${dbImports.join(", ")} } from "louise-toolkit/db";`,
+        "",
+        'export const pages = sqliteTable("pages", {',
+        "  ...pagesColumns,",
+        "  // Structured page-builder blocks (the editable home), rendered by the",
+        "  // site's own section components.",
+        '  sections: text("sections", { mode: "json" }).$type<JsonValue>(),',
+        "  // Nullable pointer to the live version (pages_versions.id); NULL = unpublished.",
+        '  publishedVersionId: integer("published_version_id"),',
+        "});",
+        "",
+        "// Version snapshots for pages. Field-independent — each saved version is one",
+        "// JSON blob — so the table only needs the slug.",
+        'export const pagesVersions = collectionVersionsTable({ slug: "pages", fields: {} });',
+        "",
+        `export { ${framework.join(", ")} };`,
+        "",
+    ].join("\n");
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./collections.js";
+export * from "./framework.js";
+export * from "./generate.js";

package/dist/schema/index.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Schema generation — config → Louise content config → Drizzle schema source.
+export * from "./collections.js";
+export * from "./framework.js";
+export * from "./generate.js";

package/dist/worker/generate.d.ts

@@ -0,0 +1,24 @@
+import type { AstroidConfig } from "../config.js";
+/**
+ * Generate the Worker entrypoint (`worker.ts`) from an Astroid config: the editor
+ * routes in collision-free order, an R2 media-asset route, and the `composeWorker`
+ * default export over Astro's SSR handler. Inquiry routes + the contact form are
+ * emitted only when a brand captures inquiries.
+ */
+export declare function generateAstroidWorker(config: AstroidConfig): string;
+/**
+ * Generate the Astro middleware (`middleware.ts`) from an Astroid config: the
+ * shared Louise flow (rate-limit the unauthenticated POST surface → resolve editor
+ * session + sticky `?louise` edit mode → content-freshness + security headers) via
+ * `createLouiseMiddleware`. The default rate rule caps `POST /api/auth/*` (magic-link
+ * sign-in) against the provisioned `RL` KV; auth is the same seam as the worker.
+ *
+ * CSP: `astro.config.mjs` enables `security.csp`, so Astro emits a hash-based
+ * `content-security-policy` response header on every SSR page. The `cspStyleSrc`
+ * below tells `createLouiseMiddleware` to rewrite that header's `style-src` to
+ * `'self' 'unsafe-inline'` — the hash-based `style-src` Astro emits would block
+ * Louise's data-driven `style=""` carriers and the editor's runtime-injected
+ * `<style>`. Script hashes are left verbatim (the template's inline scripts are
+ * kept hashable), and the inlined `data:` brand font is auto-allowed.
+ */
+export declare function generateAstroidMiddleware(_config: AstroidConfig): string;

package/dist/worker/generate.js

@@ -0,0 +1,200 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// generateAstroidWorker / generateAstroidMiddleware — emit the Cloudflare Worker
+// entrypoint and the Astro middleware a Louise site would otherwise hand-write.
+// The worker's editor routes are composed in the fixed order from the route plan
+// (routes.ts), so the "versionsRoute/searchRoute before pagesRoute" collision is
+// impossible by construction. Pure string generation, like generateAstroidSchema.
+//
+// Two seams are marked with TODO(astroid) and filled by later slices: the auth
+// `resolveEditor`, and the section-catalog `validate` on the pages routes.
+import { capturesInquiries } from "../schema/framework.js";
+import { astroidEditorRoutePlan } from "./routes.js";
+// Astroid's default editable site_settings surface — the columns the Settings
+// panel may write, and which of them hold a media-library image URL.
+const DEFAULT_SETTINGS_COLUMNS = [
+    "siteName",
+    "tagline",
+    "logoUrl",
+    "faviconUrl",
+    "brandColor",
+    "secondaryColor",
+    "tertiaryColor",
+    "contactEmail",
+    "contactPhone",
+    "contactAddress",
+    "socialLinks",
+    "navLinks",
+    "metaDescription",
+    "defaultOgImageUrl",
+    "disableIndexing",
+];
+const DEFAULT_SETTINGS_IMAGE_KEYS = ["logoUrl", "faviconUrl", "defaultOgImageUrl"];
+/**
+ * Generate the Worker entrypoint (`worker.ts`) from an Astroid config: the editor
+ * routes in collision-free order, an R2 media-asset route, and the `composeWorker`
+ * default export over Astro's SSR handler. Inquiry routes + the contact form are
+ * emitted only when a brand captures inquiries.
+ */
+export function generateAstroidWorker(config) {
+    const inquiries = capturesInquiries(config);
+    const mediaBase = config.deploy?.mediaBase ?? "/media";
+    const seedName = config.theme.name;
+    const plan = astroidEditorRoutePlan(config);
+    const editorImports = [
+        "DEFAULT_PAGE_FIELDS",
+        ...new Set(plan.map((route) => route.factory)),
+    ].sort();
+    const tables = [
+        "media",
+        "pages",
+        "pagesVersions",
+        "siteSettings",
+        ...(inquiries ? ["inquiries"] : []),
+    ].sort();
+    const routeCall = (name) => {
+        switch (name) {
+            case "versions":
+                return "versionsRoute({ table: pages, versionsTable: pagesVersions, config: pagesCollection, resolveEditor })";
+            case "search":
+                return "searchRoute({ table: pages, config: pagesCollection, resolveEditor })";
+            case "pages":
+                return 'pagesRoute({ table: pages, resolveEditor, fields: [...DEFAULT_PAGE_FIELDS, "sections"] })';
+            case "save":
+                return 'saveRoute({ resolveEditor, collections: { pages: { table: pages, fields: ["title", "seoTitle", "seoDescription"] } } })';
+            case "settings":
+                return "settingsRoute({ table: siteSettings, resolveEditor, columns: SETTINGS_COLUMNS, imageKeys: SETTINGS_IMAGE_KEYS, mediaBase: MEDIA_BASE })";
+            case "media":
+                return "mediaRoute({ table: media, resolveEditor })";
+            case "editors":
+                // Better Auth owns the `user` table (a NAME, not a Drizzle table), so this
+                // route takes the default `"user"`; a `tablePrefix` would rename it.
+                return 'editorsRoute({ table: "user", resolveEditor })';
+            case "form":
+                return "formRoute({ form: contactForm, rateLimitKv: (env) => env.RL })";
+            case "inquiries":
+                return "inquiriesRoute({ table: inquiries, resolveEditor })";
+            case "seed":
+                return `seedRoute({ table: siteSettings, resolveEditor, defaults: { siteName: ${JSON.stringify(seedName)} } })`;
+        }
+    };
+    const lines = [];
+    const p = (s = "") => lines.push(s);
+    p("// Generated by astroidjs — do not hand-edit.");
+    p("// Source: your defineAstroid config. The editor route ORDER is fixed by");
+    p("// Astroid to avoid matcher collisions — see each route's note below.");
+    p('import { handle } from "@astrojs/cloudflare/handler";');
+    p("import {");
+    for (const name of editorImports)
+        p(`  ${name},`);
+    p('} from "louise-toolkit/editor";');
+    if (inquiries)
+        p('import { defineForm } from "louise-toolkit/forms";');
+    p('import { composeWorker, type WorkerRoute } from "louise-toolkit/worker";');
+    if (inquiries)
+        p('import { inquiriesForm } from "louise-toolkit/db";');
+    p(`import { ${tables.join(", ")} } from "./schema.js";`);
+    p('import { astroidPagesCollection } from "astroidjs";');
+    p('import astroidConfig from "./astroid.config.js";');
+    p("// TODO(astroid): your AUTH seam. resolveEditor resolves the editor session");
+    p("// from a request; a truthy result authorizes editor writes. A generated auth");
+    p("// module is a later slice.");
+    p('import { resolveEditor } from "./auth.js";');
+    p();
+    p(`const MEDIA_BASE = ${JSON.stringify(mediaBase)};`);
+    p("const pagesCollection = astroidPagesCollection(astroidConfig);");
+    p();
+    p("// Editable site_settings columns the Settings panel may write, and which of");
+    p("// them resolve to a media-library asset.");
+    p(`const SETTINGS_COLUMNS = ${JSON.stringify(DEFAULT_SETTINGS_COLUMNS)};`);
+    p(`const SETTINGS_IMAGE_KEYS = ${JSON.stringify(DEFAULT_SETTINGS_IMAGE_KEYS)};`);
+    if (inquiries) {
+        p();
+        p("// Public contact form: the built-in inquiries fields + silent spam");
+        p("// heuristics (a honeypot + a minimum time-since-render).");
+        p('const contactForm = defineForm({ name: "inquiries", fields: inquiriesForm.fields, spam: { honeypot: "website", minSeconds: 2, rateLimit: { max: 5, windowSec: 60 } } });');
+    }
+    p();
+    p("// TODO(astroid): sections validation (assertValidSections) is wired onto the");
+    p("// pages/versions routes once the section catalog lands (a later slice).");
+    p("const editorRoutes: WorkerRoute<CloudflareEnv>[] = [");
+    for (const route of plan) {
+        p(`  // ${route.note}`);
+        p(`  ${routeCall(route.name)},`);
+    }
+    p("];");
+    p();
+    p("// Stream uploaded media back from R2 at MEDIA_BASE (self-hosted, no public bucket).");
+    p("const mediaAssetRoute: WorkerRoute<CloudflareEnv> = async (request, env) => {");
+    p("  const url = new URL(request.url);");
+    p("  if (!url.pathname.startsWith(`${MEDIA_BASE}/`)) return undefined;");
+    p("  const key = decodeURIComponent(url.pathname.slice(MEDIA_BASE.length + 1));");
+    p("  if (!key) return undefined;");
+    p("  const obj = await env.MEDIA.get(key);");
+    p('  if (!obj) return new Response("Not found", { status: 404 });');
+    p("  const headers = new Headers();");
+    p("  obj.writeHttpMetadata(headers);");
+    p('  headers.set("etag", obj.httpEtag);');
+    p('  headers.set("cache-control", "public, max-age=31536000, immutable");');
+    p('  headers.set("x-content-type-options", "nosniff");');
+    p("  return new Response(obj.body, { headers });");
+    p("};");
+    p();
+    p("export default composeWorker<CloudflareEnv>({");
+    p("  routes: [...editorRoutes, mediaAssetRoute],");
+    p("  fetch: (request, env, ctx) => handle(request, env, ctx),");
+    p("});");
+    p();
+    return lines.join("\n");
+}
+/**
+ * Generate the Astro middleware (`middleware.ts`) from an Astroid config: the
+ * shared Louise flow (rate-limit the unauthenticated POST surface → resolve editor
+ * session + sticky `?louise` edit mode → content-freshness + security headers) via
+ * `createLouiseMiddleware`. The default rate rule caps `POST /api/auth/*` (magic-link
+ * sign-in) against the provisioned `RL` KV; auth is the same seam as the worker.
+ *
+ * CSP: `astro.config.mjs` enables `security.csp`, so Astro emits a hash-based
+ * `content-security-policy` response header on every SSR page. The `cspStyleSrc`
+ * below tells `createLouiseMiddleware` to rewrite that header's `style-src` to
+ * `'self' 'unsafe-inline'` — the hash-based `style-src` Astro emits would block
+ * Louise's data-driven `style=""` carriers and the editor's runtime-injected
+ * `<style>`. Script hashes are left verbatim (the template's inline scripts are
+ * kept hashable), and the inlined `data:` brand font is auto-allowed.
+ */
+export function generateAstroidMiddleware(_config) {
+    // Louise's brand font is bundled + base64-inlined (no Google Fonts host to
+    // allow); createLouiseMiddleware auto-allows `data:` fonts in the CSP, so the
+    // inlined @font-face needs no manual `font-src` entry.
+    const cspStyleSrc = "'self' 'unsafe-inline'";
+    return [
+        "// Generated by astroidjs — do not hand-edit.",
+        "// The shared Louise middleware: rate-limit the unauthenticated POST surfaces,",
+        "// then resolve the editor session + sticky ?louise edit mode, then apply",
+        "// content-freshness + transport-security headers, and rewrite the style-src of",
+        "// the CSP header Astro's security.csp emits so Louise's data-driven inline",
+        "// styles + inlined data: brand font are allowed.",
+        'import { env } from "cloudflare:workers";',
+        'import { createLouiseMiddleware } from "louise-toolkit/astro";',
+        "// TODO(astroid): your AUTH seam — same resolveEditor as the generated worker.ts.",
+        'import { resolveEditor } from "./auth.js";',
+        "",
+        "// Rate-limit the public, unauthenticated POST surface, keyed by client IP",
+        "// (fixed-window KV counter that fails open). The magic-link sign-in is the one",
+        "// that matters: without a cap, anyone who knows an editor's email could trigger",
+        "// unbounded sign-in emails (inbox flooding + Email/Worker spend). `env.RL` is",
+        "// read per request (a getter) — the KV binding is only valid in request scope.",
+        "const RATE_RULES = [",
+        '  { name: "auth", method: "POST", match: (p: string) => p.startsWith("/api/auth/"), limit: 10, windowSec: 60 },',
+        "];",
+        "",
+        "export const onRequest = createLouiseMiddleware({",
+        "  resolveEditor: (request) => resolveEditor(request),",
+        "  rateLimit: { rules: RATE_RULES, kv: () => env.RL },",
+        "  // Rewrite Astro's hash-based style-src (enabled via security.csp in",
+        "  // astro.config.mjs) to permit Louise's data-driven style=\"\" + editor styles.",
+        `  cspStyleSrc: ${JSON.stringify(cspStyleSrc)},`,
+        "});",
+        "",
+    ].join("\n");
+}

package/dist/worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./routes.js";
+export * from "./generate.js";

package/dist/worker/index.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Worker + middleware generation — config → the collision-free editor route plan
+// → the Worker entrypoint and Astro middleware a site would otherwise hand-write.
+export * from "./routes.js";
+export * from "./generate.js";

package/dist/worker/routes.d.ts

@@ -0,0 +1,17 @@
+import type { AstroidConfig } from "../config.js";
+export type AstroidEditorRouteName = "versions" | "search" | "pages" | "save" | "settings" | "media" | "editors" | "form" | "inquiries" | "seed";
+export interface AstroidEditorRoute {
+    /** Stable key for this route. */
+    name: AstroidEditorRouteName;
+    /** The `louise-toolkit/editor` factory that builds it. */
+    factory: string;
+    /** Why it's here, and any ordering constraint that pins its position. */
+    note: string;
+}
+/**
+ * The ordered editor route plan for a project. Order is load-bearing: the two
+ * routes with `/pages/:id/...` sub-paths (`versions`, `search`) come first, so
+ * `pages`' catch-all `/:id` matcher can't swallow them. Inquiry routes are
+ * included only when a brand captures inquiries; `seed` is always last.
+ */
+export declare function astroidEditorRoutePlan(config: AstroidConfig): AstroidEditorRoute[];