smoodly 0.0.6 → 0.0.8

package/dist/localize.js

@@ -1,29 +1,8 @@
-// Per-field locale fallback for the two overlays the stores carry
-// (spec 2026-09-05 §2): `pages.i18n[locale].title` and
-// `entries.i18n[locale]`. Slugs are paths.ts's business (segmentFor);
-// this module owns titles and entry fields. Pure and framework-free.
-import { segmentFor } from "./paths.js";
-const present = (v) => v !== undefined && v !== null && v !== "";
-/** The locale's title, or the default locale's. */
-export function titleFor(node, locale, set) {
-    if (locale === set.default)
-        return node.title;
-    const own = node.i18n?.[locale]?.title;
-    return typeof own === "string" && own.length > 0 ? own : node.title;
-}
-/** A fresh object: the default locale's fields, overlaid per field with
- *  the locale's values. An overlay value that is undefined, null or ""
- *  falls back — a translator may leave a field blank. */
-export function localizeFields(fields, i18n, locale, set) {
-    const out = structuredClone(fields);
-    if (locale === set.default)
-        return out;
-    for (const [key, value] of Object.entries(i18n?.[locale] ?? {})) {
-        if (present(value))
-            out[key] = structuredClone(value);
-    }
-    return out;
-}
+// The fixed-page path derivation — the escape hatch's addressing (spec
+// 2026-09-05 §5). Entries and pages alike have no field fallback: their
+// locale rows own their fields, titles and slugs (spec 2026-09-06). This
+// module owns nothing but fixedPathFor now.
+import { fixedPageSegments } from "./paths.js";
 /** The path a FIXED page registration is served at in one locale — the
  *  escape hatch's addressing (spec §5: renderSmoodlyPage). Home is judged
  *  by the default-locale segment, exactly as the stores judge the record. */
@@ -31,12 +10,15 @@ export function fixedPathFor(schema, locale, set, homePageSlug) {
     if (schema.slug === undefined) {
         throw new Error(`smoodly: page registration "${schema.name}" has no fixed slug — open pages are served by renderSmoodlyPath.`);
     }
-    const slug = typeof schema.slug === "string" ? schema.slug : schema.slug[set.default];
+    // A registration declares its slugs in code, so a locale it omits means
+    // "the same segment", not "absent" — paths.ts's fixedPageSegments fills
+    // it, the same fill the boot check and the materializer use.
+    const segments = fixedPageSegments(schema.slug, set);
+    const slug = segments[set.default];
     if (slug === undefined) {
         throw new Error(`smoodly: page registration "${schema.name}" declares a per-locale slug without the default locale "${set.default}".`);
     }
     if (slug === homePageSlug)
         return "/";
-    const i18n = typeof schema.slug === "string" ? null : Object.fromEntries(Object.entries(schema.slug).map(([l, s]) => [l, { slug: s }]));
-    return `/${segmentFor({ slug, i18n }, locale, set)}`;
+    return `/${segments[locale] ?? slug}`;
 }

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/paths.d.ts

@@ -5,8 +5,21 @@ export type LocaleSet = {
     default: string;
     supported: string[];
 };
+/** ONE text for both stores: a locale outside the config set. */
+export declare const unsupportedLocale: (locale: string) => Error;
+export declare function assertSupportedLocale(locale: string, set: LocaleSet): void;
 /** A per-locale segment map: a string applies to every supported locale; an object is copied as declared. */
 export declare function perLocaleSegments(value: string | Record<string, string>, supported: string[]): Record<string, string>;
+/** The segments a FIXED PAGE registration claims, per locale. A
+ *  registration declares its slugs in code, so a locale its map omits
+ *  means "the default locale's segment", not "absent" — the
+ *  page_locales presence rule is about records, not registrations
+ *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
+ *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
+ *  (localize.ts) all fill through here, or a collision passes boot and
+ *  only surfaces at materialization. Collection mounts are NOT filled:
+ *  a per-locale path claims exactly the locales it names. */
+export declare function fixedPageSegments(slug: string | Record<string, string>, locales: LocaleSet): Record<string, string>;
 export type PathTarget = {
     kind: "page" | "entry";
     id: string;
@@ -17,18 +30,10 @@ export type PathRow = PathTarget & {
 };
 export declare const joinPath: (segments: string[]) => string;
 export declare const splitPath: (path: string) => string[];
-type SlugI18n = Record<string, {
-    slug?: string;
-}> | null | undefined;
-/** The locale's own segment, or the default locale's (per-field fallback). */
-export declare function segmentFor(node: {
-    slug: string;
-    i18n?: SlugI18n;
-}, locale: string, set: LocaleSet): string;
-/** null = every supported locale; otherwise the intersection. */
-export declare function localesOf(node: {
-    locales?: string[] | null;
-}, set: LocaleSet): string[];
+/** The node's segment in one locale. An absent locale is an error, never
+ *  a fallback: the stores' parent rule guarantees a present node has a
+ *  present ancestor chain, so a throw here is a broken invariant. */
+export declare function segmentFor(node: PageLike, locale: string): string;
 export declare function chainOf<T extends {
     id: string;
     parentId: string | null;
@@ -37,44 +42,58 @@ export declare function assertDepth(depth: number, max: number, what: string): v
 export type PageLike = {
     id: string;
     parentId: string | null;
-    slug: string;
-    i18n: Record<string, {
-        slug?: string;
-        title?: string;
-    }> | null;
-    locales: string[] | null;
+    /** The locales the node exists in, each with the node's OWN segment there. Presence IS the key (spec 2026-09-06 §3). */
+    locales: Record<string, {
+        slug: string;
+    }>;
 };
 export type PagePathOptions = {
     locales: LocaleSet;
     homePageSlug: string;
 };
+/** Home is judged by identity: the root node whose DEFAULT-locale slug is
+ *  homePageSlug serves "/" in every locale it exists in. */
+export declare const isHomeNode: (node: PageLike, opts: PagePathOptions) => boolean;
 /** The node's path in one locale: `/` for the home node, else the
- *  localized ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export declare function pagePath(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string;
+/** The same path, or null when the node or an ancestor is absent from the
+ *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+export declare function pagePathIn(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string | null;
+/** One row per locale the target EXISTS in. */
 export declare function pagePathRows(targets: PageLike[], byId: (id: string) => PageLike | undefined, opts: PagePathOptions): PathRow[];
 export type EntryLike = {
     id: string;
     parentId: string | null;
-    fields: Record<string, unknown>;
-    i18n: Record<string, Record<string, unknown>> | null;
-    locales: string[] | null;
+    /** The locales the entry exists in, each with its OWN segment there (null =
+     *  the entry claims no URL in that locale). Presence IS the key (spec
+     *  2026-09-06 §7). */
+    locales: Record<string, {
+        slug: string | null;
+    }>;
 };
 export declare function collectionSegment(path: string | Record<string, string> | undefined, locale: string, set: LocaleSet): string | null;
 /** The "claims a URL" predicate (§1): a slug is only a real segment when
  * it is a non-empty string — absent, null, or `""` all mean "no URL".
- * The sibling index predicate in sql.ts (`entries_sibling_slug_key`)
- * mirrors this rule exactly, so Postgres and memory agree on which
+ * There is no sibling-slug index: sibling uniqueness is the primary key
+ * of `paths` plus the pre-check each store makes per locale before it
+ * writes (spec 2026-09-06 §12), so Postgres and memory agree on which
  * entries can collide. */
 export declare const slugOf: (fields: Record<string, unknown>) => string | null;
-export declare function entrySegment(entry: EntryLike, locale: string, set: LocaleSet): string | null;
+/** The entry's segment in one locale: its row's slug. An absent locale
+ *  or a slug-less row is null — no URL there, never a fallback. */
+export declare function entrySegment(entry: EntryLike, locale: string): string | null;
+/** One row per locale the target EXISTS in, where the whole chain has a
+ *  segment in that locale. The stores' parent rule guarantees an ancestor
+ *  is present wherever a descendant is; an ancestor without a slug there
+ *  simply yields no URL for the subtree in that locale. */
 export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
     path?: string | Record<string, string>;
 }, set: LocaleSet): PathRow[];
 export type PageTreeNode<T extends PageLike> = {
     record: T;
-    path: string;
+    path: string | null;
     children: PageTreeNode<T>[];
 };
 export declare function buildPageTree<T extends PageLike>(records: T[], locale: string, opts: PagePathOptions): PageTreeNode<T>[];
-export {};

package/dist/paths.js

@@ -1,6 +1,7 @@
-// The one place a URL is derived (spec 2026-09-05 §1, §4). Pure and
-// framework-free: both store adapters and the tree query call these, so
-// the `paths` index and every derived `path` value agree by construction.
+// The one place a URL is derived (spec 2026-09-05 §1, §4; spec
+// 2026-09-06 §3, §7). Pure and framework-free: both store adapters and
+// the tree query call these, so the `paths` index and every derived
+// `path` value agree by construction.
 export const SEGMENT_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 export const isSegment = (s) => SEGMENT_RE.test(s);
 export function assertSegment(s, what) {
@@ -8,24 +9,39 @@ export function assertSegment(s, what) {
         throw new Error(`smoodly: ${what} "${s}" is not a valid slug — use lowercase letters, digits and single hyphens.`);
     }
 }
+/** ONE text for both stores: a locale outside the config set. */
+export const unsupportedLocale = (locale) => new Error(`smoodly: "${locale}" is not a supported locale.`);
+export function assertSupportedLocale(locale, set) {
+    if (!set.supported.includes(locale))
+        throw unsupportedLocale(locale);
+}
 /** A per-locale segment map: a string applies to every supported locale; an object is copied as declared. */
 export function perLocaleSegments(value, supported) {
     return typeof value === "string" ? Object.fromEntries(supported.map((l) => [l, value])) : { ...value };
 }
+/** The segments a FIXED PAGE registration claims, per locale. A
+ *  registration declares its slugs in code, so a locale its map omits
+ *  means "the default locale's segment", not "absent" — the
+ *  page_locales presence rule is about records, not registrations
+ *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
+ *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
+ *  (localize.ts) all fill through here, or a collision passes boot and
+ *  only surfaces at materialization. Collection mounts are NOT filled:
+ *  a per-locale path claims exactly the locales it names. */
+export function fixedPageSegments(slug, locales) {
+    const raw = perLocaleSegments(slug, locales.supported);
+    return Object.fromEntries(locales.supported.map((l) => [l, raw[l] || raw[locales.default]]));
+}
 export const joinPath = (segments) => (segments.length === 0 ? "/" : "/" + segments.join("/"));
 export const splitPath = (path) => path.split("/").filter((s) => s.length > 0);
-/** The locale's own segment, or the default locale's (per-field fallback). */
-export function segmentFor(node, locale, set) {
-    if (locale === set.default)
-        return node.slug;
-    const own = node.i18n?.[locale]?.slug;
-    return typeof own === "string" && own.length > 0 ? own : node.slug;
-}
-/** null = every supported locale; otherwise the intersection. */
-export function localesOf(node, set) {
-    if (!node.locales)
-        return [...set.supported];
-    return set.supported.filter((l) => node.locales.includes(l));
+/** The node's segment in one locale. An absent locale is an error, never
+ *  a fallback: the stores' parent rule guarantees a present node has a
+ *  present ancestor chain, so a throw here is a broken invariant. */
+export function segmentFor(node, locale) {
+    const own = node.locales[locale];
+    if (!own)
+        throw new Error(`smoodly: page "${node.id}" does not exist in locale "${locale}".`);
+    return own.slug;
 }
 export function chainOf(node, byId) {
     const chain = [node];
@@ -43,19 +59,30 @@ export function assertDepth(depth, max, what) {
     if (depth > max)
         throw new Error(`smoodly: ${what} would exceed the tree depth (${max}).`);
 }
-const isHome = (node, homePageSlug) => node.parentId === null && node.slug === homePageSlug;
+/** Home is judged by identity: the root node whose DEFAULT-locale slug is
+ *  homePageSlug serves "/" in every locale it exists in. */
+export const isHomeNode = (node, opts) => node.parentId === null && node.locales[opts.locales.default]?.slug === opts.homePageSlug;
 /** The node's path in one locale: `/` for the home node, else the
- *  localized ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export function pagePath(node, byId, locale, opts) {
-    return isHome(node, opts.homePageSlug)
-        ? "/"
-        : joinPath(chainOf(node, byId).map((n) => segmentFor(n, locale, opts.locales)));
+    return isHomeNode(node, opts) ? "/" : joinPath(chainOf(node, byId).map((n) => segmentFor(n, locale)));
+}
+/** The same path, or null when the node or an ancestor is absent from the
+ *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+export function pagePathIn(node, byId, locale, opts) {
+    if (!node.locales[locale])
+        return null;
+    if (isHomeNode(node, opts))
+        return "/";
+    const chain = chainOf(node, byId);
+    return chain.every((n) => n.locales[locale] !== undefined) ? joinPath(chain.map((n) => n.locales[locale].slug)) : null;
 }
+/** One row per locale the target EXISTS in. */
 export function pagePathRows(targets, byId, opts) {
     const rows = [];
     for (const target of targets) {
-        for (const locale of localesOf(target, opts.locales)) {
+        for (const locale of Object.keys(target.locales)) {
             rows.push({ kind: "page", id: target.id, locale, path: pagePath(target, byId, locale, opts) });
         }
     }
@@ -70,26 +97,32 @@ export function collectionSegment(path, locale, set) {
 }
 /** The "claims a URL" predicate (§1): a slug is only a real segment when
  * it is a non-empty string — absent, null, or `""` all mean "no URL".
- * The sibling index predicate in sql.ts (`entries_sibling_slug_key`)
- * mirrors this rule exactly, so Postgres and memory agree on which
+ * There is no sibling-slug index: sibling uniqueness is the primary key
+ * of `paths` plus the pre-check each store makes per locale before it
+ * writes (spec 2026-09-06 §12), so Postgres and memory agree on which
  * entries can collide. */
 export const slugOf = (fields) => {
     const slug = fields.slug;
     return typeof slug === "string" && slug.length > 0 ? slug : null;
 };
-export function entrySegment(entry, locale, set) {
-    const own = locale === set.default ? undefined : entry.i18n?.[locale]?.slug;
-    return typeof own === "string" && own.length > 0 ? own : slugOf(entry.fields);
+/** The entry's segment in one locale: its row's slug. An absent locale
+ *  or a slug-less row is null — no URL there, never a fallback. */
+export function entrySegment(entry, locale) {
+    return entry.locales[locale]?.slug ?? null;
 }
+/** One row per locale the target EXISTS in, where the whole chain has a
+ *  segment in that locale. The stores' parent rule guarantees an ancestor
+ *  is present wherever a descendant is; an ancestor without a slug there
+ *  simply yields no URL for the subtree in that locale. */
 export function entryPathRows(targets, byId, collection, set) {
     const rows = [];
     for (const target of targets) {
         const chain = chainOf(target, byId);
-        for (const locale of localesOf(target, set)) {
+        for (const locale of Object.keys(target.locales)) {
             const base = collectionSegment(collection.path, locale, set);
             if (base === null)
                 continue;
-            const segments = chain.map((e) => entrySegment(e, locale, set));
+            const segments = chain.map((e) => entrySegment(e, locale));
             if (segments.some((s) => s === null))
                 continue;
             rows.push({ kind: "entry", id: target.id, locale, path: joinPath([base, ...segments]) });
@@ -103,7 +136,7 @@ export function buildPageTree(records, locale, opts) {
         .filter((r) => r.parentId === parentId)
         .map((r) => ({
         record: r,
-        path: pagePath(r, byId, locale, opts),
+        path: pagePathIn(r, byId, locale, opts),
         children: build(r.id),
     }));
     return build(null);

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]);
@@ -32,7 +36,8 @@ export async function affectedTargets(stores, entryId, options = {}) {
     const published = [];
     for (const id of pageIds) {
         const page = await stores.pages.getPage(id);
-        if (page?.publishedVersionId)
+        // Published in ANY locale: the tag covers every locale's cached unit.
+        if (page && Object.values(page.locales).some((l) => l.status === "published"))
             published.push(id);
     }
     return { pageIds: published, entryIds };

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 } : {}),
+    };
+}