@noeos/verification-engine 0.0.0

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

@@ -0,0 +1,238 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeFrame = encodeFrame;
+exports.encodeTrustedFrame = encodeTrustedFrame;
+const node_util_1 = require("node:util");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const utf8_validation_js_1 = require("../validation/utf8-validation.js");
+const object_inspection_js_1 = require("../validation/object-inspection.js");
+const byte_sink_js_1 = require("../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");
+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 byte_sink_js_1.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. */
+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 (0, operation_result_js_1.success)(output);
+    }
+    catch {
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    }
+}
+function validateFrameInput(input) {
+    if (!(0, object_inspection_js_1.isPlainObject)(input) || !isFrameKind(input["kind"]))
+        return { ok: false, code: "FRAME_KIND_UNKNOWN" };
+    if (!Array.isArray(input["fields"]) || node_util_1.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 (!(0, object_inspection_js_1.isPlainObject)(input))
+        return undefined;
+    const entries = (0, object_inspection_js_1.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 (node_util_1.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 = (0, utf8_validation_js_1.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 diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}

package/dist/cjs/framing/frame-parser.js

@@ -0,0 +1,173 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrame = parseFrame;
+const node_util_1 = require("node:util");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const utf8_validation_js_1 = require("../validation/utf8-validation.js");
+const MAGIC = "NOEOSVE1";
+const HEADER_LENGTH = 13;
+const KIND_NAMES = Object.freeze({
+    1: "content",
+    2: "record",
+    3: "link",
+    4: "evidence",
+});
+const TYPE_NAMES = Object.freeze({
+    1: "bytes",
+    2: "utf8",
+    3: "uint64",
+    4: "none",
+});
+function parseFrame(input, limits) {
+    if (node_util_1.types.isProxy(input) || !(input instanceof Uint8Array))
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    if (input.length > limits.maxPayloadBytes)
+        return frameFailure("INPUT_LIMIT_EXCEEDED", limits);
+    if (input.length < HEADER_LENGTH)
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+    for (let index = 0; index < MAGIC.length; index += 1) {
+        if (view.getUint8(index) !== MAGIC.charCodeAt(index))
+            return frameFailure("FRAME_MAGIC_INVALID", limits);
+    }
+    const kind = KIND_NAMES[view.getUint8(8)];
+    if (kind === undefined)
+        return frameFailure("FRAME_KIND_UNKNOWN", limits);
+    if (view.getUint8(9) !== 0 || view.getUint8(10) !== 1)
+        return frameFailure("FRAME_VERSION_UNSUPPORTED", limits);
+    const fieldCount = view.getUint16(11);
+    let offset = HEADER_LENGTH;
+    let previousTag = 0;
+    const fields = [];
+    for (let index = 0; index < fieldCount; index += 1) {
+        if (offset + 11 > input.length)
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        const tag = view.getUint16(offset);
+        offset += 2;
+        const expected = expectedField(kind, tag);
+        if (tag === 0 || expected === undefined)
+            return frameFailure("FRAME_FIELD_UNKNOWN", limits);
+        if (tag === previousTag)
+            return frameFailure("FRAME_FIELD_DUPLICATE", limits);
+        if (tag < previousTag)
+            return frameFailure("FRAME_FIELD_ORDER_INVALID", limits);
+        previousTag = tag;
+        const typeCode = view.getUint8(offset);
+        offset += 1;
+        const type = TYPE_NAMES[typeCode];
+        if (type === undefined)
+            return frameFailure("FRAME_FIELD_TYPE_INVALID", limits);
+        const length = readUint64(view, offset);
+        if (length === undefined)
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        offset += 8;
+        if (length > input.length - offset)
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        if (!expected.types.includes(type))
+            return frameFailure("FRAME_FIELD_TYPE_INVALID", limits);
+        const value = readValue(tag, type, input.subarray(offset, offset + length), limits);
+        if (!value.ok)
+            return value;
+        fields.push(value.value);
+        offset += length;
+    }
+    if (offset !== input.length)
+        return frameFailure("FRAME_TRAILING_DATA", limits);
+    const expectedFields = expectedFieldsFor(kind);
+    if (fields.length !== expectedFields.length) {
+        return frameFailure("FRAME_FIELD_MISSING", limits);
+    }
+    return {
+        ok: true,
+        value: Object.freeze({ kind, protocolVersion: 1, fields: Object.freeze(fields) }),
+        diagnostics: Object.freeze([]),
+    };
+}
+function expectedFieldsFor(kind) {
+    const text = ["utf8"];
+    const bytes = ["bytes"];
+    const uint64 = ["uint64"];
+    if (kind === "content")
+        return [
+            { tag: 1, types: text },
+            { tag: 2, types: text },
+            { tag: 3, types: text },
+            { tag: 4, types: bytes },
+        ];
+    if (kind === "record")
+        return [
+            { tag: 1, types: text },
+            { tag: 2, types: text },
+            { tag: 3, types: text },
+            { tag: 4, types: text },
+            { tag: 5, types: text },
+            { tag: 6, types: uint64 },
+            { tag: 7, types: bytes },
+        ];
+    if (kind === "link")
+        return [
+            { tag: 1, types: text },
+            { tag: 2, types: text },
+            { tag: 3, types: text },
+            { tag: 4, types: uint64 },
+            { tag: 5, types: text },
+            { tag: 6, types: bytes },
+            { tag: 7, types: ["none", "bytes"] },
+        ];
+    return [
+        { tag: 1, types: text },
+        { tag: 2, types: text },
+        { tag: 3, types: bytes },
+    ];
+}
+function expectedField(kind, tag) {
+    return expectedFieldsFor(kind).find((field) => field.tag === tag);
+}
+function readValue(tag, type, value, limits) {
+    if (type === "none") {
+        if (value.length !== 0)
+            return frameFailure("FRAME_LENGTH_INVALID", limits);
+        return { ok: true, value: { tag, type: "none" }, diagnostics: Object.freeze([]) };
+    }
+    if (type === "bytes")
+        return {
+            ok: true,
+            value: { tag, type: "bytes", value: Uint8Array.from(value) },
+            diagnostics: Object.freeze([]),
+        };
+    if (type === "utf8") {
+        const decoded = (0, utf8_validation_js_1.decodeUtf8)(value);
+        if (!decoded.ok)
+            return frameFailure("UTF8_INVALID", limits);
+        return {
+            ok: true,
+            value: { tag, type: "utf8", value: decoded.value },
+            diagnostics: Object.freeze([]),
+        };
+    }
+    if (value.length !== 8)
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    const number = readUint64(new DataView(value.buffer, value.byteOffset, value.byteLength), 0);
+    if (number === undefined)
+        return frameFailure("FRAME_LENGTH_INVALID", limits);
+    return {
+        ok: true,
+        value: { tag, type: "uint64", value: number },
+        diagnostics: Object.freeze([]),
+    };
+}
+function readUint64(view, offset) {
+    let value = 0n;
+    for (let index = 0; index < 8; index += 1)
+        value = (value << 8n) | BigInt(view.getUint8(offset + index));
+    if (value > BigInt(Number.MAX_SAFE_INTEGER))
+        return undefined;
+    return Number(value);
+}
+function frameFailure(code, limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}

package/dist/cjs/framing/frame-types.js

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

package/dist/cjs/hashing/hash-adapter.js

@@ -0,0 +1,90 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHashSink = createHashSink;
+exports.hashBytes = hashBytes;
+exports.hashValidatedBytes = hashValidatedBytes;
+exports.hashChunks = hashChunks;
+const node_crypto_1 = require("node:crypto");
+const node_assert_1 = require("node:assert");
+const node_util_1 = require("node:util");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const digest_validation_js_1 = require("../validation/digest-validation.js");
+const algorithm_validation_js_1 = require("../validation/algorithm-validation.js");
+const digest_js_1 = require("../domain/digest.js");
+const NODE_ALGORITHMS = Object.freeze({
+    "sha-256": "sha256",
+    "sha-384": "sha384",
+    "sha-512": "sha512",
+});
+function createHashSink(algorithm, limits) {
+    void limits;
+    const validated = (0, algorithm_validation_js_1.validateAlgorithmId)(algorithm);
+    if (!validated.ok)
+        return validated;
+    return (0, operation_result_js_1.success)(new NodeHashSink(validated.value));
+}
+function hashBytes(algorithm, input, limits) {
+    const sinkResult = createHashSink(algorithm, limits);
+    if (!sinkResult.ok)
+        return sinkResult;
+    if (node_util_1.types.isProxy(input) || !(input instanceof Uint8Array))
+        return hashFailure("INPUT_TYPE_INVALID", limits);
+    if (input.length > limits.maxPayloadBytes)
+        return hashFailure("INPUT_LIMIT_EXCEEDED", limits);
+    sinkResult.value.update(input);
+    return (0, operation_result_js_1.success)(sinkResult.value.digest());
+}
+function hashValidatedBytes(algorithm, input) {
+    const sink = new NodeHashSink(algorithm);
+    sink.update(input);
+    return (0, operation_result_js_1.success)(sink.digest());
+}
+function hashChunks(algorithm, chunks, limits) {
+    const sinkResult = createHashSink(algorithm, limits);
+    if (!sinkResult.ok)
+        return sinkResult;
+    let total = 0;
+    try {
+        for (const chunk of chunks) {
+            if (node_util_1.types.isProxy(chunk) || !(chunk instanceof Uint8Array))
+                return hashFailure("INPUT_TYPE_INVALID", limits);
+            if (chunk.length > limits.maxPayloadBytes - total)
+                return hashFailure("INPUT_LIMIT_EXCEEDED", limits);
+            total += chunk.length;
+            sinkResult.value.update(chunk);
+        }
+        return (0, operation_result_js_1.success)(sinkResult.value.digest());
+    }
+    catch {
+        return hashFailure("NORMALIZATION_FAILED", limits);
+    }
+}
+class NodeHashSink {
+    algorithm;
+    hash;
+    finalized = false;
+    constructor(algorithm) {
+        this.algorithm = algorithm;
+        this.hash = (0, node_crypto_1.createHash)(NODE_ALGORITHMS[algorithm]);
+    }
+    update(value) {
+        if (this.finalized)
+            throw new Error("hash already finalized");
+        this.hash.update(value);
+    }
+    digest() {
+        if (this.finalized)
+            throw new Error("hash already finalized");
+        this.finalized = true;
+        const bytes = this.hash.digest();
+        node_assert_1.strict.equal(bytes.length, (0, digest_validation_js_1.digestLength)(this.algorithm), "unexpected digest length");
+        return digest_js_1.Digest.fromValidated(this.algorithm, bytes);
+    }
+}
+function hashFailure(code, limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}

package/dist/cjs/hashing/hash-frame.js

@@ -0,0 +1,16 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashFrame = hashFrame;
+exports.hashTrustedFrame = hashTrustedFrame;
+const hash_adapter_js_1 = require("./hash-adapter.js");
+function hashFrame(algorithm, frame, limits) {
+    if (!frame.ok)
+        return frame;
+    return (0, hash_adapter_js_1.hashBytes)(algorithm, frame.value, limits);
+}
+function hashTrustedFrame(algorithm, frame) {
+    if (!frame.ok)
+        return frame;
+    return (0, hash_adapter_js_1.hashValidatedBytes)(algorithm, frame.value);
+}

package/dist/cjs/index.js

@@ -0,0 +1,16 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORD_EVIDENCE_SCHEMA = exports.LINK_EVIDENCE_SCHEMA = exports.DIAGNOSTIC_SCHEMA = exports.CHAIN_SUMMARY_EVIDENCE_SCHEMA = exports.BUILTIN_PROFILES = exports.EngineConfigurationError = exports.createEngine = exports.DIAGNOSTIC_CODES = void 0;
+var generated_js_1 = require("./contracts/generated.js");
+Object.defineProperty(exports, "DIAGNOSTIC_CODES", { enumerable: true, get: function () { return generated_js_1.DIAGNOSTIC_CODES; } });
+var engine_js_1 = require("./api/engine.js");
+Object.defineProperty(exports, "createEngine", { enumerable: true, get: function () { return engine_js_1.createEngine; } });
+Object.defineProperty(exports, "EngineConfigurationError", { enumerable: true, get: function () { return engine_js_1.EngineConfigurationError; } });
+var profiles_js_1 = require("./profiles.js");
+Object.defineProperty(exports, "BUILTIN_PROFILES", { enumerable: true, get: function () { return profiles_js_1.BUILTIN_PROFILES; } });
+var types_js_1 = require("./api/types.js");
+Object.defineProperty(exports, "CHAIN_SUMMARY_EVIDENCE_SCHEMA", { enumerable: true, get: function () { return types_js_1.CHAIN_SUMMARY_EVIDENCE_SCHEMA; } });
+Object.defineProperty(exports, "DIAGNOSTIC_SCHEMA", { enumerable: true, get: function () { return types_js_1.DIAGNOSTIC_SCHEMA; } });
+Object.defineProperty(exports, "LINK_EVIDENCE_SCHEMA", { enumerable: true, get: function () { return types_js_1.LINK_EVIDENCE_SCHEMA; } });
+Object.defineProperty(exports, "RECORD_EVIDENCE_SCHEMA", { enumerable: true, get: function () { return types_js_1.RECORD_EVIDENCE_SCHEMA; } });

package/dist/cjs/normalization/byte-sink.js

@@ -0,0 +1,70 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteArraySink = void 0;
+const byte_view_js_1 = require("../domain/byte-view.js");
+const UTF8_ENCODER = new TextEncoder();
+class ByteArraySink {
+    maximum;
+    buffer = new Uint8Array(0);
+    written = 0;
+    constructor(maximum, initialCapacity = 0) {
+        this.maximum = maximum;
+        if (!Number.isSafeInteger(initialCapacity) || initialCapacity < 0) {
+            throw new RangeError("invalid initial sink capacity");
+        }
+        const capacity = Math.min(maximum, Math.max(0, initialCapacity));
+        if (capacity > 0)
+            this.buffer = new Uint8Array(capacity);
+    }
+    get byteLength() {
+        return this.written;
+    }
+    write(value) {
+        this.ensureCapacity(value.length);
+        this.buffer.set(value, this.written);
+        this.written += value.length;
+    }
+    writeByte(value) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xff)
+            throw new RangeError("byte value out of range");
+        this.ensureCapacity(1);
+        this.buffer[this.written++] = value;
+    }
+    writeAscii(value) {
+        this.ensureCapacity(value.length);
+        for (let index = 0; index < value.length; index += 1) {
+            const code = value.charCodeAt(index);
+            if (code > 0x7f)
+                throw new RangeError("non-ASCII value");
+            this.buffer[this.written++] = code;
+        }
+    }
+    writeText(value) {
+        this.write(UTF8_ENCODER.encode(value));
+    }
+    toBytes() {
+        return (0, byte_view_js_1.copyBytes)(this.buffer.subarray(0, this.written));
+    }
+    /** Internal ownership transfer; the returned view is never exposed to callers. */
+    takeBytes() {
+        const bytes = this.buffer.subarray(0, this.written);
+        this.buffer = new Uint8Array(0);
+        this.written = 0;
+        return bytes;
+    }
+    ensureCapacity(additional) {
+        if (additional > this.maximum - this.written)
+            throw new RangeError("byte sink limit exceeded");
+        const required = this.written + additional;
+        if (required <= this.buffer.length)
+            return;
+        let capacity = Math.max(256, this.buffer.length);
+        while (capacity < required)
+            capacity = Math.min(this.maximum, capacity * 2);
+        const expanded = new Uint8Array(capacity);
+        expanded.set(this.buffer.subarray(0, this.written));
+        this.buffer = expanded;
+    }
+}
+exports.ByteArraySink = ByteArraySink;