@elytracms/studio 0.0.72 → 0.0.74

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

@@ -55,6 +55,59 @@ export const tableViewStateSchema = z.object({
  */
 export const STATE_FIELD = '$state';
 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 (already a filter pseudo-field; now a column too).
+ * - `$url` — the derived delivery URL (routable collections only; NON-sortable).
+ * - `$updatedAt` — the record's last-write timestamp.
+ * - `$publishedAt` — when the live version was published (opt-in, HIDDEN by default).
+ *   RESERVED: its data path (materialize `publishedAt`) is an EC-445 follow-up, so it
+ *   is not yet emitted by {@link pseudoColumns}; the constant + sort support ship now.
+ */
+export const URL_FIELD = '$url';
+export const PUBLISHED_AT_FIELD = '$publishedAt';
+export const UPDATED_AT_FIELD = '$updatedAt';
+/** Every reserved pseudo-column key (the columns-axis `$state` included). */
+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).
+ */
+const DEFAULT_HIDDEN_PSEUDO_COLUMNS = new Set([PUBLISHED_AT_FIELD]);
+/**
+ * The reserved pseudo-columns that APPLY to a collection, in their default appended
+ * order (EC-445): `$updatedAt`, then `$state`, then `$url`. `$url` is gated on
+ * `routable` (a non-routable collection has no URL column, not an empty one), `$state`
+ * on `publishing` (a lifecycle-less rail shows no status), `$updatedAt` on `timestamps`.
+ * `$publishedAt` is reserved but not yet emitted (its data path is an EC-445 follow-up).
+ * Pure — a caller (`pseudoColumnsForSource`) supplies the signals from the source.
+ */
+export function pseudoColumns(collection, opts = {}) {
+    void collection; // reserved for future per-collection gating; kept for API symmetry
+    const cols = [];
+    if (opts.timestamps)
+        cols.push(UPDATED_AT_FIELD);
+    if (opts.publishing)
+        cols.push(STATE_FIELD);
+    if (opts.routable)
+        cols.push(URL_FIELD);
+    return cols;
+}
 export const STATE_OPTION = {
     field: STATE_FIELD,
     label: 'State',
@@ -267,9 +320,17 @@ function rawValueOf(collection, doc, field, localeConfig, isPublished) {
     return resolveField(collection, doc, field, locale, localeConfig).value;
 }
 /** The scalar a document exposes for a SORT field, locale-resolved. */
-function scalarOf(collection, doc, field, localeConfig, isPublished) {
+function scalarOf(collection, doc, field, localeConfig, isPublished, meta = {}) {
     if (field === STATE_FIELD)
         return isPublished(doc) ? 'published' : 'draft';
+    // EC-445: the pseudo-DATE columns sort by the source's materialized ISO timestamp
+    // (ISO strings order lexicographically = chronologically); `$url` is derived → not sortable.
+    if (field === UPDATED_AT_FIELD)
+        return meta.updatedAt?.(doc) ?? null;
+    if (field === PUBLISHED_AT_FIELD)
+        return meta.publishedAt?.(doc) ?? null;
+    if (field === URL_FIELD)
+        return null;
     if (!collection.fields.some((f) => f.name === field))
         return null;
     const locale = documentDefaultLocale(doc, localeConfig);
@@ -292,10 +353,13 @@ export function clauseMatches(collection, doc, localeConfig, clause, isPublished
  * content accessors, the *table* may sort any rendered column — sorting is a
  * presentation concern here; the `filterable` flag governs filters.
  */
-export function sortViewDocuments(collection, docs, localeConfig, sort, isPublished = defaultIsPublished) {
+export function sortViewDocuments(collection, docs, localeConfig, sort, isPublished = defaultIsPublished, meta = {}) {
     if (sort === null)
         return [...docs];
-    const positions = new Map(docs.map((doc) => [doc.id, scalarOf(collection, doc, sort.field, localeConfig, isPublished)]));
+    const positions = new Map(docs.map((doc) => [
+        doc.id,
+        scalarOf(collection, doc, sort.field, localeConfig, isPublished, meta),
+    ]));
     return [...docs].sort((a, b) => compareListEntries({ id: a.id, sortValue: positions.get(a.id) ?? null }, { id: b.id, sortValue: positions.get(b.id) ?? null }, sort.dir));
 }
 /**
@@ -303,18 +367,18 @@ export function sortViewDocuments(collection, docs, localeConfig, sort, isPublis
  * ones, sort. Invalid clauses never filter silently — they come back as
  * issues for the UI to surface.
  */
-export function applyViewState(collection, docs, localeConfig, state, isPublished = defaultIsPublished) {
+export function applyViewState(collection, docs, localeConfig, state, isPublished = defaultIsPublished, meta = {}) {
     const issues = validateClauses(collection, state.filters);
     const invalid = new Set(issues.map((issue) => issue.index));
     const active = state.filters.filter((_, index) => !invalid.has(index));
     const matched = docs.filter((doc) => active.every((clause) => clauseMatches(collection, doc, localeConfig, clause, isPublished)));
     return {
-        docs: sortViewDocuments(collection, matched, localeConfig, state.sort, isPublished),
+        docs: sortViewDocuments(collection, matched, localeConfig, state.sort, isPublished, meta),
         issues,
     };
 }
 // --- View state construction, equality, columns ----------------------------------
-/** The id of the unnamed built-in "All documents" view. */
+/** The id of the synthesized built-in "All entries" baseline view (EC-444). */
 export const ALL_VIEW_ID = 'all';
 /** The default (unnamed) view: no filters, no sort, every field visible. */
 /**
@@ -326,37 +390,83 @@ export const ALL_VIEW_ID = 'all';
  */
 const NON_DEFAULT_COLUMN_TYPES = new Set(['blocks', 'richText', 'object']);
 /**
- * Field names OFF the built-in "All" lens by default: the composite editing surfaces
- * (blocks/richText/object) — always noise in a scalar list — PLUS any scalar the
- * schema opts out with `form.column: false` (EC-343). Both only affect the default
- * columns: the field stays in the picker one toggle away, its form and filterability
- * are untouched, and a named view's explicit `columns` list ignores this entirely.
+ * Field names OFF the built-in baseline lens by default: exactly the composite
+ * editing surfaces (blocks/richText/object) — always noise in a scalar list. The
+ * default lens is "all scalars"; there is no per-field column opt-out any more
+ * (EC-444 hard-removed `form.column`). A field stays in the picker one toggle away,
+ * and a view curates columns by declaring an explicit `columns` list (or the
+ * `id: 'default'` baseline override).
  */
-function defaultHiddenColumns(collection) {
-    return collection.fields
-        .filter((f) => NON_DEFAULT_COLUMN_TYPES.has(f.type) || f.form?.column === false)
+function defaultHiddenColumns(collection, pseudo = []) {
+    const composites = collection.fields
+        .filter((f) => NON_DEFAULT_COLUMN_TYPES.has(f.type))
         .map((f) => f.name);
+    // EC-445: applicable opt-in pseudo-columns ($publishedAt) start hidden; the rest
+    // ($updatedAt/$state/$url) are visible by default (owner: keep them on).
+    const hiddenPseudo = pseudo.filter((name) => DEFAULT_HIDDEN_PSEUDO_COLUMNS.has(name));
+    return [...composites, ...hiddenPseudo];
 }
-export function defaultViewState(collection) {
+export function defaultViewState(collection, pseudo = []) {
     return {
         filters: [],
         sort: null,
-        // Every field keeps a slot (order + picker), but the composite surfaces and any
-        // `form.column: false` scalars start hidden so the default lens is the
-        // collection's chosen scalar columns (EC-246b / EC-343).
-        columns: orderedColumnNames(collection),
-        hidden: defaultHiddenColumns(collection),
+        // Every field keeps a slot (order + picker), but the composite surfaces start
+        // hidden so the default lens is the collection's scalar columns (EC-246b/EC-444).
+        // EC-445: the applicable reserved pseudo-columns append after the data columns.
+        columns: orderedColumnNames(collection, pseudo),
+        hidden: defaultHiddenColumns(collection, pseudo),
     };
 }
 /**
- * A config-declared view (EC-246b) — the flat authoring shape a collection
- * declares in `cms/` config: `{ name, filters?, sort?, columns?, hidden? }`.
+ * Resolve an authored VISIBLE column list (EC-444) into the internal two-axis
+ * `{columns, hidden}` table state. The authored list is exactly the columns shown,
+ * in order; every OTHER schema field is appended (in schema order) and hidden — the
+ * 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.
+ */
+export function resolveConfigColumns(collection, visible, pseudo = []) {
+    if (visible === undefined || visible.length === 0) {
+        const base = defaultViewState(collection, pseudo);
+        return { columns: base.columns, hidden: base.hidden };
+    }
+    const universe = orderedColumnNames(collection, pseudo);
+    const inUniverse = new Set(universe);
+    const seen = new Set();
+    const shown = [];
+    for (const name of visible) {
+        if (inUniverse.has(name) && !seen.has(name)) {
+            shown.push(name);
+            seen.add(name);
+        }
+    }
+    const rest = universe.filter((name) => !seen.has(name));
+    // EC-445: a schema-ONLY authored list (mentioning no pseudo-column) keeps the
+    // applicable pseudo-columns at their DEFAULT visibility — so a consumer's
+    // pre-EC-445 `columns:[…schema…]` list still shows today's status + url (+ updatedAt).
+    // Mentioning ANY pseudo-column switches them to the visible-list rule (only listed shows).
+    const mentionsPseudo = visible.some(isPseudoColumn);
+    const keepVisible = mentionsPseudo
+        ? new Set()
+        : new Set(pseudo.filter((name) => !DEFAULT_HIDDEN_PSEUDO_COLUMNS.has(name)));
+    const hidden = rest.filter((name) => !keepVisible.has(name));
+    return { columns: [...shown, ...rest], hidden };
+}
+/** 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`. */
+    /**
+     * 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
@@ -364,17 +474,26 @@ export const configViewSchema = z.object({
      */
     name: localizedStringSchema,
     /**
-     * When true this view seeds the collection's INITIAL active view (EC-343) — 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 built-in "All" lens stays available and stays the fallback.
+     * 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(),
-    /** Column order; when omitted, the view inherits the collection's default columns. */
+    /**
+     * 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(),
-    hidden: z.array(z.string().min(1)).optional(),
 });
 /**
  * Slug used to derive a config view's stable id from its name. A localized name
@@ -397,11 +516,10 @@ function configViewId(name, index) {
  * column. Config views are shared and change only in
  * code — the runtime never mutates them.
  */
-export function configViewsFor(collection) {
+export function configViewsFor(collection, pseudo = []) {
     const declared = collection.views;
     if (!Array.isArray(declared))
         return [];
-    const base = defaultViewState(collection);
     const seen = new Set();
     const resolved = [];
     declared.forEach((raw, index) => {
@@ -413,46 +531,100 @@ export function configViewsFor(collection) {
         if (seen.has(id))
             return;
         seen.add(id);
+        // EC-444: `initial` supersedes the deprecated `default` alias (one-release window).
+        const initial = view.initial ?? view.default;
+        const { columns, hidden } = resolveConfigColumns(collection, view.columns, pseudo);
         resolved.push({
             id,
             name: view.name,
-            ...(view.default ? { default: true } : {}),
+            ...(initial ? { initial: true } : {}),
             state: normalizeViewState({
                 filters: view.filters ?? [],
                 sort: view.sort ?? null,
-                columns: view.columns && view.columns.length > 0 ? view.columns : base.columns,
-                hidden: view.hidden ?? [],
+                columns,
+                hidden,
             }),
         });
     });
     return resolved;
 }
 /**
- * The id of the config view flagged `default: true` (EC-343) — the seed for a
- * collection's INITIAL active view. When several are flagged (a misconfiguration,
- * reported by {@link configViewIssues}) the FIRST in declaration order wins
- * deterministically; when none is flagged the caller falls back to the built-in
- * "All" lens. `undefined` when the collection declares no default view.
+ * Does the collection declare a baseline-override view (a config view whose id is
+ * {@link DEFAULT_VIEW_OVERRIDE_ID})? When true the synthesized "All entries" lens is
+ * replaced by that entry verbatim (see {@link resolveCollectionViews}), EC-444.
+ */
+export function hasDefaultViewOverride(collection) {
+    return configViewsFor(collection).some((view) => view.id === DEFAULT_VIEW_OVERRIDE_ID);
+}
+/**
+ * The ordered view list a collection surfaces (EC-444): the baseline first, then the
+ * config-declared views in declaration order. The baseline is either an authored
+ * OVERRIDE (the config view whose id is {@link DEFAULT_VIEW_OVERRIDE_ID}, used
+ * VERBATIM and NOT repeated among the trailing views) or, absent one, the
+ * `synthesizedBaseline` the caller passes (the studio's translated "All entries"
+ * lens). Pure — the store supplies the synthesized baseline (i18n-bound `name`).
+ */
+export function resolveCollectionViews(collection, synthesizedBaseline, pseudo = []) {
+    const configViews = configViewsFor(collection, pseudo);
+    const overrideIndex = configViews.findIndex((view) => view.id === DEFAULT_VIEW_OVERRIDE_ID);
+    if (overrideIndex < 0)
+        return [synthesizedBaseline, ...configViews];
+    const override = configViews[overrideIndex];
+    const rest = configViews.filter((_, index) => index !== overrideIndex);
+    return [override, ...rest];
+}
+/**
+ * The ids of config views that still use the DEPRECATED `default` flag without the
+ * new `initial` (EC-444). Drives the one-release deprecation warning (mirrors the
+ * duplicate-default channel); empty once every view has migrated to `initial`.
+ */
+export function deprecatedDefaultFlagViewIds(collection) {
+    const declared = collection.views;
+    if (!Array.isArray(declared))
+        return [];
+    const seen = new Set();
+    const ids = [];
+    declared.forEach((raw, index) => {
+        const parsed = configViewSchema.safeParse(raw);
+        if (!parsed.success)
+            return;
+        const view = parsed.data;
+        const id = view.id ?? configViewId(view.name, index);
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        if (view.default !== undefined && view.initial === undefined)
+            ids.push(id);
+    });
+    return ids;
+}
+/**
+ * The id of the config view flagged `initial: true` (EC-343/EC-444; `default` read
+ * as a deprecated alias) — the seed for a collection's INITIAL active view. When
+ * several are flagged (a misconfiguration, reported by {@link configViewIssues}) the
+ * FIRST in declaration order wins deterministically; when none is flagged the caller
+ * falls back to the baseline lens. `undefined` when the collection flags none.
  */
 export function defaultConfigViewId(collection) {
-    return configViewsFor(collection).find((view) => view.default)?.id;
+    return configViewsFor(collection).find((view) => view.initial)?.id;
 }
 /**
- * Validate a collection's config-declared views (EC-343): at most one may set
- * `default: true`. A duplicate is returned as an explicit, structured issue —
- * never silently swallowed — so the studio can surface it (the first default still
- * wins deterministically for seeding, per {@link defaultConfigViewId}). Pure and
- * schema-only; the DOM-free counterpart of the "failures are first-class" contract.
+ * Validate a collection's config-declared views (EC-343/EC-444): at most one may set
+ * `initial: true` (`default` counted as its deprecated alias). A duplicate is returned
+ * as an explicit, structured issue — never silently swallowed — so the studio can
+ * surface it (the first still wins deterministically for seeding, per
+ * {@link defaultConfigViewId}). Pure and schema-only; the DOM-free counterpart of the
+ * "failures are first-class" contract.
  */
 export function configViewIssues(collection) {
-    const defaults = configViewsFor(collection).filter((view) => view.default);
-    if (defaults.length <= 1)
+    const initials = configViewsFor(collection).filter((view) => view.initial);
+    if (initials.length <= 1)
         return [];
-    const viewIds = defaults.map((view) => view.id);
+    const viewIds = initials.map((view) => view.id);
     return [
         {
             code: 'duplicate-default',
-            message: `Collection "${collection.id}" declares ${defaults.length} default views (${viewIds.join(', ')}); at most one view may set \`default: true\`. Seeding "${viewIds[0]}".`,
+            message: `Collection "${collection.id}" declares ${initials.length} initial views (${viewIds.join(', ')}); at most one view may set \`initial: true\`. Seeding "${viewIds[0]}".`,
             viewIds,
         },
     ];
@@ -463,12 +635,15 @@ export function configViewIssues(collection) {
  * selector, treating the first visible column as the title), then the
  * remaining fields in schema order.
  */
-function orderedColumnNames(collection) {
+function orderedColumnNames(collection, pseudo = []) {
     const names = collection.fields.map((field) => field.name);
     const title = titleFieldOf(collection)?.name;
-    if (title === undefined || !names.includes(title))
-        return names;
-    return [title, ...names.filter((name) => name !== title)];
+    const schemaOrdered = title === undefined || !names.includes(title)
+        ? names
+        : [title, ...names.filter((name) => name !== title)];
+    // EC-445: the column UNIVERSE = schema fields, then the applicable reserved
+    // pseudo-columns (they are NOT in `collection.fields`).
+    return [...schemaOrdered, ...pseudo];
 }
 /** Deep-cloned canonical form (stable key order via the Zod shape). */
 export function normalizeViewState(state) {
@@ -486,26 +661,40 @@ export function viewStatesEqual(a, b) {
  * or hidden" — order is preserved across hide/show because visibility lives in
  * `hidden`, never in the order.
  */
-export function resolveColumns(collection, state) {
+export function resolveColumns(collection, state, pseudo = []) {
     const schemaNames = collection.fields.map((field) => field.name);
-    const schema = new Set(schemaNames);
+    // EC-445: the valid universe to KEEP from the saved order is schema fields PLUS the
+    // applicable pseudo-columns (which are not in `collection.fields`) — so a seeded
+    // `$state`/`$url`/`$updatedAt` is preserved + ordered, never dropped as "unknown".
+    const keep = new Set([...schemaNames, ...pseudo]);
     const hidden = new Set(state.hidden);
-    // Keep the saved order, restricted to live fields and de-duplicated (a
+    const inState = new Set(state.columns);
+    // Keep the saved order, restricted to the live universe and de-duplicated (a
     // corrupted persisted state must never render one field as two columns).
     const ordered = [];
     const seen = new Set();
     for (const name of state.columns) {
-        if (schema.has(name) && !seen.has(name)) {
+        if (keep.has(name) && !seen.has(name)) {
             ordered.push(name);
             seen.add(name);
         }
     }
-    const appended = schemaNames.filter((name) => !seen.has(name));
-    return [...ordered, ...appended].map((field) => ({ field, visible: !hidden.has(field) }));
+    // Append universe members the saved order predates: new schema fields (EC-213
+    // discovery), then applicable pseudo-columns not yet placed (EC-445).
+    const appended = [
+        ...schemaNames.filter((name) => !seen.has(name)),
+        ...pseudo.filter((name) => !seen.has(name)),
+    ];
+    return [...ordered, ...appended].map((field) => {
+        // A freshly-appended opt-in pseudo-column ($publishedAt) starts hidden; once it
+        // is in the saved order (an editor un-hid it) its visibility follows `hidden`.
+        const defaultHiddenAppend = DEFAULT_HIDDEN_PSEUDO_COLUMNS.has(field) && !inState.has(field);
+        return { field, visible: !hidden.has(field) && !defaultHiddenAppend };
+    });
 }
 /** The visible columns of a view, in render order (EC-213). */
-export function visibleColumns(collection, state) {
-    return resolveColumns(collection, state)
+export function visibleColumns(collection, state, pseudo = []) {
+    return resolveColumns(collection, state, pseudo)
         .filter((column) => column.visible)
         .map((column) => column.field);
 }
@@ -518,9 +707,11 @@ export function visibleColumns(collection, state) {
  * the first visible column, then the first field, then `id`, when no title field
  * is resolvable (e.g. a function title with no backing `title` field).
  */
-export function primaryColumn(collection, state) {
+export function primaryColumn(collection, state, pseudo = []) {
     return (titleFieldOf(collection)?.name ??
-        visibleColumns(collection, state)[0] ??
+        // EC-445: a pseudo-column is never the identity column (it has no title value) —
+        // fall back to the first visible SCHEMA column.
+        visibleColumns(collection, state, pseudo).find((name) => !isPseudoColumn(name)) ??
         collection.fields[0]?.name ??
         'id');
 }
@@ -530,8 +721,8 @@ export function primaryColumn(collection, state) {
  * `hidden` to fields the live schema still has (a column removed from the schema
  * must not leave dead `hidden` cruft that trips dirty-detection / persists).
  */
-function withResolvedOrder(collection, state) {
-    const columns = resolveColumns(collection, state).map((column) => column.field);
+function withResolvedOrder(collection, state, pseudo = []) {
+    const columns = resolveColumns(collection, state, pseudo).map((column) => column.field);
     const live = new Set(columns);
     const hidden = state.hidden.filter((name) => live.has(name));
     return { ...state, columns, hidden };
@@ -543,24 +734,24 @@ function withResolvedOrder(collection, state) {
  * reconciliation or a stale `hidden` entry (only a real filter/sort/visibility/
  * order change counts as "unsaved").
  */
-export function canonicalViewState(collection, state) {
-    return normalizeViewState(withResolvedOrder(collection, state));
+export function canonicalViewState(collection, state, pseudo = []) {
+    return normalizeViewState(withResolvedOrder(collection, state, pseudo));
 }
 /**
  * Toggle a column's visibility — position is preserved (EC-213): visibility
  * lives in `hidden`, the order in `columns` is untouched. Columns the saved
  * order predates are pinned into `columns` first so their place is stable.
  */
-export function toggleColumn(collection, state, field) {
-    const base = withResolvedOrder(collection, state);
+export function toggleColumn(collection, state, field, pseudo = []) {
+    const base = withResolvedOrder(collection, state, pseudo);
     const hidden = base.hidden.includes(field)
         ? base.hidden.filter((name) => name !== field)
         : [...base.hidden, field];
     return { ...base, hidden };
 }
 /** Move a column one position left (-1) or right (+1) in the full column order. */
-export function moveColumn(collection, state, field, delta) {
-    const base = withResolvedOrder(collection, state);
+export function moveColumn(collection, state, field, delta, pseudo = []) {
+    const base = withResolvedOrder(collection, state, pseudo);
     const from = base.columns.indexOf(field);
     const to = from + delta;
     if (from < 0 || to < 0 || to >= base.columns.length)