smoodly 0.0.50 → 0.0.52

package/dist/sql.d.ts

@@ -1,15 +0,0 @@
-import type { CollectionSchema } from "./collections.ts";
-export declare function collectionSQL(collection: CollectionSchema<any>): string;
-/** Foreign keys the planner needs an index for (spec 2026-09-29 pre-install
- *  fixes §3): a restrict or set-null check scans the referencing table
- *  without one, and the versions' read policies probe published_version_id
- *  on every public read. The composite indexes that exist lead with space_id. */
-export declare function foreignKeyIndexesSQL(): string;
-/** The shown snapshot of one collection's entries in a locale, filtered,
- *  ordered and limited in one query (spec 2026-09-29 content API contract
- *  §5). Invoker rights, so RLS decides what a key sees. Defined after the
- *  space layer, whose `smoodly_key_kind` it calls. */
-export declare function listEntriesSQL(): string;
-/** The delivery model (spec 2026-10-07 §1): two derived tables, a list function over the raw snapshot, a routes view. */
-export declare function publishedTablesSQL(): string;
-export declare function coreTablesSQL(): string;

package/dist/sql.js

@@ -1,556 +0,0 @@
-// Schema → SQL generation (Postgres/Supabase) for the stable schema
-// (DESIGN.md §3): all collection content lives in the one `entries`
-// table, applied once and never migrated. Per collection we emit only
-// a disposable guardrail — a published-only read view, created with
-// security_invoker so it runs under the caller's own RLS policies
-// rather than the view owner's privileges (SQL-queryable eject story;
-// sibling slug uniqueness is the `paths` primary key plus the stores'
-// per-locale pre-check, not an index). A view joins the locale rows, one row per published
-// locale (spec 2026-09-06 §7); a versioned collection reads its
-// fields from the published snapshot.
-import { SEO_KEY } from "./seo.js";
-import { currentSpaceSQL, grantsSQL, SPACE_COL, spaceLayerSQL, DEFAULT_SPACE } from "./sql-space.js";
-const snake = (s) => s.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
-const q = (s) => `"${s}"`;
-// Casts are fine in views.
-function fieldExpr(key, d, source) {
-    switch (d.type) {
-        case "text":
-        case "link":
-        case "slug":
-        case "select":
-        case "ref": // stored as the target entry's id string
-            return `${source}->>'${key}'`;
-        case "number":
-            return `(${source}->>'${key}')::numeric`;
-        case "date":
-            return `(${source}->>'${key}')::timestamptz`;
-        default:
-            return `${source}->'${key}'`; // image, video, file, object, list, richtext, refList
-    }
-}
-export function collectionSQL(collection) {
-    const name = collection.name;
-    // Every collection is versioned (spec 2026-09-14 §1): a field's value is the published
-    // snapshot's, falling back to the live row (the node's shared fields under the locale
-    // row's localized ones) for a published row from before versioning that nobody has
-    // written since — the store gives it a snapshot on its first write.
-    const source = `coalesce(v."fields", e."fields" || l."fields")`;
-    const columns = ['e."id"', 'l."locale"', 'l."slug"', 'e."sort"', 'e."created_at"', 'l."updated_at"'];
-    for (const [key, d] of Object.entries(collection.fields)) {
-        if (key === "slug")
-            continue; // the segment is the row's column, never a field
-        if (key === SEO_KEY)
-            continue; // the panel's values are Smoodly-internal, not a view column
-        columns.push(`${fieldExpr(key, d, source)} as ${q(snake(key))}`);
-    }
-    const statements = [
-        [
-            `create or replace view ${q(name)} with (security_invoker = true) as`,
-            `select`,
-            columns.map((c) => "  " + c).join(",\n"),
-            `from "entries" e`,
-            `join "entry_locales" l on l."entry_id" = e."id"`,
-            `left join "entry_versions" v on v."id" = l."published_version_id"`,
-            `where e."collection" = '${name}' and l."status" = 'published';`,
-        ].join("\n"),
-    ];
-    // Ordering reads the shown snapshot (smoodly_list_entries), so no index on the live row serves it (spec 2026-09-29 content API contract §5).
-    return statements.join("\n\n");
-}
-/** Foreign keys the planner needs an index for (spec 2026-09-29 pre-install
- *  fixes §3): a restrict or set-null check scans the referencing table
- *  without one, and the versions' read policies probe published_version_id
- *  on every public read. The composite indexes that exist lead with space_id. */
-export function foreignKeyIndexesSQL() {
-    return [
-        `create index if not exists "page_locales_draft_version_idx" on "page_locales" ("draft_version_id");`,
-        `create index if not exists "entry_locales_draft_version_idx" on "entry_locales" ("draft_version_id");`,
-        `create index if not exists "page_locales_published_version_idx" on "page_locales" ("published_version_id");`,
-        `create index if not exists "entry_locales_published_version_idx" on "entry_locales" ("published_version_id");`,
-        `create index if not exists "pages_parent_id_idx" on "pages" ("parent_id");`,
-        `create index if not exists "entries_parent_id_idx" on "entries" ("parent_id");`,
-        `create index if not exists "assets_poster_idx" on "assets" ("poster_id");`,
-    ].join("\n");
-}
-/** The shown snapshot of one collection's entries in a locale, filtered,
- *  ordered and limited in one query (spec 2026-09-29 content API contract
- *  §5). Invoker rights, so RLS decides what a key sees. Defined after the
- *  space layer, whose `smoodly_key_kind` it calls. */
-export function listEntriesSQL() {
-    return `
--- The shown snapshot of one collection's entries in a locale, filtered,
--- ordered and limited in one query (spec 2026-09-29 content API contract
--- §5): the published snapshot, or the live merge in preview. Invoker
--- rights, so RLS decides what a key sees; a preview read needs the
--- service role or a write key, anything else reads published.
-create or replace function "smoodly_list_entries"(
-  p_collection text, p_locale text, p_draft boolean, p_where jsonb, p_order jsonb,
-  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
-) returns table ("id" uuid, "fields" jsonb) language sql stable set search_path = public as $$
-  with mode as (
-    select p_draft and (current_user = 'service_role' or "smoodly_key_kind"() = 'write') as draft
-  ), shown as (
-    select e."id", e."sort", e."created_at", l."updated_at",
-      case when (select draft from mode) then e."fields" || l."fields" || jsonb_build_object('slug', l."slug")
-           else coalesce(v."fields", e."fields" || l."fields" || jsonb_build_object('slug', l."slug")) end as "fields"
-    from "entries" e
-    join "entry_locales" l on l."entry_id" = e."id" and l."locale" = p_locale
-    left join "entry_versions" v on v."id" = l."published_version_id"
-    where e."collection" = p_collection
-      and ((select draft from mode) or l."status" = 'published')
-      and (not p_has_parent or e."parent_id" is not distinct from p_parent)
-      and (p_ids is null or e."id" = any(p_ids))
-  )
-  select s."id", s."fields" 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;
-$$;`.trim();
-}
-/** The delivery model (spec 2026-10-07 §1): two derived tables, a list function over the raw snapshot, a routes view. */
-export function publishedTablesSQL() {
-    return `
--- 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_COL},
-  "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_COL},
-  "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");
-
--- The document stamp a space recorded as current (DESIGN §3, schema v10): set by \`npx smoodly rebuild\`
--- and by the first writer into an empty record; only a reader at this stamp rewrites the rows above.
-create table if not exists "published_models" (
-  "space_id" uuid primary key default ${DEFAULT_SPACE},
-  "model" text not null,
-  "recorded_at" timestamptz not null default now()
-);
-
--- The last Deploy press of a space (spec 2026-10-09 static mode §7, schema v11): who pressed and when;
--- the admin compares it with the build marker the live site serves.
-create table if not exists "space_deploys" (
-  "space_id" uuid primary key default ${DEFAULT_SPACE},
-  "requested_at" timestamptz,
-  "requested_by" text,
-  "removed_at" timestamptz
-);
-
-alter table "published_pages" enable row level security;
-alter table "published_entries" enable row level security;
-alter table "published_models" enable row level security;
-alter table "space_deploys" 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;
-
--- 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);
-$$;
-`.trim();
-}
-export function coreTablesSQL() {
-    return [
-        // The trigger/policy blocks below drop-before-create so the migration is
-        // re-appliable; on a fresh database every drop would otherwise NOTICE
-        // "does not exist, skipping" in the installer's output.
-        `set client_min_messages = warning;`,
-        currentSpaceSQL(),
-        `
-create table if not exists "pages" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "parent_id" uuid references "pages" ("id") on delete restrict,
-  "template" text,
-  "sort" numeric,
-  "fixed" text,
-  "created_at" timestamptz not null default now(),
-  "updated_at" timestamptz not null default now()
-);
-
--- The tree is the URL (spec 2026-09-05 §1): a node stores its parent and
--- its position; template null = folder. Everything a locale owns — the
--- node's own segment, title, publish state and version pointers — lives
--- in page_locales, one row per locale the page exists in (spec 2026-09-06
--- §2). There is no sibling-slug index: URL uniqueness per locale is the
--- primary key of "paths", which the stores write inside the same operation.
-create index if not exists "pages_parent_idx"
-  on "pages" ("space_id", "parent_id", "sort");
-
--- The registration that owns a code-owned record (spec 2026-09-29 nested
--- paths §3): "collection:<name>" or "page:<name>"; null = an editor's
--- page. Its path is its address from the config, not its slug chain.
-create unique index if not exists "pages_fixed_idx"
-  on "pages" ("space_id", "fixed") where "fixed" is not null;
-
-create table if not exists "page_locales" (
-  ${SPACE_COL},
-  "page_id" uuid not null references "pages" ("id") on delete cascade,
-  "locale" text not null,
-  "slug" text not null,
-  "title" text not null,
-  "status" text not null default 'draft',
-  "draft_version_id" uuid,
-  "published_version_id" uuid,
-  "updated_at" timestamptz not null default now(),
-  "updated_by" text,
-  primary key ("page_id", "locale")
-);
-
--- Sibling reorder for pages: same shape as smoodly_reorder for entries.
-create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql set search_path = public as $$
-  update "pages" pg set "sort" = u.ord
-  from unnest(p_ids) with ordinality as u(id, ord)
-  where pg."id" = u.id
-    and pg."space_id" = "smoodly_current_space"();
-$$;
-
--- A version belongs to ONE locale of one page: each locale has its own
--- draft, its own publish and its own history. One row per publish plus
--- the live draft (spec 2026-09-13 history §1): the unpublished draft row
--- is rewritten in place and saved_at is when its content last changed.
-create table if not exists "page_versions" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "page_id" uuid not null references "pages" ("id") on delete cascade,
-  "locale" text not null,
-  "tree" jsonb not null,
-  "saved_at" timestamptz not null default now()
-);
-
-create index if not exists "page_versions_page_locale_idx"
-  on "page_versions" ("page_id", "locale", "saved_at");
-
-create table if not exists "entries" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "collection" text not null,
-  "parent_id" uuid references "entries" ("id") on delete restrict,
-  "fields" jsonb not null default '{}'::jsonb,
-  "sort" numeric,
-  "created_at" timestamptz not null default now(),
-  "updated_at" timestamptz not null default now()
-);
-
--- The node holds identity, tree position and the SHARED fields — every
--- field without .localized() (spec 2026-09-06 §7): a Person's photo is
--- the same in every language. Everything a locale owns — its segment,
--- publish state, the .localized() fields and the version pointers —
--- lives in entry_locales, one row per locale the entry exists in. There
--- is no sibling-slug index any more: URL uniqueness per locale is the
--- primary key of "paths", which the stores write inside the same
--- operation, and both adapters pre-check siblings per locale in code.
-create index if not exists "entries_collection_sort_idx"
-  on "entries" ("space_id", "collection", "sort");
-
-create index if not exists "entries_parent_idx"
-  on "entries" ("space_id", "collection", "parent_id");
-
-create table if not exists "entry_locales" (
-  ${SPACE_COL},
-  "entry_id" uuid not null references "entries" ("id") on delete cascade,
-  "locale" text not null,
-  "slug" text,
-  "status" text not null default 'draft',
-  "fields" jsonb not null default '{}'::jsonb,
-  "draft_version_id" uuid,
-  "published_version_id" uuid,
-  "updated_at" timestamptz not null default now(),
-  "updated_by" text,
-  primary key ("entry_id", "locale")
-);
-
-create index if not exists "entry_locales_status_idx"
-  on "entry_locales" ("space_id", "locale", "status");
-
--- A version belongs to ONE locale of one entry and stores the MERGED
--- fields (shared + localized + slug) as they were at that save, so
--- restoring an old Finnish version restores the shared fields too.
--- Rows for every collection and every global item (spec 2026-09-14 §1).
--- One row per publish plus the live draft (spec 2026-09-13 history §1).
-create table if not exists "entry_versions" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "entry_id" uuid not null references "entries" ("id") on delete cascade,
-  "locale" text not null,
-  "fields" jsonb not null,
-  "saved_at" timestamptz not null default now()
-);
-
-create index if not exists "entry_versions_entry_locale_idx"
-  on "entry_versions" ("entry_id", "locale", "saved_at");
-
--- ── Draft pointers as foreign keys (schema v2, spec 2026-09-26 concurrency §1):
--- PostgREST embeds the draft version's saved_at through them, so every
--- locale row read carries the token. Set null on delete: discard moves
--- the pointer before it deletes the abandoned row, so nothing dangles.
-alter table "page_locales" drop constraint if exists "page_locales_draft_version_fkey";
-alter table "page_locales" add constraint "page_locales_draft_version_fkey"
-  foreign key ("draft_version_id") references "page_versions" ("id") on delete set null;
-alter table "entry_locales" drop constraint if exists "entry_locales_draft_version_fkey";
-alter table "entry_locales" add constraint "entry_locales_draft_version_fkey"
-  foreign key ("draft_version_id") references "entry_versions" ("id") on delete set null;
-
--- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
--- statement. Deliberately does not touch updated_at — a drag must not
--- make the whole collection look freshly edited. Scoped to the current
--- space by the same function the policies use.
-create or replace function "smoodly_reorder"(
-  p_collection text,
-  p_ids uuid[]
-) returns void language sql set search_path = public as $$
-  update "entries" e set "sort" = u.ord
-  from unnest(p_ids) with ordinality as u(id, ord)
-  where e."id" = u.id
-    and e."collection" = p_collection
-    and e."space_id" = "smoodly_current_space"();
-$$;
-
-create table if not exists "refs" (
-  "source_kind" text not null,
-  "source_id" uuid not null,
-  ${SPACE_COL},
-  "source_field" text not null,
-  "target_collection" text not null,
-  "target_id" uuid not null,
-  primary key ("source_kind", "source_id", "source_field", "target_id")
-);
-
--- The URL index (spec 2026-09-05 §4): the refs counterpart for paths.
--- Derived — the stores rewrite a target's rows on every create, rename,
--- move and delete — so one primary-key hit resolves any URL in any locale
--- and no page or entry can share a URL with another in any locale.
--- Rows exist for drafts too (the editor needs them); the read policy
--- admits a row only when its target is published.
--- A row with "redirect" set is an old address of its target (spec
--- 2026-09-26 redirects §2): the same primary key, so a redirect can never
--- sit where a live URL is and a live row taking the address replaces it.
--- "anchor" names the code address a row hangs under (spec 2026-09-29
--- anchored paths): "path" is only the part editors made, and the address
--- itself lives in the config; '' is the editors' own tree.
-create table if not exists "paths" (
-  ${SPACE_COL},
-  "locale" text not null,
-  "anchor" text not null default '',
-  "path" text not null,
-  "kind" text not null check ("kind" in ('page', 'entry')),
-  "target_id" uuid not null,
-  "redirect" boolean not null default false,
-  primary key ("space_id", "locale", "anchor", "path")
-);
-
-create index if not exists "paths_target_idx"
-  on "paths" ("space_id", "kind", "target_id");
-
--- Media (spec 2026-09-08): one row per upload, bytes in the "media"
--- bucket at "path". Immediate — never draft-gated, never versioned —
--- so there is no locale row and no version table. status 'pending' is
--- a row whose signed upload has not been confirmed; list never shows it.
-create table if not exists "assets" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "kind" text not null check ("kind" in ('image', 'video', 'file')),
-  "status" text not null default 'pending' check ("status" in ('pending', 'ready')),
-  "path" text not null,
-  "mime" text not null,
-  "size" bigint not null,
-  "width" integer,
-  "height" integer,
-  "duration" numeric,
-  "poster_id" uuid references "assets" ("id") on delete set null,
-  "filename" text not null,
-  "title" text,
-  "alt" text,
-  "caption" text,
-  "credit" text,
-  "created_by" text,
-  "created_at" timestamptz not null default now(),
-  "updated_at" timestamptz not null default now()
-);
-
-create index if not exists "assets_space_created_idx"
-  on "assets" ("space_id", "status", "created_at" desc);
-
--- Replace the targets' rows with the given rows in ONE call: a SQL
--- function runs in the caller's transaction, so a primary-key collision
--- rolls the whole rewrite back. Inserted rows get their space from the
--- a_set_space trigger (the claim, or the default space).
--- A target may name redirect_locales: its old live rows there stay as redirects.
--- A row carries "keys": every (anchor, path) that yields its full URL, from
--- the config's addresses (spec 2026-09-29 anchored paths §2). A redirect at
--- any of them goes (live wins, a redirect by hand has no anchor), and an old
--- row at one is the same address moving between anchors, never a redirect.
-create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql set search_path = public as $$
-  delete from "paths" p
-  using jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
-  where p."redirect" and p."locale" = r.locale
-    and exists (select 1 from jsonb_to_recordset(r.keys) as k(anchor text, path text) where k.anchor = p."anchor" and k.path = p."path")
-    and p."space_id" = "smoodly_current_space"();
-  update "paths" p set "redirect" = true
-  from jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
-  where not p."redirect" and p."kind" = t.kind and p."target_id" = t.id
-    and p."locale" = any (coalesce(t.redirect_locales, '{}'::text[]))
-    and not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
-                    cross join lateral jsonb_to_recordset(r.keys) as k(anchor text, path text)
-                    where r.locale = p."locale" and k.anchor = p."anchor" and k.path = p."path")
-    and p."space_id" = "smoodly_current_space"();
-  delete from "paths" p
-  using jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
-  where p."kind" = t.kind and p."target_id" = t.id
-    and (not p."redirect" or not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid)
-                                          where r.kind = p."kind" and r.id = p."target_id" and r.locale = p."locale"))
-    and p."space_id" = "smoodly_current_space"();
-  insert into "paths" ("locale", "anchor", "path", "kind", "target_id")
-  select r.locale, r.anchor, r.path, r.kind, r.id
-  from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid);
-$$;
-
--- One call reads every candidate (anchor, path) of a request (spec
--- 2026-09-29 anchored paths §2); the caller picks by precedence. Invoker
--- rights: the paths read policy applies, as to a plain select.
-create or replace function "smoodly_resolve_path"(p_locale text, p_keys jsonb) returns setof "paths" language sql stable set search_path = public as $$
-  select p.* from "paths" p
-  join jsonb_to_recordset(p_keys) as k(anchor text, path text) on p."anchor" = k.anchor and p."path" = k.path
-  where p."locale" = p_locale;
-$$;`.trim(),
-        foreignKeyIndexesSQL(),
-        `
--- RLS on every core table. The service role bypasses it (self-host
--- adapters untouched). The policy set that follows (space layer) admits
--- a write key to its own space and no other key to any content (spec
--- 2026-09-29 content API contract §8): the publishable key serves
--- sign-in and presence, and the generated per-collection views
--- (collectionSQL) run with security_invoker = true, so they are subject
--- to this same smoodly_read policy rather than their owner's privileges.
--- smoodly_meta: which version of this schema the database holds (spec
--- 2026-09-26 §1). One row per database, not per space; every core
--- migration file upserts the version row as its last statement, and the
--- package compares it with SCHEMA_VERSION (behind blocks the admin).
-create table if not exists "smoodly_meta" (
-  "key" text primary key,
-  "value" text not null
-);
-
-alter table "pages" enable row level security;
-alter table "page_locales" enable row level security;
-alter table "page_versions" enable row level security;
-alter table "entries" enable row level security;
-alter table "entry_locales" enable row level security;
-alter table "entry_versions" enable row level security;
-alter table "refs" enable row level security;
-alter table "paths" enable row level security;
-alter table "assets" enable row level security;
-alter table "smoodly_meta" enable row level security;
-`.trim(),
-        publishedTablesSQL(),
-        spaceLayerSQL(),
-        listEntriesSQL(),
-        grantsSQL(),
-    ].join("\n\n");
-}

package/dist/supabase-asset-store.d.ts

@@ -1,21 +0,0 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
-import { type AssetPage, type AssetQuery, type AssetStore, type BeginUploadInput, type CreateAssetInput, type FinishInput, type UploadTicket } from "./asset-store.ts";
-import { type AssetMeta, type AssetRecord } from "./media.ts";
-export declare class SupabaseAssetStore implements AssetStore {
-    private db;
-    constructor(db: SupabaseClient);
-    private fail;
-    private bucket;
-    private toRecord;
-    /** The space this client writes into — the claim, or the default. */
-    private space;
-    private insert;
-    beginUpload(input: BeginUploadInput): Promise<UploadTicket>;
-    finishUpload(id: string, dims: FinishInput): Promise<AssetRecord>;
-    create(input: CreateAssetInput): Promise<AssetRecord>;
-    get(id: string): Promise<AssetRecord | null>;
-    getMany(ids: string[]): Promise<Record<string, AssetRecord>>;
-    list(query?: AssetQuery): Promise<AssetPage>;
-    update(id: string, meta: AssetMeta): Promise<AssetRecord>;
-    delete(id: string): Promise<void>;
-}