astroidjs 0.15.0 → 0.17.0

package/dist/schema/collections.js

@@ -21,6 +21,7 @@
 // `louise-toolkit/src/...`—that resolves only because the workspace aliases the
 // package to its source, and would break the moment astroid consumes a published
 // tarball (#327).
+import { astroidMediaBase } from "./media-base.js";
 import { defineCollection, } from "louise-toolkit/content/define";
 import { assertValidSections, sanitizeSectionsRichText } from "louise-toolkit/content/sections";
 import { sanitizeRichHtml } from "louise-toolkit/security";
@@ -39,10 +40,9 @@ import { astroidSectionCatalog } from "../components/sections.js";
  * Validated by `defineCollection` at build time, so a malformed field shape throws
  * here rather than at codegen.
  */
-/** The media base a `pages` write sanitizes rich content against (config, `/media` default). */
-function pageMediaBase(config) {
-    return config.deploy?.mediaBase ?? "/media";
-}
+/** The media base a `pages` write sanitizes rich content against, read when the
+ *  write runs so a Preview checks against its own base (see media-base.ts). */
+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
@@ -113,12 +113,11 @@ export const ASTROID_RESERVED_SLUGS = [
     "sitemap.xml",
 ];
 export function astroidPagesWriteHooks(config, site = {}) {
-    const mediaBase = pageMediaBase(config);
     return {
         // `body` is a richField, so it goes through pagesRoute's own sanitize seam—with
         // the project media base, matching the hook rather than the toolkit
         // default sanitizer that knows no media base.
-        sanitize: (html) => sanitizeRichHtml(html, { mediaBase }),
+        sanitize: (html) => sanitizeRichHtml(html, { mediaBase: pageMediaBase(config) }),
         // `sections` is not a richField, so it's sanitized here in the transform,
         // which pagesRoute runs BEFORE validate—the hook's sanitize-then-validate
         // order. The site's own transform runs first, so Astroid's sanitize sees
@@ -136,7 +135,6 @@ export function astroidPagesCollection(config) {
     // 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 = pageMediaBase(config);
     const fields = {};
     fields.slug = { type: "text", required: true };
     fields.title = { type: "text", required: true };
@@ -158,7 +156,10 @@ export function astroidPagesCollection(config) {
                 async ({ data }) => {
                     let next = data;
                     if (typeof next.body === "string") {
-                        next = { ...next, body: sanitizeRichHtml(next.body, { mediaBase }) };
+                        next = {
+                            ...next,
+                            body: sanitizeRichHtml(next.body, { mediaBase: pageMediaBase(config) }),
+                        };
                     }
                     // Sanitize BEFORE validating: a richText field stores HTML, and
                     // validating the raw value would pass content the sanitizer is about

package/dist/schema/index.d.ts

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

package/dist/schema/index.js

@@ -4,3 +4,4 @@
 export * from "./collections.js";
 export * from "./framework.js";
 export * from "./generate.js";
+export * from "./media-base.js";

package/dist/schema/media-base.d.ts

@@ -0,0 +1,13 @@
+import type { AstroidConfig } from "../config.js";
+/**
+ * Record the running deployment's media base, `vars.MEDIA_URL`. The generated
+ * worker calls this at startup; an empty or absent value leaves the config's
+ * base in effect.
+ */
+export declare function setAstroidMediaBase(base: string | undefined): void;
+/**
+ * The media base a write is checked against: the running deployment's when the
+ * worker recorded one, else `deploy.mediaBase`, else `/media`. Call it when the
+ * check runs, not when it's built.
+ */
+export declare function astroidMediaBase(config: AstroidConfig): string;

package/dist/schema/media-base.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// The media base the running Worker serves from, for the checks that can't read
+// a request's `env`.
+//
+// The page sanitizers and the settings action are built once, from the config,
+// and drizzle-kit loads the schema that builds them outside a Worker. So they
+// can't take `env.MEDIA_URL` the way the generated routes do. Left on the fixed
+// `deploy.mediaBase`, a staging Preview, which serves media from its own
+// `/media`, drops every image uploaded on it as a hotlink.
+//
+// So the generated worker records `MEDIA_URL` once, at startup, and these checks
+// read it when they run. That's safe as module state because a Worker isolate
+// runs one deployment, and `MEDIA_URL` is fixed per deployment: production's
+// isolates hold production's base, and a Preview's hold the Preview's.
+let runtimeMediaBase;
+/**
+ * Record the running deployment's media base, `vars.MEDIA_URL`. The generated
+ * worker calls this at startup; an empty or absent value leaves the config's
+ * base in effect.
+ */
+export function setAstroidMediaBase(base) {
+    const trimmed = base?.replace(/\/+$/, "");
+    runtimeMediaBase = trimmed ? trimmed : undefined;
+}
+/**
+ * The media base a write is checked against: the running deployment's when the
+ * worker recorded one, else `deploy.mediaBase`, else `/media`. Call it when the
+ * check runs, not when it's built.
+ */
+export function astroidMediaBase(config) {
+    return runtimeMediaBase ?? (config.deploy?.mediaBase ?? "/media").replace(/\/+$/, "");
+}

package/dist/worker/generate.js

@@ -68,6 +68,7 @@ export function generateAstroidWorker(config) {
     const AI_ROUTES = new Set(["ai", "seoFix", "media"]);
     const editorImports = [
         "DEFAULT_PAGE_FIELDS",
+        "type PagesWrite",
         ...new Set(plan.map((route) => route.factory).filter((f) => !realtimeRouteFactories.has(f))),
     ].sort();
     const tables = [
@@ -104,8 +105,8 @@ export function generateAstroidWorker(config) {
                 //
                 // `versionsTable` makes a DELETE remove the page's version snapshots,
                 // which have no foreign key to the page and would otherwise orphan.
-                // `afterWrite` rebuilds the search index, which plain CRUD writes leave
-                // stale.
+                // `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 })';
             case "save":
                 // No `bufferKv` here, deliberately: `saveRoute` has no such option. It
@@ -122,7 +123,9 @@ export function generateAstroidWorker(config) {
                 // The site's sanitize + read hooks (config.settings.hooks), spread last
                 // so they add to the call rather than replace any part of it.
                 const hooksArg = config.settings?.hooks ? ", ...settingsHooks" : "";
-                return `settingsRoute({ table: siteSettings, resolveEditor, columns: SETTINGS_COLUMNS, imageKeys: SETTINGS_IMAGE_KEYS, mediaBase: MEDIA_BASE${customArg}${hooksArg} })`;
+                // Built per request, because the media base is per environment: a
+                // Preview's `MEDIA_URL` differs from production's (see `mediaBaseOf`).
+                return `(request, env, ctx) => settingsRoute({ table: siteSettings, resolveEditor, columns: SETTINGS_COLUMNS, imageKeys: SETTINGS_IMAGE_KEYS, mediaBase: mediaBaseOf(env)${customArg}${hooksArg} })(request, env, ctx)`;
             }
             // `aiRunner` rather than `(env) => env.AI`: it reads the binding AND the
             // LOUISE_AI kill switch, so all three assists share one definition of
@@ -173,7 +176,7 @@ export function generateAstroidWorker(config) {
     p('import { env } from "cloudflare:workers";');
     p('import { handle } from "@astrojs/cloudflare/handler";');
     p('import type { EditorSession } from "louise-toolkit/auth";');
-    p('import { createLocalApi } from "louise-toolkit/content";');
+    p('import { reindexDoc } from "louise-toolkit/content";');
     p(inquiries
         ? 'import { db, inquiriesForm } from "louise-toolkit/db";'
         : 'import { db } from "louise-toolkit/db";');
@@ -201,6 +204,7 @@ export function generateAstroidWorker(config) {
         "astroidPagesCollection",
         "astroidPagesWriteHooks",
         "readModuleSecret",
+        "setAstroidMediaBase",
         ...(inquiries ? ["sendInquiryMail"] : []),
         ...(queues ? ["type AstroidQueueMessage"] : []),
     ].sort();
@@ -228,7 +232,18 @@ export function generateAstroidWorker(config) {
         p('import { handleQueueMessage } from "./queue.js";');
     }
     p();
-    p(`const MEDIA_BASE = ${JSON.stringify(mediaBase)};`);
+    p(`const DEFAULT_MEDIA_BASE = ${JSON.stringify(mediaBase)};`);
+    p("// The public media base for this request's environment. `vars.MEDIA_URL`");
+    p('// wins, so a Preview sets its own (a path such as "/media", served from the');
+    p("// Preview's own host, since a Preview can't know its hostname in advance).");
+    p("// Read per request, not baked in: one build serves production and every");
+    p("// Preview, so nothing that differs between them can be a constant.");
+    p("const mediaBaseOf = (env: CloudflareEnv): string =>");
+    p('  (env.MEDIA_URL || DEFAULT_MEDIA_BASE).replace(/\\/+$/, "");');
+    p("// The checks built once from the config (the page sanitizers, the settings");
+    p("// action) read the base when they run. Recorded at startup, since an isolate");
+    p("// runs one deployment and `MEDIA_URL` is fixed per deployment.");
+    p("setAstroidMediaBase(env.MEDIA_URL);");
     p("const pagesCollection = astroidPagesCollection(astroidConfig);");
     p("// Sanitize + section-catalog validation for the raw pagesRoute, which runs");
     p("// no collection hook—the same contract versionsRoute gets from the config.");
@@ -237,10 +252,12 @@ export function generateAstroidWorker(config) {
         : "const pagesWriteHooks = astroidPagesWriteHooks(astroidConfig);");
     p();
     p("// pagesRoute writes with plain Drizzle, so the full-text index doesn't see a");
-    p("// title or slug change until something rebuilds it. Best-effort: pagesRoute");
-    p("// swallows a throw here, so a stale index never fails the write itself.");
-    p("async function reindexPagesSearch(editor: EditorSession): Promise<void> {");
-    p("  await createLocalApi(db(env.DB), pages, pagesCollection).reindexSearch({ session: editor });");
+    p("// title or slug change until something syncs it. This syncs only the page the");
+    p("// write touched, rather than rebuilding the whole index on every save. After a");
+    p("// delete the row is gone, and reindexDoc removes its entry. Best-effort:");
+    p("// pagesRoute swallows a throw here, so a stale index never fails the write.");
+    p("async function reindexPagesSearch(_editor: EditorSession, { id }: PagesWrite): Promise<void> {");
+    p("  await reindexDoc(db(env.DB), pages, pagesCollection, id);");
     p("}");
     p();
     p("// Editable site_settings columns the Settings panel may write, and which of");
@@ -294,7 +311,7 @@ export function generateAstroidWorker(config) {
     p("// failed crawl or a failed COUNT yields zero rather than aborting the scan,");
     p("// because a partial health report is worth strictly more than none.");
     p("async function runHealthScan(env: CloudflareEnv) {");
-    p("  const origin = env.SITE_URL ?? MEDIA_BASE;");
+    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 = ''\"),");
@@ -376,17 +393,26 @@ export function generateAstroidWorker(config) {
     }
     p("];");
     p();
-    p("// Stream uploaded media back from R2 at MEDIA_BASE (self-hosted, no public bucket).");
+    p("// Stream uploaded media back from R2 at the media base (self-hosted, no public");
+    p("// bucket). The base takes two shapes, and each is matched its own way:");
     p("//");
-    p("// Scoped by ORIGIN, not by path prefix: MEDIA_BASE is an origin, and a");
-    p('// `url.pathname` ("/web/foo.jpg") can never start with one. Comparing the two');
-    p("// against each other made the guard permanently false, so the route never ran");
-    p("// and every uploaded asset fell through to the site's 404 page. On the media");
-    p("// host the whole pathname is the R2 key.");
+    p('// - An ORIGIN ("https://media.example.com") is a media host, where the whole');
+    p("//   pathname is the R2 key. Compared by origin, never by path prefix: a");
+    p('//   `url.pathname` ("/web/foo.jpg") can never start with an origin, and a guard');
+    p("//   that compared the two once never ran, so every upload 404'd.");
+    p('// - A PATH ("/media") is a prefix on the site\'s own host, which is how a');
+    p("//   Preview serves media, since it can't know its hostname in advance.");
     p("const mediaAssetRoute: WorkerRoute<CloudflareEnv> = async (request, env) => {");
     p("  const url = new URL(request.url);");
-    p("  if (url.origin !== MEDIA_BASE) return undefined;");
-    p("  const key = decodeURIComponent(url.pathname.slice(1));");
+    p("  const base = mediaBaseOf(env);");
+    p('  const path = base.startsWith("/")');
+    p("    ? url.pathname.startsWith(`${base}/`)");
+    p("      ? url.pathname.slice(base.length + 1)");
+    p('      : ""');
+    p("    : url.origin === base");
+    p("      ? url.pathname.slice(1)");
+    p('      : "";');
+    p("  const key = decodeURIComponent(path);");
     p("  if (!key) return undefined;");
     p("  const obj = await env.MEDIA.get(key);");
     p('  if (!obj) return new Response("Not found", { status: 404 });');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astroidjs",
-  "version": "0.15.0",
+  "version": "0.17.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.33.0",
+    "louise-toolkit": "^0.34.0",
     "solid-js": "^1.9.15",
     "typescript": "^6.0.3",
     "vitest": "^4.1.11"
   },
   "peerDependencies": {
     "astro": "^7.0.9",
-    "louise-toolkit": "^0.33.0",
+    "louise-toolkit": "^0.34.0",
     "solid-js": "^1.9.0"
   },
   "peerDependenciesMeta": {