smoodly 0.0.45 → 0.0.46

package/dist/astro/server.js

@@ -0,0 +1,45 @@
+// The bound stores and site layer of an Astro project (spec 2026-10-02 astro cloud fit §1), built from its
+// smoodly.config.ts through the virtual module: what the Next starter's server.ts glue does, with no file
+// in the app. Built on first use, so a build that renders nothing needs no keys.
+import { i18n } from "astro:config/server";
+import { config as loaded } from "smoodly:config";
+import { supabaseAdminAuth } from "../admin/supabase-auth.js";
+import { createSupabaseStores, siteOptions } from "../bind.js";
+import { createSmoodlyClient } from "../client.js";
+import { presenceConfig, smoodlyEnv } from "../env.js";
+import { createSmoodlySite } from "../site.js";
+import { astroRouting, localeHref } from "./locale-paths.js";
+export const config = loaded;
+if (!config?.registry) {
+    throw new Error("smoodly: smoodly.config.ts must export `config`, the result of defineConfig(…).");
+}
+/** The address rule: astro.config's i18n when it is set, else the default locale at the root. */
+export const routing = astroRouting(i18n, config.locales);
+/** Locale-relative CMS path → site URL, for the operations and the `page` prop. */
+export const href = localeHref(config.locales, routing);
+function build() {
+    const db = createSmoodlyClient(smoodlyEnv());
+    const stores = createSupabaseStores(db, config);
+    const site = createSmoodlySite(siteOptions(config, () => ({ pages: stores.pages, entries: stores.entries, assets: stores.assets, published: stores.published })));
+    return { db, ...stores, site };
+}
+let cached = null;
+const bound = () => (cached ?? (cached = build()));
+export const site = () => bound().site;
+/** The draft cookie's key: the server-only key every Smoodly site already holds. */
+export const secret = () => smoodlyEnv().secretKey;
+let admin = null;
+/** The admin's wiring. The publishable key is asked for here, not on a live page. */
+export function adminDeps() {
+    if (admin)
+        return admin;
+    const env = smoodlyEnv("admin");
+    const { db, pages, entries, assets, members, site } = bound();
+    admin = {
+        config, pages, entries, assets, members, href, projector: site.projector,
+        auth: supabaseAdminAuth({ authUrl: env.authUrl, authKey: env.authKey, db }),
+        signIn: { url: env.authUrl, key: env.authKey },
+        presence: () => presenceConfig(env),
+    };
+    return admin;
+}

package/dist/astro/shell.d.ts

@@ -0,0 +1,67 @@
+import type { ResolvedConfig } from "../config.ts";
+import { type ReadAdapter } from "../reads.ts";
+import { type EntryItem } from "../read-shapes.ts";
+import type { PageContext } from "../page-context.ts";
+import { type SmoodlySite } from "../site.ts";
+import { type PageHead } from "./head.ts";
+import { type LocaleRouting } from "./locale-paths.ts";
+import type { ZoneContent } from "./zone.ts";
+/** What the middleware decides once per request and the routes read from `Astro.locals.smoodly`. */
+export type SmoodlyLocals = {
+    /** A verified preview: reads return drafts, and nothing is cached. */
+    draft: boolean;
+    /** The canvas asked (`smoodly-editor=1`), inside a preview only. */
+    editor: boolean;
+    /** History's stored version, inside a preview only. */
+    version?: string;
+    /** Set by the shell when it rendered a page read from the database: the response may be cached under its tags. */
+    cacheable: boolean;
+    /** Set by the shell when it rendered a page at all: in a preview, only that response is a canvas. */
+    shell: boolean;
+    /** The locale the address was read in; set by the shell. */
+    locale?: string;
+};
+declare global {
+    namespace App {
+        interface Locals {
+            smoodly?: SmoodlyLocals;
+        }
+    }
+}
+export type ShellDeps = {
+    site: SmoodlySite;
+    config: ResolvedConfig;
+    href: (path: string, locale: string) => string;
+    routing: LocaleRouting;
+    run: ReadAdapter["run"];
+    /** Seeds the request's scope with the values the lookup brought along (scope.ts `preload`); absent in a static build. */
+    preload?: (entries: {
+        key: string[];
+        tags: string[];
+        value: unknown;
+    }[]) => void;
+};
+/** Whether the project has a view file for a page type or a collection's entries. */
+export type ShellViews = {
+    page(template: string): boolean;
+    entry(collection: string): boolean;
+};
+export type Shell = {
+    kind: "notFound";
+} | {
+    kind: "redirect";
+    location: string;
+    status: 302 | 308;
+} | {
+    kind: "page";
+    template: string;
+    page: PageContext;
+    zones: Record<string, ZoneContent>;
+    head: PageHead;
+} | {
+    kind: "entry";
+    collection: string;
+    entry: EntryItem;
+    head: PageHead;
+};
+export declare function resolveShell(deps: ShellDeps, pathname: string, search: string, state: SmoodlyLocals, views: ShellViews): Promise<Shell>;

package/dist/astro/shell.js

@@ -0,0 +1,63 @@
+import { addressWithGlobalsUnit, globalUnit } from "../reads.js";
+import { toEntryItem } from "../read-shapes.js";
+import { pageContextOf } from "../site.js";
+import { headOf } from "./head.js";
+import { redirectsRoot, splitLocale } from "./locale-paths.js";
+const NOT_FOUND = { kind: "notFound" };
+export async function resolveShell(deps, pathname, search, state, views) {
+    const { site } = deps;
+    const split = splitLocale(pathname, site.locales, deps.routing);
+    if (!split) {
+        // Prefix-always, and Astro let "/" through: the default locale's home, as Astro's own root redirect would (nothing read, never cached).
+        return redirectsRoot(pathname, deps.routing) ? { kind: "redirect", location: deps.href("/", site.locales.default) + search, status: 302 } : NOT_FOUND;
+    }
+    const { locale, path } = split;
+    state.locale = locale;
+    // One read: a page or entry, a redirect row, or null; a code-owned address with no record yet comes back
+    // as its code page, as in Next (spec 2026-09-30 tester findings §2). The layout globals (`layout: true`) ride
+    // along (schema v9) and are seeded under their units' keys, so the layout's loaders cost no call; one with
+    // no published row is simply not there. The scope is seeded even with nothing, which marks a page render.
+    const items = (deps.config.registry.globals ?? []).filter((item) => item.layout);
+    const { hit: got, globals } = await deps.run(addressWithGlobalsUnit(site, locale, path, items, state.version));
+    if (!state.draft) {
+        deps.preload?.(items.filter((item) => globals.has(item.name)).map((item) => {
+            const unit = globalUnit(site, item, locale);
+            return { key: unit.key, tags: unit.tags, value: globals.get(item.name) };
+        }));
+    }
+    if (got?.kind === "redirect") {
+        // A redirect row (spec 2026-09-26 redirects §7): the node's CURRENT path in this locale, through href, the query kept; no path there is a 404.
+        const current = (await site.targetPaths(got.target))[locale];
+        return current ? { kind: "redirect", location: deps.href(current, locale) + search, status: 308 } : NOT_FOUND;
+    }
+    const hit = got;
+    if (!hit)
+        return NOT_FOUND;
+    const head = headOf(hit, locale, deps.href, site.locales);
+    if (hit.kind === "entry") {
+        if (!views.entry(hit.collection)) {
+            console.warn(`smoodly: no src/entry-pages/${hit.collection}.astro — the entry at ${hit.path} is a 404.`);
+            return NOT_FOUND;
+        }
+        state.cacheable = !state.draft;
+        state.shell = true;
+        return { kind: "entry", collection: hit.collection, entry: toEntryItem(hit.entry, hit.entry.fields, hit), head };
+    }
+    const schema = deps.config.registry.pages.find((p) => p.name === hit.template);
+    if (!schema) {
+        console.warn(`smoodly: no page type named "${hit.template}" in the config — the record at ${hit.path} is a 404.`);
+        return NOT_FOUND;
+    }
+    if (!views.page(hit.template)) {
+        console.warn(`smoodly: no src/page-types/${hit.template}.astro — the record at ${hit.path} is a 404.`);
+        return NOT_FOUND;
+    }
+    // Only a page read from the database has a tag to expire it by.
+    state.cacheable = !hit.record.id.startsWith("code:") && !state.draft;
+    state.shell = true;
+    const zoneNames = Object.keys(schema.zones ?? {});
+    const zones = Object.fromEntries(zoneNames.map((name) => [
+        name, { name, nodes: hit.tree.zones?.[name] ?? [], editor: state.editor, styleValues: site.styles },
+    ]));
+    return { kind: "page", template: hit.template, page: pageContextOf(hit, deps.href), zones, head };
+}

package/dist/astro/style.d.ts

@@ -0,0 +1 @@
+export declare function styleAttribute(own: string | undefined, inline: Record<string, unknown>): string | undefined;

package/dist/astro/style.js

@@ -0,0 +1,11 @@
+// The style attribute Section.astro writes (what Astro does for an object `style`, kept here because a string
+// `style` is merged in too): camelCase keys become kebab-case, a custom property (`--x`) keeps its name, and a
+// value that is undefined, null or "" is left out.
+const kebab = (key) => (key.startsWith("--") ? key : key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`));
+export function styleAttribute(own, inline) {
+    const declarations = Object.entries(inline)
+        .filter(([, v]) => v !== undefined && v !== null && v !== "")
+        .map(([k, v]) => `${kebab(k)}:${v}`)
+        .join(";");
+    return [own ?? "", declarations].filter(Boolean).join(";") || undefined;
+}

package/dist/astro/views-check.d.ts

@@ -0,0 +1,3 @@
+import type { Registry } from "../config.ts";
+export type ViewFiles = Record<"sections" | "elements" | "pages" | "entries", Record<string, unknown>>;
+export declare function missingViews(registry: Registry, views: ViewFiles): string[];

package/dist/astro/views-check.js

@@ -0,0 +1,19 @@
+export function missingViews(registry, views) {
+    const out = [];
+    /** Both directions for one kind: `dir` is the folder under src, `key` the glob's name in the views object. */
+    const both = (dir, key, names, wants, orphan) => {
+        // An own name only, as the shell and the renderers look a view up: an inherited `constructor` is no view.
+        for (const name of names)
+            if (!Object.prototype.hasOwnProperty.call(views[key], name))
+                out.push(`src/${dir}/${name}.astro — ${wants(name)}`);
+        for (const file of Object.keys(views[key]))
+            if (!names.includes(file))
+                out.push(`src/${dir}/${file}.astro — ${orphan(file)}`);
+    };
+    both("sections", "sections", registry.sections.map((s) => s.name), (n) => `the section "${n}" has no view`, (f) => `no section named "${f}" is registered`);
+    both("elements", "elements", registry.elements.map((e) => e.name), (n) => `the element "${n}" has no view`, (f) => `no element named "${f}" is registered`);
+    both("page-types", "pages", registry.pages.map((p) => p.name), (n) => `the page type "${n}" has no view`, (f) => `no page type named "${f}" is registered`);
+    const mounted = registry.collections.filter((c) => c.path !== undefined).map((c) => c.name);
+    both("entry-pages", "entries", mounted, (n) => `the collection "${n}" has a path and no entry page`, (f) => `no collection named "${f}" has a path`);
+    return out;
+}

package/dist/astro/zone.d.ts

@@ -0,0 +1,39 @@
+import type { TreeNode } from "../page-context.ts";
+import type { StyleValues } from "../styles.ts";
+import type { SchemaInfo } from "./defaults.ts";
+export type ZoneContent = {
+    name: string;
+    nodes: TreeNode[];
+    /** The canvas asked: emit the editor's boxes. */
+    editor: boolean;
+    /** The config's CSS values behind the styles set. */
+    styleValues: StyleValues;
+};
+/** What the zone asks of the registry and the project's views: whether the registry has a node type, whether
+ *  a view file does, and what the registry says about it. */
+export type ZoneViews = {
+    registered(type: string): boolean;
+    has(type: string): boolean;
+    about(type: string): SchemaInfo;
+};
+export type ZoneItem = {
+    kind: "empty";
+    zone: string;
+} | {
+    kind: "unknown";
+    id: string;
+    type: string;
+} | {
+    kind: "missing";
+    id: string;
+    type: string;
+} | {
+    kind: "section";
+    id: string;
+    type: string;
+    title: string;
+    props: Record<string, unknown>;
+};
+/** The canvas placeholders' look — a node whose view is missing, and a crashed section (section-crash.tsx has the React one). */
+export declare const PLACEHOLDER_CSS = "padding:24px 16px;border:1px dashed #b54708;color:#b54708;font:500 14px/1.4 system-ui,sans-serif;text-align:center";
+export declare function zoneItems(content: ZoneContent | undefined, views: ZoneViews, warn?: (message: string) => void): ZoneItem[];

package/dist/astro/zone.js

@@ -0,0 +1,33 @@
+import { SMD_KEY } from "../smd-key.js";
+/** The canvas placeholders' look — a node whose view is missing, and a crashed section (section-crash.tsx has the React one). */
+export const PLACEHOLDER_CSS = "padding:24px 16px;border:1px dashed #b54708;color:#b54708;font:500 14px/1.4 system-ui,sans-serif;text-align:center";
+export function zoneItems(content, views, warn = console.warn) {
+    // A malformed tree must not crash the render: non-array nodes are an empty zone.
+    const nodes = content && Array.isArray(content.nodes) ? content.nodes : [];
+    if (!content || nodes.length === 0)
+        return content?.editor ? [{ kind: "empty", zone: content.name }] : [];
+    const items = [];
+    for (const node of nodes) {
+        // A type the code no longer registers (drift): the React zone's "Unknown section", which the editor's report names too.
+        if (!views.registered(node.type)) {
+            if (content.editor)
+                items.push({ kind: "unknown", id: node.id, type: node.type });
+            else
+                warn(`smoodly: no registered section for node type "${node.type}" — skipping.`);
+            continue;
+        }
+        if (!views.has(node.type)) {
+            if (content.editor)
+                items.push({ kind: "missing", id: node.id, type: node.type });
+            else
+                warn(`smoodly: no src/sections/${node.type}.astro for node type "${node.type}" — skipping.`);
+            continue;
+        }
+        const { title, defaults } = views.about(node.type);
+        // The node id, the css and the values ride the styles under one reserved key; Section.astro reads and strips it.
+        const styles = { ...(node.styles ?? {}), [SMD_KEY]: { node: node.id, css: typeof node.css === "string" ? node.css : undefined, values: content.styleValues } };
+        // Settings complete, as pair() hands them to a React view: the defaults under what the editor stored.
+        items.push({ kind: "section", id: node.id, type: node.type, title, props: { ...node.fields, settings: { ...defaults, ...(node.settings ?? {}) }, styles } });
+    }
+    return items;
+}

package/dist/bind.d.ts

@@ -0,0 +1,19 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { ResolvedConfig } from "./config.ts";
+import type { SiteOptions } from "./site.ts";
+import { SupabaseAssetStore } from "./supabase-asset-store.ts";
+import { SupabaseEntryStore } from "./supabase-entry-store.ts";
+import { SupabaseMemberStore } from "./supabase-member-store.ts";
+import { SupabasePathIndex } from "./supabase-path-index.ts";
+import { SupabasePublishedStore } from "./supabase-published-store.ts";
+import { SupabasePageStore } from "./supabase-store.ts";
+export declare function createSupabaseStores(db: SupabaseClient, config: ResolvedConfig): {
+    paths: SupabasePathIndex;
+    pages: SupabasePageStore;
+    entries: SupabaseEntryStore;
+    assets: SupabaseAssetStore;
+    members: SupabaseMemberStore;
+    published: SupabasePublishedStore;
+};
+/** What createSmoodlySite takes, read off the config. */
+export declare function siteOptions(config: ResolvedConfig, stores: SiteOptions["stores"]): SiteOptions;

package/dist/bind.js

@@ -0,0 +1,34 @@
+import { SupabaseAssetStore } from "./supabase-asset-store.js";
+import { SupabaseEntryStore } from "./supabase-entry-store.js";
+import { SupabaseMemberStore } from "./supabase-member-store.js";
+import { SupabasePathIndex } from "./supabase-path-index.js";
+import { SupabasePublishedStore } from "./supabase-published-store.js";
+import { SupabasePageStore } from "./supabase-store.js";
+export function createSupabaseStores(db, config) {
+    const { sections, elements, collections, globals } = config.registry;
+    const locales = config.locales;
+    // ONE path index for both stores: pages and entries share the URL space.
+    const paths = new SupabasePathIndex(db, config.anchors);
+    const entries = new SupabaseEntryStore(db, collections, { paths, locales, globals, elements: elements });
+    const pages = new SupabasePageStore(db, {
+        sections: sections, elements: elements, entries, paths, locales,
+        custom: config.custom,
+        homePageSlug: config.homePageSlug,
+        addresses: config.addresses,
+        tree: config.pages?.tree,
+    });
+    return {
+        paths, pages, entries, assets: new SupabaseAssetStore(db), members: new SupabaseMemberStore(db),
+        published: new SupabasePublishedStore(db, collections),
+    };
+}
+/** What createSmoodlySite takes, read off the config. */
+export function siteOptions(config, stores) {
+    const { sections, elements, collections, globals, pages } = config.registry;
+    return {
+        stores, collections, globals,
+        // defineConfig's checks guarantee a section and an element carry `fields`.
+        sections: sections, elements: elements,
+        locales: config.locales, homePageSlug: config.homePageSlug, styles: config.styles, custom: config.custom, pages,
+    };
+}

package/dist/bridge/bridge.d.ts

@@ -0,0 +1,9 @@
+export type Bridge = {
+    /** New markup is in the DOM: the adapter calls it after each refresh that is not a reload. */
+    rendered(): void;
+    stop(): void;
+};
+/** `refresh` is the framework's way to render the page again in place; the default reloads the frame. */
+export declare function startBridge(options?: {
+    refresh?: () => void;
+}): Bridge;

package/dist/bridge/bridge.js

@@ -0,0 +1,107 @@
+// The editor bridge, plain (spec 2026-10-02 astro cloud fit §5): no React, no framework. It runs INSIDE
+// the canvas frame — the site's own draft route — and only there. It reports geometry (section nodes,
+// empty zones and, since spec 2026-09-10, every marked field with its resolved path), forwards select
+// and hover with the field under the pointer, refreshes on request and says when a render has
+// committed. The admin overlay draws all chrome, bar one rule that ships as BRIDGE_CSS (marks.ts): a section that
+// renders nothing is stamped blank and takes a min-height, so the editor can see and select it; the
+// live site never runs the bridge, so it keeps its true height. Rects are in document coordinates: the
+// editor sizes the frame to the full document height, so client rects + scroll offsets map 1:1 onto
+// the overlay. Each adapter starts it: Next from a wrapper that passes the router's refresh
+// (next/bridge.tsx), Astro as a script.
+import { toBridgeMessage } from "../admin/editor/protocol.js";
+import { BLANK_ATTR, CRASHED_ATTR, EDITOR_ATTR, FIELD_ATTR, NODE_ATTR, ZONE_ATTR, crashedOf, resolveMarkPath } from "../marks.js";
+const MEDIA = "img,picture,video,audio,svg,canvas,iframe,object";
+/** No visible text (innerText skips <style> and hidden content) and no media. */
+const isBlank = (el) => el.innerText.trim() === "" && el.querySelector(MEDIA) === null;
+/** `refresh` is the framework's way to render the page again in place; the default reloads the frame. */
+export function startBridge(options = {}) {
+    const refresh = options.refresh ?? (() => window.location.reload());
+    // To the framing window, at this origin: a canvas that was navigated elsewhere tells nobody anything.
+    const post = (m) => window.parent.postMessage(m, window.location.origin);
+    const docRect = (el) => {
+        const r = el.getBoundingClientRect();
+        return { x: r.left + window.scrollX, y: r.top + window.scrollY, w: r.width, h: r.height };
+    };
+    // Array.from, not spread: the package's lib set is ES2020 + DOM (no DOM.Iterable).
+    const all = (selector) => Array.from(document.querySelectorAll(selector));
+    const inEditor = (el) => Boolean(el?.closest?.(`[${EDITOR_ATTR}]`));
+    const report = () => {
+        const roots = all(`[${NODE_ATTR}]`);
+        // Stamp before measuring, so the min-height is in the rects; only on a
+        // change, so the attribute mutation this causes converges instead of looping.
+        for (const el of roots) {
+            const blank = isBlank(el);
+            if (blank !== el.hasAttribute(BLANK_ATTR)) {
+                if (blank)
+                    el.setAttribute(BLANK_ATTR, "");
+                else
+                    el.removeAttribute(BLANK_ATTR);
+            }
+        }
+        const nodes = roots.map((el) => ({ id: el.getAttribute(NODE_ATTR), ...docRect(el) }));
+        const emptyZones = all(`[${ZONE_ATTR}]`).map((el) => ({ zone: el.getAttribute(ZONE_ATTR), ...docRect(el) }));
+        const fields = [];
+        for (const el of all(`[${FIELD_ATTR}]`)) {
+            // A mark inside the admin's own editor root (a nested element card) is not the page's.
+            if (inEditor(el))
+                continue;
+            const mark = resolveMarkPath(el);
+            if (mark)
+                fields.push({ ...mark, ...docRect(el) });
+        }
+        // Rounded up from the fractional box, so the frame is never a hair too short.
+        const docH = Math.ceil(Math.max(document.documentElement.scrollHeight, document.documentElement.getBoundingClientRect().height));
+        // Crashed sections (spec 2026-09-27 section guard §6): the placeholders the guard and the canvas net left.
+        const crashed = crashedOf(all(`[${CRASHED_ATTR}]`));
+        post({ source: "smoodly", kind: "rects", nodes, emptyZones, fields, docH, crashed });
+    };
+    const raf = () => requestAnimationFrame(report);
+    const ro = new ResizeObserver(raf);
+    ro.observe(document.documentElement);
+    // characterData too: a text session edits a text node in place, and the outline must follow.
+    const mo = new MutationObserver(raf);
+    mo.observe(document.body, { subtree: true, childList: true, attributes: true, characterData: true });
+    const elementOf = (target) => target;
+    const nodeIdAt = (target) => elementOf(target)?.closest?.(`[${NODE_ATTR}]`)?.getAttribute(NODE_ATTR) ?? null;
+    const pathAt = (target) => {
+        const el = elementOf(target)?.closest?.(`[${FIELD_ATTR}]`);
+        return el ? resolveMarkPath(el)?.path ?? null : null;
+    };
+    const onClick = (e) => {
+        // The canvas must never navigate away from under the editor.
+        if (elementOf(e.target)?.closest?.("a"))
+            e.preventDefault();
+        // Inside its own editor root the admin owns every click.
+        if (inEditor(elementOf(e.target)))
+            return;
+        post({ source: "smoodly", kind: "select", id: nodeIdAt(e.target), path: pathAt(e.target), x: e.clientX, y: e.clientY });
+    };
+    const onMove = (e) => {
+        if (inEditor(elementOf(e.target)))
+            return;
+        post({ source: "smoodly", kind: "hover", id: nodeIdAt(e.target), path: pathAt(e.target) });
+    };
+    const onMessage = (e) => {
+        if (toBridgeMessage(e, window))
+            refresh();
+    };
+    document.addEventListener("click", onClick, true);
+    document.addEventListener("mousemove", onMove, true);
+    window.addEventListener("message", onMessage);
+    // The mount is a committed render too (spec 2026-09-10 §5: the inline richtext editor lets go of its
+    // container only when the editor hears one).
+    post({ source: "smoodly", kind: "rendered" });
+    report();
+    const late = setTimeout(report, 500); // fonts/images settle
+    return {
+        rendered: () => post({ source: "smoodly", kind: "rendered" }),
+        stop() {
+            ro.disconnect();
+            mo.disconnect();
+            clearTimeout(late);
+            document.removeEventListener("click", onClick, true);
+            document.removeEventListener("mousemove", onMove, true);
+            window.removeEventListener("message", onMessage);
+        },
+    };
+}

package/dist/bridge/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bridge/entry.js

@@ -0,0 +1,5 @@
+// The bridge as a script file (spec 2026-10-02 astro cloud fit §5), for an adapter that appends a script
+// tag to a preview response: Astro's. It starts with the default refresh, a reload of the frame. Loaded
+// as a module script, so the body exists when it runs.
+import { startBridge } from "./bridge.js";
+startBridge();

package/dist/bridge/preview-pill.d.ts

@@ -0,0 +1,18 @@
+export declare const PILL_TAG = "smoodly-preview-pill";
+declare const POSITIONS: readonly ["left", "center", "right"];
+export type PillPosition = (typeof POSITIONS)[number];
+/** Where Exit goes: the preview route's `disable`, then back to the page of the moment. */
+export declare function exitUrl(route: string, loc: {
+    pathname: string;
+    search: string;
+}): string;
+/** One place left or right, stopping at the ends. */
+export declare function stepPosition(from: PillPosition, by: -1 | 1): PillPosition;
+/** The third of the window a drag ended in. */
+export declare function positionAt(x: number, width: number): PillPosition;
+/** What the pill reads of the window: the test seam. */
+export type PillEnv = Pick<Window & typeof globalThis, "customElements" | "HTMLElement" | "localStorage" | "location" | "innerWidth">;
+/** Define the element, once per document. `closed` lives in the closure, so a hidden pill stays hidden
+ *  across client navigations and returns on a reload. */
+export declare function definePreviewPill(env?: PillEnv): void;
+export {};

package/dist/bridge/preview-pill.js

@@ -0,0 +1,115 @@
+// The preview pill, plain (spec 2026-09-29 pre-install fixes §2; plan 2026-10-03 plain bridge): while
+// draft mode is on, outside the editor's canvas, a floating pill says the page shows unpublished changes
+// and offers Exit preview. A custom element with its styles in a Shadow DOM — no React, no framework.
+// The page's server renders the element in draft mode only; each adapter defines it: Next from a lazy
+// chunk behind the canvas stub (next/preview-pill-define.tsx), Astro as a script. The route rides on the
+// element, so nothing is interpolated into code.
+export const PILL_TAG = "smoodly-preview-pill";
+const POSITIONS = ["left", "center", "right"];
+const KEY = "smoodly-pill-position";
+/** Where Exit goes: the preview route's `disable`, then back to the page of the moment. */
+export function exitUrl(route, loc) {
+    return `${route}${route.includes("?") ? "&" : "?"}disable&path=${encodeURIComponent(loc.pathname + loc.search)}`;
+}
+/** One place left or right, stopping at the ends. */
+export function stepPosition(from, by) {
+    return POSITIONS[Math.min(POSITIONS.length - 1, Math.max(0, POSITIONS.indexOf(from) + by))];
+}
+/** The third of the window a drag ended in. */
+export function positionAt(x, width) {
+    const at = x / width;
+    return at < 1 / 3 ? "left" : at > 2 / 3 ? "right" : "center";
+}
+const CSS = ":host{all:initial}:host([hidden]){display:none}" +
+    ".pill{position:fixed;bottom:16px;z-index:2147483647;display:flex;align-items:center;gap:8px;padding:6px 6px 6px 14px;" +
+    "border-radius:999px;background:#151727;color:#fff;font:500 13px/1.2 system-ui,-apple-system,sans-serif;" +
+    "box-shadow:0 4px 16px rgba(0,0,0,.25);cursor:grab;user-select:none;touch-action:none}" +
+    // The ring must show on any page: a dark outline for a light one, a white halo under it for a dark one.
+    ".pill:focus-visible{outline:2px solid #151727;outline-offset:2px;box-shadow:0 0 0 2px #fff,0 4px 16px rgba(0,0,0,.25)}" +
+    ".pill[data-pos=left]{left:16px}.pill[data-pos=center]{left:50%;transform:translateX(-50%)}.pill[data-pos=right]{right:16px}" +
+    ".pill.dragging{cursor:grabbing}" +
+    "a{color:#151727;background:#fff;border-radius:999px;padding:5px 10px;text-decoration:none;font-weight:600}" +
+    "button{all:unset;cursor:pointer;width:24px;height:24px;border-radius:999px;display:grid;place-items:center;color:#fff;opacity:.7}" +
+    "button:hover,button:focus-visible{opacity:1;outline:2px solid #fff}";
+const HTML = '<div class="pill" role="region" aria-label="Smoodly preview" tabindex="0" title="Drag it, or press the left and right arrow keys, to move it">' +
+    "<span>Preview · unpublished changes</span>" +
+    "<a>Exit preview</a>" +
+    '<button type="button" aria-label="Hide until reload">×</button>' +
+    "</div>";
+/** Define the element, once per document. `closed` lives in the closure, so a hidden pill stays hidden
+ *  across client navigations and returns on a reload. */
+export function definePreviewPill(env = window) {
+    if (env.customElements.get(PILL_TAG))
+        return;
+    let closed = false;
+    // Private mode and blocked site data both throw; the pill still works and simply forgets its place.
+    const load = () => {
+        try {
+            const v = env.localStorage.getItem(KEY);
+            return v === "left" || v === "right" ? v : "center";
+        }
+        catch {
+            return "center";
+        }
+    };
+    const save = (v) => { try {
+        env.localStorage.setItem(KEY, v);
+    }
+    catch { /* not remembered */ } };
+    class Pill extends env.HTMLElement {
+        connectedCallback() {
+            if (closed) {
+                this.hidden = true;
+                return;
+            }
+            if (this.shadowRoot)
+                return;
+            const root = this.attachShadow({ mode: "open" });
+            root.innerHTML = `<style>${CSS}</style>${HTML}`;
+            const pill = root.querySelector(".pill");
+            const link = root.querySelector("a");
+            const close = root.querySelector("button");
+            const place = (pos, remember) => { pill.setAttribute("data-pos", pos); if (remember)
+                save(pos); };
+            const exit = () => exitUrl(this.getAttribute("data-route") || "/api/preview", env.location);
+            place(load(), false);
+            // A real link, so it opens like any other. The address moves under a client navigation while this
+            // element stays, so it is read again when the link is about to be used.
+            const fresh = () => link.setAttribute("href", exit());
+            fresh();
+            link.addEventListener("pointerenter", fresh);
+            link.addEventListener("focus", fresh);
+            link.addEventListener("click", (e) => {
+                // A modified click (a new tab, a new window) is the browser's: the link's href is already fresh.
+                if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button)
+                    return;
+                e.preventDefault();
+                env.location.href = exit();
+            });
+            close.addEventListener("click", () => { closed = true; this.hidden = true; });
+            pill.addEventListener("keydown", (e) => {
+                // With a modifier the key is the browser's: Alt+Left is Back.
+                if ((e.key !== "ArrowLeft" && e.key !== "ArrowRight") || e.altKey || e.metaKey || e.ctrlKey || e.shiftKey)
+                    return;
+                e.preventDefault();
+                place(stepPosition(pill.getAttribute("data-pos") ?? "center", e.key === "ArrowLeft" ? -1 : 1), true);
+            });
+            let start = null;
+            const end = () => { start = null; pill.classList.remove("dragging"); pill.style.translate = ""; };
+            pill.addEventListener("pointerdown", (e) => {
+                if (e.target.closest("a,button"))
+                    return;
+                start = e.clientX;
+                pill.setPointerCapture(e.pointerId);
+                pill.classList.add("dragging");
+            });
+            pill.addEventListener("pointermove", (e) => { if (start !== null)
+                pill.style.translate = `${e.clientX - start}px 0`; });
+            pill.addEventListener("pointerup", (e) => { if (start === null)
+                return; end(); place(positionAt(e.clientX, env.innerWidth), true); });
+            pill.addEventListener("pointercancel", () => { if (start !== null)
+                end(); });
+        }
+    }
+    env.customElements.define(PILL_TAG, Pill);
+}

package/dist/cli/import.d.ts

@@ -1,11 +1,14 @@
 import { type ContentTable } from "../sql-space.ts";
 import { type SpaceConnection } from "./space-io.ts";
+import type { ResolvedConfig } from "../config.ts";
 export type ImportArgs = {
     dir: string;
 };
 export type ImportDeps = {
     cwd?: string;
     connection?: SpaceConnection;
+    /** The app's config, which the closing rebuild assembles with; default: loaded from the folder (load-config.ts). */
+    config?: ResolvedConfig;
     batchSize?: number;
     /** Test seam: runs before each batch; a throw stops the import there. */
     beforeBatch?: (table: ContentTable, index: number) => void;