@noeos/verification-engine 0.0.0

package/dist/cjs/validation/version-validation.js

@@ -0,0 +1,31 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProfileVersion = validateProfileVersion;
+exports.validateProtocolVersion = validateProtocolVersion;
+exports.validateProfileReference = validateProfileReference;
+const identifier_validation_js_1 = require("./identifier-validation.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("./result-helpers.js");
+const semverPattern = /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-(?:0|[1-9A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+function validateProfileVersion(value) {
+    if (typeof value !== "string" || value.length > 256 || !semverPattern.test(value)) {
+        return (0, result_helpers_js_1.failureWithCode)("VERSION_INVALID", "input");
+    }
+    return (0, operation_result_js_1.success)(version_js_1.ProfileVersion.fromValidated(value));
+}
+function validateProtocolVersion(value) {
+    if (value !== 1)
+        return (0, result_helpers_js_1.failureWithCode)("VERSION_INVALID", "input");
+    return (0, operation_result_js_1.success)(1);
+}
+function validateProfileReference(id, version) {
+    const idResult = (0, identifier_validation_js_1.validateProfileId)(id);
+    if (!idResult.ok)
+        return idResult;
+    const versionResult = validateProfileVersion(version);
+    if (!versionResult.ok)
+        return versionResult;
+    return (0, operation_result_js_1.success)(Object.freeze({ id: idResult.value, version: versionResult.value }));
+}

package/dist/cjs/vectors.js

@@ -0,0 +1,6 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VECTOR_SET = void 0;
+var vector_assets_js_1 = require("./contracts/vector-assets.js");
+Object.defineProperty(exports, "VECTOR_SET", { enumerable: true, get: function () { return vector_assets_js_1.VECTOR_SET; } });

package/dist/esm/api/engine.js

@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: Apache-2.0
+import { ProfileId } from "../domain/identifiers.js";
+import { ProfileVersion } from "../domain/version.js";
+import { DEFAULT_LIMITS } from "../domain/limits.js";
+import { ProfileRegistry } from "../normalization/profile-registry.js";
+import { RuleSet } from "../rules/rule-set.js";
+import { validateLimits } from "../validation/limit-validation.js";
+import { validateProfileId } from "../validation/identifier-validation.js";
+import { validateProfileVersion } from "../validation/version-validation.js";
+import { hashRecord, verifyComputedRecord, } from "../records/record-service.js";
+import { ChainBuilder as InternalChainBuilder } from "../chains/chain-builder.js";
+import { verifyChain, verifyChainStream } from "../chains/verify-chain.js";
+import { digestEvidence } from "../evidence/digest-evidence.js";
+import { parseRecordEvidence } from "../evidence/evidence-parser.js";
+/** @public */
+export function createEngine(options = {}) {
+    const limits = resolveLimits(options.limits);
+    const additionalProfiles = (options.profiles ?? []).map((profile) => adaptProfile(profile));
+    let profiles;
+    try {
+        profiles = new ProfileRegistry(additionalProfiles);
+    }
+    catch {
+        throw new EngineConfigurationError("PROFILE_VERSION_CONFLICT");
+    }
+    const rulesResult = RuleSet.create(options.rules, limits);
+    if (!rulesResult.ok)
+        throw new EngineConfigurationError("RULE_VERSION_CONFLICT");
+    const defaultPolicy = options.duplicatePolicy;
+    const observer = options.onEvent;
+    if (observer !== undefined && typeof observer !== "function") {
+        throw new EngineConfigurationError("INPUT_TYPE_INVALID");
+    }
+    return Object.freeze(new EngineImpl(limits, profiles, rulesResult.value, defaultPolicy, observer));
+}
+/** @public */
+export class EngineConfigurationError extends TypeError {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "EngineConfigurationError";
+    }
+}
+class EngineImpl {
+    limits;
+    profiles;
+    rules;
+    defaultPolicy;
+    observer;
+    recordServiceOptions;
+    constructor(limits, profiles, rules, defaultPolicy, observer) {
+        this.limits = limits;
+        this.profiles = profiles;
+        this.rules = rules;
+        this.defaultPolicy = defaultPolicy;
+        this.observer = observer;
+        this.recordServiceOptions = Object.freeze({ limits, profiles, rules });
+    }
+    hashRecord(input) {
+        if (this.observer !== undefined) {
+            this.emit({
+                name: "operation.started",
+                operation: "hash-record",
+                recordsSeen: 0,
+                bytesNormalized: 0,
+            });
+        }
+        const result = hashRecord(input, this.recordServiceOptions);
+        this.emitResult(result, "hash-record");
+        return result;
+    }
+    verifyRecord(input) {
+        const evidence = parseRecordEvidenceInput(input.evidence, this.limits);
+        if (!evidence.ok)
+            return invalidRecordResult(evidence.diagnostics);
+        const result = verifyComputedRecord(evidence.value, input.payload, this.recordServiceOptions);
+        const diagnostics = result.diagnostics;
+        const status = result.ok ? "valid" : "invalid";
+        return Object.freeze({
+            status,
+            diagnostics,
+            evidence: result.ok ? result.value : undefined,
+            stats: Object.freeze({
+                recordsSeen: 1,
+                recordsVerified: result.ok ? 1 : 0,
+                linksVerified: 0,
+                bytesNormalized: result.ok ? result.value.normalizedByteLength : 0,
+                errors: diagnostics.filter(({ severity }) => severity === "error").length,
+                warnings: diagnostics.filter(({ severity }) => severity === "warning").length,
+                info: diagnostics.filter(({ severity }) => severity === "info").length,
+            }),
+            boundaries: Object.freeze({
+                start: "not-applicable",
+                end: "not-applicable",
+            }),
+            verificationMode: "internal",
+        });
+    }
+    createChain(config) {
+        const internal = InternalChainBuilder.create({
+            ...config,
+            ...(config.duplicatePolicy === undefined && this.defaultPolicy !== undefined
+                ? { duplicatePolicy: this.defaultPolicy }
+                : {}),
+            rules: this.rulesAsUnknown(),
+        }, { limits: this.limits, profiles: this.profiles });
+        if (!internal.ok)
+            throw new EngineConfigurationError(firstCode(internal.diagnostics));
+        return new PublicChainBuilder(internal.value);
+    }
+    verifyChain(input) {
+        return verifyChain({
+            ...input,
+            ...(input.duplicatePolicy === undefined && this.defaultPolicy !== undefined
+                ? { duplicatePolicy: this.defaultPolicy }
+                : {}),
+            rules: this.rulesAsUnknown(),
+        }, { limits: this.limits, profiles: this.profiles });
+    }
+    async verifyStream(input) {
+        const { signal, ...streamConfig } = input;
+        return verifyChainStream({
+            ...streamConfig,
+            ...(streamConfig.duplicatePolicy === undefined && this.defaultPolicy !== undefined
+                ? { duplicatePolicy: this.defaultPolicy }
+                : {}),
+            rules: this.rulesAsUnknown(),
+        }, { limits: this.limits, profiles: this.profiles }, signal);
+    }
+    digestEvidence(input) {
+        return digestEvidence(input, this.limits);
+    }
+    rulesAsUnknown() {
+        return this.rules.toArray();
+    }
+    emit(event) {
+        if (this.observer === undefined)
+            return;
+        try {
+            this.observer(Object.freeze({ ...event }));
+        }
+        catch {
+            // Observer failures are intentionally isolated from deterministic operation results.
+        }
+    }
+    emitResult(result, operation) {
+        if (this.observer === undefined)
+            return;
+        if (result.ok)
+            this.emit({ name: "operation.completed", operation, recordsSeen: 1, bytesNormalized: 0 });
+        for (const diagnostic of result.diagnostics) {
+            this.emit({
+                name: "diagnostic.emitted",
+                operation,
+                recordsSeen: 0,
+                bytesNormalized: 0,
+                code: diagnostic.code,
+            });
+        }
+    }
+}
+class PublicChainBuilder {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    append(input) {
+        return this.inner.append(input);
+    }
+    appendAll(input) {
+        return this.inner.appendAll(input);
+    }
+    appendStream(input, options) {
+        return this.inner.appendStream(input, options);
+    }
+    snapshot() {
+        return this.inner.snapshot();
+    }
+    finalize() {
+        return this.inner.finalize();
+    }
+    abort(reason) {
+        this.inner.abort(reason);
+    }
+}
+function adaptProfile(profile) {
+    if (!isRecord(profile) ||
+        typeof profile.validate !== "function" ||
+        typeof profile.normalize !== "function") {
+        throw new EngineConfigurationError("INPUT_TYPE_INVALID");
+    }
+    const id = validateProfileId(profile.id);
+    const version = validateProfileVersion(profile.version);
+    if (!id.ok)
+        throw new EngineConfigurationError(firstCode(id.diagnostics));
+    if (!version.ok)
+        throw new EngineConfigurationError(firstCode(version.diagnostics));
+    validateManifest(profile, id.value.value, version.value.value);
+    const adapted = {
+        id: ProfileId.fromValidated(id.value.value),
+        version: ProfileVersion.fromValidated(version.value.value),
+        inputKind: profile.inputKind,
+        validate(input, limits) {
+            return profile.validate(input, limits);
+        },
+        normalize(input, sink, limits) {
+            return profile.normalize(input, sink, limits);
+        },
+    };
+    return Object.freeze(adapted);
+}
+function validateManifest(profile, id, version) {
+    if (!isRecord(profile.manifest))
+        throw new EngineConfigurationError("INPUT_TYPE_INVALID");
+    const manifest = profile.manifest;
+    if (Object.keys(manifest).length !== 5 ||
+        manifest.name !== id ||
+        manifest.version !== version ||
+        typeof manifest.vectorSha256 !== "string" ||
+        !/^[0-9a-f]{64}$/u.test(manifest.vectorSha256) ||
+        typeof manifest.license !== "string" ||
+        manifest.license.length === 0) {
+        throw new EngineConfigurationError("INPUT_TYPE_INVALID");
+    }
+    const limits = validateLimits(manifest.limits);
+    if (!limits.ok)
+        throw new EngineConfigurationError(firstCode(limits.diagnostics));
+}
+function resolveLimits(value) {
+    const candidate = value === undefined ? DEFAULT_LIMITS : { ...DEFAULT_LIMITS, ...value };
+    const result = validateLimits(candidate);
+    if (!result.ok)
+        throw new EngineConfigurationError(firstCode(result.diagnostics));
+    return result.value;
+}
+function parseRecordEvidenceInput(value, limits) {
+    return parseRecordEvidence(value, limits);
+}
+function invalidRecordResult(diagnostics) {
+    return Object.freeze({
+        status: "invalid",
+        diagnostics,
+        evidence: undefined,
+        stats: Object.freeze({
+            recordsSeen: 0,
+            recordsVerified: 0,
+            linksVerified: 0,
+            bytesNormalized: 0,
+            errors: diagnostics.length,
+            warnings: 0,
+            info: 0,
+        }),
+        boundaries: Object.freeze({ start: "not-applicable", end: "not-applicable" }),
+        verificationMode: "internal",
+    });
+}
+function firstCode(diagnostics) {
+    const code = diagnostics[0]?.code;
+    if (code === "INPUT_LIMIT_EXCEEDED" || code === "RULE_VERSION_CONFLICT")
+        return code;
+    return "INPUT_TYPE_INVALID";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/esm/api/types.js

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
+import { CHAIN_SUMMARY_EVIDENCE_SCHEMA, LINK_EVIDENCE_SCHEMA, RECORD_EVIDENCE_SCHEMA, } from "../domain/evidence.js";
+import { DIAGNOSTIC_SCHEMA } from "../domain/diagnostic.js";
+export { CHAIN_SUMMARY_EVIDENCE_SCHEMA, DIAGNOSTIC_SCHEMA, LINK_EVIDENCE_SCHEMA, RECORD_EVIDENCE_SCHEMA, };