smoodly 0.0.7 → 0.0.8

package/dist/index.js

@@ -4,6 +4,7 @@ import { collection, toolset } from "./collections.js";
 import { Section } from "./section-wrapper.js";
 import { page } from "./render.js";
 import { entryPage } from "./entry-page.js";
+import { shared } from "./shared.js";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.js";
 export { fixedSlug } from "./page.js";
 export { f } from "./fields.js";
@@ -19,12 +20,13 @@ export { MemoryEntryStore } from "./entry-store.js";
 export { SupabaseEntryStore } from "./supabase-entry-store.js";
 export { SupabasePathIndex } from "./supabase-path-index.js";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.js";
-export { affectedTargets, pageTag, entryTag } from "./revalidate.js";
+export { affectedTargets, pageTag, entryTag, sharedTag } from "./revalidate.js";
 export { resolveTree, resolveFields } from "./resolve.js";
 export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, } from "./paths.js";
 export { fixedPathFor } from "./localize.js";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
+export { SHARED_NODE_TYPE, STYLES_KEY, sharedLink } from "./shared.js";
 export const smoodly = {
     schema,
     section,
@@ -33,6 +35,7 @@ export const smoodly = {
     entryPage,
     collection,
     toolset,
+    shared,
     Section,
 };
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.js";

package/dist/next/page-renderer.d.ts

@@ -2,6 +2,7 @@ import type { ComponentType, ReactElement } from "react";
 import type { Metadata } from "next";
 import type { Descriptor } from "../fields.ts";
 import { type PairedPage } from "../render.tsx";
+import type { SharedSchema } from "../shared.ts";
 import { type SmoodlySite } from "../site.ts";
 /** A registered section, as renderPage's registry needs it. */
 type SectionEntry = ComponentType<any> & {
@@ -31,6 +32,9 @@ export type PathRenderOptions = {
     searchParams?: Promise<Record<string, string | string[] | undefined>>;
 };
 export declare function createPageRenderer(options: PageRendererOptions): {
+    getSmoodlyShared: <V>(item: SharedSchema<V>, opts?: {
+        locale?: string;
+    }) => Promise<V | null>;
     renderSmoodlyPath: (segments: string[], opts?: PathRenderOptions) => Promise<ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>;
     smoodlyMetadata: (segments: string[], opts?: {
         locale?: string;

package/dist/next/page-renderer.js

@@ -7,7 +7,7 @@ import { EditorBridge } from "../admin/next/bridge.js";
 import { fixedPathFor } from "../localize.js";
 import { joinPath } from "../paths.js";
 import { renderPage } from "../render.js";
-import { entryTag, pageTag } from "../revalidate.js";
+import { entryTag, pageTag, sharedTag } from "../revalidate.js";
 import { pageContextOf } from "../site.js";
 import { metadataFrom } from "./meta.js";
 export function createPageRenderer(options) {
@@ -82,7 +82,20 @@ export function createPageRenderer(options) {
      *  error surfaces as a rejected promise like every other failure. */
     const fixedPath = (Page) => (locale) => fixedPathFor(Page.schema, locale, site.locales, site.homePageSlug);
     const literal = (segments) => () => joinPath(segments);
+    /** A shared item for a layout: cached per (item, locale) under the
+     *  shared tag outside draft mode, the live draft inside it. */
+    async function getSmoodlyShared(item, opts) {
+        await connection();
+        const locale = opts?.locale ?? site.locales.default;
+        const { isEnabled: draft } = await draftMode();
+        if (draft)
+            return site.getShared(item, { locale, draft: true });
+        return unstable_cache(() => site.getShared(item, { locale }), ["smoodly-shared", item.name, locale], {
+            tags: [sharedTag(item.name)],
+        })();
+    }
     return {
+        getSmoodlyShared,
         renderSmoodlyPath: (segments, opts) => page(literal(segments), opts, any),
         smoodlyMetadata: (segments, opts) => metadata(literal(segments), opts, any),
         /** A fixed registration rendered from the developer's own route file. */

package/dist/page.js

@@ -10,7 +10,11 @@ function normalizePolicy(p) {
         case "freeform":
             return { kind: "freeform", allow: p.allow, rows: p.rows };
         case "locked":
-            return { kind: "locked", component: p.component };
+            return {
+                kind: "locked",
+                component: p.component,
+                ...(typeof p.shared === "string" ? { shared: p.shared } : {}),
+            };
         default:
             throw new Error(`smoodly: unknown zone policy kind "${String(p.kind)}".`);
     }

package/dist/refs.js

@@ -4,6 +4,7 @@
 // and never the source of truth. Stores rewrite a source's edges on
 // every save; `refs` answers only the REVERSE question (who depends on
 // this?) — forward resolution stays resolveTree's job.
+import { sharedLink } from "./shared.js";
 function targetOf(d) {
     const t = d.target?.();
     if (!t?.name)
@@ -39,6 +40,13 @@ export function collectTreeRefs(tree, sections) {
     const out = [];
     for (const nodes of Object.values(tree.zones ?? {})) {
         for (const node of nodes) {
+            // A placement (spec 2026-09-07 §5): one edge, keyed by the node id
+            // so two placements of one item on one page stay distinct rows.
+            const link = sharedLink(node);
+            if (link) {
+                out.push({ field: node.id, targetCollection: link.item, targetId: link.ref });
+                continue;
+            }
             const schema = byName.get(node.type);
             if (!schema)
                 continue; // fail-soft, same as renderPage

package/dist/resolve.d.ts

@@ -1,6 +1,7 @@
 import type { Descriptor } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
 import type { PageTree } from "./render.tsx";
+import { type SharedSchema } from "./shared.ts";
 export type EntryFetcher = (collection: string, ids: string[]) => Promise<Record<string, Record<string, unknown>>>;
 type SchemaLike = {
     name: string;
@@ -15,6 +16,8 @@ type ResolveOptions = {
     })[];
     collections: CollectionSchema<any>[];
     fetch: EntryFetcher;
+    /** The registered shared items a placement node may name (spec 2026-09-07 §4). */
+    shared?: SharedSchema[];
     /** Optional safety valve on chain length; unlimited by default. */
     maxDepth?: number;
 };

package/dist/resolve.js

@@ -6,6 +6,7 @@
 // Cycles are cut per path — a ref back to an entry already on its own
 // chain gets a shallow copy (refs as ids), so traversal terminates by
 // construction and the output stays JSON-serializable.
+import { sharedLink, SHARED_NODE_TYPE, STYLES_KEY } from "./shared.js";
 function targetOf(d) {
     const t = d.target?.();
     if (!t?.name)
@@ -27,6 +28,7 @@ export async function resolveTree(tree, options) {
         return [schema.name, schema];
     }));
     const resolved = structuredClone(tree);
+    await rewritePlacements(resolved, options.shared ?? [], options.fetch);
     const tasks = [];
     for (const nodes of Object.values(resolved.zones ?? {})) {
         for (const node of nodes) {
@@ -39,6 +41,42 @@ export async function resolveTree(tree, options) {
     await runResolution(tasks, { collections: options.collections, fetch: options.fetch, maxDepth });
     return resolved;
 }
+/** Placements first (spec 2026-09-07 §4): fetch every linked item in one
+ *  call per item, rewrite each node into the item's section node — the
+ *  placement's id stays, so the canvas selects it — and drop what the
+ *  site cannot render: an unpublished or dangling row, an object item
+ *  (no view), an unknown item. The normal pass then hydrates the
+ *  rewritten nodes' own refs. */
+async function rewritePlacements(tree, shared, fetch) {
+    const byName = new Map(shared.map((s) => [s.name, s]));
+    const wanted = new Map();
+    for (const nodes of Object.values(tree.zones ?? {})) {
+        for (const node of nodes) {
+            const link = sharedLink(node);
+            if (!link || !byName.get(link.item)?.section)
+                continue;
+            const ids = wanted.get(link.item) ?? new Set();
+            ids.add(link.ref);
+            wanted.set(link.item, ids);
+        }
+    }
+    const fetched = new Map();
+    await Promise.all([...wanted].map(async ([item, ids]) => fetched.set(item, await fetch(item, [...ids]))));
+    for (const [zone, nodes] of Object.entries(tree.zones ?? {})) {
+        tree.zones[zone] = nodes.flatMap((node) => {
+            const link = sharedLink(node);
+            if (!link)
+                return node.type === SHARED_NODE_TYPE ? [] : [node];
+            const schema = byName.get(link.item);
+            const row = fetched.get(link.item)?.[link.ref];
+            if (!schema?.section || !row)
+                return [];
+            const { [STYLES_KEY]: styles, ...fields } = structuredClone(row);
+            const isObject = styles !== null && typeof styles === "object";
+            return [{ id: node.id, type: schema.section, fields, ...(isObject ? { styles: styles } : {}) }];
+        });
+    }
+}
 /** One entry's fields, refs hydrated — the entry page's counterpart of
  *  resolveTree. Same rules, same batching, same cycle cut. */
 export async function resolveFields(fields, descriptors, options) {

package/dist/revalidate.d.ts

@@ -8,6 +8,10 @@ export type AffectedTargets = {
 };
 export declare const pageTag: (id: string) => string;
 export declare const entryTag: (id: string) => string;
+/** A shared item's cache unit, by NAME (a singleton has one row per
+ *  locale, and code owns the name): the Next glue's getSmoodlyShared
+ *  caches under it; ops.shared expires it. */
+export declare const sharedTag: (name: string) => string;
 export declare function affectedTargets(stores: {
     pages: PageStore;
     entries: EntryStore;

package/dist/revalidate.js

@@ -7,6 +7,10 @@
 // change (spec 2026-09-05 §5).
 export const pageTag = (id) => `page:${id}`;
 export const entryTag = (id) => `entry:${id}`;
+/** A shared item's cache unit, by NAME (a singleton has one row per
+ *  locale, and code owns the name): the Next glue's getSmoodlyShared
+ *  caches under it; ops.shared expires it. */
+export const sharedTag = (name) => `shared:${name}`;
 export async function affectedTargets(stores, entryId, options = {}) {
     const maxDepth = options.maxDepth ?? Infinity;
     const seen = new Set([entryId]);

package/dist/shared.d.ts

@@ -0,0 +1,46 @@
+import type { CollectionSchema } from "./collections.ts";
+import type { Descriptor } from "./fields.ts";
+import type { PairedComponent } from "./pairing.tsx";
+import type { BuilderMap, NamespaceValues, SectionSchema } from "./schema.ts";
+/** The reserved tree node type of a placement. */
+export declare const SHARED_NODE_TYPE = "shared";
+/** The reserved key a visual item's styles live under in the node's shared JSONB. */
+export declare const STYLES_KEY = "$styles";
+export type SharedSchema<V = Record<string, unknown>> = CollectionSchema<any> & {
+    kind: "shared";
+    /** The registered section a visual item renders through; absent = an object item. */
+    section?: string;
+    /** The section's style descriptors (empty for an object item). */
+    styles: Record<string, Descriptor>;
+    sample?: Record<string, unknown>;
+    /** phantom: what getShared returns */
+    readonly __value?: V;
+};
+export type SharedLink = {
+    item: string;
+    ref: string;
+};
+/** The placement a tree node is, or null for any other node. Accepts a
+ *  bare `{ type, fields }` shape or a full tree node — `id` (and any
+ *  other tree-node property) is ignored. */
+export declare function sharedLink(node: {
+    id?: string;
+    type: string;
+    fields?: Record<string, unknown>;
+}): SharedLink | null;
+type SharedInput = {
+    name: string;
+    title: string;
+    versions?: boolean;
+};
+export declare function shared<F extends BuilderMap>(input: SharedInput & {
+    fields: F;
+    section?: undefined;
+}): SharedSchema<NamespaceValues<F>>;
+export declare function shared<F extends BuilderMap, St extends BuilderMap>(input: SharedInput & {
+    section: PairedComponent<SectionSchema<F, St>, F, St>;
+    fields?: undefined;
+}): SharedSchema<NamespaceValues<F> & {
+    styles: NamespaceValues<St>;
+}>;
+export {};

package/dist/shared.js

@@ -0,0 +1,36 @@
+/** The reserved tree node type of a placement. */
+export const SHARED_NODE_TYPE = "shared";
+/** The reserved key a visual item's styles live under in the node's shared JSONB. */
+export const STYLES_KEY = "$styles";
+/** The placement a tree node is, or null for any other node. Accepts a
+ *  bare `{ type, fields }` shape or a full tree node — `id` (and any
+ *  other tree-node property) is ignored. */
+export function sharedLink(node) {
+    if (node.type !== SHARED_NODE_TYPE)
+        return null;
+    const { item, ref } = node.fields ?? {};
+    return typeof item === "string" && typeof ref === "string" ? { item, ref } : null;
+}
+export function shared(input) {
+    if (!input?.name)
+        throw new Error("smoodly: a shared item requires a name.");
+    if ((input.fields === undefined) === (input.section === undefined)) {
+        throw new Error(`smoodly: shared item "${input.name}" must declare exactly one of \`section\` or \`fields\`.`);
+    }
+    const fields = input.section
+        ? input.section.schema.fields
+        : Object.fromEntries(Object.entries(input.fields).map(([k, b]) => [k, b.descriptor]));
+    if (Object.prototype.hasOwnProperty.call(fields, STYLES_KEY)) {
+        throw new Error(`smoodly: shared item "${input.name}" has a field named "${STYLES_KEY}" — that key is reserved for a visual item's styles.`);
+    }
+    return {
+        kind: "shared",
+        name: input.name,
+        title: input.title,
+        fields,
+        styles: input.section ? input.section.schema.styles : {},
+        ...(input.section ? { section: input.section.schema.name } : {}),
+        ...(input.section?.schema.sample ? { sample: input.section.schema.sample } : {}),
+        ...(input.versions ? { versions: true } : {}),
+    };
+}

package/dist/site.d.ts

@@ -3,6 +3,7 @@ import { type EntryRecord, type EntryStore } from "./entry-store.ts";
 import { type LocaleSet, type PathTarget } from "./paths.ts";
 import type { SectionLike } from "./refs.ts";
 import type { PageContext, PageLink, PageTree } from "./render.tsx";
+import { type SharedSchema } from "./shared.ts";
 import type { PageRecord, PageStore } from "./store.ts";
 export type SiteOptions = {
     stores: () => {
@@ -11,6 +12,7 @@ export type SiteOptions = {
     };
     collections: CollectionSchema<any>[];
     sections: SectionLike[];
+    shared?: SharedSchema[];
     locales: LocaleSet;
     homePageSlug?: string;
 };
@@ -82,6 +84,14 @@ export interface SmoodlySite {
     getEntriesTree(collection: string, options?: {
         locale?: string;
     }): Promise<EntryTreeItem[]>;
+    /** A shared item's content in a locale (spec 2026-09-07 §4): an object
+     *  item's merged fields, or a visual item's section props (fields plus
+     *  `styles`), refs hydrated; null when the item has no row there or is
+     *  unpublished (outside draft mode). */
+    getShared<V>(item: SharedSchema<V>, options?: {
+        locale?: string;
+        draft?: boolean;
+    }): Promise<V | null>;
 }
 /** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
  *  bound to the render locale; the default keeps CMS paths as URLs. */

package/dist/site.js

@@ -1,6 +1,7 @@
 import { entryFieldsIn, schemaOf } from "./entry-store.js";
 import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
 import { resolveFields, resolveTree } from "./resolve.js";
+import { STYLES_KEY } from "./shared.js";
 /** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
  *  bound to the render locale; the default keeps CMS paths as URLs. */
 export function pageContextOf(hit, toUrl = (p) => p) {
@@ -51,7 +52,12 @@ export function createSmoodlySite(options) {
         const raw = draft ? await pages.getDraftTree(id, locale) : row.status === "published" ? await pages.getPublishedTree(id, locale) : null;
         if (!raw)
             return null;
-        const tree = await resolveTree(raw, { sections: options.sections, collections: options.collections, fetch: fetcher(draft, locale) });
+        const tree = await resolveTree(raw, {
+            sections: options.sections,
+            collections: options.collections,
+            shared: options.shared,
+            fetch: fetcher(draft, locale),
+        });
         const all = await pages.listPages();
         const index = new Map(all.map((n) => [n.id, n]));
         const byId = (x) => index.get(x);
@@ -171,6 +177,27 @@ export function createSmoodlySite(options) {
             const build = (parentId) => items.filter((i) => i.entry.parentId === parentId).map((i) => ({ ...i, children: build(i.entry.id) }));
             return build(null);
         },
+        async getShared(item, o) {
+            const locale = localeOf(o);
+            const draft = o?.draft ?? false;
+            const { entries } = options.stores();
+            const [record] = await entries.list(item.name);
+            if (!record)
+                return null;
+            const row = record.locales[locale];
+            if (!row || (!draft && row.status !== "published"))
+                return null;
+            const raw = draft
+                ? entryFieldsIn(record, locale)
+                : (await entries.getMany(item.name, [record.id], locale, { status: "published" }))[record.id];
+            if (!raw)
+                return null;
+            const fields = await resolveFields(raw, item.fields, { collections: options.collections, fetch: fetcher(draft, locale) });
+            if (!item.section)
+                return fields;
+            const { [STYLES_KEY]: styles, ...rest } = fields;
+            return { ...rest, styles: styles !== null && typeof styles === "object" ? styles : {} };
+        },
     };
     const site = {
         locales,

package/dist/sql-space.d.ts

@@ -1,6 +1,6 @@
 export declare const DEFAULT_SPACE = "'00000000-0000-0000-0000-000000000000'";
 export declare const SPACE_COL = "\"space_id\" uuid not null default '00000000-0000-0000-0000-000000000000'";
-export declare const CONTENT_TABLES: readonly ["pages", "page_locales", "page_versions", "saved_sections", "global_sections", "entries", "entry_locales", "entry_versions", "refs", "paths"];
+export declare const CONTENT_TABLES: readonly ["pages", "page_locales", "page_versions", "entries", "entry_locales", "entry_versions", "refs", "paths"];
 export type ContentTable = (typeof CONTENT_TABLES)[number];
 export declare function currentSpaceSQL(): string;
 export declare function spaceLayerSQL(): string;

package/dist/sql-space.js

@@ -8,8 +8,6 @@ export const CONTENT_TABLES = [
     "pages",
     "page_locales",
     "page_versions",
-    "saved_sections",
-    "global_sections",
     "entries",
     "entry_locales",
     "entry_versions",
@@ -27,10 +25,9 @@ language sql stable as $$
 $$;`.trim();
 }
 /** Which rows a read key (or the anon key, which has no claim) may see.
- *  null = write keys only — refs and the section library are editor
- *  tooling; editors is admission data; nothing a browser needs. The
- *  empty string means "read policy, no extra predicate" (global_sections
- *  is fully readable once it's in-space) — distinct from null. */
+ *  null = write keys only — refs is editor tooling; editors is admission
+ *  data; nothing a browser needs. Shared content (spec 2026-09-07) rides
+ *  the three entry predicates: it is stored as entries. */
 const PUBLISHED_READ = {
     pages: `exists (select 1 from "page_locales" l where l."page_id" = "pages"."id" and l."status" = 'published')`,
     page_locales: `"status" = 'published'`,
@@ -38,15 +35,13 @@ const PUBLISHED_READ = {
     entries: `exists (select 1 from "entry_locales" l where l."entry_id" = "entries"."id" and l."status" = 'published')`,
     entry_locales: `"status" = 'published'`,
     entry_versions: `exists (select 1 from "entry_locales" l where l."published_version_id" = "entry_versions"."id")`,
-    global_sections: ``,
-    saved_sections: null,
     refs: null,
     editors: null,
     paths: `(("kind" = 'page' and exists (select 1 from "page_locales" l where l."page_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entry_locales" l where l."entry_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published')))`,
 };
 /** Tables whose existing indexes do not lead with space_id. */
 const NEEDS_SPACE_INDEX = [
-    "page_locales", "page_versions", "entry_locales", "entry_versions", "saved_sections", "global_sections", "refs",
+    "page_locales", "page_versions", "entry_locales", "entry_versions", "refs",
 ];
 export function spaceLayerSQL() {
     const statements = [];

package/dist/sql.js

@@ -132,22 +132,6 @@ create table if not exists "page_versions" (
 create index if not exists "page_versions_page_locale_idx"
   on "page_versions" ("page_id", "locale", "created_at");
 
-create table if not exists "saved_sections" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "title" text not null,
-  "fragment" jsonb not null,
-  "created_at" timestamptz not null default now()
-);
-
-create table if not exists "global_sections" (
-  "id" uuid primary key default gen_random_uuid(),
-  ${SPACE_COL},
-  "type" text not null,
-  "content" jsonb not null,
-  "updated_at" timestamptz not null default now()
-);
-
 create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
@@ -273,8 +257,6 @@ $$;
 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 "saved_sections" enable row level security;
-alter table "global_sections" 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;

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

@@ -3,9 +3,9 @@ import type { CollectionSchema } from "./collections.ts";
 import type { AddEntryLocaleOptions, CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryUsage, EntryVersion, ListOptions } from "./entry-store.ts";
 export declare class SupabaseEntryStore implements EntryStore {
     private db;
-    private collections;
     private paths;
     private locales;
+    private schemas;
     constructor(db: SupabaseClient, collections: CollectionSchema<any>[], options?: EntryStoreOptions);
     private fail;
     private schema;

package/dist/supabase-entry-store.js

@@ -7,9 +7,9 @@
 // calls the smoodly_reorder SQL function: one statement, updated_at
 // untouched.
 import { collectionDepth, collectionOrder } from "./collections.js";
-import { DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, schemaOf, splitFields, } from "./entry-store.js";
+import { DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isSharedSchema, schemaOf, splitFields, } from "./entry-store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
-import { assertDepth, assertSupportedLocale, entryPathRows } from "./paths.js";
+import { assertDepth, assertSupportedLocale, entryPathRows, slugOf } from "./paths.js";
 // entries.id is a Postgres uuid column: filtering on a non-UUID string
 // throws invalid_text_representation. A non-UUID id can't exist in the
 // table, so treat it the same as a missing one.
@@ -44,15 +44,15 @@ function toVersion(row) {
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
         this.db = db;
-        this.collections = collections;
         this.paths = options.paths ?? new SupabasePathIndex(db);
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
+        this.schemas = [...collections, ...(options.shared ?? [])];
     }
     fail(message) {
         throw new Error(`smoodly: ${message}`);
     }
     schema(collection) {
-        return schemaOf(this.collections, collection);
+        return schemaOf(this.schemas, collection);
     }
     // ── reads ──
     async fetch(collection, id) {
@@ -240,6 +240,15 @@ export class SupabaseEntryStore {
         const schema = this.schema(collection);
         assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
+        if (isSharedSchema(schema)) {
+            const existing = await this.db.from("entries").select("id").eq("collection", collection).limit(1);
+            if (existing.error)
+                this.fail(existing.error.message);
+            if (existing.data.length > 0)
+                throw entryErrors.singleton(collection);
+            if (slugOf(fields) !== null)
+                throw entryErrors.noSlug(collection);
+        }
         const parent = await this.assertParent(collection, parentId, 1);
         this.assertParentHasLocale(parent, options.locale);
         const { shared, localized, slug } = splitFields(fields, schema);
@@ -327,6 +336,8 @@ export class SupabaseEntryStore {
         const before = await this.must(collection, id);
         const row = entryLocaleRow(before, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
+        if (isSharedSchema(schema) && slug !== null)
+            throw entryErrors.noSlug(collection);
         await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
         await this.updateNode(id, { fields: shared });
         await this.updateLocale(id, locale, { slug, fields: localized });
@@ -393,6 +404,8 @@ export class SupabaseEntryStore {
     }
     async removeLocale(collection, id, locale) {
         const schema = this.schema(collection);
+        if (isSharedSchema(schema))
+            throw entryErrors.everyLocale(collection);
         const entry = await this.must(collection, id);
         entryLocaleRow(entry, locale);
         if (Object.keys(entry.locales).length === 1)
@@ -428,6 +441,8 @@ export class SupabaseEntryStore {
         return res.data.map(toVersion);
     }
     async move(collection, id, to) {
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "it has no tree position");
         const entry = await this.must(collection, id);
         const subtree = await this.subtree(entry);
         if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
@@ -473,6 +488,8 @@ export class SupabaseEntryStore {
         const entry = await this.fetch(collection, id);
         if (!entry)
             return;
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "remove the registration to remove it");
         const children = await this.db.from("entries").select("id").eq("parent_id", id).limit(1);
         if (children.error)
             this.fail(children.error.message);
@@ -498,7 +515,8 @@ export class SupabaseEntryStore {
         return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
     }
     async reorder(collection, orderedIds) {
-        this.schema(collection);
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "it has no order");
         const res = await this.db.rpc("smoodly_reorder", { p_collection: collection, p_ids: orderedIds });
         if (res.error)
             this.fail(res.error.message);

package/dist/zones.d.ts

@@ -1,3 +1,4 @@
+import type { SharedSchema } from "./shared.ts";
 type WithSchema = {
     schema: {
         name: string;
@@ -11,9 +12,12 @@ export type ZonePolicy = {
     kind: "freeform";
     allow: string[] | "*";
     rows: boolean;
-} | {
+}
+/** `shared` names the item a bound zone shows (spec 2026-09-07 §4); `component` is its section either way. */
+ | {
     kind: "locked";
     component: string;
+    shared?: string;
 };
 export declare const z: {
     sections(components: WithSchema[]): {
@@ -26,6 +30,6 @@ export declare const z: {
         sections: WithSchema[] | "*";
         rows?: boolean;
     }): ZonePolicy;
-    locked(component: WithSchema): ZonePolicy;
+    locked(target: WithSchema | SharedSchema): ZonePolicy;
 };
 export {};

package/dist/zones.js

@@ -1,5 +1,6 @@
 // Zone policies — the freedom dial. Policies reference paired components
 // directly; only their registered names are stored (plain data).
+const isShared = (target) => "kind" in target && target.kind === "shared";
 const names = (components) => components.map((c) => c.schema.name);
 export const z = {
     sections(components) {
@@ -17,7 +18,12 @@ export const z = {
             rows: opts.rows ?? false,
         };
     },
-    locked(component) {
-        return { kind: "locked", component: component.schema.name };
+    locked(target) {
+        if (isShared(target)) {
+            if (!target.section)
+                throw new Error(`smoodly: shared item "${target.name}" has no section — a locked zone needs a visual item.`);
+            return { kind: "locked", component: target.section, shared: target.name };
+        }
+        return { kind: "locked", component: target.schema.name };
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {