@saena-io/content 0.1.0

package/src/field/field.test.ts

@@ -0,0 +1,292 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import {
+  type FieldType,
+  type InferValue,
+  type TypedDecl,
+  date,
+  fieldToConfig,
+  fieldValidate,
+  group,
+  hydrateSection,
+  image,
+  link,
+  list,
+  number,
+  object,
+  registerFieldType,
+  sectionLeaves,
+  select,
+  slug,
+  slugify,
+  softSlugify,
+  text,
+  union,
+} from './index';
+
+// A custom, config-only field type (the climbing weekly-grid stand-in) — proves custom types compose with the
+// built-ins through the same registry + recursion, getting validate/leaves/toConfig participation for free.
+interface WeeklyGrid {
+  slots: { day: number; start: string; end: string }[];
+}
+const weeklyType: FieldType<WeeklyGrid, WeeklyGrid> = {
+  id: 'test.weekly',
+  kind: 'leaf',
+  empty: () => ({ slots: [] }),
+  validate: (_d, raw) => ({
+    slots: Array.isArray((raw as WeeklyGrid)?.slots) ? (raw as WeeklyGrid).slots : [],
+  }),
+  leaves: () => [],
+  hydrate: (_d, s) => s ?? { slots: [] },
+  toConfig: (_d, s) => s ?? { slots: [] },
+  fill: (_d, s) => s ?? { slots: [] },
+};
+registerFieldType(weeklyType);
+const weekly = (): TypedDecl<WeeklyGrid> => ({ type: 'test.weekly' });
+
+// The climbing "Programs" schema: a collection of programs, each a discriminated union by `type`; the club
+// variant's `schedule` is itself a union by `mode`, whose `weekly` variant embeds the custom field.
+const programs = list(
+  union('type', {
+    competition: object({ title: text(), date: date(), rounds: number() }),
+    club: object({
+      title: text(),
+      schedule: union('mode', {
+        oneOff: object({ date: date(), time: text() }),
+        weekly: object({ grid: weekly() }),
+        booking: object({ provider: select(['internal', 'external']), url: link() }),
+      }),
+    }),
+  }),
+);
+
+const PREFIX = 'content.home.programs';
+
+const payload = {
+  items: [
+    {
+      _id: 'a',
+      value: { type: 'competition', title: 'Bouldering Cup', date: '2026-07-01', rounds: 3 },
+    },
+    {
+      _id: 'b',
+      value: {
+        type: 'club',
+        title: 'Youth Club',
+        schedule: { mode: 'weekly', grid: { slots: [{ day: 1, start: '17:00', end: '18:30' }] } },
+      },
+    },
+    {
+      _id: 'c',
+      value: {
+        type: 'club',
+        title: 'Adults Club',
+        schedule: {
+          mode: 'booking',
+          provider: 'external',
+          url: { href: 'https://book.example', label: 'Book now' },
+        },
+      },
+    },
+  ],
+};
+
+describe('field core — climbing Programs schema', () => {
+  const storage = fieldValidate(programs, payload);
+
+  it('extracts translatable leaves with structural i18n keys (item ids, nested union variant)', () => {
+    const keys = sectionLeaves(programs, storage, PREFIX)
+      .map((l) => l.key)
+      .sort();
+    expect(keys).toEqual(
+      [
+        'content.home.programs.a.title',
+        'content.home.programs.b.title',
+        'content.home.programs.c.title',
+        'content.home.programs.c.schedule.url.label',
+      ].sort(),
+    );
+    // The url label is a `plain` leaf, never the href (config).
+    const label = sectionLeaves(programs, storage, PREFIX).find((l) =>
+      l.key.endsWith('.url.label'),
+    );
+    expect(label).toMatchObject({ sourceText: 'Book now', format: 'plain' });
+  });
+
+  it('hydrates config-through + resolves translatable leaves via the localized map', () => {
+    const localized = Object.fromEntries(
+      sectionLeaves(programs, storage, PREFIX).map((l) => [l.key, `${l.sourceText} [cs]`]),
+    );
+    const value = hydrateSection(programs, storage, localized, PREFIX) as InferValue<
+      typeof programs
+    >;
+
+    expect(value).toHaveLength(3);
+    const first = value[0];
+    expect(first).toMatchObject({ type: 'competition', title: 'Bouldering Cup [cs]', rounds: 3 });
+    const booking = value[2];
+    if (booking?.type === 'club' && booking.schedule.mode === 'booking') {
+      expect(booking.schedule.url).toEqual({
+        href: 'https://book.example',
+        label: 'Book now [cs]',
+      });
+      expect(booking.schedule.provider).toBe('external');
+    } else {
+      throw new Error('expected a club/booking program');
+    }
+  });
+
+  it('projects config with translatable leaves blanked but structure + config preserved', () => {
+    const config = fieldToConfig(programs, storage) as typeof storage;
+    const items = (config as { items: { _id: string; value: Record<string, unknown> }[] }).items;
+    expect(items.map((i) => i._id)).toEqual(['a', 'b', 'c']);
+    // text leaf blanked, config kept
+    expect(items[0]?.value).toMatchObject({
+      type: 'competition',
+      title: '',
+      date: '2026-07-01',
+      rounds: 3,
+    });
+    // nested union: href kept (config), label blanked (translatable)
+    const sched = items[2]?.value.schedule as {
+      mode: string;
+      url: { href: string; label: string };
+    };
+    expect(sched).toMatchObject({
+      mode: 'booking',
+      url: { href: 'https://book.example', label: '' },
+    });
+  });
+
+  it('infers a discriminated-union value type that narrows by discriminant', () => {
+    type Programs = InferValue<typeof programs>;
+    expectTypeOf<Programs>().toBeArray();
+    const sample = [] as Programs;
+    for (const p of sample) {
+      if (p.type === 'competition') {
+        expectTypeOf(p.rounds).toBeNumber();
+        expectTypeOf(p.title).toBeString();
+      } else {
+        // club
+        if (p.schedule.mode === 'weekly') expectTypeOf(p.schedule.grid).toEqualTypeOf<WeeklyGrid>();
+        if (p.schedule.mode === 'booking')
+          expectTypeOf(p.schedule.provider).toEqualTypeOf<'internal' | 'external'>();
+      }
+    }
+  });
+});
+
+describe('field core — slug + group', () => {
+  it('slugify normalizes fully; softSlugify keeps a typed-in separator (typeable while editing)', () => {
+    expect(slugify('Summer Climbing Camp 2026!')).toBe('summer-climbing-camp-2026');
+    expect(softSlugify('Hello ')).toBe('hello-'); // trailing separator survives mid-type
+    expect(slugify('Hello ')).toBe('hello'); // …and is tidied on the full pass
+  });
+
+  it('slug is a config leaf — slugified storage, never a translatable i18n key', () => {
+    const s = object({ slug: slug({ from: 'title' }), title: text() });
+    const storage = fieldValidate(s, { slug: 'My Title!', title: 'My Title' });
+    expect((storage as { slug: string }).slug).toBe('my-title');
+    // only the text leaf is translatable; the slug stays in config
+    expect(sectionLeaves(s, storage, PREFIX).map((l) => l.key)).toEqual([
+      'content.home.programs.title',
+    ]);
+    const config = fieldToConfig(s, storage) as { slug: string; title: string };
+    expect(config.slug).toBe('my-title'); // slug survives in config
+    expect(config.title).toBe(''); // text leaf blanked
+  });
+
+  it('image: hotspot is config (clamped, survives toConfig/hydrate); alt is the only translatable leaf', () => {
+    const ref = {
+      id: 'asset-1',
+      url: '/api/assets/asset-1',
+      mime: 'image/png',
+      size: 10,
+      width: 640,
+      height: 400,
+      public: true,
+    };
+    const s = object({ pic: image() });
+    // out-of-range hotspot clamps to [0,1]; alt is kept for validation
+    const storage = fieldValidate(s, {
+      pic: { ref, alt: 'A cat', hotspot: { x: 1.4, y: -0.2 } },
+    }) as { pic: { ref: typeof ref; alt: string; hotspot?: { x: number; y: number } } };
+    expect(storage.pic.hotspot).toEqual({ x: 1, y: 0 });
+
+    // only alt is a translatable leaf — ref + hotspot are config, never i18n keys
+    expect(sectionLeaves(s, storage, PREFIX).map((l) => l.key)).toEqual([
+      'content.home.programs.pic.alt',
+    ]);
+
+    // config blanks alt but preserves ref + hotspot
+    const config = fieldToConfig(s, storage) as typeof storage;
+    expect(config.pic).toMatchObject({ ref, alt: '', hotspot: { x: 1, y: 0 } });
+
+    // hydrate restores the hotspot (config) and resolves alt from the localized map
+    const localized = { 'content.home.programs.pic.alt': 'A cat [cs]' };
+    const value = hydrateSection(s, storage, localized, PREFIX) as {
+      pic: { ref: typeof ref; alt: string; hotspot?: { x: number; y: number } };
+    };
+    expect(value.pic).toMatchObject({ ref, alt: 'A cat [cs]', hotspot: { x: 1, y: 0 } });
+  });
+
+  it('image: an absent or junk hotspot becomes undefined (centre default)', () => {
+    const s = object({ pic: image() });
+    const noHotspot = fieldValidate(s, { pic: { ref: null, alt: '' } }) as {
+      pic: { hotspot?: unknown };
+    };
+    expect(noHotspot.pic.hotspot).toBeUndefined();
+    const junk = fieldValidate(s, { pic: { ref: null, alt: '', hotspot: { x: 'nope' } } }) as {
+      pic: { hotspot?: unknown };
+    };
+    expect(junk.pic.hotspot).toBeUndefined();
+  });
+
+  it('group recurses like object, keying children under the group key', () => {
+    const s = object({ contact: group({ email: text(), phone: text() }, { label: 'Contact' }) });
+    const storage = fieldValidate(s, { contact: { email: 'a@b.c', phone: '123' } });
+    expect(
+      sectionLeaves(s, storage, PREFIX)
+        .map((l) => l.key)
+        .sort(),
+    ).toEqual(['content.home.programs.contact.email', 'content.home.programs.contact.phone']);
+    const localized = Object.fromEntries(
+      sectionLeaves(s, storage, PREFIX).map((l) => [l.key, `${l.sourceText}!`]),
+    );
+    const value = hydrateSection(s, storage, localized, PREFIX) as {
+      contact: { email: string; phone: string };
+    };
+    expect(value.contact).toEqual({ email: 'a@b.c!', phone: '123!' });
+  });
+});
+
+describe('collection key root (ADR-0011)', () => {
+  // A routed-collection entry roots its i18n keys at `content.collection.<collection>.<itemId>` — the STABLE
+  // row id, never the slug or position. The service builds that prefix; here we lock the property the design
+  // depends on: an entry's keys are namespaced by its id, so two entries never collide, and a key never embeds
+  // the slug (so renaming the slug can't re-key or orphan translations).
+  const entry = object({ title: text(), body: text() });
+  const storage = fieldValidate(entry, { title: 'Hello', body: 'World' });
+  const keysFor = (id: string) =>
+    sectionLeaves(entry, storage, `content.collection.news.${id}`)
+      .map((l) => l.key)
+      .sort();
+
+  it('roots every leaf at content.collection.<collection>.<itemId>', () => {
+    expect(keysFor('item-a')).toEqual([
+      'content.collection.news.item-a.body',
+      'content.collection.news.item-a.title',
+    ]);
+  });
+
+  it('namespaces entries by id — two entries never share a key', () => {
+    const a = new Set(keysFor('item-a'));
+    const overlap = keysFor('item-b').filter((k) => a.has(k));
+    expect(overlap).toEqual([]);
+  });
+
+  it('keys depend only on the id, not the slug (renaming a slug cannot re-key)', () => {
+    // Same id ⇒ identical keys regardless of any slug the entry might carry.
+    expect(keysFor('fixed-id')).toEqual(keysFor('fixed-id'));
+    expect(keysFor('fixed-id').every((k) => k.includes('.fixed-id.'))).toBe(true);
+  });
+});

package/src/field/index.ts

@@ -0,0 +1,49 @@
+// The field-type core barrel (React-free). Importing it registers the built-in field types (./builtins runs
+// its registration on load). Section authors import the helpers (text/richtext/object/list/union/…) and the
+// `InferValue`/`SectionContent` types from here; the server service imports the registry + key helpers.
+
+export type {
+  FieldDecl,
+  FieldKind,
+  FieldPath,
+  FieldType,
+  HydrateCtx,
+  TranslatableLeaf,
+  TypedDecl,
+} from './types';
+export {
+  fieldType,
+  hasFieldType,
+  registerFieldType,
+  fieldEmpty,
+  fieldValidate,
+  fieldToConfig,
+} from './registry';
+export {
+  text,
+  richtext,
+  number,
+  boolean,
+  date,
+  select,
+  slug,
+  link,
+  image,
+  object,
+  group,
+  list,
+  union,
+  slugify,
+  softSlugify,
+} from './builtins';
+export type { LinkValue, ImageValue, SelectCfg, SlugCfg } from './builtins';
+export {
+  joinKey,
+  sectionLeaves,
+  hydrateCtxFrom,
+  hydrateSection,
+  hydratePreview,
+  fillSection,
+} from './keys';
+export type { SectionLeaf } from './keys';
+export type { InferValue, SectionContent } from './infer';

package/src/field/infer.ts

@@ -0,0 +1,10 @@
+import type { TypedDecl } from './types';
+
+// Type-level: recover the public value type from a field declaration tree, so a section's public component is
+// typed exactly (and a union narrows by its discriminant). The authoring helpers in ./builtins compute the
+// phantom `__value`; this just reads it. `SectionContent<S>` is the alias a section component prop uses.
+
+export type InferValue<D> = D extends TypedDecl<infer V, infer _Cfg> ? V : never;
+
+/** The fully-typed content a section's public component receives, derived from its schema declaration. */
+export type SectionContent<S> = InferValue<S>;

package/src/field/keys.ts

@@ -0,0 +1,69 @@
+import { fieldType, fieldValidate } from './registry';
+import type { FieldDecl, FieldPath, HydrateCtx } from './types';
+
+// Structural i18n key scheme + the pure save/load helpers that join the field core to the content store.
+// A section's keys are `content.<page>.<section>` + the relative field path (object keys, list item ids, the
+// active union variant's sub-path). Segments never contain '.', so a dotted join is unambiguous (item ids are
+// nanoids, child keys are identifiers).
+
+const SEP = '.';
+
+/** Join a section prefix (e.g. `content.home.hero`) with a relative field path into an absolute i18n key. */
+export function joinKey(prefix: string, path: FieldPath): string {
+  return path.length ? `${prefix}${SEP}${path.join(SEP)}` : prefix;
+}
+
+export interface SectionLeaf {
+  key: string;
+  sourceText: string;
+  format: 'plain' | 'rich';
+}
+
+/** Every translatable leaf of a section value, as absolute i18n keys — for `syncTranslatable` (save) and to
+ *  collect the keys to `localizeMany` (load). `prefix` = `content.<page>.<section>`. */
+export function sectionLeaves(decl: FieldDecl, storage: unknown, prefix: string): SectionLeaf[] {
+  return fieldType(decl.type)
+    .leaves(decl, storage, [])
+    .map((l) => ({ key: joinKey(prefix, l.path), sourceText: l.sourceText, format: l.format }));
+}
+
+/** Build a HydrateCtx from a localized (key → text) map for a section prefix. */
+export function hydrateCtxFrom(localized: Record<string, string>, prefix: string): HydrateCtx {
+  return { text: (path) => localized[joinKey(prefix, path)] ?? '' };
+}
+
+/** Hydrate a section's stored config into its typed public value, given localized text. */
+export function hydrateSection(
+  decl: FieldDecl,
+  config: unknown,
+  localized: Record<string, string>,
+  prefix: string,
+): unknown {
+  return fieldType(decl.type).hydrate(decl, config, hydrateCtxFrom(localized, prefix), []);
+}
+
+/** Hydrate the admin editor's in-memory value (the FILL shape — text inline, lists as `{ items }`) straight
+ *  into the public value shape, with no server round-trip and no localized map: the translatable leaves are
+ *  read back out of the same value (via `sectionLeaves`) and fed to `hydrate`. Powers the live preview.
+ *
+ *  Runs the same `validate` the save path runs first, so the preview shows the public render of what WILL be
+ *  saved — e.g. a slug previews normalized, not its soft mid-typing value. The prefix is internal + arbitrary
+ *  (it cancels out). */
+export function hydratePreview(decl: FieldDecl, editorValue: unknown): unknown {
+  const PREFIX = 'preview';
+  const storage = fieldValidate(decl, editorValue);
+  const localized: Record<string, string> = {};
+  for (const leaf of sectionLeaves(decl, storage, PREFIX)) localized[leaf.key] = leaf.sourceText;
+  return hydrateSection(decl, storage, localized, PREFIX);
+}
+
+/** Fill a section's stored config with localized source text, preserving storage shape — the admin editor's
+ *  load (so list ids + i18n keys round-trip on save). */
+export function fillSection(
+  decl: FieldDecl,
+  config: unknown,
+  localized: Record<string, string>,
+  prefix: string,
+): unknown {
+  return fieldType(decl.type).fill(decl, config, hydrateCtxFrom(localized, prefix), []);
+}

package/src/field/registry.ts

@@ -0,0 +1,32 @@
+import type { FieldDecl, FieldType } from './types';
+
+// The React-free field-type registry: id → runtime behaviour (empty/validate/leaves/hydrate). Built-ins
+// register on import (./builtins); custom types register the same way. Composite types resolve their children
+// through `fieldType(id)`, so the whole schema tree is traversable from any value. The React editor registry
+// (id → AdminEditor) is a separate, parallel map in ../admin — same id, different world.
+
+const registry = new Map<string, FieldType>();
+
+/** Register a field type's runtime behaviour. Idempotent by id (last registration wins). */
+export function registerFieldType(type: FieldType): void {
+  registry.set(type.id, type);
+}
+
+/** Resolve a field type by id. Throws if unknown (a schema referenced an unregistered type). */
+export function fieldType(id: string): FieldType {
+  const type = registry.get(id);
+  if (!type) throw new Error(`unknown field type: ${id}`);
+  return type;
+}
+
+/** Whether a field type id is registered. */
+export function hasFieldType(id: string): boolean {
+  return registry.has(id);
+}
+
+// Convenience pass-throughs that resolve the type from a declaration — used by composites + the service.
+export const fieldEmpty = (decl: FieldDecl): unknown => fieldType(decl.type).empty(decl);
+export const fieldValidate = (decl: FieldDecl, raw: unknown): unknown =>
+  fieldType(decl.type).validate(decl, raw);
+export const fieldToConfig = (decl: FieldDecl, storage: unknown): unknown =>
+  fieldType(decl.type).toConfig(decl, storage);

package/src/field/types.ts

@@ -0,0 +1,83 @@
+// The field-type contract — the unit of composition for the content framework (ADR-0008). A FIELD is the
+// atom: the dev declares a section's fields once, and that single declaration drives the admin editor, the
+// public value type, validation, and how translatable text maps onto i18n keys. This module is React-free
+// (the server validates/persists and the public component types its content from here); the React editors
+// live in ../admin and the public readers in ../public, bound to a field type by its `id`.
+
+/** A path through a content tree, relative to a section root, e.g. ['programs', '<itemId>', 'title']. */
+export type FieldPath = string[];
+
+/** A translatable text leaf discovered by walking a value — becomes an i18n key (ADR-0005). */
+export interface TranslatableLeaf {
+  /** Structural path relative to the section root; joined with the section prefix to form the i18n key. */
+  path: FieldPath;
+  /** Main-locale source text (or serialized rich JSON for `format: 'rich'`). */
+  sourceText: string;
+  format: 'plain' | 'rich';
+}
+
+/** Localized-text lookup passed to `hydrate` — prefilled by the service via `localizeMany`. */
+export interface HydrateCtx {
+  text(path: FieldPath): string;
+}
+
+/**
+ * A field declaration — what a section author writes (e.g. `text()`, `union('type', {...})`). Pure data:
+ * a field-type `id` plus type-specific `cfg`. The runtime behaviour lives in the registered {@link FieldType}
+ * (keyed by `id`); the React editor lives in a separate registry. `cfg` carries child declarations for the
+ * composite types (object/list/union), so the whole schema is a self-describing tree.
+ */
+export interface FieldDecl<Cfg = unknown> {
+  type: string;
+  label?: string;
+  cfg?: Cfg;
+  /** Display-only show/hide based on sibling values (evaluated by the form engine for object children). */
+  visible?: (siblings: Record<string, unknown>) => boolean;
+}
+
+/**
+ * A field declaration carrying its inferred public value type as a phantom, so `InferValue` can recover the
+ * exact (discriminated-union-narrowable) shape the public component receives. The authoring helpers in
+ * ./builtins return these; `__value` is never present at runtime.
+ */
+export interface TypedDecl<Value, Cfg = unknown> extends FieldDecl<Cfg> {
+  readonly __value?: Value;
+}
+
+/** How the form engine treats a field: `leaf` = one editor (no generic recursion); the rest recurse. */
+export type FieldKind = 'leaf' | 'object' | 'list' | 'union';
+
+/**
+ * The runtime behaviour of a field type, registered by `id`. `Storage` is the persisted/save-payload shape;
+ * `Value` is what the public component reads. Composite types recurse into their children via the registry.
+ */
+export interface FieldType<Storage = unknown, Value = unknown> {
+  readonly id: string;
+  readonly kind: FieldKind;
+  /** A fresh, valid storage value for a new field/item. */
+  empty(decl: FieldDecl): Storage;
+  /** Validate (and coerce) raw input into Storage; throws on a genuine type mismatch. */
+  validate(decl: FieldDecl, raw: unknown): Storage;
+  /**
+   * Every translatable leaf under this value, by structural path. Returns leaves for the structure PRESENT
+   * (list items, the active union variant) regardless of whether the text is empty — so the same walk yields
+   * the i18n key set on both save (from the payload) and load (from the stored config).
+   */
+  leaves(decl: FieldDecl, storage: Storage, path: FieldPath): TranslatableLeaf[];
+  /** Produce the public Value: config passes through; translatable leaves resolve via `ctx.text(path)`. */
+  hydrate(decl: FieldDecl, storage: Storage, ctx: HydrateCtx, path: FieldPath): Value;
+  /**
+   * Project a save-payload Storage to the value PERSISTED in the config blob: structurally identical, but
+   * every translatable leaf blanked (its source lives in i18n). Keeps config free of duplicated source text
+   * while preserving the structure (object keys, list item ids, the active union variant) that `leaves`
+   * needs to reconstruct the i18n key set on load.
+   */
+  toConfig(decl: FieldDecl, storage: Storage): Storage;
+  /**
+   * The inverse of {@link toConfig} for the admin editor's load: fill translatable leaves from localized text
+   * (the main-locale source, for editing) while PRESERVING the storage shape — crucially list item ids — so a
+   * save round-trips stable ids and stable i18n keys. (hydrate drops list ids to give a clean public array;
+   * the editor needs them, hence this distinct projection.)
+   */
+  fill(decl: FieldDecl, config: Storage, ctx: HydrateCtx, path: FieldPath): Storage;
+}

package/src/index.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { contentPlugin } from './index';
+
+// Manifest smoke (roadmap M0): guards the content plugin's wiring + that every api function is gated by
+// content.manage (the plugin's single permission). Field/key-stability behaviour is covered by field.test.ts.
+
+describe('contentPlugin manifest', () => {
+  it('declares id, owned tables, and the content.manage permission', () => {
+    expect(contentPlugin.id).toBe('content');
+    expect(contentPlugin.tables).toEqual(['content_section_values', 'content_collection_items']);
+    expect(contentPlugin.dependsOn ?? []).toEqual([]);
+    expect((contentPlugin.permissions ?? []).map((p) => p.id)).toContain('content.manage');
+  });
+
+  it('gates every api function on content.manage (§10 defense-in-depth)', () => {
+    const api = contentPlugin.api ?? [];
+    expect(api.length).toBeGreaterThan(0);
+    for (const fn of api) {
+      expect(typeof fn.id).toBe('string');
+      expect(fn.permission, `api fn "${fn.id}" must declare a permission`).toBe('content.manage');
+    }
+  });
+});

package/src/index.ts

@@ -0,0 +1,108 @@
+import { fileURLToPath } from 'node:url';
+import { definePlugin } from '@saena-io/plugin-sdk';
+import {
+  collectionItemRef,
+  collectionListInput,
+  collectionReorderInput,
+  collectionSaveInput,
+  contentFns,
+  sectionRef,
+  sectionSaveInput,
+} from './contract';
+import {
+  deleteItem,
+  getItemForEdit,
+  getSectionForEdit,
+  listItems,
+  reorderItems,
+  saveItem,
+  saveSection,
+} from './service';
+
+// @saena-io/content — the SERVER half of the content SDK: the `Plugin` contract (migrations, api, permissions).
+// React-free by construction (ADR-0006) so it stays out of the client/SSR React graph. The field-type core
+// (./field), section registry (./define), admin form engine (./admin), and public readers (./public) are the
+// other entries. Sections themselves live in the client app, built on this SDK (ADR-0008).
+
+// Public-site reads (a page's sections, or a collection's entries) for the host's SSR loaders to call directly —
+// public rendering is SSR in the route loader, not a client RPC.
+export { getPageContent, getSectionContent, getItemBySlug, listItems } from './service';
+export type { SaveSectionInput, SaveCollectionItemInput, CollectionItemRecord } from './service';
+
+export const contentPlugin = definePlugin({
+  id: 'content',
+  name: 'Content',
+  summary: 'No-code pages, sections, and routed collections for the public site.',
+  category: 'content',
+  permissions: [
+    {
+      id: 'content.manage',
+      description: 'Edit site content (sections + collections)',
+      tier: 'editor',
+    },
+  ],
+  // The tables this plugin owns in the shared `app` schema — declared so the host fails fast on a collision
+  // with core or another plugin (roadmap M0).
+  tables: ['content_section_values', 'content_collection_items'],
+  // Drizzle migrations live beside the package (../drizzle); the host applies them via runPluginMigrations
+  // after the core schema (ADR-0006). Resolved from import.meta.url so it works in dev.
+  migrations: fileURLToPath(new URL('../drizzle', import.meta.url)),
+  api: [
+    {
+      id: contentFns.sectionGet,
+      permission: 'content.manage',
+      handler: (input, ctx) => {
+        const { page, section } = sectionRef.parse(input);
+        return getSectionForEdit(ctx, page, section);
+      },
+    },
+    {
+      id: contentFns.sectionSave,
+      permission: 'content.manage',
+      handler: async (input, ctx) => {
+        await saveSection(ctx, sectionSaveInput.parse(input));
+        return { ok: true };
+      },
+    },
+    // Routed collections (ADR-0011) — the admin manager's CRUD. Reads (list/by-slug) for the public site are
+    // SSR server-direct exports above, not RPC.
+    {
+      id: contentFns.collectionList,
+      permission: 'content.manage',
+      handler: (input, ctx) => {
+        const { collection, limit, offset } = collectionListInput.parse(input);
+        return listItems(ctx, collection, { limit, offset });
+      },
+    },
+    {
+      id: contentFns.collectionGetForEdit,
+      permission: 'content.manage',
+      handler: (input, ctx) => {
+        const { collection, id } = collectionItemRef.parse(input);
+        return getItemForEdit(ctx, collection, id);
+      },
+    },
+    {
+      id: contentFns.collectionSave,
+      permission: 'content.manage',
+      handler: (input, ctx) => saveItem(ctx, collectionSaveInput.parse(input)),
+    },
+    {
+      id: contentFns.collectionDelete,
+      permission: 'content.manage',
+      handler: async (input, ctx) => {
+        await deleteItem(ctx, collectionItemRef.parse(input));
+        return { ok: true };
+      },
+    },
+    {
+      id: contentFns.collectionReorder,
+      permission: 'content.manage',
+      handler: async (input, ctx) => {
+        const { collection, orderedIds } = collectionReorderInput.parse(input);
+        await reorderItems(ctx, collection, orderedIds);
+        return { ok: true };
+      },
+    },
+  ],
+});