@noeos/verification-engine 0.0.0

package/dist/cjs/normalization/jcs-profile.js

@@ -0,0 +1,154 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jcsProfile = void 0;
+const identifiers_js_1 = require("../domain/identifiers.js");
+const version_js_1 = require("../domain/version.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const json_value_validation_js_1 = require("../validation/json-value-validation.js");
+const byte_sink_js_1 = require("./byte-sink.js");
+const JCS_PROFILE_ID = identifiers_js_1.ProfileId.fromValidated("dev.noeos.jcs");
+const JCS_PROFILE_VERSION = version_js_1.ProfileVersion.fromValidated("1.0.0");
+const EMPTY = "";
+exports.jcsProfile = Object.freeze({
+    id: JCS_PROFILE_ID,
+    version: JCS_PROFILE_VERSION,
+    inputKind: "json",
+    validate(input, limits) {
+        return (0, json_value_validation_js_1.validateJsonValue)(input, limits);
+    },
+    normalize(input, sink) {
+        writeValue(input, sink);
+        return (0, operation_result_js_1.success)(Object.freeze({ byteLength: sink.byteLength }));
+    },
+});
+function writeValue(value, sink) {
+    if (value === null) {
+        writeAscii("null", sink);
+        return;
+    }
+    if (typeof value === "boolean") {
+        writeAscii(value ? "true" : "false", sink);
+        return;
+    }
+    if (typeof value === "number") {
+        writeText(numberToJcs(value), sink);
+        return;
+    }
+    if (typeof value === "string") {
+        writeJsonString(value, sink);
+        return;
+    }
+    if (isJsonArray(value)) {
+        writeArray(value, sink);
+        return;
+    }
+    writeObject(value, sink);
+}
+function isJsonArray(value) {
+    return Array.isArray(value);
+}
+function writeArray(value, sink) {
+    writeAscii("[", sink);
+    for (let index = 0; index < value.length; index += 1) {
+        if (index > 0)
+            writeAscii(",", sink);
+        const item = value[index];
+        if (item === undefined)
+            throw new TypeError("invalid JSON array");
+        writeValue(item, sink);
+    }
+    writeAscii("]", sink);
+}
+function writeObject(value, sink) {
+    const keys = Object.keys(value).sort(compareUtf16);
+    writeAscii("{", sink);
+    let first = true;
+    for (const key of keys) {
+        if (!first)
+            writeAscii(",", sink);
+        first = false;
+        const item = value[key];
+        if (item === undefined)
+            throw new TypeError("invalid JSON object");
+        writeJsonString(key, sink);
+        writeAscii(":", sink);
+        writeValue(item, sink);
+    }
+    writeAscii("}", sink);
+}
+function writeJsonString(value, sink) {
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit <= 0x1f || codeUnit === 0x22 || codeUnit === 0x5c) {
+            escaped = true;
+            break;
+        }
+    }
+    if (!escaped) {
+        writeAscii('"', sink);
+        writeText(value, sink);
+        writeAscii('"', sink);
+        return;
+    }
+    writeText(stringToJcs(value), sink);
+}
+function stringToJcs(value) {
+    let output = '"';
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        switch (codeUnit) {
+            case 0x08:
+                output += "\\b";
+                break;
+            case 0x09:
+                output += "\\t";
+                break;
+            case 0x0a:
+                output += "\\n";
+                break;
+            case 0x0c:
+                output += "\\f";
+                break;
+            case 0x0d:
+                output += "\\r";
+                break;
+            case 0x22:
+                output += '\\"';
+                break;
+            case 0x5c:
+                output += "\\\\";
+                break;
+            default:
+                if (codeUnit <= 0x1f)
+                    output += `\\u${codeUnit.toString(16).padStart(4, "0")}`;
+                else
+                    output += value.charAt(index);
+        }
+    }
+    return `${output}"`;
+}
+function numberToJcs(value) {
+    if (Object.is(value, -0))
+        return "0";
+    if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+        throw new TypeError("invalid JSON number");
+    }
+    return JSON.stringify(value);
+}
+function writeText(value, sink) {
+    if (sink instanceof byte_sink_js_1.ByteArraySink)
+        sink.writeText(value);
+    else
+        sink.write(new TextEncoder().encode(value));
+}
+function writeAscii(value, sink) {
+    if (sink instanceof byte_sink_js_1.ByteArraySink)
+        sink.writeAscii(value);
+    else
+        sink.write(new TextEncoder().encode(value || EMPTY));
+}
+function compareUtf16(left, right) {
+    return left < right ? -1 : 1;
+}

package/dist/cjs/normalization/normalize.js

@@ -0,0 +1,56 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToBytes = normalizeToBytes;
+exports.normalizeRegisteredToBytes = normalizeRegisteredToBytes;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const byte_sink_js_1 = require("./byte-sink.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+function normalizeToBytes(profile, input, limits) {
+    const validated = profile.validate(input, limits);
+    if (!validated.ok)
+        return validated;
+    const sink = new byte_sink_js_1.ByteArraySink(limits.maxPayloadBytes, initialCapacity(input));
+    try {
+        const normalized = profile.normalize(validated.value, sink, limits);
+        if (!normalized.ok)
+            return normalized;
+        if (normalized.value.byteLength !== sink.byteLength)
+            return normalizationFailure(limits);
+        const bytes = sink.takeBytes();
+        return {
+            ok: true,
+            value: Object.freeze({ bytes, stats: normalized.value }),
+            diagnostics: normalized.diagnostics,
+        };
+    }
+    catch {
+        return normalizationFailure(limits);
+    }
+}
+function normalizeRegisteredToBytes(profile, input, limits) {
+    const sink = new byte_sink_js_1.ByteArraySink(limits.maxPayloadBytes, initialCapacity(input));
+    try {
+        const normalized = (profile.normalizeValidated ?? profile.normalize)(input, sink, limits);
+        if (!normalized.ok)
+            return normalized;
+        if (normalized.value.byteLength !== sink.byteLength)
+            return normalizationFailure(limits);
+        return {
+            ok: true,
+            value: Object.freeze({ bytes: sink.takeBytes(), stats: normalized.value }),
+            diagnostics: normalized.diagnostics,
+        };
+    }
+    catch {
+        return normalizationFailure(limits);
+    }
+}
+function normalizationFailure(limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode("NORMALIZATION_FAILED", "normalization");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}
+function initialCapacity(input) {
+    return input instanceof Uint8Array ? input.length : 0;
+}

package/dist/cjs/normalization/profile-registry.js

@@ -0,0 +1,66 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileRegistry = void 0;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const jcs_profile_js_1 = require("./jcs-profile.js");
+const raw_bytes_profile_js_1 = require("./raw-bytes-profile.js");
+class ProfileRegistry {
+    profiles = new Map();
+    constructor(additional = []) {
+        this.registerBuiltin(raw_bytes_profile_js_1.rawBytesProfile);
+        this.registerBuiltin(jcs_profile_js_1.jcsProfile);
+        for (const profile of additional) {
+            const result = this.register(profile);
+            if (!result.ok)
+                throw new Error("profile registration conflict");
+        }
+    }
+    register(profile) {
+        const key = profileKey(profile.id, profile.version);
+        if (this.profiles.has(key)) {
+            return (0, operation_result_js_1.failure)([(0, diagnostic_collector_js_1.createDiagnostic)("PROFILE_VERSION_CONFLICT", "input")]);
+        }
+        this.profiles.set(key, eraseProfile(profile));
+        return (0, operation_result_js_1.success)(undefined);
+    }
+    resolve(id, version) {
+        const profile = this.profiles.get(profileKey(id, version));
+        if (profile === undefined)
+            return (0, operation_result_js_1.failure)([(0, diagnostic_collector_js_1.createDiagnostic)("PROFILE_UNKNOWN", "input")]);
+        return (0, operation_result_js_1.success)(profile);
+    }
+    resolveValidated(reference) {
+        const profile = this.profiles.get(`${reference.id}\u0000${reference.version}`);
+        if (profile === undefined)
+            return (0, operation_result_js_1.failure)([(0, diagnostic_collector_js_1.createDiagnostic)("PROFILE_UNKNOWN", "input")]);
+        return (0, operation_result_js_1.success)(profile);
+    }
+    registerBuiltin(profile) {
+        this.profiles.set(profileKey(profile.id, profile.version), eraseProfile(profile));
+    }
+}
+exports.ProfileRegistry = ProfileRegistry;
+function eraseProfile(profile) {
+    return Object.freeze({
+        id: profile.id,
+        version: profile.version,
+        inputKind: profile.inputKind,
+        validate: (input, limits) => profile.validate(input, limits),
+        normalize: (input, sink, limits) => {
+            const validated = profile.validate(input, limits);
+            if (!validated.ok)
+                return validated;
+            return profile.normalize(validated.value, sink, limits);
+        },
+        normalizeValidated: (input, sink, limits) => {
+            // The record service invokes this only after the profile validator succeeds.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- erased generic at the trusted registry boundary
+            return profile.normalize(input, sink, limits);
+        },
+    });
+}
+function profileKey(id, version) {
+    return `${id.value}\u0000${version.value}`;
+}

package/dist/cjs/normalization/profile.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/normalization/raw-bytes-profile.js

@@ -0,0 +1,27 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawBytesProfile = void 0;
+const node_util_1 = require("node:util");
+const identifiers_js_1 = require("../domain/identifiers.js");
+const version_js_1 = require("../domain/version.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("../validation/result-helpers.js");
+const RAW_PROFILE_ID = identifiers_js_1.ProfileId.fromValidated("dev.noeos.raw-bytes");
+const RAW_PROFILE_VERSION = version_js_1.ProfileVersion.fromValidated("1.0.0");
+exports.rawBytesProfile = Object.freeze({
+    id: RAW_PROFILE_ID,
+    version: RAW_PROFILE_VERSION,
+    inputKind: "bytes",
+    validate(input, limits) {
+        if (node_util_1.types.isProxy(input) || !(input instanceof Uint8Array))
+            return (0, result_helpers_js_1.failureWithCode)("INPUT_TYPE_INVALID", "input");
+        if (input.length > limits.maxPayloadBytes)
+            return (0, result_helpers_js_1.failureWithCode)("INPUT_LIMIT_EXCEEDED", "input");
+        return (0, operation_result_js_1.success)(input);
+    },
+    normalize(input, sink) {
+        sink.write(input);
+        return (0, operation_result_js_1.success)(Object.freeze({ byteLength: input.length }));
+    },
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/profiles.js

@@ -0,0 +1,9 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_PROFILES = void 0;
+/** @public */
+exports.BUILTIN_PROFILES = Object.freeze([
+    Object.freeze({ id: "dev.noeos.raw-bytes", version: "1.0.0", inputKind: "bytes" }),
+    Object.freeze({ id: "dev.noeos.jcs", version: "1.0.0", inputKind: "json" }),
+]);

package/dist/cjs/records/record-service.js

@@ -0,0 +1,278 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashRecord = hashRecord;
+exports.computeRecord = computeRecord;
+exports.verifyComputedRecord = verifyComputedRecord;
+exports.validateRecordInput = validateRecordInput;
+exports.validateProfile = validateProfile;
+exports.freezeRecordEvidence = freezeRecordEvidence;
+const node_util_1 = require("node:util");
+const evidence_js_1 = require("../domain/evidence.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const frame_builders_js_1 = require("../framing/frame-builders.js");
+const hash_frame_js_1 = require("../hashing/hash-frame.js");
+const normalize_js_1 = require("../normalization/normalize.js");
+const rule_set_js_1 = require("../rules/rule-set.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const algorithm_validation_js_1 = require("../validation/algorithm-validation.js");
+const digest_validation_js_1 = require("../validation/digest-validation.js");
+const identifier_validation_js_1 = require("../validation/identifier-validation.js");
+const object_inspection_js_1 = require("../validation/object-inspection.js");
+const result_helpers_js_1 = require("../validation/result-helpers.js");
+const version_validation_js_1 = require("../validation/version-validation.js");
+function hashRecord(input, options) {
+    const computed = computeRecord(input, options);
+    if (!computed.ok)
+        return computed;
+    return (0, operation_result_js_1.success)(computed.value.evidence, computed.diagnostics);
+}
+function computeRecord(input, options) {
+    const validated = validateRecordInput(input, options.limits);
+    if (!validated.ok)
+        return validated;
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(options.limits);
+    const hasRules = options.rules?.hasRules() === true;
+    if (hasRules) {
+        addAll(collector, options.rules.evaluate(Object.freeze({
+            phase: "input",
+            input: freezeInputView(validated.value),
+            recordId: validated.value.recordId,
+        }), options.limits));
+    }
+    if (collector.hasErrors())
+        return (0, operation_result_js_1.failure)(collector.finish());
+    const profileReference = validateProfileReference(validated.value, options);
+    if (!profileReference.ok)
+        return profileReference;
+    const profile = profileReference.value;
+    if (profile.inputKind === "json" && inputPayloadIsBytes(validated.value.payload)) {
+        collector.addCode("PROFILE_INPUT_KIND_MISMATCH", "input", {
+            recordId: validated.value.recordId,
+        });
+        return (0, operation_result_js_1.failure)(collector.finish());
+    }
+    if (profile.inputKind === "bytes" && !inputPayloadIsBytes(validated.value.payload)) {
+        collector.addCode("PROFILE_INPUT_KIND_MISMATCH", "input", {
+            recordId: validated.value.recordId,
+        });
+        return (0, operation_result_js_1.failure)(collector.finish());
+    }
+    if (isBuiltinRawProfile(profile) && !hasRules) {
+        return computeBuiltinRawRecord(validated.value, options);
+    }
+    const profileInput = profile.validate(validated.value.payload, options.limits);
+    if (!profileInput.ok)
+        return profileInput;
+    const normalized = (0, normalize_js_1.normalizeRegisteredToBytes)(profile, profileInput.value, options.limits);
+    if (!normalized.ok)
+        return normalized;
+    addAll(collector, normalized.diagnostics);
+    if (hasRules) {
+        addAll(collector, options.rules.evaluate(Object.freeze({
+            phase: "normalization",
+            normalized: (0, rule_set_js_1.createReadonlyByteView)(normalized.value.bytes),
+            recordId: validated.value.recordId,
+        }), options.limits));
+    }
+    if (collector.hasErrors())
+        return (0, operation_result_js_1.failure)(collector.finish());
+    const contentDigest = (0, hash_frame_js_1.hashTrustedFrame)(validated.value.algorithm, (0, frame_builders_js_1.buildTrustedContentFrame)({
+        algorithm: validated.value.algorithm,
+        profileId: validated.value.profile.id,
+        profileVersion: validated.value.profile.version,
+        normalizedBytes: normalized.value.bytes,
+    }, options.limits));
+    if (!contentDigest.ok)
+        return contentDigest;
+    const recordDigest = (0, hash_frame_js_1.hashTrustedFrame)(validated.value.algorithm, (0, frame_builders_js_1.buildTrustedRecordFrame)({
+        algorithm: validated.value.algorithm,
+        contextId: validated.value.contextId,
+        recordId: validated.value.recordId,
+        profileId: validated.value.profile.id,
+        profileVersion: validated.value.profile.version,
+        normalizedByteLength: normalized.value.stats.byteLength,
+        contentDigest: contentDigest.value,
+    }, options.limits));
+    if (!recordDigest.ok)
+        return recordDigest;
+    const evidence = freezeRecordEvidence({
+        $schema: evidence_js_1.RECORD_EVIDENCE_SCHEMA,
+        protocolVersion: 1,
+        contextId: validated.value.contextId,
+        recordId: validated.value.recordId,
+        profile: validated.value.profile,
+        algorithm: validated.value.algorithm,
+        normalizedByteLength: normalized.value.stats.byteLength,
+        contentDigest: contentDigest.value.toHex(),
+        recordDigest: recordDigest.value.toHex(),
+    });
+    if (hasRules) {
+        addAll(collector, options.rules.evaluate(Object.freeze({
+            phase: "record",
+            record: evidence,
+            recordId: evidence.recordId,
+        }), options.limits));
+    }
+    if (collector.hasErrors())
+        return (0, operation_result_js_1.failure)(collector.finish());
+    return (0, operation_result_js_1.success)(Object.freeze({
+        evidence,
+        contentDigest: contentDigest.value,
+        recordDigest: recordDigest.value,
+    }), collector.finish());
+}
+function computeBuiltinRawRecord(input, options) {
+    if (node_util_1.types.isProxy(input.payload) || !(input.payload instanceof Uint8Array)) {
+        return (0, result_helpers_js_1.failureWithCode)("INPUT_TYPE_INVALID", "input");
+    }
+    if (input.payload.length > options.limits.maxPayloadBytes) {
+        return (0, result_helpers_js_1.failureWithCode)("INPUT_LIMIT_EXCEEDED", "input");
+    }
+    const contentDigest = (0, hash_frame_js_1.hashTrustedFrame)(input.algorithm, (0, frame_builders_js_1.buildTrustedContentFrame)({
+        algorithm: input.algorithm,
+        profileId: input.profile.id,
+        profileVersion: input.profile.version,
+        normalizedBytes: input.payload,
+    }, options.limits));
+    if (!contentDigest.ok)
+        return contentDigest;
+    const recordDigest = (0, hash_frame_js_1.hashTrustedFrame)(input.algorithm, (0, frame_builders_js_1.buildTrustedRecordFrame)({
+        algorithm: input.algorithm,
+        contextId: input.contextId,
+        recordId: input.recordId,
+        profileId: input.profile.id,
+        profileVersion: input.profile.version,
+        normalizedByteLength: input.payload.length,
+        contentDigest: contentDigest.value,
+    }, options.limits));
+    if (!recordDigest.ok)
+        return recordDigest;
+    const evidence = freezeRecordEvidence({
+        $schema: evidence_js_1.RECORD_EVIDENCE_SCHEMA,
+        protocolVersion: 1,
+        contextId: input.contextId,
+        recordId: input.recordId,
+        profile: input.profile,
+        algorithm: input.algorithm,
+        normalizedByteLength: input.payload.length,
+        contentDigest: contentDigest.value.toHex(),
+        recordDigest: recordDigest.value.toHex(),
+    });
+    return (0, operation_result_js_1.success)(Object.freeze({
+        evidence,
+        contentDigest: contentDigest.value,
+        recordDigest: recordDigest.value,
+    }));
+}
+function verifyComputedRecord(expected, payload, options) {
+    const computed = computeRecord({
+        contextId: expected.contextId,
+        recordId: expected.recordId,
+        payload,
+        profile: expected.profile,
+        algorithm: expected.algorithm,
+    }, options);
+    if (!computed.ok)
+        return computed;
+    const expectedContent = expected.contentDigest;
+    const expectedRecord = expected.recordDigest;
+    const actualContent = computed.value.evidence.contentDigest;
+    const actualRecord = computed.value.evidence.recordDigest;
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(options.limits);
+    addAll(collector, computed.diagnostics);
+    if (!sameDigest(expectedContent, actualContent, expected.algorithm)) {
+        collector.addCode("CONTENT_DIGEST_MISMATCH", "record", { recordId: expected.recordId });
+    }
+    if (!sameDigest(expectedRecord, actualRecord, expected.algorithm)) {
+        collector.addCode("RECORD_DIGEST_MISMATCH", "record", { recordId: expected.recordId });
+    }
+    if (collector.hasErrors())
+        return (0, operation_result_js_1.failure)(collector.finish());
+    return (0, operation_result_js_1.success)(computed.value.evidence, collector.finish());
+}
+function validateRecordInput(value, limits) {
+    const exact = (0, object_inspection_js_1.inspectExactProperties)(value, [
+        "contextId",
+        "recordId",
+        "payload",
+        "profile",
+        "algorithm",
+    ]);
+    if (exact === undefined)
+        return inputFailure(limits);
+    const [contextIdInput, recordIdInput, payload, profileInput, algorithmInput] = exact;
+    const contextId = (0, identifier_validation_js_1.validateContextId)(contextIdInput);
+    const recordId = (0, identifier_validation_js_1.validateRecordId)(recordIdInput);
+    const profile = validateProfile(profileInput, limits);
+    const algorithm = (0, algorithm_validation_js_1.validateAlgorithmId)(algorithmInput);
+    if (!contextId.ok)
+        return contextId;
+    if (!recordId.ok)
+        return recordId;
+    if (!profile.ok)
+        return profile;
+    if (!algorithm.ok)
+        return algorithm;
+    return (0, operation_result_js_1.success)(Object.freeze({
+        contextId: contextId.value.value,
+        recordId: recordId.value.value,
+        payload,
+        profile: profile.value,
+        algorithm: algorithm.value,
+    }));
+}
+function validateProfile(value, limits) {
+    void limits;
+    const exact = (0, object_inspection_js_1.inspectExactProperties)(value, ["id", "version"]);
+    if (exact === undefined)
+        return inputFailure(limits);
+    const [idInput, versionInput] = exact;
+    const id = (0, identifier_validation_js_1.validateProfileId)(idInput);
+    const version = (0, version_validation_js_1.validateProfileVersion)(versionInput);
+    if (!id.ok)
+        return id;
+    if (!version.ok)
+        return version;
+    return (0, operation_result_js_1.success)(Object.freeze({ id: id.value.value, version: version.value.value }));
+}
+function freezeRecordEvidence(value) {
+    return Object.freeze(value);
+}
+function validateProfileReference(input, options) {
+    return options.profiles.resolveValidated(input.profile);
+}
+function inputPayloadIsBytes(value) {
+    return value instanceof Uint8Array;
+}
+function isBuiltinRawProfile(profile) {
+    return profile.id.value === "dev.noeos.raw-bytes";
+}
+function freezeInputView(value) {
+    return Object.freeze({
+        contextId: value.contextId,
+        recordId: value.recordId,
+        profile: Object.freeze({ ...value.profile }),
+        algorithm: value.algorithm,
+    });
+}
+function sameDigest(expected, actual, algorithm) {
+    const left = hexToDigest(expected, algorithm);
+    const right = hexToDigest(actual, algorithm);
+    return left !== undefined && right !== undefined && (0, digest_validation_js_1.equalDigest)(left, right);
+}
+function hexToDigest(value, algorithm) {
+    const result = (0, digest_validation_js_1.validateDigest)(value, algorithm);
+    return result.ok ? result.value : undefined;
+}
+function addAll(collector, diagnostics) {
+    if (diagnostics === undefined)
+        return;
+    for (const diagnostic of diagnostics)
+        collector.add(diagnostic);
+}
+function inputFailure(limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode("INPUT_TYPE_INVALID", "input");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}