@praxisui/table 10.0.0-rc.4 → 10.0.0-rc.40

package/fesm2022/praxisui-table-authoring.mjs

@@ -0,0 +1,2173 @@
+import { validateRichContentDocument, isSafeRichContentClassName } from '@praxisui/rich-content';
+import { resolveColumnTypeFromFieldDefinition, deepMerge, isPraxisPresentationVisualizationTableSafe, resolveTextMaskFormatFromFieldDefinition } from '@praxisui/core/schema';
+import { uiLayoutJsonIdentity, cloneBoundedUiLayoutJsonDocument, derivePageChildRuntimeId } from '@praxisui/core';
+
+const ORIGIN = '__praxisAuthoredDisabled';
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const isAction = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const hasRuntimeState = (action) => Object.keys(action).some(key => key.startsWith('__praxis'));
+function authoredDisabled(action) {
+    const origin = action[ORIGIN];
+    if (isAction(origin) && typeof origin['present'] === 'boolean'
+        && (!origin['present'] || typeof origin['value'] === 'boolean')) {
+        return origin;
+    }
+    return {
+        present: typeof action['disabled'] === 'boolean',
+        value: typeof action['disabled'] === 'boolean' ? action['disabled'] : undefined,
+        // Old materializations do not carry enough evidence to remove a denial safely.
+        ...(hasRuntimeState(action) && action['disabled'] === true ? { ambiguous: true } : {}),
+    };
+}
+/** Internal runtime bookkeeping. It survives clones but is never part of an authored action. */
+function withActionAvailability(action, disabled, source = action) {
+    const origin = authoredDisabled(source);
+    return { ...action, disabled: origin.value === true || disabled, [ORIGIN]: origin };
+}
+function identity(action) {
+    if (typeof action['id'] === 'string' && action['id'].trim())
+        return `id:${action['id']}`;
+    if (typeof action['action'] === 'string' && action['action'].trim())
+        return `action:${action['action']}`;
+    return undefined;
+}
+/** Projects only canonical action slots, never arbitrary business payloads or callback values. */
+function projectTableActionAuthoring(config, authored, report) {
+    const hasAuthoredBaseline = authored !== undefined && authored !== null;
+    function actions(value, original, path) {
+        if (!Array.isArray(value))
+            return value;
+        const originals = Array.isArray(original) ? original.filter(isAction) : [];
+        const projected = [];
+        value.forEach((item, index) => {
+            if (!isAction(item)) {
+                projected.push(item);
+                return;
+            }
+            const key = identity(item);
+            const matches = key ? originals.filter(candidate => identity(candidate) === key) : [];
+            // No label matching, positional matching or guessing across duplicate identities.
+            const source = matches.length === 1 && value.filter(candidate => isAction(candidate) && identity(candidate) === key).length === 1
+                ? matches[0] : undefined;
+            const isRuntimeSynthesizedOnly = Boolean(item['__praxisDiscoveredAction']) ||
+                Boolean(item['__praxisBulkSyncAction']) ||
+                (hasAuthoredBaseline && Boolean(item['__praxisCollectionCreateAction']));
+            if (isRuntimeSynthesizedOnly && !source) {
+                return;
+            }
+            const result = { ...item };
+            if (hasRuntimeState(item)) {
+                const origin = source && !hasRuntimeState(source) ? authoredDisabled(source) : authoredDisabled(item);
+                if (origin.present)
+                    result['disabled'] = origin.value;
+                else
+                    delete result['disabled'];
+                if (origin.ambiguous)
+                    report?.({
+                        level: 'warning', code: 'table.action.disabled.origin.unknown',
+                        message: 'Review the disabled setting: this legacy action contains runtime availability without its authored origin. The existing denial was preserved.',
+                        path: `${path}[${index}].disabled`,
+                    });
+                for (const name of Object.keys(result))
+                    if (name.startsWith('__praxis'))
+                        delete result[name];
+            }
+            if (hasOwn(item, 'children'))
+                result['children'] = actions(item['children'], source?.['children'], `${path}[${index}].children`);
+            projected.push(result);
+        });
+        return projected;
+    }
+    const result = { ...config };
+    if (config?.toolbar)
+        result.toolbar = {
+            ...config.toolbar,
+            ...(hasOwn(config.toolbar, 'actions') ? { actions: actions(config.toolbar.actions, authored?.toolbar?.actions, 'config.toolbar.actions') } : {}),
+        };
+    if (config?.actions) {
+        result.actions = { ...config.actions };
+        for (const slot of ['row', 'bulk']) {
+            const group = config.actions[slot];
+            if (group)
+                result.actions[slot] = {
+                    ...group,
+                    ...(hasOwn(group, 'actions') ? { actions: actions(group.actions, authored?.actions?.[slot]?.actions, `config.actions.${slot}.actions`) } : {}),
+                };
+        }
+    }
+    return result;
+}
+/** Internal adapter: project before canonical normalization discards runtime evidence. */
+function projectTableEditorActionInput(raw, authored) {
+    if (!isAction(raw))
+        return raw;
+    if (raw['kind'] === 'praxis.table.editor' && isAction(raw['config'])) {
+        return { ...raw, config: projectTableActionAuthoring(raw['config'], authored) };
+    }
+    return projectTableActionAuthoring(raw, authored);
+}
+
+const FORBIDDEN_ENCODED_PATH_PART = /%(?:25)*(?:2e|2f|5c)/i;
+const FORBIDDEN_RAW_PATH_PART = /\\/;
+const FORBIDDEN_CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/;
+const FORBIDDEN_DOT_SEGMENT = /(?:^|\/)\.{1,2}(?:\/|$)/;
+const ABSOLUTE_OR_SCHEME = /^(?:\/\/|[a-z][a-z0-9+.-]*:|[a-z]:[\\/])/i;
+function isTableDetailResourcePathTemplateSafe(value) {
+    const raw = String(value || '').trim();
+    const path = raw.split(/[?#]/, 1)[0];
+    return !!raw && !ABSOLUTE_OR_SCHEME.test(raw)
+        && !FORBIDDEN_CONTROL_CHARACTER.test(raw)
+        && !FORBIDDEN_ENCODED_PATH_PART.test(path)
+        && !FORBIDDEN_RAW_PATH_PART.test(path)
+        && !FORBIDDEN_DOT_SEGMENT.test(path);
+}
+function canonicalPath(value, baseHref, allowWildcard = false) {
+    const raw = String(value || '').trim();
+    if (!isTableDetailResourcePathTemplateSafe(raw))
+        return null;
+    let wildcardSentinel = '__PRAXIS_DETAIL_WILDCARD__';
+    while (raw.includes(wildcardSentinel)) {
+        wildcardSentinel += '_';
+    }
+    const prepared = allowWildcard ? raw.replace(/\*/g, wildcardSentinel) : raw;
+    try {
+        const parsed = new URL(prepared, baseHref);
+        if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password)
+            return null;
+        const path = parsed.pathname
+            .replace(/^\/+/, '')
+            .replace(new RegExp(wildcardSentinel, 'g'), '*');
+        return { origin: parsed.origin, path, url: parsed.href };
+    }
+    catch {
+        return null;
+    }
+}
+function wildcardToRegExp(pattern) {
+    let source = '^';
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === '*') {
+            if (pattern[index + 1] === '*') {
+                source += '.*';
+                index += 1;
+            }
+            else {
+                source += '[^/]+';
+            }
+        }
+        else {
+            source += character.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`${source}$`);
+}
+/** Resolves the URL exactly as the browser will, then applies same-origin and path policy. */
+function resolveTableDetailResourcePath(value, allowList, baseHref, trustedOrigin) {
+    let base;
+    let trusted;
+    try {
+        base = new URL(baseHref);
+        trusted = new URL(trustedOrigin);
+    }
+    catch {
+        return { ok: false, reason: 'invalid' };
+    }
+    const candidate = canonicalPath(value, base.href);
+    if (!candidate)
+        return { ok: false, reason: 'invalid' };
+    if (base.origin !== trusted.origin || candidate.origin !== trusted.origin) {
+        return { ok: false, reason: 'origin' };
+    }
+    const allowed = allowList.some((entry) => {
+        const pattern = canonicalPath(entry, base.href, true);
+        return !!pattern
+            && pattern.origin === trusted.origin
+            && wildcardToRegExp(pattern.path).test(candidate.path);
+    });
+    return allowed
+        ? { ok: true, url: candidate.url, normalizedPath: candidate.path }
+        : { ok: false, reason: 'allowlist' };
+}
+
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function applyTableDetailAuthoringOperation(config, operationId, input) {
+    if (!isObject(input) || !Object.keys(input).length)
+        throw new Error('Detail input must be a non-empty object.');
+    const merge = (source, patch) => {
+        if (!patch || typeof patch !== 'object' || Array.isArray(patch))
+            return structuredClone(patch);
+        const next = source && typeof source === 'object' && !Array.isArray(source) ? { ...source } : {};
+        for (const key of Object.keys(patch))
+            Object.defineProperty(next, key, {
+                value: merge(Object.prototype.hasOwnProperty.call(next, key) ? next[key] : undefined, patch[key]),
+                enumerable: true, configurable: true, writable: true,
+            });
+        return next;
+    };
+    let next = { ...config, behavior: { ...config.behavior } };
+    let command = {};
+    if (operationId === 'expansion.configure') {
+        next.behavior.expansion = merge(config.behavior?.expansion, input);
+        if (input.enabled === true)
+            command = { enabled: true, placement: 'row' };
+    }
+    else if (operationId === 'detail.configure') {
+        if (input.presentation !== undefined && !isObject(input.presentation))
+            throw new Error('Invalid detail presentation input.');
+        next.behavior.detail = merge(config.behavior?.detail, input);
+        command = {
+            placement: input.presentation?.placement,
+            initiallyCollapsed: input.presentation?.initiallyCollapsed,
+            bottomStackPosition: input.presentation?.bottomStackPosition,
+            emptyBehavior: input.presentation?.emptyBehavior,
+            enabled: input.enabled,
+        };
+    }
+    else if (operationId === 'detail.presentation.configure') {
+        next.behavior.detail = { ...config.behavior?.detail, presentation: merge(config.behavior?.detail?.presentation, input) };
+        command = {
+            placement: input.placement,
+            initiallyCollapsed: input.initiallyCollapsed,
+            bottomStackPosition: input.bottomStackPosition,
+            emptyBehavior: input.emptyBehavior,
+        };
+    }
+    else {
+        next.behavior.detail = { ...config.behavior?.detail, source: merge(config.behavior?.detail?.source, input) };
+    }
+    if (((operationId === 'detail.configure' || operationId === 'expansion.configure') && input.enabled !== undefined && typeof input.enabled !== 'boolean')
+        || (command.enabled !== undefined && typeof command.enabled !== 'boolean')
+        || (command.placement !== undefined && !['row', 'bottom'].includes(command.placement))
+        || (command.initiallyCollapsed !== undefined && typeof command.initiallyCollapsed !== 'boolean')
+        || (command.bottomStackPosition !== undefined && !['beforeControls', 'afterControls'].includes(command.bottomStackPosition))
+        || (command.emptyBehavior !== undefined && !['message', 'hide'].includes(command.emptyBehavior))) {
+        throw new Error('Invalid detail presentation input.');
+    }
+    if (Object.keys(command).length)
+        next = configureTableDetailPresentation(next, command);
+    const issues = tableDetailAuthoringIssues(next);
+    if (issues.length)
+        throw new Error(`Invalid detail configuration: ${issues.join(', ')}`);
+    return next;
+}
+/** Explicit authoring commands only. Hydration never calls this function. */
+function configureTableDetailPresentation(config, command) {
+    const behavior = config.behavior ?? {};
+    const detail = behavior.detail ?? {};
+    const presentation = { ...detail.presentation };
+    if (command.placement !== undefined)
+        presentation.placement = command.placement;
+    if (command.initiallyCollapsed !== undefined)
+        presentation.initiallyCollapsed = command.initiallyCollapsed;
+    if (command.bottomStackPosition !== undefined)
+        presentation.bottomStackPosition = command.bottomStackPosition;
+    if (command.emptyBehavior !== undefined)
+        presentation.emptyBehavior = command.emptyBehavior;
+    const next = { ...config, behavior: { ...behavior, detail: { ...detail } } };
+    const target = next.behavior;
+    if (Object.keys(presentation).length)
+        target.detail.presentation = presentation;
+    if (command.enabled !== undefined)
+        target.detail.enabled = command.enabled;
+    if (command.enabled === false) {
+        target.expansion = { ...behavior.expansion, enabled: false };
+    }
+    else if (command.placement !== undefined || command.enabled === true) {
+        target.detail.enabled = true;
+        const bottom = (command.placement ?? detail.presentation?.placement ?? 'row') === 'bottom';
+        target.expansion = { ...behavior.expansion, enabled: !bottom };
+        if (bottom && behavior.selection?.enabled !== true) {
+            target.selection = {
+                mode: 'both', allowSelectAll: false, checkboxPosition: 'start',
+                persistSelection: false, persistOnDataUpdate: false,
+                ...behavior.selection, type: 'single', enabled: true,
+            };
+        }
+    }
+    return next;
+}
+function tableDetailAuthoringIssues(config) {
+    const detail = config.behavior?.detail;
+    if (detail === undefined)
+        return [];
+    if (!isObject(detail))
+        return ['structure'];
+    for (const key of ['presentation', 'source', 'schemaContract', 'rendering', 'height', 'lazyLoad']) {
+        if (detail[key] !== undefined && !isObject(detail[key]))
+            return ['structure'];
+    }
+    const sourceMode = detail.source?.mode;
+    const resource = detail.source?.resource;
+    const resourcePath = detail.source?.resourcePath;
+    const resourceAllowList = detail.source?.resourceAllowList;
+    if ((detail.enabled !== undefined && typeof detail.enabled !== 'boolean')
+        || (detail.presentation?.initiallyCollapsed !== undefined && typeof detail.presentation.initiallyCollapsed !== 'boolean')
+        || (detail.presentation?.bottomStackPosition !== undefined && !['beforeControls', 'afterControls'].includes(detail.presentation.bottomStackPosition))
+        || (detail.presentation?.emptyBehavior !== undefined && !['message', 'hide'].includes(detail.presentation.emptyBehavior))
+        || (detail.source?.mode !== undefined && !['inline', 'resource', 'resourcePath', 'hypermedia'].includes(detail.source.mode))
+        || (detail.source?.inlineSchema !== undefined && !isObject(detail.source.inlineSchema))
+        || (detail.source?.inlineSchema?.items !== undefined && !Array.isArray(detail.source.inlineSchema.items))
+        || (resource !== undefined && !isObject(resource))
+        || (resourcePath !== undefined && !isObject(resourcePath))
+        || (detail.source?.contextMap !== undefined && !isObject(detail.source.contextMap))
+        || (resourcePath?.paramsMap !== undefined && !isObject(resourcePath.paramsMap))
+        || (resourceAllowList !== undefined && (!Array.isArray(resourceAllowList) || resourceAllowList.some((entry) => typeof entry !== 'string')))
+        || (detail.source?.fallbackMode !== undefined && !['none', 'inline', 'resource'].includes(detail.source.fallbackMode))
+        || (detail.lazyLoad?.enabled !== undefined && typeof detail.lazyLoad.enabled !== 'boolean')
+        || (detail.lazyLoad?.actionId !== undefined && typeof detail.lazyLoad.actionId !== 'string')
+        || (detail.lazyLoad?.cache !== undefined && !isObject(detail.lazyLoad.cache))
+        || (detail.lazyLoad?.cache?.enabled !== undefined && typeof detail.lazyLoad.cache.enabled !== 'boolean')
+        || (detail.lazyLoad?.cache?.ttlMs !== undefined && (!Number.isFinite(detail.lazyLoad.cache.ttlMs) || detail.lazyLoad.cache.ttlMs <= 0))
+        || (detail.lazyLoad?.retry !== undefined && !isObject(detail.lazyLoad.retry))
+        || (detail.lazyLoad?.retry?.maxAttempts !== undefined && (!Number.isInteger(detail.lazyLoad.retry.maxAttempts) || detail.lazyLoad.retry.maxAttempts < 0))
+        || (detail.lazyLoad?.cancelOnCollapse !== undefined && typeof detail.lazyLoad.cancelOnCollapse !== 'boolean')
+        || (detail.lazyLoad?.dedupeByRowKey !== undefined && typeof detail.lazyLoad.dedupeByRowKey !== 'boolean'))
+        return ['structure'];
+    const issues = [];
+    const placement = detail.presentation?.placement ?? 'row';
+    if (placement !== 'row' && placement !== 'bottom')
+        issues.push('placement');
+    if ((placement === 'bottom' || detail.enabled === false) && config.behavior?.expansion?.enabled)
+        issues.push('conflict');
+    if (detail.enabled !== false && placement === 'bottom' && !config.behavior?.selection?.enabled)
+        issues.push('selection');
+    if (detail.height?.px !== undefined && (!Number.isFinite(detail.height.px) || detail.height.px <= 0))
+        issues.push('height');
+    if (detail.height?.mode !== undefined && !['fixed', 'dynamic'].includes(detail.height.mode))
+        issues.push('height');
+    if (detail.height?.mode === 'fixed' && detail.height?.px === undefined)
+        issues.push('height');
+    const validResource = !!resource
+        && ['ui-composition', 'form-schema', 'table-schema', 'dashboard-schema'].includes(resource.kind)
+        && typeof resource.id === 'string' && !!resource.id.trim()
+        && typeof resource.version === 'string' && !!resource.version.trim();
+    const validInline = detail.source?.inlineSchema !== undefined;
+    const effectiveSourceMode = sourceMode ?? 'inline';
+    if (detail.enabled !== false && effectiveSourceMode === 'inline' && !validInline)
+        issues.push('source');
+    if (sourceMode === 'resource' && !validResource)
+        issues.push('source');
+    if (detail.source?.fallbackMode !== undefined
+        && detail.source.fallbackMode !== 'none'
+        && detail.source.fallbackMode === effectiveSourceMode)
+        issues.push('source');
+    if (sourceMode === 'resourcePath' && (typeof resourcePath?.path !== 'string' || !resourcePath.path.trim()
+        || !isTableDetailResourcePathTemplateSafe(resourcePath.path)
+        || (resourcePath.method !== undefined && !['GET', 'POST'].includes(resourcePath.method))
+        || !Array.isArray(resourceAllowList) || resourceAllowList.length === 0
+        || resourceAllowList.some((entry) => !entry.trim() || !isTableDetailResourcePathTemplateSafe(entry))))
+        issues.push('source');
+    if (detail.source?.fallbackMode === 'inline' && !validInline)
+        issues.push('source');
+    if (detail.source?.fallbackMode === 'resource' && !validResource)
+        issues.push('source');
+    if (validInline && (effectiveSourceMode === 'inline' || detail.source?.fallbackMode === 'inline')) {
+        const inlineIssues = inspectInlineDetailSchema(detail.source.inlineSchema, config);
+        issues.push(...inlineIssues);
+    }
+    return [...new Set(issues)];
+}
+function inspectInlineDetailSchema(schema, config) {
+    const issues = [];
+    const declaredActionIds = new Set((config.actions?.row?.actions ?? [])
+        .map((action) => String(action.id || '').trim())
+        .filter(Boolean));
+    const seen = new WeakSet();
+    const visit = (value) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        const node = value;
+        if (node['type'] === 'richContent') {
+            if (!validateRichContentDocument(node['document']).valid
+                || !isSafeRichContentClassName(node['rootClassName'])) {
+                issues.push('content');
+            }
+        }
+        if (typeof node['actionId'] === 'string') {
+            const actionId = node['actionId'].trim();
+            if (!actionId || !declaredActionIds.has(actionId))
+                issues.push('action');
+        }
+        Object.values(node).forEach(visit);
+    };
+    visit(schema);
+    const offContract = hasOffContractRichChildren([schema]);
+    if (offContract.cardGrid)
+        issues.push('cardGridContent');
+    if (offContract.compose)
+        issues.push('composeContent');
+    return issues;
+}
+/** Rich node types accepted as `cardGrid` card content by the canonical `TableDetailCardGridCardNode` contract. */
+const TABLE_DETAIL_CARD_GRID_PRESENTER_TYPES = new Set([
+    'text', 'icon', 'image', 'badge', 'avatar', 'metric', 'progress', 'progressBar',
+    'microVisualization', 'link', 'chip', 'button', 'rating',
+]);
+/** `RichComposeNode.items` accepts presenters only (no nested compose). */
+function isTableDetailComposeItemNode(node) {
+    if (!node || typeof node !== 'object' || Array.isArray(node))
+        return false;
+    return TABLE_DETAIL_CARD_GRID_PRESENTER_TYPES.has(String(node['type'] || '').trim());
+}
+function isTableDetailCardGridContentNode(node) {
+    if (!node || typeof node !== 'object' || Array.isArray(node))
+        return false;
+    const type = String(node['type'] || '').trim();
+    return type === 'compose' || TABLE_DETAIL_CARD_GRID_PRESENTER_TYPES.has(type);
+}
+/**
+ * Projects an authored node into canonical `cardGrid` card content (`RichPresenterNode | RichComposeNode`).
+ * Table-detail `value` fields become `metric` (labelled) or `text` presenters; structural blocks that
+ * cannot live inside a rich card (stack, tabs, card, timeline, chartRef, richContent) return `null`.
+ */
+function toTableDetailCardGridContentNode(node) {
+    if (isTableDetailCardGridContentNode(node))
+        return node;
+    const type = String(node?.['type'] || '').trim();
+    if (type === 'cardGrid') {
+        const firstCard = Array.isArray(node['cards']) ? node['cards'][0] : undefined;
+        const firstList = Array.isArray(firstCard?.content)
+            ? firstCard.content
+            : Array.isArray(firstCard?.items)
+                ? firstCard.items
+                : undefined;
+        const first = firstList?.[0];
+        return first ? toTableDetailCardGridContentNode(structuredClone(first)) : null;
+    }
+    if (type !== 'value')
+        return null;
+    const field = String(node['field'] || node['valueField'] || '').trim();
+    const authoredExpr = typeof node['valueExpr'] === 'string' ? node['valueExpr'].trim().replace(/^=\s*/, '') : '';
+    const valueExpr = authoredExpr || (field ? `row.${field}` : '');
+    const label = typeof node['label'] === 'string' && node['label'].trim()
+        ? node['label'].trim()
+        : typeof node['title'] === 'string' && node['title'].trim()
+            ? node['title'].trim()
+            : '';
+    if (valueExpr) {
+        return {
+            ...(node['id'] ? { id: node['id'] } : {}),
+            ...(label ? { type: 'metric', label, valueExpr } : { type: 'text', textExpr: valueExpr }),
+            ...(node['visibleWhen'] !== undefined && node['visibleWhen'] !== null ? { visibleWhen: node['visibleWhen'] } : {}),
+        };
+    }
+    if (Object.prototype.hasOwnProperty.call(node, 'value') && node['value'] !== undefined && node['value'] !== null) {
+        const literalText = String(node['value']);
+        if (label) {
+            return {
+                type: 'compose',
+                ...(node['id'] ? { id: node['id'] } : {}),
+                className: 'pfx-expansion-node pfx-expansion-node-value',
+                direction: 'column',
+                gap: 'xs',
+                items: [
+                    { type: 'text', className: 'pfx-expansion-node-value__label', text: label },
+                    { type: 'text', className: 'pfx-expansion-node-value__content', text: literalText },
+                ],
+                ...(node['visibleWhen'] !== undefined && node['visibleWhen'] !== null ? { visibleWhen: node['visibleWhen'] } : {}),
+            };
+        }
+        return {
+            type: 'text',
+            ...(node['id'] ? { id: node['id'] } : {}),
+            text: literalText,
+            ...(node['visibleWhen'] !== undefined && node['visibleWhen'] !== null ? { visibleWhen: node['visibleWhen'] } : {}),
+        };
+    }
+    return null;
+}
+/** Projects an authored node into a canonical compose item (presenter); a compose result yields its first presenter. */
+function toTableDetailComposeItemNode(node) {
+    if (node &&
+        typeof node === 'object' &&
+        node['type'] === 'value' &&
+        !node['field'] &&
+        !node['valueField'] &&
+        !node['valueExpr'] &&
+        Object.prototype.hasOwnProperty.call(node, 'value') &&
+        node['value'] !== undefined &&
+        node['value'] !== null) {
+        const label = typeof node['label'] === 'string' && node['label'].trim()
+            ? node['label'].trim()
+            : typeof node['title'] === 'string' && node['title'].trim()
+                ? node['title'].trim()
+                : '';
+        return {
+            type: 'text',
+            ...(node['id'] ? { id: node['id'] } : {}),
+            text: label ? `${label}: ${String(node['value'])}` : String(node['value']),
+            ...(node['visibleWhen'] !== undefined && node['visibleWhen'] !== null ? { visibleWhen: node['visibleWhen'] } : {}),
+        };
+    }
+    const projected = toTableDetailCardGridContentNode(node);
+    if (!projected)
+        return null;
+    if (projected['type'] !== 'compose')
+        return projected;
+    const first = Array.isArray(projected['items'])
+        ? projected['items'].find((item) => isTableDetailComposeItemNode(item))
+        : undefined;
+    return first ? structuredClone(first) : null;
+}
+/** True when a cardGrid card or a compose (outside richContent documents) holds off-contract children. */
+function hasOffContractRichChildren(nodes) {
+    const result = { cardGrid: false, compose: false };
+    const visit = (value) => {
+        if (!Array.isArray(value))
+            return;
+        for (const node of value) {
+            if (!node || typeof node !== 'object' || Array.isArray(node))
+                continue;
+            const record = node;
+            if (record['type'] === 'richContent')
+                continue;
+            if (record['type'] === 'cardGrid' && Array.isArray(record['cards'])) {
+                for (const card of record['cards']) {
+                    const content = Array.isArray(card?.['content']) ? card?.['content'] : card?.['items'];
+                    if (Array.isArray(content) && content.some((item) => !isTableDetailCardGridContentNode(item))) {
+                        result.cardGrid = true;
+                    }
+                }
+            }
+            if (record['type'] === 'compose' && Array.isArray(record['items'])
+                && record['items'].some((item) => !isTableDetailComposeItemNode(item))) {
+                result.compose = true;
+            }
+            visit(record['items']);
+            visit(record['content']);
+            visit(record['cards']);
+        }
+    };
+    visit(nodes);
+    return result;
+}
+/**
+ * Losslessly rewrites legacy table-detail `value` fields that sit inside cardGrid cards or compose items
+ * into canonical presenters. Structural blocks are left untouched (still reported) to avoid data loss.
+ * Returns the number of rewritten nodes.
+ */
+function normalizeTableDetailRichChildren(schema) {
+    let rewritten = 0;
+    const rewrite = (list, project, accepts) => {
+        if (!Array.isArray(list))
+            return;
+        list.forEach((item, index) => {
+            if (accepts(item) || item?.['type'] !== 'value')
+                return;
+            const projected = project(item);
+            if (projected) {
+                list[index] = projected;
+                rewritten += 1;
+            }
+        });
+    };
+    const visit = (value) => {
+        if (!Array.isArray(value))
+            return;
+        for (const node of value) {
+            if (!node || typeof node !== 'object' || Array.isArray(node) || node['type'] === 'richContent')
+                continue;
+            if (node['type'] === 'cardGrid' && Array.isArray(node['cards'])) {
+                for (const card of node['cards']) {
+                    rewrite(Array.isArray(card?.['content']) ? card?.['content'] : card?.['items'], toTableDetailCardGridContentNode, isTableDetailCardGridContentNode);
+                }
+            }
+            if (node['type'] === 'compose')
+                rewrite(node['items'], toTableDetailComposeItemNode, isTableDetailComposeItemNode);
+            visit(node['items']);
+            visit(node['content']);
+            visit(node['cards']);
+        }
+    };
+    visit([schema]);
+    return rewritten;
+}
+/** Edits the original authoring tree; keys exist only in the editor's WeakMap. */
+class TableDetailTreeDraft {
+    keys = new WeakMap();
+    sequence = 0;
+    selectedKey = null;
+    schema;
+    constructor(schema = { layout: 'stack', items: [] }) {
+        const nodeType = String(schema?.type || '').trim();
+        if (!nodeType) {
+            this.schema = schema;
+        }
+        else if (nodeType === 'tabs') {
+            this.schema = {
+                ...schema,
+                layout: 'tabs',
+                items: Array.isArray(schema.items)
+                    ? schema.items
+                    : (Array.isArray(schema.content) ? schema.content : []),
+            };
+        }
+        else {
+            this.schema = { layout: 'stack', items: [schema] };
+        }
+    }
+    entries() {
+        const result = [];
+        const visit = (nodes, depth) => {
+            if (!Array.isArray(nodes))
+                return;
+            for (const node of nodes) {
+                if (!node || typeof node !== 'object' || Array.isArray(node))
+                    continue;
+                let key = this.keys.get(node);
+                if (!key) {
+                    key = `detail-node-${++this.sequence}`;
+                    this.keys.set(node, key);
+                }
+                result.push({ key, node, siblings: nodes, depth });
+                for (const child of ['items', 'content', 'cards', 'nodes'])
+                    visit(node[child], depth + 1);
+            }
+        };
+        visit(this.schema.items, 0);
+        return result;
+    }
+    selected() { return this.entries().find(entry => entry.key === this.selectedKey); }
+    move(direction) {
+        const entry = this.selected();
+        if (!entry)
+            return;
+        const index = entry.siblings.indexOf(entry.node);
+        const next = index + direction;
+        if (next < 0 || next >= entry.siblings.length)
+            return;
+        entry.siblings.splice(index, 1);
+        entry.siblings.splice(next, 0, entry.node);
+    }
+    add(node, nested = false) {
+        const selectedEntry = this.selected();
+        const selected = selectedEntry?.node;
+        const isCardLike = selected?.type === 'card' || (!selected?.type && (Array.isArray(selected?.content) || Array.isArray(selected?.items)));
+        // Cards stored in `cardGrid.cards` follow TableDetailCardGridCardNode: rich presenters/compose only.
+        const isCardGridCard = !!selectedEntry && isCardLike && this.entries().some((entry) => entry.node['type'] === 'cardGrid' && entry.node['cards'] === selectedEntry.siblings);
+        const childKey = selected?.type === 'cardGrid'
+            ? 'cards'
+            : (isCardLike || selected?.type === 'tab')
+                ? (!Array.isArray(selected?.content) && Array.isArray(selected?.items) ? 'items' : 'content')
+                : 'items';
+        const parent = nested && selected ? selected : this.schema;
+        const key = nested && selected ? childKey : 'items';
+        if (!nested && this.schema.layout === 'tabs' && node.type !== 'tab') {
+            node = { type: 'tab', title: node.title || node.label || node.type, content: [node] };
+        }
+        else if (nested && selected?.type === 'cardGrid') {
+            if (node.type === 'cardGrid' && Array.isArray(node.cards) && node.cards.length > 0) {
+                node = structuredClone(node.cards[0]);
+            }
+            else if (node.type === 'card') {
+                const rawCardChildren = Array.isArray(node.content) ? node.content : Array.isArray(node.items) ? node.items : [];
+                const content = rawCardChildren
+                    .map((child) => toTableDetailCardGridContentNode(child))
+                    .filter((child) => !!child);
+                node = {
+                    ...(node.id ? { id: node.id } : {}),
+                    title: node.title ?? '',
+                    ...(node.subtitle !== undefined ? { subtitle: node.subtitle } : {}),
+                    content: content.length ? content : [{ type: 'text', text: node.title || 'Detalhe' }],
+                };
+            }
+            else if (!Array.isArray(node.content) && !Array.isArray(node.items)) {
+                const content = toTableDetailCardGridContentNode(node);
+                if (!content)
+                    return null;
+                node = {
+                    title: node.title || node.label || '',
+                    content: [content],
+                };
+            }
+        }
+        else if (nested && isCardGridCard) {
+            const content = toTableDetailCardGridContentNode(node);
+            if (!content)
+                return null;
+            node = content;
+        }
+        else if (nested && selected?.type === 'compose') {
+            // RichComposeNode.items accepts presenters only; the runtime drops anything else silently.
+            const item = toTableDetailComposeItemNode(node);
+            if (!item)
+                return null;
+            node = item;
+        }
+        else if (nested && isCardLike && node.type === 'cardGrid' && Array.isArray(node.cards)) {
+            const firstCardContent = node.cards[0]?.content ?? node.cards[0]?.items;
+            if (Array.isArray(firstCardContent) && firstCardContent.length > 0) {
+                node = structuredClone(firstCardContent[0]);
+            }
+        }
+        if (!Array.isArray(parent[key]))
+            parent[key] = [];
+        parent[key].push(node);
+        this.selectedKey = this.entries().find(entry => entry.node === node)?.key ?? null;
+        return node;
+    }
+}
+
+const DOCUMENT_KIND = 'praxis.table.editor';
+const DOCUMENT_VERSION = 1;
+const HORIZONTAL_SCROLL_VALUES = ['auto', 'wrap', 'none'];
+function createTableAuthoringDocument(source) {
+    const doc = {
+        kind: DOCUMENT_KIND,
+        version: DOCUMENT_VERSION,
+        config: asTableConfig(source?.config),
+    };
+    if (hasOwnProperty(source, 'bindings')) {
+        doc.bindings = source?.bindings;
+    }
+    return normalizeTableAuthoringDocument(doc);
+}
+function parseLegacyOrTableDocument(raw) {
+    const obj = asRecord(raw);
+    if (obj.kind === DOCUMENT_KIND && obj.version === DOCUMENT_VERSION) {
+        return normalizeTableAuthoringDocument({
+            kind: DOCUMENT_KIND,
+            version: DOCUMENT_VERSION,
+            config: asTableConfig(obj.config),
+            bindings: obj.bindings,
+        });
+    }
+    if (looksLikeLegacyPayload(obj)) {
+        const legacyConfig = extractLegacyTableConfig(obj);
+        const legacyIdField = normalizeIdField(obj.__idField__);
+        if (legacyIdField) {
+            legacyConfig.meta = {
+                ...(legacyConfig.meta || {}),
+                idField: legacyIdField,
+            };
+        }
+        return normalizeTableAuthoringDocument({
+            kind: DOCUMENT_KIND,
+            version: DOCUMENT_VERSION,
+            config: legacyConfig,
+            bindings: {
+                resourcePath: normalizeResourcePath(obj.__resourcePath__),
+                horizontalScroll: normalizeHorizontalScroll(obj.__horizontalScroll__),
+            },
+        });
+    }
+    return createTableAuthoringDocument({ config: raw });
+}
+function normalizeTableAuthoringDocument(doc) {
+    const config = ensureAuthoringCompleteness(normalizeTableConfig(doc?.config));
+    const legacyBindingIdField = normalizeIdField(doc?.bindings?.idField);
+    const legacyRuntimeIdField = normalizeIdField(doc?.config?.__idField__);
+    const canonicalIdField = normalizeIdField(config?.meta?.idField);
+    const migratedIdField = canonicalIdField || legacyBindingIdField || legacyRuntimeIdField;
+    if (migratedIdField && !canonicalIdField) {
+        config.meta = {
+            ...(config.meta || {}),
+            idField: migratedIdField,
+        };
+    }
+    const normalized = {
+        kind: DOCUMENT_KIND,
+        version: DOCUMENT_VERSION,
+        config,
+    };
+    if (hasOwnProperty(doc, 'bindings')) {
+        normalized.bindings = normalizeBindings(doc?.bindings);
+    }
+    return normalized;
+}
+function validateTableAuthoringDocument(doc, context) {
+    const raw = asRecord(doc);
+    const rawConfig = asRecord(raw.config);
+    const rawBindings = asRecord(raw.bindings);
+    const normalized = normalizeTableAuthoringDocument(doc);
+    const diagnostics = [];
+    projectTableActionAuthoring(rawConfig, undefined, diagnostic => diagnostics.push(diagnostic));
+    for (const issue of tableDetailAuthoringIssues(rawConfig)) {
+        diagnostics.push(errorDiagnostic(`table.config.detail.${issue}`, `Invalid detail configuration: ${issue}`, 'config.behavior.detail'));
+    }
+    if ('columns' in rawConfig && !Array.isArray(rawConfig.columns)) {
+        diagnostics.push(errorDiagnostic('table.config.columns.invalid', 'config.columns must be an array', 'config.columns'));
+        return diagnostics;
+    }
+    const rawColumns = Array.isArray(rawConfig.columns)
+        ? rawConfig.columns
+        : (normalized.config.columns || []);
+    const columnFields = new Set();
+    rawColumns.forEach((column, index) => {
+        const field = trimString(column?.field);
+        if (!field) {
+            diagnostics.push(errorDiagnostic('table.config.columns.field.required', 'Column field is required', `config.columns[${index}].field`));
+        }
+        else if (columnFields.has(field)) {
+            diagnostics.push(errorDiagnostic('table.config.columns.field.duplicate', 'Column field must be unique within the table', `config.columns[${index}].field`));
+        }
+        else {
+            columnFields.add(field);
+        }
+    });
+    if ('columnProjection' in rawConfig) {
+        const projection = asRecord(rawConfig.columnProjection);
+        if (!rawConfig.columnProjection
+            || typeof rawConfig.columnProjection !== 'object'
+            || Array.isArray(rawConfig.columnProjection)) {
+            diagnostics.push(errorDiagnostic('table.config.columnProjection.invalid', 'config.columnProjection must be an object', 'config.columnProjection'));
+        }
+        else if (projection.source !== 'schema') {
+            diagnostics.push(errorDiagnostic('table.config.columnProjection.source.invalid', 'config.columnProjection.source must be schema', 'config.columnProjection.source'));
+        }
+        if ('include' in projection) {
+            if (!Array.isArray(projection.include)
+                || projection.include.some((field) => typeof field !== 'string' || !field.trim())
+                || new Set(projection.include).size !== projection.include.length) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.include.invalid', 'config.columnProjection.include must be an ordered array of unique canonical field names', 'config.columnProjection.include'));
+            }
+        }
+        if ('order' in projection && (!Array.isArray(projection.order)
+            || projection.order.some((field) => typeof field !== 'string' || !field.trim() || field !== field.trim())
+            || new Set(projection.order).size !== projection.order.length)) {
+            diagnostics.push(errorDiagnostic('table.config.columnProjection.order.invalid', 'config.columnProjection.order must contain unique canonical field names without selecting membership', 'config.columnProjection.order'));
+        }
+        if ('overrides' in projection) {
+            const overrides = asRecord(projection.overrides);
+            if (!projection.overrides
+                || typeof projection.overrides !== 'object'
+                || Array.isArray(projection.overrides)) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.overrides.invalid', 'config.columnProjection.overrides must be an object keyed by canonical field name', 'config.columnProjection.overrides'));
+            }
+            else {
+                Object.entries(overrides).forEach(([field, override]) => {
+                    if (!field.trim() || !override || typeof override !== 'object' || Array.isArray(override)) {
+                        diagnostics.push(errorDiagnostic('table.config.columnProjection.override.invalid', 'Each column projection override must be an object keyed by canonical field name', `config.columnProjection.overrides.${field}`));
+                        return;
+                    }
+                    if (hasOwnProperty(override, 'field')) {
+                        diagnostics.push(errorDiagnostic('table.config.columnProjection.override.field.forbidden', 'A schema column projection override cannot change the canonical field identity', `config.columnProjection.overrides.${field}.field`));
+                    }
+                });
+            }
+        }
+        if ('additions' in projection) {
+            if (!Array.isArray(projection.additions)) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.additions.invalid', 'config.columnProjection.additions must be an array of editorial columns', 'config.columnProjection.additions'));
+            }
+            else {
+                const fields = projection.additions
+                    .map((column) => trimString(asRecord(column).field));
+                if (fields.some((field) => !field)
+                    || new Set(fields).size !== fields.length) {
+                    diagnostics.push(errorDiagnostic('table.config.columnProjection.additions.field.invalid', 'Each editorial addition must have a unique field', 'config.columnProjection.additions'));
+                }
+            }
+        }
+    }
+    const bindings = normalized.bindings || {};
+    const metaIdField = trimString(normalized.config?.meta?.idField);
+    if ('horizontalScroll' in rawBindings &&
+        rawBindings.horizontalScroll !== undefined &&
+        normalizeHorizontalScroll(rawBindings.horizontalScroll) === undefined) {
+        diagnostics.push(errorDiagnostic('table.bindings.horizontalScroll.invalid', 'horizontalScroll must be auto, wrap or none', 'bindings.horizontalScroll'));
+    }
+    if (bindings.horizontalScroll &&
+        !HORIZONTAL_SCROLL_VALUES.includes(bindings.horizontalScroll)) {
+        diagnostics.push(errorDiagnostic('table.bindings.horizontalScroll.invalid', 'horizontalScroll must be auto, wrap or none', 'bindings.horizontalScroll'));
+    }
+    const effectiveMode = resolveEffectiveDataMode(normalized, context);
+    if (rawConfig.columnProjection && effectiveMode !== 'remote') {
+        diagnostics.push(warnDiagnostic('table.config.columnProjection.remote-schema.required', 'Schema column projection requires a remote resourcePath at runtime', 'config.columnProjection'));
+    }
+    if (effectiveMode === 'local') {
+        if (normalized.config.behavior?.pagination?.strategy === 'server') {
+            diagnostics.push(warnDiagnostic('table.behavior.pagination.strategy.invalid-for-local', 'Server pagination will be projected to client in local mode', 'config.behavior.pagination.strategy'));
+        }
+        if (normalized.config.behavior?.sorting?.strategy === 'server') {
+            diagnostics.push(warnDiagnostic('table.behavior.sorting.strategy.invalid-for-local', 'Server sorting will be projected to client in local mode', 'config.behavior.sorting.strategy'));
+        }
+    }
+    if (context?.server?.idField &&
+        metaIdField &&
+        context.server.idField !== metaIdField) {
+        diagnostics.push(warnDiagnostic('table.meta.idField.diverges-from-server', 'config.meta.idField diverges from current server idField', 'config.meta.idField'));
+    }
+    const configHash = trimString(normalized.config?.meta?.serverHash);
+    if (context?.server?.schemaHash && !configHash) {
+        diagnostics.push(infoDiagnostic('table.meta.serverHash.snapshot-missing', 'No persisted schema snapshot is available for reconciliation with the current server schema hash', 'config.meta.serverHash'));
+    }
+    if (context?.server?.schemaHash && configHash && context.server.schemaHash !== configHash) {
+        diagnostics.push(warnDiagnostic('table.meta.serverHash.diverges-from-server', 'config.meta.serverHash snapshot diverges from current server schema hash', 'config.meta.serverHash'));
+    }
+    return diagnostics;
+}
+function toCanonicalTableConfig(doc, context) {
+    const normalized = normalizeTableAuthoringDocument(doc);
+    const cfg = cloneJson(normalized.config);
+    const effectiveMode = resolveEffectiveDataMode(normalized, context);
+    if (effectiveMode === 'local') {
+        if (cfg.behavior?.pagination?.strategy === 'server') {
+            cfg.behavior = {
+                ...(cfg.behavior || {}),
+                pagination: {
+                    ...(cfg.behavior?.pagination || {}),
+                    strategy: 'client',
+                },
+            };
+        }
+        if (cfg.behavior?.sorting?.strategy === 'server') {
+            cfg.behavior = {
+                ...(cfg.behavior || {}),
+                sorting: {
+                    ...(cfg.behavior?.sorting || {}),
+                    strategy: 'client',
+                },
+            };
+        }
+    }
+    return stripLegacyRuntimeMarkers(cfg);
+}
+function buildTableApplyPlan(doc, runtime, options) {
+    const normalized = normalizeTableAuthoringDocument(doc);
+    const hasBindings = hasOwnProperty(doc, 'bindings');
+    const diagnostics = validateTableAuthoringDocument(doc, {
+        hasLocalDataInput: runtime?.hasLocalDataInput,
+        localDataModeDefaultEnabled: runtime?.localDataModeDefaultEnabled,
+        server: {
+            idField: runtime?.server?.idField,
+            schemaHash: runtime?.server?.schemaHash,
+        },
+    });
+    const bindingsPatch = hasBindings
+        ? normalizeBindings(normalized.bindings) || {}
+        : undefined;
+    const diff = deriveBindingsDiff(bindingsPatch, runtime?.currentBindings);
+    return {
+        canonicalConfig: toCanonicalTableConfig(normalized, {
+            hasLocalDataInput: runtime?.hasLocalDataInput,
+            localDataModeDefaultEnabled: runtime?.localDataModeDefaultEnabled,
+        }),
+        bindingsPatch,
+        persistence: {
+            saveConfig: options?.saveConfig === true,
+            saveBindings: options?.saveBindings === true,
+        },
+        runtime: deriveRuntimePlan(bindingsPatch, diff),
+        metadata: {
+            attachServerMeta: options?.attachServerMeta === true,
+        },
+        diff,
+        diagnostics,
+    };
+}
+function serializeTableAuthoringDocument(doc) {
+    const normalized = normalizeTableAuthoringDocument(doc);
+    return stripUndefinedDeep({
+        kind: DOCUMENT_KIND,
+        version: DOCUMENT_VERSION,
+        config: normalized.config,
+        bindings: normalized.bindings,
+    });
+}
+function normalizeTableConfig(config) {
+    const normalized = cloneJson(projectTableActionAuthoring(config || { columns: [] }));
+    if (!Array.isArray(normalized.columns)) {
+        normalized.columns = [];
+    }
+    if (normalized.behavior && typeof normalized.behavior === 'object') {
+        Object.keys(normalized.behavior).forEach((key) => {
+            const value = normalized.behavior[key];
+            if (value &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                Object.keys(value).length === 0) {
+                delete normalized.behavior[key];
+            }
+        });
+        if (Object.keys(normalized.behavior).length === 0) {
+            delete normalized.behavior;
+        }
+    }
+    const settings = normalized.behavior?.filtering?.advancedFilters?.settings;
+    if (settings && typeof settings === 'object' && !Array.isArray(settings)) {
+        Object.keys(settings).forEach((key) => {
+            if (settings[key] === undefined || settings[key] === null || settings[key] === '') {
+                delete settings[key];
+            }
+        });
+    }
+    return normalized;
+}
+function ensureAuthoringCompleteness(config) {
+    const next = cloneJson(config);
+    const advanced = next.behavior?.filtering?.advancedFilters;
+    if (advanced &&
+        typeof advanced === 'object' &&
+        !Object.prototype.hasOwnProperty.call(advanced, 'settings')) {
+        advanced.settings = {};
+    }
+    return next;
+}
+function normalizeBindings(bindings) {
+    if (!bindings || typeof bindings !== 'object')
+        return undefined;
+    const normalized = {
+        resourcePath: normalizeResourcePath(bindings.resourcePath),
+        horizontalScroll: normalizeHorizontalScroll(bindings.horizontalScroll),
+    };
+    return stripUndefinedShallow(normalized);
+}
+function resolveEffectiveDataMode(doc, context) {
+    const resourcePath = trimString(doc.bindings?.resourcePath);
+    if (resourcePath)
+        return 'remote';
+    const localModeFlag = readBoolean(doc.config?.behavior?.localDataMode?.enabled);
+    const effectiveLocalFlag = localModeFlag ?? (context?.localDataModeDefaultEnabled === true);
+    if (context?.hasLocalDataInput && effectiveLocalFlag) {
+        return 'local';
+    }
+    return 'empty';
+}
+function deriveBindingsDiff(next, current) {
+    if (next === undefined) {
+        return {
+            resourcePathChanged: false,
+            horizontalScrollChanged: false,
+            requiresDataRefresh: false,
+        };
+    }
+    const normalizedNext = normalizeBindings(next) || {};
+    const normalizedCurrent = normalizeBindings(current) || {};
+    const resourcePathChanged = normalizeResourcePath(normalizedNext.resourcePath) !==
+        normalizeResourcePath(normalizedCurrent.resourcePath);
+    const horizontalScrollChanged = normalizeHorizontalScroll(normalizedNext.horizontalScroll) !==
+        normalizeHorizontalScroll(normalizedCurrent.horizontalScroll);
+    return {
+        resourcePathChanged,
+        horizontalScrollChanged,
+        requiresDataRefresh: resourcePathChanged,
+    };
+}
+function deriveRuntimePlan(bindings, diff) {
+    if (bindings === undefined) {
+        return {
+            reconnectDataSource: false,
+            reloadSchema: false,
+            fetchData: false,
+            refreshLocalView: false,
+        };
+    }
+    const resourcePath = trimString(bindings?.resourcePath);
+    if (resourcePath) {
+        return {
+            reconnectDataSource: !!diff?.resourcePathChanged,
+            reloadSchema: !!diff?.resourcePathChanged,
+            fetchData: !!diff?.requiresDataRefresh,
+            refreshLocalView: false,
+        };
+    }
+    return {
+        reconnectDataSource: !!diff?.resourcePathChanged,
+        reloadSchema: false,
+        fetchData: false,
+        refreshLocalView: true,
+    };
+}
+function extractLegacyTableConfig(obj) {
+    const clone = { ...obj };
+    delete clone.__resourcePath__;
+    delete clone.__resourcePathIntent__;
+    delete clone.__idField__;
+    delete clone.__horizontalScroll__;
+    return asTableConfig(clone);
+}
+function stripLegacyRuntimeMarkers(config) {
+    const clone = cloneJson(config);
+    delete clone.__resourcePath__;
+    delete clone.__resourcePathIntent__;
+    delete clone.__idField__;
+    delete clone.__horizontalScroll__;
+    return clone;
+}
+function looksLikeLegacyPayload(obj) {
+    return ('__resourcePath__' in obj ||
+        '__resourcePathIntent__' in obj ||
+        '__idField__' in obj ||
+        '__horizontalScroll__' in obj);
+}
+function asTableConfig(value) {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    return { columns: [] };
+}
+function asRecord(value) {
+    return value && typeof value === 'object'
+        ? value
+        : {};
+}
+function hasOwnProperty(value, key) {
+    return !!value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeResourcePath(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = trimString(value);
+    return trimmed || null;
+}
+function normalizeIdField(value) {
+    const trimmed = trimString(value);
+    return trimmed || undefined;
+}
+function normalizeHorizontalScroll(value) {
+    const candidate = trimString(value);
+    if (!candidate)
+        return undefined;
+    return HORIZONTAL_SCROLL_VALUES.includes(candidate) ? candidate : undefined;
+}
+function trimString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function readBoolean(value) {
+    if (value === true || value === false)
+        return value;
+    return undefined;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function stripUndefinedShallow(value) {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    if (!entries.length)
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function stripUndefinedDeep(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function errorDiagnostic(code, message, path) {
+    return { level: 'error', code, message, path };
+}
+function warnDiagnostic(code, message, path) {
+    return { level: 'warning', code, message, path };
+}
+function infoDiagnostic(code, message, path) {
+    return { level: 'info', code, message, path };
+}
+
+/**
+ * Internal canonical schema-to-column projection shared by runtime and authoring.
+ * Receives already-admitted fields and intent; does not normalize untrusted schema,
+ * recover historical evidence, execute user actions or attest provenance.
+ * No component instance, dependency injection or network request is required.
+ * Not part of the root public API.
+ */
+class TableSchemaColumnProjector {
+    convertFieldToColumn(field) {
+        const apiType = resolveColumnTypeFromFieldDefinition(field, this.inferFieldTypeFromFieldName(field.name));
+        const col = {
+            field: field.name,
+            header: field.label ?? field.name,
+            order: field.order,
+            width: field.width ?? undefined,
+            sortable: field.sortable,
+            visible: field.tableHidden || field.hidden ? false : true,
+            type: apiType,
+            _originalApiType: apiType,
+            _isApiField: true,
+        };
+        this.applySchemaFieldPresentation(field, col);
+        // Auto-renderers: map known UI controls to richer cell renderers on first bootstrap
+        // - Avatar: when backend marks controlType 'avatar' (x-ui) or field name matches avatar-like patterns
+        try {
+            this.applyAutoRenderer(field, col);
+        }
+        catch { }
+        return col;
+    }
+    projectSchemaColumns(fields, projection) {
+        const overrides = projection?.overrides ?? {};
+        const include = Array.isArray(projection?.include)
+            ? projection.include
+                .map((field) => String(field || '').trim())
+                .filter((field, index, values) => !!field && values.indexOf(field) === index)
+            : [];
+        const includeOrder = new Map(include.map((field, index) => [field, index]));
+        const order = Array.isArray(projection?.order) ? projection.order : include;
+        const presentationOrder = new Map(order.map((field, index) => [field, index]));
+        const schemaColumns = (Array.isArray(fields) ? fields : [])
+            .filter((field) => !field.tableHidden && !field.hidden)
+            .filter((field) => include.length === 0 || includeOrder.has(field.name))
+            .sort((left, right) => {
+            return (presentationOrder.get(left.name) ?? Number.MAX_SAFE_INTEGER)
+                - (presentationOrder.get(right.name) ?? Number.MAX_SAFE_INTEGER);
+        })
+            .map((field) => {
+            const base = this.convertFieldToColumn(field);
+            const override = overrides[field.name];
+            if (!override || typeof override !== 'object' || Array.isArray(override)) {
+                return base;
+            }
+            const merged = deepMerge(base, override);
+            return {
+                ...merged,
+                field: base.field,
+                _isApiField: base._isApiField,
+                _originalApiType: base._originalApiType,
+            };
+        });
+        const canonicalFields = new Set((Array.isArray(fields) ? fields : [])
+            .map((field) => String(field?.name || '').trim())
+            .filter(Boolean));
+        const additions = Array.isArray(projection?.additions)
+            ? projection.additions
+                .filter((column) => {
+                const field = String(column?.field || '').trim();
+                return !!field && !canonicalFields.has(field);
+            })
+                .map((column) => this.toPortableColumnDefinition(column))
+            : [];
+        // Presentation priority must also survive setupColumns' numeric ordering.
+        // It never admits hidden fields, overrides field identity, or selects membership.
+        const combined = [...schemaColumns, ...additions];
+        if (Array.isArray(projection?.order) && projection.order.length > 0) {
+            const additionFields = new Set(additions.map((col) => col.field));
+            combined.sort((left, right) => {
+                return (presentationOrder.get(left.field) ?? Number.MAX_SAFE_INTEGER)
+                    - (presentationOrder.get(right.field) ?? Number.MAX_SAFE_INTEGER);
+            });
+            return combined.map((column, index) => {
+                if (!additionFields.has(column.field) || presentationOrder.has(column.field)) {
+                    return { ...column, order: index };
+                }
+                return column;
+            });
+        }
+        return combined;
+    }
+    inferFieldTypeFromFieldName(fieldName) {
+        const lowercaseName = fieldName.toLowerCase();
+        // Date/time patterns - more specific patterns first (EN + PT-BR)
+        if (lowercaseName.endsWith('date') ||
+            lowercaseName.endsWith('time') ||
+            lowercaseName.endsWith('at') ||
+            lowercaseName.startsWith('date') ||
+            lowercaseName.startsWith('data') ||
+            lowercaseName.startsWith('dt_') ||
+            lowercaseName.startsWith('dt') ||
+            lowercaseName.endsWith('_em') ||
+            lowercaseName === 'created' ||
+            lowercaseName === 'updated' ||
+            lowercaseName === 'modified' ||
+            lowercaseName === 'nascimento' ||
+            lowercaseName === 'admissao' ||
+            lowercaseName === 'demissao' ||
+            lowercaseName === 'vencimento' ||
+            lowercaseName.includes('timestamp')) {
+            return 'date';
+        }
+        // Boolean patterns - most specific first to avoid conflicts (EN + PT-BR)
+        if (lowercaseName.startsWith('is_') ||
+            lowercaseName.startsWith('has_') ||
+            lowercaseName.startsWith('can_') ||
+            lowercaseName.startsWith('should_') ||
+            lowercaseName.startsWith('fl_') ||
+            lowercaseName.startsWith('ind_') ||
+            lowercaseName === 'active' ||
+            lowercaseName === 'ativo' ||
+            lowercaseName === 'inativo' ||
+            lowercaseName === 'enabled' ||
+            lowercaseName === 'habilitado' ||
+            lowercaseName === 'visible' ||
+            lowercaseName === 'visivel' ||
+            lowercaseName === 'deleted' ||
+            lowercaseName === 'excluido' ||
+            lowercaseName === 'archived' ||
+            lowercaseName === 'arquivado' ||
+            lowercaseName.endsWith('_flag') ||
+            lowercaseName.endsWith('_enabled') ||
+            lowercaseName.endsWith('_active') ||
+            lowercaseName.endsWith('_ativo')) {
+            return 'boolean';
+        }
+        // Currency/money patterns - exclude common false positives (EN + PT-BR)
+        if ((lowercaseName.includes('price') ||
+            lowercaseName.includes('preco') ||
+            lowercaseName.includes('amount') ||
+            lowercaseName.includes('cost') ||
+            lowercaseName.includes('custo') ||
+            lowercaseName.includes('salary') ||
+            lowercaseName.includes('salario') ||
+            lowercaseName.includes('remuneracao') ||
+            lowercaseName.includes('orcamento') ||
+            lowercaseName.includes('indenizacao') ||
+            lowercaseName.includes('multa') ||
+            lowercaseName.includes('desconto') ||
+            lowercaseName.includes('liquido') ||
+            lowercaseName.includes('bruto') ||
+            lowercaseName.includes('wage') ||
+            lowercaseName.includes('fee') ||
+            ((lowercaseName.includes('value') || lowercaseName.includes('valor') || lowercaseName.startsWith('vl_')) &&
+                !lowercaseName.includes('id') &&
+                !lowercaseName.includes('key'))) &&
+            !lowercaseName.includes('count') &&
+            !lowercaseName.includes('type') &&
+            !lowercaseName.includes('tipo')) {
+            return 'currency';
+        }
+        // Percentage patterns - be more specific (EN + PT-BR)
+        if (lowercaseName.includes('percent') ||
+            lowercaseName.includes('percentual') ||
+            lowercaseName.includes('aliquota') ||
+            lowercaseName.includes('margem') ||
+            lowercaseName.startsWith('pct_') ||
+            lowercaseName.endsWith('_rate') ||
+            lowercaseName.endsWith('_ratio') ||
+            lowercaseName.endsWith('_pct') ||
+            lowercaseName.endsWith('_taxa') ||
+            ((lowercaseName.includes('rate') || lowercaseName.includes('taxa')) &&
+                !lowercaseName.includes('created') &&
+                !lowercaseName.includes('updated')) ||
+            lowercaseName.endsWith('_score')) {
+            return 'percentage';
+        }
+        // Number patterns - exclude common false positives like string IDs (EN + PT-BR)
+        if ((lowercaseName.endsWith('_id') && lowercaseName !== 'id') || // composite IDs might be strings
+            lowercaseName === 'id' ||
+            lowercaseName.includes('count') ||
+            lowercaseName.includes('quantity') ||
+            lowercaseName.includes('quantidade') ||
+            lowercaseName.includes('qtd') ||
+            lowercaseName.includes('number') ||
+            lowercaseName.includes('numero') ||
+            lowercaseName.includes('total') ||
+            lowercaseName.includes('sum') ||
+            lowercaseName.includes('soma') ||
+            lowercaseName.includes('age') ||
+            lowercaseName.includes('idade') ||
+            lowercaseName.includes('weight') ||
+            lowercaseName.includes('peso') ||
+            lowercaseName.includes('height') ||
+            lowercaseName.includes('altura') ||
+            lowercaseName.includes('size') ||
+            lowercaseName.includes('tamanho') ||
+            lowercaseName.includes('pontuacao') ||
+            lowercaseName.includes('score') ||
+            lowercaseName.includes('nota') ||
+            lowercaseName.endsWith('_num') ||
+            lowercaseName.endsWith('_number')) {
+            return 'number';
+        }
+        // Default to string for ambiguous cases
+        return 'string';
+    }
+    applySchemaFieldPresentation(field, col) {
+        if (!field || !col)
+            return;
+        const controlType = this.normalizePresentationToken(field.controlType);
+        const numericFormat = this.normalizePresentationToken(field.numericFormat ?? field.format);
+        const valuePresentationType = this.normalizePresentationToken(field.valuePresentation?.type);
+        const displayFormat = this.firstNonEmptyString(field.displayFormat, field.extraProperties?.displayFormat);
+        const valueMapping = this.resolveSchemaValueMapping(field);
+        if (valueMapping && (!col.valueMapping || Object.keys(col.valueMapping).length === 0)) {
+            col.valueMapping = valueMapping;
+        }
+        const presentation = field.presentation;
+        if (presentation?.presenter === 'microVisualization' &&
+            isPraxisPresentationVisualizationTableSafe(presentation?.visualization) &&
+            !col.renderer?.type) {
+            col.renderer = {
+                ...(col.renderer || {}),
+                type: 'microVisualization',
+                microVisualization: {
+                    visualization: presentation.visualization,
+                },
+            };
+        }
+        this.applySchemaSemanticCellPresentation(field, col, presentation);
+        if (numericFormat === 'currency' || controlType === 'currency' || col.type === 'currency') {
+            const wasCurrency = col.type === 'currency';
+            col.type = 'currency';
+            if (!col.format || (!wasCurrency && !String(col.format).includes('|'))) {
+                col.format = this.resolveSchemaCurrencyFormat(field);
+            }
+            return;
+        }
+        if (numericFormat === 'date' ||
+            numericFormat === 'datetime' ||
+            valuePresentationType === 'date' ||
+            valuePresentationType === 'datetime' ||
+            controlType === 'datepicker' ||
+            controlType === 'datetimepicker' ||
+            controlType === 'datetimelocal' ||
+            controlType === 'date' ||
+            controlType === 'datetime') {
+            col.type = 'date';
+            if (!col.format) {
+                col.format = displayFormat || (numericFormat === 'datetime' ||
+                    valuePresentationType === 'datetime' ||
+                    controlType === 'datetimepicker' ||
+                    controlType === 'datetimelocal' ||
+                    controlType === 'datetime'
+                    ? 'dd/MM/yyyy HH:mm'
+                    : 'dd/MM/yyyy');
+            }
+            return;
+        }
+        if (col.type === 'boolean' && !col.format) {
+            col.format = this.resolveSchemaBooleanFormat(field);
+        }
+        const schemaDataType = this.normalizePresentationToken(field.type);
+        const schemaFormat = this.normalizePresentationToken(field.format);
+        if (col.type === 'number' && !col.format) {
+            if (displayFormat) {
+                col.format = displayFormat;
+            }
+            else if (schemaDataType === 'integer' ||
+                schemaFormat === 'integer' ||
+                schemaFormat === 'int32' ||
+                schemaFormat === 'int64' ||
+                numericFormat === 'integer' ||
+                numericFormat === 'int32' ||
+                numericFormat === 'int64') {
+                col.format = '1.0-0';
+            }
+            else {
+                const explicitDecimals = this.firstFiniteNumber(field.decimalPlaces, field.extraProperties?.decimalPlaces);
+                if (explicitDecimals !== undefined && explicitDecimals >= 0) {
+                    const decimals = Math.trunc(explicitDecimals);
+                    col.format = `1.${decimals}-${decimals}`;
+                }
+            }
+        }
+        const textMaskFormat = resolveTextMaskFormatFromFieldDefinition(field);
+        const maskResolvedType = resolveColumnTypeFromFieldDefinition(field, col.type);
+        if (textMaskFormat && maskResolvedType === 'string') {
+            col.type = 'string';
+            col.format = textMaskFormat;
+        }
+    }
+    applyAutoRenderer(field, col) {
+        if (!field || !col)
+            return;
+        // Do not override explicit renderer if any (defensive; initial columns have none)
+        if (col.renderer && col.renderer.type)
+            return;
+        const ctl = (field.controlType || '').toString().trim().toLowerCase();
+        const fname = (field.name || '').toString();
+        const isAvatarByControl = ctl === 'avatar';
+        if (isAvatarByControl) {
+            const initialsField = this.firstNonEmptyString(field.initialsField, field.extraProperties?.initialsField) || 'nomeCompleto';
+            col.renderer = {
+                type: 'avatar',
+                avatar: {
+                    srcField: fname,
+                    initialsField,
+                    shape: 'circle',
+                    size: 32,
+                },
+            };
+            // Sensible defaults for avatar column (84px prevents header truncation when centered with sort/resize gutters; not sortable by default)
+            col.align = col.align || 'center';
+            if (col.sortable === undefined)
+                col.sortable = false;
+            if (!col.width)
+                col.width = '84px';
+            return;
+        }
+    }
+    toPortableColumnDefinition(column) {
+        const cloned = this.clonePlainObject(column);
+        delete cloned['_isApiField'];
+        delete cloned['_originalApiType'];
+        return cloned;
+    }
+    normalizePresentationToken(value) {
+        return String(value ?? '')
+            .trim()
+            .toLowerCase()
+            .replace(/[_\-\s]/g, '');
+    }
+    firstNonEmptyString(...values) {
+        for (const value of values) {
+            if (typeof value !== 'string')
+                continue;
+            const trimmed = value.trim();
+            if (trimmed)
+                return trimmed;
+        }
+        return undefined;
+    }
+    resolveSchemaValueMapping(field) {
+        const explicit = field.valueMapping;
+        if (explicit && typeof explicit === 'object' && !Array.isArray(explicit)) {
+            const normalized = Object.entries(explicit).reduce((acc, [key, value]) => {
+                if (key && typeof value === 'string' && value.trim()) {
+                    acc[key] = value.trim();
+                }
+                return acc;
+            }, {});
+            if (Object.keys(normalized).length)
+                return normalized;
+        }
+        const optionMapping = this.resolveSchemaOptionsValueMapping(field);
+        if (optionMapping)
+            return optionMapping;
+        const enumValues = this.normalizeEnumValues(field.enumValues) || [];
+        if (enumValues.length) {
+            return enumValues.reduce((acc, value) => {
+                acc[value] = this.humanizeSchemaEnumValue(value);
+                return acc;
+            }, {});
+        }
+        return undefined;
+    }
+    applySchemaSemanticCellPresentation(field, col, presentation) {
+        if (!presentation || typeof presentation !== 'object')
+            return;
+        if (col.renderer?.type)
+            return;
+        const presenter = this.normalizePresentationToken(presentation.presenter ?? presentation.variant);
+        const textField = field.name;
+        const color = this.resolveSemanticPresentationColor(presentation.tone);
+        const variant = this.resolveSemanticPresentationVariant(presentation.appearance);
+        const icon = this.firstNonEmptyString(presentation.icon);
+        const tooltipText = this.firstNonEmptyString(presentation.tooltip);
+        const tooltip = tooltipText ? { text: tooltipText } : undefined;
+        const fixedText = this.firstNonEmptyString(presentation.label);
+        if (presenter === 'chip') {
+            col.renderer = {
+                type: 'chip',
+                chip: {
+                    text: fixedText,
+                    textField: fixedText ? undefined : textField,
+                    color,
+                    icon,
+                    variant,
+                    tooltip,
+                },
+            };
+            return;
+        }
+        if (presenter === 'badge' || presenter === 'status') {
+            col.renderer = {
+                type: 'badge',
+                badge: {
+                    text: fixedText,
+                    textField: fixedText ? undefined : textField,
+                    color,
+                    icon,
+                    variant,
+                    tooltip,
+                },
+            };
+            return;
+        }
+        if (presenter === 'iconvalue') {
+            const rendererIcon = icon || this.firstNonEmptyString(field.icon);
+            const affixes = this.resolveSemanticPresentationAffixes(presentation);
+            const hasAffixes = !!(affixes.prefix || affixes.suffix);
+            if (!rendererIcon && !hasAffixes)
+                return;
+            if (affixes.prefix || affixes.suffix || tooltipText) {
+                col.renderer = {
+                    type: 'icon',
+                    icon: {
+                        ...(!hasAffixes && rendererIcon ? { name: rendererIcon } : {}),
+                        textField,
+                        ...(tooltipText ? { ariaLabel: tooltipText } : {}),
+                        ...affixes,
+                    },
+                };
+                return;
+            }
+            if (!rendererIcon)
+                return;
+            col.renderer = {
+                type: 'compose',
+                compose: {
+                    items: [
+                        {
+                            type: 'icon',
+                            icon: {
+                                name: rendererIcon,
+                                ...(color ? { color } : {}),
+                                ...(field.label ? { ariaLabel: field.label } : {}),
+                            },
+                        },
+                        {
+                            type: 'value',
+                            field: textField,
+                        },
+                    ],
+                    layout: {
+                        direction: 'row',
+                        gap: 6,
+                        align: 'center',
+                    },
+                },
+            };
+        }
+    }
+    resolveSchemaCurrencyFormat(field) {
+        const currency = this.firstNonEmptyString(field.currency, field.extraProperties?.currency) || 'BRL';
+        const decimalPlaces = this.firstFiniteNumber(field.decimalPlaces, field.extraProperties?.decimalPlaces) ?? 2;
+        return `${currency}|symbol|${decimalPlaces}`;
+    }
+    resolveSchemaBooleanFormat(field) {
+        const explicit = this.firstNonEmptyString(field.booleanFormat, field.extraProperties?.booleanFormat);
+        if (explicit)
+            return explicit;
+        const trueLabel = this.firstNonEmptyString(field.trueLabel, field.labelTrue, field.extraProperties?.trueLabel, field.extraProperties?.labelTrue);
+        const falseLabel = this.firstNonEmptyString(field.falseLabel, field.labelFalse, field.extraProperties?.falseLabel, field.extraProperties?.labelFalse);
+        if (trueLabel && falseLabel) {
+            const tNorm = this.normalizePresentationToken(trueLabel);
+            const fNorm = this.normalizePresentationToken(falseLabel);
+            if (tNorm === 'ativo' && fNorm === 'inativo')
+                return 'active-inactive';
+            if (tNorm === 'sim' && (fNorm === 'nao' || fNorm === 'não'))
+                return 'yes-no';
+            return `custom|${trueLabel}|${falseLabel}`;
+        }
+        const name = this.normalizePresentationToken(field.name);
+        if (name === 'ativo' || name === 'active' || name.endsWith('ativo')) {
+            return 'active-inactive';
+        }
+        return 'true-false';
+    }
+    clonePlainObject(value) {
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return value;
+        }
+    }
+    resolveSchemaOptionsValueMapping(field) {
+        const options = this.normalizeSchemaOptions(field.options) || [];
+        if (!options.length)
+            return undefined;
+        const valueKey = this.normalizeSchemaKey(field.optionValueKey) || 'key';
+        const labelKey = this.normalizeSchemaKey(field.optionLabelKey) || 'value';
+        const mapping = options.reduce((acc, option) => {
+            if (!option || typeof option !== 'object')
+                return acc;
+            const value = option[valueKey]
+                ?? option.key
+                ?? option.id
+                ?? option.value;
+            const label = option[labelKey]
+                ?? option.label
+                ?? option.value
+                ?? option.name;
+            if (value !== undefined && value !== null && label !== undefined && label !== null) {
+                acc[String(value)] = String(label);
+            }
+            return acc;
+        }, {});
+        return Object.keys(mapping).length ? mapping : undefined;
+    }
+    normalizeEnumValues(values) {
+        if (!Array.isArray(values) || values.length === 0)
+            return undefined;
+        const normalized = values
+            .map((value) => (value != null ? String(value).trim() : ''))
+            .filter((value) => value.length > 0);
+        return normalized.length ? Array.from(new Set(normalized)) : undefined;
+    }
+    humanizeSchemaEnumValue(value) {
+        return value
+            .toLowerCase()
+            .split(/[_\-\s]+/)
+            .filter(Boolean)
+            .map((part, index) => index === 0 ? this.capitalizeSchemaEnumPart(part) : part)
+            .join(' ');
+    }
+    resolveSemanticPresentationColor(tone) {
+        const normalized = this.normalizePresentationToken(tone);
+        if (normalized === 'neutral')
+            return 'basic';
+        if (!normalized)
+            return undefined;
+        if (normalized === 'danger')
+            return 'warn';
+        if (normalized === 'warning')
+            return 'warn';
+        return normalized;
+    }
+    resolveSemanticPresentationVariant(appearance) {
+        const normalized = this.normalizePresentationToken(appearance);
+        if (normalized === 'filled' || normalized === 'outlined' || normalized === 'soft' || normalized === 'plain') {
+            return normalized;
+        }
+        return undefined;
+    }
+    resolveSemanticPresentationAffixes(presentation) {
+        const prefix = this.firstNonEmptyString(presentation.prefix);
+        const suffix = this.firstNonEmptyString(presentation.suffix);
+        return {
+            ...(prefix ? { prefix } : {}),
+            ...(suffix ? { suffix } : {}),
+        };
+    }
+    firstFiniteNumber(...values) {
+        for (const value of values) {
+            const numeric = typeof value === 'number' ? value : Number(value);
+            if (Number.isFinite(numeric))
+                return numeric;
+        }
+        return undefined;
+    }
+    normalizeSchemaOptions(options) {
+        if (!Array.isArray(options) || options.length === 0)
+            return undefined;
+        const normalized = options
+            .map((option) => {
+            if (option == null)
+                return null;
+            if (typeof option === 'string') {
+                const text = option.trim();
+                if (!text)
+                    return null;
+                return text;
+            }
+            if (typeof option === 'number') {
+                return Number.isFinite(option) ? option : null;
+            }
+            if (typeof option === 'boolean') {
+                return option;
+            }
+            if (typeof option === 'object') {
+                const candidate = option;
+                const hasKey = Object.prototype.hasOwnProperty.call(candidate, 'key');
+                const hasValue = Object.prototype.hasOwnProperty.call(candidate, 'value');
+                if (hasKey || hasValue) {
+                    const rawKey = candidate['key'] ?? candidate['value'];
+                    const rawValue = candidate['value'] ?? candidate['key'];
+                    const key = rawKey != null ? String(rawKey).trim() : '';
+                    const value = rawValue != null ? String(rawValue).trim() : '';
+                    if (!key && !value)
+                        return null;
+                    return { ...candidate, key: key || value, value: value || key };
+                }
+                return candidate;
+            }
+            return null;
+        })
+            .filter((option) => option !== null);
+        return normalized.length ? normalized : undefined;
+    }
+    normalizeSchemaKey(value) {
+        const text = value != null ? String(value).trim() : '';
+        return text.length > 0 ? text : undefined;
+    }
+    capitalizeSchemaEnumPart(value) {
+        return value ? `${value.charAt(0).toUpperCase()}${value.slice(1)}` : value;
+    }
+}
+const tableSchemaColumnProjector = new TableSchemaColumnProjector();
+
+/** Same JSON boundary and projection used when opening the native Table editor.
+ * Empty fields preserve native columns, including the disconnected editor case.
+ */
+function materializeTableEditorConfig(config, fields) {
+    const materialized = { ...config };
+    if (config.columnProjection?.source === 'schema' && fields.length > 0) {
+        materialized.columns = tableSchemaColumnProjector.projectSchemaColumns(fields, config.columnProjection);
+    }
+    return JSON.parse(JSON.stringify(materialized));
+}
+/** Full native document: canonical defaults/action normalization are owned by
+ * createTableAuthoringDocument. This is not a public host executor or attestation.
+ */
+function deriveTableEditorDocument(input) {
+    return createTableAuthoringDocument({
+        config: materializeTableEditorConfig(input.config, input.fields),
+        bindings: input.bindings,
+    });
+}
+
+/** Shared presentation ordering; hidden columns must not shift visible fallback positions. */
+function orderTableColumns(columns) {
+    if (!columns.some(column => Number.isFinite(column.order)))
+        return [...columns];
+    let visibleIndex = 0;
+    return columns.map((column, originalIndex) => {
+        const fallback = column.visible === false ? originalIndex : visibleIndex++;
+        return { column, originalIndex, explicit: Number.isFinite(column.order), order: Number.isFinite(column.order) ? Number(column.order) : fallback };
+    }).sort((left, right) => left.order - right.order
+        || Number(right.explicit) - Number(left.explicit)
+        || left.originalIndex - right.originalIndex).map(entry => entry.column);
+}
+
+/** Preserve authored values; runtime/schema defaults remain transient unless explicitly edited. */
+function applyTableAuthoringChanges(authored, baseline, edited) {
+    return projectChanges(authored, baseline, edited, true);
+}
+function projectChanges(authored, baseline, edited, tableConfigRoot) {
+    if (sameAuthoringValue(baseline, edited))
+        return authored;
+    if (!edited || typeof edited !== 'object' || Array.isArray(edited))
+        return edited;
+    const original = authored && typeof authored === 'object' ? authored : {};
+    const before = baseline && typeof baseline === 'object' ? baseline : {};
+    const after = edited;
+    const result = { ...original };
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+        if (sameAuthoringValue(before[key], after[key]))
+            continue;
+        if (!Object.hasOwn(after, key))
+            delete result[key];
+        else
+            Object.defineProperty(result, key, {
+                value: projectChanges(Object.hasOwn(original, key) ? original[key] : undefined, Object.hasOwn(before, key) ? before[key] : undefined, after[key], false),
+                enumerable: true, configurable: true, writable: true,
+            });
+    }
+    if (tableConfigRoot && isRecord(original['columnProjection']) && original['columnProjection']['source'] === 'schema'
+        && isRecord(result['columnProjection']) && result['columnProjection']['source'] === 'schema'
+        && Array.isArray(after['columns']) && JSON.stringify(before['columns']) !== JSON.stringify(after['columns'])) {
+        result['columns'] = [];
+        result['columnProjection'] = projectSchemaColumnChanges(result['columnProjection'], before['columns'], after['columns'], isRecord(before['columnProjection']) ? before['columnProjection'] : original['columnProjection'], after['columnProjection']);
+    }
+    return result;
+}
+/** Write the existing compact schema projection, never a partial columns snapshot. */
+function projectSchemaColumnChanges(authored, baseline, edited, baselineProjection, editedProjection) {
+    if (!isRecord(authored) || authored['source'] !== 'schema') {
+        throw new Error('Table schema authorship requires its canonical columnProjection.');
+    }
+    const projection = structuredClone(authored);
+    const overrides = Object.assign(Object.create(null), isRecord(projection['overrides']) ? projection['overrides'] : {});
+    const additions = columnsByField(Array.isArray(projection['additions']) ? projection['additions'] : []);
+    const before = columnsByField(Array.isArray(baseline) ? baseline : []);
+    const after = columnsByField(edited);
+    const nextAdditions = [...additions].filter(([field]) => !before.has(field) && !after.has(field))
+        .map(([, column]) => structuredClone(column));
+    for (const [field, column] of after) {
+        if (additions.has(field) || !before.has(field)) {
+            nextAdditions.push(structuredClone(column));
+            continue;
+        }
+        const previousOverride = isRecord(overrides[field]) ? overrides[field] : {};
+        if (Object.hasOwn(previousOverride, 'field')) {
+            throw new Error('Table schema overrides cannot replace canonical field identity.');
+        }
+        const projected = projectChanges({ field, ...previousOverride }, before.get(field), column, false);
+        const override = isRecord(projected) ? { ...projected } : {};
+        // A direct edit of native intent is stronger evidence than a rematerialized snapshot.
+        const baselineOverrides = isRecord(baselineProjection) && isRecord(baselineProjection['overrides'])
+            ? baselineProjection['overrides'] : {};
+        const editedOverrides = isRecord(editedProjection) && isRecord(editedProjection['overrides'])
+            ? editedProjection['overrides'] : {};
+        const oldIntent = isRecord(baselineOverrides[field]) ? baselineOverrides[field] : {};
+        const newIntent = isRecord(editedOverrides[field]) ? editedOverrides[field] : {};
+        if (isRecord(editedProjection)) {
+            for (const key of new Set([...Object.keys(oldIntent), ...Object.keys(newIntent)])) {
+                if (!changedNativeValue(oldIntent, newIntent, key))
+                    continue;
+                if (Object.hasOwn(previousOverride, key))
+                    override[key] = structuredClone(previousOverride[key]);
+                else
+                    delete override[key];
+            }
+        }
+        delete override['field'];
+        delete override['order']; // Ordering has a dedicated projection field.
+        if (Object.keys(override).length)
+            overrides[field] = override;
+        else
+            delete overrides[field];
+    }
+    // Missing fields do not erase their overrides; membership and intent are separate.
+    const previousOrder = orderedFields(before, additions);
+    const nextOrder = orderedFields(after, additions).filter(field => before.has(field));
+    if (!changedNativeValue(baselineProjection, editedProjection, 'include')
+        && previousOrder.some(field => !nextOrder.includes(field))) {
+        const include = Array.isArray(projection['include']) ? projection['include'] : [];
+        projection['include'] = [...nextOrder, ...include.filter(field => !before.has(field))];
+    }
+    if (!changedNativeValue(baselineProjection, editedProjection, 'order')
+        && JSON.stringify(previousOrder) !== JSON.stringify(nextOrder)) {
+        const order = Array.isArray(projection['order']) ? projection['order'] : [];
+        projection['order'] = [...nextOrder, ...order.filter(field => !before.has(field) && !nextOrder.includes(field))];
+    }
+    if (Object.keys(overrides).length)
+        projection['overrides'] = overrides;
+    else
+        delete projection['overrides'];
+    if (nextAdditions.length)
+        projection['additions'] = nextAdditions;
+    else
+        delete projection['additions'];
+    return projection;
+}
+function changedNativeValue(before, after, key) {
+    if (!isRecord(after))
+        return false;
+    const previous = isRecord(before) ? before : {};
+    return Object.hasOwn(previous, key) !== Object.hasOwn(after, key)
+        || !sameAuthoringValue(previous[key], after[key]);
+}
+function orderedFields(columns, additions) {
+    return orderTableColumns([...columns].map(([field, column]) => ({
+        field, order: typeof column['order'] === 'number' ? column['order'] : undefined,
+        visible: typeof column['visible'] === 'boolean' ? column['visible'] : undefined,
+    }))).map(column => column.field).filter(field => !additions.has(field));
+}
+function columnsByField(columns) {
+    const result = new Map();
+    for (const column of columns) {
+        if (!isRecord(column) || typeof column['field'] !== 'string' || !column['field'].trim()) {
+            throw new Error('Table authoring requires a non-empty column field identity.');
+        }
+        const identity = column['field'].trim();
+        if (result.has(identity))
+            throw new Error('Table authoring requires unique column field identities.');
+        result.set(identity, column);
+    }
+    return result;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Object insertion order is not authored intent; undefined is an internal absence sentinel. */
+function sameAuthoringValue(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    try {
+        return uiLayoutJsonIdentity(left) === uiLayoutJsonIdentity(right);
+    }
+    catch {
+        if (Array.isArray(left) || Array.isArray(right))
+            return Array.isArray(left) && Array.isArray(right)
+                && left.length === right.length && left.every((value, index) => sameAuthoringValue(value, right[index]));
+        if (!isRecord(left) || !isRecord(right))
+            return left === right;
+        const keys = Object.keys(left).filter(key => left[key] !== undefined);
+        const otherKeys = Object.keys(right).filter(key => right[key] !== undefined);
+        return keys.length === otherKeys.length && keys.every(key => Object.prototype.hasOwnProperty.call(right, key)
+            && sameAuthoringValue(left[key], right[key]));
+    }
+}
+
+const BINDINGS = ['resourcePath', 'horizontalScroll'];
+const INPUTS = ['config', ...BINDINGS];
+/** Raw compact schema authorship only; native normalization remains an editor/runtime projection. */
+function decodeTablePageInputs(value) {
+    let inputs;
+    try {
+        inputs = cloneBoundedUiLayoutJsonDocument(value);
+    }
+    catch {
+        return { document: null, diagnostics: [problem('table.page.json.invalid', '/definition/inputs')] };
+    }
+    const diagnostics = [];
+    extras(inputs, INPUTS, '/definition/inputs', diagnostics);
+    const config = inputs['config'];
+    if (!record(config) || !Array.isArray(config['columns']) || config['columns'].length !== 0
+        || !record(config['columnProjection']) || config['columnProjection']['source'] !== 'schema')
+        diagnostics.push(problem('table.page.config.schema-required', '/definition/inputs/config'));
+    if (record(config))
+        nulls(config, '/definition/inputs/config', diagnostics);
+    if (Object.prototype.hasOwnProperty.call(inputs, 'resourcePath') && inputs['resourcePath'] !== null && (typeof inputs['resourcePath'] !== 'string' || [...inputs['resourcePath']].length > 1024))
+        diagnostics.push(problem('table.page.resourcePath.invalid', '/definition/inputs/resourcePath'));
+    if (Object.prototype.hasOwnProperty.call(inputs, 'horizontalScroll') && !['auto', 'wrap', 'none'].includes(inputs['horizontalScroll']))
+        diagnostics.push(problem('table.page.horizontalScroll.invalid', '/definition/inputs/horizontalScroll'));
+    const bindings = Object.fromEntries(BINDINGS.filter(key => Object.prototype.hasOwnProperty.call(inputs, key)).map(key => [key, inputs[key]]));
+    const document = { kind: 'praxis.table.editor', version: 1, config, ...(Object.keys(bindings).length ? { bindings } : {}) };
+    if (!diagnostics.length) {
+        try {
+            diagnostics.push(...validateTableAuthoringDocument(document).filter(d => d.level === 'error').map(d => ({ ...d, path: nativePath(d.path) })));
+        }
+        catch {
+            diagnostics.push(problem('table.page.native.invalid', '/definition/inputs/config'));
+        }
+    }
+    if (!diagnostics.length) {
+        try {
+            cloneBoundedUiLayoutJsonDocument(document);
+        }
+        catch {
+            diagnostics.push(problem('table.page.json.invalid', '/definition/inputs'));
+        }
+    }
+    return { document: diagnostics.length ? null : document, diagnostics };
+}
+/** Core prefixes these widget-relative JSON Pointers; this callback never resolves a source/latest. */
+function validateTablePageWidget(widget) {
+    if (widget.definition.id !== 'praxis-table')
+        return [{ code: 'table.page.component.invalid', path: '/definition/id' }];
+    return decodeTablePageInputs(widget.definition.inputs).diagnostics.map(d => ({ code: d.code, path: d.path ?? '/definition/inputs' }));
+}
+function encodeTablePageInputs(value) {
+    let document;
+    try {
+        document = cloneBoundedUiLayoutJsonDocument(value);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.json.invalid', '/')] };
+    }
+    const diagnostics = [];
+    extras(document, ['kind', 'version', 'config', 'bindings'], '', diagnostics);
+    if (document['kind'] !== 'praxis.table.editor' || document['version'] !== 1)
+        diagnostics.push(problem('table.page.native.invalid', '/'));
+    const inputs = { config: document['config'] };
+    if (Object.prototype.hasOwnProperty.call(document, 'bindings')) {
+        const bindings = document['bindings'];
+        if (!record(bindings) || !Object.keys(bindings).length)
+            diagnostics.push(problem('table.page.envelope.unrepresentable', '/bindings'));
+        else {
+            extras(bindings, BINDINGS, '/bindings', diagnostics);
+            Object.assign(inputs, bindings);
+        }
+    }
+    const decoded = diagnostics.length ? null : decodeTablePageInputs(inputs);
+    return { inputs: diagnostics.length || decoded?.diagnostics.length ? null : inputs, diagnostics: [...diagnostics, ...(decoded?.diagnostics ?? [])] };
+}
+/** No-change values in a materialized native editor cannot author defaults or erase absent keys. */
+function projectTablePageEditorChanges(authoredInputs, editorBaseline, editorValue) {
+    const original = decodeTablePageInputs(authoredInputs);
+    if (!original.document)
+        return { inputs: null, diagnostics: original.diagnostics };
+    let baseline;
+    let edited;
+    try {
+        baseline = cloneBoundedUiLayoutJsonDocument(editorBaseline);
+        edited = cloneBoundedUiLayoutJsonDocument(editorValue);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.json.invalid', '/')] };
+    }
+    const authored = original.document;
+    // Native config delta has schema-column projection semantics; envelope delta is plain JSON.
+    let candidate;
+    try {
+        candidate = applyTableAuthoringChanges(authored, baseline, edited);
+        candidate['config'] = applyTableAuthoringChanges(authored['config'], baseline['config'], edited['config']);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.editor.invalid', '/definition/inputs/config')] };
+    }
+    const before = { ...authored };
+    const after = { ...candidate };
+    delete before['config'];
+    delete after['config'];
+    if (uiLayoutJsonIdentity(before) !== uiLayoutJsonIdentity(after))
+        return { inputs: null, diagnostics: [problem('table.page.seed.replacement-required', '/definition/inputs')] };
+    return encodeTablePageInputs(candidate);
+}
+function extras(source, allowed, path, diagnostics) {
+    for (const key of Object.keys(source))
+        if (!allowed.includes(key))
+            diagnostics.push(problem('table.page.profile.unsupported', path + '/' + pointer(key)));
+}
+function nulls(value, path, diagnostics) {
+    if (value === null)
+        diagnostics.push(problem('table.page.config.null', path));
+    else if (Array.isArray(value))
+        value.forEach((item, index) => nulls(item, path + '/' + index, diagnostics));
+    else if (record(value))
+        Object.entries(value).forEach(([key, item]) => nulls(item, path + '/' + pointer(key), diagnostics));
+}
+function pointer(key) { return key.replace(/~/g, '~0').replace(/\//g, '~1'); }
+function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
+function problem(code, path) { return { level: 'error', code, path, message: code }; }
+/** Derive execution-only identity and disable independent preferences. Never persist this projection. */
+function materializeTablePageRuntimeInputs(value, pageId, widgetKey, options) {
+    const decoded = decodeTablePageInputs(value);
+    if (!decoded.document)
+        return { inputs: null, diagnostics: decoded.diagnostics };
+    let id;
+    try {
+        id = derivePageChildRuntimeId(pageId, widgetKey);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.identity.invalid', '/key')] };
+    }
+    const cloned = cloneBoundedUiLayoutJsonDocument(value);
+    if (options?.preview && record(cloned['config'])) {
+        const previewConfig = { ...cloned['config'] };
+        if (record(previewConfig['actions'])) {
+            const actions = { ...previewConfig['actions'] };
+            if (record(actions['row'])) {
+                actions['row'] = {
+                    ...actions['row'],
+                    edit: false,
+                    delete: false,
+                    duplicate: false,
+                    custom: [],
+                };
+            }
+            if (record(actions['toolbar'])) {
+                actions['toolbar'] = {
+                    ...actions['toolbar'],
+                    add: false,
+                    create: false,
+                    delete: false,
+                    import: false,
+                    custom: [],
+                };
+            }
+            if (record(actions['bulk'])) {
+                actions['bulk'] = {
+                    ...actions['bulk'],
+                    enabled: false,
+                    actions: [],
+                };
+            }
+            previewConfig['actions'] = actions;
+        }
+        if (record(previewConfig['editing'])) {
+            previewConfig['editing'] = {
+                ...previewConfig['editing'],
+                enabled: false,
+            };
+        }
+        cloned['config'] = previewConfig;
+    }
+    return {
+        inputs: {
+            ...cloned,
+            tableId: id,
+            componentInstanceId: id,
+            configPersistenceStrategy: 'volatile',
+            enableCustomization: false,
+        },
+        diagnostics: [],
+    };
+}
+const TABLE_GOVERNED_PAGE_PREVIEW_ADAPTER = {
+    widgetDefinitionId: 'praxis-table',
+    certifiedForInteractivePreview: true,
+    validate: validateTablePageWidget,
+    materializePreviewInputs: (widget, pageId) => {
+        const materialized = materializeTablePageRuntimeInputs(widget.definition.inputs, pageId, widget.key, { preview: true });
+        if (!materialized.inputs) {
+            throw new Error(materialized.diagnostics[0]?.code ?? 'table.page.preview.invalid');
+        }
+        return materialized.inputs;
+    },
+};
+function nativePath(value) {
+    // The native dot-path protocol does not escape dynamic field identities. Its
+    // overrides ancestor is precise; splitting that field would invent a pointer.
+    if (value?.startsWith('config.columnProjection.overrides.'))
+        return '/definition/inputs/config/columnProjection/overrides';
+    const parts = (value ?? 'config').replace(/\[(\d+)\]/g, '.$1').split('.');
+    if (parts[0] === 'bindings')
+        parts.shift();
+    return '/definition/inputs/' + parts.map(pointer).join('/');
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { TABLE_GOVERNED_PAGE_PREVIEW_ADAPTER, buildTableApplyPlan, createTableAuthoringDocument, decodeTablePageInputs, deriveTableEditorDocument, encodeTablePageInputs, materializeTablePageRuntimeInputs, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, projectTablePageEditorChanges, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument, validateTablePageWidget };