smoodly 0.0.45 → 0.0.47

package/dist/views.js

@@ -0,0 +1,52 @@
+function match(what, key, schemas, views) {
+    const registered = new Map(schemas.map((s) => [s.name, s]));
+    const viewed = new Set();
+    for (const v of views) {
+        const schema = registered.get(v.schema.name);
+        if (!schema)
+            throw new Error(`smoodly: the view for ${what} "${v.schema.name}" has no schema in the config — add its schema to registry.${key}.`);
+        if (schema !== v.schema) {
+            throw new Error(`smoodly: the view for ${what} "${v.schema.name}" is paired with a different schema object than the one in the config — pair it with the registered schema.`);
+        }
+        viewed.add(v.schema.name);
+    }
+    for (const s of schemas) {
+        if (!viewed.has(s.name))
+            throw new Error(`smoodly: ${what} "${s.name}" is registered in the config but has no view — add its component to defineViews({ ${key} }).`);
+    }
+}
+export function defineViews(config, views) {
+    const elements = views.elements ?? [];
+    match("section", "sections", config.registry.sections, views.sections);
+    match("element", "elements", config.registry.elements, elements);
+    match("page type", "pages", config.registry.pages, views.pages.filter((p) => p.schema.kind === "page"));
+    const collections = new Map(config.registry.collections.map((c) => [c.name, c]));
+    const rendered = new Set();
+    for (const p of views.pages) {
+        if (p.schema.kind !== "entryPage")
+            continue;
+        const name = p.schema.collection;
+        if (!collections.has(name))
+            throw new Error(`smoodly: an entry page renders collection "${name}", which is not in registry.collections.`);
+        if (rendered.has(name))
+            throw new Error(`smoodly: two entry pages render collection "${name}" — keep one in defineViews({ pages }).`);
+        rendered.add(name);
+    }
+    for (const c of config.registry.collections) {
+        if (c.path !== undefined && !rendered.has(c.name)) {
+            throw new Error(`smoodly: collection "${c.name}" declares a path but no entry page — add smoodly.entryPage(${c.name}, View) to defineViews({ pages }).`);
+        }
+    }
+    // A bound RichText (createRichText) carries the element components it renders. One it lacks would
+    // vanish from every body without a word, so it is named here (final review of the registration split).
+    const bound = views.RichText?.elements;
+    if (Array.isArray(bound)) {
+        const rendered = new Set(bound.map((e) => e?.schema?.name));
+        for (const e of config.registry.elements) {
+            if ((e.contexts ?? []).includes("richtext") && !rendered.has(e.name)) {
+                throw new Error(`smoodly: element "${e.name}" has a view in defineViews({ elements }), but the bound RichText does not render it — add its component to createRichText({ elements }) in smoodly/richtext.tsx.`);
+            }
+        }
+    }
+    return { sections: views.sections, elements, pages: views.pages, ...(views.RichText ? { RichText: views.RichText } : {}) };
+}

package/dist/zones.d.ts

@@ -1,8 +1,8 @@
 import type { GlobalSchema } from "./global.ts";
-type WithSchema = {
-    schema: {
-        name: string;
-    };
+/** A section schema as a zone needs it. `kind` keeps a component out at compile time: a function has a `name` too. */
+type Named = {
+    kind: string;
+    name: string;
 };
 export type ZonePolicy = {
     kind: "sections";
@@ -22,16 +22,16 @@ export type ZonePolicy = {
     global?: string;
 };
 export declare const z: {
-    sections(components: WithSchema[]): {
+    sections(schemas: Named[]): {
         kind: "sections";
         allow: string[];
     } & {
         max(n: number): ZonePolicy;
     };
     freeform(opts: {
-        sections: WithSchema[] | "*";
+        sections: Named[] | "*";
         custom?: boolean;
     }): ZonePolicy;
-    locked(target: WithSchema | GlobalSchema): ZonePolicy;
+    locked(target: Named | GlobalSchema): ZonePolicy;
 };
 export {};

package/dist/zones.js

@@ -1,10 +1,11 @@
-// Zone policies — the freedom dial. Policies reference paired components
-// directly; only their registered names are stored (plain data).
+// Zone policies — the freedom dial. Policies reference schemas directly;
+// only their registered names are stored (plain data).
+import { schemaOnly } from "./registration.js";
 const isGlobal = (target) => "kind" in target && target.kind === "global";
-const names = (components) => components.map((c) => c.schema.name);
+const names = (schemas) => schemas.map((s) => schemaOnly(s).name);
 export const z = {
-    sections(components) {
-        const allow = names(components);
+    sections(schemas) {
+        const allow = names(schemas);
         return {
             kind: "sections",
             allow,
@@ -24,6 +25,6 @@ export const z = {
                 throw new Error(`smoodly: global item "${target.name}" has no section — a locked zone needs a visual item.`);
             return { kind: "locked", component: target.section, global: target.name };
         }
-        return { kind: "locked", component: target.schema.name };
+        return { kind: "locked", component: schemaOnly(target).name };
     },
 };

package/migrations/20261007120000_smoodly_v8.sql

@@ -0,0 +1,154 @@
+-- Smoodly core schema, version 8 (docs/superpowers/specs/2026-10-07-delivery-model-design.md).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 7: the delivery model's two derived tables,
+-- published_pages and published_entries, with the space trigger and the
+-- write-key-only policies every content table has (no row cap: they are
+-- derived), smoodly_list_published over the raw published snapshot, and
+-- the published_routes view, one lookup for any address.
+
+set client_min_messages = warning;
+
+-- The delivery model (spec 2026-10-07): Publish writes the finished document of a page, an entry
+-- or a global here; a live read is one lookup. Derived and rebuildable from the editing tables.
+create table if not exists "published_pages" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "path" text,
+  "title" text not null,
+  "has_page" boolean not null,
+  "link_fields" jsonb not null default '{}'::jsonb,
+  "document" jsonb,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+create unique index if not exists "published_pages_address_idx"
+  on "published_pages" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_pages_tree_idx"
+  on "published_pages" ("space_id", "locale", "parent_id", "sort");
+
+create table if not exists "published_entries" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "collection" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "slug" text,
+  "path" text,
+  "created_at" timestamptz not null,
+  "updated_at" timestamptz not null,
+  "fields" jsonb not null,
+  "document" jsonb not null,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+create index if not exists "published_entries_list_idx"
+  on "published_entries" ("space_id", "collection", "locale");
+create unique index if not exists "published_entries_address_idx"
+  on "published_entries" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_entries_fields_idx"
+  on "published_entries" using gin ("fields");
+
+alter table "published_pages" enable row level security;
+alter table "published_entries" enable row level security;
+
+-- smoodly_list_entries without the draft branch, over the delivery table (spec 2026-10-07 §3):
+-- `where` and `order` read the raw published snapshot, the row answers with its document.
+-- Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_list_published"(
+  p_collection text, p_locale text, p_where jsonb, p_order jsonb,
+  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
+) returns table ("id" uuid, "document" jsonb, "model" text, "stale" boolean) language sql stable set search_path = public as $$
+  with shown as (
+    select p."entry_id" as "id", p."sort", p."created_at", p."updated_at", p."fields", p."document", p."model", p."stale"
+    from "published_entries" p
+    where p."collection" = p_collection and p."locale" = p_locale
+      and (not p_has_parent or p."parent_id" is not distinct from p_parent)
+      and (p_ids is null or p."entry_id" = any(p_ids))
+  )
+  select s."id", s."document", s."model", s."stale" from shown s
+  where not exists (
+    select 1 from jsonb_each(coalesce(p_where, '{}'::jsonb)) w
+    where not (case when w.value ? 'in'
+                    then (s."fields" ->> w.key) = any (select jsonb_array_elements_text(w.value -> 'in'))
+                    else s."fields" @> jsonb_build_object(w.key, w.value -> 'contains') end))
+  order by
+    case when p_order ->> 'by' = 'manual' then s."sort" end asc nulls last,
+    case when p_order ->> 'direction' = 'asc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end asc nulls last,
+    case when p_order ->> 'direction' = 'desc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end desc nulls last,
+    s."created_at" asc, s."id" asc
+  limit p_limit;
+$$;
+
+-- One lookup for any address (spec 2026-10-07 §3): a page or an entry, under the caller's own policies.
+create or replace view "published_routes" with (security_invoker = true) as
+  select "space_id", "locale", "path", 'page' as "kind", "page_id" as "id", "document", "model", "stale", "tags", null::text as "collection"
+  from "published_pages" where "path" is not null and "has_page"
+  union all
+  select "space_id", "locale", "path", 'entry' as "kind", "entry_id" as "id", "document", "model", "stale", "tags", "collection"
+  from "published_entries" where "path" is not null;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_pages";
+create trigger "smoodly_a_set_space" before insert on "published_pages"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "published_entries";
+create trigger "smoodly_a_set_space" before insert on "published_entries"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_pages";
+
+drop policy if exists "smoodly_insert" on "published_pages";
+create policy "smoodly_insert" on "published_pages" for insert
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_update" on "published_pages";
+create policy "smoodly_update" on "published_pages" for update
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_delete" on "published_pages";
+create policy "smoodly_delete" on "published_pages" for delete
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "published_pages";
+create policy "smoodly_read" on "published_pages" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_write" on "published_entries";
+
+drop policy if exists "smoodly_insert" on "published_entries";
+create policy "smoodly_insert" on "published_entries" for insert
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_update" on "published_entries";
+create policy "smoodly_update" on "published_entries" for update
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_delete" on "published_entries";
+create policy "smoodly_delete" on "published_entries" for delete
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "published_entries";
+create policy "smoodly_read" on "published_entries" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '8')
+  on conflict ("key") do update set "value" = excluded."value";

package/migrations/20261007200000_smoodly_v9.sql

@@ -0,0 +1,30 @@
+-- Smoodly core schema, version 9 (packages/smoodly/MAINTAINERS.md, register 2026-10-07: what the delivery model left).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 8: smoodly_lookup_address, the route row and the
+-- locale's global items in one call, so a live page is one database call
+-- instead of the page then its layout's globals.
+
+set client_min_messages = warning;
+
+-- The address and the locale's global items in one call (schema v9; register 2026-10-07: a miss was two
+-- rounds, the page then the layout's globals). The route row first, kind 'page' or 'entry'; then one row per
+-- named global, kind 'global', the collection its name. A miss answers nothing: the globals ride with a page
+-- only. Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_lookup_address"(p_locale text, p_path text, p_globals text[])
+returns table ("kind" text, "id" uuid, "collection" text, "document" jsonb, "model" text, "stale" boolean, "tags" text[])
+language sql stable set search_path = public as $$
+  with route as (
+    select r."kind", r."id", r."collection", r."document", r."model", r."stale", r."tags"
+    from "published_routes" r where r."locale" = p_locale and r."path" = p_path limit 1
+  )
+  select * from route
+  union all
+  select 'global' as "kind", e."entry_id", e."collection", e."document", e."model", e."stale", e."tags"
+  from "published_entries" e
+  where e."locale" = p_locale and e."collection" = any(coalesce(p_globals, '{}'::text[]))
+    and exists (select 1 from route);
+$$;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '9')
+  on conflict ("key") do update set "value" = excluded."value";

package/migrations/20261008120000_smoodly_v10.sql

@@ -0,0 +1,47 @@
+-- Smoodly core schema, version 10 (DESIGN §3, the document stamp, decided 2026-10-08).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 9: published_models, one row per space holding the
+-- document stamp the space recorded as current, so only the deployment at that
+-- stamp rewrites delivery rows (a preview deployment on a newer package serves
+-- assembled documents and writes nothing). Additive: no function changes.
+
+set client_min_messages = warning;
+
+-- The document stamp a space recorded as current: set by `npx smoodly rebuild` and by the first writer
+-- into an empty record; only a reader at this stamp rewrites published_pages and published_entries.
+create table if not exists "published_models" (
+  "space_id" uuid primary key default '00000000-0000-0000-0000-000000000000',
+  "model" text not null,
+  "recorded_at" timestamptz not null default now()
+);
+
+alter table "published_models" enable row level security;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_models";
+create trigger "smoodly_a_set_space" before insert on "published_models"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space's record; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_models";
+
+drop policy if exists "smoodly_insert" on "published_models";
+create policy "smoodly_insert" on "published_models" for insert
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_update" on "published_models";
+create policy "smoodly_update" on "published_models" for update
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_delete" on "published_models";
+create policy "smoodly_delete" on "published_models" for delete
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "published_models";
+create policy "smoodly_read" on "published_models" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '10')
+  on conflict ("key") do update set "value" = excluded."value";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "smoodly",
-  "version": "0.0.45",
-  "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
+  "version": "0.0.47",
+  "description": "Open-source, code-first CMS for Astro and Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,10 +19,30 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
     "./next": {
       "types": "./dist/next/index.d.ts",
       "default": "./dist/next/index.js"
     },
+    "./astro": {
+      "types": "./dist/astro/index.d.ts",
+      "default": "./dist/astro/index.js"
+    },
+    "./astro/runtime": {
+      "types": "./dist/astro/runtime.d.ts",
+      "default": "./dist/astro/runtime.js"
+    },
+    "./astro/components": {
+      "types": "./dist/astro/components.d.ts",
+      "default": "./dist/astro/components.js"
+    },
+    "./astro/content": {
+      "types": "./dist/astro/content.d.ts",
+      "default": "./dist/astro/content.js"
+    },
     "./image": {
       "types": "./dist/image/index.d.ts",
       "default": "./dist/image/index.js"
@@ -39,10 +59,6 @@
       "types": "./dist/admin/index.d.ts",
       "default": "./dist/admin/index.js"
     },
-    "./admin/next": {
-      "types": "./dist/admin/next/index.d.ts",
-      "default": "./dist/admin/next/index.js"
-    },
     "./migrations": {
       "types": "./dist/migrations.d.ts",
       "default": "./dist/migrations.js"
@@ -54,35 +70,33 @@
     "bin"
   ],
   "scripts": {
-    "build": "node scripts/write-version.mjs && rm -rf dist && tsc -p tsconfig.build.json",
+    "build:admin": "tsx scripts/build-admin.ts",
+    "build": "node scripts/write-version.mjs && rm -rf dist && tsc -p tsconfig.build.json && node scripts/copy-astro.mjs && npm run build:admin",
     "prepublishOnly": "npm run build",
-    "pretest": "node scripts/write-version.mjs",
+    "pretest": "node scripts/write-version.mjs && npm run -s build:admin",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "test:supabase": "bash scripts/test-supabase.sh"
   },
   "peerDependencies": {
+    "astro": "^7.3.5",
     "next": ">=16",
     "react": "^18 || ^19"
   },
   "peerDependenciesMeta": {
+    "astro": {
+      "optional": true
+    },
     "next": {
       "optional": true
+    },
+    "react": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@types/node": "^26.4.1",
-    "@types/react": "^19",
-    "@types/react-dom": "^19.2.5",
-    "next": "^16.3.4",
-    "react": "^19",
-    "react-dom": "^19",
-    "typescript": "^5",
-    "vitest": "^3"
-  },
-  "dependencies": {
-    "@supabase/supabase-js": "^2.113.0",
+    "@fontsource-variable/public-sans": "^5.3.0",
     "@tiptap/core": "3.31.4",
     "@tiptap/extension-blockquote": "3.31.4",
     "@tiptap/extension-bold": "3.31.4",
@@ -96,7 +110,20 @@
     "@tiptap/react": "3.31.4",
     "@tiptap/starter-kit": "3.31.4",
     "@tiptap/suggestion": "3.31.4",
+    "@types/node": "^26.4.1",
+    "@types/react": "^19",
+    "@types/react-dom": "^19.2.5",
+    "astro": "^7.3.5",
+    "esbuild": "^0.28.2",
     "lucide-react": "^1.41.0",
+    "next": "^16.3.4",
+    "react": "^19",
+    "react-dom": "^19",
+    "typescript": "^5",
+    "vitest": "^3"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.113.0",
     "tsx": "^4.23.15"
   }
 }

package/dist/admin/next/bridge.d.ts

@@ -1,2 +0,0 @@
-import { type ReactElement } from "react";
-export declare function EditorBridge(): ReactElement;

package/dist/admin/next/bridge.js

@@ -1,129 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-// Runs INSIDE the draft-route iframe (glue adds it only when draft mode +
-// the editor param are on). Reports geometry — section nodes, empty zones
-// and, since spec 2026-09-10, every marked field with its resolved path —
-// forwards select/hover with the field under the pointer, executes
-// refresh/scroll, and says when a render has committed. The admin overlay
-// draws all chrome — bar one rule this component renders: a section that
-// renders nothing (a fresh custom section, an all-optional section left
-// empty) is stamped blank and takes a min-height, so the editor can see
-// and select it; the live site never mounts the bridge, so it keeps its
-// true height. Rects are in document coordinates: the iframe is sized
-// to the full document height by the editor, so client rects + scroll
-// offsets map 1:1 onto the overlay.
-import { useEffect } from "react";
-import { useRouter } from "next/navigation";
-import { BLANK_ATTR, CRASHED_ATTR, EDITOR_ATTR, FIELD_ATTR, NODE_ATTR, ZONE_ATTR, crashedOf, resolveMarkPath } from "../../marks.js";
-const post = (m) => window.parent.postMessage(m, "*");
-/** The height of an md-spaced section with nothing inside (3.5rem + 3.5rem). */
-// The editor sizes the iframe to the reported height; the document's own
-// viewport must never scroll (2026-09-26): a fractional content height
-// (4595.3px in a 4595px frame) left it scrollable by a hair, and a
-// trackpad scroll over the canvas showed the frame's overlay scrollbar.
-// Hidden overflow drops no layout — programmatic scrollIntoView still
-// works, and the live site never mounts this.
-const BRIDGE_CSS = `html{overflow:hidden}[${NODE_ATTR}][${BLANK_ATTR}]{min-height:7rem}`;
-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;
-export function EditorBridge() {
-    const router = useRouter();
-    // Every commit of this component — the mount, then each RSC refresh,
-    // which re-renders the route — tells the editor the new markup is in
-    // the DOM (spec 2026-09-10 §5: the inline richtext editor lets go of
-    // its container only then).
-    useEffect(() => { post({ source: "smoodly", kind: "rendered" }); });
-    useEffect(() => {
-        const docRect = (el) => {
-            const r = el.getBoundingClientRect();
-            return { x: r.left + window.scrollX, y: r.top + window.scrollY, w: r.width, h: r.height };
-        };
-        const all = (selector) => Array.from(document.querySelectorAll(selector));
-        const inEditor = (el) => Boolean(el?.closest?.(`[${EDITOR_ATTR}]`));
-        const report = () => {
-            // Array.from, not spread: the package's lib set is ES2020 + DOM
-            // (no DOM.Iterable), so a NodeList isn't statically iterable here.
-            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) => {
-            const m = e.data;
-            if (m?.source !== "smoodly")
-                return;
-            if (m.kind === "refresh")
-                router.refresh();
-            if (m.kind === "scroll") {
-                document
-                    .querySelector(`[${NODE_ATTR}="${CSS.escape(m.id)}"]`)
-                    ?.scrollIntoView({ behavior: "smooth", block: "center" });
-            }
-        };
-        document.addEventListener("click", onClick, true);
-        document.addEventListener("mousemove", onMove, true);
-        window.addEventListener("message", onMessage);
-        report();
-        const late = setTimeout(report, 500); // fonts/images settle
-        return () => {
-            ro.disconnect();
-            mo.disconnect();
-            clearTimeout(late);
-            document.removeEventListener("click", onClick, true);
-            document.removeEventListener("mousemove", onMove, true);
-            window.removeEventListener("message", onMessage);
-        };
-    }, [router]);
-    return _jsx("style", { "data-smoodly-bridge": "", children: BRIDGE_CSS });
-}

package/dist/admin/next/create-admin.d.ts

@@ -1,19 +0,0 @@
-import type { ReactNode } from "react";
-import type { ResolvedConfig } from "../../config.ts";
-import type { AdminOpAction } from "../ops.ts";
-import type { AuthConfig } from "../shell/session.ts";
-import type { PresenceConfig } from "../../env.ts";
-/** `presence` (optional) is the content project's public config for editing presence (spec 2026-09-26
- *  concurrency §5; presence only, never content reads, spec 2026-09-29 content API contract §8), async because its space is asked of the database; absent or failed, presence
- *  is off and everything else works. */
-export declare function createSmoodlyAdmin(input: {
-    config: ResolvedConfig;
-    op: AdminOpAction;
-    auth: () => AuthConfig;
-    presence?: () => PresenceConfig | Promise<PresenceConfig>;
-}): {
-    AdminPage: () => null;
-    AdminLayout: ({ children }: {
-        children: ReactNode;
-    }) => Promise<import("react").JSX.Element>;
-};