@praxisui/crud 8.0.0-beta.2 → 8.0.0-beta.20

package/README.md

@@ -353,6 +353,39 @@ Direcao de plataforma:
 - a semantica canonica continua cobrindo metadata, tabela interna, formulario, actions, open modes e persistencia/reabertura
 - hosts consumidores devem permanecer como demonstradores do contrato, nao como donos de um editor paralelo
 
+## Agentic Authoring Contract
+
+`PRAXIS_CRUD_AUTHORING_MANIFEST` is the executable AI authoring contract for `@praxisui/crud`.
+
+The manifest owns CRUD orchestration only:
+
+- `resource.path`, `resourceKey`, `idField`, endpoint key and query context binding
+- list surface orchestration and stable `crudContext`
+- create/edit/view action open mode, route, form binding, params, `initialValue` and back policy
+- delete enablement, confirmation, canonical submit contract and capability policy
+- dialog/drawer/route defaults consumed by `CrudLauncherService`
+- permissions derived from resource capabilities
+
+The manifest does not own child component semantics:
+
+- `TableConfig` edits must delegate to `praxis-table`
+- `FormConfig` and `FieldMetadata` edits must delegate to `praxis-dynamic-form` or `praxis-metadata-editor`
+- dialog shell changes outside CRUD defaults must delegate to `praxis-dialog` or `praxis-settings-panel`
+
+Governed operation families:
+
+- `resource.bind`
+- `list.surface.configure`
+- `surface.create.configure`
+- `surface.edit.configure`
+- `surface.view.configure`
+- `delete.enabled.set`
+- `dialog.size.set`
+- `permissions.set`
+- `form.childOperation.delegate`
+
+Stable identities are resource path/key, `crudId`, action id and child operation id. Array indexes are not canonical identities. Destructive delete behavior requires explicit confirmation and backend capability support.
+
 To build the library, run:
 
 ```bash

package/fesm2022/praxisui-crud.mjs

@@ -3409,7 +3409,7 @@ class PraxisCrudComponent {
     async onAction(action, row, runtimeEvent) {
         try {
             document.activeElement?.blur();
-            const openedByDiscovery = await this.tryOpenDiscoveredCrudSurface(action, row);
+            const openedByDiscovery = await this.tryOpenDiscoveredCrudSurface(action, row, runtimeEvent);
             if (openedByDiscovery) {
                 return;
             }
@@ -3704,17 +3704,27 @@ class PraxisCrudComponent {
     resolveFilterCriteria(meta) {
         return this.isRecord(meta?.filterCriteria) ? { ...meta.filterCriteria } : {};
     }
-    async tryOpenDiscoveredCrudSurface(action, row) {
+    async tryOpenDiscoveredCrudSurface(action, row, runtimeEvent) {
         const normalizedAction = String(action || '').trim().toLowerCase();
-        if (!this.isDiscoveryManagedCrudAction(normalizedAction) || !this.surfaceService) {
+        if (!this.surfaceService) {
             return false;
         }
-        const catalog = await this.resolveDiscoveredSurfaceCatalog(normalizedAction, row);
-        const surface = this.selectSurfaceForCrudAction(normalizedAction, catalog?.surfaces || []);
+        const providedSurface = this.resolveProvidedSurface(normalizedAction, runtimeEvent?.actionConfig);
+        if (!providedSurface && !this.isDiscoveryManagedCrudAction(normalizedAction)) {
+            return false;
+        }
+        const catalog = providedSurface
+            ? null
+            : await this.resolveDiscoveredSurfaceCatalog(normalizedAction, row);
+        const surface = providedSurface || this.selectSurfaceForCrudAction(normalizedAction, catalog?.surfaces || []);
         const resourcePath = String(catalog?.resourcePath || this.resolveResourcePath(this.resolvedMetadata) || '').trim();
-        if (!catalog || !surface || !resourcePath) {
+        if (!surface || !resourcePath) {
             return false;
         }
+        if (surface.availability?.allowed === false) {
+            this.snack.open(translateUnavailableWorkflowMessage(this.i18n, surface.availability), undefined, { duration: 2500 });
+            return true;
+        }
         let payload;
         try {
             payload = this.surfaceOpenAdapter.toPayload(surface, {
@@ -3722,7 +3732,7 @@ class PraxisCrudComponent {
                 resourceId: this.resolveRowResourceId(row),
                 endpointKey: this.resolvedMetadata?.resource?.endpointKey,
                 apiUrlEntry: this.resolveDiscoveryApiEntry(),
-                group: catalog.group ?? null,
+                group: catalog?.group ?? null,
             });
         }
         catch {
@@ -3880,6 +3890,23 @@ class PraxisCrudComponent {
         }
         return candidate;
     }
+    resolveProvidedSurface(action, candidate) {
+        if (!candidate || typeof candidate !== 'object') {
+            return null;
+        }
+        const normalizedId = String(candidate.id || '').trim().toLowerCase();
+        if (!normalizedId || normalizedId !== action) {
+            return null;
+        }
+        const surface = candidate;
+        if (!surface.kind || !surface.scope || !surface.path || !surface.method) {
+            return null;
+        }
+        if (!this.isWritableCrudSurface(surface) && !this.isReadableCrudSurface(surface)) {
+            return null;
+        }
+        return surface;
+    }
     selectSurfaceForCrudAction(action, surfaces) {
         const candidates = surfaces
             .filter((surface) => surface.availability?.allowed !== false)
@@ -4412,7 +4439,7 @@ class PraxisCrudComponent {
         />
       }
     }
-  `, isInline: true, styles: [":host{display:block;width:100%;min-width:0;max-width:100%}\n"], dependencies: [{ kind: "component", type: PraxisTable, selector: "praxis-table", inputs: ["config", "resourcePath", "data", "tableId", "componentInstanceId", "title", "subtitle", "icon", "autoDelete", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "crudContext", "filterCriteria", "queryContext", "enableCustomization", "dense"], outputs: ["rowClick", "rowDoubleClick", "rowExpansionChange", "rowAction", "toolbarAction", "bulkAction", "columnReorder", "columnReorderAttempt", "beforeDelete", "afterDelete", "deleteError", "beforeBulkDelete", "afterBulkDelete", "bulkDeleteError", "schemaStatusChange", "metadataChange", "loadingStateChange", "collectionLinksChange", "selectionChange"] }, { kind: "component", type: EmptyStateCardComponent, selector: "praxis-empty-state-card", inputs: ["icon", "title", "description", "primaryAction", "secondaryActions", "inline", "tone"] }] });
+  `, isInline: true, styles: [":host{display:block;width:100%;min-width:0;max-width:100%}\n"], dependencies: [{ kind: "component", type: PraxisTable, selector: "praxis-table", inputs: ["config", "resourcePath", "data", "tableId", "componentInstanceId", "title", "subtitle", "icon", "autoDelete", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "crudContext", "filterCriteria", "queryContext", "enableCustomization", "dense"], outputs: ["rowClick", "rowDoubleClick", "rowExpansionChange", "rowAction", "toolbarAction", "bulkAction", "exportAction", "columnReorder", "columnReorderAttempt", "beforeDelete", "afterDelete", "deleteError", "beforeBulkDelete", "afterBulkDelete", "bulkDeleteError", "schemaStatusChange", "metadataChange", "loadingStateChange", "collectionLinksChange", "selectionChange"] }, { kind: "component", type: EmptyStateCardComponent, selector: "praxis-empty-state-card", inputs: ["icon", "title", "description", "primaryAction", "secondaryActions", "inline", "tone"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCrudComponent, decorators: [{
             type: Component,
@@ -4830,7 +4857,7 @@ class DynamicFormDialogHostComponent {
         (formCancel)="onCancel()"
       ></praxis-dynamic-form>
     </mat-dialog-content>
-  `, isInline: true, styles: [":host{--dlg-header-h: 56px;--dlg-footer-h: 56px;--dlg-pad: 16px;display:flex;flex-direction:column;height:100%;overflow:hidden}:host([data-density=\"compact\"]){--dlg-header-h: 44px;--dlg-footer-h: 44px;--dlg-pad: 12px}.dialog-header{position:sticky;top:0;z-index:1;display:flex;align-items:center;gap:var(--dlg-pad);padding:0 var(--dlg-pad);height:var(--dlg-header-h);margin:0;background:var(--md-sys-color-surface-container-high);border-bottom:1px solid var(--md-sys-color-outline-variant);color:var(--md-sys-color-on-surface)}.dialog-title{margin:0;font:inherit;font-weight:600;color:var(--md-sys-color-on-surface)}.spacer{flex:1}.dialog-content{overflow:auto;padding:var(--dlg-pad);max-height:calc(100svh - var(--dlg-header-h) - 32px)}.dialog-header button.mat-icon-button{color:var(--md-sys-color-on-surface-variant)}.dialog-header button.mat-icon-button:hover{color:var(--md-sys-color-primary);background:var(--md-sys-color-primary-container)}.dialog-footer{position:sticky;bottom:0;z-index:1;padding:var(--dlg-pad)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: PraxisDynamicForm, selector: "praxis-dynamic-form", inputs: ["resourcePath", "resourceId", "initialValue", "editorialContext", "mode", "config", "actions", "schemaSource", "schemaUrl", "submitUrl", "submitMethod", "responseSchemaUrl", "apiEndpointKey", "apiUrlEntry", "enableCustomization", "formId", "componentInstanceId", "layout", "backConfig", "hooks", "removeEmptyContainersOnSave", "reactiveValidation", "reactiveValidationDebounceMs", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "readonlyModeGlobal", "disabledModeGlobal", "presentationModeGlobal", "visibleGlobal", "customEndpoints"], outputs: ["formSubmit", "formCancel", "formReset", "configChange", "formReady", "valueChange", "syncCompleted", "initializationError", "loadingStateChange", "enableCustomizationChange", "customAction", "actionConfirmation", "schemaStatusChange", "fieldRenderError"] }] });
+  `, isInline: true, styles: [":host{--dlg-header-h: 56px;--dlg-footer-h: 56px;--dlg-pad: 16px;display:flex;flex-direction:column;height:100%;overflow:hidden}:host([data-density=\"compact\"]){--dlg-header-h: 44px;--dlg-footer-h: 44px;--dlg-pad: 12px}.dialog-header{position:sticky;top:0;z-index:1;display:flex;align-items:center;gap:var(--dlg-pad);padding:0 var(--dlg-pad);height:var(--dlg-header-h);margin:0;background:var(--md-sys-color-surface-container-high);border-bottom:1px solid var(--md-sys-color-outline-variant);color:var(--md-sys-color-on-surface)}.dialog-title{margin:0;font:inherit;font-weight:600;color:var(--md-sys-color-on-surface)}.spacer{flex:1}.dialog-content{overflow:auto;padding:var(--dlg-pad);max-height:calc(100svh - var(--dlg-header-h) - 32px)}.dialog-header button.mat-icon-button{color:var(--md-sys-color-on-surface-variant)}.dialog-header button.mat-icon-button:hover{color:var(--md-sys-color-primary);background:var(--md-sys-color-primary-container)}.dialog-footer{position:sticky;bottom:0;z-index:1;padding:var(--dlg-pad)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: PraxisDynamicForm, selector: "praxis-dynamic-form", inputs: ["resourcePath", "resourceId", "initialValue", "editorialContext", "mode", "config", "actions", "schemaSource", "schemaUrl", "submitUrl", "submitMethod", "responseSchemaUrl", "apiEndpointKey", "apiUrlEntry", "enableCustomization", "formId", "componentInstanceId", "layout", "backConfig", "hooks", "removeEmptyContainersOnSave", "reactiveValidation", "reactiveValidationDebounceMs", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "readonlyModeGlobal", "disabledModeGlobal", "presentationModeGlobal", "visibleGlobal", "domainRules", "customEndpoints"], outputs: ["formSubmit", "formCancel", "formReset", "configChange", "formReady", "valueChange", "syncCompleted", "initializationError", "loadingStateChange", "enableCustomizationChange", "customAction", "actionConfirmation", "schemaStatusChange", "fieldRenderError", "ruleDiagnosticsChange"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicFormDialogHostComponent, decorators: [{
             type: Component,
@@ -5263,6 +5290,12 @@ const CRUD_AI_CAPABILITIES = {
         { path: 'resource.path', category: 'resource', valueKind: 'string', description: 'Endpoint base do recurso.' },
         { path: 'resource.idField', category: 'resource', valueKind: 'string', description: 'Campo identificador do recurso.' },
         { path: 'resource.endpointKey', category: 'resource', valueKind: 'string', description: 'Chave de endpoint (ApiEndpoint).' },
+        { path: 'queryContext.meta.domainCatalog', category: 'resource', valueKind: 'object', description: 'Referencia leve para contexto semantico/governanca resolvido via Domain Catalog; nao materializa regras em FormConfig.' },
+        { path: 'queryContext.meta.domainCatalog.schemaVersion', category: 'resource', valueKind: 'string', description: 'Versao do contrato DomainCatalogContextHint usado em runtime e prompts.' },
+        { path: 'queryContext.meta.domainCatalog.resourceKey', category: 'resource', valueKind: 'string', description: 'ResourceKey semantico estavel usado para resolver vocabulario/governanca de dominio.' },
+        { path: 'queryContext.meta.domainCatalog.releaseId', category: 'resource', valueKind: 'string', description: 'Release opcional do Domain Catalog usada como fonte do contexto.' },
+        { path: 'queryContext.meta.domainCatalog.query', category: 'resource', valueKind: 'string', description: 'Probe de campo/conceito usado para buscar itens relevantes, como cpf, salario ou status.' },
+        { path: 'queryContext.meta.domainCatalog.intent', category: 'resource', valueKind: 'enum', allowedValues: ['authoring', 'explain', 'validate', 'ai-access-control'], description: 'Intencao de uso do contexto para orientar LLMs e validadores sem expor dados alem do necessario.' },
         // --- Table / Form ---
         { path: 'table', category: 'table', valueKind: 'object', description: 'TableConfig completo (usar catalogo de tabela).' },
         { path: 'form', category: 'form', valueKind: 'object', description: 'FormConfig completo (usar catalogo de formulario).' },
@@ -5319,6 +5352,438 @@ const CRUD_AI_CAPABILITIES = {
     ],
 };
 
+const resourceBindSchema = {
+    type: 'object',
+    required: ['resourcePath'],
+    properties: {
+        resourcePath: { type: 'string' },
+        resourceKey: { type: 'string' },
+        idField: { type: ['string', 'number'] },
+        endpointKey: { type: 'string' },
+        queryContext: { type: 'object' },
+    },
+};
+const surfaceConfigureSchema = {
+    type: 'object',
+    required: ['actionId', 'openMode'],
+    properties: {
+        actionId: { enum: ['create', 'edit', 'view'] },
+        openMode: { enum: ['route', 'modal', 'drawer'] },
+        route: { type: 'string' },
+        formId: { type: 'string' },
+        form: {
+            type: 'object',
+            properties: {
+                schemaUrl: { type: 'string' },
+                submitUrl: { type: 'string' },
+                submitMethod: { enum: ['post', 'put', 'patch', 'delete'] },
+                apiEndpointKey: { type: 'string' },
+                initialValue: { type: 'object' },
+            },
+        },
+        params: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['from', 'to', 'name'],
+                properties: {
+                    from: { type: 'string' },
+                    to: { enum: ['routeParam', 'query', 'input'] },
+                    name: { type: 'string' },
+                },
+            },
+        },
+        back: { type: 'object' },
+    },
+};
+const listSurfaceSchema = {
+    type: 'object',
+    properties: {
+        tablePatch: { type: 'object' },
+        queryContext: { type: 'object' },
+        filterCriteria: { type: 'object' },
+    },
+};
+const deleteBehaviorSchema = {
+    type: 'object',
+    required: ['enabled'],
+    properties: {
+        enabled: { type: 'boolean' },
+        actionId: { type: 'string' },
+        requiresConfirmation: { type: 'boolean' },
+        autoDelete: { type: 'boolean' },
+        form: {
+            type: 'object',
+            properties: {
+                submitUrl: { type: 'string' },
+                submitMethod: { enum: ['delete'] },
+                apiEndpointKey: { type: 'string' },
+            },
+        },
+    },
+};
+const dialogHostSchema = {
+    type: 'object',
+    properties: {
+        defaultOpenMode: { enum: ['route', 'modal', 'drawer'] },
+        modal: {
+            type: 'object',
+            properties: {
+                width: { type: 'string' },
+                height: { type: 'string' },
+                minWidth: { type: 'string' },
+                maxWidth: { type: 'string' },
+                density: { type: 'string' },
+                canMaximize: { type: 'boolean' },
+                rememberLastState: { type: 'boolean' },
+                startMaximized: { type: 'boolean' },
+                disableCloseOnEsc: { type: 'boolean' },
+                disableCloseOnBackdrop: { type: 'boolean' },
+                fullscreenBreakpoint: { type: 'string' },
+            },
+        },
+        back: { type: 'object' },
+    },
+};
+const permissionsSchema = {
+    type: 'object',
+    properties: {
+        requiredCapabilities: {
+            type: 'array',
+            items: { enum: ['create', 'view', 'edit', 'delete'] },
+        },
+        actionPermissions: { type: 'object' },
+        denyWhenMissingCapability: { type: 'boolean' },
+    },
+};
+const domainGovernanceContextSchema = {
+    type: 'object',
+    required: ['resourceKey', 'query'],
+    properties: {
+        resourceKey: { type: 'string' },
+        releaseId: { type: 'string' },
+        query: { type: 'string' },
+        itemTypes: {
+            type: 'array',
+            items: { enum: ['governance', 'vocabulary', 'relationship'] },
+        },
+        intent: { enum: ['authoring', 'explain', 'validate', 'ai-access-control'] },
+    },
+};
+const childDelegateSchema = {
+    type: 'object',
+    required: ['childComponentId', 'childOperationId', 'reason'],
+    properties: {
+        childComponentId: { enum: ['praxis-dynamic-form', 'praxis-table', 'praxis-dialog', 'praxis-settings-panel'] },
+        childOperationId: { type: 'string' },
+        reason: { type: 'string' },
+        childTarget: { type: 'object' },
+        childParams: { type: 'object' },
+    },
+};
+const PRAXIS_CRUD_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-crud',
+    ownerPackage: '@praxisui/crud',
+    configSchemaId: 'CrudMetadata',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'metadata', type: 'CrudMetadata | string', description: 'Canonical CRUD metadata or serialized metadata document.' },
+        { name: 'crudId', type: 'string', description: 'Stable CRUD instance id used for table/form identity and persistence.' },
+        { name: 'componentInstanceId', type: 'string', description: 'Optional stable host instance id for multiple CRUD widgets on the same route.' },
+        { name: 'context', type: 'Record<string, unknown>', description: 'Opaque host context used for authoring seeds and launcher inputs.' },
+        { name: 'afterOpen', type: '{ mode: FormOpenMode; action: string }', description: 'Emitted after a CRUD action opens.' },
+        { name: 'afterSave', type: '{ id: string | number; data: unknown }', description: 'Emitted after save; CRUD refetches the list.' },
+        { name: 'afterDelete', type: '{ id: string | number }', description: 'Emitted after delete; CRUD refetches the list.' },
+    ],
+    editableTargets: [
+        { kind: 'resourceBinding', resolver: 'crud-resource-by-path-or-key', description: 'Resource path/key, id field, endpoint key and query context owned by CRUD orchestration.' },
+        { kind: 'listSurface', resolver: 'crud-list-surface', description: 'CRUD-hosted list surface and table delegation boundary.' },
+        { kind: 'createSurface', resolver: 'crud-action-by-id:create', description: 'Create action open mode, route/form binding and launcher inputs.' },
+        { kind: 'editSurface', resolver: 'crud-action-by-id:edit', description: 'Edit action open mode, route/form binding and launcher inputs.' },
+        { kind: 'viewSurface', resolver: 'crud-action-by-id:view', description: 'View action open mode, route/form binding and launcher inputs.' },
+        { kind: 'deleteBehavior', resolver: 'crud-action-by-id:delete', description: 'Delete action enablement, confirmation, endpoint and capability policy.' },
+        { kind: 'dialogHost', resolver: 'crud-dialog-host-defaults', description: 'Route/modal/drawer defaults consumed by CrudLauncherService and DynamicFormDialogHostComponent.' },
+        { kind: 'formBinding', resolver: 'crud-action-form-contract-by-action-id', description: 'CRUD-owned form binding fields: formId, schemaUrl, submitUrl, submitMethod, params and initialValue.' },
+        { kind: 'permissions', resolver: 'crud-resource-capabilities', description: 'CRUD action availability derived from resource capabilities and action permissions.' },
+        { kind: 'domainGovernanceContext', resolver: 'domain-catalog-context-by-resource-key', description: 'Read-only semantic/governance context resolved from Domain Catalog and referenced from CRUD queryContext.meta.' },
+        { kind: 'childOperation', resolver: 'child-authoring-manifest-operation', description: 'Delegated form/table/dialog/settings-panel operation owned by the child component manifest.' },
+    ],
+    operations: [
+        {
+            operationId: 'resource.bind',
+            title: 'Bind CRUD resource',
+            scope: 'dataBinding',
+            targetKind: 'resourceBinding',
+            target: { kind: 'resourceBinding', resolver: 'crud-resource-by-path-or-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: resourceBindSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-resource-bind', handlerContract: {
+                        reads: ['CrudMetadata.resource', 'api_metadata', 'ResourceDiscoveryService', 'GET /{resource}/capabilities'],
+                        writes: ['CrudMetadata.resource', 'CrudMetadata.queryContext', 'PraxisCrudComponent.tableCrudContext'],
+                        identityKeys: ['resourcePath', 'resourceKey'],
+                        inputSchema: resourceBindSchema,
+                        failureModes: ['resource-not-found', 'schema-url-not-canonical', 'capabilities-unavailable', 'id-field-missing'],
+                        description: 'Binds CRUD to a canonical resource and validates it against api_metadata/resource capabilities before runtime use.',
+                    } }],
+            validators: ['resource-exists-in-api-metadata', 'resource-path-canonical', 'resource-key-stable', 'id-field-known', 'resource-capabilities-resolvable'],
+            affectedPaths: ['resource.path', 'resource.idField', 'resource.endpointKey', 'queryContext', 'filterCriteria'],
+            submissionImpact: 'affects-remote-binding',
+            preconditions: ['crud-metadata-loaded', 'api-metadata-available'],
+        },
+        {
+            operationId: 'domain.governanceContext.attach',
+            title: 'Attach Domain Catalog governance context',
+            scope: 'dataBinding',
+            targetKind: 'domainGovernanceContext',
+            target: { kind: 'domainGovernanceContext', resolver: 'domain-catalog-context-by-resource-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: domainGovernanceContextSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-domain-governance-context-attach', handlerContract: {
+                        reads: ['CrudMetadata.resource', 'CrudMetadata.queryContext', 'DomainCatalogService.getGovernanceContext', 'DOMAIN_CATALOG_COMPONENT_CONTEXT_PACK', 'api_metadata'],
+                        writes: ['CrudMetadata.queryContext.meta.domainCatalog'],
+                        identityKeys: ['resourceKey', 'releaseId', 'query'],
+                        inputSchema: domainGovernanceContextSchema,
+                        failureModes: ['resource-key-missing', 'domain-catalog-release-not-found', 'governance-context-empty', 'ai-usage-forbidden'],
+                        description: 'Resolves read-only domain vocabulary/governance context and stores only a lightweight reference/probe under queryContext.meta.domainCatalog.',
+                    } }],
+            validators: ['resource-key-stable', 'domain-catalog-context-resolvable', 'domain-catalog-read-only', 'ai-usage-visibility-respected', 'no-form-config-rule-materialization'],
+            affectedPaths: ['queryContext.meta.domainCatalog'],
+            submissionImpact: 'config-only',
+            preconditions: ['crud-metadata-loaded', 'api-metadata-available', 'domain-catalog-service-available'],
+        },
+        {
+            operationId: 'list.surface.configure',
+            title: 'Configure CRUD list surface',
+            scope: 'interaction',
+            targetKind: 'listSurface',
+            target: { kind: 'listSurface', resolver: 'crud-list-surface', ambiguityPolicy: 'fail', required: true },
+            inputSchema: listSurfaceSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-list-surface-configure', handlerContract: {
+                        reads: ['CrudMetadata.table', 'CrudMetadata.queryContext', 'PRAXIS_TABLE_AUTHORING_MANIFEST', 'CRUD_AI_CAPABILITIES'],
+                        writes: ['CrudMetadata.table', 'CrudMetadata.queryContext', 'CrudMetadata.filterCriteria'],
+                        identityKeys: ['crudId'],
+                        inputSchema: listSurfaceSchema,
+                        failureModes: ['table-operation-not-delegated', 'table-patch-not-supported', 'query-context-invalid'],
+                        description: 'Configures CRUD-owned list orchestration while routing table semantics to the praxis-table manifest.',
+                    } }],
+            validators: ['table-child-operation-delegated', 'query-context-valid', 'filter-criteria-bridge-valid', 'crud-context-stable'],
+            affectedPaths: ['table', 'queryContext', 'filterCriteria'],
+            submissionImpact: 'config-only',
+            preconditions: ['crud-metadata-loaded', 'praxis-table-manifest-available'],
+        },
+        {
+            operationId: 'surface.create.configure',
+            title: 'Configure create surface',
+            scope: 'interaction',
+            targetKind: 'createSurface',
+            target: { kind: 'createSurface', resolver: 'crud-action-by-id:create', ambiguityPolicy: 'fail', required: true },
+            inputSchema: surfaceConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-create-surface-configure', handlerContract: {
+                        reads: ['CrudMetadata.actions', 'CrudLauncherService.resolveOpenMode', 'DynamicFormDialogHostComponent', 'api_metadata'],
+                        writes: ['CrudMetadata.actions[]', 'CrudMetadata.actions[].form', 'CrudMetadata.actions[].params', 'CrudMetadata.actions[].back'],
+                        identityKeys: ['actionId'],
+                        inputSchema: surfaceConfigureSchema,
+                        failureModes: ['action-not-found', 'open-mode-binding-incomplete', 'schema-url-not-canonical', 'submit-url-not-canonical', 'resource-create-not-supported'],
+                        description: 'Configures create action binding and launcher inputs without editing the child FormConfig.',
+                    } }],
+            validators: ['action-exists', 'open-mode-binding-complete', 'schema-url-canonical', 'submit-url-canonical', 'resource-create-supported', 'form-child-operation-delegated'],
+            affectedPaths: ['actions[].openMode', 'actions[].route', 'actions[].formId', 'actions[].form', 'actions[].params', 'actions[].back'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['crud-metadata-loaded', 'resource-capabilities-resolved'],
+        },
+        {
+            operationId: 'surface.edit.configure',
+            title: 'Configure edit surface',
+            scope: 'interaction',
+            targetKind: 'editSurface',
+            target: { kind: 'editSurface', resolver: 'crud-action-by-id:edit', ambiguityPolicy: 'fail', required: true },
+            inputSchema: surfaceConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-edit-surface-configure', handlerContract: {
+                        reads: ['CrudMetadata.actions', 'CrudMetadata.resource.idField', 'CrudLauncherService.resolveOpenMode', 'api_metadata'],
+                        writes: ['CrudMetadata.actions[]', 'CrudMetadata.actions[].form', 'CrudMetadata.actions[].params', 'CrudMetadata.actions[].back'],
+                        identityKeys: ['actionId'],
+                        inputSchema: surfaceConfigureSchema,
+                        failureModes: ['action-not-found', 'id-param-missing', 'open-mode-binding-incomplete', 'resource-edit-not-supported', 'submit-url-not-canonical'],
+                        description: 'Configures edit action routing/form binding and ensures id parameter mapping is available to the launcher.',
+                    } }],
+            validators: ['action-exists', 'id-field-known', 'id-param-mapping-valid', 'open-mode-binding-complete', 'schema-url-canonical', 'submit-url-canonical', 'resource-edit-supported', 'form-child-operation-delegated'],
+            affectedPaths: ['actions[].openMode', 'actions[].route', 'actions[].formId', 'actions[].form', 'actions[].params', 'actions[].back'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['crud-metadata-loaded', 'resource-capabilities-resolved'],
+        },
+        {
+            operationId: 'surface.view.configure',
+            title: 'Configure view surface',
+            scope: 'interaction',
+            targetKind: 'viewSurface',
+            target: { kind: 'viewSurface', resolver: 'crud-action-by-id:view', ambiguityPolicy: 'fail', required: true },
+            inputSchema: surfaceConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-view-surface-configure', handlerContract: {
+                        reads: ['CrudMetadata.actions', 'CrudLauncherService.resolveOpenMode', 'DynamicFormDialogHostComponent', 'api_metadata'],
+                        writes: ['CrudMetadata.actions[]', 'CrudMetadata.actions[].form', 'CrudMetadata.actions[].params', 'CrudMetadata.actions[].back'],
+                        identityKeys: ['actionId'],
+                        inputSchema: surfaceConfigureSchema,
+                        failureModes: ['action-not-found', 'open-mode-binding-incomplete', 'resource-view-not-supported', 'readonly-form-delegation-missing'],
+                        description: 'Configures view action binding and delegates readonly form behavior to the dynamic-form manifest.',
+                    } }],
+            validators: ['action-exists', 'open-mode-binding-complete', 'schema-url-canonical', 'resource-view-supported', 'form-child-operation-delegated', 'readonly-form-delegation-valid'],
+            affectedPaths: ['actions[].openMode', 'actions[].route', 'actions[].formId', 'actions[].form', 'actions[].params', 'actions[].back'],
+            submissionImpact: 'config-only',
+            preconditions: ['crud-metadata-loaded', 'resource-capabilities-resolved'],
+        },
+        {
+            operationId: 'delete.enabled.set',
+            title: 'Configure delete behavior',
+            scope: 'interaction',
+            targetKind: 'deleteBehavior',
+            target: { kind: 'deleteBehavior', resolver: 'crud-action-by-id:delete', ambiguityPolicy: 'fail', required: true },
+            inputSchema: deleteBehaviorSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-delete-behavior-set', handlerContract: {
+                        reads: ['CrudMetadata.actions', 'CrudMetadata.resource', 'GET /{resource}/{id}/capabilities'],
+                        writes: ['CrudMetadata.actions[]', 'CrudMetadata.actions[].requiresConfirmation', 'CrudMetadata.actions[].autoDelete', 'CrudMetadata.actions[].form'],
+                        identityKeys: ['actionId'],
+                        inputSchema: deleteBehaviorSchema,
+                        failureModes: ['delete-action-not-found', 'resource-delete-not-supported', 'destructive-delete-not-confirmed', 'delete-submit-url-not-canonical'],
+                        description: 'Enables or disables delete behavior with capability checks and explicit confirmation for destructive changes.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['delete-action-exists', 'resource-delete-supported', 'destructive-delete-confirmed', 'submit-url-canonical', 'permissions-delete-valid'],
+            affectedPaths: ['actions[].disabled', 'actions[].requiresConfirmation', 'actions[].autoDelete', 'actions[].form', 'actions[].form.submitUrl', 'actions[].form.submitMethod', 'actions[].form.apiEndpointKey'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['crud-metadata-loaded', 'resource-capabilities-resolved', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'dialog.size.set',
+            title: 'Configure CRUD dialog host defaults',
+            scope: 'interaction',
+            targetKind: 'dialogHost',
+            target: { kind: 'dialogHost', resolver: 'crud-dialog-host-defaults', ambiguityPolicy: 'fail', required: true },
+            inputSchema: dialogHostSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-dialog-host-set', handlerContract: {
+                        reads: ['CrudMetadata.defaults', 'CrudLauncherService.resolveOpenMode', 'DialogService', 'CRUD_DRAWER_ADAPTER'],
+                        writes: ['CrudMetadata.defaults.openMode', 'CrudMetadata.defaults.modal', 'CrudMetadata.defaults.back'],
+                        identityKeys: ['crudId'],
+                        inputSchema: dialogHostSchema,
+                        failureModes: ['open-mode-unsupported', 'drawer-adapter-missing', 'modal-size-invalid', 'back-policy-invalid'],
+                        description: 'Configures CRUD-owned route/modal/drawer defaults consumed by the launcher and dialog host.',
+                    } }],
+            validators: ['open-mode-supported', 'modal-size-valid', 'drawer-adapter-available-when-needed', 'back-policy-valid', 'settings-panel-shell-compatible'],
+            affectedPaths: ['defaults.openMode', 'defaults.modal', 'defaults.back'],
+            submissionImpact: 'config-only',
+            preconditions: ['crud-metadata-loaded'],
+        },
+        {
+            operationId: 'permissions.set',
+            title: 'Configure CRUD permissions',
+            scope: 'interaction',
+            targetKind: 'permissions',
+            target: { kind: 'permissions', resolver: 'crud-resource-capabilities', ambiguityPolicy: 'fail', required: true },
+            inputSchema: permissionsSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-permissions-set', handlerContract: {
+                        reads: ['GET /{resource}/capabilities', 'GET /{resource}/{id}/capabilities', 'CrudMetadata.actions'],
+                        writes: ['CrudMetadata.actions[].disabled', 'CrudMetadata.actions[].visibleWhen', 'CrudMetadata.actions[].requiresConfirmation'],
+                        identityKeys: ['resourcePath'],
+                        inputSchema: permissionsSchema,
+                        failureModes: ['capability-not-found', 'action-permission-conflict', 'delete-permission-without-confirmation'],
+                        description: 'Aligns CRUD action visibility/disablement with resource capabilities without inventing a second permission source.',
+                    } }],
+            validators: ['resource-capabilities-resolvable', 'action-permission-supported', 'delete-permission-requires-confirmation', 'permissions-do-not-shadow-backend'],
+            affectedPaths: ['actions[].disabled', 'actions[].visibleWhen', 'actions[].requiresConfirmation'],
+            submissionImpact: 'config-only',
+            preconditions: ['crud-metadata-loaded', 'resource-capabilities-resolved'],
+        },
+        {
+            operationId: 'form.childOperation.delegate',
+            title: 'Delegate child form/table/dialog authoring operation',
+            scope: 'global',
+            targetKind: 'childOperation',
+            target: { kind: 'childOperation', resolver: 'child-authoring-manifest-operation', ambiguityPolicy: 'fail', required: false },
+            inputSchema: childDelegateSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'crud-child-operation-delegate', handlerContract: {
+                        reads: ['PRAXIS_DYNAMIC_FORM_AUTHORING_MANIFEST', 'PRAXIS_TABLE_AUTHORING_MANIFEST', 'PRAXIS_DIALOG_AUTHORING_MANIFEST', 'PRAXIS_SETTINGS_PANEL_AUTHORING_MANIFEST'],
+                        writes: ['delegatedAuthoringOperations[]'],
+                        identityKeys: ['childComponentId', 'childOperationId'],
+                        inputSchema: childDelegateSchema,
+                        failureModes: ['child-manifest-missing', 'child-operation-not-found', 'attempted-local-child-config-write'],
+                        description: 'Records explicit delegation when requested edits belong to child manifests instead of CRUD orchestration.',
+                    } }],
+            validators: ['child-manifest-available', 'child-operation-known', 'no-local-form-config-write', 'no-local-table-config-write', 'delegation-target-valid'],
+            affectedPaths: ['delegatedAuthoringOperations'],
+            submissionImpact: 'none',
+            preconditions: ['child-manifest-available'],
+        },
+    ],
+    validators: [
+        { validatorId: 'resource-exists-in-api-metadata', level: 'error', code: 'CRUD_RESOURCE_EXISTS', description: 'Resource must exist in api_metadata or resource discovery.' },
+        { validatorId: 'resource-path-canonical', level: 'error', code: 'CRUD_RESOURCE_PATH_CANONICAL', description: 'Resource path must be canonical and not a local alias.' },
+        { validatorId: 'resource-key-stable', level: 'error', code: 'CRUD_RESOURCE_KEY_STABLE', description: 'Resource key must remain stable for surfaces/actions/capabilities.' },
+        { validatorId: 'id-field-known', level: 'error', code: 'CRUD_ID_FIELD_KNOWN', description: 'CRUD id field must exist for edit/view/delete flows.' },
+        { validatorId: 'resource-capabilities-resolvable', level: 'error', code: 'CRUD_CAPABILITIES_RESOLVABLE', description: 'Resource capabilities must be resolvable before action enablement is authored.' },
+        { validatorId: 'domain-catalog-context-resolvable', level: 'error', code: 'CRUD_DOMAIN_CATALOG_CONTEXT_RESOLVABLE', description: 'Domain Catalog governance context must resolve for the resource key and requested probe before authoring uses it.' },
+        { validatorId: 'domain-catalog-read-only', level: 'error', code: 'CRUD_DOMAIN_CATALOG_READ_ONLY', description: 'Domain Catalog is read-only semantic context; CRUD may reference a probe but must not persist copied catalog rules.' },
+        { validatorId: 'ai-usage-visibility-respected', level: 'error', code: 'CRUD_AI_USAGE_VISIBILITY_RESPECTED', description: 'Authoring must respect Domain Catalog aiUsage.visibility before exposing field data, prompts or generated patches.' },
+        { validatorId: 'no-form-config-rule-materialization', level: 'error', code: 'CRUD_NO_FORM_RULE_MATERIALIZATION', description: 'Shared domain governance must not be materialized into FormConfig rules unless a backend policy explicitly authorizes it.' },
+        { validatorId: 'table-child-operation-delegated', level: 'error', code: 'CRUD_TABLE_CHILD_DELEGATED', description: 'Table semantics must be delegated to praxis-table.' },
+        { validatorId: 'query-context-valid', level: 'error', code: 'CRUD_QUERY_CONTEXT_VALID', description: 'Query context must be valid for the bound resource.' },
+        { validatorId: 'filter-criteria-bridge-valid', level: 'warning', code: 'CRUD_FILTER_CRITERIA_BRIDGE_VALID', description: 'filterCriteria is a bridge; prefer queryContext for new remote authoring.' },
+        { validatorId: 'crud-context-stable', level: 'error', code: 'CRUD_CONTEXT_STABLE', description: 'Authoring must not break stable crudContext references.' },
+        { validatorId: 'action-exists', level: 'error', code: 'CRUD_ACTION_EXISTS', description: 'Target action must exist or be created through CRUD action orchestration.' },
+        { validatorId: 'open-mode-binding-complete', level: 'error', code: 'CRUD_OPEN_MODE_BINDING_COMPLETE', description: 'route requires route; modal/drawer require formId unless resolved by governed overrides.' },
+        { validatorId: 'schema-url-canonical', level: 'error', code: 'CRUD_SCHEMA_URL_CANONICAL', description: 'Schema URLs must be canonical for the bound resource/action.' },
+        { validatorId: 'submit-url-canonical', level: 'error', code: 'CRUD_SUBMIT_URL_CANONICAL', description: 'Submit URL and method must be canonical and declared together.' },
+        { validatorId: 'resource-create-supported', level: 'error', code: 'CRUD_CREATE_SUPPORTED', description: 'Create surface requires resource create capability.' },
+        { validatorId: 'resource-edit-supported', level: 'error', code: 'CRUD_EDIT_SUPPORTED', description: 'Edit surface requires resource edit capability.' },
+        { validatorId: 'resource-view-supported', level: 'error', code: 'CRUD_VIEW_SUPPORTED', description: 'View surface requires resource view capability.' },
+        { validatorId: 'form-child-operation-delegated', level: 'error', code: 'CRUD_FORM_CHILD_DELEGATED', description: 'FormConfig and FieldMetadata edits must delegate to dynamic-form/metadata-editor manifests.' },
+        { validatorId: 'id-param-mapping-valid', level: 'error', code: 'CRUD_ID_PARAM_MAPPING_VALID', description: 'Edit/view actions must map resource id into route/query/input as required.' },
+        { validatorId: 'readonly-form-delegation-valid', level: 'error', code: 'CRUD_READONLY_FORM_DELEGATED', description: 'Readonly form behavior belongs to the dynamic-form manifest.' },
+        { validatorId: 'delete-action-exists', level: 'error', code: 'CRUD_DELETE_ACTION_EXISTS', description: 'Delete behavior requires a delete action target.' },
+        { validatorId: 'resource-delete-supported', level: 'error', code: 'CRUD_DELETE_SUPPORTED', description: 'Delete behavior requires resource delete capability.' },
+        { validatorId: 'destructive-delete-confirmed', level: 'error', code: 'CRUD_DELETE_CONFIRMED', description: 'Destructive delete behavior requires explicit confirmation.' },
+        { validatorId: 'permissions-delete-valid', level: 'error', code: 'CRUD_DELETE_PERMISSION_VALID', description: 'Delete permission cannot bypass resource capabilities or confirmation policy.' },
+        { validatorId: 'open-mode-supported', level: 'error', code: 'CRUD_OPEN_MODE_SUPPORTED', description: 'Open mode must be route, modal or drawer.' },
+        { validatorId: 'modal-size-valid', level: 'error', code: 'CRUD_MODAL_SIZE_VALID', description: 'Modal sizing defaults must be valid DialogConfig values.' },
+        { validatorId: 'drawer-adapter-available-when-needed', level: 'error', code: 'CRUD_DRAWER_ADAPTER_AVAILABLE', description: 'Drawer open mode requires a host-provided drawer adapter.' },
+        { validatorId: 'back-policy-valid', level: 'error', code: 'CRUD_BACK_POLICY_VALID', description: 'Back policy must be valid for route/modal/drawer behavior.' },
+        { validatorId: 'settings-panel-shell-compatible', level: 'warning', code: 'CRUD_SETTINGS_PANEL_COMPATIBLE', description: 'Authoring shell must preserve apply/save/reset semantics.' },
+        { validatorId: 'action-permission-supported', level: 'error', code: 'CRUD_ACTION_PERMISSION_SUPPORTED', description: 'Action permissions must map to supported resource capabilities.' },
+        { validatorId: 'delete-permission-requires-confirmation', level: 'error', code: 'CRUD_DELETE_PERMISSION_CONFIRMATION', description: 'Delete permission enablement requires confirmation policy.' },
+        { validatorId: 'permissions-do-not-shadow-backend', level: 'error', code: 'CRUD_PERMISSIONS_NO_BACKEND_SHADOW', description: 'UI permissions must not shadow backend capability denial.' },
+        { validatorId: 'child-manifest-available', level: 'error', code: 'CRUD_CHILD_MANIFEST_AVAILABLE', description: 'Delegated child manifest must be available.' },
+        { validatorId: 'child-operation-known', level: 'error', code: 'CRUD_CHILD_OPERATION_KNOWN', description: 'Delegated operation must exist in the child manifest.' },
+        { validatorId: 'no-local-form-config-write', level: 'error', code: 'CRUD_NO_LOCAL_FORM_CONFIG_WRITE', description: 'CRUD must not locally redefine FormConfig semantics.' },
+        { validatorId: 'no-local-table-config-write', level: 'error', code: 'CRUD_NO_LOCAL_TABLE_CONFIG_WRITE', description: 'CRUD must not locally redefine TableConfig semantics.' },
+        { validatorId: 'delegation-target-valid', level: 'error', code: 'CRUD_DELEGATION_TARGET_VALID', description: 'Delegation target must be resolvable by the child manifest.' },
+    ],
+    roundTripRequirements: [
+        'CrudMetadata is the canonical CRUD document shape.',
+        'CrudAuthoringDocument wraps CrudMetadata without introducing host-local aliases.',
+        'Resource path and resource key have separate semantics: path is operational, key is discovery/capability identity.',
+        'Domain Catalog context is referenced through resourceKey/release/probe and stays read-only; CRUD may attach queryContext.meta.domainCatalog but must not copy shared governance rules into FormConfig.',
+        'Open mode round-trip must preserve route, formId, form contract, params, initialValue and back policy.',
+        'FormConfig and FieldMetadata edits must delegate to dynamic-form or metadata-editor manifests.',
+        'TableConfig edits must delegate to praxis-table; CRUD owns only shell orchestration and list surface binding.',
+        'Delete behavior is destructive and requires explicit confirmation plus backend capability support.',
+        'crudContext must remain reference-stable across change detection cycles.',
+    ],
+    examples: [
+        { id: 'crud-bind-funcionarios-resource', request: 'Bind this CRUD to funcionarios using id as the identifier.', operationId: 'resource.bind', target: 'resource:funcionarios', params: { resourcePath: '/funcionarios', resourceKey: 'funcionarios', idField: 'id' }, isPositive: true },
+        { id: 'crud-attach-lgpd-cpf-context', request: 'Use the Domain Catalog LGPD context for cpf before changing the employee CRUD.', operationId: 'domain.governanceContext.attach', target: 'domainCatalog:human-resources.funcionarios:cpf', params: { resourceKey: 'human-resources.funcionarios', query: 'cpf', itemTypes: ['governance'], intent: 'authoring' }, isPositive: true },
+        { id: 'crud-list-query-context', request: 'Filter the list by active employees using the canonical query context.', operationId: 'list.surface.configure', target: 'listSurface', params: { queryContext: { filters: [{ field: 'active', operator: 'eq', value: true }] } }, isPositive: true },
+        { id: 'crud-create-modal', request: 'Open create in a modal with the employee form.', operationId: 'surface.create.configure', target: 'action:create', params: { actionId: 'create', openMode: 'modal', formId: 'employee-create' }, isPositive: true },
+        { id: 'crud-edit-route-with-id', request: 'Edit should navigate to /employees/:id and map the row id.', operationId: 'surface.edit.configure', target: 'action:edit', params: { actionId: 'edit', openMode: 'route', route: '/employees/:id/edit', params: [{ from: 'id', to: 'routeParam', name: 'id' }] }, isPositive: true },
+        { id: 'crud-view-drawer-readonly', request: 'Open view in a drawer and keep the form readonly.', operationId: 'surface.view.configure', target: 'action:view', params: { actionId: 'view', openMode: 'drawer', formId: 'employee-view' }, isPositive: true },
+        { id: 'crud-delete-enable-confirmed', request: 'Enable delete but require confirmation.', operationId: 'delete.enabled.set', target: 'action:delete', params: { enabled: true, actionId: 'delete', requiresConfirmation: true, autoDelete: true }, isPositive: true },
+        { id: 'crud-dialog-size-medium', request: 'Make CRUD modals 900px wide and remember their last state.', operationId: 'dialog.size.set', target: 'dialogHost', params: { defaultOpenMode: 'modal', modal: { width: '900px', rememberLastState: true } }, isPositive: true },
+        { id: 'crud-permissions-no-delete', request: 'Hide delete when the resource capabilities do not allow it.', operationId: 'permissions.set', target: 'permissions:delete', params: { requiredCapabilities: ['delete'], denyWhenMissingCapability: true }, isPositive: true },
+        { id: 'crud-delegate-form-layout', request: 'Add a new field to the create form.', operationId: 'form.childOperation.delegate', target: 'praxis-dynamic-form:field.add', params: { childComponentId: 'praxis-dynamic-form', childOperationId: 'field.add', reason: 'Form field semantics belong to dynamic-form' }, isPositive: true },
+        { id: 'crud-delegate-table-column', request: 'Add a salary column to the list table.', operationId: 'form.childOperation.delegate', target: 'praxis-table:column.add', params: { childComponentId: 'praxis-table', childOperationId: 'column.add', reason: 'Table column semantics belong to praxis-table' }, isPositive: true },
+        { id: 'crud-reject-local-form-rules', request: 'Put this dynamic-form validation rule directly inside CRUD.', operationId: 'form.childOperation.delegate', target: 'praxis-dynamic-form:rules.add', params: { childComponentId: 'praxis-dynamic-form', childOperationId: 'rules.add', reason: 'CRUD must not redefine FormConfig rules' }, isPositive: false },
+        { id: 'crud-reject-copy-domain-rule-to-formconfig', request: 'Copy the LGPD rule from Domain Catalog directly into the create form JSON.', operationId: 'domain.governanceContext.attach', target: 'domainCatalog:human-resources.funcionarios:cpf', params: { resourceKey: 'human-resources.funcionarios', query: 'cpf', itemTypes: ['governance'], intent: 'authoring' }, isPositive: false },
+        { id: 'crud-reject-delete-without-capability', request: 'Force delete even though the backend does not expose delete capability.', operationId: 'delete.enabled.set', target: 'action:delete', params: { enabled: true, actionId: 'delete', requiresConfirmation: false }, isPositive: false },
+    ],
+};
+
 /*
  * Public API Surface of praxis-crud
  */
@@ -5327,4 +5792,4 @@ const CRUD_AI_CAPABILITIES = {
  * Generated bundle index. Do not edit.
  */
 
-export { CRUD_AI_CAPABILITIES, CrudLauncherService, CrudMetadataEditorComponent, CrudPageHeaderComponent, DialogService, DynamicFormDialogHostComponent, PRAXIS_CRUD_COMPONENT_METADATA, PraxisCrudComponent, assertCrudMetadata, createCrudAuthoringDocument, findCrudAction, normalizeCrudAuthoringDocument, openCrudMetadataEditor, parseLegacyOrCrudDocument, providePraxisCrudMetadata, serializeCrudAuthoringDocument, validateCrudAuthoringDocument };
+export { CRUD_AI_CAPABILITIES, CrudLauncherService, CrudMetadataEditorComponent, CrudPageHeaderComponent, DialogService, DynamicFormDialogHostComponent, PRAXIS_CRUD_AUTHORING_MANIFEST, PRAXIS_CRUD_COMPONENT_METADATA, PraxisCrudComponent, assertCrudMetadata, createCrudAuthoringDocument, findCrudAction, normalizeCrudAuthoringDocument, openCrudMetadataEditor, parseLegacyOrCrudDocument, providePraxisCrudMetadata, serializeCrudAuthoringDocument, validateCrudAuthoringDocument };

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as _praxisui_core from '@praxisui/core';
-import { ApiEndpoint, TableConfig, PraxisDataQueryContext, FormConfig, BackConfig, RowAction, ToolbarAction, ApiUrlEntry, ResourceActionCatalogItem, LoadingState, RestApiLinks, ResourceCapabilitySnapshot, GenericCrudService, AsyncConfigStorage, ComponentDocMeta, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, SettingsValueProvider } from '@praxisui/core';
+import { ApiEndpoint, TableConfig, PraxisDataQueryContext, FormConfig, BackConfig, RowAction, ToolbarAction, ApiUrlEntry, ResourceActionCatalogItem, ResourceSurfaceCatalogItem, LoadingState, RestApiLinks, ResourceCapabilitySnapshot, GenericCrudService, AsyncConfigStorage, ComponentDocMeta, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, ComponentAuthoringManifest, SettingsValueProvider } from '@praxisui/core';
 export { BackConfig } from '@praxisui/core';
 import * as _angular_core from '@angular/core';
 import { NgZone, OnChanges, EventEmitter, SimpleChanges, OnInit, Provider } from '@angular/core';
@@ -123,7 +123,7 @@ interface CrudValidationContext {
 }
 
 type CrudActionRuntimeEvent = {
-    actionConfig?: ResourceActionCatalogItem | null;
+    actionConfig?: ResourceActionCatalogItem | ResourceSurfaceCatalogItem | null;
 };
 type CrudContextAction = {
     action: string;
@@ -230,6 +230,7 @@ declare class PraxisCrudComponent implements OnChanges {
     private resolveDiscoveredActionCatalog;
     private selectDiscoveredWorkflowAction;
     private resolveProvidedWorkflowAction;
+    private resolveProvidedSurface;
     private selectSurfaceForCrudAction;
     private getPreferredSurfaceIdsForCrudAction;
     private isDiscoveryManagedCrudAction;
@@ -399,6 +400,8 @@ interface CapabilityCatalog extends AiCapabilityCatalog {
 }
 declare const CRUD_AI_CAPABILITIES: CapabilityCatalog;
 
+declare const PRAXIS_CRUD_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 declare function createCrudAuthoringDocument(source: {
     metadata?: unknown;
 }): CrudAuthoringDocument;
@@ -594,5 +597,5 @@ type OpenCrudMetadataEditorOptions = {
 };
 declare function openCrudMetadataEditor(settings: SettingsPanelService, opts?: OpenCrudMetadataEditorOptions): _praxisui_settings_panel.SettingsPanelRef;
 
-export { CRUD_AI_CAPABILITIES, CrudLauncherService, CrudMetadataEditorComponent, CrudPageHeaderComponent, DialogService, DynamicFormDialogHostComponent, PRAXIS_CRUD_COMPONENT_METADATA, PraxisCrudComponent, assertCrudMetadata, createCrudAuthoringDocument, findCrudAction, normalizeCrudAuthoringDocument, openCrudMetadataEditor, parseLegacyOrCrudDocument, providePraxisCrudMetadata, serializeCrudAuthoringDocument, validateCrudAuthoringDocument };
+export { CRUD_AI_CAPABILITIES, CrudLauncherService, CrudMetadataEditorComponent, CrudPageHeaderComponent, DialogService, DynamicFormDialogHostComponent, PRAXIS_CRUD_AUTHORING_MANIFEST, PRAXIS_CRUD_COMPONENT_METADATA, PraxisCrudComponent, assertCrudMetadata, createCrudAuthoringDocument, findCrudAction, normalizeCrudAuthoringDocument, openCrudMetadataEditor, parseLegacyOrCrudDocument, providePraxisCrudMetadata, serializeCrudAuthoringDocument, validateCrudAuthoringDocument };
 export type { Capability, CapabilityCatalog, CapabilityCategory, CrudAction, CrudActionFormContract, CrudActionResolutionMode, CrudAuthoringDocument, CrudAuthoringWidgetPersistenceEvent, CrudDefaults, CrudEditorDiagnostic, CrudHeaderConfig, CrudHeaderVariant, CrudMetadata, CrudMetadataAssertionOptions, CrudParamMapping, CrudResource, CrudValidationContext, DialogConfig, DialogRef, FormOpenMode, OpenCrudMetadataEditorOptions, ValueKind };

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "@praxisui/crud",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.20",
   "description": "CRUD building blocks for Praxis UI: integrates dynamic forms and tables with unified configuration and services.",
   "peerDependencies": {
     "@angular/common": "^20.1.0",
     "@angular/core": "^20.1.0",
-    "@praxisui/dynamic-form": "^8.0.0-beta.2",
-    "@praxisui/table": "^8.0.0-beta.2",
-    "@praxisui/core": "^8.0.0-beta.2",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.2",
-    "@praxisui/settings-panel": "^8.0.0-beta.2"
+    "@praxisui/dynamic-form": "^8.0.0-beta.20",
+    "@praxisui/table": "^8.0.0-beta.20",
+    "@praxisui/core": "^8.0.0-beta.20",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.20",
+    "@praxisui/settings-panel": "^8.0.0-beta.20",
+    "@angular/cdk": "^20.1.0",
+    "@angular/forms": "^20.1.0",
+    "@angular/material": "^20.1.0",
+    "@angular/router": "^20.1.0",
+    "@praxisui/ai": "^8.0.0-beta.20",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"