create-astroid 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BowenLabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# create-astroid
+
+Scaffold a new **Astroid** site — an editable, multi-editor Astro app on
+Cloudflare Workers — in one command.
+
+```sh
+npm create astroid my-site
+```
+
+> **Status: pre-1.0, experimental.** The scaffold's output will change between
+> minor versions.
+
+## What you get
+
+A working floor, not a blank page:
+
+- `astroid.config.ts` — the one typed config the rest is generated from
+- The generated trio — `src/schema.ts`, `src/worker.ts`, `src/middleware.ts`
+  (Drizzle schema, editor routes in collision-free order, the shared middleware)
+- `wrangler.jsonc` with every binding stubbed and clearly marked for you to fill
+- A baseline Astro app with an **inline-editable home page**, magic-link editor
+  sign-in, and the Louise editor wired up
+- Migrations + a `seed:editors` script to create the first editor
+
+## Options
+
+Anything you don't pass is prompted for. In a non-TTY every prompt takes its
+default, so the command is CI-safe. The target directory must be empty.
+
+```
+npm create astroid [directory] [options]
+
+  --dir <path>          Target directory (also the first positional)
+  --name <name>         Brand / site name
+  --key <slug>          Project key (slug); defaults to a slug of --name
+  --archetype <type>    marketing | storefront | wholesale | portfolio
+  --color <hex>         Brand color
+  --host <domain>       Primary domain, e.g. example.com
+  -h, --help            Show help
+  -v, --version         Show the version
+```
+
+## After scaffolding
+
+```sh
+cd my-site
+npm install
+npx wrangler d1 create <name>      # then paste the ids into wrangler.jsonc
+npm run doctor                     # validates config, bindings, generated files
+npm run dev
+```
+
+`npm run doctor` flags any binding id you haven't filled in yet, plus generated
+files that have drifted from the config.
+
+## How the pieces relate
+
+```
+Astro        →  renderer / router / build
+  Louise     →  unopinionated primitives + framework glue   (louise-toolkit)
+    Astroid  →  opinions: theme, sections, config, scaffold  (astroidjs)
+```
+
+- [`astroidjs`](https://github.com/bowenlabs/louise-toolkit/tree/main/packages/astroid)
+  — the meta-framework and the `astroid` CLI this scaffold writes a project for
+- [`louise-toolkit`](https://github.com/bowenlabs/louise-toolkit/tree/main/packages/louise)
+  — the underlying toolkit
+
+## License
+
+[MIT](https://github.com/bowenlabs/louise-toolkit/blob/main/LICENSE) © BowenLabs

package/index.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// `create-astroid` — scaffold a new Astroid site in one command:
+//
+//   npm create astroid@latest my-site
+//   npm create astroid@latest my-site -- --key coracle --name "Coracle Coffee" --color "#1f6f78" --host coracle.coffee
+//
+// It writes the floor: the `defineAstroid` config, the generated
+// schema/worker/middleware trio + wrangler.jsonc (via astroidjs), the Better Auth
+// migration (via louise-toolkit/auth), and the baseline Astro app from ./template.
+// Binding ids are placeholders — provision them, then `astroid deploy` (or
+// wrangler) fills them in. The generators are the SAME ones `astroid generate`
+// uses, so a fresh project is already in sync.
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { defineAstroid, generateAstroidProject, generateAstroidWrangler } from "astroidjs";
+
+const TEMPLATE_DIR = join(dirname(fileURLToPath(import.meta.url)), "template");
+
+// Files whose leading `_` is stripped on copy (npm strips real dotfiles from a
+// published package, so they ship as `_gitignore` / `_env.example`).
+const DOTFILE_RENAMES = { _gitignore: ".gitignore", "_env.example": ".env.example" };
+
+// Archetype → default editable home sections, when the user doesn't override.
+const ARCHETYPE_SECTIONS = {
+  marketing: ["hero", "featureGrid", "cta", "contact"],
+  storefront: ["hero", "marquee", "featured", "productGrid", "visit", "contact"],
+  wholesale: ["hero", "featureGrid", "story", "contact"],
+  portfolio: ["hero", "gallery", "story", "contact"],
+};
+const ARCHETYPES = Object.keys(ARCHETYPE_SECTIONS);
+
+// --- args ------------------------------------------------------------------
+function parseArgs(argv) {
+  const flags = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("--")) flags[key] = true;
+      else flags[key] = argv[++i];
+    } else positionals.push(a);
+  }
+  return { flags, positionals };
+}
+
+const slugify = (s) =>
+  s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+
+async function prompt(question, fallback) {
+  if (!process.stdin.isTTY) return fallback;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question}${fallback ? ` (${fallback})` : ""}: `)).trim();
+    return answer || fallback;
+  } finally {
+    rl.close();
+  }
+}
+
+// --- scaffold --------------------------------------------------------------
+function copyTemplate(srcDir, destDir, tokens) {
+  mkdirSync(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir)) {
+    const src = join(srcDir, entry);
+    const renamed = DOTFILE_RENAMES[entry] ?? entry;
+    const dest = join(destDir, renamed);
+    if (statSync(src).isDirectory()) {
+      copyTemplate(src, dest, tokens);
+    } else {
+      const raw = readFileSync(src, "utf8");
+      writeFileSync(dest, applyTokens(raw, tokens));
+    }
+  }
+}
+
+function applyTokens(text, tokens) {
+  return text.replace(/__([A-Z0-9_]+)__/g, (m, key) => (key in tokens ? tokens[key] : m));
+}
+
+function astroidConfigSource(config) {
+  const parts = [
+    'import { defineAstroid } from "astroidjs";',
+    "",
+    "// The whole shape of this site — one typed config. `astroid generate` (run by",
+    "// `astroid dev`/`build`) turns it into src/schema.ts, src/worker.ts, and",
+    "// src/middleware.ts; `astroid doctor` keeps them honest.",
+    "export default defineAstroid({",
+    `  key: ${JSON.stringify(config.key)},`,
+    `  archetype: ${JSON.stringify(config.archetype)},`,
+    ...(config.hosts?.length ? [`  hosts: ${JSON.stringify(config.hosts)},`] : []),
+    "  theme: {",
+    `    name: ${JSON.stringify(config.theme.name)},`,
+    `    colors: { brand: ${JSON.stringify(config.theme.colors.brand)} },`,
+    "  },",
+    `  sections: ${JSON.stringify(config.sections)},`,
+    '  deploy: { platform: "cloudflare" },',
+    "});",
+    "",
+  ];
+  return parts.join("\n");
+}
+
+function write(destDir, relPath, contents) {
+  const abs = join(destDir, relPath);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, contents);
+}
+
+const USAGE = `Scaffold a new Astroid site — an editable Astro app on Cloudflare Workers.
+
+Usage:
+  npm create astroid [directory] [options]
+
+Options:
+  --dir <path>          Target directory (also accepted as the first positional)
+  --name <name>         Brand / site name
+  --key <slug>          Project key (slug); defaults to a slug of --name
+  --archetype <type>    ${ARCHETYPES.join(" | ")}   (default: marketing)
+  --color <hex>         Brand color (default: #5b4bff)
+  --host <domain>       Primary domain, e.g. example.com
+  -h, --help            Show this help
+  -v, --version         Show the create-astroid version
+
+Anything not passed as a flag is prompted for; in a non-TTY every prompt takes
+its default, so the command is CI-safe. The target directory must be empty.
+`;
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, positionals } = parseArgs(argv);
+
+  // Handle these before any prompting — otherwise `--help` reads as a truthy
+  // flag and drops the user into the interactive scaffold instead. The short
+  // forms are read off argv directly: parseArgs only treats `--` as a flag, so
+  // a bare `-h` would otherwise be taken as the target directory.
+  if (flags.help || argv.includes("-h")) {
+    process.stdout.write(USAGE);
+    return;
+  }
+  if (flags.version || argv.includes("-v")) {
+    const pkg = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8"));
+    process.stdout.write(`${pkg.version}\n`);
+    return;
+  }
+
+  const dirArg = positionals[0] ?? flags.dir;
+  const rawName = flags.name || (dirArg ? basename(resolve(dirArg)) : undefined);
+  const name = await prompt("Brand / site name", rawName || "My Astroid Site");
+  const key = slugify(flags.key || (await prompt("Project key (slug)", slugify(name) || "my-site")));
+  const dir = resolve(dirArg || (await prompt("Directory", key)) || key);
+  const archetypeRaw = (flags.archetype || (await prompt(`Archetype (${ARCHETYPES.join("/")})`, "marketing"))).toLowerCase();
+  const archetype = ARCHETYPES.includes(archetypeRaw) ? archetypeRaw : "marketing";
+  const color = flags.color || (await prompt("Brand color (hex)", "#5b4bff"));
+  const host = flags.host && flags.host !== true ? flags.host : undefined;
+
+  if (existsSync(dir) && readdirSync(dir).length > 0) {
+    process.stderr.write(`create-astroid: target directory is not empty: ${dir}\n`);
+    process.exit(1);
+  }
+
+  // Validate + normalize through the real config surface (throws on a bad shape).
+  const config = defineAstroid({
+    key,
+    archetype,
+    ...(host ? { hosts: [host] } : {}),
+    theme: { name, colors: { brand: color } },
+    sections: ARCHETYPE_SECTIONS[archetype],
+    deploy: { platform: "cloudflare" },
+  });
+
+  const siteUrl = host ? `https://${host}` : `https://${key}.workers.dev`;
+  const tokens = {
+    KEY: key,
+    BRAND_NAME: name,
+    BRAND_COLOR: color,
+    ARCHETYPE: archetype,
+    SITE_URL: siteUrl,
+  };
+
+  // 1. The static floor (Astro app, auth seam, config files) with tokens filled.
+  copyTemplate(TEMPLATE_DIR, dir, tokens);
+
+  // 2. The typed config the generators + the app read.
+  write(dir, "astroid.config.ts", astroidConfigSource(config));
+
+  // 3. The generated trio + the scaffold-once wrangler.jsonc (astroidjs).
+  for (const file of generateAstroidProject(config)) write(dir, file.path, file.contents);
+  write(dir, "wrangler.jsonc", generateAstroidWrangler(config));
+
+  // 4. The Better Auth migration (louise-toolkit) — auth tables are fenced out of
+  //    drizzle-kit, so they're generated rather than diffed from schema.ts. Loaded
+  //    dynamically: it pulls in `better-auth` (an optional peer), which may not be
+  //    resolvable at scaffold time. If not, leave a stub + a one-liner to generate
+  //    it after install (the project has `louise` on its path then).
+  let authMigrationOk = false;
+  try {
+    const { generateAuthSchemaSql } = await import("louise-toolkit/auth");
+    write(dir, "migrations/0001_auth.sql", generateAuthSchemaSql());
+    authMigrationOk = true;
+  } catch {
+    write(
+      dir,
+      "migrations/0001_auth.sql",
+      "-- Better Auth tables — generate after install:\n--   npx louise gen-auth-schema --out migrations/0001_auth.sql\n",
+    );
+  }
+
+  const rel = dir === process.cwd() ? "." : basename(dir);
+  process.stdout.write(
+    [
+      "",
+      `✓ Scaffolded ${name} → ${rel}`,
+      "",
+      "Next steps:",
+      `  cd ${rel}`,
+      "  pnpm install",
+      "  # provision the Cloudflare bindings, then fill the ids in wrangler.jsonc:",
+      "  wrangler d1 create " + key,
+      "  wrangler r2 bucket create " + key + "-media",
+      "  wrangler kv namespace create RL && wrangler kv namespace create DRAFTS",
+      "  # apply migrations + seed your first editor:",
+      "  wrangler d1 migrations apply DB --remote",
+      "  OWNER_EMAIL=you@example.com pnpm seed:editors",
+      "  # develop / ship:",
+      "  pnpm dev            # astroid dev (regenerates, then astro dev)",
+      "  pnpm doctor         # validate config + bindings",
+      "  wrangler deploy",
+      "",
+    ].join("\n"),
+  );
+  if (!authMigrationOk) {
+    process.stdout.write(
+      "Note: generate the Better Auth migration after install:\n" +
+        "  npx louise gen-auth-schema --out migrations/0001_auth.sql\n\n",
+    );
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err instanceof Error ? err.stack : String(err)}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "create-astroid",
+  "version": "0.1.0",
+  "description": "Scaffold a new Astroid site — an editable, multi-editor Astro app on Cloudflare Workers — in one command.",
+  "keywords": [
+    "astro",
+    "astroid",
+    "cloudflare-workers",
+    "cms",
+    "create",
+    "louise-toolkit",
+    "scaffold"
+  ],
+  "license": "MIT",
+  "author": "BowenLabs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bowenlabs/louise-toolkit.git",
+    "directory": "packages/create-astroid"
+  },
+  "type": "module",
+  "bin": {
+    "create-astroid": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "template"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "louise-toolkit": "0.14.0",
+    "astroidjs": "0.1.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}

package/template/README.md

@@ -0,0 +1,106 @@
+# __BRAND_NAME__
+
+An editable, multi-editor site on Cloudflare Workers — scaffolded with
+[Astroid](https://github.com/bowenlabs/louise-toolkit) (Astro + Louise Toolkit).
+
+The whole shape of this site lives in one typed config, [`astroid.config.ts`](./astroid.config.ts).
+`src/schema.ts`, `src/worker.ts`, and `src/middleware.ts` are **generated** from it
+(they carry a "do not hand-edit" banner) — run `pnpm generate` after any config
+change, or just use `pnpm dev`/`pnpm build`, which regenerate first.
+
+## Develop
+
+```sh
+pnpm install
+cp .env.example .dev.vars   # local secrets for `astro dev`; fill SESSION_SECRET + OWNER_EMAIL
+pnpm dev                    # astroid dev: regenerate, then astro dev
+```
+
+## Deploy
+
+Astroid wrote `wrangler.jsonc` with placeholder binding ids. Pick a path to
+provision them and ship — then seed content + your first editor (below).
+
+### Zero-CLI — Deploy to Cloudflare
+
+Push this repo to GitHub and drop this button in place (swap in your repo URL).
+Cloudflare clones the repo, provisions the D1/R2/KV bindings declared in
+`wrangler.jsonc`, and deploys — no local tooling:
+
+[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=<YOUR_GITHUB_REPO_URL>)
+
+### One command — `astroid deploy`
+
+Provisions the still-placeholder bindings, applies migrations, prompts for
+secrets, and deploys — through your local `wrangler`:
+
+```sh
+pnpm astroid deploy --dry-run   # preview the exact commands it will run
+pnpm astroid deploy             # provision + migrate + secrets + deploy (asks first)
+```
+
+### By hand
+
+```sh
+wrangler d1 create __KEY__
+wrangler r2 bucket create __KEY__-media
+wrangler kv namespace create RL && wrangler kv namespace create DRAFTS
+# paste the printed ids into wrangler.jsonc, then:
+wrangler secret put SESSION_SECRET          # openssl rand -base64 32
+wrangler d1 migrations apply DB --remote
+wrangler deploy
+```
+
+### Seed content + your first editor
+
+```sh
+wrangler d1 execute DB --file seed/home.seed.sql --remote
+OWNER_EMAIL=you@example.com pnpm seed:editors
+```
+
+## Editors & auth
+
+Editors sign in with a magic link (passkeys supported). The allowlist is
+**DB-managed**: an admin `user` row *is* an editor. Seed the first one above; add
+or remove the rest from the Users panel (backed by the generated `editorsRoute`).
+There are no passwords and no editor list in env to keep in sync.
+
+### Editing your site
+
+1. Go to **`/login`** and enter a seeded editor's email. In local dev there's no
+   email binding, so the magic link is printed to the `wrangler`/`astro dev`
+   console — open it from there. In production it's emailed.
+2. The link signs you in and drops you at **`/?louise`** — edit mode. The **edit
+   bar** appears with **Settings** and **Done**.
+3. The home page's **title and body are editable in place** — click into them and
+   type. Edits stage a **draft**; **Publish** (in the edit bar) promotes it live.
+   **Settings** opens the drawer: **Pages** (create/edit other pages), **Media**,
+   **Settings** (brand, nav, contact, SEO), and **Users** (invite/remove editors).
+   **Done** leaves edit mode.
+
+Inline editing uses Astroid's [`<Editable>`](https://github.com/bowenlabs/louise-toolkit)
+primitive (`src/pages/index.astro`): it stamps the `data-louise-*` markers only in
+edit mode, so the public HTML stays clean. Wrap any page field in `<Editable
+collection="pages" key={page.id} field="…">` and pass `versionedPageId` to make it
+editable. Body HTML is sanitized on every save.
+
+## Redeploy
+
+Once provisioned, shipping changes is just:
+
+```sh
+pnpm doctor         # validate config, bindings, and generated-file freshness
+wrangler deploy     # or: pnpm astroid deploy
+```
+
+## Layout
+
+| Path | What |
+| --- | --- |
+| `astroid.config.ts` | The one typed config — brand, archetype, sections. |
+| `src/schema.ts` · `src/worker.ts` · `src/middleware.ts` | **Generated** — don't hand-edit. |
+| `wrangler.jsonc` | Yours to edit — real binding ids, routes, secrets. |
+| `src/auth.ts` | The editor auth seam (Better Auth, DB-managed editors). |
+| `src/pages/` · `src/components/` · `src/layouts/` | Your Astro app. |
+| `migrations/` | `0000_content.sql` (content + FTS) · `0001_auth.sql` (Better Auth). |
+| `scripts/seed-editors.mjs` | Bootstrap the first editor. |

package/template/_env.example

@@ -0,0 +1,12 @@
+# Local dev secrets (wrangler reads .dev.vars; copy this there for `astro dev`).
+# In production these are set with `wrangler secret put`, NOT committed.
+
+# Signs Better Auth sessions. Generate: `openssl rand -base64 32`.
+SESSION_SECRET=
+
+# The first editor's email — seeded as an admin `user` row by `pnpm seed:editors`,
+# and thereafter part of the DB-managed magic-link allowlist.
+OWNER_EMAIL=you@example.com
+
+# `from` address for magic-link + notification email (Cloudflare Email Sending).
+MAIL_FROM=no-reply@__KEY__.example

package/template/_gitignore

@@ -0,0 +1,19 @@
+# build output
+dist/
+.astro/
+
+# dependencies
+node_modules/
+
+# cloudflare / wrangler
+.wrangler/
+.dev.vars
+
+# local env + secrets
+.env
+.env.*
+!.env.example
+
+# logs / os
+*.log
+.DS_Store

package/template/astro.config.mjs

@@ -0,0 +1,30 @@
+// @ts-check
+import cloudflare from "@astrojs/cloudflare";
+import solid from "@astrojs/solid-js";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig } from "astro/config";
+
+// SSR (`output: server`) because Louise renders per-request edit affordances and
+// reads pages from D1. Solid islands power the editor UI (ADR 0001). Tailwind v4 +
+// daisyUI drive the theme (src/styles/site.css). Cloudflare *bindings* are read
+// via `import { env } from "cloudflare:workers"` (typed in src/env.d.ts), so there
+// is no astro:env schema here.
+export default defineConfig({
+  site: "__SITE_URL__",
+  output: "server",
+  adapter: cloudflare(),
+  integrations: [solid()],
+  vite: { plugins: [tailwindcss()] },
+  // Content-Security-Policy. Astro hashes every processed script + style and emits
+  // a `content-security-policy` response header on on-demand (SSR) pages — which is
+  // all of ours. The generated src/middleware.ts (createLouiseMiddleware) then
+  // rewrites `style-src` to `'self' 'unsafe-inline'` so Louise's data-driven
+  // `style=""` carriers and the editor's runtime-injected <style> are allowed, and
+  // permits the inlined `data:` brand font. This is why the inline scripts here
+  // (login.astro, LouiseEdit.astro) avoid is:inline/define:vars — those can't be
+  // hashed and would be blocked.
+  //
+  // Using Square Web Payments? Allow its SDK host in script-src:
+  //   security: { csp: { scriptDirective: { resources: ["'self'", "https://web.squarecdn.com"] } } }
+  security: { csp: true },
+});

package/template/drizzle.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "drizzle-kit";
+
+// Generates D1 (SQLite) migrations from src/schema.ts into ./migrations, applied
+// by `wrangler d1 migrations apply DB`. The schema is the astroid-generated
+// content tables (louise-toolkit/db column sets).
+//
+// Better Auth owns its own tables (user/session/account/verification/passkey) —
+// they're generated by `louise gen-auth-schema` (see migrations/0001_auth.sql),
+// NOT by Drizzle, so they're fenced out here to keep drizzle-kit from trying to
+// drop or recreate them.
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.ts",
+  out: "./migrations",
+  tablesFilter: ["!user", "!session", "!account", "!verification", "!passkey"],
+});

package/template/migrations/0000_content.sql

@@ -0,0 +1,97 @@
+-- Content tables for Astroid: pages (page-builder), version snapshots, the media
+-- library, editable site settings, inquiries, and the pages full-text index.
+-- Applied by `wrangler d1 migrations apply DB`. Matches the astroid-generated
+-- src/schema.ts; the Better Auth tables are in 0001_auth.sql.
+
+CREATE TABLE `pages` (
+  `id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  `slug` text NOT NULL,
+  `title` text NOT NULL,
+  `body` text,
+  `status` text DEFAULT 'draft' NOT NULL,
+  `seo_title` text,
+  `seo_description` text,
+  `og_image` text,
+  `noindex` integer DEFAULT false NOT NULL,
+  `sort_order` real DEFAULT 0,
+  `created_at` integer,
+  `updated_at` integer,
+  `sections` text,
+  `published_version_id` integer
+);
+CREATE UNIQUE INDEX `pages_slug_unique` ON `pages` (`slug`);
+
+CREATE TABLE `pages_versions` (
+  `id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  `parent_id` integer NOT NULL,
+  `version_data` text NOT NULL,
+  `status` text NOT NULL,
+  `created_at` integer,
+  `scheduled_at` integer
+);
+
+CREATE TABLE `media` (
+  `id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  `key` text NOT NULL,
+  `content_type` text,
+  `size` integer,
+  `width` integer,
+  `height` integer,
+  `alt` text,
+  `caption` text,
+  `uploaded_at` integer
+);
+CREATE UNIQUE INDEX `media_key_unique` ON `media` (`key`);
+
+CREATE TABLE `site_settings` (
+  `id` integer PRIMARY KEY DEFAULT 1 NOT NULL,
+  `site_name` text,
+  `tagline` text,
+  `logo_url` text,
+  `favicon_url` text,
+  `brand_color` text,
+  `secondary_color` text,
+  `tertiary_color` text,
+  `font_pairing` text,
+  `homepage_layout` text,
+  `dark_mode` integer DEFAULT false NOT NULL,
+  `theme` text,
+  `spacing_preset` text,
+  `type_tokens` text,
+  `nav_background` text,
+  `nav_text_color` text,
+  `footer_background` text,
+  `footer_text_color` text,
+  `page_background` text,
+  `surface_background` text,
+  `contact_email` text,
+  `contact_phone` text,
+  `contact_address` text,
+  `social_links` text,
+  `nav_links` text,
+  `meta_description` text,
+  `default_og_image_url` text,
+  `disable_indexing` integer DEFAULT false NOT NULL,
+  `primary_domain` text,
+  `domain_provider` text,
+  `nameserver_delegated` integer DEFAULT false NOT NULL,
+  `cf_account_id` text,
+  `cf_api_token_scoped` integer DEFAULT false NOT NULL,
+  `features` text,
+  `custom` text,
+  CONSTRAINT "site_settings_singleton" CHECK ("site_settings"."id" = 1)
+);
+
+CREATE TABLE `inquiries` (
+  `id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  `first_name` text,
+  `last_name` text,
+  `email` text NOT NULL,
+  `regarding` text,
+  `message` text NOT NULL,
+  `created_at` integer
+);
+
+-- Full-text search over pages (FTS5). A virtual table has no Drizzle schema, so
+-- it's hand-authored; kept in sync on publish, backfill via POST /api/louise/pages/reindex.
+CREATE VIRTUAL TABLE IF NOT EXISTS `pages_fts` USING fts5(`title`, `body`, `sections`);

package/template/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "__KEY__",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "astroid dev",
+    "build": "astroid build",
+    "preview": "astro preview",
+    "check": "astro check",
+    "generate": "astroid generate",
+    "doctor": "astroid doctor",
+    "seed:editors": "node scripts/seed-editors.mjs",
+    "astro": "astro"
+  },
+  "dependencies": {
+    "@astrojs/cloudflare": "^14.1.3",
+    "@astrojs/solid-js": "^7.0.1",
+    "@better-auth/passkey": "^1.6.23",
+    "astro": "^7.0.9",
+    "astroidjs": "^0.1.0",
+    "better-auth": "^1.6.23",
+    "drizzle-orm": "^0.45.2",
+    "louise-toolkit": "^0.14.0",
+    "solid-js": "^1.9.14",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.9",
+    "@cloudflare/workers-types": "^5.20260714.1",
+    "@tailwindcss/vite": "^4.1.0",
+    "daisyui": "^5.6.18",
+    "drizzle-kit": "^0.31.10",
+    "tailwindcss": "^4.1.0",
+    "typescript": "^5.9.3",
+    "wrangler": "^4.110.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}

package/template/scripts/seed-editors.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// Seed the first editor(s) — an admin `user` row per OWNER_EMAIL / ENGINEER_EMAIL.
+// A row here IS an editor and IS the magic-link allowlist, so this bootstraps
+// access before anyone can sign in. Idempotent (INSERT OR IGNORE on unique email).
+// After this, add more editors from the Users panel (never by editing env).
+//
+//   OWNER_EMAIL=you@example.com pnpm seed:editors            # seeds the remote D1
+//   OWNER_EMAIL=you@example.com pnpm seed:editors --local    # seeds the local dev D1
+//
+// Mirrors the INSERT louise-toolkit's editorsRoute uses (ISO-string dates,
+// emailVerified = 1, role 'admin').
+
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+const emails = [process.env.OWNER_EMAIL, process.env.ENGINEER_EMAIL]
+  .map((e) => e?.trim().toLowerCase())
+  .filter((e) => !!e);
+
+if (emails.length === 0) {
+  console.error("Set OWNER_EMAIL (optionally ENGINEER_EMAIL) first, e.g.:");
+  console.error("  OWNER_EMAIL=you@example.com pnpm seed:editors");
+  process.exit(1);
+}
+for (const email of emails) {
+  if (!EMAIL_RE.test(email)) {
+    console.error(`Refusing to seed a malformed email: ${email}`);
+    process.exit(1);
+  }
+}
+
+const target = process.argv.includes("--local") ? "--local" : "--remote";
+const now = new Date().toISOString();
+
+/**
+ * Quote a value as a SQL string literal, doubling any embedded single quote.
+ * `wrangler d1 execute` takes raw SQL via `--command` with no parameter binding,
+ * so values have to be escaped rather than bound — and an apostrophe is legal in
+ * an email local part, so this is a correctness fix as much as a safety one.
+ */
+const q = (value) => `'${String(value).replace(/'/g, "''")}'`;
+
+for (const email of emails) {
+  const id = randomUUID();
+  const name = email.split("@")[0];
+  const sql =
+    "INSERT OR IGNORE INTO user " +
+    "(id, name, email, emailVerified, createdAt, updatedAt, role, firstName, lastName) VALUES " +
+    `(${q(id)}, ${q(name)}, ${q(email)}, 1, ${q(now)}, ${q(now)}, 'admin', NULL, NULL);`;
+  console.log(`Seeding editor ${email} (${target}) …`);
+  execFileSync("wrangler", ["d1", "execute", "DB", target, "--command", sql], { stdio: "inherit" });
+}
+console.log("Done — these emails can now request a magic-link sign-in.");

package/template/seed/home.seed.sql

@@ -0,0 +1,14 @@
+-- Seed the editable home page (slug `home`) that src/pages/index.astro renders.
+-- Idempotent. Apply once after migrations:
+--   wrangler d1 execute DB --file seed/home.seed.sql --remote
+--   (drop --remote for the local dev D1)
+INSERT OR IGNORE INTO pages (slug, title, body, status, sort_order, created_at, updated_at)
+VALUES (
+  'home',
+  '__BRAND_NAME__',
+  '<p>Welcome to __BRAND_NAME__. Sign in at <code>/login</code>, switch on edit mode, and change this text in place — then hit Publish.</p>',
+  'published',
+  0,
+  unixepoch(),
+  unixepoch()
+);

package/template/src/auth.ts

@@ -0,0 +1,60 @@
+// The auth seam Astroid's generated worker.ts + middleware.ts import
+// (`resolveEditor`), plus the Better Auth catch-all the /api/auth route calls.
+//
+// DB-managed editors: an admin `user` row IS an editor. That table is BOTH the
+// role source and the magic-link allowlist — `resolveAdmins` reads it, so only an
+// existing editor's email can request a sign-in link. Seed the first editor with
+// `pnpm seed:editors`; add more from the Users panel (editorsRoute), never by
+// editing env. Magic-link + passkey come from `getLouiseAuth`; no passwords.
+
+import { env } from "cloudflare:workers";
+import {
+  type EditorSession,
+  getLouiseAuth,
+  handleAuthRequest,
+  type LouiseAuth,
+  type MagicLinkEmail,
+  resolveEditorSession,
+} from "louise-toolkit/auth";
+
+const BRAND = "__BRAND_NAME__";
+
+/** The DB-managed editor allowlist: every admin `user` row. */
+async function resolveAdmins(): Promise<string[]> {
+  const { results } = await env.DB.prepare(
+    "SELECT email FROM user WHERE role = 'admin'",
+  ).all<{ email: string }>();
+  return results.map((r) => r.email);
+}
+
+function renderMagicLinkEmail({ url }: { url: string; toEmail: string }): MagicLinkEmail {
+  return {
+    subject: `Sign in to ${BRAND}`,
+    text: `Sign in to ${BRAND}:\n\n${url}\n\nThis link expires in 15 minutes. If you didn't request it, ignore this email.`,
+    html: `<p>Sign in to <strong>${BRAND}</strong>:</p><p><a href="${url}">Open the ${BRAND} editor</a></p><p style="color:#666">This link expires in 15 minutes. If you didn't request it, ignore this email.</p>`,
+  };
+}
+
+/** The request-scoped Better Auth instance (magic-link + passkey, DB allowlist). */
+function getAuth(request: Request): Promise<LouiseAuth> {
+  return getLouiseAuth(env, new URL(request.url).origin, {
+    rpName: BRAND,
+    mailFrom: { email: env.MAIL_FROM, name: BRAND },
+    renderMagicLinkEmail,
+    resolveAdmins,
+  });
+}
+
+/**
+ * Re-derive the editor session from the signed Better Auth session on every
+ * request — the seam the generated worker.ts + middleware.ts call. Null when the
+ * caller isn't a signed-in editor, which is what denies edit/write access.
+ */
+export async function resolveEditor(request: Request): Promise<EditorSession | null> {
+  return resolveEditorSession(await getAuth(request), request);
+}
+
+/** Better Auth catch-all with the magic-link allowlist gate (see /api/auth). */
+export async function handleAuth(request: Request): Promise<Response> {
+  return handleAuthRequest(await getAuth(request), request, await resolveAdmins());
+}

package/template/src/components/Hero.astro

@@ -0,0 +1,16 @@
+---
+interface Props {
+  title: string;
+  tagline: string;
+}
+const { title, tagline } = Astro.props;
+---
+
+<section class="hero min-h-[60vh]">
+  <div class="hero-content text-center">
+    <div class="max-w-2xl">
+      <h1 class="text-5xl font-bold">{title}</h1>
+      <p class="py-6 text-lg opacity-80">{tagline}</p>
+    </div>
+  </div>
+</section>

package/template/src/components/LouiseEdit.astro

@@ -0,0 +1,65 @@
+---
+// Boots the in-page Louise editor — the edit bar + the Settings drawer (Pages,
+// Media, Settings, Users). Drop it before </body> in your layout.
+//
+// Gated on `Astro.locals.editMode`, which the generated middleware sets for a
+// signed-in editor who has toggled edit mode on (`?louise`). An anonymous visitor
+// gets editMode=false, so the heavy Solid/ProseKit client is never even sent to
+// them. The client self-injects its own styles.
+//
+// Pass `versionedPageId` from a page whose `<Editable>` fields should stage drafts
+// + publish (the layout forwards it). Omit it and the bar is Settings-only.
+const { editMode, editor } = Astro.locals;
+const { versionedPageId } = Astro.props as { versionedPageId?: number };
+---
+
+{
+  editMode && (
+    <>
+      {/* Per-render values (editor name, versioned page id) ride as data-* on this
+          marker element rather than a define:vars inline script. define:vars forces
+          is:inline, whose content varies per request and so can't be hashed by
+          Astro's security.csp — it would be CSP-blocked. The boot script below
+          reads them from here; being static, it hashes cleanly into script-src.
+          The element also gates the editor: no marker (a non-edit page swapped in
+          by a view transition) → boot() no-ops. */}
+      <div
+        id="louise-boot"
+        hidden
+        data-louise-user={editor?.name ?? "Editor"}
+        data-louise-versioned-page={versionedPageId != null ? String(versionedPageId) : undefined}
+      />
+      <script>
+        // Lazy-import the editor client only in edit mode. `mountLouise` renders
+        // the edit bar; `mountSettings` renders the drawer (Pages/Media/Settings +
+        // Users, backed by editorsRoute). When the page passes `versionedPageId`,
+        // the bar gains Save draft + Publish, and this page's `<Editable>` fields
+        // are edited in place — their changes stage a draft, promoted on Publish.
+        function boot() {
+          const el = document.getElementById("louise-boot");
+          if (!el) return;
+          Promise.all([
+            import("louise-toolkit/client"),
+            import("louise-toolkit/client/settings"),
+          ])
+            .then(([client, settings]) => {
+              settings.mountSettings({
+                userName: el.dataset.louiseUser || "Editor",
+                users: true,
+              });
+              const versioned = el.dataset.louiseVersionedPage;
+              client.mountLouise({
+                onOpenSettings: () =>
+                  window.dispatchEvent(new Event(settings.OPEN_SETTINGS_EVENT)),
+                versionedPageId: versioned ? Number(versioned) : undefined,
+              });
+            })
+            .catch((err) => console.error("[louise] editor bootstrap failed", err));
+        }
+        boot();
+        // Re-boot after a view-transition navigation (the swapped-in body needs it).
+        document.addEventListener("astro:page-load", boot);
+      </script>
+    </>
+  )
+}

package/template/src/env.d.ts

@@ -0,0 +1,49 @@
+/// <reference path="../.astro/types.d.ts" />
+/// <reference types="astro/client" />
+/// <reference types="@cloudflare/workers-types" />
+
+// The Cloudflare bindings this Worker exposes (wrangler.jsonc), read via
+// `import { env } from "cloudflare:workers"`. Astroid generated the wrangler
+// bindings; this is the type over them. Add a binding here when you add one to
+// wrangler.jsonc (e.g. AI, a Queue, a Durable Object).
+type CloudflareEnv = {
+  /** D1 — pages / site_settings / media / inquiries + the Better Auth tables. */
+  DB: D1Database;
+  /** R2 — uploaded media, streamed back through the Worker at MEDIA_URL. */
+  MEDIA: R2Bucket;
+  /** Public base for media URLs (the framework-agnostic media route reads this). */
+  MEDIA_URL: string;
+  /** Cloudflare Images — upload dimensions + server-side transforms. */
+  IMAGES: ImagesBinding;
+  /** KV — the security rate limiter. */
+  RL: KVNamespace;
+  /** KV — the autosave draft write-buffer (optional; falls back to direct D1). */
+  DRAFTS?: KVNamespace;
+  /** Cloudflare Email Sending — magic-link + notification email. */
+  EMAIL: SendEmail;
+  /** Static assets (bound by the @astrojs/cloudflare adapter). */
+  ASSETS: Fetcher;
+  /** Signs Better Auth sessions (`wrangler secret put SESSION_SECRET`). */
+  SESSION_SECRET: string;
+  /** First editor's email — seeded as an admin, then part of the DB allowlist. */
+  OWNER_EMAIL: string;
+  /** Optional second bootstrap editor (e.g. your engineer). */
+  ENGINEER_EMAIL?: string;
+  /** `from` address for outbound email. */
+  MAIL_FROM: string;
+};
+
+// `env` from `cloudflare:workers` is typed as the augmentable `Cloudflare.Env`.
+declare namespace Cloudflare {
+  interface Env extends CloudflareEnv {}
+}
+
+// Middleware sets these; bindings themselves come from `cloudflare:workers`.
+declare namespace App {
+  interface Locals {
+    /** Resolved editor session (authorizes writes). Null when not signed in. */
+    editor: import("louise-toolkit/auth").EditorSession | null;
+    /** Whether the page should render edit affordances. */
+    editMode: boolean;
+  }
+}

package/template/src/layouts/Site.astro

@@ -0,0 +1,30 @@
+---
+// The base HTML shell. `Astro.locals.editMode` is set by the generated
+// middleware.ts (from your auth seam); LouiseEdit boots the editor when it's on.
+import LouiseEdit from "../components/LouiseEdit.astro";
+import "../styles/site.css";
+
+interface Props {
+  title?: string;
+  description?: string;
+  /** A `pages` row id whose `<Editable>` fields stage drafts + publish. */
+  versionedPageId?: number;
+}
+
+const { title = "__BRAND_NAME__", description, versionedPageId } = Astro.props;
+const { editMode } = Astro.locals;
+---
+
+<!doctype html>
+<html lang="en" data-theme="light">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{title}</title>
+    {description && <meta name="description" content={description} />}
+  </head>
+  <body class="min-h-screen bg-base-100 text-base-content" data-edit-mode={editMode ? "" : undefined}>
+    <slot />
+    <LouiseEdit versionedPageId={versionedPageId} />
+  </body>
+</html>

package/template/src/pages/api/auth/[...all].ts

@@ -0,0 +1,9 @@
+// Better Auth catch-all — magic-link sign-in, passkey, session. The allowlist
+// gate (handleAuth → handleAuthRequest) rejects magic-link requests from
+// non-editor emails before Better Auth runs, enumeration-safe.
+import type { APIRoute } from "astro";
+import { handleAuth } from "../../../auth";
+
+export const prerender = false;
+
+export const ALL: APIRoute = ({ request }) => handleAuth(request);

package/template/src/pages/index.astro

@@ -0,0 +1,62 @@
+---
+// The home page — an editable `pages` row rendered in place. Reads the published
+// `home` row for the public view; in edit mode it reads the latest DRAFT so an
+// editor's in-progress edits resume. The <Editable> fields carry the markers the
+// Louise client turns into inline editors; saves stage a draft (versionedPageId),
+// and Publish promotes it. Seed the row once with `seed/home.seed.sql`.
+import Editable from "astroidjs/components/Editable.astro";
+import { env } from "cloudflare:workers";
+import Hero from "../components/Hero.astro";
+import Site from "../layouts/Site.astro";
+
+export const prerender = false;
+
+const { editMode } = Astro.locals;
+
+let page: { id: number; title: string; body: string | null } | null = null;
+try {
+  page = await env.DB.prepare("SELECT id, title, body FROM pages WHERE slug = 'home'").first();
+} catch {
+  // No DB binding yet (pre-provision) — fall through to the seed-me prompt.
+}
+
+let title = page?.title ?? "__BRAND_NAME__";
+let body = page?.body ?? "";
+
+// In edit mode, prefer the latest unpublished draft so edits resume across reloads.
+if (editMode && page) {
+  try {
+    const draft = await env.DB.prepare(
+      "SELECT version_data FROM pages_versions WHERE parent_id = ? AND status = 'draft' ORDER BY created_at DESC LIMIT 1",
+    )
+      .bind(page.id)
+      .first<{ version_data: string }>();
+    if (draft?.version_data) {
+      const d = JSON.parse(draft.version_data) as { title?: string; body?: string };
+      if (typeof d.title === "string") title = d.title;
+      if (typeof d.body === "string") body = d.body;
+    }
+  } catch {
+    // Non-fatal — fall back to the live row.
+  }
+}
+---
+
+<Site title={title} description={undefined} versionedPageId={page?.id}>
+  {
+    page ? (
+      <main class="mx-auto max-w-3xl px-6 py-16">
+        <Editable as="h1" collection="pages" key={page.id} field="title" class="text-5xl font-bold">
+          {title}
+        </Editable>
+        <Editable as="div" collection="pages" key={page.id} field="body" type="richtext" class="prose mt-6 max-w-none">
+          <Fragment set:html={body} />
+        </Editable>
+      </main>
+    ) : (
+      <main>
+        <Hero title={title} tagline="Seed the home page (seed/home.seed.sql) to edit it in place." />
+      </main>
+    )
+  }
+</Site>

package/template/src/pages/login.astro

@@ -0,0 +1,60 @@
+---
+// Editor sign-in. Emails a magic link (Better Auth) to an allowlisted editor;
+// clicking it starts a session and lands on `/?louise` (edit mode on). The gate
+// is enumeration-safe — the response is identical whether or not the email is an
+// editor — so the UI always says "check your email".
+import Site from "../layouts/Site.astro";
+
+export const prerender = false;
+---
+
+<Site title="Sign in">
+  <main class="hero min-h-screen">
+    <div class="hero-content w-full max-w-sm">
+      <form id="magic" class="card w-full bg-base-200 shadow-sm">
+        <div class="card-body gap-4">
+          <h1 class="card-title">Sign in to edit</h1>
+          <label class="form-control w-full">
+            <span class="label-text mb-1">Editor email</span>
+            <input
+              id="email"
+              name="email"
+              type="email"
+              required
+              autocomplete="email"
+              placeholder="you@example.com"
+              class="input input-bordered w-full"
+            />
+          </label>
+          <button type="submit" class="btn btn-primary">Email me a sign-in link</button>
+          <p id="msg" class="text-sm opacity-70" aria-live="polite"></p>
+        </div>
+      </form>
+    </div>
+  </main>
+
+  {/* Processed (NOT is:inline) so Astro's security.csp hashes it into script-src.
+      Keep it dependency-free and static — an is:inline or define:vars script here
+      would be unhashable and CSP-blocked. */}
+  <script>
+    const form = document.getElementById("magic");
+    const msg = document.getElementById("msg");
+    form?.addEventListener("submit", async (e) => {
+      e.preventDefault();
+      const input = document.getElementById("email") as HTMLInputElement | null;
+      const email = input?.value.trim();
+      if (!email || !msg) return;
+      msg.textContent = "Sending…";
+      try {
+        await fetch("/api/auth/sign-in/magic-link", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ email, callbackURL: "/?louise" }),
+        });
+        msg.textContent = "If that email is an editor, a sign-in link is on its way.";
+      } catch {
+        msg.textContent = "Something went wrong — please try again.";
+      }
+    });
+  </script>
+</Site>

package/template/src/styles/site.css

@@ -0,0 +1,10 @@
+/* The site's theme. Tailwind v4 + daisyUI; the Louise editor theme layers on top.
+   Your brand color is the single token below — Astroid wrote it from your config
+   (theme.colors.brand). Restyle by editing here; it flows through the utilities. */
+@import "tailwindcss";
+@plugin "daisyui";
+@import "louise-toolkit/theme/louise.css";
+
+:root {
+  --brand: __BRAND_COLOR__;
+}

package/template/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"],
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "types": ["@cloudflare/workers-types"]
+  }
+}