@louise-toolkit/astro 0.3.0 → 0.5.0

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

@@ -141,7 +141,14 @@ 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);
@@ -151,10 +158,15 @@ export function louiseSaveDraftAction(config) {
             // 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, toPageId(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/form-schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "astro/zod";
-import type { FormConfig } from "louise-toolkit/forms";
+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

package/dist/form-schema.js

@@ -19,18 +19,30 @@
 // Zod builder from `astro/zod` (an optional peer), so the framework-agnostic
 // core never takes a Zod dependency.
 import { z } from "astro/zod";
+import { coerceFormValue } from "louise-toolkit/forms";
+/** Coerce the way `formRoute` does, first, so an Action accepts what the route
+ *  accepts: a URL without a scheme, a number with the locale's separators. A
+ *  blank value becomes `undefined`, which an optional field allows. */
+function forgiving(field, locale, schema) {
+    return z.preprocess((raw) => coerceFormValue(field, raw, { locale }) ?? undefined, schema);
+}
 /** 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) {
+function formFieldToZod(field, locale) {
     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 "url": {
+            const url = z.url({ error: "Enter a web address, like example.com." });
+            return forgiving(field, locale, required ? url : url.optional());
+        }
+        case "number": {
+            // Form values arrive as strings; the shared coercion turns "1,200" into
+            // 1200 under the form's locale, and leaves anything else a string.
+            const number = z.number({ error: "Enter a number, like 1200." });
+            return forgiving(field, locale, required ? number : number.optional());
+        }
         case "date":
             // Accepts an ISO string, an epoch number, or a Date.
             return required ? z.coerce.date() : z.coerce.date().optional();
@@ -69,7 +81,7 @@ function formFieldToZod(field) {
 export function formToAstroSchema(form) {
     const shape = {};
     for (const [key, field] of Object.entries(form.fields)) {
-        shape[key] = formFieldToZod(field);
+        shape[key] = formFieldToZod(field, form.locale);
     }
     return z.object(shape);
 }

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

@@ -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.3.0",
+  "version": "0.5.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.34.0"
+    "louise-toolkit": "0.36.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^5.20260829.1",