@elytracms/studio 0.0.1

package/dist/components/cms/cms-store.js

@@ -0,0 +1,702 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { createCollectionRegistry, createDocumentStore, documentKey, documentSchema, resolveField, sampleDocuments, sampleFilterableCollections, sampleLocaleConfig, samplePublishedKeys, singletonDocId, titleFieldOf, validateDocument, } from '@elytracms/cms-core';
+import { validateCompositionValue } from '@elytracms/project-graph';
+import { collectComponentEmbeds, parseRichTextValue } from '@elytracms/rich-text';
+import { configureStudioLocales, useStudioLocale } from '@elytracms/studio/lib/locale';
+import { getStudioRegistry } from '@elytracms/studio/lib/registry';
+import { slugify } from '@elytracms/studio/lib/utils';
+import { createCmsPersister, getStudioOperations } from '@elytracms/studio/lib/operations';
+import { ALL_VIEW_ID, canonicalViewState, defaultViewState, deleteSavedView, loadSavedViews, newViewId, normalizeViewState, saveSavedView, viewStatesEqual, } from '@elytracms/studio/lib/cms-views';
+import { useOptionalAssets } from '../assets/assets-store';
+import { commitCellEdit } from './cell-edit';
+import { runBulkAction } from './bulk-actions';
+/** Demo per-field access (brief §8.4, EC-078). Read-only fields render disabled. */
+const READ_ONLY_FIELDS = {
+    asset: ['url'],
+};
+/**
+ * Mint a collision-safe, slug-derived page id (EC-192): the slug of the page name,
+ * suffixed `-2`/`-3`/… until it is free among the ids already taken. Empty or
+ * symbol-only names fall back to `page`. Pure so the id rule is testable without
+ * the store; `createPage` applies it against the live page documents.
+ */
+export function nextPageId(name, taken) {
+    const base = slugify(name) || 'page';
+    let id = base;
+    for (let n = 2; taken.has(id); n += 1)
+        id = `${base}-${n}`;
+    return id;
+}
+/**
+ * EC-188: validate a `blocks` composition field value against the field's `allow`
+ * vocabulary + the code-owned component registry (the leash), mapping graph
+ * issues into plain CMS findings. Injected into `validateDocument` so cms-core
+ * stays free of `@elytracms/project-graph`. Never throws — a malformed (non-node)
+ * value degrades to a single finding, matching the "validation is first-class,
+ * never a crash" rule.
+ */
+function validateComposition(value, field) {
+    if (value == null)
+        return [];
+    const roots = Array.isArray(value) ? value : [value];
+    if (!roots.every((r) => r != null && typeof r === 'object' && 'componentId' in r)) {
+        return [{ message: 'is not a valid composition (expected component nodes)', severity: 'error' }];
+    }
+    const components = getStudioRegistry().registry.lookup;
+    return validateCompositionValue(value, {
+        allow: field.allow,
+        components,
+    }).map((issue) => ({
+        message: issue.message,
+        severity: issue.severity,
+        nodePath: issue.path.join('/'),
+    }));
+}
+/**
+ * EC-189: validate the composition embeds inside a `richText` field value. Each
+ * `componentEmbed` holds a single `ComponentNode` constrained by the field's
+ * `allow` vocabulary (the SAME leash a `blocks` field uses). Parse the value, walk
+ * its embeds at any depth, and validate each embedded node via
+ * `validateCompositionValue`; findings carry the rich-text node path joined with
+ * the in-embed graph path. Injected into `validateDocument` so cms-core depends on
+ * neither `@elytracms/project-graph` nor `@elytracms/rich-text`. Never throws — a
+ * malformed embed degrades to a single finding.
+ */
+function validateRichTextEmbeds(value, field) {
+    if (value == null)
+        return [];
+    const parsed = parseRichTextValue(value);
+    // A plain-string / schema-invalid rich-text value carries no embeds to check
+    // here (scalar type validation owns reporting a malformed value).
+    if (!parsed.ok)
+        return [];
+    const components = getStudioRegistry().registry.lookup;
+    const out = [];
+    for (const occurrence of collectComponentEmbeds(parsed.value.doc)) {
+        if (!occurrence.embedded) {
+            out.push({
+                message: `embed at ${occurrence.nodePath} is missing a valid embedded component`,
+                severity: 'error',
+                nodePath: occurrence.nodePath,
+            });
+            continue;
+        }
+        for (const issue of validateCompositionValue(occurrence.embedded, {
+            allow: field.allow,
+            components,
+        })) {
+            out.push({
+                message: issue.message,
+                severity: issue.severity,
+                nodePath: `${occurrence.nodePath}/attrs/node/${issue.path.join('/')}`,
+            });
+        }
+    }
+    return out;
+}
+const CmsContext = createContext(null);
+function primaryField(collection) {
+    return titleFieldOf(collection)?.name ?? collection.fields[0]?.name ?? 'id';
+}
+/** The unnamed built-in view: no filters, no sort, every field visible. */
+function defaultView(collection) {
+    return {
+        id: ALL_VIEW_ID,
+        name: 'All documents',
+        state: collection
+            ? defaultViewState(collection)
+            : { filters: [], sort: null, columns: [], hidden: [] },
+    };
+}
+/**
+ * The CMS session store (EC-141): documents and collections are optimistic,
+ * synchronous session state (live validation while typing); every mutation —
+ * create/save/delete/state transitions — is mirrored onto the operations
+ * layer (`documents.*` / `schema.*` commands) through {@link createCmsPersister}.
+ * Failed/denied commands surface as {@link CmsStore.persistError}.
+ */
+export function CmsProvider({ children, projectId, initialCollections, initialDocuments, initialPublishedKeys, initialLocaleConfig, }) {
+    const [documents, setDocuments] = useState(() => (initialDocuments ?? sampleDocuments).map((d) => structuredClone(d)));
+    // Published-ness as the version POINTER (EC-224), decoupled from the flat
+    // `state` enum: seeded from hydration's pointer set, or — when none is supplied
+    // — the canonical sample published set for the playground. A kit's imported
+    // content (`initialDocuments` without a pointer set) starts unpublished
+    // (drafts) until an editor publishes it. The flat `state` is never consulted.
+    const [publishedKeys, setPublishedKeys] = useState(() => {
+        if (initialPublishedKeys)
+            return new Set(initialPublishedKeys);
+        return new Set(initialDocuments ? [] : samplePublishedKeys);
+    });
+    // Named saved views per collection (EC-169): loaded from the operations
+    // layer (project-scoped, shared across editors) and mutated through it.
+    const [savedViews, setSavedViews] = useState({});
+    const [activeViews, setActiveViews] = useState({});
+    // The live table state per collection where it diverges from the active
+    // view; absent key = exactly the active view's state (not dirty).
+    const [tableStates, setTableStates] = useState({});
+    // Collections are stateful so AI-generated schemas (EC-097) can be accepted
+    // into the session. The session schema IS the source the sort/filter
+    // offering follows (EC-177 gap 3): hydrated sessions receive the persisted
+    // schema via `initialCollections`; the fixture fallback is the canonical
+    // cms-core sample schema WITH its declared `filterable` flags — no
+    // session-side widenings, so the studio never offers a field the backend's
+    // delivery engine would reject.
+    const [collections, setCollections] = useState(() => [
+        ...(initialCollections ?? sampleFilterableCollections),
+    ]);
+    const [persistError, setPersistError] = useState(null);
+    const seq = useRef(0);
+    // Latest session state for the persister's lazy baseline (no re-subscribing).
+    const collectionsRef = useRef(collections);
+    collectionsRef.current = collections;
+    const documentsRef = useRef(documents);
+    documentsRef.current = documents;
+    const persisterRef = useRef(null);
+    if (persisterRef.current === null && projectId !== undefined) {
+        persisterRef.current = createCmsPersister({
+            projectId,
+            getOperations: async () => (await getStudioOperations()).operations,
+            getCollections: () => collectionsRef.current,
+            getDocuments: () => documentsRef.current,
+            onError: setPersistError,
+        });
+    }
+    const registry = useMemo(() => createCollectionRegistry(collections), [collections]);
+    const store = useMemo(() => createDocumentStore(documents), [documents]);
+    const localeConfig = initialLocaleConfig ?? sampleLocaleConfig;
+    // Asset existence is validated against the REAL asset library (assets live in
+    // their own repository, not as CMS documents). With the ambient AssetsProvider
+    // present, the oracle is the set of uploaded asset ids — but only once loaded;
+    // while it loads we are optimistic so a valid upload is never transiently
+    // flagged "unknown". With no provider (tests/fixtures), the oracle is absent
+    // and asset existence falls back to the document store.
+    const assetStore = useOptionalAssets();
+    const assetExists = useMemo(() => {
+        if (!assetStore)
+            return undefined;
+        if (assetStore.status !== 'ready')
+            return () => true;
+        const ids = new Set(assetStore.assets.map((asset) => asset.id));
+        return (id) => ids.has(id);
+    }, [assetStore]);
+    // The ambient studio locale (EC-176): this session's locale config drives
+    // the switcher options; every CMS surface follows the one active locale.
+    const { locale: activeLocale } = useStudioLocale();
+    useEffect(() => {
+        configureStudioLocales(localeConfig);
+    }, [localeConfig]);
+    const getCollection = useCallback((id) => registry.get(id), [registry]);
+    const getDocument = useCallback((ref) => documents.find((d) => d.collection === ref.collection && d.id === ref.id), [documents]);
+    const titleOf = useCallback((ref) => {
+        const doc = documents.find((d) => d.collection === ref.collection && d.id === ref.id);
+        const collection = registry.get(ref.collection);
+        if (!doc || !collection)
+            return ref.id;
+        // Resolve through the locale layer in the ambient active locale (EC-176)
+        // with EC-018 fallback, so localized titles follow the switcher.
+        const { value } = resolveField(collection, doc, primaryField(collection), activeLocale, localeConfig);
+        return typeof value === 'string' && value ? value : ref.id;
+    }, [documents, registry, localeConfig, activeLocale]);
+    const saveDocument = useCallback((doc) => {
+        setDocuments((prev) => {
+            const i = prev.findIndex((d) => d.collection === doc.collection && d.id === doc.id);
+            if (i < 0)
+                return [...prev, doc];
+            const next = [...prev];
+            next[i] = doc;
+            return next;
+        });
+        persisterRef.current?.upsertDocument(doc);
+    }, []);
+    const commitFieldEdit = useCallback((input) => {
+        const replaceWith = (doc) => setDocuments((prev) => prev.map((d) => (d.collection === doc.collection && d.id === doc.id ? doc : d)));
+        const persister = persisterRef.current;
+        return commitCellEdit({
+            registry,
+            documents: documentsRef.current,
+            localeConfig,
+            applySession: replaceWith,
+            rollbackSession: replaceWith,
+            ...(persister && projectId !== undefined
+                ? {
+                    dispatch: async (next) => {
+                        // Make sure the persisted baseline + every queued mutation
+                        // landed first, then issue the commit's single command.
+                        await persister.ensureBaseline();
+                        const { operations } = await getStudioOperations();
+                        return operations.documents.upsert({ projectId, document: next });
+                    },
+                }
+                : {}),
+        }, input);
+    }, [registry, localeConfig, projectId]);
+    const createDocument = useCallback((collectionId) => {
+        seq.current += 1;
+        const id = `new-${collectionId}-${seq.current}`;
+        const doc = { collection: collectionId, id, values: {} };
+        setDocuments((prev) => [...prev, doc]);
+        persisterRef.current?.upsertDocument(doc);
+        return { collection: collectionId, id };
+    }, []);
+    // EC-192: create a named page document with a stable, slug-derived id (not an
+    // opaque `new-page-N`), so the route bound to it reads as a real address and
+    // the id survives as the canonical key. Collision-safe against existing page
+    // ids. The route itself is written by the caller (NewPageDialog) through the
+    // operations layer, so the two writes stay in their own concerns.
+    const createPage = useCallback((input) => {
+        const collectionId = 'page';
+        const taken = new Set(documentsRef.current.filter((d) => d.collection === collectionId).map((d) => d.id));
+        const id = nextPageId(input.name, taken);
+        const doc = {
+            collection: collectionId,
+            id,
+            values: { name: input.name },
+        };
+        setDocuments((prev) => [...prev, doc]);
+        persisterRef.current?.upsertDocument(doc);
+        return { collection: collectionId, id };
+    }, []);
+    // EC-217: a singleton collection has exactly one document, keyed by the
+    // collection id (`singletonDocId`). The detail editor opens through this, so
+    // the single document is materialized on first visit (an empty draft, persisted
+    // like any create). Idempotent: never duplicates if it already exists.
+    const ensureSingletonDocument = useCallback((collectionId) => {
+        const collection = registry.get(collectionId);
+        const id = collection ? singletonDocId(collection) : collectionId;
+        const ref = { collection: collectionId, id };
+        const exists = documentsRef.current.some((d) => d.collection === collectionId && d.id === id);
+        if (!exists) {
+            const doc = { collection: collectionId, id, values: {} };
+            setDocuments((prev) => prev.some((d) => d.collection === collectionId && d.id === id) ? prev : [...prev, doc]);
+            persisterRef.current?.upsertDocument(doc);
+        }
+        return ref;
+    }, [registry]);
+    const deleteDocument = useCallback((ref) => {
+        setDocuments((prev) => prev.filter((d) => !(d.collection === ref.collection && d.id === ref.id)));
+        persisterRef.current?.deleteDocument(ref);
+    }, []);
+    // EC-224: published-ness IS the version pointer (`publishedKeys`) — the SOLE
+    // studio source of truth, read via `isPublished`. The live row stays a
+    // continuous draft (Sanity model); no flat `state` mirror is maintained. Every
+    // reader now consults the pointer (the table badge/$state via `isPublished`,
+    // the preview engine via the pin), so the flat field is read by nothing here.
+    const setPublished = useCallback((ref, published) => {
+        const key = documentKey(ref);
+        setPublishedKeys((prev) => {
+            if (prev.has(key) === published)
+                return prev;
+            const next = new Set(prev);
+            if (published)
+                next.add(key);
+            else
+                next.delete(key);
+            return next;
+        });
+    }, []);
+    const isPublished = useCallback((ref) => publishedKeys.has(documentKey(ref)), [publishedKeys]);
+    // Reconcile published-ness for a ref against the AUTHORITATIVE backend record
+    // (EC-225): the optimistic flip is a guess; once the queued op settles we read
+    // the actual pin so the badge can never claim a state the backend refused
+    // (a publish blocked by field rules, an unpublish blocked by a strict ref).
+    const reconcilePublished = useCallback(async (ref) => {
+        if (projectId === undefined)
+            return;
+        const { operations } = await getStudioOperations();
+        const record = await operations.documents.get({ projectId, ref });
+        if (record.ok)
+            setPublished(ref, record.value.publishedVersion !== undefined);
+    }, [projectId, setPublished]);
+    const publishDocument = useCallback(async (ref) => {
+        setPublished(ref, true); // optimistic
+        persisterRef.current?.publishDocument(ref);
+        await persisterRef.current?.flush();
+        await reconcilePublished(ref);
+    }, [setPublished, reconcilePublished]);
+    const unpublishDocument = useCallback(async (ref) => {
+        setPublished(ref, false); // optimistic
+        persisterRef.current?.unpublishDocument(ref);
+        await persisterRef.current?.flush();
+        await reconcilePublished(ref);
+    }, [setPublished, reconcilePublished]);
+    const loadDocumentVersions = useCallback(async (ref) => {
+        // No persisted backend (fixture/playground): no recorded history.
+        if (projectId === undefined)
+            return { versions: [] };
+        const { operations } = await getStudioOperations();
+        const [versionsRes, recordRes] = await Promise.all([
+            operations.documents.listVersions({ projectId, ref }),
+            operations.documents.get({ projectId, ref }),
+        ]);
+        if (!versionsRes.ok) {
+            setPersistError(versionsRes.error);
+            return { versions: [] };
+        }
+        // The pinned (live) version comes off the document record; a never-saved
+        // doc simply has no record (and no versions) — not an error to surface.
+        const publishedVersion = recordRes.ok ? recordRes.value.publishedVersion : undefined;
+        return {
+            versions: versionsRes.value,
+            ...(publishedVersion !== undefined ? { publishedVersion } : {}),
+        };
+    }, [projectId]);
+    const restoreDocumentVersion = useCallback(async (ref, version) => {
+        if (projectId === undefined)
+            return null;
+        // Land any queued edits before the restore reads the current draft to
+        // snapshot it (same ordering contract as commitFieldEdit/runBulk).
+        await persisterRef.current?.ensureBaseline();
+        const { operations } = await getStudioOperations();
+        const result = await operations.documents.restore({ projectId, ref, version });
+        if (!result.ok) {
+            setPersistError(result.error);
+            return null;
+        }
+        const restored = result.value.document;
+        setDocuments((prev) => prev.map((d) => d.collection === restored.collection && d.id === restored.id ? restored : d));
+        return restored;
+    }, [projectId]);
+    const validate = useCallback((doc) => validateDocument(registry, doc, {
+        store,
+        localeConfig,
+        validateComposition,
+        validateRichTextEmbeds,
+        // EC-224: the EC-173 weak-reference warning sources published-ness from
+        // the version pointer, so editing a published doc that references an
+        // unpublished target surfaces the fallback warning again (it had gone
+        // inert once the flat `state` mirror was dropped in B-3b).
+        isPublished,
+        assetExists,
+    }), [registry, store, localeConfig, isPublished, assetExists]);
+    const importDocuments = useCallback((collectionId, raw) => {
+        const report = { added: 0, rejected: [] };
+        // Pre-parse so intra-batch relation/asset targets resolve during validation.
+        const parsedBatch = [];
+        const schemaFails = [];
+        for (const item of raw) {
+            const parsed = documentSchema.safeParse({ ...item, collection: collectionId });
+            if (parsed.success)
+                parsedBatch.push(parsed.data);
+            else
+                schemaFails.push({ item, error: parsed });
+        }
+        for (const { item, error } of schemaFails) {
+            report.rejected.push({
+                id: item?.id ?? '(no id)',
+                issues: (error.success ? [] : error.error.issues).map((e) => ({
+                    code: 'invalid-field-value',
+                    severity: 'error',
+                    message: e.message,
+                    path: e.path.map((p) => (typeof p === 'symbol' ? String(p) : p)),
+                })),
+            });
+        }
+        // Validate each against existing docs PLUS the rest of the batch.
+        const batchStore = createDocumentStore([...documents, ...parsedBatch]);
+        const accepted = [];
+        for (const doc of parsedBatch) {
+            const issues = validateDocument(registry, doc, { store: batchStore, localeConfig, assetExists });
+            const errors = issues.filter((iss) => iss.severity === 'error');
+            if (errors.length > 0)
+                report.rejected.push({ id: doc.id, issues: errors });
+            else
+                accepted.push(doc);
+        }
+        if (accepted.length > 0) {
+            setDocuments((prev) => {
+                const next = [...prev];
+                for (const doc of accepted) {
+                    const i = next.findIndex((d) => d.collection === doc.collection && d.id === doc.id);
+                    if (i < 0)
+                        next.push(doc);
+                    else
+                        next[i] = doc;
+                }
+                return next;
+            });
+            for (const doc of accepted)
+                persisterRef.current?.upsertDocument(doc);
+            // EC-224: imports land as the working DRAFT. Publish-ness is the version
+            // pointer (`publishedKeys`), set by publishing — never carried in the
+            // imported row — so an import never auto-publishes; the editor publishes
+            // explicitly afterward.
+            report.added = accepted.length;
+        }
+        return report;
+    }, [registry, documents, localeConfig, assetExists]);
+    const isFieldReadOnly = useCallback((collectionId, field) => {
+        return (field.form?.readOnly === true ||
+            (READ_ONLY_FIELDS[collectionId]?.includes(field.name) ?? false));
+    }, []);
+    // --- Saved views (EC-169) -------------------------------------------------
+    // Load the project's persisted views once (operations query). Views saved by
+    // other editors/sessions on the same project show up here.
+    useEffect(() => {
+        if (projectId === undefined)
+            return;
+        let cancelled = false;
+        void getStudioOperations()
+            .then(({ operations }) => loadSavedViews(operations, projectId))
+            .then((result) => {
+            if (cancelled)
+                return;
+            if (!result.ok) {
+                setPersistError(result.error);
+                return;
+            }
+            const grouped = {};
+            for (const record of result.value) {
+                ;
+                (grouped[record.collection] ??= []).push({
+                    id: record.id,
+                    name: record.name,
+                    state: record.state,
+                });
+            }
+            setSavedViews(grouped);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [projectId]);
+    const viewsOf = useCallback((collectionId) => [
+        defaultView(registry.get(collectionId)),
+        ...(savedViews[collectionId] ?? []),
+    ], [registry, savedViews]);
+    const activeViewOf = useCallback((collectionId) => {
+        const id = activeViews[collectionId] ?? ALL_VIEW_ID;
+        return (viewsOf(collectionId).find((view) => view.id === id) ??
+            defaultView(registry.get(collectionId)));
+    }, [activeViews, viewsOf, registry]);
+    const tableStateOf = useCallback((collectionId) => tableStates[collectionId] ?? activeViewOf(collectionId).state, [tableStates, activeViewOf]);
+    const dropTableState = useCallback((collectionId) => {
+        setTableStates((prev) => {
+            if (!(collectionId in prev))
+                return prev;
+            const next = { ...prev };
+            delete next[collectionId];
+            return next;
+        });
+    }, []);
+    const setActiveView = useCallback((collectionId, viewId) => {
+        setActiveViews((prev) => ({ ...prev, [collectionId]: viewId }));
+        dropTableState(collectionId);
+    }, [dropTableState]);
+    /**
+     * Run one persisted view mutation: pending content mutations + the persisted
+     * baseline land first (so the system collection never pre-empts the content
+     * schema), then exactly one operations command. Failures surface as
+     * `persistError` and report `false` — the session is only updated on success.
+     */
+    const dispatchViewMutation = useCallback(async (run) => {
+        if (projectId === undefined)
+            return true; // fixture-only session: views stay session-local
+        await persisterRef.current?.ensureBaseline();
+        const { operations } = await getStudioOperations();
+        const result = await run(operations, projectId);
+        if (!result.ok) {
+            setPersistError(result.error);
+            return false;
+        }
+        return true;
+    }, [projectId]);
+    const saveViewAs = useCallback(async (collectionId, name) => {
+        const trimmed = name.trim();
+        if (trimmed === '')
+            return false;
+        const id = newViewId();
+        const state = normalizeViewState(tableStateOf(collectionId));
+        const ok = await dispatchViewMutation((operations, pid) => saveSavedView(operations, pid, { id, name: trimmed, collection: collectionId, state }));
+        if (!ok)
+            return false;
+        setSavedViews((prev) => ({
+            ...prev,
+            [collectionId]: [...(prev[collectionId] ?? []), { id, name: trimmed, state }],
+        }));
+        setActiveViews((prev) => ({ ...prev, [collectionId]: id }));
+        dropTableState(collectionId);
+        return true;
+    }, [dispatchViewMutation, tableStateOf, dropTableState]);
+    const saveActiveView = useCallback(async (collectionId) => {
+        const activeId = activeViews[collectionId] ?? ALL_VIEW_ID;
+        if (activeId === ALL_VIEW_ID)
+            return false; // the default view is not persistable
+        const current = (savedViews[collectionId] ?? []).find((view) => view.id === activeId);
+        if (!current)
+            return false;
+        const state = normalizeViewState(tableStateOf(collectionId));
+        const ok = await dispatchViewMutation((operations, pid) => saveSavedView(operations, pid, {
+            id: activeId,
+            name: current.name,
+            collection: collectionId,
+            state,
+        }));
+        if (!ok)
+            return false;
+        setSavedViews((prev) => ({
+            ...prev,
+            [collectionId]: (prev[collectionId] ?? []).map((view) => view.id === activeId ? { ...view, state } : view),
+        }));
+        dropTableState(collectionId);
+        return true;
+    }, [activeViews, savedViews, dispatchViewMutation, tableStateOf, dropTableState]);
+    const deleteView = useCallback(async (collectionId, viewId) => {
+        if (viewId === ALL_VIEW_ID)
+            return false;
+        // One documents.delete against the views system collection — content
+        // documents are untouched by construction.
+        const ok = await dispatchViewMutation((operations, pid) => deleteSavedView(operations, pid, viewId));
+        if (!ok)
+            return false;
+        setSavedViews((prev) => ({
+            ...prev,
+            [collectionId]: (prev[collectionId] ?? []).filter((view) => view.id !== viewId),
+        }));
+        if ((activeViews[collectionId] ?? ALL_VIEW_ID) === viewId) {
+            setActiveViews((prev) => ({ ...prev, [collectionId]: ALL_VIEW_ID }));
+            dropTableState(collectionId);
+        }
+        return true;
+    }, [dispatchViewMutation, activeViews, dropTableState]);
+    // --- Bulk actions (EC-169) ------------------------------------------------
+    const runBulk = useCallback(async (collectionId, ids, action) => {
+        let dispatch;
+        const persister = persisterRef.current;
+        if (persister && projectId !== undefined) {
+            // Pending queued mutations + baseline land first, then one awaited
+            // command per item (same ordering contract as commitFieldEdit).
+            await persister.ensureBaseline();
+            const { operations } = await getStudioOperations();
+            dispatch = (bulkAction, ref) => bulkAction === 'delete'
+                ? operations.documents.delete({ projectId, ref })
+                : bulkAction === 'publish'
+                    ? operations.documents.publish({ projectId, ref })
+                    : operations.documents.unpublish({ projectId, ref });
+        }
+        return runBulkAction({
+            documents: documentsRef.current,
+            titleOf,
+            validate: (doc) => validateDocument(registry, doc, {
+                store: createDocumentStore(documentsRef.current),
+                localeConfig,
+                // EC-225: include the composition validators so a bulk PUBLISH
+                // gates blocks/richText validity the same way the detail editor
+                // does — the operations-layer publish gate has no component
+                // registry, so composition validity is a studio-validation invariant.
+                validateComposition,
+                validateRichTextEmbeds,
+                assetExists,
+            }),
+            // EC-224: a succeeded publish/unpublish moves the version pointer
+            // (`publishedKeys`); the flat `state` mirror is updated in lockstep.
+            applyState: (ref, state) => setPublished(ref, state === 'published'),
+            applyDelete: (ref) => setDocuments((prev) => prev.filter((d) => !(d.collection === ref.collection && d.id === ref.id))),
+            ...(dispatch ? { dispatch } : {}),
+        }, collectionId, ids, action);
+    }, [projectId, titleOf, registry, localeConfig, setPublished, assetExists]);
+    const store$ = useMemo(() => ({
+        ...(projectId !== undefined ? { projectId } : {}),
+        collections,
+        localeConfig,
+        activeLocale,
+        getCollection,
+        documentsOf: (collectionId) => documents.filter((d) => d.collection === collectionId),
+        getDocument,
+        titleOf,
+        saveDocument,
+        commitFieldEdit,
+        createDocument,
+        createPage,
+        ensureSingletonDocument,
+        deleteDocument,
+        isPublished,
+        publishDocument,
+        unpublishDocument,
+        loadDocumentVersions,
+        restoreDocumentVersion,
+        importDocuments,
+        validate,
+        isFieldReadOnly,
+        viewsOf,
+        activeViewId: (collectionId) => activeViews[collectionId] ?? ALL_VIEW_ID,
+        setActiveView,
+        tableStateOf,
+        setTableState: (collectionId, update) => setTableStates((prev) => {
+            const current = prev[collectionId] ?? activeViewOf(collectionId).state;
+            const next = typeof update === 'function' ? update(current) : update;
+            return { ...prev, [collectionId]: next };
+        }),
+        isViewDirty: (collectionId) => {
+            const working = tableStates[collectionId];
+            if (working === undefined)
+                return false;
+            const active = activeViewOf(collectionId).state;
+            const collection = registry.get(collectionId);
+            if (collection === undefined)
+                return !viewStatesEqual(working, active);
+            // Compare schema-resolved forms (EC-213): a column-order reconciliation
+            // or a stale `hidden` entry must not read as an unsaved edit.
+            return !viewStatesEqual(canonicalViewState(collection, working), canonicalViewState(collection, active));
+        },
+        resetTableState: dropTableState,
+        saveActiveView,
+        saveViewAs,
+        deleteView,
+        runBulk,
+        addCollection: (def) => setCollections((prev) => [...prev.filter((c) => c.id !== def.id), def]),
+        persistError,
+        clearPersistError: () => setPersistError(null),
+        ensurePersistedBaseline: () => persisterRef.current?.ensureBaseline() ?? Promise.resolve(),
+        flushPersistence: () => persisterRef.current?.flush() ?? Promise.resolve(),
+    }), [
+        projectId,
+        collections,
+        documents,
+        localeConfig,
+        activeLocale,
+        getCollection,
+        getDocument,
+        titleOf,
+        saveDocument,
+        commitFieldEdit,
+        createDocument,
+        createPage,
+        ensureSingletonDocument,
+        deleteDocument,
+        isPublished,
+        publishDocument,
+        unpublishDocument,
+        loadDocumentVersions,
+        restoreDocumentVersion,
+        importDocuments,
+        validate,
+        isFieldReadOnly,
+        viewsOf,
+        activeViews,
+        activeViewOf,
+        tableStates,
+        tableStateOf,
+        setActiveView,
+        dropTableState,
+        saveActiveView,
+        saveViewAs,
+        deleteView,
+        runBulk,
+        registry,
+        persistError,
+    ]);
+    return _jsx(CmsContext.Provider, { value: store$, children: children });
+}
+export function useCms() {
+    const store = useContext(CmsContext);
+    if (!store)
+        throw new Error('useCms must be used within a <CmsProvider>.');
+    return store;
+}
+/** Export a locale-aware label for a field (form label or name). */
+export function fieldLabel(field) {
+    return field.form?.label ?? field.name;
+}
+export { primaryField };
+//# sourceMappingURL=cms-store.js.map