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

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

@@ -4439,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,
@@ -5346,6 +5346,396 @@ 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 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: '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: '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: '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.',
+        '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-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-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
  */
@@ -5354,4 +5744,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, ResourceSurfaceCatalogItem, 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';
@@ -400,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;
@@ -595,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,15 @@
 {
   "name": "@praxisui/crud",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.13",
   "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.11",
-    "@praxisui/table": "^8.0.0-beta.11",
-    "@praxisui/core": "^8.0.0-beta.11",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.11",
-    "@praxisui/settings-panel": "^8.0.0-beta.11"
+    "@praxisui/dynamic-form": "^8.0.0-beta.13",
+    "@praxisui/table": "^8.0.0-beta.13",
+    "@praxisui/core": "^8.0.0-beta.13",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.13",
+    "@praxisui/settings-panel": "^8.0.0-beta.13"
   },
   "dependencies": {
     "tslib": "^2.3.0"