@louise-toolkit/astro 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,76 @@
+# @louise-toolkit/astro
+
+**Astro adapter for [Louise Toolkit](https://github.com/bowenlabs/louise-toolkit)** —
+middleware, Actions, content-layer loaders, and the forms schema bridge.
+
+> **Status: pre-1.0, experimental.** The API changes between minor versions —
+> pin an exact version if you depend on it.
+
+## Why this is a separate package
+
+`louise-toolkit` is framework-agnostic, and that claim is enforced rather than
+merely stated: CI fails if the string "astro" appears anywhere in the library's
+source, in code or in prose. Everything that has to import Astro's types lives
+here instead.
+
+So the dependency runs one way — this package depends on `louise-toolkit`, never
+the reverse — and `astro` is an **optional peer**, pulled in only by sites that
+actually import this adapter.
+
+## Install
+
+```sh
+pnpm add @louise-toolkit/astro louise-toolkit astro
+```
+
+Building a whole site rather than wiring one by hand? Use
+[`astroidjs`](https://www.npmjs.com/package/astroidjs), the opinionated preset on
+top of both, or scaffold one with `pnpm create astroid`.
+
+## What it gives you
+
+**Middleware** — one factory that mounts Louise's editor routes, session handling
+and optional rate limiting into an Astro site.
+
+```ts
+// src/middleware.ts
+import { createLouiseMiddleware } from "@louise-toolkit/astro";
+
+export const onRequest = createLouiseMiddleware({/* ... */});
+```
+
+**Actions** — the editor write path as Astro Actions, so a save is a typed call
+rather than a hand-rolled endpoint. `louiseSaveAction`, `louiseSaveDraftAction`
+and `louiseSettingsAction` wrap the same primitives the framework exposes, which
+is why an agent writing over MCP and a human clicking in the editor take the
+identical code path.
+
+**Content-layer loaders** — `louiseLoader` feeds Louise-managed rows into Astro's
+content layer, and `collectionToAstroSchema` derives the Zod schema from the same
+`CollectionConfig` that drives codegen and the editor. One definition, not two
+that drift.
+
+**Catalog loader** — `defineCatalogLoader`, for commerce catalogs.
+
+**Forms bridge** — `formToAstroSchema`, deriving an Astro-shaped schema from a
+Louise `FormConfig`.
+
+## Full exports
+
+| export                                                                | what it is                                    |
+| --------------------------------------------------------------------- | --------------------------------------------- |
+| `createLouiseMiddleware`                                              | mounts editor routes, sessions, rate limiting |
+| `louiseSaveAction` · `louiseSaveDraftAction` · `louiseSettingsAction` | the editor write path as Astro Actions        |
+| `louiseLoader` · `collectionToAstroSchema`                            | content-layer loader and its derived schema   |
+| `defineCatalogLoader`                                                 | commerce catalog loader                       |
+| `formToAstroSchema`                                                   | `FormConfig` → Astro schema                   |
+
+Types ship alongside each: `LouiseMiddlewareConfig`, `LouiseMiddlewareRateLimit`,
+`EditorActionContext`, `EditorActionDeps`, `LouiseSaveActionConfig`,
+`LouiseSaveDraftActionConfig`, `LouiseSettingsActionConfig`, `SaveActionInput`,
+`SaveDraftActionInput`, `ActionErrorCtor`, `LouiseLoaderConfig`, `LouiseRow`,
+`CatalogLoaderConfig`.
+
+## License
+
+MIT © BowenLabs. See [LICENSE](./LICENSE).

package/dist/actions.d.ts

@@ -0,0 +1,133 @@
+import { z } from "astro/zod";
+import { type SaveCollectionConfig } from "louise-toolkit/editor";
+import { type SettingsPatchConfig } from "louise-toolkit/editor";
+import type { EditorRouteEnv } from "louise-toolkit/editor";
+import { type SaveDraftDeps } from "louise-toolkit/editor";
+/** The subset of Astro's `ActionError` codes the editor handlers emit. */
+type ActionErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "INTERNAL_SERVER_ERROR";
+/** The shape of Astro's `ActionError` constructor the handlers depend on —
+ *  injected (see file header) so the toolkit needn't import `astro:actions`. */
+export interface ActionErrorCtor {
+    new (opts: {
+        code: ActionErrorCode;
+        message?: string;
+    }): Error;
+}
+/** The slice of an Astro `ActionAPIContext` the editor handlers read: the
+ *  middleware-resolved `locals.editor`, plus `cookies` for the D1 bookmark. The
+ *  Worker `env` is NOT read off the context — Astro v6+ removed
+ *  `Astro.locals.runtime.env`, so it's supplied by the injected
+ *  {@link EditorActionDeps.getEnv}. A real context (which carries much more)
+ *  structurally satisfies this. */
+export interface EditorActionContext {
+    locals: {
+        editor?: unknown;
+    };
+    /** Astro's `AstroCookies` (structurally). Used to persist the D1 session
+     *  bookmark for read-your-writes on draft resume (#69). Optional so a bare
+     *  test context still satisfies this type. */
+    cookies?: {
+        set(name: string, value: string, options?: Record<string, unknown>): void;
+    };
+}
+/** The dependencies every editor Action shares: the injected `ActionError`, an
+ *  optional reader for the editor session (defaulting to `locals.editor`), and the
+ *  required `getEnv` that hands in the Worker bindings. */
+export interface EditorActionDeps<Env extends EditorRouteEnv = EditorRouteEnv> {
+    /** Astro's `ActionError` class, injected (see file header). */
+    ActionError: ActionErrorCtor;
+    /** Resolve the editor session from the Action context. Default: `locals.editor`
+     *  (set by `createLouiseMiddleware`). A falsy result answers 401. */
+    getEditor?: (ctx: EditorActionContext) => unknown;
+    /**
+     * Resolve the Worker `env` (the D1 binding) for the Action. **Required** — Astro
+     * v6+ removed `Astro.locals.runtime.env`, so there is no context field to default
+     * to; inject the bindings explicitly, typically by closing over the Cloudflare
+     * `env` (the `ctx` argument is available for per-request selection but usually
+     * unused):
+     *
+     * ```ts
+     * import { env } from "cloudflare:workers";
+     * louiseSaveAction({ collections, ActionError, getEnv: () => env });
+     * ```
+     */
+    getEnv: (ctx: EditorActionContext) => Env;
+}
+/** The validated `save` input — the inline field-save body, same keys the raw
+ *  route's `SAVE_BODY` uses. `value` stays `unknown`; its non-empty-string check
+ *  needs the collection config and so lives in `applyFieldSave`. */
+export interface SaveActionInput {
+    collection: string;
+    key: string;
+    field: string;
+    value: unknown;
+}
+export interface LouiseSaveActionConfig<Env extends EditorRouteEnv = EditorRouteEnv> extends EditorActionDeps<Env> {
+    /** Editable collections keyed by the client's `collection` slug — the same
+     *  shape the raw `saveRoute` takes. */
+    collections: Record<string, SaveCollectionConfig>;
+    /** Rich-HTML sanitizer; defaults to louise-toolkit/security's `sanitizeRichHtml`. */
+    sanitize?: (html: string) => string;
+}
+export interface LouiseSettingsActionConfig<Env extends EditorRouteEnv = EditorRouteEnv> extends EditorActionDeps<Env>, SettingsPatchConfig {
+}
+/** The validated `saveDraft` input: which versioned row (`id`) plus the changed
+ *  fields (`data`). The route takes `id` from the URL path + the fields as the
+ *  body; the Action bundles both, since an Action call has no URL. */
+export interface SaveDraftActionInput {
+    id: number;
+    data: Record<string, unknown>;
+}
+export interface LouiseSaveDraftActionConfig<Env extends EditorRouteEnv = EditorRouteEnv> extends EditorActionDeps<Env>, SaveDraftDeps<Env> {
+}
+/**
+ * Build the `{ input, handler }` config for the editor `save` Action (the inline
+ * field-save). The site drops the result into `defineAction` (see file header).
+ * The `input` schema is validated by Astro *before* the handler runs — replacing
+ * the raw route's manual `request.json()` + `standardValidate` — and the handler
+ * shares the raw route's store path via {@link applyFieldSave}, so a field is
+ * validated once and written in exactly one place.
+ */
+export declare function louiseSaveAction<Env extends EditorRouteEnv = EditorRouteEnv>(config: LouiseSaveActionConfig<Env>): {
+    input: z.ZodObject<{
+        collection: z.ZodString;
+        key: z.ZodString;
+        field: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>;
+    handler: (input: SaveActionInput, context: EditorActionContext) => Promise<{
+        ok: true;
+    }>;
+};
+/**
+ * Build the `{ input, handler }` config for the editor `settings` Action (the
+ * structured settings-panel patch). Mirrors {@link louiseSaveAction}: Astro
+ * validates the patch object as `input`, and the handler shares the raw
+ * `settingsRoute` store path via {@link applySettingsPatch} (media-strictness on
+ * image keys, base-vs-`custom` partition, singleton write). Returns the `ignored`
+ * (non-allowlisted) keys so the caller can surface what was dropped.
+ */
+export declare function louiseSettingsAction<Env extends EditorRouteEnv = EditorRouteEnv>(config: LouiseSettingsActionConfig<Env>): {
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    handler: (input: Record<string, unknown>, context: EditorActionContext) => Promise<{
+        ok: true;
+        ignored: string[];
+    }>;
+};
+/**
+ * Build the `{ input, handler }` config for the editor `saveDraft` Action (the
+ * versioned-page draft save). Mirrors {@link louiseSaveAction}, but the input
+ * bundles the row `id` with the changed `data` (an Action call has no URL to carry
+ * the id). The handler shares the raw `versionsRoute` store path via
+ * {@link applySaveDraft} — the concurrent-surface merge base and the #70 KV
+ * write-buffer — and returns that path's JSON body (a created `version`, or
+ * `{ buffered: true }` when a write is coalesced into the buffer).
+ */
+export declare function louiseSaveDraftAction<Env extends EditorRouteEnv = EditorRouteEnv>(config: LouiseSaveDraftActionConfig<Env>): {
+    input: z.ZodObject<{
+        id: z.ZodNumber;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+    handler: (input: SaveDraftActionInput, context: EditorActionContext) => Promise<Record<string, unknown>>;
+};
+export {};

package/dist/actions.js

@@ -0,0 +1,172 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `louise-toolkit/astro` — the editor mutations as Astro Actions (#72): typed,
+// Zod-validated server functions so a site calls `actions.louise.save(...)` /
+// `settings(...)` and gets end-to-end types + automatic input validation, instead
+// of hand-building a `fetch("/api/louise/*")` JSON body and re-parsing it.
+//
+//   // site: src/actions/index.ts
+//   import { defineAction, ActionError } from "astro:actions";
+//   import { env } from "cloudflare:workers";
+//   import { louiseSaveAction, louiseSettingsAction } from "louise-toolkit/astro";
+//
+//   export const server = {
+//     louise: {
+//       save: defineAction(louiseSaveAction({ collections, ActionError, getEnv: () => env })),
+//       settings: defineAction(louiseSettingsAction({ ...settingsConfig, ActionError, getEnv: () => env })),
+//     },
+//   };
+//
+// The Worker `env` (the D1 binding) is injected via `getEnv`, not read off the
+// context: Astro v6+ removed `Astro.locals.runtime.env`, so a site hands in its
+// bindings — typically `() => env` from `cloudflare:workers` — the same way the
+// core primitives take their bindings by injection (the library never reaches for
+// `cloudflare:workers` itself).
+//
+// Why a factory that returns `{ input, handler }` instead of a ready `defineAction`:
+// `defineAction`/`ActionError` live in Astro's VIRTUAL `astro:actions` module,
+// which only resolves inside an Astro app — a library can't import it (this subpath
+// imports only real `astro/*` subpaths, e.g. `astro/zod`). So the adapter ships the
+// ingredients and the SITE assembles `defineAction`, and it takes the `ActionError`
+// class by injection so the handler can still throw framework-correct 400/401/404.
+//
+// CSRF: Astro enforces same-origin on Action POSTs by default, so these port only
+// the AUTH guard (a `locals.editor` check). The store logic itself is shared with
+// the raw routes (`applyFieldSave`, `applySettingsPatch`), so nothing is parsed or
+// written twice.
+import { z } from "astro/zod";
+import { D1_BOOKMARK_COOKIE } from "louise-toolkit/db";
+import { applyFieldSave } from "louise-toolkit/editor";
+import { applySettingsPatch } from "louise-toolkit/editor";
+import { applySaveDraft } from "louise-toolkit/editor";
+import { sanitizeRichHtml } from "louise-toolkit/security";
+/** Map an `apply*` HTTP status onto an Astro `ActionError` code. */
+function statusToCode(status) {
+    if (status === 401)
+        return "UNAUTHORIZED";
+    if (status === 403)
+        return "FORBIDDEN";
+    if (status === 404)
+        return "NOT_FOUND";
+    if (status >= 500)
+        return "INTERNAL_SERVER_ERROR";
+    return "BAD_REQUEST";
+}
+/** Resolve an editor Action's deps, filling the default `locals.editor` reader.
+ *  `getEnv` has no default — Astro v6+ removed `locals.runtime.env`, so a safe one
+ *  can't exist — and a missing one is a wiring error thrown here, at
+ *  action-construction time, rather than a per-request 500 on an `undefined` env. */
+function resolveDeps(deps) {
+    if (typeof deps.getEnv !== "function") {
+        throw new TypeError("louise-toolkit/astro: `getEnv` is required — Astro v6+ removed " +
+            "`Astro.locals.runtime.env`, so inject the Worker env explicitly, " +
+            'e.g. `getEnv: () => env` from "cloudflare:workers".');
+    }
+    return {
+        ActionError: deps.ActionError,
+        getEditor: deps.getEditor ?? ((ctx) => ctx.locals.editor),
+        getEnv: deps.getEnv,
+    };
+}
+/** Require the (middleware-resolved) editor session — a missing one is a 401 —
+ *  and return it. CSRF/same-origin is Astro's default for Action POSTs, so only
+ *  auth is ported. */
+function requireEditor(resolved, ctx) {
+    const editor = resolved.getEditor(ctx);
+    if (!editor) {
+        throw new resolved.ActionError({ code: "UNAUTHORIZED", message: "Editor session required" });
+    }
+    return editor;
+}
+/** Throw the injected `ActionError` for an `apply*` failure — `never`, so a
+ *  `if (!result.ok) throwActionError(...)` narrows the result to its ok branch. */
+function throwActionError(ActionError, status, error) {
+    throw new ActionError({ code: statusToCode(status), message: error });
+}
+/**
+ * Build the `{ input, handler }` config for the editor `save` Action (the inline
+ * field-save). The site drops the result into `defineAction` (see file header).
+ * The `input` schema is validated by Astro *before* the handler runs — replacing
+ * the raw route's manual `request.json()` + `standardValidate` — and the handler
+ * shares the raw route's store path via {@link applyFieldSave}, so a field is
+ * validated once and written in exactly one place.
+ */
+export function louiseSaveAction(config) {
+    const resolved = resolveDeps(config);
+    const sanitize = config.sanitize ?? sanitizeRichHtml;
+    return {
+        input: z.object({
+            collection: z.string(),
+            key: z.string(),
+            field: z.string(),
+            value: z.unknown(),
+        }),
+        handler: async (input, context) => {
+            requireEditor(resolved, context);
+            const result = await applyFieldSave(resolved.getEnv(context), config.collections, sanitize, input);
+            if (!result.ok)
+                throwActionError(resolved.ActionError, result.status, result.error);
+            return { ok: true };
+        },
+    };
+}
+/**
+ * Build the `{ input, handler }` config for the editor `settings` Action (the
+ * structured settings-panel patch). Mirrors {@link louiseSaveAction}: Astro
+ * validates the patch object as `input`, and the handler shares the raw
+ * `settingsRoute` store path via {@link applySettingsPatch} (media-strictness on
+ * image keys, base-vs-`custom` partition, singleton write). Returns the `ignored`
+ * (non-allowlisted) keys so the caller can surface what was dropped.
+ */
+export function louiseSettingsAction(config) {
+    const resolved = resolveDeps(config);
+    return {
+        // A settings patch is an arbitrary object of allowlisted keys; the allowlist
+        // (base columns + `custom` keys) is enforced in `applySettingsPatch`.
+        input: z.record(z.string(), z.unknown()),
+        handler: async (input, context) => {
+            requireEditor(resolved, context);
+            const result = await applySettingsPatch(resolved.getEnv(context), config, input);
+            if (!result.ok)
+                throwActionError(resolved.ActionError, result.status, result.error);
+            return { ok: true, ignored: result.ignored };
+        },
+    };
+}
+/**
+ * Build the `{ input, handler }` config for the editor `saveDraft` Action (the
+ * versioned-page draft save). Mirrors {@link louiseSaveAction}, but the input
+ * bundles the row `id` with the changed `data` (an Action call has no URL to carry
+ * the id). The handler shares the raw `versionsRoute` store path via
+ * {@link applySaveDraft} — the concurrent-surface merge base and the #70 KV
+ * write-buffer — and returns that path's JSON body (a created `version`, or
+ * `{ buffered: true }` when a write is coalesced into the buffer).
+ */
+export function louiseSaveDraftAction(config) {
+    const resolved = resolveDeps(config);
+    return {
+        input: z.object({
+            id: z.number().int(),
+            data: z.record(z.string(), z.unknown()),
+        }),
+        handler: async (input, context) => {
+            const editor = requireEditor(resolved, context);
+            const result = await applySaveDraft(resolved.getEnv(context), config, editor, input.id, input.data);
+            if (!result.ok)
+                throwActionError(resolved.ActionError, result.status, result.error);
+            // Persist the D1 bookmark so this Action's draft is read-your-writes on the
+            // next edit-mode load behind read replication (#69). Mirrors the raw
+            // versionsRoute's Set-Cookie; no-op on a non-replicated D1.
+            if (result.bookmark) {
+                context.cookies?.set(D1_BOOKMARK_COOKIE, result.bookmark, {
+                    path: "/",
+                    httpOnly: true,
+                    sameSite: "lax",
+                    secure: true,
+                    maxAge: 60 * 60 * 8,
+                });
+            }
+            return result.body;
+        },
+    };
+}

package/dist/catalog.d.ts

@@ -0,0 +1,45 @@
+import type { LiveLoader } from "astro/loaders";
+type AnyRecord = Record<string, any>;
+/**
+ * What a site provides to build a catalog live loader. `Data` is the entry shape
+ * (e.g. a display product); `Filter` is the collection query shape.
+ */
+export interface CatalogLoaderConfig<Data extends AnyRecord, Filter extends AnyRecord = Record<string, never>> {
+    /** Loader name (Astro convention: the npm package or a stable id). Also the
+     *  default `cacheHint` tag. */
+    name: string;
+    /**
+     * Load the (cached) catalog for a collection query, already narrowed to what
+     * the query asks for (the site owns its own filtering — category trees, etc.).
+     * `fetchedAt` (epoch ms) becomes the `cacheHint.lastModified` so the hint
+     * reflects the snapshot's age, not the render time.
+     */
+    loadCatalog: (filter: Filter | undefined) => Promise<{
+        items: Data[];
+        fetchedAt?: number | null;
+    }>;
+    /** Resolve a single item by its entry id (slug). `null` → not found (Astro
+     *  raises `LiveEntryNotFoundError`, which the page can turn into a redirect). */
+    loadItem: (id: string) => Promise<Data | null>;
+    /** The entry id (slug) for an item — keys the collection and resolves
+     *  `getLiveEntry("catalog", slug)`. */
+    idOf: (item: Data) => string;
+    /** `cacheHint` tag for tag-based purges. Default: `name`. */
+    tag?: string;
+}
+/**
+ * Build an Astro {@link LiveLoader} for a commerce catalog from a site's cached
+ * reads. Register the result in `src/live.config.ts`:
+ *
+ * ```ts
+ * import { defineLiveCollection } from "astro:content";
+ * import { catalogLoader } from "./loaders/catalog";
+ * export const collections = { catalog: defineLiveCollection({ loader: catalogLoader }) };
+ * ```
+ *
+ * then consume with `getLiveCollection("catalog")` / `getLiveEntry("catalog", slug)`.
+ */
+export declare function defineCatalogLoader<Data extends AnyRecord, Filter extends AnyRecord = Record<string, never>>(config: CatalogLoaderConfig<Data, Filter>): LiveLoader<Data, {
+    id: string;
+}, Filter>;
+export {};

package/dist/catalog.js

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `louise-toolkit/astro` — `defineCatalogLoader`: the shared plumbing for a commerce
+// catalog served as an Astro Live Content Collection. Live collections fetch at
+// request time, so a price/stock edit shows on the next render with no rebuild.
+//
+// Every catalog loader repeats the same boilerplate — map items to keyed entries,
+// stamp a `cacheHint` (a tag for future webhook-driven purges, plus the snapshot
+// age as `lastModified`), and wrap a read failure as a loader error instead of a
+// 500. That lives here ONCE. A site injects only what's domain-specific: how to
+// read its (cached) catalog, how to resolve one item, and each item's slug — so
+// a Fourthwall site and a Square site share one loader definition and only their
+// `lib/<provider>` reads differ.
+//
+// `astro` is an OPTIONAL peer (see the entry note); only the `LiveLoader` *type*
+// is imported, and only by sites that pull in this subpath.
+function toError(error, fallback) {
+    return error instanceof Error ? error : new Error(fallback);
+}
+/**
+ * Build an Astro {@link LiveLoader} for a commerce catalog from a site's cached
+ * reads. Register the result in `src/live.config.ts`:
+ *
+ * ```ts
+ * import { defineLiveCollection } from "astro:content";
+ * import { catalogLoader } from "./loaders/catalog";
+ * export const collections = { catalog: defineLiveCollection({ loader: catalogLoader }) };
+ * ```
+ *
+ * then consume with `getLiveCollection("catalog")` / `getLiveEntry("catalog", slug)`.
+ */
+export function defineCatalogLoader(config) {
+    const tag = config.tag ?? config.name;
+    const cacheHint = (fetchedAt) => ({
+        tags: [tag],
+        ...(fetchedAt ? { lastModified: new Date(fetchedAt) } : {}),
+    });
+    return {
+        name: config.name,
+        async loadCollection({ filter }) {
+            try {
+                const { items, fetchedAt } = await config.loadCatalog(filter);
+                const hint = cacheHint(fetchedAt);
+                return {
+                    entries: items.map((item) => ({ id: config.idOf(item), data: item, cacheHint: hint })),
+                    cacheHint: hint,
+                };
+            }
+            catch (error) {
+                return { error: toError(error, `${config.name} catalog load failed`) };
+            }
+        },
+        async loadEntry({ filter }) {
+            try {
+                const item = await config.loadItem(filter.id);
+                if (!item)
+                    return undefined;
+                return { id: config.idOf(item), data: item, cacheHint: cacheHint(null) };
+            }
+            catch (error) {
+                return { error: toError(error, `${config.name} entry load failed`) };
+            }
+        },
+    };
+}

package/dist/content-loader.d.ts

@@ -0,0 +1,52 @@
+import type { Loader } from "astro/loaders";
+import { z } from "astro/zod";
+import type { CollectionConfig } from "louise-toolkit/content";
+/** A published row as read from D1 — a document in the collection's field shape. */
+export type LouiseRow = Record<string, unknown>;
+/**
+ * Build an Astro (Zod) schema from a collection's `defineCollection` fields.
+ * Unknown/bookkeeping columns (`id`, `status`, timestamps) are dropped — the
+ * schema captures exactly the declared fields, so `getCollection` entry data
+ * matches the editor's model.
+ */
+export declare function collectionToAstroSchema(collection: CollectionConfig): z.ZodType;
+export interface LouiseLoaderConfig {
+    /** The collection definition (from `defineCollection`) — drives the schema. */
+    collection: CollectionConfig;
+    /**
+     * Read the published rows to expose, each a document in the collection's field
+     * shape. The site owns D1 access (the loader runs at build time, off any
+     * binding) — typically the D1 REST API, or a cached snapshot. Only published
+     * rows should be returned; drafts never reach `getCollection`.
+     */
+    read: () => Promise<LouiseRow[]>;
+    /**
+     * The entry id (unique key) for a row. Default: `row.slug ?? row.id`, matching
+     * how Louise pages are addressed.
+     */
+    idOf?: (row: LouiseRow) => string | number;
+    /** Loader name (Astro convention). Default `louise:<slug>`. */
+    name?: string;
+}
+/**
+ * A Content Layer loader over a Louise D1 collection. Register it with Astro's
+ * `defineCollection`:
+ *
+ * ```ts
+ * // src/content.config.ts
+ * import { defineCollection } from "astro:content";
+ * import { louiseLoader } from "louise-toolkit/astro";
+ * import { pagesCollection } from "./pages-collection";
+ * import { readPublishedPages } from "./lib/louise/published-pages";
+ *
+ * export const collections = {
+ *   pages: defineCollection({
+ *     loader: louiseLoader({ collection: pagesCollection, read: readPublishedPages }),
+ *   }),
+ * };
+ * ```
+ *
+ * then read with `getCollection("pages")` / `getEntry("pages", slug)` — typed
+ * from the collection's own fields, no hand-written schema.
+ */
+export declare function louiseLoader(config: LouiseLoaderConfig): Loader;

package/dist/content-loader.js

@@ -0,0 +1,142 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `louise-toolkit/astro` — `louiseLoader`: an Astro Content Layer loader that
+// exposes a Louise D1 collection through the native `getCollection()` /
+// `getEntry()` pipeline, with a Zod schema derived from the collection's own
+// `defineCollection` fields (so entry data is typed the same way the editor
+// models it).
+//
+// Content Layer loaders run at BUILD time (in Node, during `astro build`), where
+// Cloudflare bindings don't exist — so, like `defineCatalogLoader`, the *read*
+// is injected: a site supplies `read()` (typically the D1 REST API at build, or
+// a snapshot) and this owns the rest — schema mapping, store population, content
+// digests for incremental builds, and fail-safe error handling. The result is a
+// build-time snapshot of published content; rebuild on publish (e.g. a webhook)
+// to refresh it. For request-time freshness, read D1 directly in an SSR page (or
+// use the Live-collection `defineCatalogLoader`).
+//
+// `astro` is an OPTIONAL peer (see the entry note): `Loader`/`DataStore` types
+// come from `astro/loaders` and the Zod builder from `astro/zod`, pulled in only
+// by sites that import this subpath.
+import { z } from "astro/zod";
+/**
+ * Map one Louise field to its Zod type. The budget is deliberately permissive on
+ * read: D1 is the source of truth and the values were already validated on write
+ * (the Local API), so this describes shape for `getCollection`'s types rather
+ * than re-litigating validity.
+ */
+function fieldToZod(field) {
+    switch (field.type) {
+        case "text":
+        case "upload":
+            return z.string();
+        case "select":
+            return field.options.length > 0
+                ? z.enum([...field.options])
+                : z.string();
+        case "number":
+        // A `hasMany: false` relationship is a plain integer column (the related
+        // row's id); `hasMany: true` has no column and is dropped in `mapFields`.
+        case "relationship":
+            return z.number();
+        case "checkbox":
+            // D1 stores booleans as 0/1 — accept either and normalize to boolean.
+            return z.union([z.boolean(), z.number().transform((n) => n !== 0)]);
+        case "date":
+            // D1 stores dates as integer epochs; a REST/JSON read may hand back a
+            // number or an ISO string. `coerce` accepts all three.
+            return z.coerce.date();
+        case "group":
+            // A group flattens to real columns in D1, but the Local API re-nests it on
+            // read — so mirror the config's nested object shape.
+            return z.object(mapFields(field.fields));
+        // JSON-backed columns (rich text, builder arrays, freeform json) pass through
+        // untouched — their inner shape is the site's concern, not the loader's.
+        case "richText":
+        case "array":
+        case "json":
+            return z.unknown();
+        default:
+            return z.unknown();
+    }
+}
+/** Build the `{ key: ZodType }` shape for a set of fields, honoring required. */
+function mapFields(fields) {
+    const shape = {};
+    for (const [key, field] of Object.entries(fields)) {
+        // A hasMany relationship lives in a join table — no column on this row.
+        if (field.type === "relationship" && field.hasMany)
+            continue;
+        const base = fieldToZod(field);
+        // Non-required columns are nullable in D1 and may be absent from a row.
+        shape[key] = field.required ? base : base.nullable().optional();
+    }
+    return shape;
+}
+/**
+ * Build an Astro (Zod) schema from a collection's `defineCollection` fields.
+ * Unknown/bookkeeping columns (`id`, `status`, timestamps) are dropped — the
+ * schema captures exactly the declared fields, so `getCollection` entry data
+ * matches the editor's model.
+ */
+export function collectionToAstroSchema(collection) {
+    return z.object(mapFields(collection.fields));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * A Content Layer loader over a Louise D1 collection. Register it with Astro's
+ * `defineCollection`:
+ *
+ * ```ts
+ * // src/content.config.ts
+ * import { defineCollection } from "astro:content";
+ * import { louiseLoader } from "louise-toolkit/astro";
+ * import { pagesCollection } from "./pages-collection";
+ * import { readPublishedPages } from "./lib/louise/published-pages";
+ *
+ * export const collections = {
+ *   pages: defineCollection({
+ *     loader: louiseLoader({ collection: pagesCollection, read: readPublishedPages }),
+ *   }),
+ * };
+ * ```
+ *
+ * then read with `getCollection("pages")` / `getEntry("pages", slug)` — typed
+ * from the collection's own fields, no hand-written schema.
+ */
+export function louiseLoader(config) {
+    const slug = config.collection.slug;
+    const name = config.name ?? `louise:${slug}`;
+    const idOf = config.idOf ?? ((row) => (row.slug ?? row.id));
+    return {
+        name,
+        schema: collectionToAstroSchema(config.collection),
+        async load(context) {
+            // `parseData`/`generateDigest` are called on `context` rather than
+            // destructured: pulling them out unbinds them from the loader context
+            // (`typescript/unbound-method`); Astro binds them, but the bound call keeps
+            // the intent explicit.
+            const { store, logger } = context;
+            let rows;
+            try {
+                rows = await config.read();
+            }
+            catch (error) {
+                // Fail safe: leave the last good store in place rather than wiping the
+                // collection to empty on a transient read failure. `logger` is already
+                // scoped to the loader name by Astro, so don't re-prefix it.
+                logger.error(`read failed, keeping existing entries: ${errorMessage(error)}`);
+                return;
+            }
+            store.clear();
+            for (const row of rows) {
+                const id = String(idOf(row));
+                const data = await context.parseData({ id, data: row });
+                store.set({ id, data, digest: context.generateDigest(data) });
+            }
+            logger.info(`loaded ${rows.length} published ${rows.length === 1 ? "entry" : "entries"}`);
+        },
+    };
+}

package/dist/form-schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "astro/zod";
+import type { FormConfig } from "louise-toolkit/forms";
+/**
+ * Build a Zod schema from a `defineForm` definition's fields — the form is the
+ * single source of truth for its Astro Action `input`, so the handler receives a
+ * typed, validated value and the client infers the same shape. Field-level
+ * `validation`/`schema` extras still run in the shared `validateSubmission` pass;
+ * this describes the field set's structural shape and its built-in type checks.
+ *
+ * Targets JSON actions (an absent optional field is `undefined`), matching how a
+ * typed island calls an action.
+ */
+export declare function formToAstroSchema(form: FormConfig): z.ZodType;

package/dist/form-schema.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `louise-toolkit/astro` — `formToAstroSchema`: the forms counterpart to
+// `collectionToAstroSchema`. It maps a `defineForm` definition to a Zod schema
+// so a form can drop straight into an Astro Action's `input`:
+//
+//   export const server = {
+//     inquiry: defineAction({
+//       input: formToAstroSchema(inquiryForm),
+//       handler: async (input) => { /* input is typed + validated */ },
+//     }),
+//   };
+//
+// This closes the gap where form actions took raw `FormData` + a hand-written
+// interface + manual coercion: the field set is the single source of truth, and
+// the client gets the inferred input type for free.
+//
+// Like the collection bridge, this lives in `louise-toolkit/astro` and pulls the
+// Zod builder from `astro/zod` (an optional peer), so the framework-agnostic
+// core never takes a Zod dependency.
+import { z } from "astro/zod";
+/** Map one form field to its Zod type, including the type's built-in format
+ *  check (email/url) and coercion (number/date/checkbox). */
+function formFieldToZod(field) {
+    const required = field.required ?? false;
+    switch (field.type) {
+        case "email":
+            return required ? z.email() : z.email().optional();
+        case "url":
+            return required ? z.url() : z.url().optional();
+        case "number":
+            // Form values arrive as strings; `coerce` turns "5" into 5.
+            return required ? z.coerce.number() : z.coerce.number().optional();
+        case "date":
+            // Accepts an ISO string, an epoch number, or a Date.
+            return required ? z.coerce.date() : z.coerce.date().optional();
+        case "checkbox": {
+            // A checkbox may arrive as a real boolean (JSON action), or "on"/"true"/
+            // "1"/1 (form-encoded) — normalize any of them to a boolean.
+            const bool = z
+                .union([z.boolean(), z.number(), z.string()])
+                .transform((v) => v === true || v === 1 || v === "1" || v === "true" || v === "on");
+            return required ? bool : bool.optional();
+        }
+        case "select": {
+            // Options double as the allowlist — a value outside them is rejected.
+            const select = field.options && field.options.length > 0
+                ? z.enum([...field.options])
+                : z.string();
+            return required ? select : select.optional();
+        }
+        default: {
+            // text / textarea / tel / file → a plain string (file holds the uploaded
+            // asset URL). Required string-likes must be non-empty.
+            return required ? z.string().min(1, `${field.label} is required`) : z.string().optional();
+        }
+    }
+}
+/**
+ * Build a Zod schema from a `defineForm` definition's fields — the form is the
+ * single source of truth for its Astro Action `input`, so the handler receives a
+ * typed, validated value and the client infers the same shape. Field-level
+ * `validation`/`schema` extras still run in the shared `validateSubmission` pass;
+ * this describes the field set's structural shape and its built-in type checks.
+ *
+ * Targets JSON actions (an absent optional field is `undefined`), matching how a
+ * typed island calls an action.
+ */
+export function formToAstroSchema(form) {
+    const shape = {};
+    for (const [key, field] of Object.entries(form.fields)) {
+        shape[key] = formFieldToZod(field);
+    }
+    return z.object(shape);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type ActionErrorCtor, type EditorActionContext, type EditorActionDeps, type LouiseSaveActionConfig, type LouiseSaveDraftActionConfig, type LouiseSettingsActionConfig, louiseSaveAction, louiseSaveDraftAction, louiseSettingsAction, type SaveActionInput, type SaveDraftActionInput, } from "./actions.js";
+export { type CatalogLoaderConfig, defineCatalogLoader } from "./catalog.js";
+export { collectionToAstroSchema, louiseLoader, type LouiseLoaderConfig, type LouiseRow, } from "./content-loader.js";
+export { formToAstroSchema } from "./form-schema.js";
+export { createLouiseMiddleware, type LouiseMiddlewareConfig, type LouiseMiddlewareRateLimit, } from "./middleware.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `@louise-toolkit/astro` — optional Astro glue for Louise sites. Framework-specific
+// helpers that import Astro's types live here (never in the framework-agnostic
+// core), so `astro` is an OPTIONAL peer, pulled in only by sites that import
+// this subpath. First inhabitant: the shared middleware factory.
+export { louiseSaveAction, louiseSaveDraftAction, louiseSettingsAction, } from "./actions.js";
+export { defineCatalogLoader } from "./catalog.js";
+export { collectionToAstroSchema, louiseLoader, } from "./content-loader.js";
+export { formToAstroSchema } from "./form-schema.js";
+export { createLouiseMiddleware, } from "./middleware.js";

package/dist/middleware.d.ts

@@ -0,0 +1,95 @@
+import type { APIContext, MiddlewareHandler } from "astro";
+import { type RateLimitBackend, type RateRule } from "louise-toolkit/security";
+export interface LouiseMiddlewareRateLimit {
+    /** The site's rate-limit rules — the public POST surfaces worth protecting. */
+    rules: RateRule[];
+    /**
+     * Rate-limit backend — a KV counter or Cloudflare's native Rate Limiting
+     * binding, or a getter that yields one. A getter is resolved per request, so a
+     * `cloudflare:workers` `env` binding is read in request scope rather than at
+     * module-eval — the same reason editor Actions take `getEnv: () => env`. A
+     * getter that yields a falsy backend (e.g. the KV namespace isn't provisioned
+     * yet) simply skips rate-limiting — fail open, consistent with {@link rateLimit}.
+     */
+    kv: RateLimitBackend | (() => RateLimitBackend | undefined);
+}
+export interface LouiseMiddlewareConfig<TEditor = unknown> {
+    /**
+     * Resolve the editor session for a request — the site wraps its own auth,
+     * e.g. `resolveEditorSession(await getLouiseAuth(env, origin), request)`. A
+     * truthy result is written to `locals.editor` and unlocks edit mode; `null`
+     * renders the public page. A thrown error (e.g. missing bindings under plain
+     * `astro preview`) degrades to public rendering.
+     */
+    resolveEditor: (request: Request) => TEditor | null | Promise<TEditor | null>;
+    /** Rate-limit the public POST surfaces before any other work. Omit to skip. */
+    rateLimit?: LouiseMiddlewareRateLimit;
+    /**
+     * `style-src` replacement for the response CSP header — the site's allow-list.
+     * Astro's `security.csp` hashes inline island styles, which voids the
+     * `'unsafe-inline'` the data-driven `style=""` carriers need; this rewrites
+     * ONLY `style-src` (script hashes stay verbatim). No-op without a CSP header
+     * (astro dev). Omit to skip.
+     */
+    cspStyleSrc?: string;
+    /** Apply {@link louiseSecurityHeaders} (HSTS, nosniff, referrer, …) to the
+     *  response. Default `true`. */
+    securityHeaders?: boolean;
+    /**
+     * Extra per-request work after editor resolution, before `next()` — e.g.
+     * resolve a second session (a shop customer) onto `locals`. Runs inside the
+     * same try/catch, so a throw degrades to public rendering.
+     */
+    extend?: (context: APIContext) => void | Promise<void>;
+    /**
+     * Authorize the request after {@link extend} has populated `locals`, and
+     * before the page runs. Return a `Response` to short-circuit (a redirect, a
+     * 401/403), or `undefined` to continue.
+     *
+     * Deliberately separate from `extend`: sessions must be resolved before
+     * anything can be authorized against them, and collapsing the two would make
+     * that ordering a convention rather than a guarantee. It runs OUTSIDE the
+     * `extend` try/catch, because a guard that throws must fail closed — a
+     * swallowed error there would serve the protected page.
+     */
+    guard?: (context: APIContext) => Response | undefined | Promise<Response | undefined>;
+    /**
+     * Rewrite the request internally before the page runs — return the path to
+     * render, or `undefined` to render the requested one. Runs **after**
+     * {@link guard}, so policy is still expressed against the URL the visitor
+     * actually asked for rather than an internal one.
+     *
+     * This exists because neither existing hook can rewrite: `extend` returns
+     * `void` and `guard` returns only a `Response`. Astro permits exactly one
+     * middleware file, and in a generated one there is nowhere else to put it.
+     *
+     * The motivating case is host dispatch — serving `*.example.com` from one
+     * Worker by mapping a subdomain onto an internal path prefix. The middleware
+     * stays policy-free: what a host means, and whether an unknown one is a 404,
+     * belong to the site.
+     *
+     * ```ts
+     * rewrite: (context) => {
+     *   const tenant = context.locals.tenant;
+     *   return tenant ? `/t/${tenant.slug}${context.url.pathname}` : undefined;
+     * },
+     * ```
+     *
+     * The visitor's URL is unchanged — this is an internal rewrite, not a
+     * redirect, so `context.url` still reads as the public address and links
+     * rendered from it stay correct.
+     */
+    rewrite?: (context: APIContext) => string | undefined | Promise<string | undefined>;
+    /** Edit-mode cookie name. Default {@link LOUISE_EDIT_COOKIE} (`"louise_edit"`).
+     *  Change it and the `withEdgeCache` bypass predicate must be told too, or an
+     *  editor gets served the cached public page. */
+    editCookie?: string;
+}
+/**
+ * Build the shared Louise Astro middleware: rate-limit → resolve the editor
+ * session + sticky `?louise` edit mode → `next()` → content-freshness cache headers
+ * + CSP `style-src` rewrite + transport security headers. Sites supply the bits
+ * that vary via {@link LouiseMiddlewareConfig} and export the result as
+ * `onRequest`.
+ */
+export declare function createLouiseMiddleware<TEditor = unknown>(config: LouiseMiddlewareConfig<TEditor>): MiddlewareHandler;

package/dist/middleware.js

@@ -0,0 +1,139 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// louise-toolkit/astro — the shared Louise Astro middleware, as a factory. Every
+// Louise site's `middleware.ts` runs the same flow; only the auth wiring, rate
+// rules, and CSP allow-list vary. `createLouiseMiddleware` owns the flow and
+// takes those as config, so a site's middleware collapses to:
+//
+//   export const onRequest = createLouiseMiddleware({
+//     resolveEditor: (req) =>
+//       resolveEditorSession(getLouiseAuth(env, new URL(req.url).origin), req),
+//     rateLimit: { rules: RATE_RULES, kv: () => env.RL },
+//     cspStyleSrc: "'self' 'unsafe-inline'",
+//   });
+//
+// (The brand font is bundled + base64-inlined — no Google Fonts host to allow.
+// The middleware auto-allows `data:` fonts in the response CSP, so a strict
+// `font-src` needs no manual change for the inlined @font-face.)
+//
+// This subpath is the ONE place Louise touches Astro's types — `astro` is an
+// optional peer, pulled in only by sites that import `louise-toolkit/astro`.
+import { allowCspDataFonts, louiseSecurityHeaders, matchRateRule, rateLimit, rewriteCspStyleSrc, } from "louise-toolkit/security";
+import { LOUISE_EDIT_COOKIE } from "louise-toolkit/worker";
+/**
+ * Build the shared Louise Astro middleware: rate-limit → resolve the editor
+ * session + sticky `?louise` edit mode → `next()` → content-freshness cache headers
+ * + CSP `style-src` rewrite + transport security headers. Sites supply the bits
+ * that vary via {@link LouiseMiddlewareConfig} and export the result as
+ * `onRequest`.
+ */
+export function createLouiseMiddleware(config) {
+    // The default comes from the same constant `isEditRequest` reads, so the
+    // cookie this sets and the predicate that looks for it cannot drift apart.
+    const editCookie = config.editCookie ?? LOUISE_EDIT_COOKIE;
+    return async (context, next) => {
+        // Rate-limit the public, unauthenticated POST surfaces before any other
+        // work. Keyed by client IP via a KV counter; `rateLimit` fails open on a KV
+        // error so a limiter outage never takes down sign-in or the contact form.
+        if (config.rateLimit) {
+            const rule = matchRateRule(config.rateLimit.rules, context.request.method, context.url.pathname);
+            if (rule) {
+                // Resolve the backend only for a matched surface, and per request: a
+                // getter defers the `env` binding read to request scope (never
+                // module-eval). A falsy backend (binding not yet provisioned) skips
+                // limiting — fail open, like `rateLimit` itself.
+                const backend = typeof config.rateLimit.kv === "function" ? config.rateLimit.kv() : config.rateLimit.kv;
+                if (backend) {
+                    const ip = context.request.headers.get("cf-connecting-ip") ?? "unknown";
+                    const { ok, retryAfter } = await rateLimit(backend, `${rule.name}:${ip}`, rule.limit, rule.windowSec);
+                    if (!ok) {
+                        return new Response(JSON.stringify({ error: "Too many requests. Please try again shortly." }), {
+                            status: 429,
+                            headers: { "content-type": "application/json", "retry-after": String(retryAfter) },
+                        });
+                    }
+                }
+            }
+        }
+        const locals = context.locals;
+        locals.editor = null;
+        locals.editMode = false;
+        try {
+            const editor = await config.resolveEditor(context.request);
+            if (editor) {
+                locals.editor = editor;
+                // Edit mode is sticky: ?louise enters (sets a cookie), ?louise=off
+                // exits. The cookie alone never grants anything — the session above is
+                // always re-checked, so a stale cookie without a session renders public.
+                const param = context.url.searchParams.get("louise");
+                if (context.url.searchParams.has("louise") && param !== "off") {
+                    // `secure` only over https, so plain-http localhost dev still round-trips
+                    // the toggle. The cookie grants nothing on its own — the session above is
+                    // re-verified every request — so this is hygiene, not a control.
+                    context.cookies.set(editCookie, "1", {
+                        path: "/",
+                        sameSite: "lax",
+                        secure: context.url.protocol === "https:",
+                    });
+                    locals.editMode = true;
+                }
+                else if (param === "off") {
+                    context.cookies.delete(editCookie, { path: "/" });
+                }
+                else {
+                    locals.editMode = context.cookies.get(editCookie)?.value === "1";
+                }
+            }
+        }
+        catch {
+            // Missing bindings (e.g. plain `astro preview`, an unprovisioned
+            // SESSION_SECRET) → public rendering. Auth degrading is fine; what it
+            // must NOT do is cancel anything else.
+        }
+        // extend gets its OWN catch, deliberately separate from auth's. When these
+        // shared one, `resolveEditor` throwing (a sentinel SESSION_SECRET — the
+        // dormant-until-provisioned state every module is supposed to survive)
+        // silently skipped extend too, and everything extend feeds died with it:
+        // `locals.tenant` never set, so host dispatch quietly served the ordinary
+        // site on every tenant subdomain. An unprovisioned editor secret must
+        // degrade to "signed out", never to "storefronts don't resolve".
+        try {
+            await config.extend?.(context);
+        }
+        catch {
+            // extend's own failure still degrades to public rendering.
+        }
+        // Outside the catch above, on purpose: a guard exists to REFUSE, so an
+        // error inside it must not be swallowed into "carry on and render the
+        // protected page". Locals are already populated by `extend` at this point.
+        const denied = await config.guard?.(context);
+        if (denied)
+            return denied;
+        // After the guard, deliberately: a rewrite changes which page renders, not
+        // who may see it, so authorizing against the rewritten path would mean
+        // policy written in internal URLs the site never publishes.
+        //
+        // Outside the try/catch too, for the same reason the guard is: a rewrite
+        // that throws must not degrade into rendering the UNREWRITTEN path, which
+        // for host dispatch is another tenant's page.
+        const rewrite = await config.rewrite?.(context);
+        const response = rewrite === undefined ? await next() : await next(rewrite);
+        // content freshness: cached HTML would hide editor edits. Edit-mode pages are
+        // per-editor and must be live (`no-store`); public HTML `no-cache` so edits
+        // appear without a manual purge. Only HTML — hashed `/_astro/*` assets keep
+        // their immutable caching (set via `_headers`).
+        if ((response.headers.get("content-type") ?? "").includes("text/html")) {
+            response.headers.set("Cache-Control", locals.editMode ? "no-store" : "no-cache");
+        }
+        if (config.cspStyleSrc)
+            rewriteCspStyleSrc(response, config.cspStyleSrc);
+        // Louise's bundled brand font is an inlined `data:` @font-face (loaded on
+        // every edit surface), so guarantee the CSP permits data: fonts — no-op
+        // without a CSP header or when already allowed. Saves consumers a font-src edit.
+        allowCspDataFonts(response);
+        if (config.securityHeaders !== false) {
+            louiseSecurityHeaders(response, { hostname: context.url.hostname });
+        }
+        return response;
+    };
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@louise-toolkit/astro",
+  "version": "0.1.0",
+  "description": "Astro adapter for louise-toolkit: middleware, Actions, content-layer loaders, and the forms schema bridge.",
+  "keywords": [
+    "astro",
+    "cloudflare",
+    "cms",
+    "louise",
+    "louise-toolkit"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bowenlabs/louise-toolkit.git",
+    "directory": "packages/louise-astro"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "louise-toolkit": "0.27.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20260829.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "astro": "^7.2.9",
+    "drizzle-orm": "^0.45.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11"
+  },
+  "peerDependencies": {
+    "astro": "^7.0.6"
+  },
+  "peerDependenciesMeta": {
+    "astro": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "check": "vp check",
+    "test": "vp test",
+    "typecheck": "tsgo --noEmit"
+  }
+}