storefront-layouts-staging 1.0.0-staging.0

package/dist/editor/document/adapter.js

@@ -0,0 +1,159 @@
+import { deepMergeLayoutPayload } from '../../lib/layout-config-hydration.js';
+import { EDITOR_DOC_VERSION, SNAPSHOT_CONTENT_KEY } from './constants.js';
+import { SHOPAZA_BLOCK_TYPES, SHOPAZA_DOCUMENT_ROOT_ID, applySectionContentEntriesToStoreConfig, applyTemplateBlocksToStoreConfig, buildTemplateFromOverlay, hasStructuredBlockTree, mergeSectionEntriesIntoContent, } from './block-tree.js';
+import { validateEditorEnvelope } from './validate.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function emptyTemplate() {
+    return {
+        rootBlockId: SHOPAZA_DOCUMENT_ROOT_ID,
+        blocks: {
+            [SHOPAZA_DOCUMENT_ROOT_ID]: {
+                id: SHOPAZA_DOCUMENT_ROOT_ID,
+                type: SHOPAZA_BLOCK_TYPES.document,
+                name: SHOPAZA_BLOCK_TYPES.document,
+                attributes: {},
+                innerBlocks: [],
+            },
+        },
+        slots: {},
+    };
+}
+/**
+ * Round-trip bridge: current runtime is StoreConfig. Block tree is placeholder until full migration.
+ */
+export function storeConfigToEnvelope(config, options, overlayLayout) {
+    const layoutType = options.layoutType;
+    const templateType = options.templateType ?? 'home';
+    const templateId = options.templateId ?? `${templateType}-default`;
+    const storeId = config.id || 'unknown-store';
+    const updatedAt = nowIso();
+    const template = overlayLayout && Array.isArray(overlayLayout.pages) && overlayLayout.pages.length > 0
+        ? buildTemplateFromOverlay(overlayLayout)
+        : emptyTemplate();
+    const baseContent = {
+        entries: {
+            [SNAPSHOT_CONTENT_KEY]: {
+                key: SNAPSHOT_CONTENT_KEY,
+                value: config,
+                source: 'merchant',
+                updatedAt,
+            },
+        },
+    };
+    const content = overlayLayout && Array.isArray(overlayLayout.pages) && overlayLayout.pages.length > 0
+        ? mergeSectionEntriesIntoContent({ entries: baseContent.entries }, overlayLayout, updatedAt)
+        : { entries: baseContent.entries };
+    return {
+        documentId: `${storeId}:${layoutType}:${templateId}`,
+        storeId,
+        layoutType,
+        layoutVersion: options.layoutVersion ?? 1,
+        templateType,
+        templateId,
+        editorDocVersion: EDITOR_DOC_VERSION,
+        updatedAt,
+        template,
+        content,
+        styles: {
+            globalTokens: {},
+            blockStyleOverrides: {},
+        },
+    };
+}
+export function envelopeToStoreConfig(envelope) {
+    const v = validateEditorEnvelope(envelope);
+    if (!v.ok) {
+        const msg = v.diagnostics.map(d => d.message).join('; ');
+        throw new Error(`[envelopeToStoreConfig] Invalid envelope: ${msg}`);
+    }
+    const entry = envelope.content.entries[SNAPSHOT_CONTENT_KEY];
+    if (!entry || entry.value == null || typeof entry.value !== 'object') {
+        throw new Error(`[envelopeToStoreConfig] Missing ${SNAPSHOT_CONTENT_KEY}`);
+    }
+    let config = entry.value;
+    if (hasStructuredBlockTree(envelope.template)) {
+        config = applyTemplateBlocksToStoreConfig(envelope.template, config);
+    }
+    config = applySectionContentEntriesToStoreConfig(envelope, config);
+    return config;
+}
+/**
+ * Deterministic JSON stringify for regression compares (sorted keys).
+ */
+export function stableStringify(value) {
+    const seen = new WeakSet();
+    const sort = (v) => {
+        if (v === null || typeof v !== 'object')
+            return v;
+        if (seen.has(v))
+            return '[Circular]';
+        seen.add(v);
+        if (Array.isArray(v))
+            return v.map(sort);
+        const o = v;
+        const out = {};
+        for (const k of Object.keys(o).sort()) {
+            out[k] = sort(o[k]);
+        }
+        return out;
+    };
+    return JSON.stringify(sort(value));
+}
+/**
+ * Prefer the live editor StoreConfig for layoutConfig while keeping envelope-derived identity fields.
+ * Prevents stale section:* entries from resetting cross-page heroes during save/publish compile.
+ */
+export function mergeAuthoritativeStoreConfig(compiled, authoritative) {
+    const compiledLc = (compiled.layoutConfig ?? {});
+    const authLc = authoritative.layoutConfig;
+    if (!authLc)
+        return compiled;
+    return {
+        ...compiled,
+        ...authoritative,
+        layoutConfig: deepMergeLayoutPayload(compiledLc, authLc),
+    };
+}
+/**
+ * Validates the envelope, derives legacy runtime config, and builds split persistence blobs + compiled cache.
+ */
+export function compileEditorDocument(envelope, options) {
+    const validation = validateEditorEnvelope(envelope);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            diagnostics: validation.diagnostics,
+            legacyConfig: null,
+            persistence: null,
+        };
+    }
+    try {
+        const legacyFromEnvelope = envelopeToStoreConfig(envelope);
+        const legacyConfig = options?.authoritativeStoreConfig
+            ? mergeAuthoritativeStoreConfig(legacyFromEnvelope, options.authoritativeStoreConfig)
+            : legacyFromEnvelope;
+        return {
+            ok: true,
+            diagnostics: [],
+            legacyConfig,
+            persistence: {
+                editorDocument: envelope,
+                templateJson: envelope.template,
+                contentJson: envelope.content,
+                stylesJson: envelope.styles,
+                compiledLegacyConfigJson: legacyConfig,
+            },
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            ok: false,
+            diagnostics: [{ gate: 'compatibility', message: msg }],
+            legacyConfig: null,
+            persistence: null,
+        };
+    }
+}

package/dist/editor/document/block-tree.d.ts

@@ -0,0 +1,46 @@
+import type { OverlayLayoutJSON } from '../payaza-form/engine';
+export type OverlayPage = OverlayLayoutJSON['pages'][number];
+import type { StoreConfig } from '../../lib/store-types';
+import type { ContentDocument, ContentEntry, EditorDocumentEnvelope, TemplateDocument } from './types';
+/** Document root — one tree per storefront layout JSON. */
+export declare const SHOPAZA_DOCUMENT_ROOT_ID = "shopaza:document:root";
+export declare const SHOPAZA_BLOCK_TYPES: {
+    readonly document: "shopaza/document";
+    readonly page: "shopaza/page";
+    readonly section: "shopaza/section";
+};
+/** Section payload lives under `attributes.payload` (editable as a whole or field-by-field via overlay). */
+export declare const SECTION_PAYLOAD_KEY = "payload";
+/**
+ * Resolved section keys for a page: `sectionOrder` first (validated), then remaining schema keys.
+ */
+export declare function resolveSectionKeyOrderForPage(page: OverlayPage): string[];
+/**
+ * Swap a section one step up/down in List view order (mutates overlay copy).
+ */
+export declare function moveSectionKeyInPageOrder(overlay: OverlayLayoutJSON, pageId: string, sectionKey: string, direction: 'up' | 'down'): OverlayLayoutJSON;
+/**
+ * True when the template contains real Shopaza section blocks (not only an empty document root).
+ */
+export declare function hasStructuredBlockTree(template: TemplateDocument): boolean;
+/**
+ * Build a Gutenberg-style tree from overlay JSON: document → pages → sections.
+ * Each section block carries `attributes.payload` (merchant data) and `bind` for compile to StoreConfig.
+ */
+export declare function buildTemplateFromOverlay(overlay: OverlayLayoutJSON): TemplateDocument;
+/** Content API keys: `section:{pageId}:{sectionKey}` — mirrors each section payload for split persistence. */
+export declare function sectionContentEntryKey(pageId: string, sectionKey: string): string;
+/**
+ * Flat content map alongside the block tree (WordPress-style “entity” hooks).
+ */
+export declare function buildSectionContentEntries(overlay: OverlayLayoutJSON, updatedAt: string): Record<string, ContentEntry>;
+export declare function mergeSectionEntriesIntoContent(base: ContentDocument, overlay: OverlayLayoutJSON, updatedAt: string): ContentDocument;
+/**
+ * Merge section block payloads into a StoreConfig copy (after snapshot hydrate).
+ */
+export declare function applyTemplateBlocksToStoreConfig(template: TemplateDocument, base: StoreConfig): StoreConfig;
+/**
+ * Merge persisted section:* content entries when snapshot was slimmed for wire transfer.
+ */
+export declare function applySectionContentEntriesToStoreConfig(envelope: EditorDocumentEnvelope, base: StoreConfig): StoreConfig;
+//# sourceMappingURL=block-tree.d.ts.map

package/dist/editor/document/block-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-tree.d.ts","sourceRoot":"","sources":["../../../src/editor/document/block-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,MAAM,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAA2B,eAAe,EAAE,YAAY,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhI,2DAA2D;AAC3D,eAAO,MAAM,wBAAwB,0BAA0B,CAAC;AAEhE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,4GAA4G;AAC5G,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAU7C;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAMzE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,IAAI,GAAG,MAAM,GACvB,iBAAiB,CAkBnB;AAqCD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAK1E;AAoCD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CA8ErF;AAED,8GAA8G;AAC9G,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAExE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAkBtH;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE,MAAM,GAChB,eAAe,CAOjB;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,CAsD3G;AAID;;GAEG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,sBAAsB,EAChC,IAAI,EAAE,WAAW,GAChB,WAAW,CAgEb"}

package/dist/editor/document/block-tree.js

@@ -0,0 +1,345 @@
+import { deepClone } from '../../lib/utils/index.js';
+/** Document root — one tree per storefront layout JSON. */
+export const SHOPAZA_DOCUMENT_ROOT_ID = 'shopaza:document:root';
+export const SHOPAZA_BLOCK_TYPES = {
+    document: 'shopaza/document',
+    page: 'shopaza/page',
+    section: 'shopaza/section',
+};
+/** Section payload lives under `attributes.payload` (editable as a whole or field-by-field via overlay). */
+export const SECTION_PAYLOAD_KEY = 'payload';
+function sectionBlockId(pageId, sectionKey) {
+    return `shopaza:section:${pageId}:${sectionKey}`;
+}
+function pageBlockId(pageId) {
+    return `shopaza:page:${pageId}`;
+}
+/**
+ * Resolved section keys for a page: `sectionOrder` first (validated), then remaining schema keys.
+ */
+export function resolveSectionKeyOrderForPage(page) {
+    const schema = page._schema || {};
+    const schemaKeys = Object.keys(schema);
+    const preferred = (page.sectionOrder || []).filter((k) => schemaKeys.includes(k));
+    const rest = schemaKeys.filter((k) => !preferred.includes(k));
+    return [...preferred, ...rest];
+}
+/**
+ * Swap a section one step up/down in List view order (mutates overlay copy).
+ */
+export function moveSectionKeyInPageOrder(overlay, pageId, sectionKey, direction) {
+    const pi = overlay.pages.findIndex((p) => p.id === pageId);
+    if (pi === -1)
+        return overlay;
+    const page = overlay.pages[pi];
+    const keys = resolveSectionKeyOrderForPage(page);
+    const i = keys.indexOf(sectionKey);
+    if (i === -1)
+        return overlay;
+    const j = direction === 'up' ? i - 1 : i + 1;
+    if (j < 0 || j >= keys.length)
+        return overlay;
+    const nextOrder = [...keys];
+    [nextOrder[i], nextOrder[j]] = [nextOrder[j], nextOrder[i]];
+    const pages = [...overlay.pages];
+    pages[pi] = { ...page, sectionOrder: nextOrder };
+    return { ...overlay, pages };
+}
+function setValueByPath(obj, path, value) {
+    if (!path)
+        return obj;
+    const parts = path.split('.');
+    const result = deepClone(obj);
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const next = current[part];
+        if (next == null || typeof next !== 'object') {
+            current[part] = {};
+        }
+        else {
+            current[part] = deepClone(next);
+        }
+        current = current[part];
+    }
+    const last = parts[parts.length - 1];
+    const existing = current[last];
+    if (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof existing === 'object' &&
+        existing !== null &&
+        !Array.isArray(existing)) {
+        current[last] = { ...existing, ...value };
+    }
+    else {
+        current[last] = value;
+    }
+    return result;
+}
+/**
+ * True when the template contains real Shopaza section blocks (not only an empty document root).
+ */
+export function hasStructuredBlockTree(template) {
+    for (const b of Object.values(template.blocks)) {
+        if (b.type === SHOPAZA_BLOCK_TYPES.section || b.name === SHOPAZA_BLOCK_TYPES.section)
+            return true;
+    }
+    return false;
+}
+function payazaFlatBlockId(pageId, sectionKey, path) {
+    return `shopaza:block:${pageId}:${sectionKey}:${path.join('-')}`;
+}
+/**
+ * Flattens serialized `payaza/*` blocks under a section into TemplateDocument `blocks` entries
+ * for outline / document tooling. Payload remains source of truth on the parent `shopaza/section`.
+ */
+function registerPayazaSubtree(flat, pageId, sectionKey, nodes, pathPrefix) {
+    const ids = [];
+    nodes.forEach((node, idx) => {
+        const addr = [...pathPrefix, idx];
+        const bid = payazaFlatBlockId(pageId, sectionKey, addr);
+        ids.push(bid);
+        const inner = Array.isArray(node.innerBlocks)
+            ? registerPayazaSubtree(flat, pageId, sectionKey, node.innerBlocks, addr)
+            : [];
+        flat[bid] = {
+            id: bid,
+            type: String(node.name),
+            name: String(node.name),
+            attributes: { payazaSerialized: deepClone(node) },
+            innerBlocks: inner,
+        };
+    });
+    return ids;
+}
+/**
+ * Build a Gutenberg-style tree from overlay JSON: document → pages → sections.
+ * Each section block carries `attributes.payload` (merchant data) and `bind` for compile to StoreConfig.
+ */
+export function buildTemplateFromOverlay(overlay) {
+    const blocks = {};
+    const pageRootIds = [];
+    for (const page of overlay.pages) {
+        const pid = pageBlockId(page.id);
+        pageRootIds.push(pid);
+        const sectionIds = [];
+        const schema = page._schema || {};
+        for (const sectionKey of resolveSectionKeyOrderForPage(page)) {
+            const sid = sectionBlockId(page.id, sectionKey);
+            sectionIds.push(sid);
+            const sectionSchema = schema[sectionKey];
+            const sourcePath = sectionSchema?._sourcePath;
+            const raw = page.data[sectionKey];
+            const bind = {
+                kind: 'overlay-section',
+                pageId: page.id,
+                sectionKey,
+                ...(sourcePath ? { sourcePath } : {}),
+                // Payloads from non-hydrated pages are raw schema defaults; flag them so
+                // compile never stamps defaults over the merchant's saved config.
+                hydrated: page._hydrated === true,
+            };
+            const serializedRoots = raw &&
+                typeof raw === 'object' &&
+                !Array.isArray(raw) &&
+                Array.isArray(raw.blocks)
+                ? raw.blocks
+                : [];
+            const payazaChildIds = serializedRoots.length > 0 ? registerPayazaSubtree(blocks, page.id, sectionKey, serializedRoots, []) : [];
+            blocks[sid] = {
+                id: sid,
+                type: SHOPAZA_BLOCK_TYPES.section,
+                name: SHOPAZA_BLOCK_TYPES.section,
+                attributes: {
+                    [SECTION_PAYLOAD_KEY]: raw !== undefined ? deepClone(raw) : {},
+                },
+                innerBlocks: payazaChildIds,
+                bind,
+            };
+        }
+        blocks[pid] = {
+            id: pid,
+            type: SHOPAZA_BLOCK_TYPES.page,
+            name: SHOPAZA_BLOCK_TYPES.page,
+            attributes: {
+                pageId: page.id,
+                label: page.label,
+                path: page.path,
+            },
+            innerBlocks: sectionIds,
+        };
+    }
+    blocks[SHOPAZA_DOCUMENT_ROOT_ID] = {
+        id: SHOPAZA_DOCUMENT_ROOT_ID,
+        type: SHOPAZA_BLOCK_TYPES.document,
+        name: SHOPAZA_BLOCK_TYPES.document,
+        attributes: {
+            layoutId: overlay.layoutId,
+            layoutName: overlay.layoutName,
+        },
+        innerBlocks: pageRootIds,
+    };
+    return {
+        rootBlockId: SHOPAZA_DOCUMENT_ROOT_ID,
+        blocks,
+        slots: {},
+    };
+}
+/** Content API keys: `section:{pageId}:{sectionKey}` — mirrors each section payload for split persistence. */
+export function sectionContentEntryKey(pageId, sectionKey) {
+    return `section:${pageId}:${sectionKey}`;
+}
+/**
+ * Flat content map alongside the block tree (WordPress-style “entity” hooks).
+ */
+export function buildSectionContentEntries(overlay, updatedAt) {
+    const entries = {};
+    for (const page of overlay.pages) {
+        // Non-hydrated pages hold schema defaults — never persist them as section:* entries
+        // or they overwrite merchant content from other pages at envelope compile time.
+        if (page._hydrated !== true)
+            continue;
+        for (const sectionKey of resolveSectionKeyOrderForPage(page)) {
+            const key = sectionContentEntryKey(page.id, sectionKey);
+            const raw = page.data[sectionKey];
+            entries[key] = {
+                key,
+                value: raw !== undefined ? deepClone(raw) : {},
+                source: 'merchant',
+                updatedAt,
+            };
+        }
+    }
+    return entries;
+}
+export function mergeSectionEntriesIntoContent(base, overlay, updatedAt) {
+    const merged = { ...base, entries: { ...base.entries } };
+    const sectionEntries = buildSectionContentEntries(overlay, updatedAt);
+    for (const [k, v] of Object.entries(sectionEntries)) {
+        merged.entries[k] = v;
+    }
+    return merged;
+}
+/**
+ * Merge section block payloads into a StoreConfig copy (after snapshot hydrate).
+ */
+export function applyTemplateBlocksToStoreConfig(template, base) {
+    if (!hasStructuredBlockTree(template))
+        return base;
+    let config = deepClone(base);
+    if (!config.layoutConfig)
+        config.layoutConfig = { sections: {} };
+    if (!config.layoutConfig.sections)
+        config.layoutConfig.sections = {};
+    if (!config.layoutConfig.pages)
+        config.layoutConfig.pages = {};
+    // Home-page section keys: a non-home section must never mirror into the global
+    // `sections` map under a key the home page owns (e.g. `hero`), or it would
+    // overwrite the home page's content at compile time.
+    const homeSectionKeys = new Set();
+    for (const block of Object.values(template.blocks)) {
+        if (block.type !== SHOPAZA_BLOCK_TYPES.section && block.name !== SHOPAZA_BLOCK_TYPES.section)
+            continue;
+        if (block.bind?.kind === 'overlay-section' && block.bind.pageId === 'home') {
+            homeSectionKeys.add(block.bind.sectionKey);
+        }
+    }
+    for (const block of Object.values(template.blocks)) {
+        if (block.type !== SHOPAZA_BLOCK_TYPES.section && block.name !== SHOPAZA_BLOCK_TYPES.section)
+            continue;
+        if (!block.bind || block.bind.kind !== 'overlay-section')
+            continue;
+        // Skip payloads from non-hydrated overlay pages: they hold raw schema defaults,
+        // and applying them would erase the merchant's saved content for those pages.
+        // The snapshot config (`base`) is authoritative for anything the user didn't touch.
+        if (block.bind.hydrated === false)
+            continue;
+        const payload = block.attributes[SECTION_PAYLOAD_KEY];
+        if (payload === undefined)
+            continue;
+        const { pageId, sectionKey, sourcePath } = block.bind;
+        const cloned = deepClone(payload);
+        if (sourcePath) {
+            config = setValueByPath(config, sourcePath, cloned);
+            continue;
+        }
+        if (pageId === 'home') {
+            config.layoutConfig.sections[sectionKey] = cloned;
+        }
+        else {
+            if (!config.layoutConfig.pages[pageId]) {
+                config.layoutConfig.pages[pageId] = {};
+            }
+            const pageEntry = config.layoutConfig.pages[pageId];
+            pageEntry[sectionKey] = cloned;
+            if (!homeSectionKeys.has(sectionKey)) {
+                config.layoutConfig.sections[sectionKey] = cloned;
+            }
+        }
+    }
+    return config;
+}
+const SECTION_CONTENT_ENTRY_PREFIX = 'section:';
+/**
+ * Merge persisted section:* content entries when snapshot was slimmed for wire transfer.
+ */
+export function applySectionContentEntriesToStoreConfig(envelope, base) {
+    const entries = envelope.content?.entries;
+    if (!entries || typeof entries !== 'object')
+        return base;
+    let config = null;
+    const templateBlocks = envelope.template?.blocks;
+    for (const [key, entry] of Object.entries(entries)) {
+        if (!key.startsWith(SECTION_CONTENT_ENTRY_PREFIX))
+            continue;
+        const remainder = key.slice(SECTION_CONTENT_ENTRY_PREFIX.length);
+        const separator = remainder.indexOf(':');
+        if (separator <= 0)
+            continue;
+        const pageId = remainder.slice(0, separator);
+        const sectionKey = remainder.slice(separator + 1);
+        if (!pageId || !sectionKey)
+            continue;
+        const value = entry?.value;
+        if (value === undefined)
+            continue;
+        const sectionBlock = templateBlocks?.[sectionBlockId(pageId, sectionKey)];
+        const bind = sectionBlock?.bind?.kind === 'overlay-section'
+            ? sectionBlock.bind
+            : undefined;
+        if (bind?.hydrated === false)
+            continue;
+        if (config === null) {
+            config = deepClone(base);
+            if (!config.layoutConfig)
+                config.layoutConfig = { sections: {} };
+            if (!config.layoutConfig.sections)
+                config.layoutConfig.sections = {};
+            if (!config.layoutConfig.pages)
+                config.layoutConfig.pages = {};
+        }
+        const cloned = deepClone(value);
+        // Respect alignment schema `_sourcePath` when the editor overlay key differs from
+        // where the persisted layoutConfig expects this section payload to live.
+        const sourcePath = templateBlocks && templateBlocks[sectionBlockId(pageId, sectionKey)]?.bind &&
+            templateBlocks[sectionBlockId(pageId, sectionKey)].bind?.kind === 'overlay-section' &&
+            templateBlocks[sectionBlockId(pageId, sectionKey)].bind
+                ?.sourcePath;
+        if (sourcePath) {
+            config = setValueByPath(config, sourcePath, cloned);
+            continue;
+        }
+        if (pageId === 'home') {
+            config.layoutConfig.sections[sectionKey] = cloned;
+        }
+        else {
+            if (!config.layoutConfig.pages[pageId]) {
+                config.layoutConfig.pages[pageId] = {};
+            }
+            const pageEntry = config.layoutConfig.pages[pageId];
+            pageEntry[sectionKey] = cloned;
+        }
+    }
+    return config ?? base;
+}

package/dist/editor/document/constants.d.ts

@@ -0,0 +1,6 @@
+import type { StoreLayoutType } from '../../lib/store-types';
+/** Bump when EditorDocumentEnvelope shape changes incompatibly. */
+export declare const EDITOR_DOC_VERSION = 1;
+export declare const SUPPORTED_LAYOUT_TYPES: readonly StoreLayoutType[];
+export declare const SNAPSHOT_CONTENT_KEY = "__store_snapshot__";
+//# sourceMappingURL=constants.d.ts.map

package/dist/editor/document/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/editor/document/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,eAAO,MAAM,sBAAsB,EAAE,SAAS,eAAe,EAUnD,CAAC;AAEX,eAAO,MAAM,oBAAoB,uBAAuB,CAAC"}

package/dist/editor/document/constants.js

@@ -0,0 +1,14 @@
+/** Bump when EditorDocumentEnvelope shape changes incompatibly. */
+export const EDITOR_DOC_VERSION = 1;
+export const SUPPORTED_LAYOUT_TYPES = [
+    'food',
+    'food-modern',
+    'clothing',
+    'clothing-minimal',
+    'booking',
+    'booking-agenda',
+    'electronics',
+    'electronics-grid',
+    'motivational-speaker',
+];
+export const SNAPSHOT_CONTENT_KEY = '__store_snapshot__';

package/dist/editor/document/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './constants';
+export * from './validate';
+export * from './adapter';
+export * from './layout-id';
+export * from './block-tree';
+//# sourceMappingURL=index.d.ts.map

package/dist/editor/document/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/editor/document/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/editor/document/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './constants.js';
+export * from './validate.js';
+export * from './adapter.js';
+export * from './layout-id.js';
+export * from './block-tree.js';

package/dist/editor/document/layout-id.d.ts

@@ -0,0 +1,3 @@
+import type { StoreLayoutType } from '../../lib/store-types';
+export declare function normalizeEditorLayoutId(raw: string): StoreLayoutType | null;
+//# sourceMappingURL=layout-id.d.ts.map

package/dist/editor/document/layout-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-id.d.ts","sourceRoot":"","sources":["../../../src/editor/document/layout-id.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAc7D,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAI3E"}

package/dist/editor/document/layout-id.js

@@ -0,0 +1,17 @@
+const LAYOUT_ID_MAP = {
+    'fashion-hub': 'clothing',
+    'savory-bites': 'food',
+    'modern-eats': 'food-modern',
+    'minimal-style': 'clothing-minimal',
+    'fashion-minimal': 'clothing-minimal',
+    'urban-retreat': 'booking',
+    'agenda-book': 'booking-agenda',
+    'grid-tech': 'electronics-grid',
+    'mindset-mastery': 'motivational-speaker',
+};
+export function normalizeEditorLayoutId(raw) {
+    const key = String(raw || '').trim().toLowerCase();
+    if (!key)
+        return null;
+    return (LAYOUT_ID_MAP[key] ?? key);
+}