@elytracms/studio 0.0.78 → 0.0.79

package/dist/lib/data/content-session-refresh.js

@@ -0,0 +1,138 @@
+/**
+ * Content-session write-sync (EC-460) — the root-cause fix for the playground
+ * population family.
+ *
+ * The canvas preview engine (`collection-content.ts`) resolves listings,
+ * relation picks, and rich-text links against a module-global content session
+ * that used to refresh ONLY at project boot and per CMS-surface mount
+ * (`project-session.tsx`). A document authored or published after the last of
+ * those hydrations was invisible to every canvas resolver while the picker UIs
+ * (which read the live CMS store) showed it — the listing rendered its empty
+ * state against real published same-session content, and a `multiple` relation
+ * resolved 1-of-3 / 0-of-3 picked chips, all silently.
+ *
+ * This module closes the loop at the ONE write chokepoint the studio already
+ * has: the operations lifecycle event bus ("validate → authorize → mutate →
+ * emit"; its documented consumers include cache invalidation, vision AD-7 —
+ * the reference index and revalidation webhooks attach the same way). Every
+ * SUCCEEDED command in a content-bearing domain marks the session stale; a
+ * registered refresher (the project session's own `loadCms`, so both modes run
+ * the identical `loadHydratedCms` → `configureContentSession` path — no new
+ * loader, no transport bypass, no second cache) re-hydrates it, debounced so a
+ * persister burst coalesces into one load.
+ *
+ * Refreshes only run while a CONSUMER (a mounted canvas) is registered — a
+ * session with no preview surface just keeps the stale flag and re-hydrates
+ * when the next consumer arrives, so connected mode never pays a per-autosave
+ * query while nobody is previewing. The pure orchestrator
+ * ({@link createContentSessionSync}) takes its timer + refresh injected, so the
+ * coalescing/latch behaviour is unit-tested in node (house pattern); the
+ * module-level singleton below is the app wiring.
+ */
+/** Domains whose succeeded commands change what the preview engine serves. */
+export const CONTENT_SESSION_WRITE_DOMAINS = new Set([
+    'documents',
+    'schema',
+    'assets',
+]);
+/** Whether an operation event invalidates the preview content session. */
+export function isContentSessionWrite(event) {
+    return (event.kind === 'command' &&
+        event.status === 'succeeded' &&
+        CONTENT_SESSION_WRITE_DOMAINS.has(event.domain));
+}
+/**
+ * The pure orchestrator: stale flag + consumer count + one coalesced refresh.
+ *
+ * - `markStale` with no consumers only flags; the next `addConsumer` refreshes.
+ * - `markStale` with consumers schedules a trailing debounce (bursts coalesce).
+ * - A `markStale` DURING an in-flight refresh re-runs once after it settles —
+ *   the refresh that was already reading may have missed that write.
+ */
+export function createContentSessionSync(deps) {
+    const delayMs = deps.delayMs ?? 150;
+    const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    const clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+    let stale = false;
+    let consumers = 0;
+    let timer = null;
+    let running = false;
+    let rerun = false;
+    function run() {
+        if (running) {
+            rerun = true;
+            return;
+        }
+        running = true;
+        stale = false;
+        void deps
+            .refresh()
+            .catch(() => {
+            // A failed hydration keeps the session stale so the next trigger retries;
+            // the loader itself already reports the failure loudly (loadCmsIntoSession).
+            stale = true;
+        })
+            .finally(() => {
+            running = false;
+            if (rerun || (stale && consumers > 0)) {
+                rerun = false;
+                schedule();
+            }
+        });
+    }
+    function schedule() {
+        if (timer !== null)
+            clearTimer(timer);
+        timer = setTimer(() => {
+            timer = null;
+            run();
+        }, delayMs);
+    }
+    return {
+        markStale() {
+            stale = true;
+            if (consumers > 0)
+                schedule();
+        },
+        addConsumer() {
+            consumers += 1;
+            if (stale && timer === null && !running)
+                schedule();
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                consumers -= 1;
+            };
+        },
+        isStale() {
+            return stale;
+        },
+    };
+}
+let currentRefresher = null;
+const sync = createContentSessionSync({
+    refresh: () => currentRefresher?.() ?? Promise.resolve(),
+});
+/**
+ * Register the active project's session refresher (`ProjectSessionProvider`
+ * mounts it with its `loadCms`; leaving the project unregisters). Only one is
+ * active at a time — the studio shows one project per session.
+ */
+export function registerContentSessionRefresher(refresher) {
+    currentRefresher = refresher;
+    return () => {
+        if (currentRefresher === refresher)
+            currentRefresher = null;
+    };
+}
+/** Mark the shared session stale (the event-bus listener calls this). */
+export function markContentSessionStale() {
+    sync.markStale();
+}
+/** Register a mounted preview consumer (the canvas); returns the release. */
+export function acquireContentSessionConsumer() {
+    return sync.addConsumer();
+}
+//# sourceMappingURL=content-session-refresh.js.map

package/dist/lib/data/content-session-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-session-refresh.js","sourceRoot":"","sources":["../../../src/lib/data/content-session-refresh.ts"],"names":[],"mappings":"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","sourcesContent":["import type { OperationEvent } from '@elytracms/studio/lib/operations'\n\n/**\n * Content-session write-sync (EC-460) — the root-cause fix for the playground\n * population family.\n *\n * The canvas preview engine (`collection-content.ts`) resolves listings,\n * relation picks, and rich-text links against a module-global content session\n * that used to refresh ONLY at project boot and per CMS-surface mount\n * (`project-session.tsx`). A document authored or published after the last of\n * those hydrations was invisible to every canvas resolver while the picker UIs\n * (which read the live CMS store) showed it — the listing rendered its empty\n * state against real published same-session content, and a `multiple` relation\n * resolved 1-of-3 / 0-of-3 picked chips, all silently.\n *\n * This module closes the loop at the ONE write chokepoint the studio already\n * has: the operations lifecycle event bus (\"validate → authorize → mutate →\n * emit\"; its documented consumers include cache invalidation, vision AD-7 —\n * the reference index and revalidation webhooks attach the same way). Every\n * SUCCEEDED command in a content-bearing domain marks the session stale; a\n * registered refresher (the project session's own `loadCms`, so both modes run\n * the identical `loadHydratedCms` → `configureContentSession` path — no new\n * loader, no transport bypass, no second cache) re-hydrates it, debounced so a\n * persister burst coalesces into one load.\n *\n * Refreshes only run while a CONSUMER (a mounted canvas) is registered — a\n * session with no preview surface just keeps the stale flag and re-hydrates\n * when the next consumer arrives, so connected mode never pays a per-autosave\n * query while nobody is previewing. The pure orchestrator\n * ({@link createContentSessionSync}) takes its timer + refresh injected, so the\n * coalescing/latch behaviour is unit-tested in node (house pattern); the\n * module-level singleton below is the app wiring.\n */\n\n/** Domains whose succeeded commands change what the preview engine serves. */\nexport const CONTENT_SESSION_WRITE_DOMAINS: ReadonlySet<string> = new Set([\n  'documents',\n  'schema',\n  'assets',\n])\n\n/** Whether an operation event invalidates the preview content session. */\nexport function isContentSessionWrite(event: OperationEvent): boolean {\n  return (\n    event.kind === 'command' &&\n    event.status === 'succeeded' &&\n    CONTENT_SESSION_WRITE_DOMAINS.has(event.domain)\n  )\n}\n\nexport interface ContentSessionSyncDeps {\n  /** Re-hydrate the session (the project session's `loadCms`). Never throws upward. */\n  refresh: () => Promise<unknown>\n  /** Trailing debounce for write bursts (ms). */\n  delayMs?: number\n  /** Injectable timer pair (tests drive time manually). */\n  setTimer?: (fn: () => void, ms: number) => unknown\n  clearTimer?: (handle: unknown) => void\n}\n\nexport interface ContentSessionSync {\n  /** A content-bearing write succeeded — refresh (debounced) if anyone previews. */\n  markStale(): void\n  /** A preview surface mounted; returns its release. A stale session refreshes now. */\n  addConsumer(): () => void\n  /** Whether a refresh is currently owed (test/introspection seam). */\n  isStale(): boolean\n}\n\n/**\n * The pure orchestrator: stale flag + consumer count + one coalesced refresh.\n *\n * - `markStale` with no consumers only flags; the next `addConsumer` refreshes.\n * - `markStale` with consumers schedules a trailing debounce (bursts coalesce).\n * - A `markStale` DURING an in-flight refresh re-runs once after it settles —\n *   the refresh that was already reading may have missed that write.\n */\nexport function createContentSessionSync(deps: ContentSessionSyncDeps): ContentSessionSync {\n  const delayMs = deps.delayMs ?? 150\n  const setTimer = deps.setTimer ?? ((fn: () => void, ms: number) => setTimeout(fn, ms))\n  const clearTimer = deps.clearTimer ?? ((handle: unknown) => clearTimeout(handle as number))\n\n  let stale = false\n  let consumers = 0\n  let timer: unknown = null\n  let running = false\n  let rerun = false\n\n  function run(): void {\n    if (running) {\n      rerun = true\n      return\n    }\n    running = true\n    stale = false\n    void deps\n      .refresh()\n      .catch(() => {\n        // A failed hydration keeps the session stale so the next trigger retries;\n        // the loader itself already reports the failure loudly (loadCmsIntoSession).\n        stale = true\n      })\n      .finally(() => {\n        running = false\n        if (rerun || (stale && consumers > 0)) {\n          rerun = false\n          schedule()\n        }\n      })\n  }\n\n  function schedule(): void {\n    if (timer !== null) clearTimer(timer)\n    timer = setTimer(() => {\n      timer = null\n      run()\n    }, delayMs)\n  }\n\n  return {\n    markStale() {\n      stale = true\n      if (consumers > 0) schedule()\n    },\n    addConsumer() {\n      consumers += 1\n      if (stale && timer === null && !running) schedule()\n      let released = false\n      return () => {\n        if (released) return\n        released = true\n        consumers -= 1\n      }\n    },\n    isStale() {\n      return stale\n    },\n  }\n}\n\n// --- App wiring (module singleton) -------------------------------------------------\n\ntype Refresher = () => Promise<unknown>\n\nlet currentRefresher: Refresher | null = null\n\nconst sync = createContentSessionSync({\n  refresh: () => currentRefresher?.() ?? Promise.resolve(),\n})\n\n/**\n * Register the active project's session refresher (`ProjectSessionProvider`\n * mounts it with its `loadCms`; leaving the project unregisters). Only one is\n * active at a time — the studio shows one project per session.\n */\nexport function registerContentSessionRefresher(refresher: Refresher): () => void {\n  currentRefresher = refresher\n  return () => {\n    if (currentRefresher === refresher) currentRefresher = null\n  }\n}\n\n/** Mark the shared session stale (the event-bus listener calls this). */\nexport function markContentSessionStale(): void {\n  sync.markStale()\n}\n\n/** Register a mounted preview consumer (the canvas); returns the release. */\nexport function acquireContentSessionConsumer(): () => void {\n  return sync.addConsumer()\n}\n"]}

package/dist/lib/data/index.d.ts

@@ -2,3 +2,5 @@ export * from './data-store.js';
 export * from './sample-capture.js';
 export * from './sources-store.js';
 export * from './collection-content.js';
+export * from './content-session-refresh.js';
+export * from './playground-unload-guard.js';

package/dist/lib/data/index.js

@@ -2,6 +2,8 @@ export * from './data-store.js';
 export * from './sample-capture.js';
 export * from './sources-store.js';
 export * from './collection-content.js';
+export * from './content-session-refresh.js';
+export * from './playground-unload-guard.js';
 // Data providers (EC-167) are imported from './providers' directly: the module
 // exports a `DataProvider` domain type that would collide with the store's
 // `<DataProvider>` React provider in a wildcard barrel.

package/dist/lib/data/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/data/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,+EAA+E;AAC/E,2EAA2E;AAC3E,wDAAwD","sourcesContent":["export * from './data-store'\nexport * from './sample-capture'\nexport * from './sources-store'\nexport * from './collection-content'\n// Data providers (EC-167) are imported from './providers' directly: the module\n// exports a `DataProvider` domain type that would collide with the store's\n// `<DataProvider>` React provider in a wildcard barrel.\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/data/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AACzC,+EAA+E;AAC/E,2EAA2E;AAC3E,wDAAwD","sourcesContent":["export * from './data-store'\nexport * from './sample-capture'\nexport * from './sources-store'\nexport * from './collection-content'\nexport * from './content-session-refresh'\nexport * from './playground-unload-guard'\n// Data providers (EC-167) are imported from './providers' directly: the module\n// exports a `DataProvider` domain type that would collide with the store's\n// `<DataProvider>` React provider in a wildcard barrel.\n"]}

package/dist/lib/data/playground-unload-guard.d.ts

@@ -0,0 +1,22 @@
+import type { OperationEvent } from '@elytracms/studio/lib/operations';
+/** Should this operation event arm the playground unload guard? */
+export declare function shouldArmUnloadGuard(event: OperationEvent, playground?: boolean): boolean;
+export interface UnloadGuardState {
+    /** A qualifying write happened — register the listener once. */
+    arm(): void;
+    /** Is the guard live (listener registered)? */
+    isArmed(): boolean;
+}
+/**
+ * The arm-once state machine. `register` is the injected DOM seam — it is
+ * called exactly once, on the first arm, with the handler that flags the
+ * unload prompt (`event.preventDefault()` + legacy `returnValue`).
+ */
+export declare function createUnloadGuardState(register: (handler: (event: BeforeUnloadEvent) => void) => void): UnloadGuardState;
+/**
+ * Feed an operation event to the guard (the project session's event-bus
+ * subscription calls this alongside the content-session staleness mark).
+ */
+export declare function notePlaygroundWriteForUnloadGuard(event: OperationEvent): void;
+/** Introspection seam (live verification + tests): is the page-level guard armed? */
+export declare function isPlaygroundUnloadGuardArmed(): boolean;

package/dist/lib/data/playground-unload-guard.js

@@ -0,0 +1,73 @@
+/**
+ * EC-461 — the playground `beforeunload` guard.
+ *
+ * The playground's world is one in-memory adapter: a full page unload — a
+ * reload, a Vite full-reload after a source edit (HMR), a hard top-level
+ * navigation, a closed tab — destroys every authored document, schema change,
+ * asset and publish irrecoverably. That is documented semantics, but losing it
+ * SILENTLY is not acceptable once the session actually holds authored state.
+ *
+ * The rule (stated once, applied everywhere): the guard arms in PLAYGROUND
+ * mode only, the first time a content-bearing write command succeeds on the
+ * operations event bus (the same `isContentSessionWrite` predicate the EC-460
+ * content-session sync uses — documents/schema/assets), and never disarms for
+ * the rest of the page's life: any such write means the world has diverged
+ * from its deterministic seed, and nothing short of the unload itself brings
+ * it back. Connected mode never arms — writes persist to the backend within
+ * the autosave rhythm, in-app navigation flushes pending autosaves on unmount,
+ * and explicit-save rails carry their own `UnsavedChangesGuard`; a blanket
+ * unload prompt there would cry wolf on every visit.
+ *
+ * The decision core ({@link createUnloadGuardState}) is pure (house pattern);
+ * the module singleton below injects the real `window` listener registration.
+ * Browsers require sticky user activation to actually show the dialog — an
+ * un-interacted-with tab reloads silently regardless, which is fine: any
+ * authored write implies interaction.
+ */
+import { isPlaygroundMode } from '@elytracms/studio/lib/persistence';
+import { isContentSessionWrite } from './content-session-refresh.js';
+/** Should this operation event arm the playground unload guard? */
+export function shouldArmUnloadGuard(event, playground = isPlaygroundMode()) {
+    return playground && isContentSessionWrite(event);
+}
+/**
+ * The arm-once state machine. `register` is the injected DOM seam — it is
+ * called exactly once, on the first arm, with the handler that flags the
+ * unload prompt (`event.preventDefault()` + legacy `returnValue`).
+ */
+export function createUnloadGuardState(register) {
+    let armed = false;
+    return {
+        arm() {
+            if (armed)
+                return;
+            armed = true;
+            register((event) => {
+                event.preventDefault();
+                // Legacy channel — some browsers still require a truthy returnValue.
+                event.returnValue = '';
+            });
+        },
+        isArmed() {
+            return armed;
+        },
+    };
+}
+// --- App wiring (module singleton) -------------------------------------------------
+const guard = createUnloadGuardState((handler) => {
+    if (typeof window !== 'undefined')
+        window.addEventListener('beforeunload', handler);
+});
+/**
+ * Feed an operation event to the guard (the project session's event-bus
+ * subscription calls this alongside the content-session staleness mark).
+ */
+export function notePlaygroundWriteForUnloadGuard(event) {
+    if (shouldArmUnloadGuard(event))
+        guard.arm();
+}
+/** Introspection seam (live verification + tests): is the page-level guard armed? */
+export function isPlaygroundUnloadGuardArmed() {
+    return guard.isArmed();
+}
+//# sourceMappingURL=playground-unload-guard.js.map

package/dist/lib/data/playground-unload-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground-unload-guard.js","sourceRoot":"","sources":["../../../src/lib/data/playground-unload-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAEpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,mEAAmE;AACnE,MAAM,UAAU,oBAAoB,CAClC,KAAqB,EACrB,aAAsB,gBAAgB,EAAE;IAExC,OAAO,UAAU,IAAI,qBAAqB,CAAC,KAAK,CAAC,CAAA;AACnD,CAAC;AASD;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAA+D;IAE/D,IAAI,KAAK,GAAG,KAAK,CAAA;IACjB,OAAO;QACL,GAAG;YACD,IAAI,KAAK;gBAAE,OAAM;YACjB,KAAK,GAAG,IAAI,CAAA;YACZ,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,KAAK,CAAC,cAAc,EAAE,CAAA;gBACtB,qEAAqE;gBACrE,KAAK,CAAC,WAAW,GAAG,EAAE,CAAA;YACxB,CAAC,CAAC,CAAA;QACJ,CAAC;QACD,OAAO;YACL,OAAO,KAAK,CAAA;QACd,CAAC;KACF,CAAA;AACH,CAAC;AAED,sFAAsF;AAEtF,MAAM,KAAK,GAAG,sBAAsB,CAAC,CAAC,OAAO,EAAE,EAAE;IAC/C,IAAI,OAAO,MAAM,KAAK,WAAW;QAAE,MAAM,CAAC,gBAAgB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAA;AACrF,CAAC,CAAC,CAAA;AAEF;;;GAGG;AACH,MAAM,UAAU,iCAAiC,CAAC,KAAqB;IACrE,IAAI,oBAAoB,CAAC,KAAK,CAAC;QAAE,KAAK,CAAC,GAAG,EAAE,CAAA;AAC9C,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,4BAA4B;IAC1C,OAAO,KAAK,CAAC,OAAO,EAAE,CAAA;AACxB,CAAC","sourcesContent":["/**\n * EC-461 — the playground `beforeunload` guard.\n *\n * The playground's world is one in-memory adapter: a full page unload — a\n * reload, a Vite full-reload after a source edit (HMR), a hard top-level\n * navigation, a closed tab — destroys every authored document, schema change,\n * asset and publish irrecoverably. That is documented semantics, but losing it\n * SILENTLY is not acceptable once the session actually holds authored state.\n *\n * The rule (stated once, applied everywhere): the guard arms in PLAYGROUND\n * mode only, the first time a content-bearing write command succeeds on the\n * operations event bus (the same `isContentSessionWrite` predicate the EC-460\n * content-session sync uses — documents/schema/assets), and never disarms for\n * the rest of the page's life: any such write means the world has diverged\n * from its deterministic seed, and nothing short of the unload itself brings\n * it back. Connected mode never arms — writes persist to the backend within\n * the autosave rhythm, in-app navigation flushes pending autosaves on unmount,\n * and explicit-save rails carry their own `UnsavedChangesGuard`; a blanket\n * unload prompt there would cry wolf on every visit.\n *\n * The decision core ({@link createUnloadGuardState}) is pure (house pattern);\n * the module singleton below injects the real `window` listener registration.\n * Browsers require sticky user activation to actually show the dialog — an\n * un-interacted-with tab reloads silently regardless, which is fine: any\n * authored write implies interaction.\n */\nimport { isPlaygroundMode } from '@elytracms/studio/lib/persistence'\nimport type { OperationEvent } from '@elytracms/studio/lib/operations'\nimport { isContentSessionWrite } from './content-session-refresh'\n\n/** Should this operation event arm the playground unload guard? */\nexport function shouldArmUnloadGuard(\n  event: OperationEvent,\n  playground: boolean = isPlaygroundMode(),\n): boolean {\n  return playground && isContentSessionWrite(event)\n}\n\nexport interface UnloadGuardState {\n  /** A qualifying write happened — register the listener once. */\n  arm(): void\n  /** Is the guard live (listener registered)? */\n  isArmed(): boolean\n}\n\n/**\n * The arm-once state machine. `register` is the injected DOM seam — it is\n * called exactly once, on the first arm, with the handler that flags the\n * unload prompt (`event.preventDefault()` + legacy `returnValue`).\n */\nexport function createUnloadGuardState(\n  register: (handler: (event: BeforeUnloadEvent) => void) => void,\n): UnloadGuardState {\n  let armed = false\n  return {\n    arm() {\n      if (armed) return\n      armed = true\n      register((event) => {\n        event.preventDefault()\n        // Legacy channel — some browsers still require a truthy returnValue.\n        event.returnValue = ''\n      })\n    },\n    isArmed() {\n      return armed\n    },\n  }\n}\n\n// --- App wiring (module singleton) -------------------------------------------------\n\nconst guard = createUnloadGuardState((handler) => {\n  if (typeof window !== 'undefined') window.addEventListener('beforeunload', handler)\n})\n\n/**\n * Feed an operation event to the guard (the project session's event-bus\n * subscription calls this alongside the content-session staleness mark).\n */\nexport function notePlaygroundWriteForUnloadGuard(event: OperationEvent): void {\n  if (shouldArmUnloadGuard(event)) guard.arm()\n}\n\n/** Introspection seam (live verification + tests): is the page-level guard armed? */\nexport function isPlaygroundUnloadGuardArmed(): boolean {\n  return guard.isArmed()\n}\n"]}

package/dist/lib/i18n/messages.de.js

@@ -215,7 +215,7 @@ export const deMessages = {
     'cms.list.emptyNone': 'Noch keine {noun}.',
     'cms.list.emptyFiltered': 'Keine Dokumente entsprechen den Filtern der aktuellen Ansicht.',
     'cms.list.selectAll': 'Alle Dokumente in der Ansicht auswählen',
-    'cms.list.selectRow': '{id} auswählen',
+    'cms.list.selectRow': '{title} auswählen',
     'cms.list.column.title': 'Titel',
     'cms.list.column.state': 'Status',
     // EC-448 — Icon-Header der fixierten Status-Punkt-Spalte (nur `aria-label`/`title`).
@@ -306,6 +306,7 @@ export const deMessages = {
     'cms.cell.blockCount.other': '{count} Blöcke',
     'cms.cell.createsVariantTitle': 'Beim Speichern wird die {locale}-Übersetzung dieses Feldes erstellt.',
     'cms.cell.newVariant': 'neu',
+    'cms.cell.editAria': '{field} von {title} bearbeiten',
     // ─────────────────────────────────────────────────────────────────────────
     // CMS — document detail editor
     // ─────────────────────────────────────────────────────────────────────────
@@ -940,6 +941,7 @@ export const deMessages = {
     'builder.canvas.reusableMissingTitle': 'Dieses wiederverwendbare Element fehlt',
     'builder.canvas.reusableUnpublishedHint': 'Veröffentlichen Sie es, um es hier und auf Live-Seiten anzuzeigen — oder öffnen Sie es im Eigenschaften-Panel, um weiter zu bearbeiten.',
     'builder.canvas.reusableMissingHint': 'Öffnen Sie das „Element“ der Einbettung im Eigenschaften-Panel, um die Referenz zu korrigieren.',
+    'builder.canvas.listingInvalidTitle': 'Diese Liste kann nicht ausgeführt werden:',
     'builder.canvas.viewportPreviewAria': '{label} Vorschau',
     'builder.canvas.viewportWidthTitle': '{label} Breite',
     'builder.canvas.breakpointsIssueLabel': 'Breakpoints',