@researchdatabox/redbox-core 5.0.2 → 5.0.4-beta.12498

package/dist/record-contract/canonical-json.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedboxCanonicalJsonError = void 0;
+exports.normalizeRedboxCanonicalJsonV1 = normalizeRedboxCanonicalJsonV1;
+exports.serializeRedboxCanonicalJsonV1 = serializeRedboxCanonicalJsonV1;
+const deep_freeze_1 = require("./deep-freeze");
+/** A value Redbox Canonical JSON v1 cannot represent without silently changing it. */
+class RedboxCanonicalJsonError extends Error {
+    reason;
+    path;
+    constructor(reason, path, message) {
+        super(message);
+        this.reason = reason;
+        this.path = path;
+        this.name = 'RedboxCanonicalJsonError';
+    }
+}
+exports.RedboxCanonicalJsonError = RedboxCanonicalJsonError;
+function compareLexicographically(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function childPath(path, key) {
+    return `${path}[${JSON.stringify(key)}]`;
+}
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function normalizedArray(value, path, ancestors) {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new RedboxCanonicalJsonError('symbol-property', path, `${path} contains a symbol property, which Redbox Canonical JSON v1 rejects.`);
+    }
+    const names = Object.getOwnPropertyNames(value);
+    const expectedPropertyCount = value.length + 1;
+    if (names.length !== expectedPropertyCount || !names.includes('length')) {
+        throw new RedboxCanonicalJsonError('sparse-or-extended-array', path, `${path} is sparse or has extended array properties, which Redbox Canonical JSON v1 rejects.`);
+    }
+    const result = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const property = String(index);
+        if (!Object.prototype.hasOwnProperty.call(value, property)) {
+            throw new RedboxCanonicalJsonError('sparse-or-extended-array', path, `${path} is sparse, which Redbox Canonical JSON v1 rejects.`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, property);
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            throw new RedboxCanonicalJsonError('sparse-or-extended-array', `${path}[${index}]`, `${path}[${index}] is not an ordinary array item.`);
+        }
+        result.push(normalizeValue(descriptor.value, `${path}[${index}]`, ancestors));
+    }
+    return result;
+}
+function normalizedObject(value, path, ancestors) {
+    if (!isPlainObject(value)) {
+        throw new RedboxCanonicalJsonError('non-plain-object', path, `${path} is not a plain JSON object, which Redbox Canonical JSON v1 rejects.`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new RedboxCanonicalJsonError('symbol-property', path, `${path} contains a symbol property, which Redbox Canonical JSON v1 rejects.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const result = Object.create(null);
+    for (const key of Object.keys(descriptors).sort(compareLexicographically)) {
+        const descriptor = descriptors[key];
+        const propertyPath = childPath(path, key);
+        if (!descriptor.enumerable) {
+            throw new RedboxCanonicalJsonError('non-enumerable-property', propertyPath, `${propertyPath} is non-enumerable, which Redbox Canonical JSON v1 rejects.`);
+        }
+        if (!('value' in descriptor)) {
+            throw new RedboxCanonicalJsonError('accessor-property', propertyPath, `${propertyPath} is an accessor, which Redbox Canonical JSON v1 rejects without invoking it.`);
+        }
+        result[key] = normalizeValue(descriptor.value, propertyPath, ancestors);
+    }
+    return result;
+}
+function normalizeValue(value, path, ancestors) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new RedboxCanonicalJsonError('non-finite-number', path, `${path} contains a non-finite number, which Redbox Canonical JSON v1 rejects.`);
+        }
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== 'object') {
+        throw new RedboxCanonicalJsonError('non-json-type', path, `${path} contains ${typeof value}, which Redbox Canonical JSON v1 rejects.`);
+    }
+    if (ancestors.has(value)) {
+        throw new RedboxCanonicalJsonError('cycle', path, `${path} contains a cycle, which Redbox Canonical JSON v1 rejects.`);
+    }
+    ancestors.add(value);
+    try {
+        return Array.isArray(value) ? normalizedArray(value, path, ancestors) : normalizedObject(value, path, ancestors);
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function serializeNormalized(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(serializeNormalized).join(',')}]`;
+    }
+    const objectValue = value;
+    return `{${Object.keys(objectValue)
+        .sort(compareLexicographically)
+        .map(key => `${JSON.stringify(key)}:${serializeNormalized(objectValue[key])}`)
+        .join(',')}}`;
+}
+/**
+ * Clone and validate a value using Redbox Canonical JSON format v1 rules.
+ *
+ * V1 accepts only ordinary JSON values, preserves array order, converts -0 to
+ * JSON's ordinary `0`, and orders object keys lexicographically by UTF-16 code
+ * units. It deliberately rejects every value JSON.stringify would omit or
+ * silently rewrite, as well as cycles, accessors, and non-plain objects.
+ */
+function normalizeRedboxCanonicalJsonV1(value) {
+    return (0, deep_freeze_1.freezeDeep)(normalizeValue(value, '$', new Set()));
+}
+/** Serialize a value as Redbox Canonical JSON format v1. */
+function serializeRedboxCanonicalJsonV1(value) {
+    return serializeNormalized(normalizeRedboxCanonicalJsonV1(value));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/record-contract/codes.d.ts

@@ -0,0 +1,36 @@
+export declare const RECORD_SCHEMA_PROBLEM_CODES: {
+    readonly CONFIG_INVALID: "record-schema.config-invalid";
+    readonly AUTHENTICATION_REQUIRED: "record-schema.authentication-required";
+    readonly INVALID_REQUEST: "record-schema.invalid-request";
+    readonly NOT_FOUND: "record-schema.not-found";
+    readonly FORBIDDEN: "record-schema.forbidden";
+    readonly NOT_RESOLVABLE: "record-schema.not-resolvable";
+    readonly LIMIT_EXCEEDED: "record-schema.limit-exceeded";
+    readonly INVALID_CONTRACT: "record-schema.invalid-contract";
+    readonly UNAVAILABLE: "record-schema.unavailable";
+    readonly STORAGE_UNAVAILABLE: "record-schema.storage-unavailable";
+    readonly ARTIFACT_WRITE_FAILED: "record-schema.artifact-write-failed";
+    readonly GRANT_WRITE_FAILED: "record-schema.grant-write-failed";
+    readonly DIGEST_COLLISION: "record-schema.digest-collision";
+    readonly REFERENCE_INVALID: "record-schema.reference-invalid";
+    readonly REFERENCE_KEY_COLLISION: "record-schema.reference-key-collision";
+    readonly ARTIFACT_NOT_FOUND: "record-schema.artifact-not-found";
+    readonly LIMIT_DEPTH: "record-schema.limit-depth";
+    readonly LIMIT_PROPERTIES: "record-schema.limit-properties";
+    readonly LIMIT_DOCUMENT_BYTES: "record-schema.limit-document-bytes";
+    readonly LIMIT_DIAGNOSTICS: "record-schema.limit-diagnostics";
+    readonly LIMIT_CONTRIBUTOR_TIMEOUT: "record-schema.limit-contributor-timeout";
+    readonly CONTRIBUTOR_INVALID: "record-schema.contributor-invalid";
+    readonly CONTRIBUTOR_DUPLICATE: "record-schema.contributor-duplicate";
+    readonly CONTRIBUTOR_FAILED: "record-schema.contributor-failed";
+    readonly UNSUPPORTED_COMPONENT: "record-schema.unsupported-component";
+    readonly PRECONDITION_FAILED: "record-schema.precondition-failed";
+    readonly TYPE: "record-schema.type";
+    readonly ADDITIONAL_PROPERTY: "record-schema.additional-property";
+    readonly REQUIRED: "record-schema.required";
+    readonly ENUM: "record-schema.enum";
+    readonly ARRAY_ITEM: "record-schema.array-item";
+    readonly VALIDATION_GENERIC: "record-schema.validation";
+};
+export type RecordSchemaProblemCode = (typeof RECORD_SCHEMA_PROBLEM_CODES)[keyof typeof RECORD_SCHEMA_PROBLEM_CODES];
+//# sourceMappingURL=codes.d.ts.map

package/dist/record-contract/codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../src/record-contract/codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC9B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/record-contract/codes.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_SCHEMA_PROBLEM_CODES = void 0;
+exports.RECORD_SCHEMA_PROBLEM_CODES = {
+    CONFIG_INVALID: 'record-schema.config-invalid',
+    AUTHENTICATION_REQUIRED: 'record-schema.authentication-required',
+    INVALID_REQUEST: 'record-schema.invalid-request',
+    NOT_FOUND: 'record-schema.not-found',
+    FORBIDDEN: 'record-schema.forbidden',
+    NOT_RESOLVABLE: 'record-schema.not-resolvable',
+    LIMIT_EXCEEDED: 'record-schema.limit-exceeded',
+    INVALID_CONTRACT: 'record-schema.invalid-contract',
+    UNAVAILABLE: 'record-schema.unavailable',
+    STORAGE_UNAVAILABLE: 'record-schema.storage-unavailable',
+    ARTIFACT_WRITE_FAILED: 'record-schema.artifact-write-failed',
+    GRANT_WRITE_FAILED: 'record-schema.grant-write-failed',
+    DIGEST_COLLISION: 'record-schema.digest-collision',
+    REFERENCE_INVALID: 'record-schema.reference-invalid',
+    REFERENCE_KEY_COLLISION: 'record-schema.reference-key-collision',
+    ARTIFACT_NOT_FOUND: 'record-schema.artifact-not-found',
+    LIMIT_DEPTH: 'record-schema.limit-depth',
+    LIMIT_PROPERTIES: 'record-schema.limit-properties',
+    LIMIT_DOCUMENT_BYTES: 'record-schema.limit-document-bytes',
+    LIMIT_DIAGNOSTICS: 'record-schema.limit-diagnostics',
+    LIMIT_CONTRIBUTOR_TIMEOUT: 'record-schema.limit-contributor-timeout',
+    CONTRIBUTOR_INVALID: 'record-schema.contributor-invalid',
+    CONTRIBUTOR_DUPLICATE: 'record-schema.contributor-duplicate',
+    CONTRIBUTOR_FAILED: 'record-schema.contributor-failed',
+    UNSUPPORTED_COMPONENT: 'record-schema.unsupported-component',
+    PRECONDITION_FAILED: 'record-schema.precondition-failed',
+    TYPE: 'record-schema.type',
+    ADDITIONAL_PROPERTY: 'record-schema.additional-property',
+    REQUIRED: 'record-schema.required',
+    ENUM: 'record-schema.enum',
+    ARRAY_ITEM: 'record-schema.array-item',
+    VALIDATION_GENERIC: 'record-schema.validation',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVjb3JkLWNvbnRyYWN0L2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFhLFFBQUEsMkJBQTJCLEdBQUc7SUFDekMsY0FBYyxFQUFFLDhCQUE4QjtJQUU5Qyx1QkFBdUIsRUFBRSx1Q0FBdUM7SUFDaEUsZUFBZSxFQUFFLCtCQUErQjtJQUNoRCxTQUFTLEVBQUUseUJBQXlCO0lBQ3BDLFNBQVMsRUFBRSx5QkFBeUI7SUFDcEMsY0FBYyxFQUFFLDhCQUE4QjtJQUM5QyxjQUFjLEVBQUUsOEJBQThCO0lBQzlDLGdCQUFnQixFQUFFLGdDQUFnQztJQUNsRCxXQUFXLEVBQUUsMkJBQTJCO0lBRXhDLG1CQUFtQixFQUFFLG1DQUFtQztJQUN4RCxxQkFBcUIsRUFBRSxxQ0FBcUM7SUFDNUQsa0JBQWtCLEVBQUUsa0NBQWtDO0lBQ3RELGdCQUFnQixFQUFFLGdDQUFnQztJQUNsRCxpQkFBaUIsRUFBRSxpQ0FBaUM7SUFDcEQsdUJBQXVCLEVBQUUsdUNBQXVDO0lBQ2hFLGtCQUFrQixFQUFFLGtDQUFrQztJQUV0RCxXQUFXLEVBQUUsMkJBQTJCO0lBQ3hDLGdCQUFnQixFQUFFLGdDQUFnQztJQUNsRCxvQkFBb0IsRUFBRSxvQ0FBb0M7SUFDMUQsaUJBQWlCLEVBQUUsaUNBQWlDO0lBQ3BELHlCQUF5QixFQUFFLHlDQUF5QztJQUVwRSxtQkFBbUIsRUFBRSxtQ0FBbUM7SUFDeEQscUJBQXFCLEVBQUUscUNBQXFDO0lBQzVELGtCQUFrQixFQUFFLGtDQUFrQztJQUN0RCxxQkFBcUIsRUFBRSxxQ0FBcUM7SUFFNUQsbUJBQW1CLEVBQUUsbUNBQW1DO0lBRXhELElBQUksRUFBRSxvQkFBb0I7SUFDMUIsbUJBQW1CLEVBQUUsbUNBQW1DO0lBQ3hELFFBQVEsRUFBRSx3QkFBd0I7SUFDbEMsSUFBSSxFQUFFLG9CQUFvQjtJQUMxQixVQUFVLEVBQUUsMEJBQTBCO0lBQ3RDLGtCQUFrQixFQUFFLDBCQUEwQjtDQUN0QyxDQUFDIn0=

package/dist/record-contract/contributor-registry.d.ts

@@ -0,0 +1,76 @@
+import type { FormComponentDefinitionFrame } from '@researchdatabox/sails-ng-common';
+import type { ContractNode, ContractObjectNode, RecordContractDiagnostic, RecordContractPointer, RecordContractPublicContext } from './types';
+export type RecordContractContributorNullability = 'non-null' | 'nullable' | 'configuration';
+export interface RecordContractCompileChildrenOptions {
+    readonly definitionKey?: string;
+}
+export interface RecordContractContributorCompileContext {
+    readonly component: Readonly<FormComponentDefinitionFrame>;
+    readonly pointer: RecordContractPointer;
+    readonly publicContext: RecordContractPublicContext;
+    compileChildren(components: readonly FormComponentDefinitionFrame[], parent: RecordContractPointer, options?: RecordContractCompileChildrenOptions): Promise<ContractObjectNode>;
+}
+export type RecordContractComponentContribution = {
+    readonly kind: 'node';
+    readonly node: ContractNode;
+    readonly diagnostics?: readonly RecordContractDiagnostic[];
+} | {
+    readonly kind: 'non-persisting';
+    readonly children?: readonly FormComponentDefinitionFrame[];
+};
+interface RecordContractContributorBase {
+    readonly key: string;
+    readonly version: string;
+    readonly nullability: RecordContractContributorNullability;
+}
+export interface RecordContractComponentContributor extends RecordContractContributorBase {
+    readonly kind: 'component';
+    readonly componentType: string;
+    /** RFC 6901 pointers relative to the component's form-owned field root. */
+    readonly ownedPointers: readonly string[];
+    compile(context: RecordContractContributorCompileContext): RecordContractComponentContribution | Promise<RecordContractComponentContribution>;
+}
+export type RecordContractContributor = RecordContractComponentContributor;
+export interface RecordContractContributorRegistration {
+    readonly contributor: RecordContractContributor;
+    readonly source: 'core' | 'hook';
+    readonly packageName?: string;
+}
+export declare const RECORD_CONTRACT_REGISTRATION_CODES: {
+    readonly INVALID_KEY: "record-contract.registration.invalid-key";
+    readonly INVALID_VERSION: "record-contract.registration.invalid-version";
+    readonly INVALID_COMPONENT_TYPE: "record-contract.registration.invalid-component-type";
+    readonly INVALID_POINTER: "record-contract.registration.invalid-pointer";
+    readonly DUPLICATE_KEY: "record-contract.registration.duplicate-key";
+    readonly DUPLICATE_COMPONENT: "record-contract.registration.duplicate-component";
+    readonly OVERLAPPING_ROOT: "record-contract.registration.overlapping-root";
+    readonly INVALID_EXPORT: "record-contract.registration.invalid-export";
+};
+export type RecordContractRegistrationCode = (typeof RECORD_CONTRACT_REGISTRATION_CODES)[keyof typeof RECORD_CONTRACT_REGISTRATION_CODES];
+export interface RecordContractRegistrationIssue {
+    readonly code: RecordContractRegistrationCode;
+    readonly key: string;
+    readonly detail: string;
+}
+export declare class RecordContractContributorRegistrationError extends Error {
+    readonly issues: readonly RecordContractRegistrationIssue[];
+    constructor(issues: readonly RecordContractRegistrationIssue[]);
+}
+export interface RecordContractContributorRegistryOptions {
+    readonly additionalIssues?: readonly RecordContractRegistrationIssue[];
+}
+/** Immutable, deterministically ordered registry validated at its construction boundary. */
+export declare class RecordContractContributorRegistry {
+    #private;
+    constructor(registrations: readonly RecordContractContributorRegistration[], options?: RecordContractContributorRegistryOptions);
+    registrations(): readonly RecordContractContributorRegistration[];
+    component(componentType: string): RecordContractContributorRegistration | undefined;
+}
+export interface RecordContractContributorDiscoveryState {
+    readonly registrations: readonly RecordContractContributorRegistration[];
+    readonly registrationIssues: readonly RecordContractRegistrationIssue[];
+    readonly componentTypes: readonly string[];
+}
+export declare function recordContractContributorDiscoveryState(registrations: readonly RecordContractContributorRegistration[], registrationIssues?: readonly RecordContractRegistrationIssue[]): RecordContractContributorDiscoveryState;
+export {};
+//# sourceMappingURL=contributor-registry.d.ts.map

package/dist/record-contract/contributor-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contributor-registry.d.ts","sourceRoot":"","sources":["../../src/record-contract/contributor-registry.ts"],"names":[],"mappings":"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"}

package/dist/record-contract/contributor-registry.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordContractContributorRegistry = exports.RecordContractContributorRegistrationError = exports.RECORD_CONTRACT_REGISTRATION_CODES = void 0;
+exports.recordContractContributorDiscoveryState = recordContractContributorDiscoveryState;
+const json_pointer_1 = require("./json-pointer");
+exports.RECORD_CONTRACT_REGISTRATION_CODES = {
+    INVALID_KEY: 'record-contract.registration.invalid-key',
+    INVALID_VERSION: 'record-contract.registration.invalid-version',
+    INVALID_COMPONENT_TYPE: 'record-contract.registration.invalid-component-type',
+    INVALID_POINTER: 'record-contract.registration.invalid-pointer',
+    DUPLICATE_KEY: 'record-contract.registration.duplicate-key',
+    DUPLICATE_COMPONENT: 'record-contract.registration.duplicate-component',
+    OVERLAPPING_ROOT: 'record-contract.registration.overlapping-root',
+    INVALID_EXPORT: 'record-contract.registration.invalid-export',
+};
+class RecordContractContributorRegistrationError extends Error {
+    issues;
+    constructor(issues) {
+        const sorted = sortRegistrationIssues(issues);
+        super(`Invalid record-contract contributor registrations:\n${sorted
+            .map(issue => `- ${issue.code} [${issue.key}]: ${issue.detail}`)
+            .join('\n')}`);
+        this.name = 'RecordContractContributorRegistrationError';
+        this.issues = Object.freeze(sorted.map(item => Object.freeze({ ...item })));
+    }
+}
+exports.RecordContractContributorRegistrationError = RecordContractContributorRegistrationError;
+const STABLE_KEY = /^[a-z0-9][a-z0-9._:/-]*$/;
+const STABLE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const COMPONENT_TYPE = /^[A-Za-z][A-Za-z0-9_.:-]*$/;
+function sortRegistrationIssues(issues) {
+    return [...issues].sort((left, right) => left.code.localeCompare(right.code) ||
+        left.key.localeCompare(right.key) ||
+        left.detail.localeCompare(right.detail));
+}
+function registrationSortKey(registration) {
+    const contributor = registration.contributor;
+    return `${contributor.componentType}:${contributor.key}:${registration.packageName ?? ''}`;
+}
+function immutableRegistration(registration) {
+    const contributor = Object.freeze({
+        ...registration.contributor,
+        ownedPointers: Object.freeze([...registration.contributor.ownedPointers]),
+    });
+    return Object.freeze({
+        contributor,
+        source: registration.source,
+        ...(registration.packageName === undefined ? {} : { packageName: registration.packageName }),
+    });
+}
+function issue(code, key, detail) {
+    return { code, key, detail };
+}
+/** Immutable, deterministically ordered registry validated at its construction boundary. */
+class RecordContractContributorRegistry {
+    #registrations;
+    #components;
+    constructor(registrations, options = {}) {
+        const ordered = registrations
+            .map(immutableRegistration)
+            .sort((left, right) => registrationSortKey(left).localeCompare(registrationSortKey(right)));
+        const issues = [...(options.additionalIssues ?? [])];
+        const keys = new Map();
+        const components = new Map();
+        for (const registration of ordered) {
+            const contributor = registration.contributor;
+            const key = contributor.key.trim();
+            if (!STABLE_KEY.test(key)) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.INVALID_KEY, contributor.key, 'Expected a stable lowercase key.'));
+            }
+            if (!STABLE_VERSION.test(contributor.version)) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.INVALID_VERSION, contributor.key, 'Expected a non-blank stable version.'));
+            }
+            if (keys.has(key)) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.DUPLICATE_KEY, key, 'Contributor key is already registered.'));
+            }
+            else {
+                keys.set(key, registration);
+            }
+            if (!COMPONENT_TYPE.test(contributor.componentType)) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.INVALID_COMPONENT_TYPE, contributor.key, `Invalid component type ${JSON.stringify(contributor.componentType)}.`));
+            }
+            if (components.has(contributor.componentType)) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.DUPLICATE_COMPONENT, contributor.componentType, 'Component type is already registered.'));
+            }
+            else {
+                components.set(contributor.componentType, registration);
+            }
+            if (contributor.ownedPointers.length === 0) {
+                issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.INVALID_POINTER, contributor.key, 'A component contributor must declare at least one owned pointer.'));
+            }
+            const owned = [];
+            for (const pointer of contributor.ownedPointers) {
+                if (!(0, json_pointer_1.isRecordContractPointer)(pointer)) {
+                    issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.INVALID_POINTER, contributor.key, `Invalid relative owned pointer ${JSON.stringify(pointer)}.`));
+                }
+                else if (owned.some(existing => (0, json_pointer_1.recordContractPointersOverlap)(existing, pointer))) {
+                    issues.push(issue(exports.RECORD_CONTRACT_REGISTRATION_CODES.OVERLAPPING_ROOT, contributor.key, `Owned pointer ${JSON.stringify(pointer)} overlaps another owned pointer.`));
+                }
+                else {
+                    owned.push((0, json_pointer_1.recordContractPointer)(pointer));
+                }
+            }
+        }
+        if (issues.length > 0) {
+            throw new RecordContractContributorRegistrationError(issues);
+        }
+        this.#registrations = Object.freeze(ordered);
+        this.#components = components;
+    }
+    registrations() {
+        return this.#registrations;
+    }
+    component(componentType) {
+        return this.#components.get(componentType);
+    }
+}
+exports.RecordContractContributorRegistry = RecordContractContributorRegistry;
+function recordContractContributorDiscoveryState(registrations, registrationIssues = []) {
+    return Object.freeze({
+        registrations: Object.freeze([...registrations]),
+        registrationIssues: Object.freeze(sortRegistrationIssues(registrationIssues).map(item => Object.freeze({ ...item }))),
+        componentTypes: Object.freeze([...new Set(registrations.map(registration => registration.contributor.componentType))].sort((left, right) => left < right ? -1 : left > right ? 1 : 0)),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/record-contract/core-contributors.d.ts

@@ -0,0 +1,44 @@
+import type { RecordContractComponentContributor } from './contributor-registry';
+export type CoreRecordContractComponentClassification = 'scalar' | 'object' | 'array' | 'specialized' | 'container' | 'non-persisting';
+/** Closed inventory used by startup/CI coverage checks. */
+export declare const CORE_RECORD_CONTRACT_COMPONENT_INVENTORY: {
+    readonly AccordionComponent: "container";
+    readonly AccordionPanelComponent: "container";
+    readonly CancelButtonComponent: "non-persisting";
+    readonly CheckboxInputComponent: "scalar";
+    readonly CheckboxTreeComponent: "specialized";
+    readonly ContentComponent: "non-persisting";
+    readonly DataLocationComponent: "specialized";
+    readonly DateInputComponent: "scalar";
+    readonly DeleteButtonComponent: "non-persisting";
+    readonly DropdownInputComponent: "scalar";
+    readonly FileUploadComponent: "specialized";
+    readonly GroupComponent: "object";
+    readonly IntegrationStatusComponent: "non-persisting";
+    readonly MapComponent: "specialized";
+    readonly PDFListComponent: "specialized";
+    readonly PublishDataLocationRefreshComponent: "non-persisting";
+    readonly PublishDataLocationSelectorComponent: "specialized";
+    readonly QuestionTreeComponent: "specialized";
+    readonly RadioInputComponent: "scalar";
+    readonly RecordMetadataRetrieverComponent: "non-persisting";
+    readonly RecordSelectorComponent: "specialized";
+    readonly RelatedObjectDataComponent: "non-persisting";
+    readonly RepeatableComponent: "array";
+    readonly ReusableComponent: "container";
+    readonly RichTextEditorComponent: "scalar";
+    readonly SaveButtonComponent: "non-persisting";
+    readonly SaveStatusComponent: "non-persisting";
+    readonly SimpleInputComponent: "scalar";
+    readonly SuggestedValidationSummaryComponent: "non-persisting";
+    readonly TabComponent: "container";
+    readonly TabContentComponent: "container";
+    readonly TabNavButtonComponent: "non-persisting";
+    readonly TextAreaComponent: "scalar";
+    readonly TypeaheadInputComponent: "specialized";
+    readonly ValidationSummaryComponent: "non-persisting";
+    readonly WorkspaceSelectorComponent: "non-persisting";
+};
+export type CoreRecordContractComponentType = keyof typeof CORE_RECORD_CONTRACT_COMPONENT_INVENTORY;
+export declare function createCoreRecordContractContributors(): readonly RecordContractComponentContributor[];
+//# sourceMappingURL=core-contributors.d.ts.map

package/dist/record-contract/core-contributors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-contributors.d.ts","sourceRoot":"","sources":["../../src/record-contract/core-contributors.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAEV,kCAAkC,EAGnC,MAAM,wBAAwB,CAAC;AAGhC,MAAM,MAAM,yCAAyC,GACnD,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAEjF,2DAA2D;AAC3D,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCmC,CAAC;AAEzF,MAAM,MAAM,+BAA+B,GAAG,MAAM,OAAO,wCAAwC,CAAC;AA4YpG,wBAAgB,oCAAoC,IAAI,SAAS,kCAAkC,EAAE,CA0EpG"}