smoodly 0.0.44 → 0.0.46

package/dist/astro/middleware.js

@@ -0,0 +1,83 @@
+// The one middleware the integration adds (spec 2026-10-02 astro cloud fit §7): it decides once whether a
+// request is a verified preview, opens the request scope every read reports its tags to (scope.ts), and
+// when the body is whole — every component has rendered, so every read has been heard — tells Astro's
+// response cache (cache.ts). Astro reads a response's tags the moment the response exists, so waiting
+// for the body is what makes a late read count. A preview response gains the draft marker and, in the
+// canvas, the bridge, when the shell rendered it; a live page gains nothing. Nothing under the preview
+// address is ever stored, and neither is a render a publish overtook or one a read failed in.
+import { defineMiddleware } from "astro:middleware";
+import { loadAdminFiles } from "../admin/files.js";
+import { ADMIN_INTERNAL } from "../admin/page-data.js";
+import { settle } from "./cache.js";
+import { previewDocument } from "./preview-document.js";
+import { DRAFT_COOKIE, isDraftCookie, previewPath } from "./preview.js";
+import { inRequestScope, readsHeader, timingHeader } from "./scope.js";
+import { config, secret } from "./server.js";
+export const onRequest = defineMiddleware(async (context, next) => {
+    const { pathname, searchParams } = context.url;
+    const admin = config.admin.path;
+    if (pathname === admin || pathname.startsWith(`${admin}/`))
+        return next();
+    const locals = context.locals;
+    // The preview route rewrites to the page's own address, which runs the middleware again: the first pass decided.
+    if (locals.smoodly)
+        return next();
+    const preview = previewPath(pathname) !== null;
+    const draft = preview && (await isDraftCookie(context.cookies.get(DRAFT_COOKIE)?.value, secret()));
+    const state = {
+        draft,
+        editor: draft && searchParams.get("smoodly-editor") === "1",
+        version: (draft && searchParams.get("smoodly-version")) || undefined,
+        cacheable: false,
+        shell: false,
+    };
+    locals.smoodly = state;
+    const scope = { tags: new Set(), draft, failed: false, reads: 0, ...(process.env.SMOODLY_DEBUG_READS === "1" ? { marks: [] } : {}) };
+    const started = Date.now();
+    const origin = performance.now();
+    let last = origin;
+    const stage = (name) => { const now = performance.now(); scope.marks?.push({ name, start: last, end: now }); last = now; };
+    // Absent when Astro renders an error page.
+    const cache = context.cache;
+    const closed = (headers) => {
+        headers.set("cache-control", "no-store");
+        headers.set("x-robots-tag", "noindex");
+        return headers;
+    };
+    return inRequestScope(scope, async () => {
+        const response = await next();
+        stage("render");
+        // A response that takes no body (a developer's 204 or 304): nothing to read, nothing to cache. Under the
+        // preview address it still carries the closed headers.
+        if (response.status === 204 || response.status === 304 || response.body === null) {
+            if (!preview)
+                return response;
+            settle(cache, response, { ...state, preview, started, failed: scope.failed }, scope.tags);
+            return new Response(null, { status: response.status, statusText: response.statusText, headers: closed(new Headers(response.headers)) });
+        }
+        if (!response.headers.get("content-type")?.includes("text/html")) {
+            if (!preview)
+                return response;
+            // Whatever a preview address answers, a file or the closed 404, no cache may keep it.
+            settle(cache, response, { ...state, preview, started, failed: scope.failed }, scope.tags);
+            return new Response(response.body, { status: response.status, statusText: response.statusText, headers: closed(new Headers(response.headers)) });
+        }
+        const body = await response.text();
+        stage("body");
+        settle(cache, response, { ...state, preview, started, failed: scope.failed }, scope.tags);
+        stage("settle");
+        const headers = new Headers(response.headers);
+        headers.delete("content-length");
+        readsHeader(headers, scope);
+        timingHeader(headers, scope, origin);
+        if (!preview)
+            return new Response(body, { status: response.status, headers });
+        closed(headers);
+        // Only a page the shell rendered is a canvas. A page file of the project's own over the same address
+        // gets no marker and no bridge, so the editor's diagnosis names it as shadowed (canvas-diagnosis.ts).
+        if (!draft || !state.shell)
+            return new Response(body, { status: response.status, headers });
+        const files = await loadAdminFiles();
+        return new Response(previewDocument(body, state.editor, `${admin}/${ADMIN_INTERNAL}/${files.hash}/bridge.js`), { status: response.status, headers });
+    });
+});

package/dist/astro/preview-document.d.ts

@@ -0,0 +1 @@
+export declare function previewDocument(html: string, editor: boolean, bridgeSrc: string): string;

package/dist/astro/preview-document.js

@@ -0,0 +1,18 @@
+// What a preview response gains (spec 2026-10-02 astro cloud fit §5; DESIGN.md §2, live pages run no
+// Smoodly code): the draft marker the editor's canvas diagnosis looks for, and in the canvas the bridge's
+// one stylesheet rule and its script. Added by the middleware to preview responses only, so the
+// developer's layout holds no Smoodly tag and a live page carries nothing.
+import { BRIDGE_ATTR, DRAFT_META_NAME } from "../admin/editor/canvas-diagnosis.js";
+import { BRIDGE_CSS } from "../marks.js";
+export function previewDocument(html, editor, bridgeSrc) {
+    const head = `<meta name="${DRAFT_META_NAME}">${editor ? `<style ${BRIDGE_ATTR}="">${BRIDGE_CSS}</style>` : ""}`;
+    // A module script runs after the document is parsed: the bridge needs the body.
+    const tail = editor ? `<script type="module" src="${bridgeSrc}"></script>` : "";
+    const doctype = /^\s*<!doctype[^>]*>/i.exec(html)?.[0] ?? "";
+    const withHead = html.includes("</head>")
+        ? html.replace("</head>", () => `${head}</head>`)
+        : doctype + head + html.slice(doctype.length);
+    if (!tail)
+        return withHead;
+    return withHead.includes("</body>") ? withHead.replace("</body>", () => `${tail}</body>`) : withHead + tail;
+}

package/dist/astro/preview.d.ts

@@ -0,0 +1,10 @@
+export declare const DRAFT_COOKIE = "smoodly-draft";
+export declare const PREVIEW_BASE = "/_smoodly/preview";
+export declare function draftCookieValue(secret: string): Promise<string>;
+/** `verify` compares in constant time. */
+export declare function isDraftCookie(value: string | undefined, secret: string): Promise<boolean>;
+/** The page path a preview address names ("/" for the base itself), or null when `pathname` is not one. */
+export declare function previewPath(pathname: string): string | null;
+/** The page path a preview address may rewrite to: never the admin, never a preview address again (a
+ *  rewrite into either would serve the admin as a canvas, or loop until Astro answers 508). */
+export declare function previewTarget(pathname: string, adminPath: string): string | null;

package/dist/astro/preview.js

@@ -0,0 +1,72 @@
+// The preview address and its key (DESIGN.md Vision, preview per framework; spec 2026-10-02 astro cloud
+// fit §7): Astro serves every draft under PREVIEW_BASE, to a browser that holds the draft cookie. The
+// cookie's value is an HMAC of a fixed message under the site's secret key: the draft operation, which
+// only a signed-in editor can call, is the only thing that can make one. Web Crypto only, so the code
+// runs on any host.
+export const DRAFT_COOKIE = "smoodly-draft";
+export const PREVIEW_BASE = "/_smoodly/preview";
+const encoder = new TextEncoder();
+const MESSAGE = encoder.encode("smoodly-draft:v1");
+const keyOf = (secret) => crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+export async function draftCookieValue(secret) {
+    if (!secret)
+        throw new Error("smoodly: the draft cookie needs SMOODLY_SECRET_KEY.");
+    const signature = await crypto.subtle.sign("HMAC", await keyOf(secret), MESSAGE);
+    return [...new Uint8Array(signature)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** `verify` compares in constant time. */
+export async function isDraftCookie(value, secret) {
+    if (!secret || !value || !/^[0-9a-f]{64}$/.test(value))
+        return false;
+    const signature = Uint8Array.from(value.match(/../g), (pair) => parseInt(pair, 16));
+    return crypto.subtle.verify("HMAC", await keyOf(secret), signature, MESSAGE);
+}
+/** The page path a preview address names ("/" for the base itself), or null when `pathname` is not one. */
+export function previewPath(pathname) {
+    if (pathname !== PREVIEW_BASE && !pathname.startsWith(`${PREVIEW_BASE}/`))
+        return null;
+    const rest = pathname.slice(PREVIEW_BASE.length).replace(/\/+$/, "");
+    return rest === "" ? "/" : rest;
+}
+/** astro/dist/core/util/pathname.js validateAndDecodePathname, with its refusals as null. */
+function decodeLikeAstro(pathname) {
+    let decoded;
+    try {
+        decoded = decodeURI(pathname);
+    }
+    catch {
+        return null;
+    }
+    let iterations = 0;
+    while (decoded !== pathname) {
+        if (iterations >= 10)
+            return null;
+        pathname = decoded;
+        try {
+            decoded = decodeURI(pathname);
+        }
+        catch {
+            break;
+        }
+        iterations++;
+    }
+    return decoded;
+}
+/** The page path a preview address may rewrite to: never the admin, never a preview address again (a
+ *  rewrite into either would serve the admin as a canvas, or loop until Astro answers 508). */
+export function previewTarget(pathname, adminPath) {
+    const encoded = previewPath(pathname);
+    if (encoded === null)
+        return null;
+    // Astro's rewrite decodes the address repeatedly (decodeURI until it stops changing, ten times at most)
+    // before it matches a route, so the check reads that fully decoded path; an address Astro would refuse
+    // (a first decode error, or more than ten levels) is refused. The shell hands in `Astro.url.pathname`,
+    // which Astro has already decoded once and collapsed (`//` to `/`), so the repeated decode here is
+    // defence in depth. Handed a raw path it would not be enough: a `//admin` target passes the check and
+    // the rewrite collapses it to `/admin`.
+    const path = decodeLikeAstro(encoded);
+    if (path === null)
+        return null;
+    const under = (base) => path === base || path.startsWith(`${base}/`);
+    return under(adminPath) || under(PREVIEW_BASE) ? null : encoded;
+}

package/dist/astro/richtext.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedImage } from "../media.ts";
+export type RichTextChunk = {
+    kind: "html";
+    html: string;
+} | {
+    kind: "image";
+    image: ResolvedImage;
+    caption: string;
+} | {
+    kind: "element";
+    name: string;
+    fields: Record<string, unknown>;
+    settings: Record<string, unknown>;
+};
+export declare function richtextChunks(doc: unknown): RichTextChunk[];

package/dist/astro/richtext.js

@@ -0,0 +1,78 @@
+import { escapeHtml, isResolvedImage, safeHref } from "../richtext-href.js";
+import { ELEMENT_NODE, IMAGE_NODE } from "../richtext-walk.js";
+const asRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+const WRAP = { paragraph: "p", bulletList: "ul", orderedList: "ol", listItem: "li", blockquote: "blockquote" };
+export function richtextChunks(doc) {
+    const d = doc;
+    if (!d || typeof d !== "object" || d.type !== "doc" || !Array.isArray(d.content))
+        return [];
+    const out = [];
+    let html = "";
+    const flush = () => { if (html !== "") {
+        out.push({ kind: "html", html });
+        html = "";
+    } };
+    const walk = (node) => {
+        if (!node || typeof node !== "object")
+            return;
+        const children = () => { for (const c of Array.isArray(node.content) ? node.content : [])
+            walk(c); };
+        const wrap = WRAP[node.type];
+        if (wrap) {
+            html += `<${wrap}>`;
+            children();
+            html += `</${wrap}>`;
+            return;
+        }
+        switch (node.type) {
+            case "text":
+                html += withMarks(escapeHtml(node.text ?? ""), node.marks ?? []);
+                return;
+            case "heading": {
+                const level = Math.min(6, Math.max(1, Math.round(Number(node.attrs?.level ?? 1) || 1)));
+                html += `<h${level}>`;
+                children();
+                html += `</h${level}>`;
+                return;
+            }
+            case "hardBreak":
+                html += "<br>";
+                return;
+            case IMAGE_NODE: {
+                const a = (node.attrs ?? {});
+                if (!isResolvedImage(a.image))
+                    return;
+                flush();
+                out.push({ kind: "image", image: a.image, caption: typeof a.caption === "string" ? a.caption : "" });
+                return;
+            }
+            case ELEMENT_NODE: {
+                const a = (node.attrs ?? {});
+                if (typeof a.name !== "string")
+                    return;
+                flush();
+                out.push({ kind: "element", name: a.name, fields: asRecord(a.fields), settings: asRecord(a.settings) });
+                return;
+            }
+            default: children();
+        }
+    };
+    for (const n of d.content)
+        walk(n);
+    flush();
+    return out;
+}
+/** Marks wrap from the first outward: [bold, italic] → <em><strong>…</strong></em>. */
+function withMarks(inner, marks) {
+    return marks.reduce((acc, m) => {
+        switch (m.type) {
+            case "bold": return `<strong>${acc}</strong>`;
+            case "italic": return `<em>${acc}</em>`;
+            case "link": {
+                const href = safeHref(m.attrs?.href);
+                return href === null ? acc : `<a href="${escapeHtml(href)}">${acc}</a>`;
+            }
+            default: return acc;
+        }
+    }, inner);
+}

package/dist/astro/routes/admin.d.ts

@@ -0,0 +1,3 @@
+import type { APIRoute } from "astro";
+export declare const prerender = false;
+export declare const ALL: APIRoute;

package/dist/astro/routes/admin.js

@@ -0,0 +1,41 @@
+// The admin in an Astro project (spec 2026-10-02 astro cloud fit §4), injected by the integration at the
+// admin path: the page, the package's files and the operations endpoint are the framework-free handler's
+// (admin/handler.ts), made once per server. This file adds only what is Astro's: the tags an operation
+// expires go to the response cache together, and draft mode is the draft cookie, scoped to the preview
+// address. The request's own effects ride an AsyncLocalStorage, so one handler serves requests at once.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createAdminHandler } from "../../admin/handler.js";
+import { expire } from "../cache.js";
+import { DRAFT_COOKIE, PREVIEW_BASE, draftCookieValue } from "../preview.js";
+import { adminDeps, secret } from "../server.js";
+export const prerender = false;
+const current = new AsyncLocalStorage();
+const effects = () => {
+    const got = current.getStore();
+    if (!got)
+        throw new Error("smoodly: an admin operation ran outside its request.");
+    return got;
+};
+const secure = (context) => context.url.protocol === "https:" || context.request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim() === "https";
+const handle = createAdminHandler(() => ({
+    ...adminDeps(),
+    previewBase: PREVIEW_BASE,
+    effects: {
+        revalidate: (tag) => void effects().expired.add(tag),
+        draft: {
+            enable: async () => {
+                const { context } = effects();
+                context.cookies.set(DRAFT_COOKIE, await draftCookieValue(secret()), {
+                    path: PREVIEW_BASE, httpOnly: true, sameSite: "lax", secure: secure(context),
+                });
+            },
+            disable: () => effects().context.cookies.delete(DRAFT_COOKIE, { path: PREVIEW_BASE }),
+        },
+    },
+}));
+export const ALL = async (context) => {
+    const state = { expired: new Set(), context };
+    const response = await current.run(state, () => handle(context.request));
+    await expire(context.cache, state.expired);
+    return response;
+};

package/dist/astro/routes/page.astro

@@ -0,0 +1,17 @@
+---
+// The page shell (spec 2026-10-02 astro cloud fit §6–§7), injected by the integration at every address a
+// page file of the project's own does not take: the address becomes the project's view for the page's
+// type or for the entry's collection, with the page or the entry and the head as data; a redirect row
+// answers 308, as in Next (302 for the root under a prefixed default) (spec 2026-09-26 redirects §7). A preview arrives here by a rewrite from the
+// preview address, so the view sees the page's real address either way.
+import { views } from "smoodly:views";
+import { shell } from "smoodly/astro/runtime";
+
+const result = await shell(Astro.url.pathname, Astro.url.search, Astro.locals.smoodly, views, Astro.cache);
+// An empty 404: Astro renders the project's own 404 page for it, prerendered or not, or its default one.
+if (result.kind === "notFound") return new Response(null, { status: 404 });
+if (result.kind === "redirect") return Astro.redirect(result.location, result.status);
+const View = result.kind === "page" ? views.pages[result.template] : views.entries[result.collection];
+const props = result.kind === "page" ? { page: result.page, zones: result.zones, head: result.head } : { entry: result.entry, head: result.head };
+---
+<View {...props} />

package/dist/astro/routes/preview.astro

@@ -0,0 +1,11 @@
+---
+// The preview address (DESIGN.md Vision, preview per framework): /_smoodly/preview/<the page's path>,
+// open to a browser with the draft cookie and to no other. It rewrites to the page's own address, where
+// the same route a visitor gets renders the draft, so the page sees its real address. The admin and a
+// preview address inside a preview address are no page: a closed 404 for both.
+import { adminPath, previewTarget } from "smoodly/astro/runtime";
+
+const target = Astro.locals.smoodly?.draft ? previewTarget(Astro.url.pathname, adminPath) : null;
+if (target === null) return new Response("Not found", { status: 404, headers: { "cache-control": "no-store" } });
+return Astro.rewrite(target + Astro.url.search);
+---

package/dist/astro/runtime.d.ts

@@ -0,0 +1,32 @@
+export { EMPTY_ATTR, NODE_ATTR, ZONE_ATTR } from "../marks.ts";
+export { SMD_KEY } from "../smd-key.ts";
+export { DEFAULT_STYLE_VALUES, inlineStyles } from "../styles.ts";
+export { safeCss, scopedCss } from "../css.ts";
+export { PLACEHOLDER_CSS, zoneItems, type ZoneContent, type ZoneItem, type ZoneViews } from "./zone.ts";
+export { CRASHED_ATTR, FIELD_ATTR, ITEM_ATTR } from "../marks.ts";
+export { crashMessage } from "../crash-message.ts";
+export { styleAttribute } from "./style.ts";
+export { richtextChunks, type RichTextChunk } from "./richtext.ts";
+export { CUSTOM_NODE_TYPE } from "../custom/schema.ts";
+export { IMAGE_WIDTHS, imageRequest, imageWidths, placeImage } from "./image.ts";
+export { previewPath, previewTarget } from "./preview.ts";
+export { href } from "./server.ts";
+export type { Shell, SmoodlyLocals } from "./shell.ts";
+import { type RegistryInfo } from "./defaults.ts";
+import { type ViewFiles } from "./views-check.ts";
+export type { PageHead } from "./head.ts";
+export type { ViewFiles } from "./views-check.ts";
+import { type Shell, type SmoodlyLocals } from "./shell.ts";
+/** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
+ *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  the project's view files to the registry and names every disagreement once. */
+export declare function shell(pathname: string, search: string, state: SmoodlyLocals, views: ViewFiles, cache?: unknown): Promise<Shell>;
+/** The registry's titles and settings defaults, for the zone and the richtext renderer. */
+export declare const info: RegistryInfo;
+/** The custom section's rows and layout css, at the project's (already resolved) stacking breakpoint. */
+export declare const customLayoutOf: (rows: unknown, styles: Record<string, unknown>) => {
+    list: import("../index.ts").CustomRow[];
+    styles: Record<string, unknown>;
+};
+/** Where the admin is mounted, for the preview route to refuse. */
+export declare const adminPath: string;

package/dist/astro/runtime.js

@@ -0,0 +1,46 @@
+// What the package's own .astro files import (spec 2026-10-02 astro cloud fit §8). They name this entry,
+// `smoodly/astro/runtime`, and never a relative .ts file: tsc compiles this module for dist and leaves an
+// .astro file as it is.
+export { EMPTY_ATTR, NODE_ATTR, ZONE_ATTR } from "../marks.js";
+export { SMD_KEY } from "../smd-key.js";
+export { DEFAULT_STYLE_VALUES, inlineStyles } from "../styles.js";
+export { safeCss, scopedCss } from "../css.js";
+export { PLACEHOLDER_CSS, zoneItems } from "./zone.js";
+export { CRASHED_ATTR, FIELD_ATTR, ITEM_ATTR } from "../marks.js";
+export { crashMessage } from "../crash-message.js";
+export { styleAttribute } from "./style.js";
+export { richtextChunks } from "./richtext.js";
+export { CUSTOM_NODE_TYPE } from "../custom/schema.js";
+export { IMAGE_WIDTHS, imageRequest, imageWidths, placeImage } from "./image.js";
+export { previewPath, previewTarget } from "./preview.js";
+export { href } from "./server.js";
+import { customLayout } from "./custom.js";
+import { registryInfo } from "./defaults.js";
+import { lifetime } from "./cache.js";
+import { astroReads, preload } from "./scope.js";
+import { config, href, routing, site } from "./server.js";
+import { missingViews } from "./views-check.js";
+import { resolveShell } from "./shell.js";
+let viewsChecked = false;
+/** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
+ *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  the project's view files to the registry and names every disagreement once. */
+export async function shell(pathname, search, state, views, cache) {
+    if (!viewsChecked) {
+        viewsChecked = true;
+        const missing = missingViews(config.registry, views);
+        if (missing.length > 0)
+            console.warn(`smoodly: the views and the config disagree:\n  ${missing.join("\n  ")}`);
+    }
+    const shellViews = { page: (template) => Object.prototype.hasOwnProperty.call(views.pages, template), entry: (collection) => Object.prototype.hasOwnProperty.call(views.entries, collection) };
+    const result = await resolveShell({ site: site(), config, href, routing, run: astroReads.run, preload }, pathname, search, state, shellViews);
+    if (state.cacheable)
+        lifetime(cache);
+    return result;
+}
+/** The registry's titles and settings defaults, for the zone and the richtext renderer. */
+export const info = registryInfo(config.registry);
+/** The custom section's rows and layout css, at the project's (already resolved) stacking breakpoint. */
+export const customLayoutOf = (rows, styles) => customLayout(rows, styles, config.custom.breakpoint);
+/** Where the admin is mounted, for the preview route to refuse. */
+export const adminPath = config.admin.path;

package/dist/astro/scope.d.ts

@@ -0,0 +1,45 @@
+import type { ReadAdapter } from "../reads.ts";
+export type RequestScope = {
+    /** The tags of every published read the response has made so far. */
+    readonly tags: Set<string>;
+    /** The request is a verified preview: reads return drafts. */
+    readonly draft: boolean;
+    /** A read threw: whatever the page made of it (Astro's live collections hand the error back as a value,
+     *  a section's guard swallows it) is not the content, so the response is never cached (cache.ts). */
+    failed: boolean;
+    /** The database calls the response has made (the content client's requests, spec 2026-10-07 delivery model). */
+    reads: number;
+    /** Under SMOODLY_DEBUG_READS=1 only: when each read and each stage of the response ran, for the Server-Timing header. */
+    marks?: {
+        name: string;
+        start: number;
+        end: number;
+    }[];
+    /** Values the shell's lookup brought along (the layout's globals, schema v9), by unit key: a unit run under one
+     *  of these keys is answered here, without a read. */
+    seeded?: Map<string, {
+        value: unknown;
+        tags: string[];
+    }>;
+};
+/** Seeds the current request's scope with values a read brought along, under the keys the units they stand for
+ *  would use (`globalUnit`'s for a global item). Outside a scope, nothing. */
+export declare function preload(entries: {
+    key: string[];
+    tags: string[];
+    value: unknown;
+}[]): void;
+/** One database call in the current request, if any. The content client calls it through a global
+ *  (client.ts), installed once per process here. */
+export declare function countRead(): void;
+/** `x-smoodly-reads: <n>` on a response under SMOODLY_DEBUG_READS=1: how the browser suite holds a live
+ *  page to one lookup plus its globals. Off by default: a count is not for visitors. */
+export declare function readsHeader(headers: Headers, scope: RequestScope, env?: Record<string, string | undefined>): void;
+/** `server-timing` under SMOODLY_DEBUG_READS=1: every read (its key after the model, the ms it started at,
+ *  its duration) and the middleware's stages, plus the age of this process, so a cold start is visible. */
+export declare function timingHeader(headers: Headers, scope: RequestScope, origin: number, env?: Record<string, string | undefined>): void;
+/** Runs `fn` with `scope` as the request's: every read it starts, at any depth, finds it. */
+export declare function inRequestScope<T>(scope: RequestScope, fn: () => Promise<T>): Promise<T>;
+export declare function requestScope(): RequestScope | undefined;
+/** Astro's adapter for the read layer. No gate: these routes render on request, and a static build may read. */
+export declare const astroReads: ReadAdapter;

package/dist/astro/scope.js

@@ -0,0 +1,103 @@
+var _a;
+// The request scope and Astro's read adapter (spec 2026-10-02 astro cloud fit §6–§7): Astro caches whole
+// responses, so every read a response makes must add its tags, and a developer must never have to. The
+// middleware opens one scope per request (middleware.ts); every unit of the read layer (../reads.ts) run
+// inside it is heard here, wherever in the render it starts. A draft scope reads the draft and tags
+// nothing, because a draft response is never cached. `node:async_hooks` is the one Node module the
+// adapter's server code imports: Astro's own render scope and its Node adapter use the same storage.
+import { AsyncLocalStorage } from "node:async_hooks";
+const seedKey = (key) => key.join("\u0000");
+// A global read during a page render that the lookup did not bring: once per item per process, in development
+// only — a deliberate read on one page type is fine and would only be noise on a server.
+const hinted = new Set();
+function hintUnseeded(key, scope) {
+    if (process.env.NODE_ENV === "production" || key[2] !== "global" || !scope.seeded)
+        return;
+    const name = key[3] ?? "";
+    if (hinted.has(name))
+        return;
+    hinted.add(name);
+    console.warn(`smoodly: the global "${name}" was read while rendering a page but is not flagged \`layout: true\`, so every uncached page that reads it costs a database call. Flag it if every page renders it; ignore this if only some pages do.`);
+}
+/** Seeds the current request's scope with values a read brought along, under the keys the units they stand for
+ *  would use (`globalUnit`'s for a global item). Outside a scope, nothing. */
+export function preload(entries) {
+    const scope = storage.getStore();
+    if (!scope)
+        return;
+    scope.seeded ?? (scope.seeded = new Map());
+    for (const e of entries)
+        scope.seeded.set(seedKey(e.key), { value: e.value, tags: e.tags });
+}
+// One storage per process, however many copies of this module a bundler makes.
+const KEY = Symbol.for("smoodly:request-scope");
+const host = globalThis;
+const storage = (host[KEY] ?? (host[KEY] = new AsyncLocalStorage()));
+/** One database call in the current request, if any. The content client calls it through a global
+ *  (client.ts), installed once per process here. */
+export function countRead() {
+    const scope = storage.getStore();
+    if (scope)
+        scope.reads++;
+}
+const COUNTER = Symbol.for("smoodly:read-counter");
+(_a = globalThis)[COUNTER] ?? (_a[COUNTER] = countRead);
+/** `x-smoodly-reads: <n>` on a response under SMOODLY_DEBUG_READS=1: how the browser suite holds a live
+ *  page to one lookup plus its globals. Off by default: a count is not for visitors. */
+export function readsHeader(headers, scope, env = process.env) {
+    if (env.SMOODLY_DEBUG_READS === "1")
+        headers.set("x-smoodly-reads", String(scope.reads));
+}
+const BOOTED = Date.now();
+/** `server-timing` under SMOODLY_DEBUG_READS=1: every read (its key after the model, the ms it started at,
+ *  its duration) and the middleware's stages, plus the age of this process, so a cold start is visible. */
+export function timingHeader(headers, scope, origin, env = process.env) {
+    if (env.SMOODLY_DEBUG_READS !== "1" || !scope.marks)
+        return;
+    const parts = scope.marks.map((m, i) => `m${i};desc="${m.name.replace(/["\\]/g, "")}@${Math.round(m.start - origin)}";dur=${Math.round(m.end - m.start)}`);
+    parts.push(`boot;dur=${Date.now() - BOOTED}`);
+    headers.set("server-timing", parts.join(", "));
+}
+/** Runs `fn` with `scope` as the request's: every read it starts, at any depth, finds it. */
+export function inRequestScope(scope, fn) {
+    return storage.run(scope, fn);
+}
+export function requestScope() {
+    return storage.getStore();
+}
+/** Astro's adapter for the read layer. No gate: these routes render on request, and a static build may read. */
+export const astroReads = {
+    async run(unit) {
+        const scope = storage.getStore();
+        if (scope && !scope.draft)
+            for (const tag of unit.tags)
+                scope.tags.add(tag);
+        const started = performance.now();
+        const seeded = scope && !scope.draft ? scope.seeded?.get(seedKey(unit.key)) : undefined;
+        if (seeded) {
+            for (const tag of seeded.tags)
+                scope.tags.add(tag);
+            if (unit.tagsOf)
+                for (const tag of unit.tagsOf(seeded.value))
+                    scope.tags.add(tag);
+            scope.marks?.push({ name: `${unit.key.slice(2).join("/")} (seeded)`, start: started, end: performance.now() });
+            return seeded.value;
+        }
+        if (scope && !scope.draft)
+            hintUnseeded(unit.key, scope);
+        try {
+            const value = await unit.read(scope?.draft === true);
+            // Tags the value brings (a read by address): added after a successful read only.
+            if (scope && !scope.draft && unit.tagsOf)
+                for (const tag of unit.tagsOf(value))
+                    scope.tags.add(tag);
+            scope?.marks?.push({ name: unit.key.slice(2).join("/"), start: started, end: performance.now() });
+            return value;
+        }
+        catch (error) {
+            if (scope)
+                scope.failed = true;
+            throw error;
+        }
+    },
+};

package/dist/astro/server.d.ts

@@ -0,0 +1,14 @@
+import type { AdminHandlerDeps } from "../admin/handler.ts";
+import type { ResolvedConfig } from "../config.ts";
+export declare const config: ResolvedConfig;
+/** The address rule: astro.config's i18n when it is set, else the default locale at the root. */
+export declare const routing: import("./locale-paths.ts").LocaleRouting;
+/** Locale-relative CMS path → site URL, for the operations and the `page` prop. */
+export declare const href: (path: string, locale: string) => string;
+export declare const site: () => import("../site.ts").SmoodlySite;
+/** The draft cookie's key: the server-only key every Smoodly site already holds. */
+export declare const secret: () => string;
+type AdminDeps = Omit<AdminHandlerDeps, "effects" | "previewBase">;
+/** The admin's wiring. The publishable key is asked for here, not on a live page. */
+export declare function adminDeps(): AdminDeps;
+export {};