@louise-toolkit/astro 0.2.1 → 0.2.2

package/README.md

@@ -1,21 +1,21 @@
 # @louise-toolkit/astro
 
-**Astro adapter for [Louise Toolkit](https://github.com/bowenlabs/louise-toolkit)** —
+**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 —
+> **Status: pre-1.0, experimental.** The API changes between minor versions, so
 > 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
+source, whether that's code or 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.
+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
+import this adapter.
 
 ## Install
 
@@ -29,7 +29,7 @@ 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
+**Middleware**: one factory that mounts Louise's editor routes, session handling,
 and optional rate limiting into an Astro site.
 
 ```ts
@@ -47,20 +47,20 @@ Middleware runs before Astro knows which route file answers, so a public route
 is declared by path: the toolkit's form and vitals routes are exempt at their
 default paths, and `apiGate: { isPublic: (path) => … }` adds your own.
 
-**Actions** — the editor write path as Astro Actions, so a save is a typed call
-rather than a hand-rolled endpoint. `louiseSaveAction`, `louiseSaveDraftAction`
+**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 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.
+**Catalog loader**: `defineCatalogLoader`, for commerce catalogs.
 
-**Forms bridge** — `formToAstroSchema`, deriving an Astro-shaped schema from a
+**Forms bridge**: `formToAstroSchema`, which derives an Astro-shaped schema from a
 Louise `FormConfig`.
 
 ## Full exports

package/dist/actions.d.ts

@@ -5,8 +5,8 @@ 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`. */
+/** 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;
@@ -15,7 +15,7 @@ export interface ActionErrorCtor {
 }
 /** 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
+ *  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. */
@@ -40,7 +40,7 @@ export interface EditorActionDeps<Env extends EditorRouteEnv = EditorRouteEnv> {
      *  (set by `createLouiseMiddleware`). A falsy result answers 401. */
     getEditor?: (ctx: EditorActionContext) => unknown;
     /**
-     * Resolve the Worker `env` (the D1 binding) for the Action. **Required** — Astro
+     * 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
@@ -53,7 +53,7 @@ export interface EditorActionDeps<Env extends EditorRouteEnv = EditorRouteEnv> {
      */
     getEnv: (ctx: EditorActionContext) => Env;
 }
-/** The validated `save` input — the inline field-save body, same keys the raw
+/** 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 {
@@ -63,7 +63,7 @@ export interface SaveActionInput {
     value: unknown;
 }
 export interface LouiseSaveActionConfig<Env extends EditorRouteEnv = EditorRouteEnv> extends EditorActionDeps<Env> {
-    /** Editable collections keyed by the client's `collection` slug — the same
+    /** 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`. */
@@ -83,8 +83,8 @@ export interface LouiseSaveDraftActionConfig<Env extends EditorRouteEnv = Editor
 /**
  * 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
+ * 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.
  */
@@ -119,8 +119,8 @@ export declare function louiseSettingsAction<Env extends EditorRouteEnv = Editor
  * 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
+ * {@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>): {

package/dist/actions.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// `louise-toolkit/astro` — the editor mutations as Astro Actions (#72): typed,
+// `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.
@@ -19,14 +19,14 @@
 //
 // 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
+// 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
+// which only resolves inside an Astro app—a library can't import it (this subpath
+// imports only real `astro/*` subpaths, for example `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.
 //
@@ -53,8 +53,8 @@ function statusToCode(status) {
     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
+ *  `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") {
@@ -68,8 +68,8 @@ function resolveDeps(deps) {
         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
+/** 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);
@@ -78,7 +78,7 @@ function requireEditor(resolved, ctx) {
     }
     return editor;
 }
-/** Throw the injected `ActionError` for an `apply*` failure — `never`, so a
+/** 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 });
@@ -86,8 +86,8 @@ function throwActionError(ActionError, status, 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
+ * 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.
  */
@@ -138,8 +138,8 @@ export function louiseSettingsAction(config) {
  * 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
+ * {@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) {

package/dist/catalog.d.ts

@@ -2,7 +2,7 @@ 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.
+ * (for example, 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
@@ -10,7 +10,7 @@ export interface CatalogLoaderConfig<Data extends AnyRecord, Filter extends AnyR
     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.).
+     * 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.
      */
@@ -21,7 +21,7 @@ export interface CatalogLoaderConfig<Data extends AnyRecord, Filter extends AnyR
     /** 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
+    /** 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`. */

package/dist/catalog.js

@@ -1,14 +1,14 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// `louise-toolkit/astro` — `defineCatalogLoader`: the shared plumbing for a commerce
+// `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,
+// 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
+// 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.
 //

package/dist/content-loader.d.ts

@@ -1,22 +1,22 @@
 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. */
+/** 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
+ * 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. */
+    /** 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
+     * binding)—typically the D1 REST API, or a cached snapshot. Only published
      * rows should be returned; drafts never reach `getCollection`.
      */
     read: () => Promise<LouiseRow[]>;
@@ -46,7 +46,7 @@ export interface LouiseLoaderConfig {
  * };
  * ```
  *
- * then read with `getCollection("pages")` / `getEntry("pages", slug)` — typed
+ * 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

@@ -1,17 +1,17 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// `louise-toolkit/astro` — `louiseLoader`: an Astro Content Layer loader that
+// `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*
+// 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
+// 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)
+// build-time snapshot of published content; rebuild on publish (for example, a webhook)
 // to refresh it. For request-time freshness, read D1 directly in an SSR page (or
 // use the Live-collection `defineCatalogLoader`).
 //
@@ -40,7 +40,7 @@ function fieldToZod(field) {
         case "relationship":
             return z.number();
         case "checkbox":
-            // D1 stores booleans as 0/1 — accept either and normalize to boolean.
+            // 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
@@ -48,10 +48,10 @@ function fieldToZod(field) {
             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.
+            // 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.
+        // untouched—their inner shape is the site's concern, not the loader's.
         case "richText":
         case "array":
         case "json":
@@ -64,7 +64,7 @@ function fieldToZod(field) {
 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.
+        // A hasMany relationship lives in a join table—no column on this row.
         if (field.type === "relationship" && field.hasMany)
             continue;
         const base = fieldToZod(field);
@@ -75,7 +75,7 @@ function mapFields(fields) {
 }
 /**
  * Build an Astro (Zod) schema from a collection's `defineCollection` fields.
- * Unknown/bookkeeping columns (`id`, `status`, timestamps) are dropped — the
+ * Unknown/bookkeeping columns (`id`, `status`, timestamps) are dropped—the
  * schema captures exactly the declared fields, so `getCollection` entry data
  * matches the editor's model.
  */
@@ -103,7 +103,7 @@ function errorMessage(error) {
  * };
  * ```
  *
- * then read with `getCollection("pages")` / `getEntry("pages", slug)` — typed
+ * then read with `getCollection("pages")` / `getEntry("pages", slug)`—typed
  * from the collection's own fields, no hand-written schema.
  */
 export function louiseLoader(config) {

package/dist/form-schema.d.ts

@@ -1,7 +1,7 @@
 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
+ * 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;

package/dist/form-schema.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// `louise-toolkit/astro` — `formToAstroSchema`: the forms counterpart to
+// `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`:
 //
@@ -36,14 +36,14 @@ function formFieldToZod(field) {
             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.
+            // "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.
+            // 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();
@@ -57,7 +57,7 @@ function formFieldToZod(field) {
     }
 }
 /**
- * Build a Zod schema from a `defineForm` definition's fields — the form is the
+ * 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;

package/dist/index.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// `@louise-toolkit/astro` — optional Astro glue for Louise sites. Framework-specific
+// `@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.

package/dist/middleware.d.ts

@@ -1,15 +1,15 @@
 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. */
+    /** 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
+     * 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}.
+     * module-eval—the same reason editor Actions take `getEnv: () => env`. A
+     * getter that yields a falsy backend (for example, the KV namespace isn't provisioned
+     * yet) simply skips rate-limiting—fail open, consistent with {@link rateLimit}.
      */
     kv: RateLimitBackend | (() => RateLimitBackend | undefined);
 }
@@ -18,7 +18,7 @@ export interface LouiseMiddlewareApiGate {
     prefix?: string;
     /**
      * Paths under the prefix an anonymous request may still reach, on top of the
-     * toolkit's own public routes at their default mounts (forms and vitals — see
+     * toolkit's own public routes at their default mounts (forms and vitals—see
      * `isLouisePublicPath`).
      *
      * A path, not a mark on the route, because middleware runs before it knows
@@ -29,17 +29,17 @@ export interface LouiseMiddlewareApiGate {
 }
 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
+     * Resolve the editor session for a request—the site wraps its own auth,
+     * for example, `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
+     * renders the public page. A thrown error (for example, 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.
+     * `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
@@ -50,13 +50,13 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
      *  response. Default `true`. */
     securityHeaders?: boolean;
     /**
-     * Hosts to keep out of search indexes — sent as `X-Robots-Tag: noindex`.
-     * E.g. `(host) => isNoindexHost(host, { prefixes: ["preview."] })`. Set here
+     * Hosts to keep out of search indexes—sent as `X-Robots-Tag: noindex`.
+     * For example, `(host) => isNoindexHost(host, { prefixes: ["preview."] })`. Set here
      * rather than in a page, because a streamed page's headers are already gone.
      */
     noindex?: (hostname: string) => boolean;
     /**
-     * Extra per-request work after editor resolution, before `next()` — e.g.
+     * Extra per-request work after editor resolution, before `next()`—for example,
      * resolve a second session (a shop customer) onto `locals`. Runs inside the
      * same try/catch, so a throw degrades to public rendering.
      */
@@ -69,12 +69,12 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
      * 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
+     * `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
+     * 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.
@@ -83,7 +83,7 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
      * `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
+     * 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.
@@ -95,7 +95,7 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
      * },
      * ```
      *
-     * The visitor's URL is unchanged — this is an internal rewrite, not a
+     * 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.
      */
@@ -103,7 +103,7 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
     /**
      * Deny-by-default gate for the editor API (ADR 0012), for routes mounted as
      * framework API routes (`runEditorRoute`) rather than `composeWorker` routes.
-     * `true` — or an object to change the prefix or add public paths — and every
+     * `true`—or an object to change the prefix or add public paths—and every
      * request under `/api/louise` must resolve to an editor, with writes and
      * WebSocket upgrades origin-checked, before any route runs. Gated responses
      * get `Cache-Control: no-store` unless the route set its own. Omit to skip.

package/dist/middleware.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
 //
-// louise-toolkit/astro — the shared Louise Astro middleware, as a factory. Every
+// 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:
@@ -12,11 +12,11 @@
 //     cspStyleSrc: "'self' 'unsafe-inline'",
 //   });
 //
-// (The brand font is bundled + base64-inlined — no Google Fonts host to allow.
+// (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
+// 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 { isLouisePublicPath, LOUISE_API_PREFIX, LOUISE_EDIT_COOKIE, louiseApiGate, underPrefix, } from "louise-toolkit/worker";
@@ -43,7 +43,7 @@ export function createLouiseMiddleware(config) {
                 // 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.
+                // 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";
@@ -65,13 +65,13 @@ export function createLouiseMiddleware(config) {
             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
+                // 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.
+                    // 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",
@@ -88,14 +88,14 @@ export function createLouiseMiddleware(config) {
             }
         }
         catch {
-            // Missing bindings (e.g. plain `astro preview`, an unprovisioned
+            // Missing bindings (for example, plain `astro preview`, an unprovisioned
             // SESSION_SECRET) → public rendering. Auth degrading is fine; what it
             // must NOT do is cancel anything else.
         }
         // The API gate, before extend: it needs only the editor, and a refused
         // request shouldn't pay for the site's extra work. A `resolveEditor` that
         // threw left `locals.editor` null above, so where pages degrade to public
-        // the API fails closed — refused, not served anonymously.
+        // the API fails closed—refused, not served anonymously.
         const pathname = context.url.pathname;
         const gatedApi = apiGate !== undefined &&
             underPrefix(pathname, apiPrefix) &&
@@ -110,7 +110,7 @@ export function createLouiseMiddleware(config) {
                 return finish(context, denied);
         }
         // extend gets its OWN catch, deliberately separate from auth's. When these
-        // shared one, `resolveEditor` throwing (a sentinel SESSION_SECRET — the
+        // 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
@@ -149,7 +149,7 @@ export function createLouiseMiddleware(config) {
         const locals = context.locals;
         // 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
+        // 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");
@@ -157,7 +157,7 @@ export function createLouiseMiddleware(config) {
         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
+        // 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);
         const noindex = config.noindex?.(context.url.hostname) ?? false;

package/dist/resume.d.ts

@@ -8,8 +8,8 @@ export interface ResumeReadSession {
 }
 /**
  * Open a D1 session anchored at the editor's persisted bookmark, for the
- * edit-mode resume read. On a database without read replication — or a
- * runtime without the Sessions API — `client` is the raw binding and nothing
+ * edit-mode resume read. On a database without read replication—or a
+ * runtime without the Sessions API—`client` is the raw binding and nothing
  * changes, so this is safe to wire before replication is on.
  *
  * Edit mode only: a view-mode render should stay session-free and cookie-free,

package/dist/resume.js

@@ -7,8 +7,8 @@
 import { D1_BOOKMARK_COOKIE, D1_BOOKMARK_MAX_AGE, d1Bookmark, openD1Session, } from "louise-toolkit/db";
 /**
  * Open a D1 session anchored at the editor's persisted bookmark, for the
- * edit-mode resume read. On a database without read replication — or a
- * runtime without the Sessions API — `client` is the raw binding and nothing
+ * edit-mode resume read. On a database without read replication—or a
+ * runtime without the Sessions API—`client` is the raw binding and nothing
  * changes, so this is safe to wire before replication is on.
  *
  * Edit mode only: a view-mode render should stay session-free and cookie-free,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@louise-toolkit/astro",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Astro adapter for louise-toolkit: middleware, Actions, content-layer loaders, and the forms schema bridge.",
   "keywords": [
     "astro",
@@ -35,11 +35,12 @@
     "access": "public"
   },
   "dependencies": {
-    "louise-toolkit": "0.30.1"
+    "louise-toolkit": "0.31.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^5.20260829.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "@vitest/coverage-v8": "4.1.11",
     "astro": "^7.2.9",
     "drizzle-orm": "^0.45.2",
     "typescript": "^5.9.3",
@@ -59,7 +60,7 @@
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "check": "vp check",
-    "test": "vp test",
+    "test": "vp test --coverage",
     "typecheck": "tsgo --noEmit"
   }
 }