@velastack/cms 0.1.0

package/dist/components/cms/cms-text.svelte

@@ -0,0 +1,131 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import { getCmsScope } from './scope.js';
+	import { cmsStore, type CmsScopeRef } from './cms-store.svelte.js';
+
+	type Props = {
+		name: string;
+		fallback?: string;
+		/** Per-item override used by `CmsRepeater`. */
+		value?: unknown;
+		children?: Snippet;
+	};
+
+	let { name, fallback, value, children }: Props = $props();
+
+	const scope = getCmsScope();
+	const ref = $derived<CmsScopeRef | null>(
+		scope ? { scopeId: scope.scopeId, routeId: scope.routeId, params: scope.params } : null
+	);
+
+	const resolved = $derived.by(() => {
+		if (value !== undefined) return value;
+		return ref ? cmsStore.getValue(ref, name) : undefined;
+	});
+
+	const display = $derived(typeof resolved === 'string' ? resolved : (fallback ?? ''));
+	const editable = $derived(cmsStore.isEditing && value === undefined && !!ref);
+
+	let el = $state<HTMLSpanElement>();
+	let childrenEl = $state<HTMLElement>();
+	let initialFromChildren = $state<string | undefined>(undefined);
+	let composing = false;
+
+	$effect.pre(() => {
+		if (editable && childrenEl && initialFromChildren === undefined) {
+			const text = childrenEl.textContent?.trim();
+			initialFromChildren = text || undefined;
+		}
+	});
+
+	const editValue = $derived.by(() => {
+		if (typeof resolved === 'string') return resolved;
+		if (fallback !== undefined) return fallback;
+		return initialFromChildren ?? '';
+	});
+
+	$effect(() => {
+		if (!el) return;
+		const target = editValue;
+		if (document.activeElement === el) return;
+		if (el.textContent === target) return;
+		el.textContent = target;
+	});
+
+	const writeValue = (text: string) => {
+		if (!ref) return;
+		cmsStore.setValue(ref, name, text);
+	};
+
+	const onInput = (e: Event) => {
+		if (composing) return;
+		writeValue((e.currentTarget as HTMLElement).textContent ?? '');
+	};
+
+	const onKeydown = (e: KeyboardEvent) => {
+		if (e.key === 'Enter') e.preventDefault();
+	};
+
+	const onCompositionEnd = (e: CompositionEvent) => {
+		composing = false;
+		writeValue((e.currentTarget as HTMLElement).textContent ?? '');
+	};
+</script>
+
+{#if editable && ref}
+	<span
+		bind:this={el}
+		class="cms-text-editable"
+		contenteditable="plaintext-only"
+		data-placeholder={name}
+		data-cms-name={name}
+		data-cms-scope={scope?.scopeId ?? '?'}
+		role="textbox"
+		tabindex="0"
+		aria-multiline="false"
+		aria-label={name}
+		spellcheck="true"
+		oninput={onInput}
+		onkeydown={onKeydown}
+		oncompositionstart={() => (composing = true)}
+		oncompositionend={onCompositionEnd}
+	></span>
+{:else if display}
+	{display}
+{:else if children}
+	<span bind:this={childrenEl} class="cms-text-children">{@render children()}</span>
+{:else}
+	<span class="cms-missing" data-cms-name={name} data-cms-scope={scope?.scopeId ?? '?'}>{name}</span
+	>
+{/if}
+
+<style>
+	.cms-text-editable {
+		border-radius: 0.125rem;
+		outline: 1px dashed rgba(127, 127, 127, 0.6);
+		outline-offset: 2px;
+	}
+	.cms-text-editable:focus {
+		outline: 2px solid rgb(99, 102, 241);
+		outline-offset: 2px;
+	}
+	.cms-text-editable:empty::before {
+		content: attr(data-placeholder);
+		color: rgba(127, 127, 127, 0.6);
+		font-style: italic;
+	}
+
+	.cms-text-children {
+		display: contents;
+	}
+
+	.cms-missing {
+		display: inline-block;
+		padding: 0 0.25rem;
+		border: 1px dashed rgba(127, 127, 127, 0.6);
+		border-radius: 0.25rem;
+		font-family: ui-monospace, monospace;
+		font-size: 0.85em;
+		color: rgba(127, 127, 127, 0.9);
+	}
+</style>

package/dist/components/cms/cms-text.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from 'svelte';
+type Props = {
+    name: string;
+    fallback?: string;
+    /** Per-item override used by `CmsRepeater`. */
+    value?: unknown;
+    children?: Snippet;
+};
+declare const CmsText: import("svelte").Component<Props, {}, "">;
+type CmsText = ReturnType<typeof CmsText>;
+export default CmsText;

package/dist/components/cms/index.d.ts

@@ -0,0 +1,13 @@
+export { default as CmsText } from './cms-text.svelte';
+export { default as CmsRichText } from './cms-rich-text.svelte';
+export { default as CmsMarkdown } from './cms-markdown.svelte';
+export { default as CmsImage } from './cms-image.svelte';
+export { default as CmsBoolean } from './cms-boolean.svelte';
+export { default as CmsNumber } from './cms-number.svelte';
+export { default as CmsDateTime } from './cms-date-time.svelte';
+export { default as CmsLink } from './cms-link.svelte';
+export type { CmsLinkValue, CmsLinkRenderProps } from './cms-link.svelte';
+export { default as CmsRepeater } from './cms-repeater.svelte';
+export { default as CmsEntries } from './cms-entries.svelte';
+export { CMS_SCOPE, getCmsScope, getCmsValue } from './scope.js';
+export type { CmsScope, CmsPayload, CmsEntry } from './scope.js';

package/dist/components/cms/index.js

@@ -0,0 +1,11 @@
+export { default as CmsText } from './cms-text.svelte';
+export { default as CmsRichText } from './cms-rich-text.svelte';
+export { default as CmsMarkdown } from './cms-markdown.svelte';
+export { default as CmsImage } from './cms-image.svelte';
+export { default as CmsBoolean } from './cms-boolean.svelte';
+export { default as CmsNumber } from './cms-number.svelte';
+export { default as CmsDateTime } from './cms-date-time.svelte';
+export { default as CmsLink } from './cms-link.svelte';
+export { default as CmsRepeater } from './cms-repeater.svelte';
+export { default as CmsEntries } from './cms-entries.svelte';
+export { CMS_SCOPE, getCmsScope, getCmsValue } from './scope.js';

package/dist/components/cms/install-scope.svelte.d.ts

@@ -0,0 +1,7 @@
+export type InstallCmsScopeConfig = {
+    scopeId: string;
+    kind: 'layout' | 'page';
+    routeId: string;
+    ownedParams: string[];
+};
+export declare const installCmsScope: (config: InstallCmsScopeConfig) => void;

package/dist/components/cms/install-scope.svelte.js

@@ -0,0 +1,33 @@
+import { setContext } from 'svelte';
+import { page } from '$app/state';
+import { CMS_SCOPE } from './scope.js';
+/**
+ * Used by the build-time auto-injection in `+layout.svelte` / `+page.svelte`.
+ * Sets the `CMS_SCOPE` Svelte context to a runes-backed scope object that
+ * tracks `page.params` so navigation between sibling param values updates the
+ * scope's `params` (e.g. `{ slug: 'suite-1' }` → `{ slug: 'suite-2' }`).
+ */
+const collectOwnedParams = (ownedParams, all) => {
+    const out = {};
+    for (const p of ownedParams) {
+        const v = all[p];
+        if (typeof v === 'string')
+            out[p] = v;
+    }
+    return out;
+};
+export const installCmsScope = (config) => {
+    // Compute synchronously at init so SSR sees the right params — `$effect`
+    // only fires on the client.
+    const initialParams = collectOwnedParams(config.ownedParams, page.params);
+    const scope = $state({
+        scopeId: config.scopeId,
+        kind: config.kind,
+        routeId: config.routeId,
+        params: initialParams
+    });
+    $effect(() => {
+        scope.params = collectOwnedParams(config.ownedParams, page.params);
+    });
+    setContext(CMS_SCOPE, scope);
+};

package/dist/components/cms/locale-merge.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure locale-fallback merge helpers, shared between the server-load path
+ * (`resolveCmsPayload`) and the client-overlay path (`loadAndApplyOverlay`)
+ * so both compose the same `requested → default → undefined` chain.
+ *
+ * The convention (see `mock-adapter.ts`'s contract): adapters return only
+ * what's stored for the requested locale. Callers fetch the requested locale
+ * AND the default locale separately, then call these helpers to produce the
+ * fallback-merged result. Defaults fill gaps; requested values override.
+ *
+ * Tombstones are not handled here — callers should resolve tombstone
+ * precedence (requested wins outright) before passing trees in.
+ */
+import type { CmsEntry } from './scope.js';
+import { type Tree } from './path.js';
+/**
+ * Merge requested-locale doc trees over default-locale doc trees, per scope.
+ *
+ * - Both present → `mergeTree(fallback, requested)` (requested overrides on
+ *   leaves; objects deep-merge; arrays replace).
+ * - Requested only → returned as-is (requested locale has its own content;
+ *   default-locale entry happens to be missing — surface what we have).
+ * - Fallback only → returned as-is (requested locale lacks the scope; show
+ *   the default-locale value).
+ * - Neither → scope omitted from output.
+ *
+ * Pass `fallback = null` for the no-fallback case (locale === defaultLocale,
+ * or single-locale fetch); the function then just unwraps `requested`.
+ */
+export declare const mergeLocaleDocs: (requested: Record<string, Tree | undefined>, fallback: Record<string, Tree | undefined> | null) => Record<string, Tree>;
+/**
+ * Merge requested-locale entry lists over default-locale entry lists, per
+ * routeId. Entries are unioned by stringified `params`; requested-locale
+ * entries win on metadata when both locales have the same `params`.
+ *
+ * Pass `fallback = null` for the no-fallback case; the function then returns
+ * the requested map verbatim (each list is whatever the caller stored).
+ *
+ * Tombstone filtering (`redirectTo`, `gone`) happens at the call site.
+ */
+export declare const mergeLocaleEntries: (requested: Record<string, CmsEntry[]>, fallback: Record<string, CmsEntry[]> | null) => Record<string, CmsEntry[]>;

package/dist/components/cms/locale-merge.js

@@ -0,0 +1,77 @@
+/**
+ * Pure locale-fallback merge helpers, shared between the server-load path
+ * (`resolveCmsPayload`) and the client-overlay path (`loadAndApplyOverlay`)
+ * so both compose the same `requested → default → undefined` chain.
+ *
+ * The convention (see `mock-adapter.ts`'s contract): adapters return only
+ * what's stored for the requested locale. Callers fetch the requested locale
+ * AND the default locale separately, then call these helpers to produce the
+ * fallback-merged result. Defaults fill gaps; requested values override.
+ *
+ * Tombstones are not handled here — callers should resolve tombstone
+ * precedence (requested wins outright) before passing trees in.
+ */
+import { mergeTree } from './path.js';
+/**
+ * Merge requested-locale doc trees over default-locale doc trees, per scope.
+ *
+ * - Both present → `mergeTree(fallback, requested)` (requested overrides on
+ *   leaves; objects deep-merge; arrays replace).
+ * - Requested only → returned as-is (requested locale has its own content;
+ *   default-locale entry happens to be missing — surface what we have).
+ * - Fallback only → returned as-is (requested locale lacks the scope; show
+ *   the default-locale value).
+ * - Neither → scope omitted from output.
+ *
+ * Pass `fallback = null` for the no-fallback case (locale === defaultLocale,
+ * or single-locale fetch); the function then just unwraps `requested`.
+ */
+export const mergeLocaleDocs = (requested, fallback) => {
+    const out = {};
+    const scopeIds = new Set([
+        ...Object.keys(requested),
+        ...(fallback ? Object.keys(fallback) : [])
+    ]);
+    for (const scopeId of scopeIds) {
+        const r = requested[scopeId];
+        const f = fallback?.[scopeId];
+        if (f && r)
+            out[scopeId] = mergeTree(f, r);
+        else if (f)
+            out[scopeId] = f;
+        else if (r)
+            out[scopeId] = r;
+    }
+    return out;
+};
+/**
+ * Merge requested-locale entry lists over default-locale entry lists, per
+ * routeId. Entries are unioned by stringified `params`; requested-locale
+ * entries win on metadata when both locales have the same `params`.
+ *
+ * Pass `fallback = null` for the no-fallback case; the function then returns
+ * the requested map verbatim (each list is whatever the caller stored).
+ *
+ * Tombstone filtering (`redirectTo`, `gone`) happens at the call site.
+ */
+export const mergeLocaleEntries = (requested, fallback) => {
+    if (!fallback) {
+        const out = {};
+        for (const [rid, list] of Object.entries(requested))
+            out[rid] = [...list];
+        return out;
+    }
+    const out = {};
+    const routeIds = new Set([...Object.keys(requested), ...Object.keys(fallback)]);
+    for (const routeId of routeIds) {
+        const r = requested[routeId] ?? [];
+        const f = fallback[routeId] ?? [];
+        const merged = new Map();
+        for (const e of f)
+            merged.set(JSON.stringify(e.params), e);
+        for (const e of r)
+            merged.set(JSON.stringify(e.params), e);
+        out[routeId] = [...merged.values()];
+    }
+    return out;
+};

package/dist/components/cms/overlay-sync.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Pure decision logic for the editor overlay sync. The admin bar reads URL
+ * params + store state, calls `deriveOverlayIntents`, and dispatches the
+ * returned intents (URL navigations, async overlay loads, overlay clears).
+ *
+ * Keeping this pure lets us unit-test every (versionKey, locale, openRelease,
+ * previewParam, openReleaseFetched) combination without spinning up Svelte.
+ */
+import type { CmsScopeRef } from './cms-store.svelte.js';
+export type OverlayIntent = {
+    kind: 'fetch-open-release';
+} | {
+    kind: 'fetch-version-release';
+    versionKey: string;
+} | {
+    kind: 'set-preview-param';
+    value: string | null;
+} | {
+    kind: 'load-version-overlay';
+    versionKey: string;
+    locale: string;
+}
+/** `previewKey: null` fetches published-only — used when previewing a
+ *  non-default locale without an open draft, so the overlay carries the
+ *  locale's published tree (with default-locale fallback merged by
+ *  `loadAndApplyOverlay`'s dual-fetch). */
+ | {
+    kind: 'load-overlay';
+    previewKey: string | null;
+    locale: string;
+} | {
+    kind: 'clear-overlay';
+};
+export interface OverlaySyncInput {
+    /** `?version=…` URL param: when set, we're in past-release snapshot mode. */
+    versionKey: string | null;
+    /** Active editor preview locale (URL `?locale=` overriding `cms.locale`). */
+    locale: string;
+    /**
+     * `page.data.cms.locale` — the locale the server rendered for this request.
+     * When `locale === pageLocale`, the page's `cms.docs` already provides the
+     * base content (no overlay needed for "show the published tree"). When
+     * they differ, we must load the overlay so non-default-locale views see
+     * content (with default-locale fallback) rather than empty fields.
+     */
+    pageLocale: string;
+    /** Current open-release preview_key from `cmsStore.openRelease`, or null. */
+    openReleaseKey: string | null;
+    /** Whether `fetchOpenRelease` has resolved at least once this session. */
+    openReleaseFetched: boolean;
+    /** `?preview=…` URL param value, or null if absent. */
+    previewParam: string | null;
+}
+/**
+ * Decide what to do given the current sync state. Rules, in order:
+ *
+ * 1. If openRelease hasn't been fetched yet, always emit `fetch-open-release`.
+ *    (Version mode still loads its overlay immediately; non-version decisions
+ *    defer to the next pass once the fetch resolves.)
+ * 2. Version mode wins: load the past-release snapshot for `versionKey` and
+ *    `locale`. Don't touch `?preview=` (the consumer chose `?version=`).
+ * 3. Otherwise, only act on draft-mode rules once `openReleaseFetched` is
+ *    true — pre-fetch we don't know if there's a draft, so we mustn't strip
+ *    a preexisting `?preview=` from the URL.
+ * 4. With an open release whose key disagrees with `?preview=`, sync the URL
+ *    first; the param change re-runs the effect into rule 5.
+ * 5. With an open release whose key matches: load the draft overlay.
+ * 6. With no open release but a stale `?preview=`: strip the param. Then
+ *    fall through to rule 7's locale logic in the *same* intent batch so the
+ *    field render isn't briefly empty between strip and the next effect run.
+ * 7. With no open release and no draft overlay needed:
+ *    - `locale === pageLocale`: clear the overlay — the page's `cms.docs` is
+ *      authoritative and matching, so the field reads from base directly.
+ *    - `locale !== pageLocale`: load published-only overlay. Without this,
+ *      `mergedTree(non-pageLocale)` would have empty base AND empty overlay,
+ *      and fields would fall through to their component fallback even though
+ *      a default-locale value exists. The dual-fetch in `loadAndApplyOverlay`
+ *      composes the `requested → default → undefined` chain.
+ */
+export declare function deriveOverlayIntents(input: OverlaySyncInput): OverlayIntent[];
+/** Stable cache key for `(scope, locale)` overlay/draft buckets. */
+export declare const composeKey: (scope: CmsScopeRef, locale: string) => string;

package/dist/components/cms/overlay-sync.js

@@ -0,0 +1,76 @@
+/**
+ * Pure decision logic for the editor overlay sync. The admin bar reads URL
+ * params + store state, calls `deriveOverlayIntents`, and dispatches the
+ * returned intents (URL navigations, async overlay loads, overlay clears).
+ *
+ * Keeping this pure lets us unit-test every (versionKey, locale, openRelease,
+ * previewParam, openReleaseFetched) combination without spinning up Svelte.
+ */
+/**
+ * Decide what to do given the current sync state. Rules, in order:
+ *
+ * 1. If openRelease hasn't been fetched yet, always emit `fetch-open-release`.
+ *    (Version mode still loads its overlay immediately; non-version decisions
+ *    defer to the next pass once the fetch resolves.)
+ * 2. Version mode wins: load the past-release snapshot for `versionKey` and
+ *    `locale`. Don't touch `?preview=` (the consumer chose `?version=`).
+ * 3. Otherwise, only act on draft-mode rules once `openReleaseFetched` is
+ *    true — pre-fetch we don't know if there's a draft, so we mustn't strip
+ *    a preexisting `?preview=` from the URL.
+ * 4. With an open release whose key disagrees with `?preview=`, sync the URL
+ *    first; the param change re-runs the effect into rule 5.
+ * 5. With an open release whose key matches: load the draft overlay.
+ * 6. With no open release but a stale `?preview=`: strip the param. Then
+ *    fall through to rule 7's locale logic in the *same* intent batch so the
+ *    field render isn't briefly empty between strip and the next effect run.
+ * 7. With no open release and no draft overlay needed:
+ *    - `locale === pageLocale`: clear the overlay — the page's `cms.docs` is
+ *      authoritative and matching, so the field reads from base directly.
+ *    - `locale !== pageLocale`: load published-only overlay. Without this,
+ *      `mergedTree(non-pageLocale)` would have empty base AND empty overlay,
+ *      and fields would fall through to their component fallback even though
+ *      a default-locale value exists. The dual-fetch in `loadAndApplyOverlay`
+ *      composes the `requested → default → undefined` chain.
+ */
+export function deriveOverlayIntents(input) {
+    const intents = [];
+    if (!input.openReleaseFetched) {
+        intents.push({ kind: 'fetch-open-release' });
+    }
+    if (input.versionKey) {
+        intents.push({ kind: 'fetch-version-release', versionKey: input.versionKey }, { kind: 'load-version-overlay', versionKey: input.versionKey, locale: input.locale });
+        return intents;
+    }
+    if (!input.openReleaseFetched)
+        return intents;
+    if (input.openReleaseKey && input.previewParam !== input.openReleaseKey) {
+        intents.push({ kind: 'set-preview-param', value: input.openReleaseKey });
+        return intents;
+    }
+    if (input.openReleaseKey) {
+        intents.push({
+            kind: 'load-overlay',
+            previewKey: input.openReleaseKey,
+            locale: input.locale
+        });
+        return intents;
+    }
+    if (input.previewParam) {
+        intents.push({ kind: 'set-preview-param', value: null });
+    }
+    if (input.locale !== input.pageLocale) {
+        intents.push({ kind: 'load-overlay', previewKey: null, locale: input.locale });
+    }
+    else {
+        intents.push({ kind: 'clear-overlay' });
+    }
+    return intents;
+}
+/** Stable cache key for `(scope, locale)` overlay/draft buckets. */
+export const composeKey = (scope, locale) => {
+    const keys = Object.keys(scope.params).sort();
+    const base = keys.length === 0
+        ? scope.scopeId
+        : `${scope.scopeId}?${keys.map((k) => `${k}=${scope.params[k]}`).join('&')}`;
+    return `${base}|locale=${locale}`;
+};

package/dist/components/cms/path.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Lodash-style path utilities for tree-shaped CMS state.
+ *
+ * Paths are dot-separated strings: `welcome.title`, `gallery.0.caption`,
+ * `metadata.openGraph.image.url`. Numeric segments index arrays. There are
+ * no brackets — `gallery[0].caption` is not supported. When `set` walks into
+ * a missing parent, the next segment's shape decides whether to create an
+ * array (numeric) or a plain object (anything else).
+ *
+ * `mergeTree` deep-merges plain objects but **replaces arrays wholesale** —
+ * critical so a repeater's reorder/delete doesn't accidentally concat with
+ * the previous order.
+ */
+export type Tree = Record<string, unknown>;
+export declare const parsePath: (path: string) => string[];
+export declare const get: (tree: unknown, path: string) => unknown;
+export declare const has: (tree: unknown, path: string) => boolean;
+export declare const set: (tree: Tree, path: string, value: unknown) => void;
+export declare const unset: (tree: Tree, path: string) => boolean;
+export declare const mergeTree: (...trees: Array<Tree | undefined>) => Tree;
+/**
+ * Sorted leaf paths whose values differ between `before` and `after`. Used by
+ * the publish dialog to summarize what changed in a release item.
+ *
+ * Treats `undefined` as an empty tree at the root, so adding/removing top-level
+ * branches still produces leaf paths. Two arrays of equal length recurse per
+ * index; arrays of differing length emit the array path itself (aligns with
+ * `mergeTree`'s array-replace semantics).
+ */
+export declare const diffPaths: (before: unknown, after: unknown) => string[];

package/dist/components/cms/path.js

@@ -0,0 +1,156 @@
+/**
+ * Lodash-style path utilities for tree-shaped CMS state.
+ *
+ * Paths are dot-separated strings: `welcome.title`, `gallery.0.caption`,
+ * `metadata.openGraph.image.url`. Numeric segments index arrays. There are
+ * no brackets — `gallery[0].caption` is not supported. When `set` walks into
+ * a missing parent, the next segment's shape decides whether to create an
+ * array (numeric) or a plain object (anything else).
+ *
+ * `mergeTree` deep-merges plain objects but **replaces arrays wholesale** —
+ * critical so a repeater's reorder/delete doesn't accidentally concat with
+ * the previous order.
+ */
+const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const isIndex = (s) => /^[0-9]+$/.test(s);
+export const parsePath = (path) => (path === '' ? [] : path.split('.'));
+export const get = (tree, path) => {
+    const segs = parsePath(path);
+    let cur = tree;
+    for (const s of segs) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[s];
+    }
+    return cur;
+};
+export const has = (tree, path) => {
+    const segs = parsePath(path);
+    if (segs.length === 0)
+        return tree !== undefined;
+    let cur = tree;
+    for (let i = 0; i < segs.length; i++) {
+        if (cur == null || typeof cur !== 'object')
+            return false;
+        if (!(segs[i] in cur))
+            return false;
+        cur = cur[segs[i]];
+    }
+    return true;
+};
+export const set = (tree, path, value) => {
+    const segs = parsePath(path);
+    if (segs.length === 0)
+        throw new Error('set: empty path');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cur = tree;
+    for (let i = 0; i < segs.length - 1; i++) {
+        const seg = segs[i];
+        const next = segs[i + 1];
+        const child = cur[seg];
+        if (child == null || typeof child !== 'object') {
+            cur[seg] = isIndex(next) ? [] : {};
+        }
+        cur = cur[seg];
+    }
+    cur[segs[segs.length - 1]] = value;
+};
+export const unset = (tree, path) => {
+    const segs = parsePath(path);
+    if (segs.length === 0)
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cur = tree;
+    for (let i = 0; i < segs.length - 1; i++) {
+        if (cur == null || typeof cur !== 'object')
+            return false;
+        cur = cur[segs[i]];
+    }
+    if (cur == null || typeof cur !== 'object')
+        return false;
+    const last = segs[segs.length - 1];
+    if (!(last in cur))
+        return false;
+    delete cur[last];
+    return true;
+};
+export const mergeTree = (...trees) => {
+    const out = {};
+    for (const tree of trees) {
+        if (!tree)
+            continue;
+        for (const [k, v] of Object.entries(tree)) {
+            const prev = out[k];
+            if (isPlainObject(v) && isPlainObject(prev)) {
+                out[k] = mergeTree(prev, v);
+            }
+            else {
+                out[k] = v;
+            }
+        }
+    }
+    return out;
+};
+/**
+ * Sorted leaf paths whose values differ between `before` and `after`. Used by
+ * the publish dialog to summarize what changed in a release item.
+ *
+ * Treats `undefined` as an empty tree at the root, so adding/removing top-level
+ * branches still produces leaf paths. Two arrays of equal length recurse per
+ * index; arrays of differing length emit the array path itself (aligns with
+ * `mergeTree`'s array-replace semantics).
+ */
+export const diffPaths = (before, after) => {
+    const out = [];
+    walk(before ?? {}, after ?? {}, '', out);
+    out.sort();
+    return out;
+};
+const walk = (b, a, prefix, out) => {
+    if (b === a)
+        return;
+    // One side undefined, the other a tree → enumerate the tree's leaves.
+    if (b === undefined && (isPlainObject(a) || Array.isArray(a))) {
+        walkLeaves(a, prefix, out);
+        return;
+    }
+    if (a === undefined && (isPlainObject(b) || Array.isArray(b))) {
+        walkLeaves(b, prefix, out);
+        return;
+    }
+    if (isPlainObject(b) && isPlainObject(a)) {
+        const keys = new Set([...Object.keys(b), ...Object.keys(a)]);
+        for (const k of keys) {
+            const sub = prefix ? `${prefix}.${k}` : k;
+            walk(b[k], a[k], sub, out);
+        }
+        return;
+    }
+    if (Array.isArray(b) && Array.isArray(a) && b.length === a.length) {
+        for (let i = 0; i < b.length; i++) {
+            const sub = prefix ? `${prefix}.${i}` : `${i}`;
+            walk(b[i], a[i], sub, out);
+        }
+        return;
+    }
+    if (prefix)
+        out.push(prefix);
+};
+const walkLeaves = (v, prefix, out) => {
+    if (isPlainObject(v)) {
+        for (const [k, sub] of Object.entries(v)) {
+            const p = prefix ? `${prefix}.${k}` : k;
+            walkLeaves(sub, p, out);
+        }
+        return;
+    }
+    if (Array.isArray(v)) {
+        for (let i = 0; i < v.length; i++) {
+            const p = prefix ? `${prefix}.${i}` : `${i}`;
+            walkLeaves(v[i], p, out);
+        }
+        return;
+    }
+    if (prefix)
+        out.push(prefix);
+};