@praxisui/files-upload 8.0.0-beta.3 → 8.0.0-beta.31

package/README.md

@@ -271,6 +271,32 @@ const cfg: FilesUploadConfig = {
 - `maxFilesPerBulkValidator`
 - `maxBulkSizeValidator`
 
+## Agentic Authoring Contract
+
+`@praxisui/files-upload` publishes an executable `ComponentAuthoringManifest` through
+`PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST`.
+
+The contract exposes typed operation families for:
+
+- accepted types: `accept.types.set`
+- single-file and batch limits: `limit.fileSize.set`, `limit.fileCount.set`
+- backend upload surfaces: `endpoint.presign.set`, `endpoint.upload.set`
+- upload policy: `security.policy.set`
+- error message overrides: `message.error.set`
+- display mode and UI flags: `display.mode.set`
+
+Endpoint authoring intentionally changes only the canonical `baseUrl` runtime input
+and the upload `strategy`. The direct, bulk and presign paths remain fixed as
+`baseUrl/upload`, `baseUrl/bulk` and `baseUrl/upload/presign?filename=...` so hosts
+do not create parallel endpoint semantics outside `FilesApiClient`.
+
+Every manifest operation declares its own editable target resolver, ambiguity policy,
+preconditions, validators, affected paths, effects and typed submission impact. Upload
+limits and accepted types are marked as submission-affecting; endpoint and security
+policy edits are marked as remote-binding changes and require confirmation; error
+messages are config-only; display changes are visual-only. These categories are the
+same metadata projected into `praxis-component-registry-ingestion.json`.
+
 ## Error handling
 
 `ErrorMapperService` translates backend error codes from `errors[0]` into user-facing messages and exposes rate limit information.

package/fesm2022/praxisui-files-upload.mjs

@@ -32,7 +32,7 @@ import { MatTooltipModule } from '@angular/material/tooltip';
 import * as i2 from '@angular/material/snack-bar';
 import { MatSnackBarModule } from '@angular/material/snack-bar';
 import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { of, throwError, BehaviorSubject, map as map$1, startWith, retry, debounceTime, from } from 'rxjs';
+import { of, throwError, BehaviorSubject, map as map$1, startWith, retry, debounceTime, from, Subscription } from 'rxjs';
 import * as i1$3 from '@praxisui/settings-panel';
 import { SETTINGS_PANEL_DATA } from '@praxisui/settings-panel';
 import { map, catchError, take, concatMap, toArray, tap, filter, defaultIfEmpty } from 'rxjs/operators';
@@ -6232,6 +6232,114 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 args: ['pendingPanel']
             }] } });
 
+class PraxisFilesUploadWidgetConfigEditor {
+    inputs = null;
+    widgetKey;
+    uploadEditor;
+    isDirty$ = new BehaviorSubject(false);
+    isValid$ = new BehaviorSubject(true);
+    isBusy$ = new BehaviorSubject(false);
+    subscription = new Subscription();
+    ngAfterViewInit() {
+        if (!this.uploadEditor) {
+            return;
+        }
+        this.initializeChildEditor();
+        this.subscription.add(this.uploadEditor.isDirty$.subscribe((value) => this.isDirty$.next(value)));
+        this.subscription.add(this.uploadEditor.isValid$.subscribe((value) => this.isValid$.next(value)));
+        this.subscription.add(this.uploadEditor.isBusy$.subscribe((value) => this.isBusy$.next(value)));
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    getSettingsValue() {
+        return this.buildValue(this.uploadEditor?.getSettingsValue());
+    }
+    onSave() {
+        return this.buildValue(this.uploadEditor?.getSettingsValue() ?? this.inputs?.config);
+    }
+    reset() {
+        this.initializeChildEditor();
+    }
+    initializeChildEditor() {
+        const config = this.normalizeEditorPatch(this.inputs?.config ?? {});
+        this.uploadEditor?.form.patchValue(config, { emitEvent: false });
+        this.uploadEditor?.isDirty$.next(false);
+    }
+    buildValue(rawConfig) {
+        return {
+            inputs: {
+                ...(this.inputs ?? {}),
+                config: (rawConfig ?? {}),
+                filesUploadId: this.inputs?.filesUploadId ?? this.widgetKey,
+                componentInstanceId: this.inputs?.componentInstanceId ?? this.widgetKey,
+                baseUrl: this.inputs?.baseUrl,
+                displayMode: this.inputs?.displayMode ?? 'full',
+                context: this.inputs?.context ?? null,
+                enableCustomization: this.inputs?.enableCustomization ?? false,
+            },
+        };
+    }
+    normalizeEditorPatch(config) {
+        const patch = structuredClone(config ?? {});
+        if (Array.isArray(patch.ui?.accept)) {
+            patch.ui = {
+                ...patch.ui,
+                accept: patch.ui.accept.join(','),
+            };
+        }
+        if (Array.isArray(patch.ui?.list?.detailsFields)) {
+            patch.ui = {
+                ...patch.ui,
+                list: {
+                    ...patch.ui.list,
+                    detailsFields: patch.ui.list.detailsFields.join(','),
+                },
+            };
+        }
+        if (Array.isArray(patch.options?.allowedExtensions)) {
+            patch.options = {
+                ...patch.options,
+                allowedExtensions: patch.options.allowedExtensions.join(','),
+            };
+        }
+        if (Array.isArray(patch.options?.acceptMimeTypes)) {
+            patch.options = {
+                ...patch.options,
+                acceptMimeTypes: patch.options.acceptMimeTypes.join(','),
+            };
+        }
+        return patch;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisFilesUploadWidgetConfigEditor, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: PraxisFilesUploadWidgetConfigEditor, isStandalone: true, selector: "praxis-files-upload-widget-config-editor", inputs: { inputs: "inputs", widgetKey: "widgetKey" }, viewQueries: [{ propertyName: "uploadEditor", first: true, predicate: ["uploadEditor"], descendants: true }], ngImport: i0, template: `
+    <section data-testid="files-upload-widget-config-editor">
+      <praxis-files-upload-config-editor #uploadEditor />
+    </section>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: PraxisFilesUploadConfigEditor, selector: "praxis-files-upload-config-editor" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisFilesUploadWidgetConfigEditor, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'praxis-files-upload-widget-config-editor',
+                    standalone: true,
+                    imports: [CommonModule, PraxisFilesUploadConfigEditor],
+                    template: `
+    <section data-testid="files-upload-widget-config-editor">
+      <praxis-files-upload-config-editor #uploadEditor />
+    </section>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { inputs: [{
+                type: Input
+            }], widgetKey: [{
+                type: Input
+            }], uploadEditor: [{
+                type: ViewChild,
+                args: ['uploadEditor']
+            }] } });
+
 const PRAXIS_FILES_UPLOAD_COMPONENT_METADATA = {
     id: 'praxis-files-upload',
     selector: 'praxis-files-upload',
@@ -6239,6 +6347,14 @@ const PRAXIS_FILES_UPLOAD_COMPONENT_METADATA = {
     friendlyName: 'Praxis Files Upload',
     description: 'Componente para upload de arquivos com suporte a configuracao dinamica, eventos e integracao com backend.',
     icon: 'upload_file',
+    authoringManifestRef: {
+        componentId: 'praxis-files-upload',
+        source: 'PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST',
+    },
+    configEditor: {
+        component: PraxisFilesUploadWidgetConfigEditor,
+        title: 'Configurar upload de arquivos',
+    },
     inputs: [
         {
             name: 'config',
@@ -6358,6 +6474,12 @@ const PRAXIS_FILES_UPLOAD_COMPONENT_METADATA = {
             label: 'Arquivos pendentes',
             description: 'Disparado quando o estado de selecao pendente muda.',
         },
+        {
+            name: 'readinessChange',
+            type: 'FilesUploadReadinessEvent',
+            label: 'Prontidao',
+            description: 'Disparado quando o componente alterna entre configuracao local, servidor ou fallback.',
+        },
         {
             name: 'proximityChange',
             type: 'boolean',
@@ -6559,10 +6681,335 @@ const FILES_UPLOAD_AI_CAPABILITIES = {
     ],
 };
 
+const PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-files-upload',
+    ownerPackage: '@praxisui/files-upload',
+    configSchemaId: 'FilesUploadConfig',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'config', type: 'FilesUploadConfig', description: 'Upload strategy, UI, limits, backend options, bulk execution, quota/rate feedback, headers and messages.' },
+        { name: 'filesUploadId', type: 'string', description: 'Stable upload id used for config persistence and telemetry correlation.' },
+        { name: 'componentInstanceId', type: 'string', description: 'Optional instance discriminator when the same upload id appears more than once.' },
+        { name: 'baseUrl', type: 'string', description: 'Canonical files API base URL. Direct upload uses baseUrl/upload, bulk uses baseUrl/bulk and presign uses baseUrl/upload/presign.' },
+        { name: 'displayMode', type: "'full' | 'compact'", allowedValues: ['full', 'compact'], description: 'Runtime display mode input.' },
+        { name: 'context', type: 'Record<string, unknown>', description: 'Host context available to metadata and event consumers.' },
+        { name: 'enableCustomization', type: 'boolean', description: 'Enables the Settings Panel configuration editor.' },
+    ],
+    editableTargets: [
+        { kind: 'acceptedTypes', resolver: 'files-accept-list', description: 'Allowed file extensions and MIME types projected to ui.accept, options.allowedExtensions and options.acceptMimeTypes.' },
+        { kind: 'sizeLimit', resolver: 'max-file-size-policy', description: 'Maximum single-file size in limits.maxFileSizeBytes and backend-facing options.maxUploadSizeMb.' },
+        { kind: 'fileCountLimit', resolver: 'max-files-per-bulk-policy', description: 'Maximum number of files accepted in a bulk selection.' },
+        { kind: 'presignEndpoint', resolver: 'files-api-base-url-presign-contract', description: 'Presign operation endpoint derived from baseUrl + /upload/presign; arbitrary per-operation URLs are not accepted.' },
+        { kind: 'uploadEndpoint', resolver: 'files-api-base-url-upload-contract', description: 'Direct and bulk upload endpoints derived from baseUrl + /upload and /bulk.' },
+        { kind: 'securityPolicy', resolver: 'upload-security-policy', description: 'Strict validation, virus scanning, conflict policy, target directory, quotas, rate limit and contextual headers.' },
+        { kind: 'errorMessages', resolver: 'upload-error-code-message', description: 'Host-provided message overrides under messages.errors keyed by backend error code.' },
+        { kind: 'display', resolver: 'files-upload-display-mode-and-ui', description: 'Runtime displayMode plus non-backend visual UI flags.' },
+    ],
+    operations: [
+        {
+            operationId: 'accept.types.set',
+            title: 'Set accepted file types',
+            scope: 'global',
+            targetKind: 'acceptedTypes',
+            target: { kind: 'acceptedTypes', resolver: 'files-accept-list', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['accept'],
+                properties: {
+                    accept: { type: 'array', items: { type: 'string' } },
+                    allowedExtensions: { type: 'array', items: { type: 'string' } },
+                    acceptMimeTypes: { type: 'array', items: { type: 'string' } },
+                },
+            },
+            effects: [
+                { kind: 'set-value', path: 'ui.accept' },
+                { kind: 'set-value', path: 'options.allowedExtensions' },
+                { kind: 'set-value', path: 'options.acceptMimeTypes' },
+            ],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['file-type-list-explicit', 'file-type-entry-valid', 'backend-accept-options-consistent', 'editor-runtime-round-trip'],
+            affectedPaths: ['ui.accept', 'options.allowedExtensions', 'options.acceptMimeTypes'],
+            submissionImpact: 'affects-submission',
+            preconditions: ['config-initialized'],
+        },
+        {
+            operationId: 'limit.fileSize.set',
+            title: 'Set max file size',
+            scope: 'global',
+            targetKind: 'sizeLimit',
+            target: { kind: 'sizeLimit', resolver: 'max-file-size-policy', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['maxFileSizeBytes'],
+                properties: {
+                    maxFileSizeBytes: { type: 'number' },
+                    maxUploadSizeMb: { type: 'number' },
+                },
+            },
+            effects: [
+                { kind: 'set-value', path: 'limits.maxFileSizeBytes' },
+                { kind: 'set-value', path: 'options.maxUploadSizeMb' },
+            ],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['size-limit-numeric', 'size-limit-within-platform-policy', 'size-limit-client-backend-consistent', 'editor-runtime-round-trip'],
+            affectedPaths: ['limits.maxFileSizeBytes', 'options.maxUploadSizeMb'],
+            submissionImpact: 'affects-submission',
+            preconditions: ['config-initialized'],
+        },
+        {
+            operationId: 'limit.fileCount.set',
+            title: 'Set max file count',
+            scope: 'global',
+            targetKind: 'fileCountLimit',
+            target: { kind: 'fileCountLimit', resolver: 'max-files-per-bulk-policy', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['maxFilesPerBulk'],
+                properties: {
+                    maxFilesPerBulk: { type: 'number' },
+                    maxBulkSizeBytes: { type: 'number' },
+                },
+            },
+            effects: [
+                { kind: 'set-value', path: 'limits.maxFilesPerBulk' },
+                { kind: 'set-value', path: 'limits.maxBulkSizeBytes' },
+            ],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['file-count-limit-numeric', 'bulk-size-limit-numeric', 'bulk-limit-within-platform-policy', 'editor-runtime-round-trip'],
+            affectedPaths: ['limits.maxFilesPerBulk', 'limits.maxBulkSizeBytes'],
+            submissionImpact: 'affects-submission',
+            preconditions: ['config-initialized'],
+        },
+        {
+            operationId: 'endpoint.presign.set',
+            title: 'Set presign endpoint',
+            scope: 'global',
+            targetKind: 'presignEndpoint',
+            target: { kind: 'presignEndpoint', resolver: 'files-api-base-url-presign-contract', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['baseUrl'],
+                properties: {
+                    baseUrl: { type: 'string' },
+                    strategy: { enum: ['direct', 'presign', 'auto'] },
+                    allowCrossOriginPresignedTarget: { type: 'boolean' },
+                },
+            },
+            effects: [{
+                    kind: 'compile-domain-patch',
+                    handler: 'files-upload-presign-base-url',
+                    handlerContract: {
+                        reads: ['baseUrl', 'strategy'],
+                        writes: ['baseUrl', 'strategy'],
+                        identityKeys: ['baseUrl'],
+                        inputSchema: {
+                            type: 'object',
+                            required: ['baseUrl'],
+                            properties: {
+                                baseUrl: { type: 'string' },
+                                strategy: { enum: ['direct', 'presign', 'auto'] },
+                                allowCrossOriginPresignedTarget: { type: 'boolean' },
+                            },
+                        },
+                        failureModes: ['unsafe-url', 'non-praxis-backend-surface', 'presign-path-override', 'cross-origin-presigned-fields-leak'],
+                        description: 'Validates the files API base URL and preserves the canonical POST baseUrl/upload/presign?filename=... contract; arbitrary presign URLs are rejected.',
+                    },
+                }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['endpoint-url-safe', 'endpoint-uses-praxis-backend-surface', 'presign-endpoint-fixed-contract', 'presign-cross-origin-fields-safe', 'security-change-confirmed'],
+            affectedPaths: ['baseUrl', 'strategy'],
+            submissionImpact: 'affects-remote-binding',
+            preconditions: ['config-initialized', 'confirmation-collected'],
+        },
+        {
+            operationId: 'endpoint.upload.set',
+            title: 'Set upload endpoint',
+            scope: 'global',
+            targetKind: 'uploadEndpoint',
+            target: { kind: 'uploadEndpoint', resolver: 'files-api-base-url-upload-contract', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['baseUrl'],
+                properties: {
+                    baseUrl: { type: 'string' },
+                    strategy: { enum: ['direct', 'presign', 'auto'] },
+                    allowCrossOriginPresignedTarget: { type: 'boolean' },
+                },
+            },
+            effects: [{
+                    kind: 'compile-domain-patch',
+                    handler: 'files-upload-direct-base-url',
+                    handlerContract: {
+                        reads: ['baseUrl', 'strategy'],
+                        writes: ['baseUrl', 'strategy'],
+                        identityKeys: ['baseUrl'],
+                        inputSchema: {
+                            type: 'object',
+                            required: ['baseUrl'],
+                            properties: {
+                                baseUrl: { type: 'string' },
+                                strategy: { enum: ['direct', 'presign', 'auto'] },
+                                allowCrossOriginPresignedTarget: { type: 'boolean' },
+                            },
+                        },
+                        failureModes: ['unsafe-url', 'non-praxis-backend-surface', 'upload-path-override', 'bulk-path-override'],
+                        description: 'Validates the files API base URL and preserves the canonical POST baseUrl/upload and POST baseUrl/bulk contracts.',
+                    },
+                }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['endpoint-url-safe', 'endpoint-uses-praxis-backend-surface', 'upload-endpoint-fixed-contract', 'bulk-endpoint-fixed-contract', 'security-change-confirmed'],
+            affectedPaths: ['baseUrl', 'strategy'],
+            submissionImpact: 'affects-remote-binding',
+            preconditions: ['config-initialized', 'confirmation-collected'],
+        },
+        {
+            operationId: 'security.policy.set',
+            title: 'Set upload security policy',
+            scope: 'global',
+            targetKind: 'securityPolicy',
+            target: { kind: 'securityPolicy', resolver: 'upload-security-policy', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    strictValidation: { type: 'boolean' },
+                    enableVirusScanning: { type: 'boolean' },
+                    defaultConflictPolicy: { enum: ['ERROR', 'SKIP', 'OVERWRITE', 'MAKE_UNIQUE', 'RENAME'] },
+                    targetDirectory: { type: 'string' },
+                    showQuotaWarnings: { type: 'boolean' },
+                    blockOnExceed: { type: 'boolean' },
+                    autoRetryOn429: { type: 'boolean' },
+                    showBannerOn429: { type: 'boolean' },
+                    maxAutoRetry: { type: 'number' },
+                    baseBackoffMs: { type: 'number' },
+                    tenantHeader: { type: 'string' },
+                    userHeader: { type: 'string' },
+                },
+            },
+            effects: [
+                { kind: 'merge-object', path: 'options' },
+                { kind: 'merge-object', path: 'quotas' },
+                { kind: 'merge-object', path: 'rateLimit' },
+                { kind: 'merge-object', path: 'headers' },
+            ],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['security-change-confirmed', 'security-policy-compatible', 'target-directory-safe', 'conflict-policy-valid', 'quota-rate-policy-valid', 'header-names-safe', 'editor-runtime-round-trip'],
+            affectedPaths: ['options.strictValidation', 'options.enableVirusScanning', 'options.defaultConflictPolicy', 'options.targetDirectory', 'quotas', 'rateLimit', 'headers'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'confirmation-collected'],
+        },
+        {
+            operationId: 'message.error.set',
+            title: 'Set error message override',
+            scope: 'global',
+            targetKind: 'errorMessages',
+            target: { kind: 'errorMessages', resolver: 'upload-error-code-message', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['code', 'message'],
+                properties: {
+                    code: { type: 'string' },
+                    message: { type: 'string' },
+                },
+            },
+            effects: [{ kind: 'merge-object', path: 'messages.errors' }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['error-code-known', 'error-message-i18n-compatible', 'message-not-empty', 'editor-runtime-round-trip'],
+            affectedPaths: ['messages.errors'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized'],
+        },
+        {
+            operationId: 'display.mode.set',
+            title: 'Set display mode',
+            scope: 'global',
+            targetKind: 'display',
+            target: { kind: 'display', resolver: 'files-upload-display-mode-and-ui', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    displayMode: { enum: ['full', 'compact'] },
+                    dense: { type: 'boolean' },
+                    showDropzone: { type: 'boolean' },
+                    showProgress: { type: 'boolean' },
+                    manualUpload: { type: 'boolean' },
+                    showMetadataForm: { type: 'boolean' },
+                    showConflictPolicySelector: { type: 'boolean' },
+                },
+            },
+            effects: [
+                { kind: 'set-value', path: 'displayMode' },
+                { kind: 'merge-object', path: 'ui' },
+            ],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['display-mode-valid', 'display-ui-compatible', 'editor-runtime-round-trip'],
+            affectedPaths: ['displayMode', 'ui.dense', 'ui.showDropzone', 'ui.showProgress', 'ui.manualUpload', 'ui.showMetadataForm', 'ui.showConflictPolicySelector'],
+            submissionImpact: 'visual-only',
+            preconditions: ['config-initialized'],
+        },
+    ],
+    validators: [
+        { validatorId: 'file-type-list-explicit', level: 'error', code: 'PFU001', description: 'Accepted type edits must provide a non-empty explicit list and may not rely on wildcard-only policy.' },
+        { validatorId: 'file-type-entry-valid', level: 'error', code: 'PFU002', description: 'Each accepted type must be a valid extension, exact MIME type or controlled subtype wildcard.' },
+        { validatorId: 'backend-accept-options-consistent', level: 'error', code: 'PFU003', description: 'ui.accept hints must remain consistent with options.allowedExtensions and options.acceptMimeTypes when backend validation is configured.' },
+        { validatorId: 'size-limit-numeric', level: 'error', code: 'PFU004', description: 'Single file size limits must be positive numeric byte and MB values.' },
+        { validatorId: 'size-limit-within-platform-policy', level: 'error', code: 'PFU005', description: 'Single file size limits must not exceed the platform upload policy for the selected backend surface.' },
+        { validatorId: 'size-limit-client-backend-consistent', level: 'error', code: 'PFU006', description: 'limits.maxFileSizeBytes and options.maxUploadSizeMb must describe the same effective maximum when both are present.' },
+        { validatorId: 'file-count-limit-numeric', level: 'error', code: 'PFU007', description: 'Bulk file count limits must be positive integers.' },
+        { validatorId: 'bulk-size-limit-numeric', level: 'error', code: 'PFU008', description: 'Bulk size limits must be positive numeric byte values when provided.' },
+        { validatorId: 'bulk-limit-within-platform-policy', level: 'error', code: 'PFU009', description: 'Bulk count and aggregate size limits must not exceed backend batch policy.' },
+        { validatorId: 'endpoint-url-safe', level: 'error', code: 'PFU010', description: 'Endpoint edits must use a safe absolute or approved relative baseUrl and reject javascript:, data:, credentials-in-URL and path traversal.' },
+        { validatorId: 'endpoint-uses-praxis-backend-surface', level: 'error', code: 'PFU011', description: 'Endpoint edits must resolve to the approved Praxis files backend surface for the host environment.' },
+        { validatorId: 'presign-endpoint-fixed-contract', level: 'error', code: 'PFU012', description: 'Presign authoring may change baseUrl but must preserve POST baseUrl/upload/presign?filename=... as the runtime contract.' },
+        { validatorId: 'upload-endpoint-fixed-contract', level: 'error', code: 'PFU013', description: 'Direct upload authoring may change baseUrl but must preserve POST baseUrl/upload as the runtime contract.' },
+        { validatorId: 'bulk-endpoint-fixed-contract', level: 'error', code: 'PFU014', description: 'Bulk upload authoring may change baseUrl but must preserve POST baseUrl/bulk as the runtime contract.' },
+        { validatorId: 'presign-cross-origin-fields-safe', level: 'error', code: 'PFU015', description: 'Cross-origin presigned upload targets must not receive Praxis metadata/options fields unless explicitly approved by the presign response contract.' },
+        { validatorId: 'security-change-confirmed', level: 'error', code: 'PFU016', description: 'Endpoint and security policy edits require explicit confirmation before patch compilation.' },
+        { validatorId: 'security-policy-compatible', level: 'error', code: 'PFU017', description: 'Strict validation, virus scanning, conflict policy, target directory, quota and rate-limit settings must be compatible with backend effective config.' },
+        { validatorId: 'target-directory-safe', level: 'error', code: 'PFU018', description: 'Target directory values must be normalized backend paths and must reject traversal or absolute filesystem paths.' },
+        { validatorId: 'conflict-policy-valid', level: 'error', code: 'PFU019', description: 'Default conflict policy must be one of ERROR, SKIP, OVERWRITE, MAKE_UNIQUE or RENAME.' },
+        { validatorId: 'quota-rate-policy-valid', level: 'error', code: 'PFU020', description: 'Quota and rate-limit UX settings must use non-negative retry counts/backoffs and cannot silently bypass backend enforcement.' },
+        { validatorId: 'header-names-safe', level: 'warning', code: 'PFU021', description: 'Contextual header names must be explicit HTTP token names and must not override authorization, cookie or content-type headers.' },
+        { validatorId: 'error-code-known', level: 'warning', code: 'PFU022', description: 'Error message overrides should target known backend error catalog codes or documented host-specific extensions.' },
+        { validatorId: 'error-message-i18n-compatible', level: 'warning', code: 'PFU023', description: 'User-facing error messages must remain compatible with the host i18n/editor flow and not expose raw technical exception text.' },
+        { validatorId: 'message-not-empty', level: 'error', code: 'PFU024', description: 'Error message overrides must be non-empty user-facing text.' },
+        { validatorId: 'display-mode-valid', level: 'error', code: 'PFU025', description: 'Display mode must be full or compact.' },
+        { validatorId: 'display-ui-compatible', level: 'warning', code: 'PFU026', description: 'Display changes must keep progress, manual upload and metadata form affordances reachable for the selected mode.' },
+        { validatorId: 'editor-runtime-round-trip', level: 'error', code: 'PFU027', description: 'Settings Panel editor, AI adapter snapshot and runtime inputs must round-trip config, baseUrl and displayMode without changing upload behavior.' },
+    ],
+    roundTripRequirements: [
+        'Accepted type authoring must keep UI hints and backend-facing validation options aligned; ui.accept alone is not the canonical server policy.',
+        'Endpoint authoring changes only the canonical files API baseUrl and strategy; direct, bulk and presign paths remain fixed by FilesApiClient.',
+        'Security-affecting edits require confirmation and must round-trip through Settings Panel persistence without weakening strict validation, virus scanning, quota or rate-limit policy by omission.',
+        'Error message overrides remain keyed by backend error catalog code and must stay user-facing/i18n-compatible.',
+        'Display authoring may change displayMode and UI flags, but must not mutate backend options or upload submission payload.',
+    ],
+    examples: [
+        { id: 'accept-pdf-images', request: 'Accept only PDF and image uploads.', operationId: 'accept.types.set', params: { accept: ['application/pdf', 'image/*'], allowedExtensions: ['pdf', 'png', 'jpg', 'jpeg'], acceptMimeTypes: ['application/pdf', 'image/png', 'image/jpeg'] }, isPositive: true },
+        { id: 'max-five-mb', request: 'Limit each file to 5 MB.', operationId: 'limit.fileSize.set', params: { maxFileSizeBytes: 5242880, maxUploadSizeMb: 5 }, isPositive: true },
+        { id: 'max-three-files', request: 'Allow at most three files per upload batch.', operationId: 'limit.fileCount.set', params: { maxFilesPerBulk: 3 }, isPositive: true },
+        { id: 'set-presign-base-url', request: 'Use the official files API for presigned uploads.', operationId: 'endpoint.presign.set', params: { baseUrl: 'https://api.praxis.example/files', strategy: 'presign' }, isPositive: true },
+        { id: 'set-direct-base-url', request: 'Use the official files API for direct uploads.', operationId: 'endpoint.upload.set', params: { baseUrl: 'https://api.praxis.example/files', strategy: 'direct' }, isPositive: true },
+        { id: 'reject-unsafe-endpoint', request: 'Set upload endpoint to javascript:alert(1).', operationId: 'endpoint.upload.set', params: { baseUrl: 'javascript:alert(1)', strategy: 'direct' }, isPositive: false },
+        { id: 'tighten-security-policy', request: 'Enable strict validation and virus scanning for uploads.', operationId: 'security.policy.set', params: { strictValidation: true, enableVirusScanning: true, defaultConflictPolicy: 'ERROR' }, isPositive: true },
+        { id: 'reject-unconfirmed-security-policy', request: 'Disable strict validation without confirmation.', operationId: 'security.policy.set', params: { strictValidation: false, enableVirusScanning: false }, isPositive: false },
+        { id: 'quota-message', request: 'Show a friendly message when quota is exceeded.', operationId: 'message.error.set', params: { code: 'QUOTA_EXCEEDED', message: 'Upload quota reached for this period.' }, isPositive: true },
+        { id: 'compact-display', request: 'Use compact upload display and keep progress visible.', operationId: 'display.mode.set', params: { displayMode: 'compact', dense: true, showProgress: true }, isPositive: true },
+    ],
+};
+
 // Export all public API from subdirectories
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BulkUploadResultStatus, ErrorCode, ErrorMapperService, FILES_UPLOAD_AI_CAPABILITIES, FILES_UPLOAD_EN_US, FILES_UPLOAD_ERROR_MESSAGES, FILES_UPLOAD_PT_BR, FILES_UPLOAD_TEXTS, FilesApiClient, PRAXIS_FILES_UPLOAD_COMPONENT_METADATA, PdxFilesUploadFieldComponent, PraxisFilesUpload, PraxisFilesUploadConfigEditor, PresignedUploaderService, ScanStatus, TRANSLATE_LIKE, acceptValidator, createPraxisFilesUploadI18nConfig, getPrimaryErrorItem, isErrorEnvelope, maxBulkSizeValidator, maxFileSizeValidator, maxFilesPerBulkValidator, providePraxisFilesUploadI18n, providePraxisFilesUploadMetadata, resolvePraxisFilesUploadText };
+export { BulkUploadResultStatus, ErrorCode, ErrorMapperService, FILES_UPLOAD_AI_CAPABILITIES, FILES_UPLOAD_EN_US, FILES_UPLOAD_ERROR_MESSAGES, FILES_UPLOAD_PT_BR, FILES_UPLOAD_TEXTS, FilesApiClient, PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST, PRAXIS_FILES_UPLOAD_COMPONENT_METADATA, PdxFilesUploadFieldComponent, PraxisFilesUpload, PraxisFilesUploadConfigEditor, PraxisFilesUploadWidgetConfigEditor, PresignedUploaderService, ScanStatus, TRANSLATE_LIKE, acceptValidator, createPraxisFilesUploadI18nConfig, getPrimaryErrorItem, isErrorEnvelope, maxBulkSizeValidator, maxFileSizeValidator, maxFilesPerBulkValidator, providePraxisFilesUploadI18n, providePraxisFilesUploadMetadata, resolvePraxisFilesUploadText };

package/index.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, OnDestroy, NgZone, OnInit, OnChanges, AfterViewInit, EventEmitter, ViewContainerRef, ChangeDetectorRef, DestroyRef, Provider } from '@angular/core';
 import { FormControl, ValidatorFn, FormGroup, FormBuilder } from '@angular/forms';
-import { PraxisI18nDictionary, PraxisI18nConfig, PraxisI18nService, AsyncConfigStorage, ComponentDocMeta, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog } from '@praxisui/core';
+import { PraxisI18nDictionary, PraxisI18nConfig, PraxisI18nService, AsyncConfigStorage, ComponentDocMeta, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, ComponentAuthoringManifest } from '@praxisui/core';
 import { SettingsPanelService, SettingsValueProvider } from '@praxisui/settings-panel';
 import { HttpClient, HttpEvent, HttpHeaders } from '@angular/common/http';
 import { Observable, BehaviorSubject } from 'rxjs';
@@ -802,6 +802,39 @@ declare class PraxisFilesUploadConfigEditor implements OnInit, SettingsValueProv
     static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilesUploadConfigEditor, "praxis-files-upload-config-editor", never, {}, {}, never, never, true, never>;
 }
 
+interface PraxisFilesUploadWidgetEditorInputs {
+    config?: FilesUploadConfig | null;
+    filesUploadId?: string;
+    componentInstanceId?: string;
+    baseUrl?: string;
+    displayMode?: 'full' | 'compact';
+    context?: Record<string, unknown> | null;
+    enableCustomization?: boolean;
+    [key: string]: unknown;
+}
+interface PraxisFilesUploadWidgetEditorValue {
+    inputs: PraxisFilesUploadWidgetEditorInputs;
+}
+declare class PraxisFilesUploadWidgetConfigEditor implements SettingsValueProvider, AfterViewInit, OnDestroy {
+    inputs: PraxisFilesUploadWidgetEditorInputs | null;
+    widgetKey?: string;
+    uploadEditor?: PraxisFilesUploadConfigEditor;
+    readonly isDirty$: BehaviorSubject<boolean>;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    private readonly subscription;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getSettingsValue(): PraxisFilesUploadWidgetEditorValue;
+    onSave(): PraxisFilesUploadWidgetEditorValue;
+    reset(): void;
+    private initializeChildEditor;
+    private buildValue;
+    private normalizeEditorPatch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilesUploadWidgetConfigEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilesUploadWidgetConfigEditor, "praxis-files-upload-widget-config-editor", never, { "inputs": { "alias": "inputs"; "required": false; }; "widgetKey": { "alias": "widgetKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
 declare const FILES_UPLOAD_EN_US: {
     'praxis.filesUpload.editor.summary.ariaLabel': string;
     'praxis.filesUpload.editor.summary.title': string;
@@ -1465,5 +1498,7 @@ interface CapabilityCatalog extends AiCapabilityCatalog {
 }
 declare const FILES_UPLOAD_AI_CAPABILITIES: CapabilityCatalog;
 
-export { BulkUploadResultStatus, ErrorCode, ErrorMapperService, FILES_UPLOAD_AI_CAPABILITIES, FILES_UPLOAD_EN_US, FILES_UPLOAD_ERROR_MESSAGES, FILES_UPLOAD_PT_BR, FILES_UPLOAD_TEXTS, FilesApiClient, PRAXIS_FILES_UPLOAD_COMPONENT_METADATA, PdxFilesUploadFieldComponent, PraxisFilesUpload, PraxisFilesUploadConfigEditor, PresignedUploaderService, ScanStatus, TRANSLATE_LIKE, acceptValidator, createPraxisFilesUploadI18nConfig, getPrimaryErrorItem, isErrorEnvelope, maxBulkSizeValidator, maxFileSizeValidator, maxFilesPerBulkValidator, providePraxisFilesUploadI18n, providePraxisFilesUploadMetadata, resolvePraxisFilesUploadText };
-export type { ApiErrorEnvelope, ApiErrorItem, ApiResponseStatus, ApiSuccessEnvelope, BulkConfig, BulkUploadFile, BulkUploadFileResult, BulkUploadOptions, BulkUploadResponse, BulkUploadResponseData, Capability, CapabilityCatalog, CapabilityCategory, EffectiveUploadConfig, ErrorLike, ErrorResponse, FileMetadata, FileUploadOptions, FilesUploadBackendOptionsConfig, FilesUploadConfig, FilesUploadExecutionConfig, FilesUploadHeadersConfig, FilesUploadMessagesConfig, FilesUploadQuotaFeedbackConfig, FilesUploadRateLimitFeedbackConfig, FilesUploadReadinessEvent, FilesUploadReadySource, FilesUploadReadyState, FilesUploadStrategy, FilesUploadTexts, FilesUploadValidationConfig, FilesUploadVisualConfig, MappedError, Metadata, PendingFilesState, PraxisFilesUploadI18nOptions, PresignResponse, QuotasConfig, RateLimitConfig, RateLimitInfo, ServerMessages, TranslateLike, UploadOptions, UploadProgressEvent, UploadResponse, UploadResponseData, UploadStartEvent, ValueKind };
+declare const PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
+export { BulkUploadResultStatus, ErrorCode, ErrorMapperService, FILES_UPLOAD_AI_CAPABILITIES, FILES_UPLOAD_EN_US, FILES_UPLOAD_ERROR_MESSAGES, FILES_UPLOAD_PT_BR, FILES_UPLOAD_TEXTS, FilesApiClient, PRAXIS_FILES_UPLOAD_AUTHORING_MANIFEST, PRAXIS_FILES_UPLOAD_COMPONENT_METADATA, PdxFilesUploadFieldComponent, PraxisFilesUpload, PraxisFilesUploadConfigEditor, PraxisFilesUploadWidgetConfigEditor, PresignedUploaderService, ScanStatus, TRANSLATE_LIKE, acceptValidator, createPraxisFilesUploadI18nConfig, getPrimaryErrorItem, isErrorEnvelope, maxBulkSizeValidator, maxFileSizeValidator, maxFilesPerBulkValidator, providePraxisFilesUploadI18n, providePraxisFilesUploadMetadata, resolvePraxisFilesUploadText };
+export type { ApiErrorEnvelope, ApiErrorItem, ApiResponseStatus, ApiSuccessEnvelope, BulkConfig, BulkUploadFile, BulkUploadFileResult, BulkUploadOptions, BulkUploadResponse, BulkUploadResponseData, Capability, CapabilityCatalog, CapabilityCategory, EffectiveUploadConfig, ErrorLike, ErrorResponse, FileMetadata, FileUploadOptions, FilesUploadBackendOptionsConfig, FilesUploadConfig, FilesUploadExecutionConfig, FilesUploadHeadersConfig, FilesUploadMessagesConfig, FilesUploadQuotaFeedbackConfig, FilesUploadRateLimitFeedbackConfig, FilesUploadReadinessEvent, FilesUploadReadySource, FilesUploadReadyState, FilesUploadStrategy, FilesUploadTexts, FilesUploadValidationConfig, FilesUploadVisualConfig, MappedError, Metadata, PendingFilesState, PraxisFilesUploadI18nOptions, PraxisFilesUploadWidgetEditorInputs, PraxisFilesUploadWidgetEditorValue, PresignResponse, QuotasConfig, RateLimitConfig, RateLimitInfo, ServerMessages, TranslateLike, UploadOptions, UploadProgressEvent, UploadResponse, UploadResponseData, UploadStartEvent, ValueKind };

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@praxisui/files-upload",
-  "version": "8.0.0-beta.3",
+  "version": "8.0.0-beta.31",
   "description": "File upload components and services for Praxis UI with presigned and direct strategies, quotas and rate-limit handling.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
     "@angular/cdk": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/material": "^20.0.0",
-    "@praxisui/core": "^8.0.0-beta.3",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.3",
-    "@praxisui/settings-panel": "^8.0.0-beta.3"
+    "@praxisui/core": "^8.0.0-beta.31",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.31",
+    "@praxisui/settings-panel": "^8.0.0-beta.31",
+    "@angular/forms": "^20.0.0",
+    "@angular/router": "^20.0.0",
+    "@praxisui/ai": "^8.0.0-beta.31",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"