@praxisui/files-upload 8.0.0-beta.0 → 8.0.0-beta.11

package/README.md

@@ -271,6 +271,25 @@ 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`.
+
 ## 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

@@ -1063,7 +1063,7 @@ function createPraxisFilesUploadI18nConfig(options = {}) {
         };
     }
     return {
-        locale: options.locale,
+        locale: options.locale ?? 'pt-BR',
         fallbackLocale: options.fallbackLocale ?? 'pt-BR',
         dictionaries,
     };
@@ -3775,7 +3775,7 @@ class PraxisFilesUpload {
         return this.t('selectFiles', 'Selecionar arquivo(s)');
     }
     get policySummaryAriaLabel() {
-        return this.t('policySummaryAction', 'Informacoes sobre politicas de upload');
+        return this.t('policySummaryAction', 'Informações sobre políticas de upload');
     }
     pendingFileRemoveAriaLabel(file) {
         return `${this.t('removePendingFile', 'Remover arquivo selecionado')}: ${file.name}`;
@@ -3976,14 +3976,15 @@ class PraxisFilesUpload {
         }
         const optionsJson = this.buildOptionsJson(metadataObj);
         const strategy = this.config?.strategy ?? 'direct';
+        const isBulkMode = this.shouldUseBulkMode(files);
         this.uploadStart.emit({
             files,
-            mode: files.length > 1 && this.allowMultiple ? 'bulk' : 'single',
+            mode: isBulkMode ? 'bulk' : 'single',
             strategy,
             filesUploadId: this.filesUploadId || undefined,
             baseUrl: this.baseUrl,
         });
-        if (files.length > 1 && this.allowMultiple) {
+        if (isBulkMode) {
             this.uploadMultipleFiles(files, strategy, metadataObj, optionsJson);
         }
         else if (strategy === 'presign' || strategy === 'auto') {
@@ -4060,6 +4061,13 @@ class PraxisFilesUpload {
             });
         }
     }
+    shouldUseBulkMode(files) {
+        const maxFilesPerBulk = this.config?.limits?.maxFilesPerBulk;
+        const allowsBulk = maxFilesPerBulk !== undefined
+            ? maxFilesPerBulk > 1
+            : this.allowMultiple;
+        return files.length > 1 && allowsBulk;
+    }
     directUpload(file, options) {
         const api = this.requireApiClient();
         const baseUrl = this.requireBaseUrl();
@@ -5622,8 +5630,8 @@ class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
         this.control().markAsTouched();
         this.control().markAsDirty();
     }
-    clearUploadState() {
-        this.updateUploadValidationState();
+    clearUploadState(externalErrors) {
+        this.updateUploadValidationState(undefined, externalErrors);
         this.uploadError = null;
     }
     applyUploadErrorState(message, validationKey) {
@@ -5640,8 +5648,9 @@ class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
         return `${extraFiles} ${this.t('fieldChipAria', 'arquivos adicionais selecionados')}`;
     }
     onUploadSuccess(file) {
+        const externalErrors = this.getNonUploadErrors();
         this.applyResolvedValue(file);
-        this.clearUploadState();
+        this.clearUploadState(externalErrors);
         this.batchCount = 1;
         this.uploadSuccess.emit(file);
     }
@@ -5784,6 +5793,7 @@ class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
     onOpenInfo() { }
     onOpenMenu() { }
     onClear() {
+        const externalErrors = this.getNonUploadErrors();
         this.lastFileName = null;
         this.batchCount = 0;
         this.uploadError = null;
@@ -5794,7 +5804,7 @@ class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
             const c = this.control();
             c.markAsPristine();
             c.markAsUntouched();
-            this.updateUploadValidationState();
+            this.updateUploadValidationState(undefined, externalErrors);
         }
         catch { }
     }
@@ -5840,14 +5850,19 @@ class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
             this.pendingPanel?.nativeElement.focus();
         });
     }
-    updateUploadValidationState(validationKey) {
+    getNonUploadErrors() {
         const currentErrors = { ...(this.control().errors ?? {}) };
         delete currentErrors.upload;
         delete currentErrors.uploadPartial;
+        return currentErrors;
+    }
+    updateUploadValidationState(validationKey, baseErrors) {
+        const control = this.control();
+        const currentErrors = { ...(baseErrors ?? this.getNonUploadErrors()) };
         if (validationKey) {
             currentErrors[validationKey] = true;
         }
-        this.control().setErrors(Object.keys(currentErrors).length ? currentErrors : null);
+        control.setErrors(Object.keys(currentErrors).length ? currentErrors : null);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PdxFilesUploadFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: PdxFilesUploadFieldComponent, isStandalone: true, selector: "pdx-material-files-upload", inputs: { config: "config", valueMode: "valueMode", baseUrl: "baseUrl" }, outputs: { uploadSuccess: "uploadSuccess", bulkComplete: "bulkComplete", error: "error" }, host: { properties: { "class": "componentCssClasses()", "attr.data-field-type": "\"files-upload\"", "attr.data-field-name": "metadata()?.name", "attr.data-component-id": "componentId()" } }, providers: [providePraxisFilesUploadI18n()], viewQueries: [{ propertyName: "uploader", first: true, predicate: ["uploader"], descendants: true }, { propertyName: "pendingTrigger", first: true, predicate: ["pendingTrigger"], descendants: true }, { propertyName: "pendingPanel", first: true, predicate: ["pendingPanel"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
@@ -6343,6 +6358,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',
@@ -6544,10 +6565,305 @@ const FILES_UPLOAD_AI_CAPABILITIES = {
     ],
 };
 
+const conflictPolicyEnum = ['ERROR', 'SKIP', 'OVERWRITE', 'MAKE_UNIQUE', 'RENAME'];
+const displayModeEnum = ['full', 'compact'];
+const strategyEnum = ['direct', 'presign', 'auto'];
+const endpointInputSchema = {
+    type: 'object',
+    required: ['baseUrl'],
+    properties: {
+        baseUrl: { type: 'string' },
+        strategy: { enum: strategyEnum },
+        allowCrossOriginPresignedTarget: { type: 'boolean' },
+    },
+};
+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: displayModeEnum, 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' },
+            ],
+            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: true,
+            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' },
+            ],
+            validators: ['size-limit-numeric', 'size-limit-within-platform-policy', 'size-limit-client-backend-consistent', 'editor-runtime-round-trip'],
+            affectedPaths: ['limits.maxFileSizeBytes', 'options.maxUploadSizeMb'],
+            submissionImpact: true,
+            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' },
+            ],
+            validators: ['file-count-limit-numeric', 'bulk-size-limit-numeric', 'bulk-limit-within-platform-policy', 'editor-runtime-round-trip'],
+            affectedPaths: ['limits.maxFilesPerBulk', 'limits.maxBulkSizeBytes'],
+            submissionImpact: true,
+            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: endpointInputSchema,
+            effects: [{
+                    kind: 'compile-domain-patch',
+                    handler: 'files-upload-presign-base-url',
+                    handlerContract: {
+                        reads: ['baseUrl', 'strategy', 'config.strategy'],
+                        writes: ['baseUrl', 'config.strategy'],
+                        identityKeys: ['baseUrl'],
+                        inputSchema: endpointInputSchema,
+                        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: true,
+            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: endpointInputSchema,
+            effects: [{
+                    kind: 'compile-domain-patch',
+                    handler: 'files-upload-direct-base-url',
+                    handlerContract: {
+                        reads: ['baseUrl', 'strategy', 'config.strategy'],
+                        writes: ['baseUrl', 'config.strategy'],
+                        identityKeys: ['baseUrl'],
+                        inputSchema: endpointInputSchema,
+                        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: true,
+            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: conflictPolicyEnum },
+                    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: true,
+            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' }],
+            validators: ['error-code-known', 'error-message-i18n-compatible', 'message-not-empty', 'editor-runtime-round-trip'],
+            affectedPaths: ['messages.errors'],
+            submissionImpact: false,
+            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: displayModeEnum },
+                    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' },
+            ],
+            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: false,
+            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, 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';
@@ -384,7 +384,7 @@ declare const FILES_UPLOAD_TEXTS: InjectionToken<FilesUploadTexts>;
 /** @deprecated Transitional compatibility token. Prefer PraxisI18nService. */
 declare const TRANSLATE_LIKE: InjectionToken<TranslateLike>;
 declare function createPraxisFilesUploadI18nConfig(options?: PraxisFilesUploadI18nOptions): Partial<PraxisI18nConfig>;
-declare function providePraxisFilesUploadI18n(options?: PraxisFilesUploadI18nOptions): i0.Provider;
+declare function providePraxisFilesUploadI18n(options?: PraxisFilesUploadI18nOptions): i0.Provider[];
 declare function resolvePraxisFilesUploadText(i18n: PraxisI18nService, key: string, fallback: string, legacyTexts?: FilesUploadTexts, legacyTranslate?: TranslateLike): string;
 
 interface RateLimitInfo {
@@ -631,6 +631,7 @@ declare class PraxisFilesUpload implements OnInit, OnChanges, AfterViewInit, OnD
     removePendingFile(file: File): void;
     private emitPendingState;
     private startUpload;
+    private shouldUseBulkMode;
     private directUpload;
     private uploadMultipleFiles;
     private uploadMultipleFilesDirect;
@@ -732,6 +733,7 @@ declare class PdxFilesUploadFieldComponent extends SimpleBaseInputComponent {
     pendingFileSummary(file: File): string;
     formatBytes(bytes: number): string;
     private focusPendingPanelSoon;
+    private getNonUploadErrors;
     private updateUploadValidationState;
     static ɵfac: i0.ɵɵFactoryDeclaration<PdxFilesUploadFieldComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PdxFilesUploadFieldComponent, "pdx-material-files-upload", never, { "config": { "alias": "config"; "required": false; }; "valueMode": { "alias": "valueMode"; "required": false; }; "baseUrl": { "alias": "baseUrl"; "required": false; }; }, { "uploadSuccess": "uploadSuccess"; "bulkComplete": "bulkComplete"; "error": "error"; }, never, never, true, never>;
@@ -1463,5 +1465,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 };
+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, 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 };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@praxisui/files-upload",
-  "version": "8.0.0-beta.0",
+  "version": "8.0.0-beta.11",
   "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.0",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.0",
-    "@praxisui/settings-panel": "^8.0.0-beta.0"
+    "@praxisui/core": "^8.0.0-beta.11",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.11",
+    "@praxisui/settings-panel": "^8.0.0-beta.11"
   },
   "dependencies": {
     "tslib": "^2.3.0"