@velastack/cms 0.4.0 → 0.5.1

package/dist/core/structured.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Structured values: the shapes behind the editor components (hours, team,
+ * testimonials, …) and the two rules every one of them follows.
+ *
+ * 1. **Versioned shapes, whole-object writes.** A structured value is a plain
+ *    object with a `v` version number. Components never patch a leaf inside
+ *    it; they read the whole value through the schema's `normalize`, change
+ *    it, and write the whole object back. A field the editor clears is
+ *    written as `null`, never dropped: the draft and release trees deep-merge
+ *    over the published tree, and a missing key merges to "unchanged" while
+ *    `null` merges to "cleared". That is what stops a cleared field from
+ *    reverting to the template's demo copy.
+ *
+ * 2. **Localisation is a string overlay, never a second structure.** The
+ *    default locale stores the full value at `<name>`. Every other locale
+ *    stores only strings, at `<name>.$t.<id>.<field>`, keyed by the stable
+ *    `id` of the list item they translate (the reserved id `_` addresses the
+ *    value's own root fields). Because objects deep-merge across locales,
+ *    reading `es` yields the default structure plus the `es` overlay, and
+ *    {@link applyTranslations} folds the strings in. Structure edits happen in
+ *    the default locale only, so the item list can never fork between
+ *    languages.
+ */
+import { type Tree } from './path.js';
+/** Branch under a structured value that holds a locale's string overlay. */
+export declare const TRANSLATIONS_KEY = "$t";
+/** Overlay id that addresses the structured value's root fields. */
+export declare const ROOT_ID = "_";
+/** `{ [itemId]: { [field]: string } }` — what a non-default locale stores. */
+export type TranslationOverlay = Record<string, Record<string, string>>;
+export type StructuredItem = {
+    id: string;
+} & Record<string, unknown>;
+/**
+ * One list of items inside a structured value. `key` names the array field,
+ * `translatable` the item fields holding translatable text (a string, or an
+ * array of strings, translated per index as `<field>.<i>`), and `items` any
+ * lists nested inside each item (a collection item's `details`, a pricing
+ * tier's `features`). Every item at every level carries a stable `id`.
+ */
+export type ItemsSpec = {
+    key: string;
+    translatable: readonly string[];
+    items?: ItemsSpec | readonly ItemsSpec[];
+};
+export type StructuredSchema<T extends Tree> = {
+    /** Exported component name, e.g. `'CmsHours'`. Recorded in the manifest. */
+    component: string;
+    /** Current shape version, written as `v` on every value. */
+    version: number;
+    /** Root-level fields holding translatable strings, e.g. `['note']`. A
+     * dotted path addresses a nested field (`'labels.closed'`). */
+    translatable: readonly string[];
+    /** The value's item lists, when it has any, and the item fields that translate. */
+    items?: ItemsSpec | readonly ItemsSpec[];
+    /**
+     * Turn anything the store may hold — an older version, a hand-seeded
+     * partial object, garbage — into the current shape. Must never throw.
+     */
+    normalize: (raw: unknown) => T;
+    /** The cleared value: what an editor gets after "Clear". */
+    empty: () => T;
+};
+export type Structured<T extends Tree> = StructuredSchema<T> & {
+    /**
+     * Resolve a stored value the way a display component reads it:
+     * `undefined` (nothing stored) → the fallback; `null` (cleared) → empty;
+     * anything else → normalized, with the locale overlay applied.
+     */
+    read: (raw: unknown, fallback: T | undefined) => T;
+};
+export declare const isPlainObject: (v: unknown) => v is Tree;
+export declare const defineStructured: <T extends Tree>(schema: StructuredSchema<T>) => Structured<T>;
+/** Path of one translated string: `<name>.$t.<id>.<field>`. */
+export declare const translationPath: (name: string, id: string, field: string) => string;
+/** The `$t` branch of a stored value, when it is one. A dotted field
+ * (`labels.closed`, `tags.0`) is stored nested by the path-based writes and
+ * read back flat here. */
+export declare const extractTranslations: (raw: unknown) => TranslationOverlay | undefined;
+/** A copy of `raw` without its `$t` branch, so a whole-object write in the
+ * default locale never carries another locale's strings. */
+export declare const stripTranslations: (raw: unknown) => unknown;
+/** `set` that copies along the path instead of mutating shared branches. */
+export declare const setIn: (obj: Tree, path: string, value: unknown) => Tree;
+/**
+ * Fold a locale's string overlay into a normalized default-locale value.
+ * Root fields come from the `_` id; item fields from the item's own `id`,
+ * at every nesting level. Only non-empty strings override, so an
+ * untranslated field shows the default-locale text rather than a blank.
+ */
+export declare const applyTranslations: <T extends Tree>(value: T, overlay: TranslationOverlay | undefined, schema: Pick<StructuredSchema<T>, "translatable" | "items">) => T;
+export type TranslatableField = {
+    /** Overlay id: an item id, or `_` for a root field. */
+    id: string;
+    /** Field path within the object the id addresses (`note`, `labels.closed`, `tags.0`). */
+    field: string;
+    /** The default-locale string being translated. */
+    source: string;
+};
+/**
+ * Every translatable, non-empty string in a normalized default-locale value.
+ * Drives the popover's translation tab and the Locales panel's counts.
+ */
+export declare const translatableFields: <T extends Tree>(value: T, schema: Pick<StructuredSchema<T>, "translatable" | "items">) => TranslatableField[];
+/** How many translatable strings a locale's overlay still lacks. */
+export declare const countTranslations: <T extends Tree>(value: T, overlay: TranslationOverlay | undefined, schema: Pick<StructuredSchema<T>, "translatable" | "items">) => {
+    total: number;
+    missing: number;
+};
+export declare const asString: (v: unknown, fallback?: string) => string;
+export declare const asNumber: (v: unknown, fallback?: number | null) => number | null;
+export declare const asBoolean: (v: unknown, fallback?: boolean) => boolean;
+/**
+ * Normalize a list of items, guaranteeing every item carries a string `id`.
+ * An item without one (a hand-written seed, say) gets a deterministic
+ * `item-<index>` so reads stay stable until the editor next writes the list,
+ * at which point the ids are persisted.
+ */
+export declare const asItems: <I extends StructuredItem>(raw: unknown, normalizeItem: (item: Tree, index: number) => Omit<I, "id">) => I[];
+/** A short random id for a newly added item. Stable once written. */
+export declare const newItemId: () => string;
+/** Read a structured value's overlay for one locale out of a whole scope tree. */
+export declare const overlayAt: (tree: Tree | undefined, name: string) => TranslationOverlay | undefined;
+/** A list of strings; anything else is dropped. */
+export declare const asStrings: (v: unknown) => string[];
+/** A nullable string: `null` (cleared) stays `null`; anything else is a string. */
+export declare const asOptionalString: (v: unknown) => string | null;
+/** One of a fixed set of strings, else the fallback. */
+export declare const asEnum: <E extends string>(v: unknown, values: readonly E[], fallback: E) => E;
+/** Move an item within a list, returning a new list. */
+export declare const moveItem: <I>(list: readonly I[], from: number, to: number) => I[];

package/dist/core/structured.js

@@ -0,0 +1,235 @@
+/**
+ * Structured values: the shapes behind the editor components (hours, team,
+ * testimonials, …) and the two rules every one of them follows.
+ *
+ * 1. **Versioned shapes, whole-object writes.** A structured value is a plain
+ *    object with a `v` version number. Components never patch a leaf inside
+ *    it; they read the whole value through the schema's `normalize`, change
+ *    it, and write the whole object back. A field the editor clears is
+ *    written as `null`, never dropped: the draft and release trees deep-merge
+ *    over the published tree, and a missing key merges to "unchanged" while
+ *    `null` merges to "cleared". That is what stops a cleared field from
+ *    reverting to the template's demo copy.
+ *
+ * 2. **Localisation is a string overlay, never a second structure.** The
+ *    default locale stores the full value at `<name>`. Every other locale
+ *    stores only strings, at `<name>.$t.<id>.<field>`, keyed by the stable
+ *    `id` of the list item they translate (the reserved id `_` addresses the
+ *    value's own root fields). Because objects deep-merge across locales,
+ *    reading `es` yields the default structure plus the `es` overlay, and
+ *    {@link applyTranslations} folds the strings in. Structure edits happen in
+ *    the default locale only, so the item list can never fork between
+ *    languages.
+ */
+import { get, leafPaths } from './path.js';
+/** Branch under a structured value that holds a locale's string overlay. */
+export const TRANSLATIONS_KEY = '$t';
+/** Overlay id that addresses the structured value's root fields. */
+export const ROOT_ID = '_';
+export const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+export const defineStructured = (schema) => ({
+    ...schema,
+    read: (raw, fallback) => {
+        if (raw === undefined)
+            return fallback === undefined ? schema.empty() : schema.normalize(fallback);
+        if (raw === null)
+            return schema.empty();
+        const overlay = extractTranslations(raw);
+        const value = schema.normalize(stripTranslations(raw));
+        return overlay ? applyTranslations(value, overlay, schema) : value;
+    }
+});
+/** Path of one translated string: `<name>.$t.<id>.<field>`. */
+export const translationPath = (name, id, field) => `${name}.${TRANSLATIONS_KEY}.${id}.${field}`;
+/** The `$t` branch of a stored value, when it is one. A dotted field
+ * (`labels.closed`, `tags.0`) is stored nested by the path-based writes and
+ * read back flat here. */
+export const extractTranslations = (raw) => {
+    if (!isPlainObject(raw))
+        return undefined;
+    const t = raw[TRANSLATIONS_KEY];
+    if (!isPlainObject(t))
+        return undefined;
+    const out = {};
+    for (const [id, fields] of Object.entries(t)) {
+        if (!isPlainObject(fields))
+            continue;
+        const strings = {};
+        for (const path of leafPaths(fields)) {
+            const v = get(fields, path);
+            if (typeof v === 'string')
+                strings[path] = v;
+        }
+        out[id] = strings;
+    }
+    return out;
+};
+/** A copy of `raw` without its `$t` branch, so a whole-object write in the
+ * default locale never carries another locale's strings. */
+export const stripTranslations = (raw) => {
+    if (!isPlainObject(raw) || !(TRANSLATIONS_KEY in raw))
+        return raw;
+    const { [TRANSLATIONS_KEY]: _omit, ...rest } = raw;
+    return rest;
+};
+const overlayString = (overlay, id, field) => {
+    const v = overlay[id]?.[field];
+    return typeof v === 'string' && v !== '' ? v : undefined;
+};
+const specList = (items) => items === undefined ? [] : Array.isArray(items) ? items : [items];
+const isStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === 'string');
+/** `set` that copies along the path instead of mutating shared branches. */
+export const setIn = (obj, path, value) => {
+    const [head, ...rest] = path.split('.');
+    const out = { ...obj };
+    if (rest.length === 0) {
+        out[head] = value;
+        return out;
+    }
+    const child = obj[head];
+    out[head] = setIn(isPlainObject(child) ? child : {}, rest.join('.'), value);
+    return out;
+};
+/**
+ * Fold a locale's string overlay into one object (the root value or an item)
+ * and, recursively, into the item lists it holds.
+ */
+const applyTo = (obj, id, translatable, items, overlay) => {
+    let out = { ...obj };
+    for (const field of translatable) {
+        const cur = get(obj, field);
+        if (typeof cur === 'string') {
+            const s = overlayString(overlay, id, field);
+            if (s !== undefined)
+                out = setIn(out, field, s);
+        }
+        else if (isStringArray(cur)) {
+            let changed = false;
+            const next = cur.map((v, i) => {
+                const s = overlayString(overlay, id, `${field}.${i}`);
+                if (s === undefined)
+                    return v;
+                changed = true;
+                return s;
+            });
+            if (changed)
+                out = setIn(out, field, next);
+        }
+    }
+    for (const spec of specList(items)) {
+        const list = obj[spec.key];
+        if (!Array.isArray(list))
+            continue;
+        out[spec.key] = list.map((item) => isPlainObject(item) && typeof item.id === 'string'
+            ? applyTo(item, item.id, spec.translatable, spec.items, overlay)
+            : item);
+    }
+    return out;
+};
+/**
+ * Fold a locale's string overlay into a normalized default-locale value.
+ * Root fields come from the `_` id; item fields from the item's own `id`,
+ * at every nesting level. Only non-empty strings override, so an
+ * untranslated field shows the default-locale text rather than a blank.
+ */
+export const applyTranslations = (value, overlay, schema) => {
+    if (!overlay)
+        return value;
+    return applyTo(value, ROOT_ID, schema.translatable, schema.items, overlay);
+};
+const collectFrom = (obj, id, translatable, items, out) => {
+    for (const field of translatable) {
+        const cur = get(obj, field);
+        if (typeof cur === 'string') {
+            if (cur !== '')
+                out.push({ id, field, source: cur });
+        }
+        else if (isStringArray(cur)) {
+            cur.forEach((s, i) => {
+                if (s !== '')
+                    out.push({ id, field: `${field}.${i}`, source: s });
+            });
+        }
+    }
+    for (const spec of specList(items)) {
+        const list = obj[spec.key];
+        if (!Array.isArray(list))
+            continue;
+        for (const item of list) {
+            if (!isPlainObject(item) || typeof item.id !== 'string')
+                continue;
+            collectFrom(item, item.id, spec.translatable, spec.items, out);
+        }
+    }
+};
+/**
+ * Every translatable, non-empty string in a normalized default-locale value.
+ * Drives the popover's translation tab and the Locales panel's counts.
+ */
+export const translatableFields = (value, schema) => {
+    const out = [];
+    collectFrom(value, ROOT_ID, schema.translatable, schema.items, out);
+    return out;
+};
+/** How many translatable strings a locale's overlay still lacks. */
+export const countTranslations = (value, overlay, schema) => {
+    const fields = translatableFields(value, schema);
+    let missing = 0;
+    for (const f of fields) {
+        if (!overlay || overlayString(overlay, f.id, f.field) === undefined)
+            missing += 1;
+    }
+    return { total: fields.length, missing };
+};
+// ---------------------------------------------------------------------------
+// Normalizer building blocks
+// ---------------------------------------------------------------------------
+export const asString = (v, fallback = '') => typeof v === 'string' ? v : fallback;
+export const asNumber = (v, fallback = null) => typeof v === 'number' && Number.isFinite(v) ? v : fallback;
+export const asBoolean = (v, fallback = false) => typeof v === 'boolean' ? v : fallback;
+/**
+ * Normalize a list of items, guaranteeing every item carries a string `id`.
+ * An item without one (a hand-written seed, say) gets a deterministic
+ * `item-<index>` so reads stay stable until the editor next writes the list,
+ * at which point the ids are persisted.
+ */
+export const asItems = (raw, normalizeItem) => {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    raw.forEach((entry, index) => {
+        if (!isPlainObject(entry))
+            return;
+        const id = typeof entry.id === 'string' && entry.id !== '' ? entry.id : `item-${index}`;
+        out.push({ id, ...normalizeItem(entry, index) });
+    });
+    return out;
+};
+/** A short random id for a newly added item. Stable once written. */
+export const newItemId = () => {
+    const bytes = new Uint8Array(6);
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues)
+        crypto.getRandomValues(bytes);
+    else
+        for (let i = 0; i < bytes.length; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    let out = '';
+    for (const b of bytes)
+        out += b.toString(16).padStart(2, '0');
+    return out;
+};
+/** Read a structured value's overlay for one locale out of a whole scope tree. */
+export const overlayAt = (tree, name) => extractTranslations(get(tree, name));
+/** A list of strings; anything else is dropped. */
+export const asStrings = (v) => Array.isArray(v) ? v.filter((s) => typeof s === 'string') : [];
+/** A nullable string: `null` (cleared) stays `null`; anything else is a string. */
+export const asOptionalString = (v) => typeof v === 'string' && v !== '' ? v : null;
+/** One of a fixed set of strings, else the fallback. */
+export const asEnum = (v, values, fallback) => typeof v === 'string' && values.includes(v) ? v : fallback;
+/** Move an item within a list, returning a new list. */
+export const moveItem = (list, from, to) => {
+    const next = [...list];
+    const [item] = next.splice(from, 1);
+    next.splice(to, 0, item);
+    return next;
+};

package/dist/core/wire.d.ts

@@ -11,7 +11,7 @@
  * `published_at` stay snake_case because that is what the JSON carries.
  */
 import type { Tree } from './path.js';
-import type { PageDeleteOutcome } from './page-entry.js';
+import type { PageDeleteOutcome, PageEntry } from './page-entry.js';
 export type { PageDeleteOutcome };
 /** One pending change in a release, without the bookkeeping the store adds. */
 export type ReleaseItemCore = {
@@ -182,6 +182,36 @@ export type CmsDeployState = {
     };
     latest?: CmsDeployRun | null;
 };
+/**
+ * A project's published content in one object: `layouts` and `pages` keyed
+ * `[locale][routeId]`, plus the non-localised `site` tree. `POST /seed`
+ * accepts it and `GET /export` returns it, so a template's published
+ * `content/` can seed a fresh project and a project can be dumped back into
+ * the same shape. A page keyed by route id may be a bare tree (a static page,
+ * `params: {}`) or a full `PageEntry[]`.
+ */
+export type CmsSeed = {
+    layouts?: Record<string, Record<string, Tree>>;
+    pages?: Record<string, Record<string, Tree | PageEntry[]>>;
+    site?: Tree;
+};
+export type SeedRequest = CmsSeed & {
+    /** Overwrite a project that already has published rows. */
+    force?: boolean;
+};
+export type SeedSummary = {
+    locales: string[];
+    layouts: number;
+    pages: number;
+    site: boolean;
+};
+export type SeedResponse = {
+    ok: true;
+    seeded: SeedSummary;
+} | {
+    ok: false;
+    reason: 'already-seeded';
+};
 export type DocsResponse = {
     contents: Tree;
 } | PageDeleteOutcome;

package/dist/editor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `@velastack/cms/editor` — the editing chrome a structured component's
+ * editable sibling imports lazily, so none of it reaches the public bundle:
+ *
+ * ```svelte
+ * {#await import('@velastack/cms/editor') then { StructuredEditorPopover, FieldInput, ReorderButtons }}
+ * ```
+ */
+export { default as StructuredEditorPopover } from './components/admin-bar/structured-editor-popover.svelte';
+export { default as FieldInput } from './components/admin-bar/field-input.svelte';
+export type { FieldInputType } from './components/admin-bar/field-input.svelte';
+export { default as ReorderButtons } from './components/admin-bar/reorder-buttons.svelte';
+export { default as FieldsForm } from './components/admin-bar/fields-form.svelte';
+export { default as ListField } from './components/admin-bar/list-field.svelte';
+export { default as LinkInput } from './components/admin-bar/link-input.svelte';
+export { default as RichTextInput } from './components/admin-bar/rich-text-input.svelte';
+export { default as CssRoot } from './components/admin-bar/css-root.svelte';
+export { Button } from './components/admin-bar/ui/button/index.js';
+export { Input } from './components/admin-bar/ui/input/index.js';
+export { Textarea } from './components/admin-bar/ui/textarea/index.js';
+export { Switch } from './components/admin-bar/ui/switch/index.js';
+export { Checkbox } from './components/admin-bar/ui/checkbox/index.js';
+export * as Popover from './components/admin-bar/ui/popover/index.js';
+export * as Tabs from './components/admin-bar/ui/tabs/index.js';
+export * as Sheet from './components/admin-bar/ui/sheet/index.js';
+export { default as CmsMediaPicker } from './components/cms/cms-media-picker.svelte';

package/dist/editor.js

@@ -0,0 +1,25 @@
+/**
+ * `@velastack/cms/editor` — the editing chrome a structured component's
+ * editable sibling imports lazily, so none of it reaches the public bundle:
+ *
+ * ```svelte
+ * {#await import('@velastack/cms/editor') then { StructuredEditorPopover, FieldInput, ReorderButtons }}
+ * ```
+ */
+export { default as StructuredEditorPopover } from './components/admin-bar/structured-editor-popover.svelte';
+export { default as FieldInput } from './components/admin-bar/field-input.svelte';
+export { default as ReorderButtons } from './components/admin-bar/reorder-buttons.svelte';
+export { default as FieldsForm } from './components/admin-bar/fields-form.svelte';
+export { default as ListField } from './components/admin-bar/list-field.svelte';
+export { default as LinkInput } from './components/admin-bar/link-input.svelte';
+export { default as RichTextInput } from './components/admin-bar/rich-text-input.svelte';
+export { default as CssRoot } from './components/admin-bar/css-root.svelte';
+export { Button } from './components/admin-bar/ui/button/index.js';
+export { Input } from './components/admin-bar/ui/input/index.js';
+export { Textarea } from './components/admin-bar/ui/textarea/index.js';
+export { Switch } from './components/admin-bar/ui/switch/index.js';
+export { Checkbox } from './components/admin-bar/ui/checkbox/index.js';
+export * as Popover from './components/admin-bar/ui/popover/index.js';
+export * as Tabs from './components/admin-bar/ui/tabs/index.js';
+export * as Sheet from './components/admin-bar/ui/sheet/index.js';
+export { default as CmsMediaPicker } from './components/cms/cms-media-picker.svelte';

package/dist/index.d.ts

@@ -14,14 +14,36 @@ export type { CmsNumberProps } from './components/cms/cms-number.svelte';
 export { default as CmsDateTime } from './components/cms/cms-date-time.svelte';
 export type { CmsDateTimeMode, CmsDateTimeProps } from './components/cms/cms-date-time.svelte';
 export { default as CmsLink } from './components/cms/cms-link.svelte';
-export type { CmsLinkValue, CmsLinkRenderProps } from './components/cms/cms-link.svelte';
-export { default as CmsRepeater } from './components/cms/cms-repeater.svelte';
+export type { CmsLinkRenderProps } from './components/cms/cms-link.svelte';
 export { default as CmsEntries } from './components/cms/cms-entries.svelte';
+export { default as CmsNav } from './components/cms/cms-nav.svelte';
+export { default as CmsHours } from './components/cms/cms-hours.svelte';
+export { default as CmsContact } from './components/cms/cms-contact.svelte';
+export { default as CmsSocialLinks } from './components/cms/cms-social-links.svelte';
+export { default as CmsCollection } from './components/cms/cms-collection.svelte';
+export { default as CmsTeam } from './components/cms/cms-team.svelte';
+export { default as CmsTestimonials } from './components/cms/cms-testimonials.svelte';
+export { default as CmsPricing } from './components/cms/cms-pricing.svelte';
+export { default as CmsFaq } from './components/cms/cms-faq.svelte';
+export { default as CmsStats } from './components/cms/cms-stats.svelte';
+export { default as CmsSteps } from './components/cms/cms-steps.svelte';
+export { default as CmsTimeline } from './components/cms/cms-timeline.svelte';
+export { default as CmsGallery } from './components/cms/cms-gallery.svelte';
+export { default as CmsLogos } from './components/cms/cms-logos.svelte';
+export { default as CmsSchedule } from './components/cms/cms-schedule.svelte';
+export * from './core/shapes/index.js';
 export { default as AdminBar } from './components/admin-bar/admin-bar.svelte';
-export { definePage } from './components/admin-bar/page-config.js';
+export { useCmsField, resolveScopeRef, ROOT_SCOPE_ID } from './components/cms/use-cms-field.svelte.js';
+export type { CmsField, CmsFieldInput } from './components/cms/use-cms-field.svelte.js';
+export { defineStructured, applyTranslations, countTranslations, extractTranslations, stripTranslations, translatableFields, translationPath, asBoolean, asEnum, asItems, asNumber, asOptionalString, asString, asStrings, moveItem, newItemId, setIn, ROOT_ID, TRANSLATIONS_KEY } from './core/structured.js';
+export type { ItemsSpec, Structured, StructuredItem, StructuredSchema, TranslatableField, TranslationOverlay } from './core/structured.js';
+export { registerStructured, getStructured } from './core/structured-registry.js';
+export { toMetaTags } from './core/metadata.js';
+export type { MetaTagsOptions, MetaTagsOutput } from './core/metadata.js';
+export { definePage, DEFAULT_METADATA_SCHEMA, metadataSchemaFor } from './components/admin-bar/page-config.js';
 export type { CmsPageConfig, CmsCreatablePageConfig, CmsStaticPageConfig, CmsPageField, CmsPageMetadataSchema, MetadataFieldSchema, MetadataPrimitive } from './components/admin-bar/page-config.js';
 export { cmsStore } from './components/cms/cms-store.svelte.js';
 export { cms } from './components/cms/cms-store.svelte.js';
 export { CMS_SCOPE, getCmsScope, getCmsValue, getPageScope } from './components/cms/scope.js';
 export { installCmsScope } from './components/cms/install-scope.svelte.js';
-export type { CmsEntry, CmsManifest, CmsManifestRoute, CmsManifestScope, CmsPayload, CmsScope, CmsScopeEntry } from './components/cms/scope.js';
+export type { CmsEntry, CmsManifest, CmsManifestRoute, CmsManifestScope, CmsManifestUsage, CmsPayload, CmsScope, CmsScopeEntry, SiteFieldSchema, SiteFieldType, SiteSchema } from './components/cms/scope.js';

package/dist/index.js

@@ -13,12 +13,41 @@ export { default as CmsBoolean } from './components/cms/cms-boolean.svelte';
 export { default as CmsNumber } from './components/cms/cms-number.svelte';
 export { default as CmsDateTime } from './components/cms/cms-date-time.svelte';
 export { default as CmsLink } from './components/cms/cms-link.svelte';
-export { default as CmsRepeater } from './components/cms/cms-repeater.svelte';
 export { default as CmsEntries } from './components/cms/cms-entries.svelte';
+// Structured editor components. Each reads one versioned value, opens a
+// popover editor in edit mode and hands the typed view to `children`.
+// Their value types, normalizers and JSON-LD helpers come from the shapes.
+export { default as CmsNav } from './components/cms/cms-nav.svelte';
+export { default as CmsHours } from './components/cms/cms-hours.svelte';
+export { default as CmsContact } from './components/cms/cms-contact.svelte';
+export { default as CmsSocialLinks } from './components/cms/cms-social-links.svelte';
+export { default as CmsCollection } from './components/cms/cms-collection.svelte';
+export { default as CmsTeam } from './components/cms/cms-team.svelte';
+export { default as CmsTestimonials } from './components/cms/cms-testimonials.svelte';
+export { default as CmsPricing } from './components/cms/cms-pricing.svelte';
+export { default as CmsFaq } from './components/cms/cms-faq.svelte';
+// List presets: fixed item shapes; a new shape is a new preset here.
+export { default as CmsStats } from './components/cms/cms-stats.svelte';
+export { default as CmsSteps } from './components/cms/cms-steps.svelte';
+export { default as CmsTimeline } from './components/cms/cms-timeline.svelte';
+export { default as CmsGallery } from './components/cms/cms-gallery.svelte';
+export { default as CmsLogos } from './components/cms/cms-logos.svelte';
+export { default as CmsSchedule } from './components/cms/cms-schedule.svelte';
+export * from './core/shapes/index.js';
 // Admin bar (sync wrapper; admin-bar-internal + seo-panel are async chunks)
 export { default as AdminBar } from './components/admin-bar/admin-bar.svelte';
+// Building blocks for structured components: the field hook, the value
+// rules (versioned shapes, `$t` overlay) and the registry the Locales panel
+// reads. The editor popover and field inputs are admin-bar chunks, imported
+// lazily by editable siblings:
+//   `import('@velastack/cms/editor')`
+export { useCmsField, resolveScopeRef, ROOT_SCOPE_ID } from './components/cms/use-cms-field.svelte.js';
+export { defineStructured, applyTranslations, countTranslations, extractTranslations, stripTranslations, translatableFields, translationPath, asBoolean, asEnum, asItems, asNumber, asOptionalString, asString, asStrings, moveItem, newItemId, setIn, ROOT_ID, TRANSLATIONS_KEY } from './core/structured.js';
+export { registerStructured, getStructured } from './core/structured-registry.js';
+// Page metadata → svelte-meta-tags props.
+export { toMetaTags } from './core/metadata.js';
 // Per-route page configuration — declare in `page.cms.ts` next to `+page.svelte`.
-export { definePage } from './components/admin-bar/page-config.js';
+export { definePage, DEFAULT_METADATA_SCHEMA, metadataSchemaFor } from './components/admin-bar/page-config.js';
 // Edit-mode store
 export { cmsStore } from './components/cms/cms-store.svelte.js';
 // Merged CMS read view (server payload + client overlay), shaped like CmsPayload

package/dist/server/load-cms.js

@@ -61,6 +61,7 @@ export const resolveCmsPayload = async (args) => {
             routeId: scope.routeId,
             params: scopeParams,
             fields: scope.fields,
+            ...(scope.usages ? { usages: scope.usages } : {}),
             locale: forLocale
         };
     });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@velastack/cms",
-	"version": "0.4.0",
+	"version": "0.5.1",
 	"description": "A scope-aware CMS for SvelteKit, for static or dynamic sites.",
 	"keywords": [
 		"svelte",
@@ -57,6 +57,11 @@
 			"svelte": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
+		"./editor": {
+			"types": "./dist/editor.d.ts",
+			"svelte": "./dist/editor.js",
+			"default": "./dist/editor.js"
+		},
 		"./server": {
 			"types": "./dist/server/index.d.ts",
 			"default": "./dist/server/index.js"
@@ -72,6 +77,10 @@
 		"./adapter": {
 			"types": "./plugin/dist/adapter.d.ts",
 			"default": "./plugin/dist/adapter.js"
+		},
+		"./build": {
+			"types": "./plugin/dist/build.d.ts",
+			"default": "./plugin/dist/build.js"
 		}
 	},
 	"peerDependencies": {
@@ -110,7 +119,7 @@
 		"tw-animate-css": "^1.4.0",
 		"typescript": "^6.0.3",
 		"vite": "^8.2.2",
-		"vitest": "^4.1.11"
+		"vitest": "^5.0.1"
 	},
 	"dependencies": {
 		"@sveltejs/adapter-static": "^3.0.10",
@@ -119,7 +128,7 @@
 		"@tiptap/pm": "^3.30.6",
 		"@tiptap/starter-kit": "^3.30.6",
 		"bits-ui": "^2.19.0",
-		"devalue": "^5.9.2",
+		"devalue": "^6.0.0",
 		"tailwind-merge": "^3.6.0"
 	}
 }