@noeos/verification-engine 0.0.0

package/dist/esm/domain/version.js

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+const profileVersionBrand = Symbol("ProfileVersion");
+export class ProfileVersion {
+    value;
+    [profileVersionBrand] = true;
+    constructor(value) {
+        this.value = value;
+    }
+    static fromValidated(value) {
+        return Object.freeze(new ProfileVersion(value));
+    }
+}

package/dist/esm/evidence/digest-evidence.js

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+import { buildTrustedEvidenceFrame } from "../framing/frame-builders.js";
+import { hashTrustedFrame } from "../hashing/hash-frame.js";
+import { jcsProfile } from "../normalization/jcs-profile.js";
+import { normalizeToBytes } from "../normalization/normalize.js";
+import { parseEvidence } from "./evidence-parser.js";
+export function digestEvidence(value, limits) {
+    const evidence = parseEvidence(value, limits);
+    if (!evidence.ok)
+        return evidence;
+    const normalized = normalizeToBytes(jcsProfile, evidence.value, limits);
+    if (!normalized.ok)
+        return normalized;
+    return hashTrustedFrame(evidence.value.algorithm, buildTrustedEvidenceFrame({
+        algorithm: evidence.value.algorithm,
+        schemaUrn: evidence.value.$schema,
+        evidenceJcsBytes: normalized.value.bytes,
+    }, limits));
+}

package/dist/esm/evidence/evidence-parser.js

@@ -0,0 +1,281 @@
+// SPDX-License-Identifier: Apache-2.0
+import { CHAIN_SUMMARY_EVIDENCE_SCHEMA, LINK_EVIDENCE_SCHEMA, RECORD_EVIDENCE_SCHEMA, } from "../domain/evidence.js";
+import { failure, success } from "../domain/operation-result.js";
+import { validateAlgorithmId } from "../validation/algorithm-validation.js";
+import { DiagnosticCollector } from "../validation/diagnostic-collector.js";
+import { validateDigest } from "../validation/digest-validation.js";
+import { validateContextId, validateRecordId, validateSequenceId, } from "../validation/identifier-validation.js";
+import { parseJsonText } from "../validation/json-text-parser.js";
+import { inspectPlainObject } from "../validation/object-inspection.js";
+import { validatePosition } from "../validation/position-validation.js";
+import { validateProtocolVersion } from "../validation/version-validation.js";
+import { validateProfile } from "../records/record-service.js";
+export function parseEvidence(value, limits) {
+    const entries = inspectPlainObject(value);
+    if (entries === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const schema = new Map(entries).get("$schema");
+    if (schema === RECORD_EVIDENCE_SCHEMA)
+        return parseRecordEvidence(value, limits);
+    if (schema === LINK_EVIDENCE_SCHEMA)
+        return parseLinkEvidence(value, limits);
+    if (schema === CHAIN_SUMMARY_EVIDENCE_SCHEMA)
+        return parseChainSummaryEvidence(value, limits);
+    return evidenceFailure("EVIDENCE_SCHEMA_UNKNOWN", limits);
+}
+export function parseEvidenceText(value, limits) {
+    const parsed = parseJsonText(value, limits);
+    if (!parsed.ok)
+        return parsed;
+    return parseEvidence(parsed.value, limits);
+}
+export function parseRecordEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "recordId",
+        "profile",
+        "algorithm",
+        "normalizedByteLength",
+        "contentDigest",
+        "recordDigest",
+    ]);
+    if (fields?.get("$schema") !== RECORD_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const common = parseRecordFields(fields, limits);
+    if (!common.ok)
+        return common;
+    return success(Object.freeze({ $schema: RECORD_EVIDENCE_SCHEMA, ...common.value }));
+}
+export function parseLinkEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "sequenceId",
+        "position",
+        "recordId",
+        "profile",
+        "algorithm",
+        "normalizedByteLength",
+        "contentDigest",
+        "recordDigest",
+        "previous",
+        "linkDigest",
+    ]);
+    if (fields?.get("$schema") !== LINK_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const common = parseRecordFields(fields, limits);
+    const sequenceId = validateSequenceId(fields.get("sequenceId"));
+    const position = validatePosition(fields.get("position"));
+    if (!common.ok)
+        return common;
+    if (!sequenceId.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if (!position.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const previous = parsePrevious(fields.get("previous"), common.value.algorithm, limits);
+    const linkDigest = validateDigest(fields.get("linkDigest"), common.value.algorithm);
+    if (!previous.ok || !linkDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if ((position.value.value === 0) !== (previous.value.kind === "none")) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    return success(Object.freeze({
+        $schema: LINK_EVIDENCE_SCHEMA,
+        ...common.value,
+        sequenceId: sequenceId.value.value,
+        position: position.value.value,
+        previous: previous.value,
+        linkDigest: linkDigest.value.toHex(),
+    }));
+}
+export function parseChainSummaryEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "sequenceId",
+        "profile",
+        "algorithm",
+        "count",
+        "firstPosition",
+        "lastPosition",
+        "firstLinkDigest",
+        "finalLinkDigest",
+        "boundaries",
+        "status",
+        "diagnostics",
+    ], true);
+    if (fields?.get("$schema") !== CHAIN_SUMMARY_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const protocol = validateProtocolVersion(fields.get("protocolVersion"));
+    const contextId = validateContextId(fields.get("contextId"));
+    const sequenceId = validateSequenceId(fields.get("sequenceId"));
+    const profile = validateProfile(fields.get("profile"), limits);
+    const algorithm = validateAlgorithmId(fields.get("algorithm"));
+    const count = validateNonNegativeSafeInteger(fields.get("count"));
+    const boundaries = parseBoundaries(fields.get("boundaries"));
+    const status = fields.get("status");
+    const diagnostics = parseDiagnosticSummary(fields.get("diagnostics"));
+    if (!protocol.ok ||
+        !contextId.ok ||
+        !sequenceId.ok ||
+        !profile.ok ||
+        !algorithm.ok ||
+        count === undefined ||
+        boundaries === undefined ||
+        !isStatus(status) ||
+        diagnostics === undefined) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    if (count === 0) {
+        if (fields.has("firstPosition") ||
+            fields.has("lastPosition") ||
+            fields.has("firstLinkDigest") ||
+            fields.has("finalLinkDigest"))
+            return evidenceFailure("EVIDENCE_INVALID", limits);
+        return success(Object.freeze({
+            $schema: CHAIN_SUMMARY_EVIDENCE_SCHEMA,
+            protocolVersion: 1,
+            contextId: contextId.value.value,
+            sequenceId: sequenceId.value.value,
+            profile: profile.value,
+            algorithm: algorithm.value,
+            count,
+            boundaries,
+            status,
+            diagnostics,
+        }));
+    }
+    if (!fields.has("firstPosition") ||
+        !fields.has("lastPosition") ||
+        !fields.has("firstLinkDigest") ||
+        !fields.has("finalLinkDigest"))
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const firstPosition = validateNonNegativeSafeInteger(fields.get("firstPosition"));
+    const lastPosition = validateNonNegativeSafeInteger(fields.get("lastPosition"));
+    const firstDigest = validateDigest(fields.get("firstLinkDigest"), algorithm.value);
+    const finalDigest = validateDigest(fields.get("finalLinkDigest"), algorithm.value);
+    if (firstPosition === undefined ||
+        lastPosition === undefined ||
+        firstPosition > lastPosition ||
+        !firstDigest.ok ||
+        !finalDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return success(Object.freeze({
+        $schema: CHAIN_SUMMARY_EVIDENCE_SCHEMA,
+        protocolVersion: 1,
+        contextId: contextId.value.value,
+        sequenceId: sequenceId.value.value,
+        profile: profile.value,
+        algorithm: algorithm.value,
+        count,
+        firstPosition,
+        lastPosition,
+        firstLinkDigest: firstDigest.value.toHex(),
+        finalLinkDigest: finalDigest.value.toHex(),
+        boundaries,
+        status,
+        diagnostics,
+    }));
+}
+function parseRecordFields(fields, limits) {
+    const protocol = validateProtocolVersion(fields.get("protocolVersion"));
+    const contextId = validateContextId(fields.get("contextId"));
+    const recordId = validateRecordId(fields.get("recordId"));
+    const profile = validateProfile(fields.get("profile"), limits);
+    const algorithm = validateAlgorithmId(fields.get("algorithm"));
+    const normalizedByteLength = validateNonNegativeSafeInteger(fields.get("normalizedByteLength"));
+    if (!protocol.ok ||
+        !contextId.ok ||
+        !recordId.ok ||
+        !profile.ok ||
+        !algorithm.ok ||
+        normalizedByteLength === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const contentDigest = validateDigest(fields.get("contentDigest"), algorithm.value);
+    const recordDigest = validateDigest(fields.get("recordDigest"), algorithm.value);
+    if (!contentDigest.ok || !recordDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return success(Object.freeze({
+        protocolVersion: 1,
+        contextId: contextId.value.value,
+        recordId: recordId.value.value,
+        profile: profile.value,
+        algorithm: algorithm.value,
+        normalizedByteLength,
+        contentDigest: contentDigest.value.toHex(),
+        recordDigest: recordDigest.value.toHex(),
+    }));
+}
+function parsePrevious(value, algorithm, limits) {
+    const fields = strictFields(value, ["kind", "value"], true);
+    if (fields === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if (fields.get("kind") === "none" && fields.size === 1)
+        return success(Object.freeze({ kind: "none" }));
+    if (fields.get("kind") !== "digest" || fields.size !== 2)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const digest = validateDigest(fields.get("value"), algorithm);
+    if (!digest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return success(Object.freeze({ kind: "digest", value: digest.value.toHex() }));
+}
+function parseBoundaries(value) {
+    const fields = strictFields(value, ["start", "end"]);
+    if (fields === undefined)
+        return undefined;
+    const start = fields.get("start");
+    const end = fields.get("end");
+    if (!isBoundary(start) || !isBoundary(end))
+        return undefined;
+    return Object.freeze({ start, end });
+}
+function parseDiagnosticSummary(value) {
+    const fields = strictFields(value, ["errors", "warnings", "info", "truncated"]);
+    if (fields === undefined)
+        return undefined;
+    const errors = validateNonNegativeSafeInteger(fields.get("errors"));
+    const warnings = validateNonNegativeSafeInteger(fields.get("warnings"));
+    const info = validateNonNegativeSafeInteger(fields.get("info"));
+    const truncated = fields.get("truncated");
+    if (errors === undefined ||
+        warnings === undefined ||
+        info === undefined ||
+        typeof truncated !== "boolean")
+        return undefined;
+    return Object.freeze({ errors, warnings, info, truncated });
+}
+function strictFields(value, keys, optional = false) {
+    const entries = inspectPlainObject(value);
+    if (entries === undefined)
+        return undefined;
+    const fields = new Map(entries);
+    for (const key of fields.keys())
+        if (!keys.includes(key))
+            return undefined;
+    if (!optional && fields.size !== keys.length)
+        return undefined;
+    if (optional && fields.size > keys.length)
+        return undefined;
+    return fields;
+}
+function validateNonNegativeSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function isBoundary(value) {
+    return value === "verified" || value === "unverified" || value === "not-applicable";
+}
+function isStatus(value) {
+    return (value === "valid" || value === "invalid" || value === "indeterminate" || value === "aborted");
+}
+function evidenceFailure(code, limits) {
+    const collector = new DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return failure(collector.finish());
+}

package/dist/esm/framing/frame-builders.js

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+import { digestBytesForTrustedFrame } from "../domain/digest.js";
+import { encodeFrame, encodeTrustedFrame } from "./frame-encoder.js";
+export function buildContentFrame(input, limits) {
+    const frame = {
+        kind: "content",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.profileId },
+            { tag: 3, type: "utf8", value: input.profileVersion },
+            { tag: 4, type: "bytes", value: input.normalizedBytes },
+        ],
+    };
+    return encodeFrame(frame, limits);
+}
+export function buildRecordFrame(input, limits) {
+    const frame = {
+        kind: "record",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.recordId },
+            { tag: 4, type: "utf8", value: input.profileId },
+            { tag: 5, type: "utf8", value: input.profileVersion },
+            { tag: 6, type: "uint64", value: input.normalizedByteLength },
+            { tag: 7, type: "bytes", value: input.contentDigest.toBytes() },
+        ],
+    };
+    return encodeFrame(frame, limits);
+}
+export function buildLinkFrame(input, limits) {
+    const previous = input.previousLinkDigest;
+    const frame = {
+        kind: "link",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.sequenceId },
+            { tag: 4, type: "uint64", value: input.position },
+            { tag: 5, type: "utf8", value: input.recordId },
+            { tag: 6, type: "bytes", value: input.recordDigest.toBytes() },
+            previous === undefined
+                ? { tag: 7, type: "none" }
+                : { tag: 7, type: "bytes", value: previous.toBytes() },
+        ],
+    };
+    return encodeFrame(frame, limits);
+}
+export function buildEvidenceFrame(input, limits) {
+    const frame = {
+        kind: "evidence",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.schemaUrn },
+            { tag: 3, type: "bytes", value: input.evidenceJcsBytes },
+        ],
+    };
+    return encodeFrame(frame, limits);
+}
+export function buildTrustedContentFrame(input, limits) {
+    return encodeTrustedFrame({
+        kind: "content",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.profileId },
+            { tag: 3, type: "utf8", value: input.profileVersion },
+            { tag: 4, type: "bytes", value: input.normalizedBytes },
+        ],
+    }, limits);
+}
+export function buildTrustedRecordFrame(input, limits) {
+    return encodeTrustedFrame({
+        kind: "record",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.recordId },
+            { tag: 4, type: "utf8", value: input.profileId },
+            { tag: 5, type: "utf8", value: input.profileVersion },
+            { tag: 6, type: "uint64", value: input.normalizedByteLength },
+            { tag: 7, type: "bytes", value: digestBytesForTrustedFrame(input.contentDigest) },
+        ],
+    }, limits);
+}
+export function buildTrustedLinkFrame(input, limits) {
+    return encodeTrustedFrame({
+        kind: "link",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.sequenceId },
+            { tag: 4, type: "uint64", value: input.position },
+            { tag: 5, type: "utf8", value: input.recordId },
+            { tag: 6, type: "bytes", value: digestBytesForTrustedFrame(input.recordDigest) },
+            input.previousLinkDigest === undefined
+                ? { tag: 7, type: "none" }
+                : {
+                    tag: 7,
+                    type: "bytes",
+                    value: digestBytesForTrustedFrame(input.previousLinkDigest),
+                },
+        ],
+    }, limits);
+}
+export function buildTrustedEvidenceFrame(input, limits) {
+    return encodeTrustedFrame({
+        kind: "evidence",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.schemaUrn },
+            { tag: 3, type: "bytes", value: input.evidenceJcsBytes },
+        ],
+    }, limits);
+}

package/dist/esm/framing/frame-encoder.js

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: Apache-2.0
+import { types } from "node:util";
+import { failure, success } from "../domain/operation-result.js";
+import { DiagnosticCollector } from "../validation/diagnostic-collector.js";
+import { encodeUtf8 } from "../validation/utf8-validation.js";
+import { inspectPlainObject, isPlainObject } from "../validation/object-inspection.js";
+import { ByteArraySink } from "../normalization/byte-sink.js";
+const MAGIC = "NOEOSVE1";
+const PROTOCOL_VERSION = 1;
+const KIND_CODES = Object.freeze({
+    content: 0x01,
+    record: 0x02,
+    link: 0x03,
+    evidence: 0x04,
+});
+const MAGIC_BYTES = new TextEncoder().encode(MAGIC);
+const UTF8_ENCODER = new TextEncoder();
+const SHA256_BYTES = UTF8_ENCODER.encode("sha-256");
+const SHA384_BYTES = UTF8_ENCODER.encode("sha-384");
+const SHA512_BYTES = UTF8_ENCODER.encode("sha-512");
+const RAW_PROFILE_BYTES = UTF8_ENCODER.encode("dev.noeos.raw-bytes");
+const JCS_PROFILE_BYTES = UTF8_ENCODER.encode("dev.noeos.jcs");
+const PROFILE_VERSION_BYTES = UTF8_ENCODER.encode("1.0.0");
+export function encodeFrame(input, limits) {
+    const frameInput = validateFrameInput(input);
+    if (!frameInput.ok)
+        return frameFailure(frameInput.code, limits);
+    const kindCode = KIND_CODES[frameInput.value.kind];
+    if (frameInput.value.fields.length > 0xffff)
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    const encodedFields = [];
+    let previousTag = 0;
+    for (const field of frameInput.value.fields) {
+        if (!Number.isSafeInteger(field.tag) || field.tag < 1 || field.tag > 0xffff) {
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        }
+        if (field.tag === previousTag)
+            return frameFailure("FRAME_FIELD_DUPLICATE", limits);
+        if (field.tag < previousTag)
+            return frameFailure("FRAME_FIELD_ORDER_INVALID", limits);
+        previousTag = field.tag;
+        const encoded = encodeField(field, limits);
+        if (!encoded.ok)
+            return encoded;
+        encodedFields.push(encoded.value);
+    }
+    const sink = new ByteArraySink(limits.maxPayloadBytes);
+    try {
+        sink.write(new TextEncoder().encode(MAGIC));
+        sink.write(Uint8Array.of(kindCode, 0, PROTOCOL_VERSION));
+        sink.write(uint16Bytes(encodedFields.length));
+        for (const field of encodedFields) {
+            sink.write(uint16Bytes(field.tag));
+            sink.write(Uint8Array.of(field.typeCode));
+            sink.write(uint64Bytes(field.value.length));
+            sink.write(field.value);
+        }
+        return { ok: true, value: sink.toBytes(), diagnostics: Object.freeze([]) };
+    }
+    catch {
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    }
+}
+/** Internal fast path. Callers must have completed positive validation. */
+export function encodeTrustedFrame(input, limits) {
+    const kindCode = KIND_CODES[input.kind];
+    const encodedFields = [];
+    let total = MAGIC_BYTES.length + 3 + 2;
+    try {
+        for (const field of input.fields) {
+            const encoded = encodeTrustedField(field, limits);
+            total += 2 + 1 + 8 + encoded.length;
+            encodedFields.push(encoded);
+        }
+        if (input.fields.length > 0xffff || total > limits.maxPayloadBytes) {
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        }
+        const output = new Uint8Array(total);
+        let offset = 0;
+        output.set(MAGIC_BYTES, offset);
+        offset += MAGIC_BYTES.length;
+        output[offset++] = kindCode;
+        output[offset++] = 0;
+        output[offset++] = PROTOCOL_VERSION;
+        output[offset++] = (encodedFields.length >>> 8) & 0xff;
+        output[offset++] = encodedFields.length & 0xff;
+        for (const field of encodedFields) {
+            output[offset++] = (field.tag >>> 8) & 0xff;
+            output[offset++] = field.tag & 0xff;
+            output[offset++] = field.typeCode;
+            writeUint64(output, offset, field.length);
+            offset += 8;
+            if (field.value instanceof Uint8Array) {
+                output.set(field.value, offset);
+                offset += field.length;
+            }
+            else {
+                writeUint64(output, offset, field.value);
+                offset += 8;
+            }
+        }
+        return success(output);
+    }
+    catch {
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    }
+}
+function validateFrameInput(input) {
+    if (!isPlainObject(input) || !isFrameKind(input["kind"]))
+        return { ok: false, code: "FRAME_KIND_UNKNOWN" };
+    if (!Array.isArray(input["fields"]) || types.isProxy(input["fields"]))
+        return { ok: false, code: "FRAME_LENGTH_INVALID" };
+    const fields = [];
+    for (const field of input["fields"]) {
+        const validated = validateFrameField(field);
+        if (validated === undefined)
+            return { ok: false, code: "FRAME_FIELD_TYPE_INVALID" };
+        fields.push(validated);
+    }
+    return { ok: true, value: { kind: input["kind"], fields } };
+}
+function validateFrameField(input) {
+    if (!isPlainObject(input))
+        return undefined;
+    const entries = inspectPlainObject(input);
+    if (entries === undefined)
+        return undefined;
+    const properties = new Map(entries);
+    const tag = properties.get("tag");
+    const type = properties.get("type");
+    if (typeof tag !== "number" || typeof type !== "string")
+        return undefined;
+    if (type === "bytes") {
+        const value = properties.get("value");
+        if (types.isProxy(value) || !(value instanceof Uint8Array))
+            return undefined;
+        return { tag, type, value };
+    }
+    if (type === "utf8") {
+        const value = properties.get("value");
+        if (typeof value !== "string")
+            return undefined;
+        return { tag, type, value };
+    }
+    if (type === "uint64") {
+        const value = properties.get("value");
+        if (typeof value !== "number")
+            return undefined;
+        return { tag, type, value };
+    }
+    if (type === "none" && !properties.has("value"))
+        return { tag, type };
+    return undefined;
+}
+function isFrameKind(value) {
+    return value === "content" || value === "record" || value === "link" || value === "evidence";
+}
+function encodeField(field, limits) {
+    if (field.type === "bytes") {
+        return successField(field.tag, 0x01, field.value);
+    }
+    if (field.type === "utf8") {
+        const encoded = encodeUtf8(field.value, limits.maxPayloadBytes);
+        if (!encoded.ok)
+            return encoded;
+        return successField(field.tag, 0x02, encoded.value);
+    }
+    if (field.type === "uint64") {
+        if (!Number.isSafeInteger(field.value) || field.value < 0)
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        return successField(field.tag, 0x03, uint64Bytes(field.value));
+    }
+    return successField(field.tag, 0x04, new Uint8Array(0));
+}
+function encodeTrustedField(field, limits) {
+    if (field.type === "bytes") {
+        return { tag: field.tag, typeCode: 0x01, value: field.value, length: field.value.length };
+    }
+    if (field.type === "utf8") {
+        const value = trustedUtf8(field.value);
+        if (value.length > limits.maxPayloadBytes)
+            throw new RangeError("frame field too large");
+        return { tag: field.tag, typeCode: 0x02, value, length: value.length };
+    }
+    if (field.type === "uint64")
+        return { tag: field.tag, typeCode: 0x03, value: field.value, length: 8 };
+    return { tag: field.tag, typeCode: 0x04, value: 0, length: 0 };
+}
+function trustedUtf8(value) {
+    if (value === "sha-256")
+        return SHA256_BYTES;
+    if (value === "sha-384")
+        return SHA384_BYTES;
+    if (value === "sha-512")
+        return SHA512_BYTES;
+    if (value === "dev.noeos.raw-bytes")
+        return RAW_PROFILE_BYTES;
+    if (value === "dev.noeos.jcs")
+        return JCS_PROFILE_BYTES;
+    if (value === "1.0.0")
+        return PROFILE_VERSION_BYTES;
+    return UTF8_ENCODER.encode(value);
+}
+function successField(tag, typeCode, value) {
+    return {
+        ok: true,
+        value: Object.freeze({ tag, typeCode, value: Uint8Array.from(value) }),
+        diagnostics: Object.freeze([]),
+    };
+}
+function uint16Bytes(value) {
+    return Uint8Array.of((value >>> 8) & 0xff, value & 0xff);
+}
+function uint64Bytes(value) {
+    const output = new Uint8Array(8);
+    let remaining = BigInt(value);
+    for (let index = 7; index >= 0; index -= 1) {
+        output[index] = Number(remaining & 0xffn);
+        remaining >>= 8n;
+    }
+    return output;
+}
+function writeUint64(output, offset, value) {
+    let remaining = BigInt(value);
+    for (let index = offset + 7; index >= offset; index -= 1) {
+        output[index] = Number(remaining & 0xffn);
+        remaining >>= 8n;
+    }
+}
+function frameFailure(code, limits) {
+    const collector = new DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return failure(collector.finish());
+}