@praxisui/core 8.0.0-beta.11 → 8.0.0-beta.13

package/fesm2022/praxisui-core.mjs

@@ -127,6 +127,25 @@ function buildSchemaId(params) {
         parts.push(`origin:${params.apiOrigin}`);
     return parts.join('|');
 }
+/**
+ * Produces a deterministic, storage-safe segment for places that impose short
+ * identifier limits. This must not replace the semantic schemaId stored in
+ * payloads or metadata.
+ */
+function buildSchemaIdStorageKeySegment(schemaId) {
+    const normalized = String(schemaId || '').trim();
+    if (!normalized)
+        return '';
+    return `schema-${fnv1a32Base36(normalized)}-${normalized.length.toString(36)}`;
+}
+function fnv1a32Base36(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(36).padStart(7, '0');
+}
 
 function hash(input) {
     let h = 0;
@@ -5351,6 +5370,26 @@ class SurfaceBindingRuntimeService {
         }
         return resolvedWidget;
     }
+    resolveSurfacePayload(surfacePayload, actionContext, explicitContext) {
+        const context = this.buildContext(surfacePayload, actionContext, explicitContext);
+        let resolvedPayload = this.resolveTemplate(this.clone(surfacePayload), context);
+        for (const binding of surfacePayload.bindings || []) {
+            const rawTargetPath = String(binding?.to || '').trim();
+            if (!rawTargetPath)
+                continue;
+            const value = this.resolveBindingValue(binding, context);
+            if (rawTargetPath.startsWith('widget.')) {
+                resolvedPayload = {
+                    ...resolvedPayload,
+                    widget: this.setValueAtPath(resolvedPayload.widget, this.normalizeWidgetTargetPath(rawTargetPath), value),
+                };
+            }
+            else {
+                resolvedPayload = this.setValueAtPath(resolvedPayload, rawTargetPath, value);
+            }
+        }
+        return resolvedPayload;
+    }
     extractByPath(obj, path) {
         if (!path)
             return obj;
@@ -5442,6 +5481,9 @@ class SurfaceBindingRuntimeService {
             return '';
         return path.startsWith('widget.') ? path.slice('widget.'.length) : path;
     }
+    normalizeWidgetTargetPath(rawPath) {
+        return this.normalizeTargetPath(rawPath);
+    }
     tokenizePath(path) {
         const tokens = [];
         let buffer = '';
@@ -5925,9 +5967,14 @@ class GlobalActionService {
         const payload = normalized.payloadExpr
             ? this.resolvePayloadExpr(normalized.payloadExpr, context)
             : normalized.payload;
+        const contextPayload = normalized.payloadExpr
+            ? payload
+            : (context && Object.prototype.hasOwnProperty.call(context, 'payload')
+                ? context.payload
+                : payload);
         return this.execute(normalized.actionId, payload, {
             ...context,
-            payload,
+            payload: contextPayload,
             meta: {
                 ...(context?.meta || {}),
                 ...(normalized.meta ? { actionRef: normalized.meta } : {}),
@@ -6029,8 +6076,8 @@ class GlobalActionService {
             if (!surfacePayload?.widget?.id) {
                 return { success: false, error: 'surface.open requires widget.id' };
             }
-            const resolvedWidget = this.surfaceBindingRuntime.resolveWidget(surfacePayload.widget, surfacePayload.bindings, surfacePayload, context, surfacePayload.context);
-            const data = await this.surface.open({ ...surfacePayload, widget: resolvedWidget }, context);
+            const resolvedPayload = this.surfaceBindingRuntime.resolveSurfacePayload(surfacePayload, context, surfacePayload.context);
+            const data = await this.surface.open(resolvedPayload, context);
             return { success: true, data };
         });
         this.register('toast.success', async (payload) => {
@@ -7447,7 +7494,10 @@ const DEFAULT_JSON_LOGIC_OPERATORS = [
             if (!parsed || !Array.isArray(rawDays)) {
                 return false;
             }
-            const normalized = rawDays.map((item) => Number(item)).filter(Number.isFinite);
+            const normalized = rawDays
+                .map((item) => Number(item))
+                .filter(Number.isFinite)
+                .map((item) => item === 0 ? 7 : item);
             if (!normalized.length) {
                 return false;
             }
@@ -9421,6 +9471,439 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+const PRAXIS_EXPORT_FORMULA_PREFIXES = ['=', '+', '-', '@', '\t', '\r'];
+const PRAXIS_DEFAULT_EXPORT_SECURITY_POLICY = {
+    escapeFormulaValues: true,
+    formulaPrefixes: PRAXIS_EXPORT_FORMULA_PREFIXES,
+    formulaEscapePrefix: "'",
+};
+function resolvePraxisExportScope(request) {
+    if (request.scope !== 'auto') {
+        return request.scope;
+    }
+    const selection = request.selection;
+    const hasSelectedItems = !!selection?.selectedItems?.length;
+    const hasSelectedKeys = !!selection?.selectedKeys?.length;
+    const hasAllMatchingSelection = selection?.allMatchingSelected === true;
+    if (hasSelectedItems || hasSelectedKeys || hasAllMatchingSelection) {
+        return 'selected';
+    }
+    return request.filters || request.query ? 'filtered' : 'currentPage';
+}
+function resolvePraxisCollectionExportItems(request) {
+    const scope = resolvePraxisExportScope(request);
+    const loadedItems = request.loadedItems ?? [];
+    if (scope === 'selected') {
+        const selectedItems = request.selection?.selectedItems;
+        if (selectedItems?.length) {
+            return selectedItems;
+        }
+        const keyField = request.selection?.keyField;
+        const selectedKeys = request.selection?.selectedKeys;
+        if (!keyField || !selectedKeys?.length) {
+            return [];
+        }
+        const selectedKeySet = new Set(selectedKeys);
+        return loadedItems.filter((item) => selectedKeySet.has(readPraxisExportValue(item, keyField)));
+    }
+    return loadedItems;
+}
+function resolvePraxisExportFields(request) {
+    const configuredFields = request.fields?.filter((field) => field.exportable !== false && field.visible !== false);
+    if (configuredFields?.length) {
+        return configuredFields;
+    }
+    const sample = resolvePraxisCollectionExportItems(request)[0];
+    if (!sample || typeof sample !== 'object') {
+        return [];
+    }
+    return Object.keys(sample).map((key) => ({
+        key,
+        label: key,
+        valuePath: key,
+    }));
+}
+function readPraxisExportValue(item, path) {
+    if (!item || !path) {
+        return undefined;
+    }
+    return path.split('.').reduce((value, segment) => {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        return value[segment];
+    }, item);
+}
+function escapePraxisExportCell(value, policy = PRAXIS_DEFAULT_EXPORT_SECURITY_POLICY) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    const text = value instanceof Date ? value.toISOString() : String(value);
+    if (!policy.escapeFormulaValues || !text) {
+        return text;
+    }
+    return startsWithPraxisFormula(text, policy.formulaPrefixes)
+        ? `${policy.formulaEscapePrefix}${text}`
+        : text;
+}
+function serializePraxisCollectionToCsv(request, policy = PRAXIS_DEFAULT_EXPORT_SECURITY_POLICY) {
+    const fields = resolvePraxisExportFields(request);
+    const items = resolvePraxisCollectionExportItems(request);
+    const rows = [];
+    if (request.includeHeaders !== false) {
+        rows.push(fields.map((field) => quoteCsvCell(field.label ?? field.key)).join(','));
+    }
+    for (const item of applyPraxisExportLimit(items, request.maxRows)) {
+        const cells = fields.map((field) => {
+            const rawValue = field.valueGetter
+                ? field.valueGetter(item)
+                : readPraxisExportValue(item, field.valuePath ?? field.key);
+            const formattedValue = request.applyFormatting !== false && field.formatter
+                ? field.formatter(rawValue, item)
+                : rawValue;
+            return quoteCsvCell(escapePraxisExportCell(formattedValue, policy));
+        });
+        rows.push(cells.join(','));
+    }
+    return rows.join('\r\n');
+}
+function serializePraxisCollectionToJson(request) {
+    const fields = resolvePraxisExportFields(request);
+    const items = applyPraxisExportLimit(resolvePraxisCollectionExportItems(request), request.maxRows);
+    const rows = items.map((item) => fields.reduce((row, field) => {
+        const rawValue = field.valueGetter
+            ? field.valueGetter(item)
+            : readPraxisExportValue(item, field.valuePath ?? field.key);
+        row[field.key] = request.applyFormatting !== false && field.formatter
+            ? field.formatter(rawValue, item)
+            : rawValue;
+        return row;
+    }, {}));
+    return JSON.stringify(rows, null, 2);
+}
+function hasPraxisCollectionExportArtifact(result) {
+    if (!result) {
+        return false;
+    }
+    if (result.status === 'deferred') {
+        return true;
+    }
+    if (typeof result.downloadUrl === 'string' && result.downloadUrl.trim()) {
+        return true;
+    }
+    return result.content !== undefined && result.content !== null;
+}
+function assertPraxisCollectionExportArtifact(result) {
+    if (!hasPraxisCollectionExportArtifact(result)) {
+        throw new Error('Collection export completed without content, downloadUrl, or deferred status.');
+    }
+}
+function applyPraxisExportLimit(items, maxRows) {
+    if (!maxRows || maxRows <= 0 || items.length <= maxRows) {
+        return items;
+    }
+    return items.slice(0, maxRows);
+}
+function quoteCsvCell(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function startsWithPraxisFormula(text, formulaPrefixes) {
+    let index = 0;
+    while (index < text.length && /\s/.test(text.charAt(index))) {
+        index += 1;
+    }
+    if (index >= text.length) {
+        return false;
+    }
+    const candidate = text.slice(index);
+    return formulaPrefixes.some((prefix) => candidate.startsWith(prefix));
+}
+
+const PRAXIS_COLLECTION_EXPORT_PROVIDER = new InjectionToken('PRAXIS_COLLECTION_EXPORT_PROVIDER');
+const PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS = new InjectionToken('PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS', {
+    providedIn: 'root',
+    factory: () => ({}),
+});
+const PRAXIS_EXPORT_SECURITY_POLICY = new InjectionToken('PRAXIS_EXPORT_SECURITY_POLICY', {
+    providedIn: 'root',
+    factory: () => PRAXIS_DEFAULT_EXPORT_SECURITY_POLICY,
+});
+function providePraxisCollectionExportProvider(provider) {
+    return {
+        provide: PRAXIS_COLLECTION_EXPORT_PROVIDER,
+        useValue: provider,
+    };
+}
+
+class PraxisCollectionExportService {
+    provider;
+    securityPolicy;
+    constructor(provider, securityPolicy) {
+        this.provider = provider;
+        this.securityPolicy = securityPolicy;
+    }
+    async exportCollection(request) {
+        if (this.provider) {
+            return this.provider.exportCollection(request);
+        }
+        return this.exportLocalCollection(request);
+    }
+    exportLocalCollection(request) {
+        const scope = resolvePraxisExportScope(request);
+        const requiresRemoteProvider = !!request.resourcePath && (scope === 'filtered' || scope === 'all');
+        if (requiresRemoteProvider) {
+            throw new Error(`PraxisCollectionExportService requires a collection export provider for remote "${scope}" exports.`);
+        }
+        const items = resolvePraxisCollectionExportItems(request);
+        const rowCount = request.maxRows && request.maxRows > 0
+            ? Math.min(items.length, request.maxRows)
+            : items.length;
+        if (request.format === 'csv') {
+            return {
+                status: 'completed',
+                format: request.format,
+                scope,
+                fileName: request.fileName,
+                mimeType: 'text/csv;charset=utf-8',
+                content: serializePraxisCollectionToCsv(request, this.securityPolicy),
+                rowCount,
+            };
+        }
+        if (request.format === 'json') {
+            return {
+                status: 'completed',
+                format: request.format,
+                scope,
+                fileName: request.fileName,
+                mimeType: 'application/json;charset=utf-8',
+                content: serializePraxisCollectionToJson(request),
+                rowCount,
+            };
+        }
+        throw new Error(`PraxisCollectionExportService requires a collection export provider for "${request.format}" exports.`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCollectionExportService, deps: [{ token: PRAXIS_COLLECTION_EXPORT_PROVIDER, optional: true }, { token: PRAXIS_EXPORT_SECURITY_POLICY }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCollectionExportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCollectionExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PRAXIS_COLLECTION_EXPORT_PROVIDER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PRAXIS_EXPORT_SECURITY_POLICY]
+                }] }] });
+
+class PraxisHttpCollectionExportProvider {
+    http;
+    apiUrlConfig;
+    options;
+    constructor(http, apiUrlConfig, options) {
+        this.http = http;
+        this.apiUrlConfig = apiUrlConfig;
+        this.options = options;
+    }
+    async exportCollection(request) {
+        const url = this.resolveEndpoint(request);
+        const body = this.buildRequestBody(request);
+        const response = await firstValueFrom(this.http.post(url, body, {
+            headers: this.buildHeaders(),
+            observe: 'response',
+            responseType: 'blob',
+            withCredentials: this.options?.withCredentials,
+        }));
+        return this.normalizeResponse(response, request);
+    }
+    resolveEndpoint(request) {
+        const configuredEndpoint = this.options?.endpoint;
+        if (typeof configuredEndpoint === 'function') {
+            return this.resolveUrl(configuredEndpoint(request));
+        }
+        if (configuredEndpoint) {
+            return this.resolveUrl(configuredEndpoint);
+        }
+        const resourcePath = request.resourcePath?.trim();
+        if (!resourcePath) {
+            throw new Error('PraxisHttpCollectionExportProvider requires request.resourcePath or an explicit endpoint option.');
+        }
+        return this.resolveUrl(`${resourcePath.replace(/\/+$/, '')}/export`);
+    }
+    resolveUrl(pathOrUrl) {
+        const value = pathOrUrl.trim();
+        if (/^https?:\/\//i.test(value)) {
+            return value;
+        }
+        const base = this.resolveApiBaseUrl();
+        const path = this.normalizePathForBase(value, base);
+        return base ? `${base}/${path}` : `/${path}`;
+    }
+    normalizePathForBase(pathOrUrl, base) {
+        const path = pathOrUrl.replace(/^\/+/, '');
+        const baseLastSegment = base
+            .replace(/\/+$/, '')
+            .split('/')
+            .filter(Boolean)
+            .pop();
+        if (baseLastSegment && path === baseLastSegment) {
+            return '';
+        }
+        const duplicatedPrefix = baseLastSegment ? `${baseLastSegment}/` : '';
+        return duplicatedPrefix && path.startsWith(duplicatedPrefix)
+            ? path.slice(duplicatedPrefix.length)
+            : path;
+    }
+    resolveApiBaseUrl() {
+        const key = this.options?.apiUrlKey || 'default';
+        const entry = this.apiUrlConfig?.[key] || this.apiUrlConfig?.['default'];
+        return buildApiUrl(entry || {}).replace(/\/+$/, '');
+    }
+    buildHeaders() {
+        const key = this.options?.apiUrlKey || 'default';
+        const entry = this.apiUrlConfig?.[key] || this.apiUrlConfig?.['default'];
+        let headers = buildHeaders(entry || {});
+        for (const [name, value] of Object.entries(this.options?.headers || {})) {
+            headers = (headers || new HttpHeaders()).set(name, value);
+        }
+        return headers;
+    }
+    buildRequestBody(request) {
+        const effectiveScope = resolvePraxisExportScope(request);
+        const includeLoadedItems = this.options?.includeLoadedItems === true ||
+            !request.resourcePath ||
+            effectiveScope === 'currentPage' ||
+            effectiveScope === 'selected';
+        return {
+            ...request,
+            scope: effectiveScope,
+            loadedItems: includeLoadedItems ? request.loadedItems : undefined,
+            metadata: {
+                ...request.metadata,
+                configuredScope: request.scope,
+                effectiveScope,
+            },
+        };
+    }
+    async normalizeResponse(response, request) {
+        const blob = response.body || new Blob();
+        const contentType = response.headers.get('content-type') || blob.type || undefined;
+        if (contentType?.includes('application/json')) {
+            const text = await blob.text();
+            const parsed = JSON.parse(text || '{}');
+            const exportHeaders = this.normalizeExportHeaders(response);
+            return {
+                ...parsed,
+                format: parsed.format || request.format,
+                scope: parsed.scope || resolvePraxisExportScope(request),
+                fileName: parsed.fileName || this.resolveFileName(response, request),
+                rowCount: parsed.rowCount ?? exportHeaders.rowCount,
+                warnings: this.mergeWarnings(parsed.warnings, exportHeaders.warnings),
+                metadata: {
+                    ...exportHeaders.metadata,
+                    ...parsed.metadata,
+                },
+            };
+        }
+        const exportHeaders = this.normalizeExportHeaders(response);
+        return {
+            status: 'completed',
+            format: request.format,
+            scope: resolvePraxisExportScope(request),
+            fileName: this.resolveFileName(response, request),
+            mimeType: contentType,
+            content: blob,
+            rowCount: exportHeaders.rowCount,
+            warnings: exportHeaders.warnings,
+            metadata: {
+                httpStatus: response.status,
+                ...exportHeaders.metadata,
+            },
+        };
+    }
+    normalizeExportHeaders(response) {
+        const rowCount = this.readNumberHeader(response, 'X-Export-Row-Count');
+        const truncated = this.readBooleanHeader(response, 'X-Export-Truncated');
+        const maxRows = this.readNumberHeader(response, 'X-Export-Max-Rows');
+        const candidateRows = this.readNumberHeader(response, 'X-Export-Candidate-Row-Count');
+        const warnings = this.readWarningHeader(response);
+        const metadata = {};
+        if (truncated !== undefined) {
+            metadata['truncated'] = truncated;
+        }
+        if (maxRows !== undefined) {
+            metadata['maxRows'] = maxRows;
+        }
+        if (candidateRows !== undefined) {
+            metadata['candidateRows'] = candidateRows;
+        }
+        return { rowCount, warnings, metadata };
+    }
+    readNumberHeader(response, headerName) {
+        const value = response.headers.get(headerName);
+        if (!value) {
+            return undefined;
+        }
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    readBooleanHeader(response, headerName) {
+        const value = response.headers.get(headerName);
+        if (value === null) {
+            return undefined;
+        }
+        return value.toLowerCase() === 'true';
+    }
+    readWarningHeader(response) {
+        const value = response.headers.get('X-Export-Warnings');
+        if (!value) {
+            return [];
+        }
+        return value
+            .split('|')
+            .map((warning) => warning.trim())
+            .filter(Boolean);
+    }
+    mergeWarnings(parsedWarnings, headerWarnings) {
+        const warnings = [
+            ...(parsedWarnings || []),
+            ...headerWarnings,
+        ];
+        return warnings.length ? warnings : undefined;
+    }
+    resolveFileName(response, request) {
+        const disposition = response.headers.get('content-disposition') || '';
+        const utf8Match = disposition.match(/filename\*=UTF-8''([^;]+)/i);
+        if (utf8Match?.[1]) {
+            return decodeURIComponent(utf8Match[1].trim().replace(/^"|"$/g, ''));
+        }
+        const asciiMatch = disposition.match(/filename="?([^";]+)"?/i);
+        if (asciiMatch?.[1]) {
+            return asciiMatch[1].trim();
+        }
+        return request.fileName;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisHttpCollectionExportProvider, deps: [{ token: i1.HttpClient }, { token: API_URL, optional: true }, { token: PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisHttpCollectionExportProvider });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisHttpCollectionExportProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [API_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS]
+                }] }] });
+
 const FIELD_SELECTOR_REGISTRY_BASE = new InjectionToken('FIELD_SELECTOR_REGISTRY_BASE');
 const FIELD_SELECTOR_REGISTRY_OVERRIDES = new InjectionToken('FIELD_SELECTOR_REGISTRY_OVERRIDES');
 const FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS = new InjectionToken('FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS');
@@ -12967,6 +13450,17 @@ const STEPPER_CONFIG_EDITOR = new InjectionToken('STEPPER_CONFIG_EDITOR');
 const DYNAMIC_PAGE_SHELL_EDITOR = new InjectionToken('DYNAMIC_PAGE_SHELL_EDITOR');
 const DYNAMIC_PAGE_CONFIG_EDITOR = new InjectionToken('DYNAMIC_PAGE_CONFIG_EDITOR');
 
+function providePraxisHttpCollectionExportProvider(options = {}) {
+    return [
+        { provide: PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS, useValue: options },
+        PraxisHttpCollectionExportProvider,
+        {
+            provide: PRAXIS_COLLECTION_EXPORT_PROVIDER,
+            useExisting: PraxisHttpCollectionExportProvider,
+        },
+    ];
+}
+
 const RESOURCE_DISCOVERY_I18N_NAMESPACE = 'resourceDiscovery';
 const RESOURCE_AVAILABILITY_REASON_KEY_BY_CODE = {
     'resource-state-blocked': 'availability.reason.resource-state-blocked',
@@ -13256,6 +13750,99 @@ function createEmptyRichContentDocument() {
     };
 }
 
+function normalizeItemId(kind, value, index) {
+    const candidate = typeof value === 'string' ? value.trim() : '';
+    if (candidate)
+        return candidate;
+    return `${kind}-${index + 1}`;
+}
+function fieldItemId(fieldName, index) {
+    const slug = fieldName
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return `field-${slug || 'unnamed'}-${index + 1}`;
+}
+function getLegacyFieldName(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+    if (value && typeof value === 'object') {
+        const name = value.name;
+        if (typeof name === 'string') {
+            const trimmed = name.trim();
+            return trimmed || null;
+        }
+    }
+    return null;
+}
+function createFieldLayoutItem(fieldName, index = 0) {
+    return {
+        kind: 'field',
+        id: fieldItemId(fieldName, index),
+        fieldName,
+    };
+}
+function isFormLayoutItem(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const item = value;
+    if (item.kind === 'field') {
+        return typeof item.fieldName === 'string';
+    }
+    if (item.kind === 'richContent') {
+        const document = item.document;
+        return !!document && typeof document === 'object';
+    }
+    return false;
+}
+function normalizeFormLayoutItems(column) {
+    const rawItems = column?.items;
+    if (Array.isArray(rawItems)) {
+        return rawItems
+            .map((rawItem, index) => {
+            if (!isFormLayoutItem(rawItem))
+                return null;
+            if (rawItem.kind === 'field') {
+                const fieldName = rawItem.fieldName.trim();
+                if (!fieldName)
+                    return null;
+                return {
+                    ...rawItem,
+                    id: normalizeItemId('field', rawItem.id, index),
+                    fieldName,
+                };
+            }
+            return {
+                ...rawItem,
+                id: normalizeItemId('richContent', rawItem.id, index),
+            };
+        })
+            .filter((item) => item !== null);
+    }
+    const rawFields = column?.fields;
+    if (!Array.isArray(rawFields))
+        return [];
+    return rawFields
+        .map((field, index) => {
+        const fieldName = getLegacyFieldName(field);
+        return fieldName ? createFieldLayoutItem(fieldName, index) : null;
+    })
+        .filter((item) => item !== null);
+}
+function getFormLayoutFieldNames(items) {
+    if (!Array.isArray(items))
+        return [];
+    return items
+        .filter((item) => item.kind === 'field')
+        .map((item) => item.fieldName);
+}
+function getFormColumnFieldNames(column) {
+    return getFormLayoutFieldNames(normalizeFormLayoutItems(column));
+}
+
 function defaultGenerateId(kind, used) {
     // determinístico + compacto, evitando Math.random (facilita tests/replays)
     let seq = 1;
@@ -13309,12 +13896,13 @@ function ensureIds(config, options = {}) {
             const rowId = takeOrGenerate('row', row.id, used, keepExistingUnique, generateId);
             const safeColumns = (row.columns ?? []).map((col) => {
                 const colId = takeOrGenerate('col', col.id, used, keepExistingUnique, generateId);
-                // garantir fields como array
-                const fields = Array.isArray(col.fields) ? col.fields : [];
+                const items = normalizeFormLayoutItems(col);
+                const fields = getFormLayoutFieldNames(items);
                 return {
                     ...col,
                     id: colId,
                     fields,
+                    items,
                 };
             });
             return {
@@ -13612,7 +14200,7 @@ function getReferencedFieldMetadata(config, allFieldMetadata) {
     config.sections.forEach((section) => {
         section.rows.forEach((row) => {
             row.columns.forEach((column) => {
-                column.fields.forEach((fieldName) => {
+                getFormColumnFieldNames(column).forEach((fieldName) => {
                     referencedFieldNames.add(fieldName);
                 });
             });
@@ -14862,6 +15450,23 @@ const RULE_PROPERTY_SCHEMA = {
         { name: 'className', type: 'string', label: 'Classe CSS' },
         { name: 'style', type: 'object', label: 'Estilos inline' },
     ],
+    visualBlock: [
+        { name: 'visible', type: 'boolean', label: 'Visível', category: 'behavior' },
+        { name: 'hidden', type: 'boolean', label: 'Oculto', category: 'behavior' },
+        {
+            name: 'layout',
+            type: 'enum',
+            label: 'Layout',
+            category: 'layout',
+            enumValues: [
+                { value: 'block', label: 'Bloco' },
+                { value: 'inline', label: 'Inline' },
+            ],
+        },
+        { name: 'rootClassName', type: 'string', label: 'Classe raiz', category: 'appearance' },
+        { name: 'className', type: 'string', label: 'Classe CSS', category: 'appearance' },
+        { name: 'style', type: 'object', label: 'Estilos inline', category: 'appearance' },
+    ],
 };
 
 const EDITORIAL_THEME_PRESETS = [
@@ -16382,7 +16987,8 @@ function normalizeTargets(rule) {
                 : rawTargets.some((t) => t?.startsWith('action:')) ? 'action'
                     : rawTargets.some((t) => t?.startsWith('row:')) ? 'row'
                         : rawTargets.some((t) => t?.startsWith('column:')) ? 'column'
-                            : 'field');
+                            : rawTargets.some((t) => t?.startsWith('visualBlock:')) ? 'visualBlock'
+                                : 'field');
     const targets = rawTargets.map((t) => stripPrefix(t));
     return { targetType, targets };
 }
@@ -16398,6 +17004,8 @@ function stripPrefix(value) {
         return value.substring('row:'.length);
     if (value?.startsWith('column:'))
         return value.substring('column:'.length);
+    if (value?.startsWith('visualBlock:'))
+        return value.substring('visualBlock:'.length);
     return value;
 }
 function isScopedSectionHeaderActionTarget(value) {
@@ -18717,6 +19325,16 @@ function getFieldMetadataCapabilities() {
  */
 const ENUMS = {
     layoutOrientation: ['vertical', 'columns'],
+    canvasMode: ['grid'],
+    canvasAutoRows: ['fixed', 'content'],
+    canvasCollisionPolicy: ['block', 'swap'],
+    groupingKind: ['section', 'tabs', 'hero', 'rail'],
+    groupingLayout: ['stack', 'grid', 'row'],
+    heroEmphasis: ['high', 'medium'],
+    railSide: ['left', 'right'],
+    deviceKind: ['desktop', 'tablet', 'mobile'],
+    stateMergeStrategy: ['replace', 'merge', 'append', 'remove-keys'],
+    derivedStateComputeKind: ['json-logic', 'template', 'operator', 'transformer'],
     shellKind: ['dashboard-card', 'none'],
     actionVariant: ['icon', 'text', 'outlined'],
     actionPlacement: ['header', 'window'],
@@ -18724,6 +19342,9 @@ const ENUMS = {
 const CAPS = [
     { path: 'page', category: 'page', valueKind: 'object', description: 'Definicao da pagina dinamica.' },
     { path: 'page.context', category: 'context', valueKind: 'object', description: 'Contexto compartilhado entre widgets.' },
+    { path: 'page.layoutPreset', category: 'layout', valueKind: 'string', description: 'ID canonico opcional do preset estrutural da pagina.' },
+    { path: 'page.layoutPresetOptions', category: 'layout', valueKind: 'object', description: 'Opcoes especificas do preset estrutural consumidas por builders e runtimes futuros.' },
+    { path: 'page.themePreset', category: 'appearance', valueKind: 'string', description: 'ID opcional do preset de tema para shell, graficos, densidade e defaults visuais.' },
     { path: 'page.layout', category: 'layout', valueKind: 'object', description: 'Layout base da pagina.' },
     { path: 'page.layout.orientation', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.layoutOrientation, description: 'Orientacao do grid (vertical/columns).' },
     { path: 'page.layout.columns', category: 'layout', valueKind: 'number', description: 'Numero de colunas (quando orientation=columns).' },
@@ -18733,6 +19354,26 @@ const CAPS = [
     { path: 'page.layout.breakpoints.md', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint md.' },
     { path: 'page.layout.breakpoints.lg', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint lg.' },
     { path: 'page.layout.breakpoints.xl', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint xl.' },
+    { path: 'page.canvas', category: 'layout', valueKind: 'object', description: 'Canvas espacial canonico da pagina quando houver geometria explicita.' },
+    { path: 'page.canvas.mode', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.canvasMode, description: 'Modo canonico do canvas. Valor atual: grid.' },
+    { path: 'page.canvas.columns', category: 'layout', valueKind: 'number', description: 'Numero de colunas do canvas espacial.' },
+    { path: 'page.canvas.rowUnit', category: 'layout', valueKind: 'string', description: 'Altura base das linhas do canvas, como 80px.' },
+    { path: 'page.canvas.gap', category: 'layout', valueKind: 'string', description: 'Espacamento entre itens do canvas.' },
+    { path: 'page.canvas.autoRows', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.canvasAutoRows, description: 'Politica de linhas automaticas do canvas.' },
+    { path: 'page.canvas.collisionPolicy', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.canvasCollisionPolicy, description: 'Politica de colisao do canvas espacial.' },
+    { path: 'page.canvas.items', category: 'layout', valueKind: 'object', description: 'Mapa canonico de geometria por widget key.' },
+    { path: 'page.canvas.items.<widgetKey>.col', category: 'layout', valueKind: 'number', description: 'Coluna inicial do widget no canvas.' },
+    { path: 'page.canvas.items.<widgetKey>.row', category: 'layout', valueKind: 'number', description: 'Linha inicial do widget no canvas.' },
+    { path: 'page.canvas.items.<widgetKey>.colSpan', category: 'layout', valueKind: 'number', description: 'Quantidade de colunas ocupadas pelo widget.' },
+    { path: 'page.canvas.items.<widgetKey>.rowSpan', category: 'layout', valueKind: 'number', description: 'Quantidade de linhas ocupadas pelo widget.' },
+    { path: 'page.canvas.items.<widgetKey>.zIndex', category: 'layout', valueKind: 'number', description: 'Camada opcional do item no canvas.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints', category: 'layout', valueKind: 'object', description: 'Restricoes opcionais de posicao e tamanho do item no canvas.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.minColSpan', category: 'layout', valueKind: 'number', description: 'Span minimo de colunas permitido.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.minRowSpan', category: 'layout', valueKind: 'number', description: 'Span minimo de linhas permitido.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.maxColSpan', category: 'layout', valueKind: 'number', description: 'Span maximo de colunas permitido.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.maxRowSpan', category: 'layout', valueKind: 'number', description: 'Span maximo de linhas permitido.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.lockPosition', category: 'layout', valueKind: 'boolean', description: 'Bloqueia alteracao de posicao do item no canvas.' },
+    { path: 'page.canvas.items.<widgetKey>.constraints.lockSize', category: 'layout', valueKind: 'boolean', description: 'Bloqueia alteracao de tamanho do item no canvas.' },
     { path: 'page.widgets', category: 'widgets', valueKind: 'array', description: 'Lista de widgets renderizados.' },
     { path: 'page.widgets[].key', category: 'widgets', valueKind: 'string', description: 'Identificador unico do widget.' },
     { path: 'page.widgets[].className', category: 'widgets', valueKind: 'string', description: 'Classe CSS opcional do widget.' },
@@ -18752,30 +19393,107 @@ const CAPS = [
     { path: 'page.widgets[].shell.actions[].variant', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionVariant, description: 'Estilo visual da acao.' },
     { path: 'page.widgets[].shell.actions[].placement', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionPlacement, description: 'Posicionamento da acao.' },
     { path: 'page.widgets[].shell.actions[].emit', category: 'shell', valueKind: 'string', description: 'Evento emitido ao acionar a acao.' },
+    { path: 'page.state', category: 'state', valueKind: 'object', description: 'Estado declarativo opcional compartilhado por widgets e composicao.' },
+    { path: 'page.state.values', category: 'state', valueKind: 'object', description: 'Valores primarios mutaveis escritos por widgets, defaults ou host.' },
+    { path: 'page.state.schema', category: 'state', valueKind: 'object', description: 'Descritores dos paths primarios de estado.' },
+    { path: 'page.state.schema.<token>.type', category: 'state', valueKind: 'string', description: 'Tipo semantico opcional do path de estado.' },
+    { path: 'page.state.schema.<token>.initial', category: 'state', valueKind: 'object', description: 'Valor inicial usado quando page.state.values omite o path.' },
+    { path: 'page.state.schema.<token>.persist', category: 'state', valueKind: 'boolean', description: 'Indica se o path primario deve ser persistido com a pagina.' },
+    { path: 'page.state.schema.<token>.mergeStrategy', category: 'state', valueKind: 'enum', allowedValues: ENUMS.stateMergeStrategy, description: 'Como escritas de widget/estado combinam com o valor atual.' },
+    { path: 'page.state.schema.<token>.description', category: 'state', valueKind: 'string', description: 'Descricao opcional do path para builders e catalogos AI.' },
+    { path: 'page.state.schema.<token>.tags', category: 'state', valueKind: 'array', description: 'Tags opcionais para busca e governanca do estado.' },
+    { path: 'page.state.derived', category: 'state', valueKind: 'object', description: 'Descritores de estado derivado recomputado pelo runtime.' },
+    { path: 'page.state.derived.<token>.dependsOn', category: 'state', valueKind: 'array', description: 'Paths de estado que alimentam o valor derivado.' },
+    { path: 'page.state.derived.<token>.compute', category: 'state', valueKind: 'object', description: 'Descritor de computacao do estado derivado.' },
+    { path: 'page.state.derived.<token>.compute.kind', category: 'state', valueKind: 'enum', allowedValues: ENUMS.derivedStateComputeKind, description: 'Tipo de computacao do estado derivado.' },
+    { path: 'page.state.derived.<token>.compute.expression', category: 'state', valueKind: 'expression', description: 'Expressao Json Logic para compute.kind=json-logic.' },
+    { path: 'page.state.derived.<token>.compute.value', category: 'state', valueKind: 'object', description: 'Valor template para compute.kind=template.' },
+    { path: 'page.state.derived.<token>.compute.operator', category: 'state', valueKind: 'string', description: 'Operador para compute.kind=operator.' },
+    { path: 'page.state.derived.<token>.compute.options', category: 'state', valueKind: 'object', description: 'Opcoes do operador ou transformer.' },
+    { path: 'page.state.derived.<token>.compute.transformerId', category: 'state', valueKind: 'string', description: 'Identificador do transformer para compute.kind=transformer.' },
+    { path: 'page.state.derived.<token>.description', category: 'state', valueKind: 'string', description: 'Descricao opcional do estado derivado.' },
+    { path: 'page.state.derived.<token>.cache', category: 'state', valueKind: 'boolean', description: 'Permite cache futuro do valor derivado.' },
     { path: 'page.composition', category: 'connections', valueKind: 'object', description: 'Envelope canonico da composicao persistida.' },
     { path: 'page.composition.version', category: 'connections', valueKind: 'string', description: 'Versao do envelope de composicao.' },
     { path: 'page.composition.links', category: 'connections', valueKind: 'array', description: 'Links canonicos entre widgets e estado.' },
     { path: 'page.composition.links[].id', category: 'connections', valueKind: 'string', description: 'Identificador estavel do link.' },
     { path: 'page.composition.links[].from', category: 'connections', valueKind: 'object', description: 'Endpoint de origem do link.' },
+    { path: 'page.composition.links[].from.kind', category: 'connections', valueKind: 'string', description: 'Tipo do endpoint de origem, como component-port ou state.' },
+    { path: 'page.composition.links[].from.ref', category: 'connections', valueKind: 'object', description: 'Referencia estruturada do endpoint de origem.' },
+    { path: 'page.composition.links[].from.ref.widget', category: 'connections', valueKind: 'string', description: 'Widget top-level dono do endpoint de origem.' },
+    { path: 'page.composition.links[].from.ref.port', category: 'connections', valueKind: 'string', description: 'Porta de origem do componente.' },
+    { path: 'page.composition.links[].from.ref.direction', category: 'connections', valueKind: 'string', description: 'Direcao da porta de origem.' },
+    { path: 'page.composition.links[].from.ref.nestedPath', category: 'connections', valueKind: 'array', description: 'NestedPath canonico para porta de componente filho de origem.' },
+    { path: 'page.composition.links[].from.ref.nestedPath[].kind', category: 'connections', valueKind: 'string', description: 'Tipo do segmento nested de origem.' },
+    { path: 'page.composition.links[].from.ref.nestedPath[].id', category: 'connections', valueKind: 'string', description: 'Identificador estrutural do segmento nested de origem.' },
+    { path: 'page.composition.links[].from.ref.nestedPath[].key', category: 'connections', valueKind: 'string', description: 'Chave estavel do widget filho no segmento terminal de origem.', critical: true },
+    { path: 'page.composition.links[].from.ref.nestedPath[].index', category: 'connections', valueKind: 'number', description: 'Indice auxiliar para diagnostico visual; nao use como identidade primaria.' },
+    { path: 'page.composition.links[].from.ref.nestedPath[].componentType', category: 'connections', valueKind: 'string', description: 'Tipo do componente real do widget filho de origem.' },
     { path: 'page.composition.links[].to', category: 'connections', valueKind: 'object', description: 'Endpoint de destino do link.' },
+    { path: 'page.composition.links[].to.kind', category: 'connections', valueKind: 'string', description: 'Tipo do endpoint de destino, como component-port ou state.' },
+    { path: 'page.composition.links[].to.ref', category: 'connections', valueKind: 'object', description: 'Referencia estruturada do endpoint de destino.' },
+    { path: 'page.composition.links[].to.ref.widget', category: 'connections', valueKind: 'string', description: 'Widget top-level dono do endpoint de destino.' },
+    { path: 'page.composition.links[].to.ref.port', category: 'connections', valueKind: 'string', description: 'Porta de destino do componente.' },
+    { path: 'page.composition.links[].to.ref.direction', category: 'connections', valueKind: 'string', description: 'Direcao da porta de destino.' },
+    { path: 'page.composition.links[].to.ref.nestedPath', category: 'connections', valueKind: 'array', description: 'NestedPath canonico para porta de componente filho de destino.' },
+    { path: 'page.composition.links[].to.ref.nestedPath[].kind', category: 'connections', valueKind: 'string', description: 'Tipo do segmento nested de destino.' },
+    { path: 'page.composition.links[].to.ref.nestedPath[].id', category: 'connections', valueKind: 'string', description: 'Identificador estrutural do segmento nested de destino.' },
+    { path: 'page.composition.links[].to.ref.nestedPath[].key', category: 'connections', valueKind: 'string', description: 'Chave estavel do widget filho no segmento terminal de destino.', critical: true },
+    { path: 'page.composition.links[].to.ref.nestedPath[].index', category: 'connections', valueKind: 'number', description: 'Indice auxiliar para diagnostico visual; nao use como identidade primaria.' },
+    { path: 'page.composition.links[].to.ref.nestedPath[].componentType', category: 'connections', valueKind: 'string', description: 'Tipo do componente real do widget filho de destino.' },
     { path: 'page.composition.links[].intent', category: 'connections', valueKind: 'string', description: 'Intencao semantica do link.' },
     { path: 'page.composition.links[].transform', category: 'connections', valueKind: 'object', description: 'Pipeline de transformacao do link.' },
     { path: 'page.composition.links[].condition', category: 'connections', valueKind: 'expression', description: 'Guarda semantica opcional do link, expressa como um unico AST Json Logic canonico.' },
     { path: 'page.composition.links[].policy', category: 'connections', valueKind: 'object', description: 'Politicas operacionais opcionais do link, como debounce, distinct e missing-value.' },
     { path: 'page.composition.links[].metadata', category: 'connections', valueKind: 'object', description: 'Metadados opcionais do link.' },
+    { path: 'page.grouping', category: 'layout', valueKind: 'array', description: 'Modelo semantico opcional de secoes, abas, areas hero e rails.' },
+    { path: 'page.grouping[].kind', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.groupingKind, description: 'Tipo do agrupamento semantico.' },
+    { path: 'page.grouping[].id', category: 'layout', valueKind: 'string', description: 'Identificador estavel do agrupamento.' },
+    { path: 'page.grouping[].label', category: 'layout', valueKind: 'string', description: 'Rotulo opcional do agrupamento.' },
+    { path: 'page.grouping[].widgetKeys', category: 'layout', valueKind: 'array', description: 'Widgets pertencentes ao agrupamento section, hero ou rail.' },
+    { path: 'page.grouping[].layout', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.groupingLayout, description: 'Layout opcional para agrupamento section.' },
+    { path: 'page.grouping[].tabs', category: 'layout', valueKind: 'array', description: 'Abas do agrupamento kind=tabs.' },
+    { path: 'page.grouping[].tabs[].id', category: 'layout', valueKind: 'string', description: 'Identificador estavel da aba.' },
+    { path: 'page.grouping[].tabs[].label', category: 'layout', valueKind: 'string', description: 'Rotulo da aba.' },
+    { path: 'page.grouping[].tabs[].widgetKeys', category: 'layout', valueKind: 'array', description: 'Widgets renderizados dentro da aba.' },
+    { path: 'page.grouping[].emphasis', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.heroEmphasis, description: 'Enfase opcional para agrupamento hero.' },
+    { path: 'page.grouping[].side', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.railSide, description: 'Lado do rail quando kind=rail.' },
+    { path: 'page.slotAssignments', category: 'layout', valueKind: 'object', description: 'Mapa canonico de widget key para slot semantico de preset.' },
+    { path: 'page.deviceLayouts', category: 'layout', valueKind: 'object', description: 'Variantes opcionais de layout por dispositivo.' },
+    { path: 'page.deviceLayouts.desktop', category: 'layout', valueKind: 'object', description: 'Overrides de layout para desktop.' },
+    { path: 'page.deviceLayouts.tablet', category: 'layout', valueKind: 'object', description: 'Overrides de layout para tablet.' },
+    { path: 'page.deviceLayouts.mobile', category: 'layout', valueKind: 'object', description: 'Overrides de layout para mobile.' },
+    { path: 'page.deviceLayouts.desktop.layout', category: 'layout', valueKind: 'object', description: 'Override de WidgetPageLayout para desktop.' },
+    { path: 'page.deviceLayouts.desktop.canvas', category: 'layout', valueKind: 'object', description: 'Override de canvas para desktop.' },
+    { path: 'page.deviceLayouts.desktop.groupingOverrides', category: 'layout', valueKind: 'array', description: 'Overrides de agrupamentos para desktop.' },
+    { path: 'page.deviceLayouts.desktop.widgetOverrides', category: 'layout', valueKind: 'object', description: 'Overrides por widget key para desktop.' },
+    { path: 'page.deviceLayouts.desktop.widgetOverrides.<widgetKey>.hidden', category: 'layout', valueKind: 'boolean', description: 'Oculta o widget em desktop.' },
+    { path: 'page.deviceLayouts.tablet.layout', category: 'layout', valueKind: 'object', description: 'Override de WidgetPageLayout para tablet.' },
+    { path: 'page.deviceLayouts.tablet.canvas', category: 'layout', valueKind: 'object', description: 'Override de canvas para tablet.' },
+    { path: 'page.deviceLayouts.tablet.groupingOverrides', category: 'layout', valueKind: 'array', description: 'Overrides de agrupamentos para tablet.' },
+    { path: 'page.deviceLayouts.tablet.widgetOverrides', category: 'layout', valueKind: 'object', description: 'Overrides por widget key para tablet.' },
+    { path: 'page.deviceLayouts.tablet.widgetOverrides.<widgetKey>.hidden', category: 'layout', valueKind: 'boolean', description: 'Oculta o widget em tablet.' },
+    { path: 'page.deviceLayouts.mobile.layout', category: 'layout', valueKind: 'object', description: 'Override de WidgetPageLayout para mobile.' },
+    { path: 'page.deviceLayouts.mobile.canvas', category: 'layout', valueKind: 'object', description: 'Override de canvas para mobile.' },
+    { path: 'page.deviceLayouts.mobile.groupingOverrides', category: 'layout', valueKind: 'array', description: 'Overrides de agrupamentos para mobile.' },
+    { path: 'page.deviceLayouts.mobile.widgetOverrides', category: 'layout', valueKind: 'object', description: 'Overrides por widget key para mobile.' },
+    { path: 'page.deviceLayouts.mobile.widgetOverrides.<widgetKey>.hidden', category: 'layout', valueKind: 'boolean', description: 'Oculta o widget em mobile.' },
 ];
 const DYNAMIC_PAGE_AI_CAPABILITIES = {
-    version: 'v1.0',
+    version: 'v1.1',
     enums: ENUMS,
     targets: ['praxis-dynamic-page'],
     notes: [
-        'Este catalogo e especifico para o componente praxis-dynamic-page.',
-        'Widgets e page.composition.links sao arrays; o adapter faz merge por key estavel.',
+        'Este catalogo e especifico para o runtime praxis-dynamic-page; operacoes de authoring/mutacao pertencem ao manifesto do praxis-page-builder.',
+        'WidgetPageDefinition e o contrato canonico persistido: widgets, composition.links, state, context, layout, canvas, presets, grouping, slotAssignments, deviceLayouts e themePreset.',
+        'Widgets e page.composition.links sao arrays; ferramentas de patch legadas fazem merge por key estavel e id estavel.',
+        'page.canvas.items e um mapa por widget key; nao modele canvas.items como array.',
         'Taxonomia editorial: condition usa Json Logic canonico; transform usa pipeline declarativo; nao trate ambos como a mesma "expression".',
         'Para remocao/replace, use flags {_remove:true} ou {_replace:true} no item.',
         'Para renomear um link, inclua {_beforeKey:"link-id-anterior"} no item.',
         'Inputs de widgets dependem do componente (ex: praxis-table, praxis-dynamic-form). Evite inventar campos; prefira pedir confirmacao.',
         'Use ids estaveis para links e keys estaveis para widgets.',
+        'Nested component ports usam endpoint component-port com nestedPath; o owner em ref.widget continua sendo o widget top-level.',
         'Objetivo: compor widgets e relacionamentos canonicos (ex.: master-detail).',
         'Link tipico de master-detail: component-port(table.rowClick) -> component-port(form.resourceId) com transform map payload.row.id.',
     ],
@@ -18792,6 +19510,75 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { value: 'columns', label: 'Colunas' },
             ],
         },
+        'page.canvas.mode': {
+            mode: 'enum',
+            options: [
+                { value: 'grid', label: 'Grid' },
+            ],
+        },
+        'page.canvas.autoRows': {
+            mode: 'enum',
+            options: [
+                { value: 'fixed', label: 'Linhas fixas' },
+                { value: 'content', label: 'Conteudo' },
+            ],
+        },
+        'page.canvas.collisionPolicy': {
+            mode: 'enum',
+            options: [
+                { value: 'block', label: 'Bloquear colisao' },
+                { value: 'swap', label: 'Trocar posicao' },
+            ],
+        },
+        'page.grouping[].kind': {
+            mode: 'enum',
+            options: [
+                { value: 'section', label: 'Secao' },
+                { value: 'tabs', label: 'Abas' },
+                { value: 'hero', label: 'Hero' },
+                { value: 'rail', label: 'Rail' },
+            ],
+        },
+        'page.grouping[].layout': {
+            mode: 'enum',
+            options: [
+                { value: 'stack', label: 'Empilhado' },
+                { value: 'grid', label: 'Grid' },
+                { value: 'row', label: 'Linha' },
+            ],
+        },
+        'page.grouping[].emphasis': {
+            mode: 'enum',
+            options: [
+                { value: 'high', label: 'Alta' },
+                { value: 'medium', label: 'Media' },
+            ],
+        },
+        'page.grouping[].side': {
+            mode: 'enum',
+            options: [
+                { value: 'left', label: 'Esquerda' },
+                { value: 'right', label: 'Direita' },
+            ],
+        },
+        'page.state.schema.<token>.mergeStrategy': {
+            mode: 'enum',
+            options: [
+                { value: 'replace', label: 'Substituir' },
+                { value: 'merge', label: 'Mesclar' },
+                { value: 'append', label: 'Acrescentar' },
+                { value: 'remove-keys', label: 'Remover chaves' },
+            ],
+        },
+        'page.state.derived.<token>.compute.kind': {
+            mode: 'enum',
+            options: [
+                { value: 'json-logic', label: 'Json Logic' },
+                { value: 'template', label: 'Template' },
+                { value: 'operator', label: 'Operador' },
+                { value: 'transformer', label: 'Transformer' },
+            ],
+        },
         'page.widgets[].shell.kind': {
             mode: 'enum',
             options: [
@@ -19336,7 +20123,10 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
         'page.composition.links[]': ['id'],
     },
     hints: [
-        'praxis-dynamic-page e um host de composicao: cria widgets, conecta ports canonicos e mantem relacoes em page.composition.links.',
+        'praxis-dynamic-page e runtime de composicao: consome WidgetPageDefinition, renderiza widgets e mantem relacoes em page.composition.links.',
+        'Mutacoes agentic de pagina pertencem ao manifesto do praxis-page-builder; use este context pack como descoberta/runtime guidance.',
+        'WidgetPageDefinition inclui widgets, composition.links, state, context, layout, canvas, layoutPreset, layoutPresetOptions, grouping, slotAssignments, deviceLayouts e themePreset.',
+        'page.canvas.items e um mapa por widget key, nao um array; cada entrada guarda col, row, colSpan, rowSpan, zIndex e constraints opcionais.',
         'Widgets e composition.links sao arrays; o patching deve fazer merge por key (widgets) e por id (links).',
         'Preferir mudancas incrementais: alterar/estender em vez de substituir toda a pagina.',
         'Para remover um item, envie {_remove: true} junto ao widget/link.',
@@ -28983,4 +29773,4 @@ function provideHookWhitelist(allowed) {
  * Generated bundle index. Do not edit.
  */
 
-export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, AnalyticsPresentationResolver, AnalyticsSchemaContractService, AnalyticsStatsRequestBuilderService, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, CompositionRuntimeFacade, ConsoleLoggerSink, CrudOperationResolutionService, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_JSON_LOGIC_OPERATORS, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_SURFACE_SERVICE, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NestedPortCatalogService, NestedWidgetConfigAccessor, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_JSON_LOGIC_OPERATORS, PRAXIS_LAYER_SCALE_DEFAULTS, PRAXIS_LAYER_SCALE_VARS, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisJsonLogicError, PraxisJsonLogicService, PraxisLayerScaleStyleService, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RESOURCE_DISCOVERY_I18N_CONFIG, RESOURCE_DISCOVERY_I18N_NAMESPACE, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceActionOpenAdapterService, ResourceDiscoveryService, ResourceQuickConnectComponent, ResourceSurfaceOpenAdapterService, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_DRAWER_BRIDGE, SURFACE_OPEN_I18N_CONFIG, SURFACE_OPEN_I18N_NAMESPACE, SURFACE_OPEN_PRESETS, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, SurfaceBindingRuntimeService, SurfaceOpenActionEditorComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildPraxisLayerScaleCss, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createEmptyRichContentDocument, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionPayloadActualType, getGlobalActionPayloadTypeIssue, getGlobalActionUiSchema, getMissingGlobalActionPayloadKeys, getReferencedFieldMetadata, getRequiredGlobalActionPayloadKeys, getTextTransformer, hasMeaningfulGlobalActionPayloadValue, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isGlobalActionRef, isInlineFilterControlType, isRangeValidForFilter, isRequiredGlobalActionParamPayloadMissing, isRequiredGlobalActionPayloadMissing, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, migrateLegacyCompositionLink, migrateLegacyCompositionLinks, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizeGlobalActionRef, normalizePath, normalizePraxisDataQueryContext, normalizeResourceAvailabilityReasonCode, normalizeStart, normalizeUnknownError, normalizeWidgetEventPath, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisIconDefaults, providePraxisJsonLogicOperator, providePraxisJsonLogicOperatorOverride, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveDefaultValuePresentationFormat, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolvePraxisFilterCriteria, resolveResourceAvailabilityReasonKey, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, translateResourceAvailabilityReason, translateResourceDiscoveryText, translateUnavailableWorkflowMessage, trim, uniqueAsyncValidator, urlValidator, validateGlobalActionRef, validateGlobalActionRefs, withMessage, withPraxisHttpLoading };
+export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, AnalyticsPresentationResolver, AnalyticsSchemaContractService, AnalyticsStatsRequestBuilderService, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, CompositionRuntimeFacade, ConsoleLoggerSink, CrudOperationResolutionService, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_JSON_LOGIC_OPERATORS, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_SURFACE_SERVICE, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NestedPortCatalogService, NestedWidgetConfigAccessor, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_COLLECTION_EXPORT_HTTP_OPTIONS, PRAXIS_COLLECTION_EXPORT_PROVIDER, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_EXPORT_SECURITY_POLICY, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_EXPORT_FORMULA_PREFIXES, PRAXIS_EXPORT_SECURITY_POLICY, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_JSON_LOGIC_OPERATORS, PRAXIS_LAYER_SCALE_DEFAULTS, PRAXIS_LAYER_SCALE_VARS, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCollectionExportService, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisHttpCollectionExportProvider, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisJsonLogicError, PraxisJsonLogicService, PraxisLayerScaleStyleService, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RESOURCE_DISCOVERY_I18N_CONFIG, RESOURCE_DISCOVERY_I18N_NAMESPACE, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceActionOpenAdapterService, ResourceDiscoveryService, ResourceQuickConnectComponent, ResourceSurfaceOpenAdapterService, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_DRAWER_BRIDGE, SURFACE_OPEN_I18N_CONFIG, SURFACE_OPEN_I18N_NAMESPACE, SURFACE_OPEN_PRESETS, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, SurfaceBindingRuntimeService, SurfaceOpenActionEditorComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, assertPraxisCollectionExportArtifact, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildPraxisLayerScaleCss, buildSchemaId, buildSchemaIdStorageKeySegment, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createEmptyRichContentDocument, createFieldLayoutItem, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, escapePraxisExportCell, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getFormColumnFieldNames, getFormLayoutFieldNames, getGlobalActionCatalog, getGlobalActionPayloadActualType, getGlobalActionPayloadTypeIssue, getGlobalActionUiSchema, getMissingGlobalActionPayloadKeys, getReferencedFieldMetadata, getRequiredGlobalActionPayloadKeys, getTextTransformer, hasMeaningfulGlobalActionPayloadValue, hasPraxisCollectionExportArtifact, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isFormLayoutItem, isGlobalActionRef, isInlineFilterControlType, isRangeValidForFilter, isRequiredGlobalActionParamPayloadMissing, isRequiredGlobalActionPayloadMissing, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, migrateLegacyCompositionLink, migrateLegacyCompositionLinks, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormLayoutItems, normalizeFormMetadata, normalizeGlobalActionRef, normalizePath, normalizePraxisDataQueryContext, normalizeResourceAvailabilityReasonCode, normalizeStart, normalizeUnknownError, normalizeWidgetEventPath, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisCollectionExportProvider, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpCollectionExportProvider, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisIconDefaults, providePraxisJsonLogicOperator, providePraxisJsonLogicOperatorOverride, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, readPraxisExportValue, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveDefaultValuePresentationFormat, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolvePraxisCollectionExportItems, resolvePraxisExportFields, resolvePraxisExportScope, resolvePraxisFilterCriteria, resolveResourceAvailabilityReasonKey, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, serializePraxisCollectionToCsv, serializePraxisCollectionToJson, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, translateResourceAvailabilityReason, translateResourceDiscoveryText, translateUnavailableWorkflowMessage, trim, uniqueAsyncValidator, urlValidator, validateGlobalActionRef, validateGlobalActionRefs, withMessage, withPraxisHttpLoading };