@louise-toolkit/astro 0.2.7 → 0.4.0

package/README.md

@@ -44,8 +44,8 @@ Pass `apiGate: true` to deny the editor API by default: every request under
 writes and WebSocket upgrades origin-checked. This is the same gate as
 `composeWorker({ gate })` (ADR 0012), for routes mounted as Astro API routes.
 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.
+is declared by path: the toolkit's form, vitals, and status 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`,

package/dist/actions.d.ts

@@ -2,7 +2,7 @@ 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";
+import { type DraftSoftLocks, 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
@@ -77,8 +77,13 @@ export interface LouiseSettingsActionConfig<Env extends EditorRouteEnv = EditorR
 export interface SaveDraftActionInput {
     id: number;
     data: Record<string, unknown>;
+    /** The field revisions the save started from (`SaveDraftOptions.base`). */
+    base?: Record<string, string>;
 }
 export interface LouiseSaveDraftActionConfig<Env extends EditorRouteEnv = EditorRouteEnv> extends EditorActionDeps<Env>, SaveDraftDeps<Env> {
+    /** The soft-locks a save respects (#572): `realtimeSoftLocks` from
+     *  `louise-toolkit/realtime`, as `versionsRoute` takes it. */
+    softLocks?: DraftSoftLocks<Env>;
 }
 /**
  * Build the `{ input, handler }` config for the editor `save` Action (the inline
@@ -121,12 +126,20 @@ export declare function louiseSettingsAction<Env extends EditorRouteEnv = Editor
  * 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).
+ * `{ buffered: true }` when a write is coalesced into the buffer), with the
+ * saved fields' `revs`.
+ *
+ * A save whose `base` is stale for a field someone else changed returns
+ * `{ conflicts }` rather than throwing (#572). An Action's rejection reaches the
+ * client only as an error, which can't carry the current values the owner
+ * needs to choose between, so the conflict comes back as data. A save that
+ * changes a field another editor holds returns `{ locked }` the same way.
  */
 export declare function louiseSaveDraftAction<Env extends EditorRouteEnv = EditorRouteEnv>(config: LouiseSaveDraftActionConfig<Env>): {
     input: z.ZodObject<{
         id: z.ZodNumber;
         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        base: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>;
     handler: (input: SaveDraftActionInput, context: EditorActionContext) => Promise<Record<string, unknown>>;
 };

package/dist/actions.js

@@ -35,6 +35,7 @@
 // the raw routes (`applyFieldSave`, `applySettingsPatch`), so nothing is parsed or
 // written twice.
 import { z } from "astro/zod";
+import { toPageId } from "louise-toolkit/content";
 import { D1_BOOKMARK_COOKIE } from "louise-toolkit/db";
 import { applyFieldSave } from "louise-toolkit/editor";
 import { applySettingsPatch } from "louise-toolkit/editor";
@@ -140,18 +141,32 @@ export function louiseSettingsAction(config) {
  * 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).
+ * `{ buffered: true }` when a write is coalesced into the buffer), with the
+ * saved fields' `revs`.
+ *
+ * A save whose `base` is stale for a field someone else changed returns
+ * `{ conflicts }` rather than throwing (#572). An Action's rejection reaches the
+ * client only as an error, which can't carry the current values the owner
+ * needs to choose between, so the conflict comes back as data. A save that
+ * changes a field another editor holds returns `{ locked }` the same way.
  */
 export function louiseSaveDraftAction(config) {
     const resolved = resolveDeps(config);
     return {
         input: z.object({
-            id: z.number().int(),
+            // Positive, like every row ID, so `toPageId` below can't throw on input
+            // this schema accepted.
+            id: z.number().int().positive(),
             data: z.record(z.string(), z.unknown()),
+            base: z.record(z.string(), z.string()).optional(),
         }),
         handler: async (input, context) => {
             const editor = requireEditor(resolved, context);
-            const result = await applySaveDraft(resolved.getEnv(context), config, editor, input.id, input.data);
+            const result = await applySaveDraft(resolved.getEnv(context), config, editor, toPageId(input.id), input.data, { base: input.base, softLocks: config.softLocks });
+            if (!result.ok && result.conflicts)
+                return { conflicts: result.conflicts };
+            if (!result.ok && result.locked)
+                return { locked: result.locked };
             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

package/dist/index.d.ts

@@ -3,4 +3,5 @@ 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 { type ResumeReadSession, resumeReadSession } from "./resume.js";
+export { type SeoHeadContext, type SeoHeadInput, seoHead } from "./seo.js";
 export { createLouiseMiddleware, type LouiseMiddlewareConfig, type LouiseMiddlewareRateLimit, } from "./middleware.js";

package/dist/index.js

@@ -9,4 +9,5 @@ export { defineCatalogLoader } from "./catalog.js";
 export { collectionToAstroSchema, louiseLoader, } from "./content-loader.js";
 export { formToAstroSchema } from "./form-schema.js";
 export { resumeReadSession } from "./resume.js";
+export { seoHead } from "./seo.js";
 export { createLouiseMiddleware, } from "./middleware.js";

package/dist/middleware.d.ts

@@ -18,8 +18,8 @@ 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
-     * `isLouisePublicPath`).
+     * toolkit's own public routes at their default mounts (forms, vitals, and
+     * status—see `isLouisePublicPath`).
      *
      * A path, not a mark on the route, because middleware runs before it knows
      * which route file will answer: a route can't declare itself public here the
@@ -113,6 +113,25 @@ export interface LouiseMiddlewareConfig<TEditor = unknown> {
      * resolved on every request regardless.
      */
     apiGate?: boolean | LouiseMiddlewareApiGate;
+    /**
+     * Where a path moved, for a GET or HEAD that would otherwise answer 404
+     * (#574). Return `{ location, status }` to redirect, or `null` to keep the 404.
+     * It runs only after the page answered 404, so a live page always wins. The
+     * visitor's query string carries over.
+     *
+     * ```ts
+     * redirectFor: (path) => resolvePageRedirect(db(env.DB), pageRedirects, path),
+     * ```
+     *
+     * A lookup that throws keeps the 404.
+     */
+    redirectFor?: (pathname: string, context: APIContext) => {
+        location: string;
+        status: number;
+    } | null | Promise<{
+        location: string;
+        status: number;
+    } | null>;
     /** 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. */

package/dist/middleware.js

@@ -137,6 +137,21 @@ export function createLouiseMiddleware(config) {
         // for host dispatch is another tenant's page.
         const rewrite = await config.rewrite?.(context);
         const response = rewrite === undefined ? await next() : await next(rewrite);
+        // A page that moved: answer its old URL with a redirect instead of the 404.
+        if (config.redirectFor &&
+            response.status === 404 &&
+            (context.request.method === "GET" || context.request.method === "HEAD")) {
+            // An async wrapper, so a lookup that throws before returning a promise
+            // keeps the 404 too.
+            const lookup = config.redirectFor;
+            const moved = await (async () => lookup(context.url.pathname, context))().catch(() => null);
+            if (moved) {
+                return finish(context, new Response(null, {
+                    status: moved.status,
+                    headers: { location: `${moved.location}${context.url.search}` },
+                }));
+            }
+        }
         // An editor's JSON must not land in a shared cache. A route that chose its
         // own policy keeps it.
         if (gatedApi && !response.headers.has("cache-control")) {

package/dist/seo.d.ts

@@ -0,0 +1,16 @@
+import { type PageHeadInput } from "louise-toolkit/seo";
+/** The part of `Astro` (or an `APIContext`) that `seoHead` reads. */
+export interface SeoHeadContext {
+    /** The configured `site`, the canonical origin. */
+    site?: URL | undefined;
+    url: URL;
+}
+/** Everything `pageHead` takes except what the request supplies. */
+export type SeoHeadInput = Omit<PageHeadInput, "origin" | "path"> & Partial<Pick<PageHeadInput, "origin">>;
+/**
+ * The page's head tags as HTML, from `pageHead` and `renderHeadTags`. The
+ * origin is `input.origin`, then Astro's configured `site`, then the request's
+ * own origin; set `site` in `astro.config` so a preview host or a proxy can't
+ * leak into the canonical URL. The path is the request's.
+ */
+export declare function seoHead(context: SeoHeadContext, input: SeoHeadInput): string;

package/dist/seo.js

@@ -0,0 +1,16 @@
+// Copyright (c) 2026 BowenLabs. Louise Toolkit is MIT licensed.
+//
+// `pageHead` from louise-toolkit/seo, with the origin and path filled in from
+// Astro's request context. The adapter ships no `.astro` components, so a page
+// prints the result itself: `<Fragment set:html={seoHead(Astro, { … })} />`.
+import { pageHead, renderHeadTags } from "louise-toolkit/seo";
+/**
+ * The page's head tags as HTML, from `pageHead` and `renderHeadTags`. The
+ * origin is `input.origin`, then Astro's configured `site`, then the request's
+ * own origin; set `site` in `astro.config` so a preview host or a proxy can't
+ * leak into the canonical URL. The path is the request's.
+ */
+export function seoHead(context, input) {
+    const origin = input.origin ?? context.site?.origin ?? context.url.origin;
+    return renderHeadTags(pageHead({ ...input, origin, path: `${context.url.pathname}${context.url.search}` }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@louise-toolkit/astro",
-  "version": "0.2.7",
+  "version": "0.4.0",
   "description": "Astro adapter for louise-toolkit: middleware, Actions, content-layer loaders, and the forms schema bridge.",
   "keywords": [
     "astro",
@@ -9,7 +9,7 @@
     "louise",
     "louise-toolkit"
   ],
-  "homepage": "https://louisetoolkit.com",
+  "homepage": "https://docs.louisetoolkit.org",
   "bugs": "https://github.com/bowenlabs/louise-toolkit/issues",
   "license": "MIT",
   "author": "BowenLabs",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "louise-toolkit": "0.33.0"
+    "louise-toolkit": "0.35.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^5.20260829.1",