@researchdatabox/sails-ng-common 5.0.3 → 5.0.4-beta.12498

package/dist/src/record-save.model.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Contracts shared by the browser and server for record-save operations.
+ *
+ * These are deliberately data-only contracts.  The server and Angular
+ * packages provide their own runtime response classes while this package
+ * remains safe to consume from either side of the application.
+ */
+import { LineagePathsOptional, LineagePathsPartial } from './config/names/naming-helpers';
+import type { RecordConcurrencyMetadata } from './record-concurrency.model';
+export interface ActionResult {
+    /** True when the requested primary action was completed. */
+    success: boolean;
+    /** The record identifier, when one is known. */
+    oid: string;
+    /** Compatibility summary for legacy callers. */
+    message: string;
+    /** Action-specific response data. */
+    data?: unknown;
+    /** Authoritative server-projected metadata, or null when unavailable. */
+    metadata: Record<string, unknown> | null;
+}
+export type RecordSaveOutcome = 'saved' | 'saved-with-warnings' | 'not-saved' | 'unknown';
+export declare const RECORD_SAVE_PROBLEM_KINDS: readonly ["validation", "processing", "authorization", "conflict", "system", "network"];
+export type RecordSaveProblemKind = (typeof RECORD_SAVE_PROBLEM_KINDS)[number];
+export type RecordSaveProblemSource = 'schema';
+export type RecordSaveLifecyclePhase = 'pre-save' | 'persistence' | 'attachments' | 'post-save' | 'response' | 'transport';
+export type RecordSavePhase = 'schema' | RecordSaveLifecyclePhase;
+export type RecordSaveValidatorParameterPrimitive = string | number | boolean | null;
+export type RecordSaveValidatorParameterValue = RecordSaveValidatorParameterPrimitive | RecordSaveValidatorParameterPrimitive[];
+export type RecordSaveValidatorParameters = Record<string, RecordSaveValidatorParameterValue>;
+export declare const RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS: {
+    readonly maxEntries: 16;
+    readonly maxKeyLength: 64;
+    readonly maxStringLength: 256;
+    readonly maxArrayLength: 16;
+    readonly maxSerializedLength: 4096;
+};
+export declare const RECORD_SAVE_VALIDATOR_CLASS_MAX_LENGTH = 128;
+export declare const RECORD_SAVE_MESSAGE_MAX_LENGTH = 1024;
+export declare const RECORD_SAVE_VALIDATOR_PARAMETER_KEY_PATTERN: RegExp;
+export declare const RECORD_SAVE_PUBLIC_FIELD_LIMITS: {
+    readonly maxCodeLength: 128;
+    readonly maxFieldLength: 128;
+    readonly maxPointerLength: 2048;
+    readonly maxAttachmentIdLength: 128;
+};
+export declare const RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN: RegExp;
+export declare const RECORD_SAVE_EXPECTED_JSON_TYPES: readonly ["array", "boolean", "integer", "null", "number", "object", "string"];
+export type RecordSaveExpectedJsonType = (typeof RECORD_SAVE_EXPECTED_JSON_TYPES)[number];
+export interface RecordSaveIssueExpectedShape {
+    type: RecordSaveExpectedJsonType;
+}
+export declare const RECORD_SAVE_LINEAGE_LIMITS: {
+    readonly maxSegments: 64;
+    readonly maxSegmentLength: 128;
+    readonly maxPointerLength: 2048;
+};
+export interface RecordSaveIssue {
+    /** A safe, stable identifier suitable for translation or support lookup. */
+    code?: string;
+    /** Safe user-facing text. Raw provider/exception text must not be placed here. */
+    message: string;
+    /** Configured form field name, when the issue maps unambiguously. */
+    field?: string;
+    /** JSON pointer into Angular or record metadata, when available. */
+    pointer?: string;
+    /** Narrow structural expectation safe to expose for schema type failures. */
+    expected?: RecordSaveIssueExpectedShape;
+    /** Logical attachment identity, never a storage key or path. */
+    attachmentId?: string;
+    /** Validator implementation class, when this is a validator failure. */
+    class?: string;
+    /** Bounded scalar parameters used to render a configured validator message. */
+    params?: RecordSaveValidatorParameters;
+    /** Validator-configured field ownership override. */
+    targetField?: LineagePathsPartial;
+    /** Lineage of the field or form control that produced the issue. */
+    lineagePaths?: LineagePathsOptional;
+}
+/** True only for root or syntactically valid RFC 6901 JSON pointers. */
+export declare function isRecordSaveJsonPointer(value: unknown): value is string;
+/** Remove non-allowlisted, executable, excessive, and otherwise unsafe validator parameters. */
+export declare function sanitizeRecordSaveValidatorParameters(value: unknown, validatorClass?: unknown): RecordSaveValidatorParameters | undefined;
+/**
+ * Copy only the public issue allowlist and normalize bounded validator/lineage
+ * metadata. This is suitable for a response serialization boundary.
+ */
+export declare function sanitizeRecordSaveIssue(value: unknown): RecordSaveIssue;
+export interface RecordSaveSchemaProblem {
+    kind: RecordSaveProblemKind;
+    source: RecordSaveProblemSource;
+    phase: 'schema';
+    issues: RecordSaveIssue[];
+}
+export interface RecordSaveLifecycleProblem {
+    kind: RecordSaveProblemKind;
+    source?: never;
+    phase: RecordSaveLifecyclePhase;
+    issues: RecordSaveIssue[];
+}
+/** A nonblocking form suggestion, distinct from incomplete save work. */
+export interface RecordSaveAdvisoryProblem {
+    kind: 'validation';
+    source: 'advisory';
+    phase: 'pre-save' | 'post-save';
+    issues: RecordSaveIssue[];
+}
+/** Provenance and phase form one discriminated contract. */
+export type RecordSaveProblem = RecordSaveSchemaProblem | RecordSaveLifecycleProblem | RecordSaveAdvisoryProblem;
+export type RecordAttachmentOperation = 'add' | 'finalize' | 'delete';
+export type RecordAttachmentItemStatus = 'completed' | 'incomplete' | 'unknown';
+export type RecordAttachmentCompletionStatus = 'not-required' | 'completed' | 'incomplete' | 'unknown';
+export interface RecordAttachmentCompletionItem {
+    field: string;
+    attachmentId: string;
+    fileId?: string;
+    operation: RecordAttachmentOperation;
+    status: RecordAttachmentItemStatus;
+    /** A safe, bounded code such as attachment-reupload-required. */
+    code?: string;
+}
+export interface RecordAttachmentCompletion {
+    status: RecordAttachmentCompletionStatus;
+    items: RecordAttachmentCompletionItem[];
+}
+export interface RecordSaveCompletion {
+    attachments: RecordAttachmentCompletion;
+}
+export interface RecordSaveResult extends ActionResult {
+    outcome: RecordSaveOutcome;
+    problems: RecordSaveProblem[];
+    completion: RecordSaveCompletion;
+    requestId: string;
+    concurrency?: RecordConcurrencyMetadata;
+}
+/** A schema warning can coexist with a complete save; unfinished work cannot. */
+export declare function isRecordSaveComplete(result: Pick<RecordSaveResult, 'outcome' | 'problems' | 'completion'>): boolean;
+export type StorageMutationApplicationState = 'applied' | 'not-applied' | 'unknown';
+export declare function emptyRecordSaveCompletion(): RecordSaveCompletion;
+/**
+ * Reduce item-level attachment facts into the public aggregate status.
+ * Unknown takes precedence over incomplete because it represents less
+ * certainty about the physical operation.
+ */
+export declare function reduceAttachmentStatus(items: readonly RecordAttachmentCompletionItem[]): RecordAttachmentCompletionStatus;
+export declare function isRecordSaveOutcome(value: unknown): value is RecordSaveOutcome;
+export declare function isRecordSaveProblemKind(value: unknown): value is RecordSaveProblemKind;
+/**
+ * Canonical save request-correlation identifier: one RFC 4122 UUID. It is
+ * correlation only and is never treated as an idempotency key.
+ */
+export declare const RECORD_SAVE_REQUEST_ID_PATTERN: RegExp;
+export declare const RECORD_SAVE_REQUEST_ID_MAX_LENGTH = 36;
+export declare function isRecordSaveRequestId(value: unknown): value is string;

package/dist/src/record-save.model.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Contracts shared by the browser and server for record-save operations.
+ *
+ * These are deliberately data-only contracts.  The server and Angular
+ * packages provide their own runtime response classes while this package
+ * remains safe to consume from either side of the application.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_SAVE_REQUEST_ID_MAX_LENGTH = exports.RECORD_SAVE_REQUEST_ID_PATTERN = exports.RECORD_SAVE_LINEAGE_LIMITS = exports.RECORD_SAVE_EXPECTED_JSON_TYPES = exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN = exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS = exports.RECORD_SAVE_VALIDATOR_PARAMETER_KEY_PATTERN = exports.RECORD_SAVE_MESSAGE_MAX_LENGTH = exports.RECORD_SAVE_VALIDATOR_CLASS_MAX_LENGTH = exports.RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS = exports.RECORD_SAVE_PROBLEM_KINDS = void 0;
+exports.isRecordSaveJsonPointer = isRecordSaveJsonPointer;
+exports.sanitizeRecordSaveValidatorParameters = sanitizeRecordSaveValidatorParameters;
+exports.sanitizeRecordSaveIssue = sanitizeRecordSaveIssue;
+exports.isRecordSaveComplete = isRecordSaveComplete;
+exports.emptyRecordSaveCompletion = emptyRecordSaveCompletion;
+exports.reduceAttachmentStatus = reduceAttachmentStatus;
+exports.isRecordSaveOutcome = isRecordSaveOutcome;
+exports.isRecordSaveProblemKind = isRecordSaveProblemKind;
+exports.isRecordSaveRequestId = isRecordSaveRequestId;
+const plain_record_1 = require("./internal/plain-record");
+exports.RECORD_SAVE_PROBLEM_KINDS = [
+    'validation',
+    'processing',
+    'authorization',
+    'conflict',
+    'system',
+    'network',
+];
+exports.RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS = {
+    maxEntries: 16,
+    maxKeyLength: 64,
+    maxStringLength: 256,
+    maxArrayLength: 16,
+    maxSerializedLength: 4_096,
+};
+exports.RECORD_SAVE_VALIDATOR_CLASS_MAX_LENGTH = 128;
+exports.RECORD_SAVE_MESSAGE_MAX_LENGTH = 1_024;
+exports.RECORD_SAVE_VALIDATOR_PARAMETER_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS = {
+    maxCodeLength: 128,
+    maxFieldLength: 128,
+    maxPointerLength: 2_048,
+    maxAttachmentIdLength: 128,
+};
+exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+exports.RECORD_SAVE_EXPECTED_JSON_TYPES = [
+    'array',
+    'boolean',
+    'integer',
+    'null',
+    'number',
+    'object',
+    'string',
+];
+exports.RECORD_SAVE_LINEAGE_LIMITS = {
+    maxSegments: 64,
+    maxSegmentLength: 128,
+    maxPointerLength: 2_048,
+};
+/** True only for root or syntactically valid RFC 6901 JSON pointers. */
+function isRecordSaveJsonPointer(value) {
+    if (typeof value !== 'string' || (value !== '' && !value.startsWith('/'))) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] !== '~')
+            continue;
+        const escaped = value[index + 1];
+        if (escaped !== '0' && escaped !== '1')
+            return false;
+        index += 1;
+    }
+    return true;
+}
+function sanitizeRecordSaveIssueExpected(value) {
+    if (!(0, plain_record_1.isPlainRecord)(value))
+        return undefined;
+    const type = value.type;
+    return typeof type === 'string' && exports.RECORD_SAVE_EXPECTED_JSON_TYPES.includes(type)
+        ? { type: type }
+        : undefined;
+}
+/**
+ * Validator parameters are not a generic public bag. This allowlist contains
+ * only bounded derived facts needed by shipped translations; submitted values,
+ * configured patterns/expressions/descriptions, and provider details stay
+ * server-side.
+ */
+const PUBLIC_VALIDATOR_PARAMETER_RULES = {
+    min: { requiredThreshold: 'number' },
+    max: { requiredThreshold: 'number' },
+    minLength: { actualLength: 'number', requiredLength: 'number' },
+    maxLength: { actualLength: 'number', requiredLength: 'number' },
+    required: { required: 'boolean' },
+    requiredTrue: { required: 'boolean' },
+    'different-values': { controlCount: 'number', valueCount: 'number' },
+    'typeahead-source': { multiSelect: 'boolean', sourceType: 'source-type' },
+};
+function safeValidatorParameterForRule(value, rule) {
+    if (rule === 'number')
+        return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    if (rule === 'boolean')
+        return typeof value === 'boolean' ? value : undefined;
+    return value === 'static' || value === 'vocabulary' || value === 'query' || value === 'service' ? value : undefined;
+}
+/** Remove non-allowlisted, executable, excessive, and otherwise unsafe validator parameters. */
+function sanitizeRecordSaveValidatorParameters(value, validatorClass) {
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return undefined;
+    }
+    const rules = typeof validatorClass === 'string' ? PUBLIC_VALIDATOR_PARAMETER_RULES[validatorClass] : undefined;
+    if (!rules)
+        return undefined;
+    const result = {};
+    let acceptedEntries = 0;
+    for (const [key, rawValue] of Object.entries(value)) {
+        if (acceptedEntries >= exports.RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS.maxEntries) {
+            break;
+        }
+        if (!exports.RECORD_SAVE_VALIDATOR_PARAMETER_KEY_PATTERN.test(key) ||
+            key.length > exports.RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS.maxKeyLength) {
+            continue;
+        }
+        const rule = rules[key];
+        const safeValue = rule ? safeValidatorParameterForRule(rawValue, rule) : undefined;
+        if (safeValue === undefined) {
+            continue;
+        }
+        const candidate = { ...result, [key]: safeValue };
+        if (JSON.stringify(candidate).length <= exports.RECORD_SAVE_VALIDATOR_PARAMETER_LIMITS.maxSerializedLength) {
+            result[key] = safeValue;
+            acceptedEntries += 1;
+        }
+    }
+    return acceptedEntries > 0 ? result : undefined;
+}
+function sanitizeLineagePath(value) {
+    if (!Array.isArray(value) || value.length > exports.RECORD_SAVE_LINEAGE_LIMITS.maxSegments) {
+        return undefined;
+    }
+    const result = [];
+    for (const segment of value) {
+        if (typeof segment === 'string') {
+            if (segment.length > exports.RECORD_SAVE_LINEAGE_LIMITS.maxSegmentLength) {
+                return undefined;
+            }
+            result.push(segment);
+        }
+        else if (typeof segment === 'number' && Number.isSafeInteger(segment) && segment >= 0) {
+            result.push(segment);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return result;
+}
+function sanitizeLineagePathProperties(value) {
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return undefined;
+    }
+    const result = {};
+    for (const key of ['formConfig', 'dataModel', 'angularComponents', 'layout']) {
+        if (value[key] !== undefined) {
+            const path = sanitizeLineagePath(value[key]);
+            if (path !== undefined) {
+                result[key] = path;
+            }
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function sanitizeLineagePaths(value) {
+    if (!(0, plain_record_1.isPlainRecord)(value)) {
+        return undefined;
+    }
+    const result = sanitizeLineagePathProperties(value) ?? {};
+    for (const key of ['angularComponentsJsonPointer', 'layoutJsonPointer']) {
+        const pointer = value[key];
+        if (typeof pointer === 'string' && pointer.length <= exports.RECORD_SAVE_LINEAGE_LIMITS.maxPointerLength) {
+            result[key] = pointer;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/**
+ * Copy only the public issue allowlist and normalize bounded validator/lineage
+ * metadata. This is suitable for a response serialization boundary.
+ */
+function sanitizeRecordSaveIssue(value) {
+    const item = (0, plain_record_1.isPlainRecord)(value) ? value : {};
+    const issue = {
+        message: typeof item.message === 'string' ? item.message.slice(0, exports.RECORD_SAVE_MESSAGE_MAX_LENGTH) : '',
+    };
+    const code = item.code;
+    if (typeof code === 'string' &&
+        code.length <= exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS.maxCodeLength &&
+        exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN.test(code))
+        issue.code = code;
+    const field = item.field;
+    if (typeof field === 'string' &&
+        field.length <= exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS.maxFieldLength &&
+        exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN.test(field))
+        issue.field = field;
+    const pointer = item.pointer;
+    if (isRecordSaveJsonPointer(pointer) && pointer.length <= exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS.maxPointerLength)
+        issue.pointer = pointer;
+    const expected = sanitizeRecordSaveIssueExpected(item.expected);
+    if (expected !== undefined) {
+        issue.expected = expected;
+    }
+    const attachmentId = item.attachmentId;
+    if (typeof attachmentId === 'string' &&
+        attachmentId.length <= exports.RECORD_SAVE_PUBLIC_FIELD_LIMITS.maxAttachmentIdLength &&
+        exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN.test(attachmentId))
+        issue.attachmentId = attachmentId;
+    if (typeof item.class === 'string' &&
+        item.class.length <= exports.RECORD_SAVE_VALIDATOR_CLASS_MAX_LENGTH &&
+        exports.RECORD_SAVE_PUBLIC_IDENTIFIER_PATTERN.test(item.class)) {
+        issue.class = item.class;
+    }
+    const params = sanitizeRecordSaveValidatorParameters(item.params, issue.class);
+    if (params !== undefined) {
+        issue.params = params;
+    }
+    const targetField = sanitizeLineagePathProperties(item.targetField);
+    if (targetField !== undefined) {
+        issue.targetField = targetField;
+    }
+    const lineagePaths = sanitizeLineagePaths(item.lineagePaths);
+    if (lineagePaths !== undefined) {
+        issue.lineagePaths = lineagePaths;
+    }
+    return issue;
+}
+/** A schema warning can coexist with a complete save; unfinished work cannot. */
+function isRecordSaveComplete(result) {
+    const attachmentStatus = result.completion?.attachments?.status;
+    if (attachmentStatus !== 'not-required' && attachmentStatus !== 'completed') {
+        return false;
+    }
+    if (result.outcome === 'saved')
+        return true;
+    if (result.outcome !== 'saved-with-warnings')
+        return false;
+    return result.problems.length > 0 &&
+        result.problems.every(problem => problem.source === 'schema' || problem.source === 'advisory');
+}
+function emptyRecordSaveCompletion() {
+    return {
+        attachments: {
+            status: 'not-required',
+            items: [],
+        },
+    };
+}
+/**
+ * Reduce item-level attachment facts into the public aggregate status.
+ * Unknown takes precedence over incomplete because it represents less
+ * certainty about the physical operation.
+ */
+function reduceAttachmentStatus(items) {
+    if (items.length === 0) {
+        return 'not-required';
+    }
+    if (items.some(item => item.status === 'unknown')) {
+        return 'unknown';
+    }
+    if (items.some(item => item.status === 'incomplete')) {
+        return 'incomplete';
+    }
+    return 'completed';
+}
+function isRecordSaveOutcome(value) {
+    return value === 'saved' || value === 'saved-with-warnings' || value === 'not-saved' || value === 'unknown';
+}
+function isRecordSaveProblemKind(value) {
+    return typeof value === 'string' && exports.RECORD_SAVE_PROBLEM_KINDS.includes(value);
+}
+/**
+ * Canonical save request-correlation identifier: one RFC 4122 UUID. It is
+ * correlation only and is never treated as an idempotency key.
+ */
+exports.RECORD_SAVE_REQUEST_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+exports.RECORD_SAVE_REQUEST_ID_MAX_LENGTH = 36;
+function isRecordSaveRequestId(value) {
+    return typeof value === 'string' && exports.RECORD_SAVE_REQUEST_ID_PATTERN.test(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-save.model.js","sourceRoot":"","sources":["../../src/record-save.model.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAoHH,0DAWC;AAwCD,sFAkCC;AAwDD,0DAqDC;AA2DD,oDASC;AAID,8DAOC;AAOD,wDAaC;AAED,kDAEC;AAED,0DAEC;AAWD,sDAEC;AA3aD,0DAAwD;AAoB3C,QAAA,yBAAyB,GAAG;IACvC,YAAY;IACZ,YAAY;IACZ,eAAe;IACf,UAAU;IACV,QAAQ;IACR,SAAS;CACD,CAAC;AAqBE,QAAA,sCAAsC,GAAG;IACpD,UAAU,EAAE,EAAE;IACd,YAAY,EAAE,EAAE;IAChB,eAAe,EAAE,GAAG;IACpB,cAAc,EAAE,EAAE;IAClB,mBAAmB,EAAE,KAAK;CAClB,CAAC;AAEE,QAAA,sCAAsC,GAAG,GAAG,CAAC;AAC7C,QAAA,8BAA8B,GAAG,KAAK,CAAC;AACvC,QAAA,2CAA2C,GAAG,2BAA2B,CAAC;AAC1E,QAAA,+BAA+B,GAAG;IAC7C,aAAa,EAAE,GAAG;IAClB,cAAc,EAAE,GAAG;IACnB,gBAAgB,EAAE,KAAK;IACvB,qBAAqB,EAAE,GAAG;CAClB,CAAC;AACE,QAAA,qCAAqC,GAAG,+BAA+B,CAAC;AAExE,QAAA,+BAA+B,GAAG;IAC7C,OAAO;IACP,SAAS;IACT,SAAS;IACT,MAAM;IACN,QAAQ;IACR,QAAQ;IACR,QAAQ;CACA,CAAC;AAQE,QAAA,0BAA0B,GAAG;IACxC,WAAW,EAAE,EAAE;IACf,gBAAgB,EAAE,GAAG;IACrB,gBAAgB,EAAE,KAAK;CACf,CAAC;AAyBX,wEAAwE;AACxE,SAAgB,uBAAuB,CAAC,KAAc;IACpD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QAC1E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACrD,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG;YAAE,SAAS;QACnC,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QACjC,IAAI,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,GAAG;YAAE,OAAO,KAAK,CAAC;QACrD,KAAK,IAAI,CAAC,CAAC;IACb,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,+BAA+B,CAAC,KAAc;IACrD,IAAI,CAAC,IAAA,4BAAa,EAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACxB,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAK,uCAAqD,CAAC,QAAQ,CAAC,IAAI,CAAC;QACtG,CAAC,CAAC,EAAE,IAAI,EAAE,IAAkC,EAAE;QAC9C,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAGD;;;;;GAKG;AACH,MAAM,gCAAgC,GAElC;IACF,GAAG,EAAE,EAAE,iBAAiB,EAAE,QAAQ,EAAE;IACpC,GAAG,EAAE,EAAE,iBAAiB,EAAE,QAAQ,EAAE;IACpC,SAAS,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE;IAC/D,SAAS,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE;IAC/D,QAAQ,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;IACjC,YAAY,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;IACrC,kBAAkB,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE;IACpE,kBAAkB,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE;CAC1E,CAAC;AAEF,SAAS,6BAA6B,CACpC,KAAc,EACd,IAAkC;IAElC,IAAI,IAAI,KAAK,QAAQ;QAAE,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtG,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,YAAY,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AACtH,CAAC;AAED,gGAAgG;AAChG,SAAgB,qCAAqC,CACnD,KAAc,EACd,cAAwB;IAExB,IAAI,CAAC,IAAA,4BAAa,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,gCAAgC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChH,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,MAAM,MAAM,GAAkC,EAAE,CAAC;IACjD,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,IAAI,eAAe,IAAI,8CAAsC,CAAC,UAAU,EAAE,CAAC;YACzE,MAAM;QACR,CAAC;QACD,IACE,CAAC,mDAA2C,CAAC,IAAI,CAAC,GAAG,CAAC;YACtD,GAAG,CAAC,MAAM,GAAG,8CAAsC,CAAC,YAAY,EAChE,CAAC;YACD,SAAS;QACX,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;QACxB,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,6BAA6B,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEnF,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,SAAS;QACX,CAAC;QACD,MAAM,SAAS,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC;QAClD,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,MAAM,IAAI,8CAAsC,CAAC,mBAAmB,EAAE,CAAC;YACnG,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;YACxB,eAAe,IAAI,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,OAAO,eAAe,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAClD,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAc;IACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,kCAA0B,CAAC,WAAW,EAAE,CAAC;QACnF,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;QAC5B,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,IAAI,OAAO,CAAC,MAAM,GAAG,kCAA0B,CAAC,gBAAgB,EAAE,CAAC;gBACjE,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;YACxF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,6BAA6B,CAAC,KAAc;IACnD,IAAI,CAAC,IAAA,4BAAa,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,KAAK,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,QAAQ,CAAU,EAAE,CAAC;QACtF,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,GAAG,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;YAC7C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7D,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAc;IAC1C,IAAI,CAAC,IAAA,4BAAa,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,MAAM,GAAyB,6BAA6B,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;IAChF,KAAK,MAAM,GAAG,IAAI,CAAC,8BAA8B,EAAE,mBAAmB,CAAU,EAAE,CAAC;QACjF,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,IAAI,kCAA0B,CAAC,gBAAgB,EAAE,CAAC;YACjG,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;QACxB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7D,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,KAAc;IACpD,MAAM,IAAI,GAAG,IAAA,4BAAa,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/C,MAAM,KAAK,GAAoB;QAC7B,OAAO,EAAE,OAAO,IAAI,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,sCAA8B,CAAC,CAAC,CAAC,CAAC,EAAE;KACvG,CAAC;IACF,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,IACE,OAAO,IAAI,KAAK,QAAQ;QACxB,IAAI,CAAC,MAAM,IAAI,uCAA+B,CAAC,aAAa;QAC5D,6CAAqC,CAAC,IAAI,CAAC,IAAI,CAAC;QAEhD,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;IACpB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACzB,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,CAAC,MAAM,IAAI,uCAA+B,CAAC,cAAc;QAC9D,6CAAqC,CAAC,IAAI,CAAC,KAAK,CAAC;QAEjD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;IACtB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC7B,IAAI,uBAAuB,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,IAAI,uCAA+B,CAAC,gBAAgB;QACxG,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;IAC1B,MAAM,QAAQ,GAAG,+BAA+B,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC5B,CAAC;IACD,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;IACvC,IACE,OAAO,YAAY,KAAK,QAAQ;QAChC,YAAY,CAAC,MAAM,IAAI,uCAA+B,CAAC,qBAAqB;QAC5E,6CAAqC,CAAC,IAAI,CAAC,YAAY,CAAC;QAExD,KAAK,CAAC,YAAY,GAAG,YAAY,CAAC;IACpC,IACE,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ;QAC9B,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,8CAAsC;QAC3D,6CAAqC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EACtD,CAAC;QACD,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IAC3B,CAAC;IACD,MAAM,MAAM,GAAG,qCAAqC,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/E,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;IACxB,CAAC;IACD,MAAM,WAAW,GAAG,6BAA6B,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACpE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,KAAK,CAAC,WAAW,GAAG,WAAW,CAAC;IAClC,CAAC;IACD,MAAM,YAAY,GAAG,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC7D,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,KAAK,CAAC,YAAY,GAAG,YAAY,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AA0DD,iFAAiF;AACjF,SAAgB,oBAAoB,CAAC,MAAqE;IACxG,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC;IAChE,IAAI,gBAAgB,KAAK,cAAc,IAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,MAAM,CAAC,OAAO,KAAK,qBAAqB;QAAE,OAAO,KAAK,CAAC;IAC3D,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;QAC/B,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC;AACnG,CAAC;AAID,SAAgB,yBAAyB;IACvC,OAAO;QACL,WAAW,EAAE;YACX,MAAM,EAAE,cAAc;YACtB,KAAK,EAAE,EAAE;SACV;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CACpC,KAAgD;IAEhD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,cAAc,CAAC;IACxB,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC,EAAE,CAAC;QAClD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,YAAY,CAAC,EAAE,CAAC;QACrD,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,SAAgB,mBAAmB,CAAC,KAAc;IAChD,OAAO,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,qBAAqB,IAAI,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,SAAS,CAAC;AAC9G,CAAC;AAED,SAAgB,uBAAuB,CAAC,KAAc;IACpD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,iCAA+C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACvG,CAAC;AAED;;;GAGG;AACU,QAAA,8BAA8B,GACzC,4EAA4E,CAAC;AAElE,QAAA,iCAAiC,GAAG,EAAE,CAAC;AAEpD,SAAgB,qBAAqB,CAAC,KAAc;IAClD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,sCAA8B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjF,CAAC"}

package/dist/src/testing.d.ts

@@ -0,0 +1,3 @@
+/** Testing-only shared fixtures. This module is intentionally outside the production root barrel. */
+export * from './jsonata-parity.fixtures';
+export * from './validation/validation-groups.fixtures';

package/dist/src/testing.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Testing-only shared fixtures. This module is intentionally outside the production root barrel. */
+__exportStar(require("./jsonata-parity.fixtures"), exports);
+__exportStar(require("./validation/validation-groups.fixtures"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxR0FBcUc7QUFDckcsNERBQTBDO0FBQzFDLDBFQUF3RCJ9

package/dist/src/validation/record-validation.model.d.ts

@@ -0,0 +1,84 @@
+/** Public operation names are small, case-sensitive identifiers. */
+export declare const VALIDATION_OPERATION_NAME_MAX_LENGTH = 64;
+export declare const VALIDATION_OPERATION_NAME_PATTERN: RegExp;
+/** Bounded display metadata limits used at the public discovery boundary. */
+export declare const VALIDATION_OPERATION_LABEL_MAX_LENGTH = 256;
+export declare const VALIDATION_OPERATION_DESCRIPTION_MAX_LENGTH = 1024;
+/** Safe server-owned references used by validation workflow/form discovery. */
+export declare const RECORD_VALIDATION_REFERENCE_PATTERN: RegExp;
+/** Deterministic ordering for public validation identifiers. */
+export declare function compareRecordValidationIdentifiers(left: string, right: string): number;
+/** Normalize bounded public display text without coercing hostile values. */
+export declare function safeValidationDiscoveryText(value: unknown, maxLength: number): string | undefined;
+/**
+ * A server-owned validation intent and its form-level defaults.
+ *
+ * Operation names are configuration keys (for example `draft` or `publish`),
+ * rather than values from a fixed framework enum.
+ */
+export interface ValidationOperationDefinition {
+    /** The exact validation-group set to use for this operation. */
+    enabledValidationGroups: string[];
+    /** Optional safe display label. */
+    label?: string;
+    /** Optional safe display description. */
+    description?: string;
+    /** Roles allowed to use the operation. Omission adds no role restriction. */
+    roles?: string[];
+    /** Workflow targets allowed for the operation. Omission adds no target restriction. */
+    allowedTargetSteps?: string[];
+}
+/**
+ * A more-specific operation layer. Defined properties replace or restrict the
+ * corresponding form-level defaults; omitted properties inherit them.
+ */
+export interface ValidationOperationOverride extends Partial<ValidationOperationDefinition> {
+    /** Optional rollout-mode override for this operation. */
+    mode?: ValidationMode;
+}
+/**
+ * Workflow stages may refine operation policy, but rollout mode is deliberately
+ * not stage-scoped. Enforcement remains a `(record type, operation)` decision.
+ */
+export type ValidationOperationPolicyOverride = Omit<ValidationOperationOverride, 'mode'> & {
+    mode?: never;
+};
+/** Safe operation metadata suitable for discovery responses. */
+export interface ValidationOperationDiscovery {
+    name: string;
+    label?: string;
+    description?: string;
+    /**
+     * Actor-authorized transition targets applicable to this operation. An
+     * unrestricted operation receives every actor-authorized target.
+     */
+    allowedTargetSteps?: string[];
+}
+/**
+ * Project an untrusted service result onto the complete public discovery
+ * contract. Optional target authorization can only narrow reported targets.
+ */
+export declare function sanitizeValidationOperationDiscovery(value: unknown, authorizedTargetSteps?: ReadonlySet<string>): ValidationOperationDiscovery | undefined;
+/** Whether authoritative validation observes or rejects a failed save. */
+export type ValidationMode = 'shadow' | 'enforce';
+/** Safe diagnostic severity shared by group resolution and server validation. */
+export type RecordValidationDiagnosticSeverity = 'info' | 'warning' | 'error';
+/**
+ * A safe diagnostic from validation configuration or execution.
+ *
+ * This contract intentionally has no arbitrary details bag: raw records,
+ * requests, users, parameters, and exceptions must not enter diagnostics.
+ */
+export interface RecordValidationDiagnostic {
+    code: string;
+    severity: RecordValidationDiagnosticSeverity;
+    message: string;
+    formName?: string;
+    operation?: string;
+    group?: string;
+    field?: string;
+    pointer?: string;
+    /** Safe configured expression name; never an expression source or value. */
+    expressionName?: string;
+    validatorClass?: string;
+}

package/dist/src/validation/record-validation.model.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_VALIDATION_REFERENCE_PATTERN = exports.VALIDATION_OPERATION_DESCRIPTION_MAX_LENGTH = exports.VALIDATION_OPERATION_LABEL_MAX_LENGTH = exports.VALIDATION_OPERATION_NAME_PATTERN = exports.VALIDATION_OPERATION_NAME_MAX_LENGTH = void 0;
+exports.compareRecordValidationIdentifiers = compareRecordValidationIdentifiers;
+exports.safeValidationDiscoveryText = safeValidationDiscoveryText;
+exports.sanitizeValidationOperationDiscovery = sanitizeValidationOperationDiscovery;
+/** Public operation names are small, case-sensitive identifiers. */
+exports.VALIDATION_OPERATION_NAME_MAX_LENGTH = 64;
+exports.VALIDATION_OPERATION_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/;
+/** Bounded display metadata limits used at the public discovery boundary. */
+exports.VALIDATION_OPERATION_LABEL_MAX_LENGTH = 256;
+exports.VALIDATION_OPERATION_DESCRIPTION_MAX_LENGTH = 1024;
+/** Safe server-owned references used by validation workflow/form discovery. */
+exports.RECORD_VALIDATION_REFERENCE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+/** Deterministic ordering for public validation identifiers. */
+function compareRecordValidationIdentifiers(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/** Normalize bounded public display text without coercing hostile values. */
+function safeValidationDiscoveryText(value, maxLength) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    return normalized && normalized.length <= maxLength ? normalized : undefined;
+}
+/**
+ * Project an untrusted service result onto the complete public discovery
+ * contract. Optional target authorization can only narrow reported targets.
+ */
+function sanitizeValidationOperationDiscovery(value, authorizedTargetSteps) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    const name = typeof candidate.name === 'string' ? candidate.name.trim() : '';
+    if (!exports.VALIDATION_OPERATION_NAME_PATTERN.test(name))
+        return undefined;
+    const label = safeValidationDiscoveryText(candidate.label, exports.VALIDATION_OPERATION_LABEL_MAX_LENGTH);
+    const description = safeValidationDiscoveryText(candidate.description, exports.VALIDATION_OPERATION_DESCRIPTION_MAX_LENGTH);
+    const allowedTargetSteps = Array.isArray(candidate.allowedTargetSteps)
+        ? [...new Set(candidate.allowedTargetSteps
+                .filter((step) => typeof step === 'string')
+                .map(step => step.trim())
+                .filter(step => exports.RECORD_VALIDATION_REFERENCE_PATTERN.test(step) &&
+                (authorizedTargetSteps === undefined || authorizedTargetSteps.has(step))))].sort(compareRecordValidationIdentifiers)
+        : [];
+    return {
+        name,
+        ...(label ? { label } : {}),
+        ...(description ? { description } : {}),
+        ...(allowedTargetSteps.length > 0 ? { allowedTargetSteps } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/validation/validation-groups.d.ts

@@ -0,0 +1,29 @@
+import { FormFieldValidationGroup, FormValidationGroups } from './form.model';
+import { RecordValidationDiagnostic } from './record-validation.model';
+/** Initial source used by a validation-group change. */
+export declare const formValidationGroupsChangeInitial: readonly ["all", "none", "current", "empty"];
+/**
+ * `empty` is retained as a deprecated alias for `none` so stored legacy form
+ * expressions continue to work while producing an observable diagnostic.
+ */
+export type FormValidationGroupsChangeInitial = (typeof formValidationGroupsChangeInitial)[number];
+export interface ValidationGroupCalculationResult {
+    enabledValidationGroups: string[];
+    diagnostics: RecordValidationDiagnostic[];
+}
+export declare const VALIDATION_GROUP_EMPTY_INITIAL_DIAGNOSTIC: "validation-group-initial-empty-deprecated";
+export declare const VALIDATION_GROUP_UNKNOWN_INITIAL_DIAGNOSTIC: "validation-group-initial-unknown";
+/**
+ * Fold one validation-group change using the historical Angular semantics.
+ *
+ * Important compatibility behavior:
+ * - an empty resulting array is preserved (ValidatorsSupport interprets it as
+ *   all validators);
+ * - `none`/legacy `empty` start from an empty array, while the configured
+ *   `none` group is represented by the literal group name `none`;
+ * - includes append only missing names and excludes remove the first present
+ *   occurrence, matching the original client implementation;
+ * - unknown names are retained for the authoritative caller to diagnose;
+ * - an operation group array, when supplied, replaces the folded array last.
+ */
+export declare function calculateValidationGroups(currentValidationGroups: readonly string[], validationGroups: Readonly<FormValidationGroups>, initial?: FormValidationGroupsChangeInitial, groups?: FormFieldValidationGroup, operationEnabledValidationGroups?: readonly string[]): ValidationGroupCalculationResult;