@elytracms/studio 0.0.93 → 0.0.95

package/dist/lib/cms/published-documents.d.ts

@@ -1,5 +1,7 @@
 import type { CmsDocument } from '@elytracms/core/cms-core';
+import type { OperationError } from '@elytracms/core/operations';
 import type { OperationsClient } from '../operations/index.js';
+import type { ReadState } from '../query/index.js';
 /**
  * The PUBLISHED-perspective documents of a collection (EC-205, "live = published")
  * — the pinned published snapshot of each currently-published document, keyed by
@@ -13,12 +15,13 @@ import type { OperationsClient } from '../operations/index.js';
  * seam — invalidated only when a command that moves a live pin succeeds (NOT on
  * every autosave upsert — a draft edit doesn't change what's published). Cost: ONE
  * bulk `documents.listPublished` read (EC-307).
+ *
+ * EC-628: the pool is a {@link ReadState} — `ready` carries the pinned published snapshot
+ * per published document id; a failed read is `error` with the localized reason, and
+ * every surface reading the pool (the list's URL column, the editor header's live link)
+ * shows it. A failure is never an empty pool: an empty pool says "nothing is published".
  */
-export interface PublishedDocuments {
-    /** Pinned published snapshot per published document id. Empty while loading. */
-    byId: ReadonlyMap<string, CmsDocument>;
-    status: 'loading' | 'ready';
-}
+export type PublishedDocuments = ReadState<ReadonlyMap<string, CmsDocument>>;
 /**
  * Commands that change which version is pinned live (and thus the pool).
  *
@@ -30,12 +33,27 @@ export interface PublishedDocuments {
  * move or the delete of a pinned row changes published output.
  */
 export declare const PUBLISHED_RELOAD_OPS: readonly ["documents.publish", "documents.unpublish", "documents.pinVersion", "documents.delete", "documents.clear"];
+/**
+ * A failed `documents.listPublished` read (EC-628), carrying the operation's typed error so
+ * the surface localizes it when it renders — the query cache outlives a UI-language switch.
+ */
+export declare class PublishedReadError extends Error {
+    readonly error: OperationError;
+    constructor(error: OperationError);
+}
 /**
  * Build the published pool of a collection (pure over the operations client): the
  * pinned published snapshot of every currently-published document, keyed by id.
  * EC-307: one bulk `documents.listPublished` read — the backend resolves each
  * `publishedVersion` pointer to its recorded snapshot — instead of a `list` plus a
- * per-document `listVersions` fan-out. Read failures degrade to an empty pool.
+ * per-document `listVersions` fan-out. A failed read REJECTS with
+ * {@link PublishedReadError} (EC-628) — it used to resolve to an empty pool.
  */
 export declare function loadPublishedDocuments(operations: OperationsClient, projectId: string, collectionId: string): Promise<Map<string, CmsDocument>>;
+/** The {@link PublishedDocuments} state of the pool's query (pure — the hook's mapping). */
+export declare function publishedDocumentsState(query: {
+    readonly isError: boolean;
+    readonly error: unknown;
+    readonly data: ReadonlyMap<string, CmsDocument> | undefined;
+}): PublishedDocuments;
 export declare function usePublishedDocuments(projectId: string | undefined, collectionId: string): PublishedDocuments;

package/dist/lib/cms/published-documents.js

@@ -1,4 +1,6 @@
-import { useOperationQuery } from '@elytracms/studio/lib/query';
+import { readStateOf, useOperationQuery } from '../query/index.js';
+import { translate } from '../i18n/index.js';
+import { operationErrorMessage } from '../persona/labels.js';
 /**
  * Commands that change which version is pinned live (and thus the pool).
  *
@@ -16,23 +18,54 @@ export const PUBLISHED_RELOAD_OPS = [
     'documents.delete',
     'documents.clear',
 ];
-const EMPTY_POOL = new Map();
+/** No project (a fixture session without a backend): nothing is published, by construction. */
+const NO_PROJECT_POOL = { status: 'ready', value: new Map() };
+/**
+ * A failed `documents.listPublished` read (EC-628), carrying the operation's typed error so
+ * the surface localizes it when it renders — the query cache outlives a UI-language switch.
+ */
+export class PublishedReadError extends Error {
+    error;
+    constructor(error) {
+        super(error.message);
+        this.error = error;
+        this.name = 'PublishedReadError';
+    }
+}
 /**
  * Build the published pool of a collection (pure over the operations client): the
  * pinned published snapshot of every currently-published document, keyed by id.
  * EC-307: one bulk `documents.listPublished` read — the backend resolves each
  * `publishedVersion` pointer to its recorded snapshot — instead of a `list` plus a
- * per-document `listVersions` fan-out. Read failures degrade to an empty pool.
+ * per-document `listVersions` fan-out. A failed read REJECTS with
+ * {@link PublishedReadError} (EC-628) — it used to resolve to an empty pool.
  */
 export async function loadPublishedDocuments(operations, projectId, collectionId) {
     const result = await operations.documents.listPublished({ projectId, collection: collectionId });
     if (!result.ok)
-        return new Map();
+        throw new PublishedReadError(result.error);
     const byId = new Map();
     for (const snapshot of result.value)
         byId.set(snapshot.id, snapshot);
     return byId;
 }
+/**
+ * The pool's sentence when its read failed (EC-628): one message, shown by every surface
+ * that reads the pool — the operation's reason in the UI language when it carries a
+ * catalog reference (EC-494), its English otherwise.
+ */
+function publishedReadFailure(error) {
+    const reason = error instanceof PublishedReadError
+        ? operationErrorMessage(error.error)
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    return translate('cms.editor.publishedReadFailed', { reason });
+}
+/** The {@link PublishedDocuments} state of the pool's query (pure — the hook's mapping). */
+export function publishedDocumentsState(query) {
+    return readStateOf(query, publishedReadFailure);
+}
 export function usePublishedDocuments(projectId, collectionId) {
     const query = useOperationQuery({
         // Playground/fixture mode (no backend) is `enabled: false` → never queried.
@@ -42,7 +75,7 @@ export function usePublishedDocuments(projectId, collectionId) {
         enabled: projectId !== undefined,
     });
     if (projectId === undefined)
-        return { byId: EMPTY_POOL, status: 'ready' };
-    return { byId: query.data ?? EMPTY_POOL, status: query.isPending ? 'loading' : 'ready' };
+        return NO_PROJECT_POOL;
+    return publishedDocumentsState(query);
 }
 //# sourceMappingURL=published-documents.js.map

package/dist/lib/cms/published-documents.js.map

@@ -1 +1 @@
-{"version":3,"file":"published-documents.js","sourceRoot":"","sources":["../../../src/lib/cms/published-documents.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAsB/D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,mBAAmB;IACnB,qBAAqB;IACrB,sBAAsB;IACtB,kBAAkB;IAClB,iBAAiB;CACT,CAAA;AAEV,MAAM,UAAU,GAAqC,IAAI,GAAG,EAAE,CAAA;AAE9D;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,UAA4B,EAC5B,SAAiB,EACjB,YAAoB;IAEpB,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAA;IAChG,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,IAAI,GAAG,EAAE,CAAA;IAChC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAA;IAC3C,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,KAAK;QAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAA;IACpE,OAAO,IAAI,CAAA;AACb,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,SAA6B,EAC7B,YAAoB;IAEpB,MAAM,KAAK,GAAG,iBAAiB,CAA2B;QACxD,4EAA4E;QAC5E,QAAQ,EAAE,CAAC,oBAAoB,EAAE,SAAS,IAAI,GAAG,EAAE,YAAY,CAAC;QAChE,MAAM,EAAE,CAAC,UAAU,EAAE,EAAE,CAAC,sBAAsB,CAAC,UAAU,EAAE,SAAmB,EAAE,YAAY,CAAC;QAC7F,YAAY,EAAE,oBAAoB;QAClC,OAAO,EAAE,SAAS,KAAK,SAAS;KACjC,CAAC,CAAA;IACF,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAA;IACzE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,EAAE,CAAA;AAC1F,CAAC","sourcesContent":["import type { CmsDocument } from '@elytracms/core/cms-core'\nimport type { OperationsClient } from '../operations'\nimport { useOperationQuery } from '@elytracms/studio/lib/query'\n\n/**\n * The PUBLISHED-perspective documents of a collection (EC-205, \"live = published\")\n * — the pinned published snapshot of each currently-published document, keyed by\n * id. Live surfaces (a document's live URL + \"View live\", EC-216) MUST derive\n * from this, never from the draft rows the studio edits: an unpublished document,\n * or an unpublished `slug`/`parent` edit, must never leak into a \"live\" URL. The\n * pool is exactly the set the live site would serve, so composing a nested page's\n * URL from these ancestors yields the URL the live site actually resolves.\n *\n * EC-308/AD-17: loaded + kept fresh through the one `useOperationQuery` cache\n * seam — invalidated only when a command that moves a live pin succeeds (NOT on\n * every autosave upsert — a draft edit doesn't change what's published). Cost: ONE\n * bulk `documents.listPublished` read (EC-307).\n */\nexport interface PublishedDocuments {\n  /** Pinned published snapshot per published document id. Empty while loading. */\n  byId: ReadonlyMap<string, CmsDocument>\n  status: 'loading' | 'ready'\n}\n\n/**\n * Commands that change which version is pinned live (and thus the pool).\n *\n * EC-579 (RESIDUE-2c): `documents.pinVersion` moves the pin too — it is how a\n * changeset revert restores a prior live version — and was missing, so a revert left\n * the live URLs on the old pool until a reload. `documents.restore` was here and\n * moves nothing: it writes the DRAFT from a recorded version (`documents.replace`),\n * never the pin. The same answer the Convex trigger gives server-side: only a pin\n * move or the delete of a pinned row changes published output.\n */\nexport const PUBLISHED_RELOAD_OPS = [\n  'documents.publish',\n  'documents.unpublish',\n  'documents.pinVersion',\n  'documents.delete',\n  'documents.clear',\n] as const\n\nconst EMPTY_POOL: ReadonlyMap<string, CmsDocument> = new Map()\n\n/**\n * Build the published pool of a collection (pure over the operations client): the\n * pinned published snapshot of every currently-published document, keyed by id.\n * EC-307: one bulk `documents.listPublished` read — the backend resolves each\n * `publishedVersion` pointer to its recorded snapshot — instead of a `list` plus a\n * per-document `listVersions` fan-out. Read failures degrade to an empty pool.\n */\nexport async function loadPublishedDocuments(\n  operations: OperationsClient,\n  projectId: string,\n  collectionId: string,\n): Promise<Map<string, CmsDocument>> {\n  const result = await operations.documents.listPublished({ projectId, collection: collectionId })\n  if (!result.ok) return new Map()\n  const byId = new Map<string, CmsDocument>()\n  for (const snapshot of result.value) byId.set(snapshot.id, snapshot)\n  return byId\n}\n\nexport function usePublishedDocuments(\n  projectId: string | undefined,\n  collectionId: string,\n): PublishedDocuments {\n  const query = useOperationQuery<Map<string, CmsDocument>>({\n    // Playground/fixture mode (no backend) is `enabled: false` → never queried.\n    queryKey: ['publishedDocuments', projectId ?? '∅', collectionId],\n    loader: (operations) => loadPublishedDocuments(operations, projectId as string, collectionId),\n    invalidateOn: PUBLISHED_RELOAD_OPS,\n    enabled: projectId !== undefined,\n  })\n  if (projectId === undefined) return { byId: EMPTY_POOL, status: 'ready' }\n  return { byId: query.data ?? EMPTY_POOL, status: query.isPending ? 'loading' : 'ready' }\n}\n"]}
+{"version":3,"file":"published-documents.js","sourceRoot":"","sources":["../../../src/lib/cms/published-documents.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAuBzD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,mBAAmB;IACnB,qBAAqB;IACrB,sBAAsB;IACtB,kBAAkB;IAClB,iBAAiB;CACT,CAAA;AAEV,+FAA+F;AAC/F,MAAM,eAAe,GAAuB,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,GAAG,EAAE,EAAE,CAAA;AAEjF;;;GAGG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IACtB;IAArB,YAAqB,KAAqB;QACxC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QADD,UAAK,GAAL,KAAK,CAAgB;QAExC,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAA;IAClC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,UAA4B,EAC5B,SAAiB,EACjB,YAAoB;IAEpB,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAA;IAChG,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC1D,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAA;IAC3C,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,KAAK;QAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAA;IACpE,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,KAAc;IAC1C,MAAM,MAAM,GACV,KAAK,YAAY,kBAAkB;QACjC,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC;QACpC,CAAC,CAAC,KAAK,YAAY,KAAK;YACtB,CAAC,CAAC,KAAK,CAAC,OAAO;YACf,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IACrB,OAAO,SAAS,CAAC,gCAAgC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAA;AAChE,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,uBAAuB,CAAC,KAIvC;IACC,OAAO,WAAW,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAA;AACjD,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,SAA6B,EAC7B,YAAoB;IAEpB,MAAM,KAAK,GAAG,iBAAiB,CAA2B;QACxD,4EAA4E;QAC5E,QAAQ,EAAE,CAAC,oBAAoB,EAAE,SAAS,IAAI,GAAG,EAAE,YAAY,CAAC;QAChE,MAAM,EAAE,CAAC,UAAU,EAAE,EAAE,CAAC,sBAAsB,CAAC,UAAU,EAAE,SAAmB,EAAE,YAAY,CAAC;QAC7F,YAAY,EAAE,oBAAoB;QAClC,OAAO,EAAE,SAAS,KAAK,SAAS;KACjC,CAAC,CAAA;IACF,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,eAAe,CAAA;IACnD,OAAO,uBAAuB,CAAC,KAAK,CAAC,CAAA;AACvC,CAAC","sourcesContent":["import type { CmsDocument } from '@elytracms/core/cms-core'\nimport type { OperationError } from '@elytracms/core/operations'\nimport type { OperationsClient } from '../operations'\nimport { readStateOf, useOperationQuery } from '../query'\nimport type { ReadState } from '../query'\nimport { translate } from '../i18n'\nimport { operationErrorMessage } from '../persona/labels'\n\n/**\n * The PUBLISHED-perspective documents of a collection (EC-205, \"live = published\")\n * — the pinned published snapshot of each currently-published document, keyed by\n * id. Live surfaces (a document's live URL + \"View live\", EC-216) MUST derive\n * from this, never from the draft rows the studio edits: an unpublished document,\n * or an unpublished `slug`/`parent` edit, must never leak into a \"live\" URL. The\n * pool is exactly the set the live site would serve, so composing a nested page's\n * URL from these ancestors yields the URL the live site actually resolves.\n *\n * EC-308/AD-17: loaded + kept fresh through the one `useOperationQuery` cache\n * seam — invalidated only when a command that moves a live pin succeeds (NOT on\n * every autosave upsert — a draft edit doesn't change what's published). Cost: ONE\n * bulk `documents.listPublished` read (EC-307).\n *\n * EC-628: the pool is a {@link ReadState} — `ready` carries the pinned published snapshot\n * per published document id; a failed read is `error` with the localized reason, and\n * every surface reading the pool (the list's URL column, the editor header's live link)\n * shows it. A failure is never an empty pool: an empty pool says \"nothing is published\".\n */\nexport type PublishedDocuments = ReadState<ReadonlyMap<string, CmsDocument>>\n\n/**\n * Commands that change which version is pinned live (and thus the pool).\n *\n * EC-579 (RESIDUE-2c): `documents.pinVersion` moves the pin too — it is how a\n * changeset revert restores a prior live version — and was missing, so a revert left\n * the live URLs on the old pool until a reload. `documents.restore` was here and\n * moves nothing: it writes the DRAFT from a recorded version (`documents.replace`),\n * never the pin. The same answer the Convex trigger gives server-side: only a pin\n * move or the delete of a pinned row changes published output.\n */\nexport const PUBLISHED_RELOAD_OPS = [\n  'documents.publish',\n  'documents.unpublish',\n  'documents.pinVersion',\n  'documents.delete',\n  'documents.clear',\n] as const\n\n/** No project (a fixture session without a backend): nothing is published, by construction. */\nconst NO_PROJECT_POOL: PublishedDocuments = { status: 'ready', value: new Map() }\n\n/**\n * A failed `documents.listPublished` read (EC-628), carrying the operation's typed error so\n * the surface localizes it when it renders — the query cache outlives a UI-language switch.\n */\nexport class PublishedReadError extends Error {\n  constructor(readonly error: OperationError) {\n    super(error.message)\n    this.name = 'PublishedReadError'\n  }\n}\n\n/**\n * Build the published pool of a collection (pure over the operations client): the\n * pinned published snapshot of every currently-published document, keyed by id.\n * EC-307: one bulk `documents.listPublished` read — the backend resolves each\n * `publishedVersion` pointer to its recorded snapshot — instead of a `list` plus a\n * per-document `listVersions` fan-out. A failed read REJECTS with\n * {@link PublishedReadError} (EC-628) — it used to resolve to an empty pool.\n */\nexport async function loadPublishedDocuments(\n  operations: OperationsClient,\n  projectId: string,\n  collectionId: string,\n): Promise<Map<string, CmsDocument>> {\n  const result = await operations.documents.listPublished({ projectId, collection: collectionId })\n  if (!result.ok) throw new PublishedReadError(result.error)\n  const byId = new Map<string, CmsDocument>()\n  for (const snapshot of result.value) byId.set(snapshot.id, snapshot)\n  return byId\n}\n\n/**\n * The pool's sentence when its read failed (EC-628): one message, shown by every surface\n * that reads the pool — the operation's reason in the UI language when it carries a\n * catalog reference (EC-494), its English otherwise.\n */\nfunction publishedReadFailure(error: unknown): string {\n  const reason =\n    error instanceof PublishedReadError\n      ? operationErrorMessage(error.error)\n      : error instanceof Error\n        ? error.message\n        : String(error)\n  return translate('cms.editor.publishedReadFailed', { reason })\n}\n\n/** The {@link PublishedDocuments} state of the pool's query (pure — the hook's mapping). */\nexport function publishedDocumentsState(query: {\n  readonly isError: boolean\n  readonly error: unknown\n  readonly data: ReadonlyMap<string, CmsDocument> | undefined\n}): PublishedDocuments {\n  return readStateOf(query, publishedReadFailure)\n}\n\nexport function usePublishedDocuments(\n  projectId: string | undefined,\n  collectionId: string,\n): PublishedDocuments {\n  const query = useOperationQuery<Map<string, CmsDocument>>({\n    // Playground/fixture mode (no backend) is `enabled: false` → never queried.\n    queryKey: ['publishedDocuments', projectId ?? '∅', collectionId],\n    loader: (operations) => loadPublishedDocuments(operations, projectId as string, collectionId),\n    invalidateOn: PUBLISHED_RELOAD_OPS,\n    enabled: projectId !== undefined,\n  })\n  if (projectId === undefined) return NO_PROJECT_POOL\n  return publishedDocumentsState(query)\n}\n"]}

package/dist/lib/cms-views/view-model.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import type { CmsDocument, CollectionDef, FieldDef, Locale, LocaleConfig, LocalizedString } from '@elytracms/core/cms-core';
+import { configViewSchema, filterClauseSchema, filterScalarSchema, isPseudoColumn, PUBLISHED_AT_FIELD, STATE_FIELD, UPDATED_AT_FIELD, URL_FIELD, viewSortSchema } from '@elytracms/core/cms-core';
+import type { CmsDocument, CollectionDef, ConfigView, FieldDef, FilterClause, Locale, LocaleConfig, LocalizedString, ViewSort } from '@elytracms/core/cms-core';
 import type { FilterOperator, FilterScalar } from '@elytracms/core/content';
 /**
  * The pure table-view model for the CMS collection table (EC-169).
@@ -17,38 +18,12 @@ import type { FilterOperator, FilterScalar } from '@elytracms/core/content';
  * "show me drafts → bulk publish" working set and still speaks only the
  * closed vocabulary (`eq`/`in`).
  */
-export declare const filterScalarSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-export declare const filterClauseSchema: z.ZodObject<{
-    field: z.ZodString;
-    op: z.ZodEnum<{
-        empty: "empty";
-        contains: "contains";
-        in: "in";
-        endsWith: "endsWith";
-        startsWith: "startsWith";
-        eq: "eq";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-    }>;
-    value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
-}, z.core.$strip>;
-export type FilterClause = z.infer<typeof filterClauseSchema>;
-export declare const viewSortSchema: z.ZodObject<{
-    field: z.ZodString;
-    dir: z.ZodEnum<{
-        asc: "asc";
-        desc: "desc";
-    }>;
-}, z.core.$strip>;
-export type ViewSort = z.infer<typeof viewSortSchema>;
+export { configViewSchema, filterClauseSchema, filterScalarSchema, isPseudoColumn, PUBLISHED_AT_FIELD, STATE_FIELD, UPDATED_AT_FIELD, URL_FIELD, viewSortSchema, };
+export type { ConfigView, FilterClause, ViewSort };
 export declare const tableViewStateSchema: z.ZodObject<{
     filters: z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         op: z.ZodEnum<{
-            empty: "empty";
-            contains: "contains";
             in: "in";
             endsWith: "endsWith";
             startsWith: "startsWith";
@@ -57,6 +32,8 @@ export declare const tableViewStateSchema: z.ZodObject<{
             gte: "gte";
             lt: "lt";
             lte: "lte";
+            contains: "contains";
+            empty: "empty";
         }>;
         value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
     }, z.core.$strip>>;
@@ -71,36 +48,6 @@ export declare const tableViewStateSchema: z.ZodObject<{
     hidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type TableViewState = z.infer<typeof tableViewStateSchema>;
-/**
- * Sentinel field key for the publication state. `$`-prefixed so it can never
- * collide with a schema field name (`fieldDefSchema` names are identifiers).
- */
-export declare const STATE_FIELD = "$state";
-/**
- * Reserved pseudo-COLUMN keys — the columns-axis siblings of the filter-axis
- * {@link STATE_FIELD}. `$`-prefixed so they can never collide with a schema field
- * name; they participate in a view's `columns` list AND the Display picker exactly
- * like a schema field (orderable / hideable / includable), but they are NOT drawn
- * from `collection.fields` — the column UNIVERSE is `[...schemaFields, ...pseudoColumns]`.
- *
- * - `$state` — publication status. A reserved `$`-key, but NO LONGER a reorderable
- *   column: EC-448 promoted it to a FIXED structural leading column (checkbox →
- *   status-dot → title), so it is NOT emitted by {@link pseudoColumns} and never
- *   participates in the reorderable columns/hidden/order model. It stays a reserved
- *   key (filter + sort) and {@link isPseudoColumn} still recognizes it, so an authored
- *   view listing `$state` is a harmless no-op (see {@link resolveConfigColumns}).
- * - `$url` — the derived delivery URL (routable collections only; NON-sortable).
- * - `$updatedAt` — the record's last-write timestamp.
- * - `$publishedAt` — the record's FIRST-publish instant (EC-447; opt-in, HIDDEN by
- *   default). Now materialized end-to-end (`cmsDocuments.publishedAt` → source
- *   `timestamps.publishedAt`) and emitted by {@link pseudoColumns} when the source
- *   both materializes timestamps and has a publish lifecycle.
- */
-export declare const URL_FIELD = "$url";
-export declare const PUBLISHED_AT_FIELD = "$publishedAt";
-export declare const UPDATED_AT_FIELD = "$updatedAt";
-/** Is `name` a reserved pseudo-column (a `$`-key, not a schema field)? */
-export declare function isPseudoColumn(name: string): boolean;
 /**
  * Capability signals that make a pseudo-column applicable to a collection/source
  * (EC-445). Supplied by the caller from the portable source — the model stays pure.
@@ -269,49 +216,14 @@ export declare function defaultViewState(collection: CollectionDef, pseudo?: rea
  * same shape {@link defaultViewState} produces, so {@link resolveColumns} renders
  * precisely the authored list, visible, in that order. An omitted (or empty) list
  * inherits the collection's default lens (all scalars visible, composites hidden).
- * Unknown names in the authored list (a field the schema no longer has) are dropped.
+ * An authored name outside the universe — no longer a field, or a reserved column that
+ * does not apply to this source — is skipped here so the list still renders; a name that
+ * is neither a top-level field nor a reserved `$` key never reaches a resolved config
+ * (EC-622: the config gate refuses it, `collectionViewFindings`).
  */
 export declare function resolveConfigColumns(collection: CollectionDef, visible: readonly string[] | undefined, pseudo?: readonly string[]): Pick<TableViewState, 'columns' | 'hidden'>;
 /** The reserved `views[]` id whose entry OVERRIDES the synthesized baseline view (EC-444). */
 export declare const DEFAULT_VIEW_OVERRIDE_ID = "default";
-/**
- * A config-declared view (EC-246b/EC-444) — the flat authoring shape a collection
- * declares in `cms/` config: `{ name, initial?, filters?, sort?, columns? }`.
- * Filters/sort/columns sit at the top level (no nested `state` wrapper). The
- * studio validates + interprets these; `cms-core` stores them opaquely (it
- * can't reference the filter vocabulary without a layering cycle).
- */
-export declare const configViewSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
-    initial: z.ZodOptional<z.ZodBoolean>;
-    default: z.ZodOptional<z.ZodBoolean>;
-    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        field: z.ZodString;
-        op: z.ZodEnum<{
-            empty: "empty";
-            contains: "contains";
-            in: "in";
-            endsWith: "endsWith";
-            startsWith: "startsWith";
-            eq: "eq";
-            gt: "gt";
-            gte: "gte";
-            lt: "lt";
-            lte: "lte";
-        }>;
-        value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
-    }, z.core.$strip>>>;
-    sort: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        field: z.ZodString;
-        dir: z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>;
-    }, z.core.$strip>>>;
-    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type ConfigView = z.infer<typeof configViewSchema>;
 /**
  * A resolved view: identity + the table state it restores (matches `SavedView`).
  * `name` stays a {@link LocalizedString} — resolved at the render site (EC-343), like
@@ -327,7 +239,8 @@ export interface ResolvedView {
 /**
  * Resolve a collection's config-declared `views` into full {@link ResolvedView}s
  * (EC-246b). Each is validated with {@link configViewSchema}; malformed entries
- * and duplicate ids are dropped (defensive). Columns fall back to the collection
+ * and duplicate ids are skipped (defensive — a malformed view never reaches a resolved
+ * config: the config gate refuses it, EC-622). Columns fall back to the collection
  * default when a view doesn't pin them, so a filter-only view still renders every
  * column. Config views are shared and change only in
  * code — the runtime never mutates them.

package/dist/lib/cms-views/view-model.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { canonicalDateValue, localizedStringSchema, resolveField, resolveLabel, titleFieldOf, } from '@elytracms/core/cms-core';
-import { localizedLabel, translate } from '@elytracms/studio/lib/i18n';
-import { contentQueryErrorMessage } from '@elytracms/studio/lib/persona/labels';
-import { FILTER_OPERATORS, compareListEntries, sortScalarOf, filterableFields, matchesFieldValue, validateWhere, } from '@elytracms/core/content';
+import { canonicalDateValue, configViewSchema, filterClauseSchema, filterScalarSchema, isPseudoColumn, PUBLISHED_AT_FIELD, resolveField, resolveLabel, STATE_FIELD, titleFieldOf, UPDATED_AT_FIELD, URL_FIELD, viewSortSchema, } from '@elytracms/core/cms-core';
+import { localizedLabel, translate } from '../i18n/index.js';
+import { contentQueryErrorMessage } from '../persona/labels.js';
+import { compareListEntries, sortScalarOf, filterableFields, matchesFieldValue, validateWhere, } from '@elytracms/core/content';
 /**
  * The pure table-view model for the CMS collection table (EC-169).
  *
@@ -20,18 +20,10 @@ import { FILTER_OPERATORS, compareListEntries, sortScalarOf, filterableFields, m
  * closed vocabulary (`eq`/`in`).
  */
 // --- Schemas (single source of truth — persisted view records reuse these) ----
-export const filterScalarSchema = z.union([z.string(), z.number(), z.boolean()]);
-export const filterClauseSchema = z.object({
-    /** A schema field name, or {@link STATE_FIELD} for the publication state. */
-    field: z.string().min(1),
-    op: z.enum(FILTER_OPERATORS),
-    /** `in` carries an array of scalars; every other operator one scalar. */
-    value: z.union([filterScalarSchema, z.array(filterScalarSchema)]),
-});
-export const viewSortSchema = z.object({
-    field: z.string().min(1),
-    dir: z.enum(['asc', 'desc']),
-});
+// EC-622: the authoring shape of a view and the reserved `$` keys are declared ONCE, in
+// cms-core (`collection-views.ts`), where the config gate judges every declared view —
+// re-exported here unchanged, so this module's public names stay what they were.
+export { configViewSchema, filterClauseSchema, filterScalarSchema, isPseudoColumn, PUBLISHED_AT_FIELD, STATE_FIELD, UPDATED_AT_FIELD, URL_FIELD, viewSortSchema, };
 export const tableViewStateSchema = z.object({
     /** AND-only list of conditions (no OR, no nesting — vision AD-3). */
     filters: z.array(filterClauseSchema),
@@ -50,53 +42,16 @@ export const tableViewStateSchema = z.object({
     hidden: z.array(z.string().min(1)).default([]),
 });
 // --- The built-in publication-state filter column ------------------------------
-/**
- * Sentinel field key for the publication state. `$`-prefixed so it can never
- * collide with a schema field name (`fieldDefSchema` names are identifiers).
- */
-export const STATE_FIELD = '$state';
+// `STATE_FIELD` (the publication-state sentinel) and the reserved pseudo-COLUMN keys
+// (`$url`, `$updatedAt`, `$publishedAt` — EC-445/EC-447) are declared in cms-core
+// (`collection-views.ts`, EC-622) and re-exported above. `$state` is a reserved key
+// (filter + sort) but NOT a reorderable column: EC-448 made it the FIXED structural
+// leading column, so {@link pseudoColumns} never emits it and an authored view listing
+// `$state` is a harmless no-op (see {@link resolveConfigColumns}). Which reserved key
+// APPLIES to a collection is this module's runtime decision ({@link pseudoColumns}); the
+// config gate accepts every reserved key.
 const STATE_VALUES = ['draft', 'published'];
 // --- Reserved pseudo-COLUMNS (EC-445) ------------------------------------------
-/**
- * Reserved pseudo-COLUMN keys — the columns-axis siblings of the filter-axis
- * {@link STATE_FIELD}. `$`-prefixed so they can never collide with a schema field
- * name; they participate in a view's `columns` list AND the Display picker exactly
- * like a schema field (orderable / hideable / includable), but they are NOT drawn
- * from `collection.fields` — the column UNIVERSE is `[...schemaFields, ...pseudoColumns]`.
- *
- * - `$state` — publication status. A reserved `$`-key, but NO LONGER a reorderable
- *   column: EC-448 promoted it to a FIXED structural leading column (checkbox →
- *   status-dot → title), so it is NOT emitted by {@link pseudoColumns} and never
- *   participates in the reorderable columns/hidden/order model. It stays a reserved
- *   key (filter + sort) and {@link isPseudoColumn} still recognizes it, so an authored
- *   view listing `$state` is a harmless no-op (see {@link resolveConfigColumns}).
- * - `$url` — the derived delivery URL (routable collections only; NON-sortable).
- * - `$updatedAt` — the record's last-write timestamp.
- * - `$publishedAt` — the record's FIRST-publish instant (EC-447; opt-in, HIDDEN by
- *   default). Now materialized end-to-end (`cmsDocuments.publishedAt` → source
- *   `timestamps.publishedAt`) and emitted by {@link pseudoColumns} when the source
- *   both materializes timestamps and has a publish lifecycle.
- */
-export const URL_FIELD = '$url';
-export const PUBLISHED_AT_FIELD = '$publishedAt';
-export const UPDATED_AT_FIELD = '$updatedAt';
-/**
- * Every reserved pseudo-column key. `$state` is included (it is still a reserved
- * `$`-key: the filter/sort axis + the FIXED structural status column, EC-448) so
- * {@link isPseudoColumn} never mistakes it for a schema field — but it is NOT a
- * reorderable column, so it is absent from the `pseudo` sets {@link pseudoColumns}
- * emits into the order/hide/picker model.
- */
-const PSEUDO_COLUMN_FIELDS = [
-    STATE_FIELD,
-    URL_FIELD,
-    PUBLISHED_AT_FIELD,
-    UPDATED_AT_FIELD,
-];
-/** Is `name` a reserved pseudo-column (a `$`-key, not a schema field)? */
-export function isPseudoColumn(name) {
-    return PSEUDO_COLUMN_FIELDS.includes(name);
-}
 /**
  * Pseudo-columns HIDDEN by default (opt-in): the extra publish timestamp. Everything
  * else applicable (`$updatedAt`/`$state`/`$url`) is on by default (owner, 2026-07-17).
@@ -460,7 +415,10 @@ export function defaultViewState(collection, pseudo = []) {
  * same shape {@link defaultViewState} produces, so {@link resolveColumns} renders
  * precisely the authored list, visible, in that order. An omitted (or empty) list
  * inherits the collection's default lens (all scalars visible, composites hidden).
- * Unknown names in the authored list (a field the schema no longer has) are dropped.
+ * An authored name outside the universe — no longer a field, or a reserved column that
+ * does not apply to this source — is skipped here so the list still renders; a name that
+ * is neither a top-level field nor a reserved `$` key never reaches a resolved config
+ * (EC-622: the config gate refuses it, `collectionViewFindings`).
  */
 export function resolveConfigColumns(collection, visible, pseudo = []) {
     if (visible === undefined || visible.length === 0) {
@@ -494,46 +452,6 @@ export function resolveConfigColumns(collection, visible, pseudo = []) {
 }
 /** The reserved `views[]` id whose entry OVERRIDES the synthesized baseline view (EC-444). */
 export const DEFAULT_VIEW_OVERRIDE_ID = 'default';
-/**
- * A config-declared view (EC-246b/EC-444) — the flat authoring shape a collection
- * declares in `cms/` config: `{ name, initial?, filters?, sort?, columns? }`.
- * Filters/sort/columns sit at the top level (no nested `state` wrapper). The
- * studio validates + interprets these; `cms-core` stores them opaquely (it
- * can't reference the filter vocabulary without a layering cycle).
- */
-export const configViewSchema = z.object({
-    /**
-     * Optional stable id; defaults to a slug of `name`. The reserved value
-     * {@link DEFAULT_VIEW_OVERRIDE_ID} (`'default'`) marks the baseline-override entry.
-     */
-    id: z.string().min(1).optional(),
-    /**
-     * View label; localizable (EC-343): a plain string or a `{ locale }` map, resolved
-     * at the render site via the same `resolveLabel` path as `form.label` (EC-241).
-     */
-    name: localizedStringSchema,
-    /**
-     * When true this view seeds the collection's INITIAL active view (EC-343/EC-444) —
-     * the curated lens an editor lands on before picking one. At most one per collection;
-     * a duplicate is a visible validation issue ({@link configViewIssues}), never silent.
-     * The baseline lens stays available and stays the fallback.
-     */
-    initial: z.boolean().optional(),
-    /**
-     * @deprecated EC-444 — renamed to {@link ConfigView.initial}. Still read as an alias
-     * for one release (`initial ?? default`) with a console warning; removed next release.
-     * Distinct from a field's default VALUE and from the reserved `id: 'default'` override.
-     */
-    default: z.boolean().optional(),
-    filters: z.array(filterClauseSchema).optional(),
-    sort: viewSortSchema.nullable().optional(),
-    /**
-     * The single ordered list of VISIBLE columns (EC-444): what you list is what shows,
-     * in that order. Omit to inherit the collection's default columns (all scalars). The
-     * two-axis `{columns, hidden}` internal state is derived by {@link resolveConfigColumns}.
-     */
-    columns: z.array(z.string().min(1)).optional(),
-});
 /**
  * Slug used to derive a config view's stable id from its name. A localized name
  * (EC-343) slugs its DEFAULT-locale text so the id is stable across the active UI
@@ -550,7 +468,8 @@ function configViewId(name, index) {
 /**
  * Resolve a collection's config-declared `views` into full {@link ResolvedView}s
  * (EC-246b). Each is validated with {@link configViewSchema}; malformed entries
- * and duplicate ids are dropped (defensive). Columns fall back to the collection
+ * and duplicate ids are skipped (defensive — a malformed view never reaches a resolved
+ * config: the config gate refuses it, EC-622). Columns fall back to the collection
  * default when a view doesn't pin them, so a filter-only view still renders every
  * column. Config views are shared and change only in
  * code — the runtime never mutates them.