@researchdatabox/redbox-core 5.0.4 → 5.1.0-beta.12568

package/dist/record-contract/record-contract-compiler.js

@@ -0,0 +1,775 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordContractCompiler = void 0;
+const sails_ng_common_1 = require("@researchdatabox/sails-ng-common");
+const perf_hooks_1 = require("perf_hooks");
+const codes_1 = require("./codes");
+const deep_freeze_1 = require("./deep-freeze");
+const json_pointer_1 = require("./json-pointer");
+const core_contributors_1 = require("./core-contributors");
+const record_contract_context_1 = require("./record-contract-context");
+const noopFormOverrideLog = () => undefined;
+const FORM_OVERRIDE_LOGGER = Object.freeze({
+    silly: noopFormOverrideLog,
+    verbose: noopFormOverrideLog,
+    trace: noopFormOverrideLog,
+    debug: noopFormOverrideLog,
+    log: noopFormOverrideLog,
+    info: noopFormOverrideLog,
+    warn: noopFormOverrideLog,
+    error: noopFormOverrideLog,
+    crit: noopFormOverrideLog,
+    fatal: noopFormOverrideLog,
+    silent: noopFormOverrideLog,
+    blank: noopFormOverrideLog,
+});
+class CompilerFailure extends Error {
+    failureKind;
+    code;
+    diagnostic;
+    constructor(failureKind, code, diagnostic) {
+        super(diagnostic.message);
+        this.failureKind = failureKind;
+        this.code = code;
+        this.diagnostic = diagnostic;
+        this.name = 'RecordContractCompilerFailure';
+    }
+}
+class ContractNodeLimitError extends Error {
+    limit;
+    constructor(limit) {
+        super(`Contract node exceeded its ${limit} limit.`);
+        this.limit = limit;
+        this.name = 'ContractNodeLimitError';
+    }
+}
+class CloneDepthLimitError extends Error {
+    constructor() {
+        super('Contributor output exceeds the configured nesting-depth limit.');
+        this.name = 'CloneDepthLimitError';
+    }
+}
+function forkCompilerState(state) {
+    return {
+        definitions: { ...state.definitions },
+        diagnostics: [...state.diagnostics],
+        fieldOwners: { ...state.fieldOwners },
+        validatorSummaries: [...state.validatorSummaries],
+        activeDefinitions: new Set(state.activeDefinitions),
+        propertyCount: state.propertyCount,
+        partial: state.partial,
+    };
+}
+function replaceRecord(target, source) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
+    }
+    Object.assign(target, source);
+}
+function commitCompilerState(target, source) {
+    replaceRecord(target.definitions, source.definitions);
+    replaceRecord(target.fieldOwners, source.fieldOwners);
+    target.diagnostics.splice(0, target.diagnostics.length, ...source.diagnostics);
+    target.validatorSummaries.splice(0, target.validatorSummaries.length, ...source.validatorSummaries);
+    target.activeDefinitions.clear();
+    source.activeDefinitions.forEach(definition => target.activeDefinitions.add(definition));
+    target.propertyCount = source.propertyCount;
+    target.partial = source.partial;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function contributorIdentity(registration) {
+    const contributor = registration.contributor;
+    return {
+        key: contributor.key,
+        version: contributor.version,
+        source: registration.source,
+    };
+}
+function diagnosticSortKey(diagnostic) {
+    return [
+        diagnostic.code,
+        diagnostic.pointer ?? '',
+        diagnostic.componentType ?? '',
+        diagnostic.contributor?.key ?? '',
+        diagnostic.message,
+    ].join('\u0000');
+}
+function summarySortKey(summary) {
+    return [summary.code, summary.pointers.join(','), summary.groups.join(','), summary.operations.join(',')].join('\u0000');
+}
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isNativeRegExp(value) {
+    return Object.getPrototypeOf(value) === RegExp.prototype;
+}
+function isNonPersistingContribution(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || !isPlainObject(value)) {
+        return false;
+    }
+    const kind = Object.getOwnPropertyDescriptor(value, 'kind');
+    return kind?.enumerable === true && 'value' in kind && kind.value === 'non-persisting';
+}
+/** Clone without invoking accessors or accepting values JSON would silently rewrite. */
+function cloneJsonSafe(value, path = '$', ancestors = new Set(), depth = 0, maxDepth = Number.MAX_SAFE_INTEGER, allowUndefined = false, allowRuntimeFormObjects = false) {
+    if (depth > maxDepth) {
+        throw new CloneDepthLimitError();
+    }
+    if (value === undefined && allowUndefined) {
+        return value;
+    }
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new Error(`${path} contains a non-finite number.`);
+        }
+        return value;
+    }
+    if (typeof value !== 'object') {
+        throw new Error(`${path} contains a non-JSON ${typeof value} value.`);
+    }
+    if (ancestors.has(value)) {
+        throw new Error(`${path} contains a cycle.`);
+    }
+    ancestors.add(value);
+    try {
+        if (allowRuntimeFormObjects && isNativeRegExp(value)) {
+            const descriptors = Object.getOwnPropertyDescriptors(value);
+            if (Object.getOwnPropertySymbols(value).length > 0 ||
+                Object.keys(descriptors).some(key => key !== 'lastIndex') ||
+                !descriptors.lastIndex ||
+                !('value' in descriptors.lastIndex) ||
+                descriptors.lastIndex.enumerable) {
+                throw new Error(`${path} contains an extended RegExp.`);
+            }
+            // Form validator configuration permits RegExp values. Preserve their
+            // deterministic semantics without carrying the mutable lastIndex or
+            // RegExp prototype across the compiler boundary.
+            return { source: value.source, flags: value.flags };
+        }
+        if (Array.isArray(value)) {
+            if (Object.getOwnPropertySymbols(value).length > 0 || Object.keys(value).length !== value.length) {
+                throw new Error(`${path} contains a sparse or extended array.`);
+            }
+            return value.map((item, index) => cloneJsonSafe(item, `${path}[${index}]`, ancestors, depth + 1, maxDepth, allowUndefined, allowRuntimeFormObjects));
+        }
+        if (!allowRuntimeFormObjects && !isPlainObject(value)) {
+            throw new Error(`${path} is not a plain JSON object.`);
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new Error(`${path} contains symbol properties.`);
+        }
+        const clone = {};
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+            if (!descriptor.enumerable || !('value' in descriptor)) {
+                throw new Error(`${path}.${key} is not an enumerable data property.`);
+            }
+            clone[key] = cloneJsonSafe(descriptor.value, `${path}.${key}`, ancestors, depth + 1, maxDepth, allowUndefined, allowRuntimeFormObjects);
+        }
+        return clone;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function cloneCompilerInput(value, path, allowRuntimeFormObjects = false) {
+    return (0, deep_freeze_1.freezeDeep)(cloneJsonSafe(value, path, new Set(), 0, Number.MAX_SAFE_INTEGER, true, allowRuntimeFormObjects));
+}
+function snapshotCompileRequest(request) {
+    return Object.freeze({
+        // FormsService returns visitor-aware class instances. Snapshot only their
+        // enumerable data; prototype methods never cross the compiler boundary.
+        form: cloneCompilerInput(request.form, '$request.form', true),
+        context: (0, record_contract_context_1.snapshotRecordContractPublicContext)(request.context),
+        ...(request.reusableFormDefinitions === undefined
+            ? {}
+            : {
+                reusableFormDefinitions: cloneCompilerInput(request.reusableFormDefinitions, '$request.reusableFormDefinitions'),
+            }),
+    });
+}
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+function validateCondition(condition, maximumDepth) {
+    const pending = [{ condition, depth: 0 }];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current) {
+            continue;
+        }
+        if (current.depth > maximumDepth) {
+            throw new ContractNodeLimitError('depth');
+        }
+        const item = current.condition;
+        if (item.kind === 'exists' || item.kind === 'equals') {
+            (0, json_pointer_1.recordContractPointer)(item.pointer);
+        }
+        else if (item.kind === 'in') {
+            (0, json_pointer_1.recordContractPointer)(item.pointer);
+            if (!Array.isArray(item.values)) {
+                throw new Error('Condition values must be an array.');
+            }
+        }
+        else if (item.kind === 'not') {
+            pending.push({ condition: item.condition, depth: current.depth + 1 });
+        }
+        else {
+            if (!Array.isArray(item.conditions) || item.conditions.length === 0) {
+                throw new Error('Combined conditions require at least one condition.');
+            }
+            for (const child of item.conditions) {
+                pending.push({ condition: child, depth: current.depth + 1 });
+            }
+        }
+    }
+}
+function validateContractNode(node, baseDepth, maxDepth, maxProperties) {
+    const pending = [{ node, depth: baseDepth }];
+    let propertyCount = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current) {
+            continue;
+        }
+        if (current.depth > maxDepth) {
+            throw new ContractNodeLimitError('depth');
+        }
+        const currentNode = current.node;
+        if (!isBoolean(currentNode.nullable)) {
+            throw new Error('Contract nodes require an explicit boolean nullability declaration.');
+        }
+        switch (currentNode.kind) {
+            case 'scalar':
+                if (!['string', 'number', 'integer', 'boolean'].includes(currentNode.scalarType)) {
+                    throw new Error('Scalar node type is invalid.');
+                }
+                break;
+            case 'object': {
+                if (!['allow', 'declared'].includes(currentNode.unknownProperties)) {
+                    throw new Error('Object node unknown-property policy is invalid.');
+                }
+                if (currentNode.properties === null ||
+                    typeof currentNode.properties !== 'object' ||
+                    Array.isArray(currentNode.properties)) {
+                    throw new Error('Object node properties must be a plain object.');
+                }
+                const children = Object.values(currentNode.properties);
+                propertyCount += children.length;
+                if (propertyCount > maxProperties) {
+                    throw new ContractNodeLimitError('properties');
+                }
+                for (const child of children) {
+                    pending.push({ node: child, depth: current.depth + 1 });
+                }
+                break;
+            }
+            case 'array':
+                pending.push({ node: currentNode.items, depth: current.depth + 1 });
+                break;
+            case 'any':
+                break;
+            case 'conditional':
+                validateCondition(currentNode.condition, maxDepth - current.depth);
+                pending.push({ node: currentNode.thenNode, depth: current.depth + 1 });
+                if (currentNode.elseNode) {
+                    pending.push({ node: currentNode.elseNode, depth: current.depth + 1 });
+                }
+                break;
+            default: {
+                const exhaustive = currentNode;
+                throw new Error(`Unknown contract node ${String(exhaustive)}.`);
+            }
+        }
+    }
+}
+function estimatedBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+function safeNames(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    return [
+        ...new Set(values.filter((value) => typeof value === 'string' && /^[A-Za-z0-9._:-]+$/.test(value))),
+    ].sort();
+}
+function safeValidatorCode(value) {
+    if (typeof value !== 'string' || !/^[A-Za-z0-9._:-]+$/.test(value)) {
+        return 'form.custom';
+    }
+    const safeBuiltIns = new Set([
+        'any-of',
+        'different-values',
+        'doi',
+        'email',
+        'integer',
+        'max',
+        'maxLength',
+        'min',
+        'minLength',
+        'orcid',
+        'pattern',
+        'required',
+        'requiredTrue',
+        'url',
+    ]);
+    return safeBuiltIns.has(value) ? `form.${value}` : 'form.custom';
+}
+function validatorPointer(validator, fallback) {
+    const target = asRecord(validator).targetField;
+    const dataModel = asRecord(target).dataModel;
+    return Array.isArray(dataModel)
+        ? (0, json_pointer_1.recordContractPointerFromTokens)(dataModel.filter((value) => typeof value === 'string' || typeof value === 'number'))
+        : fallback;
+}
+class RecordContractCompiler {
+    registry;
+    limits;
+    constructor(registry, limits) {
+        this.registry = registry;
+        this.limits = limits;
+    }
+    async compile(request) {
+        const state = {
+            definitions: {},
+            diagnostics: [],
+            fieldOwners: {},
+            validatorSummaries: [],
+            activeDefinitions: new Set(),
+            propertyCount: 0,
+            partial: false,
+        };
+        try {
+            const snapshot = snapshotCompileRequest(request);
+            this.assertDepth(0, (0, json_pointer_1.recordContractPointer)(''));
+            const root = await this.compileChildren(snapshot.form.componentDefinitions ?? [], (0, json_pointer_1.recordContractPointer)(''), 0, snapshot, state);
+            this.collectValidators(snapshot.form.validators, (0, json_pointer_1.recordContractPointer)(''), snapshot.form, state);
+            this.validateNodeBounds(root, 0, (0, json_pointer_1.recordContractPointer)(''));
+            const contract = (0, deep_freeze_1.freezeDeep)({
+                root,
+                definitions: Object.fromEntries(Object.entries(state.definitions).sort(([left], [right]) => left.localeCompare(right))),
+                fieldOwners: Object.fromEntries(Object.entries(state.fieldOwners).sort(([left], [right]) => left.localeCompare(right))),
+                validatorSummaries: [...state.validatorSummaries].sort((left, right) => summarySortKey(left).localeCompare(summarySortKey(right))),
+                diagnostics: [...state.diagnostics].sort((left, right) => diagnosticSortKey(left).localeCompare(diagnosticSortKey(right))),
+                completeness: state.partial ? 'partial' : 'complete',
+                context: snapshot.context,
+            });
+            if (estimatedBytes(contract) > this.limits.maxDocumentBytes) {
+                throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DOCUMENT_BYTES, 'The estimated record-contract output exceeds the configured document-byte limit.', (0, json_pointer_1.recordContractPointer)(''));
+            }
+            return Object.freeze({ kind: 'compiled', contract });
+        }
+        catch (error) {
+            const failure = error instanceof CompilerFailure
+                ? error
+                : new CompilerFailure('invalid-contract', codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, {
+                    code: codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT,
+                    severity: 'error',
+                    message: error instanceof Error ? error.message : 'Record contract compilation failed.',
+                });
+            const diagnostics = [...state.diagnostics, failure.diagnostic].sort((left, right) => diagnosticSortKey(left).localeCompare(diagnosticSortKey(right)));
+            return Object.freeze({
+                kind: 'failed',
+                failureKind: failure.failureKind,
+                code: failure.code,
+                diagnostics: (0, deep_freeze_1.freezeDeep)(diagnostics),
+            });
+        }
+    }
+    async compileChildren(components, parent, depth, request, state, definitionKey) {
+        this.assertDepth(depth, parent);
+        const properties = {};
+        const roleFilteredComponents = new Map();
+        for (const component of components) {
+            if (this.isRoleFilteredDuplicate(component, roleFilteredComponents)) {
+                continue;
+            }
+            const contributions = await this.compileComponent(component, parent, depth + 1, request, state);
+            for (const [name, node] of contributions) {
+                if (Object.hasOwn(properties, name)) {
+                    throw this.invalidFailure('record-contract.path-ownership-collision', `Multiple components attempted to own ${(0, json_pointer_1.joinRecordContractPointer)(parent, name)}.`, (0, json_pointer_1.joinRecordContractPointer)(parent, name));
+                }
+                properties[name] = node;
+            }
+        }
+        return {
+            kind: 'object',
+            nullable: false,
+            properties: Object.fromEntries(Object.entries(properties).sort(([left], [right]) => left.localeCompare(right))),
+            unknownProperties: request.context.unknownProperties,
+            ...(definitionKey ? { definitionKey } : {}),
+        };
+    }
+    async compileComponent(component, parent, depth, request, state) {
+        this.assertDepth(depth, parent);
+        if (!this.isAvailableInEditMode(component)) {
+            return [];
+        }
+        const reusableName = component.overrides?.reusableFormName;
+        if (typeof reusableName === 'string' && reusableName !== '') {
+            return this.compileReusable(component, reusableName, parent, depth, request, state);
+        }
+        component = this.applyEditModeName(component);
+        const componentType = component.component?.class;
+        if (typeof componentType !== 'string' || componentType.trim() === '') {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, 'A form component has no stable component class.', parent);
+        }
+        const registration = this.registry.component(componentType);
+        if (!registration || registration.contributor.kind !== 'component') {
+            if (Object.hasOwn(core_contributors_1.CORE_RECORD_CONTRACT_COMPONENT_INVENTORY, componentType)) {
+                throw this.invalidFailure('record-contract.uncovered-core-component', `Core component ${componentType} has no record-contract contributor.`, parent, componentType);
+            }
+            return this.unsupportedComponent(component, parent, componentType, state);
+        }
+        const contributor = registration.contributor;
+        const identity = contributorIdentity(registration);
+        const fieldName = component.name;
+        const pointer = fieldName ? (0, json_pointer_1.joinRecordContractPointer)(parent, fieldName) : parent;
+        const contributionState = forkCompilerState(state);
+        this.collectValidators(component.model?.config?.validators, pointer, request.form, contributionState);
+        this.collectUnrepresentableExpressions(component, pointer, contributionState);
+        let contribution;
+        try {
+            const compileContext = Object.freeze({
+                component,
+                pointer,
+                publicContext: request.context,
+                compileChildren: async (children, childParent, options) => (0, deep_freeze_1.freezeDeep)(await this.compileChildren(cloneCompilerInput(children, `$contributor[${contributor.key}].children`), childParent, depth + 1, request, contributionState, options?.definitionKey)),
+            });
+            contribution = await this.withTimeout(() => contributor.compile(compileContext), contributor.key, pointer);
+            const allowRuntimeChildren = isNonPersistingContribution(contribution);
+            contribution = cloneJsonSafe(contribution, `$contributor[${contributor.key}]`, new Set(), 0, this.limits.maxDepth + 8, allowRuntimeChildren);
+            if (estimatedBytes(contribution) > this.limits.maxDocumentBytes) {
+                throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DOCUMENT_BYTES, `Contributor ${contributor.key} output exceeds the configured output estimate.`, pointer, componentType);
+            }
+        }
+        catch (error) {
+            if (error instanceof CompilerFailure) {
+                throw error;
+            }
+            if (error instanceof CloneDepthLimitError) {
+                throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DEPTH, `Record-contract contributor ${contributor.key} output exceeds the configured nesting-depth limit.`, pointer, componentType);
+            }
+            throw new CompilerFailure('contributor-failed', codes_1.RECORD_SCHEMA_PROBLEM_CODES.CONTRIBUTOR_FAILED, {
+                code: codes_1.RECORD_SCHEMA_PROBLEM_CODES.CONTRIBUTOR_FAILED,
+                severity: 'error',
+                message: `Record-contract contributor ${contributor.key} returned invalid output.`,
+                pointer,
+                componentType,
+                contributor: identity,
+            });
+        }
+        if (contribution.kind === 'non-persisting') {
+            if (!contribution.children || contribution.children.length === 0) {
+                commitCompilerState(state, contributionState);
+                return [];
+            }
+            const childNode = await this.compileChildren(contribution.children, parent, depth + 1, request, contributionState);
+            commitCompilerState(state, contributionState);
+            return Object.entries(childNode.properties);
+        }
+        if (!fieldName) {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, `Persisting component ${componentType} has no metadata field name.`, parent, componentType);
+        }
+        try {
+            this.validateNodeBounds(contribution.node, depth, pointer);
+            this.assertNullability(contributor.nullability, contribution.node, contributor.key, pointer);
+        }
+        catch (error) {
+            if (error instanceof CompilerFailure && error.failureKind === 'limit-exceeded') {
+                throw error;
+            }
+            throw new CompilerFailure('contributor-failed', codes_1.RECORD_SCHEMA_PROBLEM_CODES.CONTRIBUTOR_FAILED, {
+                code: codes_1.RECORD_SCHEMA_PROBLEM_CODES.CONTRIBUTOR_FAILED,
+                severity: 'error',
+                message: `Record-contract contributor ${contributor.key} returned invalid output.`,
+                pointer,
+                componentType,
+                contributor: identity,
+            });
+        }
+        this.claimProperty(pointer, componentType, identity, contributionState);
+        for (const owned of contributor.ownedPointers) {
+            const ownedPointer = owned === '' ? pointer : (0, json_pointer_1.appendRecordContractPointer)(pointer, (0, json_pointer_1.recordContractPointer)(owned));
+            this.claimOwnedPointer(ownedPointer, componentType, identity, contributionState);
+        }
+        for (const diagnostic of contribution.diagnostics ?? []) {
+            this.addDiagnostic({ ...diagnostic, contributor: identity }, contributionState);
+        }
+        if (containsPermissiveNode(contribution.node)) {
+            contributionState.partial = true;
+        }
+        commitCompilerState(state, contributionState);
+        return [[fieldName, contribution.node]];
+    }
+    async compileReusable(component, name, parent, depth, request, state) {
+        const definition = request.reusableFormDefinitions?.[name];
+        if (!definition) {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, `Reusable form definition ${name} does not exist.`, parent);
+        }
+        if (state.activeDefinitions.has(name)) {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, `Reusable form definition cycle detected at ${name}.`, parent);
+        }
+        state.activeDefinitions.add(name);
+        try {
+            const reusableFormDefinitions = {};
+            for (const [definitionName, components] of Object.entries(request.reusableFormDefinitions ?? {})) {
+                // Reusable definitions are hook-extensible at the compiler boundary,
+                // while the shared form expander exposes the closed core component
+                // union. The runtime shape is the common FormComponentDefinitionFrame.
+                reusableFormDefinitions[definitionName] = [...components];
+            }
+            const expanded = new sails_ng_common_1.FormOverride(FORM_OVERRIDE_LOGGER).applyOverridesReusable([component], reusableFormDefinitions);
+            const effectiveComponents = expanded.map(expandedComponent => {
+                if (expandedComponent.name || !component.name) {
+                    return expandedComponent;
+                }
+                const overrides = { ...expandedComponent.overrides };
+                delete overrides.replaceName;
+                return {
+                    ...expandedComponent,
+                    name: component.name,
+                    ...(Object.keys(overrides).length > 0 ? { overrides } : { overrides: undefined }),
+                };
+            });
+            const compiled = await this.compileChildren(effectiveComponents, parent, depth + 1, request, state);
+            return Object.entries(compiled.properties).map(([propertyName, node]) => {
+                if (node.definitionKey) {
+                    return [propertyName, node];
+                }
+                const definitionKey = `reusable:${JSON.stringify(name)}:property:${JSON.stringify(propertyName)}`;
+                const referencedNode = { ...node, definitionKey };
+                const prior = state.definitions[definitionKey];
+                if (prior && JSON.stringify(prior) !== JSON.stringify(referencedNode)) {
+                    throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, `Reusable form definition ${name} property ${propertyName} compiled inconsistently.`, parent);
+                }
+                state.definitions[definitionKey] = referencedNode;
+                return [propertyName, referencedNode];
+            });
+        }
+        finally {
+            state.activeDefinitions.delete(name);
+        }
+    }
+    isAvailableInEditMode(component) {
+        const allowModes = component.constraints?.allowModes;
+        return !Array.isArray(allowModes) || allowModes.length === 0 || allowModes.includes('edit');
+    }
+    /**
+     * Role-specific form variants can describe the same persisted field more
+     * than once. The record schema is role-independent, so retain the first
+     * variant when the role scopes are disjoint and let the client visitor pick
+     * the variant for the current user. Overlapping or unrestricted variants
+     * remain a contract error because they may represent a real collision.
+     */
+    isRoleFilteredDuplicate(component, roleFilteredComponents) {
+        if (!component.model || !this.isAvailableInEditMode(component)) {
+            return false;
+        }
+        const fieldName = this.applyEditModeName(component).name;
+        const allowRoles = component.constraints?.authorization?.allowRoles;
+        if (!fieldName || !Array.isArray(allowRoles) || allowRoles.length === 0) {
+            return false;
+        }
+        const priorComponents = roleFilteredComponents.get(fieldName) ?? [];
+        const isDuplicate = priorComponents.some(priorComponent => {
+            const priorRoles = priorComponent.constraints?.authorization?.allowRoles;
+            return (Array.isArray(priorRoles) &&
+                priorRoles.length > 0 &&
+                allowRoles.every(role => !priorRoles.includes(role)));
+        });
+        priorComponents.push(component);
+        roleFilteredComponents.set(fieldName, priorComponents);
+        return isDuplicate;
+    }
+    applyEditModeName(component) {
+        const replaceName = component.overrides?.replaceName;
+        return replaceName === undefined || replaceName === component.name
+            ? component
+            : { ...component, name: replaceName };
+    }
+    unsupportedComponent(component, parent, componentType, state) {
+        if (!component.name) {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, `Unsupported component ${componentType} has no field name.`, parent, componentType);
+        }
+        const pointer = (0, json_pointer_1.joinRecordContractPointer)(parent, component.name);
+        const node = {
+            kind: 'any',
+            nullable: true,
+            reason: 'unsupported-component',
+            annotations: {
+                extensions: { 'x-redbox-unsupported-component': componentType },
+            },
+        };
+        this.claimProperty(pointer, componentType, undefined, state);
+        this.addDiagnostic({
+            code: 'x-redbox-unsupported-component',
+            severity: 'warning',
+            message: 'A custom component has no registered record-contract contributor and remains permissive.',
+            pointer,
+            componentType,
+        }, state);
+        state.partial = true;
+        return [[component.name, node]];
+    }
+    collectValidators(configured, fallbackPointer, form, state) {
+        for (const validator of configured ?? []) {
+            const groups = safeNames(validator.groups?.include);
+            const operations = Object.entries(form.validationOperations ?? {})
+                .filter(([, operation]) => {
+                const operationGroups = safeNames(operation.enabledValidationGroups);
+                return groups.length === 0 || operationGroups.some(group => groups.includes(group));
+            })
+                .map(([name]) => name)
+                .filter(name => /^[A-Za-z0-9._:-]+$/.test(name))
+                .sort();
+            state.validatorSummaries.push({
+                code: safeValidatorCode(validator.class),
+                pointers: [validatorPointer(validator, fallbackPointer)],
+                groups,
+                operations,
+                blocking: true,
+            });
+        }
+    }
+    collectUnrepresentableExpressions(component, pointer, state) {
+        const expressions = component.expressions ?? [];
+        if (expressions.length === 0) {
+            return;
+        }
+        this.addDiagnostic({
+            code: 'record-contract.unrepresentable-condition',
+            severity: 'warning',
+            message: 'Runtime component expressions are annotation-only and do not remove the field from the contract.',
+            pointer,
+            componentType: component.component.class,
+        }, state);
+        state.partial = true;
+    }
+    claimProperty(pointer, key, contributor, state, kind = 'component') {
+        if (state.fieldOwners[pointer]) {
+            throw this.invalidFailure('record-contract.path-ownership-collision', `Metadata path ${pointer} already has an owner.`, pointer);
+        }
+        state.propertyCount += 1;
+        if (state.propertyCount > this.limits.maxProperties) {
+            throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_PROPERTIES, 'The record contract exceeds the configured property limit.', pointer);
+        }
+        state.fieldOwners[pointer] = { kind, key, ...(contributor ? { contributor } : {}) };
+    }
+    claimOwnedPointer(pointer, key, contributor, state) {
+        const existing = state.fieldOwners[pointer];
+        if (existing && existing.contributor?.key !== contributor.key) {
+            throw this.invalidFailure('record-contract.path-ownership-collision', `Contributor ${contributor.key} attempted to overwrite ${pointer}.`, pointer);
+        }
+        if (!existing) {
+            state.fieldOwners[pointer] = { kind: 'component', key, contributor };
+        }
+    }
+    addDiagnostic(diagnostic, state) {
+        if (state.diagnostics.length >= this.limits.maxDiagnostics) {
+            throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DIAGNOSTICS, 'The record contract exceeds the configured diagnostic limit.', diagnostic.pointer ?? (0, json_pointer_1.recordContractPointer)(''));
+        }
+        state.diagnostics.push(diagnostic);
+        if (diagnostic.code === 'x-redbox-unsupported-component' ||
+            diagnostic.code === 'record-contract.unrepresentable-condition' ||
+            diagnostic.code === 'record-contract.core-permissive-shape') {
+            state.partial = true;
+        }
+    }
+    assertDepth(depth, pointer) {
+        if (depth > this.limits.maxDepth) {
+            throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DEPTH, 'The record contract exceeds the configured nesting-depth limit.', pointer);
+        }
+    }
+    assertNullability(policy, node, key, pointer) {
+        if ((policy === 'non-null' && node.nullable) || (policy === 'nullable' && !node.nullable)) {
+            throw this.invalidFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.CONTRIBUTOR_INVALID, `Contributor ${key} output contradicts its declared nullability policy.`, pointer);
+        }
+    }
+    validateNodeBounds(node, baseDepth, pointer) {
+        try {
+            validateContractNode(node, baseDepth, this.limits.maxDepth, this.limits.maxProperties);
+        }
+        catch (error) {
+            if (error instanceof ContractNodeLimitError) {
+                if (error.limit === 'depth') {
+                    throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_DEPTH, 'Contributor output exceeds the configured nesting-depth limit.', pointer);
+                }
+                throw this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_PROPERTIES, 'Contributor output exceeds the configured property limit.', pointer);
+            }
+            throw error;
+        }
+    }
+    async withTimeout(invoke, key, pointer) {
+        // JavaScript cannot pre-empt a synchronous callback. Charge its measured
+        // elapsed time immediately, then give asynchronous completion only the
+        // remaining budget and verify total elapsed time again after settlement.
+        const startedAt = perf_hooks_1.performance.now();
+        const timeoutFailure = () => this.limitFailure(codes_1.RECORD_SCHEMA_PROBLEM_CODES.LIMIT_CONTRIBUTOR_TIMEOUT, `Record-contract contributor ${key} exceeded its configured timeout.`, pointer);
+        const pending = invoke();
+        const synchronousElapsedMs = perf_hooks_1.performance.now() - startedAt;
+        if (synchronousElapsedMs > this.limits.contributorTimeoutMs) {
+            throw timeoutFailure();
+        }
+        let timeout;
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timeout = setTimeout(() => reject(timeoutFailure()), this.limits.contributorTimeoutMs - synchronousElapsedMs);
+        });
+        try {
+            const result = await Promise.race([Promise.resolve(pending), timeoutPromise]);
+            if (perf_hooks_1.performance.now() - startedAt > this.limits.contributorTimeoutMs) {
+                throw timeoutFailure();
+            }
+            return result;
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    invalidFailure(code, message, pointer, componentType) {
+        return new CompilerFailure('invalid-contract', codes_1.RECORD_SCHEMA_PROBLEM_CODES.INVALID_CONTRACT, {
+            code,
+            severity: 'error',
+            message,
+            pointer,
+            ...(componentType ? { componentType } : {}),
+        });
+    }
+    limitFailure(code, message, pointer, componentType) {
+        return new CompilerFailure('limit-exceeded', code, {
+            code,
+            severity: 'error',
+            message,
+            pointer,
+            ...(componentType ? { componentType } : {}),
+        });
+    }
+}
+exports.RecordContractCompiler = RecordContractCompiler;
+function containsPermissiveNode(node) {
+    switch (node.kind) {
+        case 'any':
+            return node.reason !== undefined;
+        case 'array':
+            return containsPermissiveNode(node.items);
+        case 'object':
+            return Object.values(node.properties).some(containsPermissiveNode);
+        case 'conditional':
+            return containsPermissiveNode(node.thenNode) || (node.elseNode ? containsPermissiveNode(node.elseNode) : false);
+        case 'scalar':
+            return false;
+        default: {
+            const exhaustive = node;
+            return exhaustive;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-contract-compiler.js","sourceRoot":"","sources":["../../src/record-contract/record-contract-compiler.ts"],"names":[],"mappings":"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"}