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

package/fesm2022/praxisui-table-authoring.mjs

@@ -0,0 +1,1463 @@
+import { validateRichContentDocument, isSafeRichContentClassName } from '@praxisui/rich-content';
+import { resolveColumnTypeFromFieldDefinition, deepMerge, isPraxisPresentationVisualizationTableSafe, resolveTextMaskFormatFromFieldDefinition } from '@praxisui/core/schema';
+
+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) {
+    function actions(value, original, path) {
+        if (!Array.isArray(value))
+            return value;
+        const originals = Array.isArray(original) ? original.filter(isAction) : [];
+        return value.map((item, index) => {
+            if (!isAction(item))
+                return item;
+            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 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`);
+            return result;
+        });
+    }
+    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);
+    return issues;
+}
+/** 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 selected = this.selected()?.node;
+        const childKey = selected?.type === 'card' || selected?.type === 'tab' ? '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] };
+        }
+        if (!Array.isArray(parent[key]))
+            parent[key] = [];
+        parent[key].push(node);
+        this.selectedKey = this.entries().find(entry => entry.node === node)?.key ?? null;
+    }
+}
+
+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) {
+            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) => {
+                const explicitOrder = presentationOrder.get(column.field);
+                return explicitOrder !== undefined ? { ...column, order: explicitOrder } : column;
+            });
+        }
+        return combined;
+    }
+    inferFieldTypeFromFieldName(fieldName) {
+        const lowercaseName = fieldName.toLowerCase();
+        // Date/time patterns - more specific patterns first
+        if (lowercaseName.endsWith('date') ||
+            lowercaseName.endsWith('time') ||
+            lowercaseName.endsWith('at') ||
+            lowercaseName.startsWith('date') ||
+            lowercaseName === 'created' ||
+            lowercaseName === 'updated' ||
+            lowercaseName === 'modified' ||
+            lowercaseName.includes('timestamp')) {
+            return 'date';
+        }
+        // Boolean patterns - most specific first to avoid conflicts
+        if (lowercaseName.startsWith('is_') ||
+            lowercaseName.startsWith('has_') ||
+            lowercaseName.startsWith('can_') ||
+            lowercaseName.startsWith('should_') ||
+            lowercaseName === 'active' ||
+            lowercaseName === 'enabled' ||
+            lowercaseName === 'visible' ||
+            lowercaseName === 'deleted' ||
+            lowercaseName === 'archived' ||
+            lowercaseName.endsWith('_flag') ||
+            lowercaseName.endsWith('_enabled') ||
+            lowercaseName.endsWith('_active')) {
+            return 'boolean';
+        }
+        // Currency/money patterns - exclude common false positives
+        if ((lowercaseName.includes('price') ||
+            lowercaseName.includes('amount') ||
+            lowercaseName.includes('cost') ||
+            lowercaseName.includes('salary') ||
+            lowercaseName.includes('wage') ||
+            lowercaseName.includes('fee') ||
+            (lowercaseName.includes('value') &&
+                !lowercaseName.includes('id') &&
+                !lowercaseName.includes('key'))) &&
+            !lowercaseName.includes('count') &&
+            !lowercaseName.includes('type')) {
+            return 'currency';
+        }
+        // Percentage patterns - be more specific
+        if (lowercaseName.includes('percent') ||
+            lowercaseName.endsWith('_rate') ||
+            lowercaseName.endsWith('_ratio') ||
+            lowercaseName.endsWith('_pct') ||
+            (lowercaseName.includes('rate') &&
+                !lowercaseName.includes('created') &&
+                !lowercaseName.includes('updated')) ||
+            lowercaseName.endsWith('_score')) {
+            return 'percentage';
+        }
+        // Number patterns - exclude common false positives like string IDs
+        if ((lowercaseName.endsWith('_id') && lowercaseName !== 'id') || // composite IDs might be strings
+            lowercaseName === 'id' ||
+            lowercaseName.includes('count') ||
+            lowercaseName.includes('quantity') ||
+            lowercaseName.includes('number') ||
+            lowercaseName.includes('total') ||
+            lowercaseName.includes('sum') ||
+            lowercaseName.includes('age') ||
+            lowercaseName.includes('weight') ||
+            lowercaseName.includes('height') ||
+            lowercaseName.includes('size') ||
+            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 = valueMapping;
+        }
+        const presentation = field.presentation;
+        if (presentation?.presenter === 'microVisualization' &&
+            isPraxisPresentationVisualizationTableSafe(presentation?.visualization)) {
+            col.renderer = {
+                ...(col.renderer || {}),
+                type: 'microVisualization',
+                microVisualization: {
+                    visualization: presentation.visualization,
+                },
+            };
+        }
+        this.applySchemaSemanticCellPresentation(field, col, presentation);
+        if (numericFormat === 'currency' || controlType === 'currency' || col.type === 'currency') {
+            col.type = 'currency';
+            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';
+            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 &&
+            (schemaDataType === 'integer' || schemaFormat === 'int32' || schemaFormat === 'int64')) {
+            col.format = '1.0-0';
+        }
+        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 lname = fname.toLowerCase();
+        const isAvatarByControl = ctl === 'avatar';
+        if (isAvatarByControl) {
+            col.renderer = {
+                type: 'avatar',
+                avatar: {
+                    srcField: fname,
+                    initialsField: 'nomeCompleto',
+                    shape: 'circle',
+                    size: 32,
+                },
+            };
+            // Sensible defaults for avatar column
+            col.align = col.align || 'center';
+            if (!col.width)
+                col.width = '56px';
+            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 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,
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { buildTableApplyPlan, createTableAuthoringDocument, deriveTableEditorDocument, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument };