@reallyme/codec 0.1.20 → 0.1.22

package/dist/multiformat.js

@@ -1,8 +1,11 @@
 // SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
 //
 // SPDX-License-Identifier: Apache-2.0
+import { create } from "@bufbuild/protobuf";
 import { ReallyMeCodecError } from "./errors.js";
-import { ensureBytesInput, ensureStringInput, ensureStringValue, readBooleanOutput, readBytesOutput, readBytesProperty, readObjectOutput, readProtoResultOutput, readOptionalLengthProperty, readStringOutput, readStringProperty, } from "./readOutput.js";
+import { CodecMulticodecLookupPrefixRequestSchema, CodecMulticodecPrefixForNameRequestSchema, CodecMulticodecTableRequestSchema, CodecMultikeyParseRequestSchema, CodecOperationRequestSchema, } from "./proto/generated/reallyme/codec/v1/codec_pb.js";
+import { processGeneratedProtoRequest, protoPayloadOrThrow, } from "./protoProcess.js";
+import { ensureBytesInput, ensureStringInput, ensureStringValue, readBooleanOutput, readBytesOutput, readBytesProperty, readObjectOutput, readOptionalLengthProperty, readStringOutput, readStringProperty, } from "./readOutput.js";
 import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
 const validTags = new Set([
     "encryption",
@@ -17,6 +20,7 @@ const validKeyMaterialKinds = new Set([
     "private-key",
     "symmetric-key",
 ]);
+const MAX_MULTICODEC_TABLE_ENTRIES = 1_024;
 const readTag = (object) => {
     const tag = readStringProperty(object, "tag");
     if (!validTags.has(tag)) {
@@ -77,10 +81,28 @@ const readParsedMultikey = (value) => {
     return { ...parsed, expectedPublicKeyLength };
 };
 const readMulticodecTable = (value) => {
-    if (!Array.isArray(value)) {
+    try {
+        if (!Array.isArray(value) ||
+            Object.getPrototypeOf(value) !== Array.prototype ||
+            value.length > MAX_MULTICODEC_TABLE_ENTRIES) {
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        const table = [];
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined || !("value" in descriptor)) {
+                throw new ReallyMeCodecError("provider-failure");
+            }
+            table.push(readMulticodecMetadata(descriptor.value));
+        }
+        return table;
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value.map(readMulticodecMetadata);
 };
 export const base58btcEncode = (bytes) => {
     ensureBytesInput(bytes);
@@ -107,32 +129,49 @@ export const multicodecPrefixForName = (codecName) => {
     return readMulticodecMetadata(requireReallyMeCodecWasmProvider().multicodecPrefixForName(codecName));
 };
 export const multicodecPrefixForNameProto = (codecName) => {
-    ensureStringInput(codecName);
-    return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecPrefixForNameProto(codecName));
+    return protoPayloadOrThrow(multicodecPrefixForNameProtoResult(codecName));
 };
 export const multicodecPrefixForNameProtoResult = (codecName) => {
     ensureStringInput(codecName);
-    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecPrefixForNameProtoResult(codecName));
+    return processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+        operation: {
+            case: "multicodecPrefixForName",
+            value: create(CodecMulticodecPrefixForNameRequestSchema, {
+                name: codecName,
+            }),
+        },
+    }));
 };
 export const multicodecLookupPrefix = (bytes) => {
     ensureBytesInput(bytes);
     return readMulticodecMetadata(requireReallyMeCodecWasmProvider().multicodecLookupPrefix(bytes));
 };
 export const multicodecLookupPrefixProto = (bytes) => {
-    ensureBytesInput(bytes);
-    return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecLookupPrefixProto(bytes));
+    return protoPayloadOrThrow(multicodecLookupPrefixProtoResult(bytes));
 };
 export const multicodecLookupPrefixProtoResult = (bytes) => {
     ensureBytesInput(bytes);
-    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecLookupPrefixProtoResult(bytes));
+    return processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+        operation: {
+            case: "multicodecLookupPrefix",
+            value: create(CodecMulticodecLookupPrefixRequestSchema, {
+                value: bytes,
+            }),
+        },
+    }));
 };
 export const multicodecStripPrefix = (bytes) => {
     ensureBytesInput(bytes);
     return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecStripPrefix(bytes));
 };
 export const multicodecTable = () => readMulticodecTable(requireReallyMeCodecWasmProvider().multicodecTable());
-export const multicodecTableProto = () => readBytesOutput(requireReallyMeCodecWasmProvider().multicodecTableProto());
-export const multicodecTableProtoResult = () => readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecTableProtoResult());
+export const multicodecTableProto = () => protoPayloadOrThrow(multicodecTableProtoResult());
+export const multicodecTableProtoResult = () => processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+    operation: {
+        case: "multicodecTable",
+        value: create(CodecMulticodecTableRequestSchema),
+    },
+}));
 export const multikeyEncode = (codecName, publicKey) => {
     ensureStringInput(codecName);
     ensureBytesInput(publicKey);
@@ -143,12 +182,16 @@ export const multikeyParse = (multikey) => {
     return readParsedMultikey(requireReallyMeCodecWasmProvider().multikeyParse(multikey));
 };
 export const multikeyParseProto = (multikey) => {
-    ensureStringInput(multikey);
-    return readBytesOutput(requireReallyMeCodecWasmProvider().multikeyParseProto(multikey));
+    return protoPayloadOrThrow(multikeyParseProtoResult(multikey));
 };
 export const multikeyParseProtoResult = (multikey) => {
     ensureStringInput(multikey);
-    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multikeyParseProtoResult(multikey));
+    return processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+        operation: {
+            case: "multikeyParse",
+            value: create(CodecMultikeyParseRequestSchema, { multikey }),
+        },
+    }));
 };
 export const bindingTypeMatchesCodec = (bindingType, codecName) => {
     ensureStringInput(bindingType);

package/dist/pem.d.ts

@@ -15,7 +15,7 @@ export type ReallyMePemDocument = Readonly<{
     label: ReallyMePemLabel;
     der: Uint8Array;
 }>;
-export declare const decodePem: (input: string, policy?: ReallyMePemDecodePolicy) => ReallyMePemDocument;
-export declare const decodePemProto: (input: string, policy?: ReallyMePemDecodePolicy) => Uint8Array;
-export declare const decodePemProtoResult: (input: string, policy?: ReallyMePemDecodePolicy) => ReallyMeCodecProtoResult;
-export declare const encodePem: (label: ReallyMePemLabel, der: Uint8Array, options?: ReallyMePemEncodeOptions) => string;
+export declare const decodePem: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => ReallyMePemDocument;
+export declare const decodePemProto: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => Uint8Array;
+export declare const decodePemProtoResult: (input: Uint8Array, policy?: ReallyMePemDecodePolicy) => ReallyMeCodecProtoResult;
+export declare const encodePem: (label: ReallyMePemLabel, der: Uint8Array, options?: ReallyMePemEncodeOptions) => Uint8Array;

package/dist/pem.js

@@ -1,14 +1,29 @@
 // SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
 //
 // SPDX-License-Identifier: Apache-2.0
+import { create } from "@bufbuild/protobuf";
+import { stringifyBoundaryJson } from "./boundary.js";
 import { ReallyMeCodecError } from "./errors.js";
-import { ensureBytesInput, ensureStringInput, readBytesOutput, readBytesProperty, readObjectOutput, readProtoResultOutput, readStringOutput, readStringProperty, } from "./readOutput.js";
+import { CodecOperationRequestSchema, CodecPemDecodeOptionsSchema, CodecPemDecodeRequestSchema, CodecPemLabel, } from "./proto/generated/reallyme/codec/v1/codec_pb.js";
+import { processGeneratedProtoRequest, protoPayloadOrThrow, } from "./protoProcess.js";
+import { ensureBytesInput, readBytesOutput, readBytesProperty, readObjectOutput, readStringProperty, } from "./readOutput.js";
 import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
 const validLabels = new Set([
     "PRIVATE KEY",
     "EC PRIVATE KEY",
     "PUBLIC KEY",
 ]);
+const MAX_PEM_ALLOWED_LABELS = 1_024;
+const pemDecodePolicyFields = new Set([
+    "allowedLabels",
+    "maxInputLen",
+    "maxDerLen",
+]);
+const pemEncodeOptionFields = new Set([
+    "maxDerLen",
+    "lineWidth",
+    "lineEnding",
+]);
 const requirePemLabel = (label) => {
     if (!validLabels.has(label)) {
         throw new ReallyMeCodecError("invalid-input");
@@ -22,67 +37,199 @@ const requirePemLabel = (label) => {
             throw new ReallyMeCodecError("invalid-input");
     }
 };
+const readPemLabel = (label) => {
+    if (!validLabels.has(label)) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    switch (label) {
+        case "PRIVATE KEY":
+        case "EC PRIVATE KEY":
+        case "PUBLIC KEY":
+            return label;
+        default:
+            throw new ReallyMeCodecError("provider-failure");
+    }
+};
 const requirePositiveInteger = (value) => {
     if (value !== undefined &&
         (!Number.isSafeInteger(value) || value <= 0)) {
         throw new ReallyMeCodecError("invalid-input");
     }
 };
+const readSnapshotProperty = (value, name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, name);
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (!("value" in descriptor)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return descriptor.value;
+};
+const snapshotOptionsRecord = (value, allowedFields) => {
+    try {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new ReallyMeCodecError("invalid-input");
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new ReallyMeCodecError("invalid-input");
+        }
+        const entries = [];
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key !== "string" || !allowedFields.has(key)) {
+                throw new ReallyMeCodecError("invalid-input");
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor === undefined || !("value" in descriptor)) {
+                throw new ReallyMeCodecError("invalid-input");
+            }
+            entries.push([key, descriptor.value]);
+        }
+        return Object.fromEntries(entries);
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("invalid-input");
+    }
+};
+const readPositiveIntegerOption = (value, name) => {
+    const property = readSnapshotProperty(value, name);
+    if (property === undefined) {
+        return undefined;
+    }
+    if (typeof property !== "number") {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    requirePositiveInteger(property);
+    return property;
+};
+const snapshotDecodePolicy = (policy) => {
+    if (policy === undefined) {
+        return undefined;
+    }
+    const snapshot = snapshotOptionsRecord(policy, pemDecodePolicyFields);
+    const labelsValue = readSnapshotProperty(snapshot, "allowedLabels");
+    let allowedLabels;
+    if (labelsValue !== undefined) {
+        if (!Array.isArray(labelsValue) ||
+            Object.getPrototypeOf(labelsValue) !== Array.prototype ||
+            labelsValue.length > MAX_PEM_ALLOWED_LABELS) {
+            throw new ReallyMeCodecError("invalid-input");
+        }
+        allowedLabels = [];
+        for (let index = 0; index < labelsValue.length; index += 1) {
+            const label = readSnapshotProperty(labelsValue, String(index));
+            if (typeof label !== "string") {
+                throw new ReallyMeCodecError("invalid-input");
+            }
+            allowedLabels.push(requirePemLabel(label));
+        }
+    }
+    const maxInputLen = readPositiveIntegerOption(snapshot, "maxInputLen");
+    const maxDerLen = readPositiveIntegerOption(snapshot, "maxDerLen");
+    return {
+        ...(allowedLabels === undefined ? {} : { allowedLabels }),
+        ...(maxInputLen === undefined ? {} : { maxInputLen }),
+        ...(maxDerLen === undefined ? {} : { maxDerLen }),
+    };
+};
+const snapshotEncodeOptions = (options) => {
+    if (options === undefined) {
+        return undefined;
+    }
+    const snapshot = snapshotOptionsRecord(options, pemEncodeOptionFields);
+    const maxDerLen = readPositiveIntegerOption(snapshot, "maxDerLen");
+    const lineWidth = readPositiveIntegerOption(snapshot, "lineWidth");
+    const lineEndingValue = readSnapshotProperty(snapshot, "lineEnding");
+    let lineEnding;
+    if (lineEndingValue !== undefined) {
+        if (lineEndingValue !== "lf" && lineEndingValue !== "crlf") {
+            throw new ReallyMeCodecError("invalid-input");
+        }
+        lineEnding = lineEndingValue;
+    }
+    return {
+        ...(maxDerLen === undefined ? {} : { maxDerLen }),
+        ...(lineWidth === undefined ? {} : { lineWidth }),
+        ...(lineEnding === undefined ? {} : { lineEnding }),
+    };
+};
+const requireProtoUint32 = (value) => {
+    requirePositiveInteger(value);
+    if (value === undefined) {
+        return 0;
+    }
+    if (value > 0xffff_ffff) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return value;
+};
+const protoPemLabel = (label) => {
+    switch (label) {
+        case "PRIVATE KEY":
+            return CodecPemLabel.PRIVATE_KEY;
+        case "EC PRIVATE KEY":
+            return CodecPemLabel.EC_PRIVATE_KEY;
+        case "PUBLIC KEY":
+            return CodecPemLabel.PUBLIC_KEY;
+    }
+};
 const encodeOptions = (options) => {
     if (options === undefined) {
         return "";
     }
-    return JSON.stringify(options);
+    return stringifyBoundaryJson(options);
 };
 const readPemDocument = (value) => {
     const object = readObjectOutput(value);
     return {
-        label: requirePemLabel(readStringProperty(object, "label")),
+        label: readPemLabel(readStringProperty(object, "label")),
         der: readBytesProperty(object, "der"),
     };
 };
 export const decodePem = (input, policy) => {
-    ensureStringInput(input);
-    if (policy?.allowedLabels !== undefined) {
-        for (const label of policy.allowedLabels) {
-            requirePemLabel(label);
-        }
-    }
-    requirePositiveInteger(policy?.maxInputLen);
-    requirePositiveInteger(policy?.maxDerLen);
-    return readPemDocument(requireReallyMeCodecWasmProvider().pemDecode(input, encodeOptions(policy)));
+    ensureBytesInput(input);
+    const snapshot = snapshotDecodePolicy(policy);
+    return readPemDocument(requireReallyMeCodecWasmProvider().pemDecode(input, encodeOptions(snapshot)));
 };
 export const decodePemProto = (input, policy) => {
-    ensureStringInput(input);
-    if (policy?.allowedLabels !== undefined) {
-        for (const label of policy.allowedLabels) {
-            requirePemLabel(label);
-        }
-    }
-    requirePositiveInteger(policy?.maxInputLen);
-    requirePositiveInteger(policy?.maxDerLen);
-    return readBytesOutput(requireReallyMeCodecWasmProvider().pemDecodeProto(input, encodeOptions(policy)));
+    return protoPayloadOrThrow(decodePemProtoResult(input, policy));
 };
 export const decodePemProtoResult = (input, policy) => {
-    ensureStringInput(input);
-    if (policy?.allowedLabels !== undefined) {
-        for (const label of policy.allowedLabels) {
-            requirePemLabel(label);
+    ensureBytesInput(input);
+    const snapshot = snapshotDecodePolicy(policy);
+    const allowedLabels = [];
+    if (snapshot?.allowedLabels !== undefined) {
+        for (const label of snapshot.allowedLabels) {
+            allowedLabels.push(protoPemLabel(requirePemLabel(label)));
+        }
+    }
+    const request = create(CodecPemDecodeRequestSchema, { pem: input });
+    try {
+        if (snapshot !== undefined) {
+            request.options = create(CodecPemDecodeOptionsSchema, {
+                allowedLabels,
+                maxInputLen: requireProtoUint32(snapshot.maxInputLen),
+                maxDerLen: requireProtoUint32(snapshot.maxDerLen),
+            });
         }
+        return processGeneratedProtoRequest(create(CodecOperationRequestSchema, {
+            operation: {
+                case: "pemDecode",
+                value: request,
+            },
+        }));
+    }
+    finally {
+        request.pem = new Uint8Array(0);
     }
-    requirePositiveInteger(policy?.maxInputLen);
-    requirePositiveInteger(policy?.maxDerLen);
-    return readProtoResultOutput(requireReallyMeCodecWasmProvider().pemDecodeProtoResult(input, encodeOptions(policy)));
 };
 export const encodePem = (label, der, options) => {
     requirePemLabel(label);
     ensureBytesInput(der);
-    requirePositiveInteger(options?.maxDerLen);
-    requirePositiveInteger(options?.lineWidth);
-    if (options?.lineEnding !== undefined &&
-        options.lineEnding !== "lf" &&
-        options.lineEnding !== "crlf") {
-        throw new ReallyMeCodecError("invalid-input");
-    }
-    return readStringOutput(requireReallyMeCodecWasmProvider().pemEncode(label, der, encodeOptions(options)));
+    const snapshot = snapshotEncodeOptions(options);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().pemEncode(label, der, encodeOptions(snapshot)));
 };