astroidjs 0.17.0 → 0.19.0

package/dist/queues/scaffold.js

@@ -105,9 +105,20 @@ export function generateAstroidQueueSeam(config) {
         "// MEANS for this project.",
         "//",
         "// Throwing marks the message for retry. That's usually right—a failed",
-        "// refresh means the site is serving stale data—and Cloudflare routes it to",
-        "// the DLQ once it exceeds max_retries (wrangler.jsonc).",
-        'import { astroidQueueHandler, type AstroidQueueMessage } from "astroidjs";',
+        "// refresh means the site is serving stale data—and the queue owns the",
+        "// retries: it waits `retry_delay` between deliveries and routes the message",
+        "// to the DLQ once it exceeds max_retries (wrangler.jsonc).",
+        'import { astroidQueue, astroidQueueHandler, type AstroidQueueMessage } from "astroidjs";',
+        "",
+        `// Send every message through this, never \`env.${ASTROID_QUEUE_BINDING}\` directly: the`,
+        "// queue binding when there is one, otherwise `handleQueueMessage` run in the",
+        "// request. A staging Preview has no queue, because a consumer can't target a",
+        "// Preview, so a producer that sends straight to the binding throws there.",
+        "// The inline path outlasts nothing but the request, with no retry and no",
+        "// DLQ, so it's a Preview fallback, not a production path.",
+        "export function commerceQueue(env: CloudflareEnv) {",
+        `  return astroidQueue(env.${ASTROID_QUEUE_BINDING}, (message) => handleQueueMessage(env, message));`,
+        "}",
         "",
         "export async function handleQueueMessage(",
         "  env: CloudflareEnv,",
@@ -135,20 +146,22 @@ export function generateAstroidQueueSeam(config) {
         `      //   const r = await astroidCatalogSync(items, { db: env.DB, table: ${JSON.stringify(table)} });`,
         '      //   if (r.failed > 0) console.warn("[catalog] skipped", r.failed, r.errors);',
         "      //",
-        // Nobody is watching a queue message, which flips the retry trade-off that
-        // an attended checkout route settles the other way.
+        // One layer owns retries, and it's the queue: it survives the isolate,
+        // waits between deliveries, and ends in the DLQ. Retries inside the handler
+        // multiply with the queue's (#61).
         ...(provider === "square"
             ? [
-                "      // Nobody is watching this run, so let the client retry: SquareConfig",
-                "      // takes `retry: { attempts: 3 }`, backing off on 429/5xx inside every",
-                "      // verb. It is off by default because a checkout route has a customer",
-                "      // watching a spinner, and there a fast failure beats a slow one. Here",
-                "      // the opposite holds—a catalog push that gives up halfway is worse.",
+                "      // Leave SquareConfig's `retry` off here. The queue already redelivers",
+                "      // a failed message, `retry_delay` apart, up to max_retries times",
+                "      // (wrangler.jsonc). Client retries multiply with those deliveries:",
+                "      // `retry: { attempts: 3 }` on a queue with max_retries 5 is up to 24",
+                "      // Square calls for one message, against a provider that's already",
+                "      // failing or rate limiting.",
             ]
             : [
-                "      // Nobody is watching this run, so ask for backoff on 429/5xx wherever",
-                "      // the client offers it. Attended paths are better off failing fast; a",
-                "      // catalog push that gives up halfway is not.",
+                "      // Leave the client's own retries off here. The queue already",
+                "      // redelivers a failed message, `retry_delay` apart, up to max_retries",
+                "      // times (wrangler.jsonc), and client retries multiply with those.",
             ]),
         "      //",
         "      // The sync is idempotent (keyed on the provider's id) and never",
@@ -198,12 +211,13 @@ export function generateAstroidWebhookRoute(config, forProvider) {
         "// secret land afterwards instead of being lost.",
         "//",
         "// A staging Preview has no queue, since a consumer can't target one, so",
-        "// there the event runs in the request through the same handler instead.",
+        "// `commerceQueue` runs the event in the request through the consumer's own",
+        "// handler instead (src/queue.ts).",
         'import type { APIRoute } from "astro";',
         'import { handleWebhook, readModuleSecret } from "astroidjs";',
         'import { env } from "cloudflare:workers";',
         `import { ${p.verifier} } from ${JSON.stringify(p.module)};`,
-        'import { handleQueueMessage } from "../../../queue";',
+        'import { commerceQueue } from "../../../queue";',
         "",
         "export const prerender = false;",
         "",
@@ -214,8 +228,7 @@ export function generateAstroidWebhookRoute(config, forProvider) {
         "  return handleWebhook(request, url, {",
         `    provider: ${JSON.stringify(provider)},`,
         `    secret: await readModuleSecret(env.${COMMERCE_PROVIDER_SECRETS[provider].webhook}),`,
-        `    queue: env.${ASTROID_QUEUE_BINDING},`,
-        "    inline: (message) => handleQueueMessage(env, message),",
+        "    queue: commerceQueue(env),",
         `    verify: ({ raw, secret }) => ${p.call},`,
         "  });",
         "};",

package/dist/queues/webhook.d.ts

@@ -10,6 +10,29 @@ import type { AstroidQueueMessage } from "./messages.js";
 export interface QueueProducer<T = AstroidQueueMessage> {
     send(message: T): Promise<unknown>;
 }
+/**
+ * The queue binding when it's bound, and otherwise a stand-in producer that
+ * runs `handler` on each message in the request.
+ *
+ * A staging Preview leaves the queue unbound, because a queue consumer can't
+ * target a Preview (louise-toolkit ADR 0017), so every producer that sends
+ * straight to the binding throws there. Send through this instead, with the
+ * handler the queue consumer runs, and the same code works on both:
+ *
+ * ```ts
+ * export const commerceQueue = (env: CloudflareEnv) =>
+ *   astroidQueue(env.COMMERCE_QUEUE, (message) => handleQueueMessage(env, message));
+ *
+ * await commerceQueue(env).send({ kind: "catalog_refresh" });
+ * ```
+ *
+ * It's a Preview fallback, not a production path. A message run inline lasts
+ * only as long as the request, gets no retry and no dead-letter queue, and a
+ * slow one holds the response open. The stand-in's `send` throws whatever the
+ * handler throws, where a real `send` would have succeeded and left the failure
+ * to the consumer. The binding always wins when it's there.
+ */
+export declare function astroidQueue<T = AstroidQueueMessage>(queue: QueueProducer<T> | null | undefined, handler: (message: T) => Promise<void>): QueueProducer<T>;
 export interface WebhookVerifyInput {
     /** The raw request body, exactly as received. */
     raw: string;
@@ -28,10 +51,16 @@ export interface WebhookRouteOptions {
     secret: string | null;
     /** Signature check over the raw body—for example, `verifySquareSignature`. */
     verify: (input: WebhookVerifyInput) => boolean | Promise<boolean>;
-    /** The queue binding, or null/undefined when Queues aren't provisioned. */
+    /**
+     * The queue binding, or null/undefined when Queues aren't provisioned. Pass
+     * {@link astroidQueue}'s producer to run the message in the request when the
+     * binding is absent, such as on a staging Preview.
+     */
     queue?: QueueProducer | null;
     /**
-     * Run a message in the request instead, when `queue` is absent. A staging
+     * Run a message in the request instead, when `queue` is absent. Prefer
+     * passing {@link astroidQueue}'s producer as `queue`, which covers every
+     * producer in a site rather than this one route. A staging
      * Preview leaves the queue unbound, because a queue consumer can't target a
      * Preview (louise-toolkit ADR 0017), so without this every webhook a Preview
      * receives answers 503 and the provider retries it forever.

package/dist/queues/webhook.js

@@ -14,6 +14,37 @@
 // available: a 5xx means "try again", a 4xx means "never again", and returning
 // the wrong one either loses the event permanently or pins the provider in a
 // retry loop. Each code below is chosen for what it tells the sender to do.
+/**
+ * The queue binding when it's bound, and otherwise a stand-in producer that
+ * runs `handler` on each message in the request.
+ *
+ * A staging Preview leaves the queue unbound, because a queue consumer can't
+ * target a Preview (louise-toolkit ADR 0017), so every producer that sends
+ * straight to the binding throws there. Send through this instead, with the
+ * handler the queue consumer runs, and the same code works on both:
+ *
+ * ```ts
+ * export const commerceQueue = (env: CloudflareEnv) =>
+ *   astroidQueue(env.COMMERCE_QUEUE, (message) => handleQueueMessage(env, message));
+ *
+ * await commerceQueue(env).send({ kind: "catalog_refresh" });
+ * ```
+ *
+ * It's a Preview fallback, not a production path. A message run inline lasts
+ * only as long as the request, gets no retry and no dead-letter queue, and a
+ * slow one holds the response open. The stand-in's `send` throws whatever the
+ * handler throws, where a real `send` would have succeeded and left the failure
+ * to the consumer. The binding always wins when it's there.
+ */
+export function astroidQueue(queue, handler) {
+    if (queue)
+        return queue;
+    return {
+        send: async (message) => {
+            await handler(message);
+        },
+    };
+}
 const text = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
 /** Default event-type reader: a top-level `type` string. */
 function defaultEventType(payload) {

package/dist/schema/collections.d.ts

@@ -69,6 +69,12 @@ export interface AstroidPagesHooks {
  * with a 422 instead.
  */
 export declare const ASTROID_RESERVED_SLUGS: readonly string[];
+/**
+ * The reserved slugs for this config: {@link ASTROID_RESERVED_SLUGS}, plus the
+ * file routes a module scaffolds, minus any in `pages.allowSlugs`. A
+ * portfolio's gallery is `src/pages/work.astro`.
+ */
+export declare function astroidReservedSlugs(config: AstroidConfig): string[];
 export declare function astroidPagesWriteHooks(config: AstroidConfig, site?: AstroidPagesHooks): {
     sanitize: (html: string) => string;
     transform: (data: Record<string, unknown>, ctx: AstroidPagesWriteContext) => Promise<Record<string, unknown>>;

package/dist/schema/collections.js

@@ -47,7 +47,7 @@ const pageMediaBase = astroidMediaBase;
  * The section catalog a `pages` write is validated + sanitized against: the
  * site's own (`config.sectionCatalog`) when it registered bespoke sections, else
  * Astroid's built-in vocabulary. This is what lets a site with its own section
- * designs (coracle's 13) keep the same write contract as a stock Astroid site.
+ * designs keep the same write contract as a stock Astroid site.
  */
 function resolveSectionCatalog(config) {
     return config.sectionCatalog ?? astroidSectionCatalog;
@@ -109,9 +109,21 @@ export const ASTROID_RESERVED_SLUGS = [
     "_astro",
     "api",
     "cdn-cgi",
+    // The scaffold's own file routes, which every site has.
+    "contact",
+    "login",
     "robots.txt",
     "sitemap.xml",
 ];
+/**
+ * The reserved slugs for this config: {@link ASTROID_RESERVED_SLUGS}, plus the
+ * file routes a module scaffolds, minus any in `pages.allowSlugs`. A
+ * portfolio's gallery is `src/pages/work.astro`.
+ */
+export function astroidReservedSlugs(config) {
+    const allowed = new Set(config.pages?.allowSlugs ?? []);
+    return [...ASTROID_RESERVED_SLUGS, ...(config.archetype === "portfolio" ? ["work"] : [])].filter((slug) => !allowed.has(slug));
+}
 export function astroidPagesWriteHooks(config, site = {}) {
     return {
         // `body` is a richField, so it goes through pagesRoute's own sanitize seam—with
@@ -127,7 +139,7 @@ export function astroidPagesWriteHooks(config, site = {}) {
             await site.validate?.(data, ctx);
             await assertAstroidPageSections(config, data, ctx.operation);
         },
-        reservedSlugs: [...ASTROID_RESERVED_SLUGS, ...(site.reservedSlugs ?? [])],
+        reservedSlugs: [...astroidReservedSlugs(config), ...(site.reservedSlugs ?? [])],
     };
 }
 export function astroidPagesCollection(config) {

package/dist/schema/framework.d.ts

@@ -1,13 +1,14 @@
 import type { AstroidConfig } from "../config.js";
 /** A ready-made table Astroid re-exports from `louise-toolkit/db`. */
-export type AstroidFrameworkTable = "inquiries" | "media" | "siteSettings";
+export type AstroidFrameworkTable = "inquiries" | "media" | "pageRedirects" | "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.
+ * import/export lists are stable). `media`, `pageRedirects`, and `siteSettings`
+ * always; `inquiries` when a brand captures them. `pageRedirects` keeps a
+ * renamed page's old URL working, which every site with a Pages panel needs.
  */
 export declare function astroidFrameworkTables(config: AstroidConfig): AstroidFrameworkTable[];

package/dist/schema/framework.js

@@ -2,15 +2,15 @@
 //
 // 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).
+// tables never drift from Louise. `media`, `pageRedirects`, 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) {
     // Explicit override wins—a site whose inquiry surface is a bespoke section
-    // (coracle's custom `contactForm`) can't be detected from the built-in
+    // (a custom `contactForm`, say) can't be detected from the built-in
     // vocabulary, so it says so directly.
     if (typeof config.inquiries === "boolean")
         return config.inquiries;
@@ -21,11 +21,12 @@ export function capturesInquiries(config) {
 }
 /**
  * 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.
+ * import/export lists are stable). `media`, `pageRedirects`, and `siteSettings`
+ * always; `inquiries` when a brand captures them. `pageRedirects` keeps a
+ * renamed page's old URL working, which every site with a Pages panel needs.
  */
 export function astroidFrameworkTables(config) {
-    const tables = ["media", "siteSettings"];
+    const tables = ["media", "pageRedirects", "siteSettings"];
     if (capturesInquiries(config))
         tables.push("inquiries");
     return tables.sort();

package/dist/worker/gateway.d.ts

@@ -0,0 +1,12 @@
+import type { AiGatewayOptions } from "louise-toolkit/ai";
+/** The `vars` entry that names the site's AI Gateway. */
+export declare const ASTROID_AI_GATEWAY_VAR = "AI_GATEWAY_ID";
+/**
+ * The AI Gateway options for this request's environment, or `undefined` to
+ * call Workers AI directly. Reads `AI_GATEWAY_ID`: unset, empty, or the
+ * placeholder sentinel all mean off.
+ *
+ * Takes `env` as `unknown`, like the toolkit's `aiRunner`, so a site whose
+ * `CloudflareEnv` doesn't declare the variable still compiles.
+ */
+export declare function astroidAiGateway(env: unknown): AiGatewayOptions | undefined;

package/dist/worker/gateway.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// AI Gateway for the editor's AI assists, off until a site names one.
+//
+// Every louise-toolkit AI route takes a `gateway` option, and without one no
+// successful AI call is logged anywhere: no latency, no error rate, and no
+// cache. A gateway gives all three with no toolkit change. It's a variable,
+// not config, so production can log through one while a Preview, which sets
+// no variable, calls Workers AI directly.
+//
+// The log holds the text an editor sends to the assists. Say so on the site's
+// privacy page before you set the variable.
+import { ASTROID_SECRET_PLACEHOLDER } from "../secrets.js";
+/** The `vars` entry that names the site's AI Gateway. */
+export const ASTROID_AI_GATEWAY_VAR = "AI_GATEWAY_ID";
+/**
+ * The AI Gateway options for this request's environment, or `undefined` to
+ * call Workers AI directly. Reads `AI_GATEWAY_ID`: unset, empty, or the
+ * placeholder sentinel all mean off.
+ *
+ * Takes `env` as `unknown`, like the toolkit's `aiRunner`, so a site whose
+ * `CloudflareEnv` doesn't declare the variable still compiles.
+ */
+export function astroidAiGateway(env) {
+    const id = env?.[ASTROID_AI_GATEWAY_VAR];
+    if (typeof id !== "string")
+        return undefined;
+    const trimmed = id.trim();
+    if (!trimmed || trimmed === ASTROID_SECRET_PLACEHOLDER)
+        return undefined;
+    return { id: trimmed };
+}

package/dist/worker/generate.js

@@ -69,10 +69,13 @@ export function generateAstroidWorker(config) {
     const editorImports = [
         "DEFAULT_PAGE_FIELDS",
         "type PagesWrite",
+        "MEDIA_ALT_MISSING_SQL",
+        "d1Check",
         ...new Set(plan.map((route) => route.factory).filter((f) => !realtimeRouteFactories.has(f))),
     ].sort();
     const tables = [
         "media",
+        "pageRedirects",
         "pages",
         "pagesVersions",
         "siteSettings",
@@ -90,10 +93,13 @@ export function generateAstroidWorker(config) {
                 return `vitalsRoute({ dataset: (env) => env.${ASTROID_VITALS_BINDING} })`;
             case "health":
                 return "healthRoute({ resolveEditor, read: readSiteHealth })";
+            case "status":
+                return "statusRoute({ checks: STATUS_CHECKS, reuseMs: STATUS_REUSE_MS })";
             case "realtime":
                 return `realtimeRoute({ resolveEditor, namespace: (env) => env.${ASTROID_REALTIME_BINDING} })`;
             case "versions":
-                return "versionsRoute({ table: pages, versionsTable: pagesVersions, config: pagesCollection, resolveEditor, bufferKv: (env) => env.DRAFTS })";
+                // `redirects` records `/old → /new` when a publish changes the slug.
+                return "versionsRoute({ table: pages, versionsTable: pagesVersions, config: pagesCollection, resolveEditor, bufferKv: (env) => env.DRAFTS, redirects: pageRedirects })";
             case "search":
                 return "searchRoute({ table: pages, config: pagesCollection, resolveEditor })";
             case "pages":
@@ -107,7 +113,15 @@ export function generateAstroidWorker(config) {
                 // which have no foreign key to the page and would otherwise orphan.
                 // `afterWrite` syncs the written page's search index entry, which plain
                 // CRUD writes leave stale.
-                return 'pagesRoute({ table: pages, versionsTable: pagesVersions, resolveEditor, fields: [...DEFAULT_PAGE_FIELDS, "sections"], ...pagesWriteHooks, afterWrite: reindexPagesSearch })';
+                //
+                // `drafts` carries a Pages panel update into the page's pending draft,
+                // with the same config and buffer versionsRoute uses. Without it, a
+                // rename made while a draft was pending came undone at the next
+                // publish, which copies the whole draft snapshot onto the live row.
+                //
+                // `redirects` records `/old → /new` in the same batch as a slug change,
+                // and the middleware's `redirectFor` serves it.
+                return 'pagesRoute({ table: pages, versionsTable: pagesVersions, drafts: { config: pagesCollection, bufferKv: (env) => env.DRAFTS }, redirects: pageRedirects, resolveEditor, fields: [...DEFAULT_PAGE_FIELDS, "sections"], ...pagesWriteHooks, afterWrite: reindexPagesSearch })';
             case "save":
                 // No `bufferKv` here, deliberately: `saveRoute` has no such option. It
                 // writes live field saves (title, SEO) straight through, and the draft
@@ -131,10 +145,12 @@ export function generateAstroidWorker(config) {
             // LOUISE_AI kill switch, so all three assists share one definition of
             // "is generation on?" instead of each re-deriving it. Embeddings keep
             // binding-presence as their switch—see the helper's comment.
+            // `gateway` routes both through AI Gateway when the site sets
+            // `AI_GATEWAY_ID`, and calls Workers AI directly when it doesn't.
             case "ai":
-                return "aiRoute({ resolveEditor, ai: aiRunner })";
+                return "aiRoute({ resolveEditor, ai: aiRunner, gateway: astroidAiGateway })";
             case "seoFix":
-                return "seoFixRoute({ table: pages, resolveEditor, ai: aiRunner })";
+                return "seoFixRoute({ table: pages, resolveEditor, ai: aiRunner, gateway: astroidAiGateway })";
             case "media": {
                 // `altText` fills a new upload's alt from the image itself. Best-effort
                 // by contract—a model error or a missing binding never fails the
@@ -197,10 +213,14 @@ export function generateAstroidWorker(config) {
         p('import { aiRunner } from "louise-toolkit/ai";');
     }
     p('import { checkLinks } from "louise-toolkit/browser";');
+    p('import { reportDegraded } from "louise-toolkit/errors";');
     p('import { readHealthSummary, summarizeHealth, writeHealthSummary } from "louise-toolkit/health";');
     p('import { composeWorker, isEditRequest, type WorkerRoute, withEdgeCache } from "louise-toolkit/worker";');
     p(`import { ${tables.join(", ")} } from "./schema.js";`);
     const astroidImports = [
+        ...(plan.some((route) => route.name === "ai" || route.name === "seoFix")
+            ? ["astroidAiGateway"]
+            : []),
         "astroidPagesCollection",
         "astroidPagesWriteHooks",
         "readModuleSecret",
@@ -221,6 +241,11 @@ export function generateAstroidWorker(config) {
         p("// route. Scaffolded once and yours to edit.");
         p('import { pagesHooks } from "./pages-hooks.js";');
     }
+    if (config.status?.checks) {
+        p("// Your STATUS seam: the site's own checks for the public status route,");
+        p("// such as a catalog snapshot's age. Scaffolded once and yours to edit.");
+        p('import { statusChecks } from "./status-checks.js";');
+    }
     if (config.settings?.hooks) {
         p("// Your SETTINGS seam: per-key sanitizers and a GET transform for the");
         p("// Settings panel. Scaffolded once and yours to edit.");
@@ -314,7 +339,9 @@ export function generateAstroidWorker(config) {
     p("  const origin = env.SITE_URL ?? mediaBaseOf(env);");
     p("  const [brokenLinks, missingAlt, seoGaps] = await Promise.all([");
     p('    checkLinks({ base: origin, paths: ["/"] }).catch(() => []),');
-    p("    countRows(env, \"SELECT COUNT(*) AS n FROM media WHERE alt IS NULL OR alt = ''\"),");
+    p("    // Only an unwritten alt (NULL) is missing. An empty one is an image the");
+    p("    // owner marked decorative, which HTML says to skip.");
+    p("    countRows(env, `SELECT COUNT(*) AS n FROM media WHERE ${MEDIA_ALT_MISSING_SQL}`),");
     p("    countRows(");
     p("      env,");
     p("      \"SELECT COUNT(*) AS n FROM pages WHERE status = 'published'\" +");
@@ -330,6 +357,27 @@ export function generateAstroidWorker(config) {
     p("  return summary;");
     p("}");
     p();
+    p("// --- public status ---------------------------------------------------------");
+    p("// What statusRoute answers an outside probe with: 200 when every check");
+    p("// passes, 503 when any fails, throws, or takes over two seconds. Anyone can");
+    p("// make these run, so each is one cheap read, and a burst of probes reuses one");
+    p("// result per isolate for STATUS_REUSE_MS.");
+    p("const STATUS_REUSE_MS = 10_000;");
+    p("const STATUS_CHECKS = {");
+    p("  // D1 answers `SELECT 1`.");
+    p("  d1: d1Check((env: CloudflareEnv) => env.DB),");
+    p("  // The public home page reads real content, not the seed-me fallback the");
+    p("  // page renders when its row is missing (an unseeded or wiped database,");
+    p("  // or a migration that never ran, which throws and fails the check too).");
+    p("  content: async (env: CloudflareEnv) =>");
+    p(`    (await env.DB.prepare("SELECT 1 FROM pages WHERE slug = 'home'").first()) !== null,`);
+    if (config.status?.checks) {
+        p("  // The site's own, from src/status-checks.ts. Spread last, so a site");
+        p("  // check with the same name replaces Astroid's on purpose.");
+        p("  ...statusChecks,");
+    }
+    p("};");
+    p();
     p("/** One COUNT, degrading to 0—a missing table must not abort the scan. */");
     p("async function countRows(env: CloudflareEnv, sql: string): Promise<number> {");
     p("  try {");
@@ -476,7 +524,9 @@ export function generateAstroidWorker(config) {
     p(`    if (controller.cron === ${JSON.stringify(ASTROID_HEALTH_CRON)}) {`);
     p("      // Daily site-health scan. `waitUntil` because the crawl outlives the");
     p("      // handler's return, and a scan that throws must not retry the cron.");
-    p("      ctx.waitUntil(runHealthScan(env).catch(() => {}));");
+    p("      // Reported rather than swallowed: the Health panel keeps showing the");
+    p("      // last good scan, so this log line is the only sign that one failed.");
+    p('      ctx.waitUntil(runHealthScan(env).catch((error) => reportDegraded("health.scan", error)));');
     p("      return;");
     p("    }");
     if (cron) {
@@ -555,6 +605,7 @@ export function generateAstroidMiddleware(config) {
         "// styles + inlined data: brand font are allowed.",
         'import { env } from "cloudflare:workers";',
         'import { createLouiseMiddleware } from "@louise-toolkit/astro";',
+        'import { db, pageRedirects, resolvePageRedirect } from "louise-toolkit/db";',
         // One `astroidjs` import, composed from what this config actually uses—two
         // import statements for the same module is legal and reads as an
         // oversight in a file nobody is supposed to hand-edit.
@@ -612,6 +663,9 @@ export function generateAstroidMiddleware(config) {
         "  // anything the worker's routes didn't answer. A second check behind the",
         "  // worker's gate, and free: the editor is resolved here on every request.",
         "  apiGate: true,",
+        "  // A renamed page's old URL answers a 301 to the new one. It runs only after",
+        "  // the page answered 404, so a page later created on the old path wins.",
+        "  redirectFor: (path) => resolvePageRedirect(db(env.DB), pageRedirects, path),",
         // `extend` runs once and may need to populate BOTH—a tenanted site with a
         // portal resolves a tenant and a customer on the same request.
         ...(portal || tenancy

package/dist/worker/index.d.ts

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

package/dist/worker/index.js

@@ -4,3 +4,4 @@
 // → the Worker entrypoint and Astro middleware a site would otherwise hand-write.
 export * from "./routes.js";
 export * from "./generate.js";
+export * from "./gateway.js";

package/dist/worker/routes.d.ts

@@ -1,5 +1,5 @@
 import type { AstroidConfig } from "../config.js";
-export type AstroidEditorRouteName = "ai" | "health" | "realtime" | "vitals" | "overview" | "seoFix" | "versions" | "search" | "pages" | "save" | "settings" | "media" | "editors" | "form" | "inquiries" | "seed";
+export type AstroidEditorRouteName = "ai" | "health" | "realtime" | "vitals" | "status" | "overview" | "seoFix" | "versions" | "search" | "pages" | "save" | "settings" | "media" | "editors" | "form" | "inquiries" | "seed";
 export interface AstroidEditorRoute {
     /** Stable key for this route. */
     name: AstroidEditorRouteName;

package/dist/worker/routes.js

@@ -82,6 +82,11 @@ export function astroidEditorRoutePlan(config) {
         factory: "vitalsRoute",
         note: "Public CWV ingestion (POST /api/louise/vitals). NOT session-gated—these are anonymous visitor beacons—but same-origin only, and it accepts-and-drops without the dataset binding. Always 204.",
     });
+    routes.push({
+        name: "status",
+        factory: "statusRoute",
+        note: "Public status for an outside probe (GET/HEAD /api/louise/status): 200 when every check passes, 503 when any fails. A publicRoute under ADR 0012, so the gate lets an anonymous probe through, and it answers booleans and ages, never error text. Owns its own path, so it collides with nothing.",
+    });
     routes.push({
         name: "health",
         factory: "healthRoute",
@@ -90,7 +95,7 @@ export function astroidEditorRoutePlan(config) {
     routes.push({
         name: "ai",
         factory: "aiRoute",
-        note: "Editor AI assists—rewrite/expand/shorten a selection, suggest SEO for a page. Owns /api/louise/ai/*, so it collides with nothing. POST-only and editor-gated, since each call spends AI budget.",
+        note: "Editor AI assists—rewrite a selection (tighten, rephrase, simplify, or fix), suggest SEO for a page. Owns /api/louise/ai/*, so it collides with nothing. POST-only and editor-gated, since each call spends AI budget.",
     });
     if (capturesInquiries(config)) {
         routes.push({

package/dist/workflow/advance.js

@@ -10,7 +10,7 @@
 // expected—`UPDATE … SET stage = ? WHERE id = ? AND stage = ?`—and treat "0 rows
 // changed" as the conflict signal rather than checking first and hoping.
 //
-// ORDERING MATTERS, and the reference gets it wrong. ghostfire's floor route
+// ORDERING MATTERS, and the reference gets it wrong. Its floor route
 // inserts the sign-off row and THEN runs the guarded update, so a double submit
 // writes two audit rows even though only one advance lands. Here the guarded
 // update goes first and the audit row is written only if it actually moved the

package/dist/workflow/config.js

@@ -2,7 +2,7 @@
 //
 // `defineWorkflow`—staged, audited pipelines.
 //
-// The shape this generalizes is ghostfire.coffee's production floor, and the
+// The shape this generalizes is a client site's production floor, and the
 // framing correction in #256 is the important part: despite the name "order
 // tracker", it is NOT queue- or Durable-Object-driven. It is a synchronous SSR
 // + D1 state machine—an integer `stage` column advanced by sign-off rows,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astroidjs",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Astroid — an opinionated meta-framework over Louise Toolkit and Astro for building editable, multi-editor sites on Cloudflare Workers.",
   "keywords": [
     "astro",
@@ -64,14 +64,14 @@
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@vitest/coverage-v8": "4.1.11",
     "astro": "^7.2.9",
-    "louise-toolkit": "^0.34.0",
+    "louise-toolkit": "^0.36.0",
     "solid-js": "^1.9.15",
     "typescript": "^6.0.3",
     "vitest": "^4.1.11"
   },
   "peerDependencies": {
     "astro": "^7.0.9",
-    "louise-toolkit": "^0.34.0",
+    "louise-toolkit": "^0.36.0",
     "solid-js": "^1.9.0"
   },
   "peerDependenciesMeta": {

package/src/components/StageBar.astro

@@ -1,7 +1,7 @@
 ---
 // `<StageBar>`—a pipeline's progress as a segmented bar.
 //
-// Generalized from ghostfire's six-stage floor tracker, which hard-coded the
+// Generalized from a client site's six-stage floor tracker, which hard-coded the
 // segment count, the corner radii, the brand hex codes, and a mascot image.
 // Here the stage list drives everything and the colours are theme tokens, so a
 // four-stage onboarding flow and an eight-stage production line both work and

package/src/components/media-meta.ts

@@ -9,7 +9,7 @@
 //
 // So the whole page is resolved in ONE bounded `IN (...)` lookup before anything
 // renders, and the result is threaded down as `mediaMeta`. This is the pattern
-// ghostfire's `Sections.astro` arrived at independently, generalized.
+// a client site's `Sections.astro` arrived at independently, generalized.
 //
 // The collection step is SCHEMA-DRIVEN: it walks the catalog looking for fields
 // of `type: "image"` rather than hardcoding field names. That's what keeps it