@atproto/lex-json 0.0.14 → 0.0.15

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atproto/lex-json
 
+## 0.0.15
+
+### Patch Changes
+
+- [#4835](https://github.com/bluesky-social/atproto/pull/4835) [`f6f100c`](https://github.com/bluesky-social/atproto/commit/f6f100c33700a7ff58a1458109cc7420131feed0) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add `lexParseJsonBytes` utility to parse a byte array containing a json string directly into lex data
+
+- Updated dependencies [[`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856), [`f6f100c`](https://github.com/bluesky-social/atproto/commit/f6f100c33700a7ff58a1458109cc7420131feed0), [`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856), [`c62651d`](https://github.com/bluesky-social/atproto/commit/c62651dd69f1e18bd854b66e499b91fee9eaa856)]:
+  - @atproto/lex-data@0.0.15
+
 ## 0.0.14
 
 ### Patch Changes

package/dist/blob.d.ts

@@ -1,4 +1,4 @@
-import { BlobRef, BlobRefCheckOptions, LexMap } from '@atproto/lex-data';
+import { BlobRefCheckOptions, LexMap, TypedBlobRef } from '@atproto/lex-data';
 /**
  * Parses a blob reference from a JSON object.
  *
@@ -19,7 +19,7 @@ import { BlobRef, BlobRefCheckOptions, LexMap } from '@atproto/lex-data';
  * @example
  * ```typescript
  * // Parse a blob reference from JSON
- * const blobRef = parseBlobRef({
+ * const blobRef = parseTypedBlobRef({
  *   $type: 'blob',
  *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },
  *   mimeType: 'image/png',
@@ -29,9 +29,9 @@ import { BlobRef, BlobRefCheckOptions, LexMap } from '@atproto/lex-data';
  * // blobRef.ref is a Cid instance
  *
  * // Returns undefined for non-blob objects
- * const result = parseBlobRef({ foo: 'bar' })
+ * const result = parseTypedBlobRef({ foo: 'bar' })
  * // result is undefined
  * ```
  */
-export declare function parseBlobRef(input: LexMap, options?: BlobRefCheckOptions): BlobRef | undefined;
+export declare function parseTypedBlobRef(input: LexMap, options?: BlobRefCheckOptions): TypedBlobRef | undefined;
 //# sourceMappingURL=blob.d.ts.map

package/dist/blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,MAAM,EAEP,MAAM,mBAAmB,CAAA;AAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,GAAG,SAAS,CAwBrB"}
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,MAAM,EACN,YAAY,EAEb,MAAM,mBAAmB,CAAA;AAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,mBAAmB,GAC5B,YAAY,GAAG,SAAS,CAwB1B"}

package/dist/blob.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBlobRef = parseBlobRef;
+exports.parseTypedBlobRef = parseTypedBlobRef;
 const lex_data_1 = require("@atproto/lex-data");
 const link_js_1 = require("./link.js");
 /**
@@ -23,7 +23,7 @@ const link_js_1 = require("./link.js");
  * @example
  * ```typescript
  * // Parse a blob reference from JSON
- * const blobRef = parseBlobRef({
+ * const blobRef = parseTypedBlobRef({
  *   $type: 'blob',
  *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },
  *   mimeType: 'image/png',
@@ -33,11 +33,11 @@ const link_js_1 = require("./link.js");
  * // blobRef.ref is a Cid instance
  *
  * // Returns undefined for non-blob objects
- * const result = parseBlobRef({ foo: 'bar' })
+ * const result = parseTypedBlobRef({ foo: 'bar' })
  * // result is undefined
  * ```
  */
-function parseBlobRef(input, options) {
+function parseTypedBlobRef(input, options) {
     if (input.$type !== 'blob')
         return undefined;
     const ref = input?.ref;
@@ -52,10 +52,10 @@ function parseBlobRef(input, options) {
         if (!cid)
             return undefined;
         const blob = { ...input, ref: cid };
-        if ((0, lex_data_1.isBlobRef)(blob, options))
+        if ((0, lex_data_1.isTypedBlobRef)(blob, options))
             return blob;
     }
-    if ((0, lex_data_1.isBlobRef)(input)) {
+    if ((0, lex_data_1.isTypedBlobRef)(input)) {
         return input;
     }
     return undefined;

package/dist/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":";;AA0CA,oCA2BC;AArED,gDAK0B;AAC1B,uCAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,YAAY,CAC1B,KAAa,EACb,OAA6B;IAE7B,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,SAAS,CAAA;IAE5C,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAA;IACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IAErD,8EAA8E;IAC9E,oEAAoE;IACpE,qEAAqE;IACrE,iDAAiD;IAEjD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAE1B,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;QACnC,IAAI,IAAA,oBAAS,EAAC,IAAI,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;IAC3C,CAAC;IAED,IAAI,IAAA,oBAAS,EAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC","sourcesContent":["import {\n  BlobRef,\n  BlobRefCheckOptions,\n  LexMap,\n  isBlobRef,\n} from '@atproto/lex-data'\nimport { parseLexLink } from './link.js'\n\n/**\n * Parses a blob reference from a JSON object.\n *\n * In the AT Protocol, blobs are referenced using a specific object structure\n * with `$type: 'blob'`, a `ref` property containing a CID link, and metadata\n * like `mimeType` and `size`. This function validates and parses such objects\n * into `BlobRef` instances.\n *\n * The function handles both cases where the `ref` property is:\n * - A `{$link: string}` object (when parsing from JSON)\n * - Already a `Cid` instance (when the parent object has been partially converted)\n *\n * @param input - A Lex map potentially representing a blob reference\n * @param options - Optional blob reference validation options\n * @returns The parsed `BlobRef` if the input is a valid blob reference,\n *          or `undefined` if the input is not a valid blob representation\n *\n * @example\n * ```typescript\n * // Parse a blob reference from JSON\n * const blobRef = parseBlobRef({\n *   $type: 'blob',\n *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },\n *   mimeType: 'image/png',\n *   size: 12345\n * })\n *\n * // blobRef.ref is a Cid instance\n *\n * // Returns undefined for non-blob objects\n * const result = parseBlobRef({ foo: 'bar' })\n * // result is undefined\n * ```\n */\nexport function parseBlobRef(\n  input: LexMap,\n  options?: BlobRefCheckOptions,\n): BlobRef | undefined {\n  if (input.$type !== 'blob') return undefined\n\n  const ref = input?.ref\n  if (!ref || typeof ref !== 'object') return undefined\n\n  // @NOTE Because json to lex conversion can be performed both in a depth-first\n  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via\n  // jsonToLex), the `ref` property may either be a LexMap with a $link\n  // property, or it may already be a CID instance.\n\n  if ('$link' in ref) {\n    const cid = parseLexLink(ref)\n    if (!cid) return undefined\n\n    const blob = { ...input, ref: cid }\n    if (isBlobRef(blob, options)) return blob\n  }\n\n  if (isBlobRef(input)) {\n    return input\n  }\n\n  return undefined\n}\n"]}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":";;AA0CA,8CA2BC;AArED,gDAK0B;AAC1B,uCAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,iBAAiB,CAC/B,KAAa,EACb,OAA6B;IAE7B,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,SAAS,CAAA;IAE5C,MAAM,GAAG,GAAG,KAAK,EAAE,GAAG,CAAA;IACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IAErD,8EAA8E;IAC9E,oEAAoE;IACpE,qEAAqE;IACrE,iDAAiD;IAEjD,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,SAAS,CAAA;QAE1B,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;QACnC,IAAI,IAAA,yBAAc,EAAC,IAAI,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAA;IAChD,CAAC;IAED,IAAI,IAAA,yBAAc,EAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAA;IACd,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC","sourcesContent":["import {\n  BlobRefCheckOptions,\n  LexMap,\n  TypedBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { parseLexLink } from './link.js'\n\n/**\n * Parses a blob reference from a JSON object.\n *\n * In the AT Protocol, blobs are referenced using a specific object structure\n * with `$type: 'blob'`, a `ref` property containing a CID link, and metadata\n * like `mimeType` and `size`. This function validates and parses such objects\n * into `BlobRef` instances.\n *\n * The function handles both cases where the `ref` property is:\n * - A `{$link: string}` object (when parsing from JSON)\n * - Already a `Cid` instance (when the parent object has been partially converted)\n *\n * @param input - A Lex map potentially representing a blob reference\n * @param options - Optional blob reference validation options\n * @returns The parsed `BlobRef` if the input is a valid blob reference,\n *          or `undefined` if the input is not a valid blob representation\n *\n * @example\n * ```typescript\n * // Parse a blob reference from JSON\n * const blobRef = parseTypedBlobRef({\n *   $type: 'blob',\n *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },\n *   mimeType: 'image/png',\n *   size: 12345\n * })\n *\n * // blobRef.ref is a Cid instance\n *\n * // Returns undefined for non-blob objects\n * const result = parseTypedBlobRef({ foo: 'bar' })\n * // result is undefined\n * ```\n */\nexport function parseTypedBlobRef(\n  input: LexMap,\n  options?: BlobRefCheckOptions,\n): TypedBlobRef | undefined {\n  if (input.$type !== 'blob') return undefined\n\n  const ref = input?.ref\n  if (!ref || typeof ref !== 'object') return undefined\n\n  // @NOTE Because json to lex conversion can be performed both in a depth-first\n  // manner (e.g. via lexParse) or in a breadth-first manner (e.g. via\n  // jsonToLex), the `ref` property may either be a LexMap with a $link\n  // property, or it may already be a CID instance.\n\n  if ('$link' in ref) {\n    const cid = parseLexLink(ref)\n    if (!cid) return undefined\n\n    const blob = { ...input, ref: cid }\n    if (isTypedBlobRef(blob, options)) return blob\n  }\n\n  if (isTypedBlobRef(input)) {\n    return input\n  }\n\n  return undefined\n}\n"]}

package/dist/lex-json.d.ts

@@ -78,6 +78,10 @@ export type LexParseOptions = {
  * ```
  */
 export declare function lexParse<T extends LexValue = LexValue>(input: string, options?: LexParseOptions): T;
+/**
+ * Parses a `Uint8Array` containing JSON data into a Lex value.
+ */
+export declare function lexParseJsonBytes(jsonBytes: Uint8Array, options?: LexParseOptions): LexValue;
 /**
  * Converts a parsed JSON representation of Lexicon value to a {@link LexValue}.
  *

package/dist/lex-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lex-json.d.ts","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,QAAQ,EAET,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAc,SAAS,EAAE,MAAM,WAAW,CAAA;AAGjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAKpD;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EACpD,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAmC,GAC3C,CAAC,CAiBH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,eAAmC,GAC3C,QAAQ,CAsBV;AA+CD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAqBpD"}
+{"version":3,"file":"lex-json.d.ts","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,QAAQ,EAGT,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAc,SAAS,EAAE,MAAM,WAAW,CAAA;AAGjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAKpD;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EACpD,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAmC,GAC3C,CAAC,CAiBH;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,UAAU,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAWV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,eAAmC,GAC3C,QAAQ,CAsBV;AA+CD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAqBpD"}

package/dist/lex-json.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lexStringify = lexStringify;
 exports.lexParse = lexParse;
+exports.lexParseJsonBytes = lexParseJsonBytes;
 exports.jsonToLex = jsonToLex;
 exports.lexToJson = lexToJson;
 const lex_data_1 = require("@atproto/lex-data");
@@ -93,6 +94,19 @@ function lexParse(input, options = { strict: false }) {
         }
     });
 }
+/**
+ * Parses a `Uint8Array` containing JSON data into a Lex value.
+ */
+function lexParseJsonBytes(jsonBytes, options) {
+    // @TODO optimize this to avoid intermediate string. This requires a custom
+    // JSON parser that can operate on binary data, which is non-trivial, but
+    // could be a future improvement if performance is a concern. See the link
+    // below for an example of a JSON parser that operates on binary data in
+    // @ipld/dag-json
+    // https://github.com/ipld/js-dag-json/blob/57912da6e9d64a179f7d2384c3b6d7b07fbfb143/src/index.js#L161
+    const jsonString = (0, lex_data_1.utf8FromBytes)(jsonBytes);
+    return lexParse(jsonString, options);
+}
 /**
  * Converts a parsed JSON representation of Lexicon value to a {@link LexValue}.
  *
@@ -292,7 +306,7 @@ function parseSpecialJsonObject(input, options) {
         // the strict option is enabled.
         if (options.strict) {
             if (input.$type === 'blob') {
-                const blob = (0, blob_js_1.parseBlobRef)(input, options);
+                const blob = (0, blob_js_1.parseTypedBlobRef)(input, options);
                 if (blob)
                     return blob;
                 throw new TypeError(`Invalid blob object`);

package/dist/lex-json.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex-json.js","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  Cid,\n  LexArray,\n  LexMap,\n  LexValue,\n  isCid,\n} from '@atproto/lex-data'\nimport { parseBlobRef } from './blob.js'\nimport { encodeLexBytes, parseLexBytes } from './bytes.js'\nimport { JsonObject, JsonValue } from './json.js'\nimport { encodeLexLink, parseLexLink } from './link.js'\n\n/**\n * Serialize a Lex value to a JSON string.\n *\n * This function serializes AT Protocol data model values to JSON, automatically\n * encoding special types:\n * - `Cid` instances are encoded as `{$link: string}`\n * - `Uint8Array` instances are encoded as `{$bytes: string}` (base64)\n *\n * @param input - The Lex value to stringify\n * @returns A JSON string representation of the value\n *\n * @example\n * ```typescript\n * import { lexStringify } from '@atproto/lex'\n *\n * // Stringify with CID and bytes encoding\n * const json = lexStringify({\n *   ref: someCid,\n *   data: new Uint8Array([72, 101, 108, 108, 111])\n * })\n * // json is '{\"ref\":{\"$link\":\"bafyrei...\"},\"data\":{\"$bytes\":\"SGVsbG8=\"}}'\n * ```\n */\nexport function lexStringify(input: LexValue): string {\n  // @NOTE Because of the way the \"replacer\" works in JSON.stringify, it's\n  // simpler to convert Lex to JSON first rather than trying to do it\n  // on-the-fly.\n  return JSON.stringify(lexToJson(input))\n}\n\n/**\n * Options for parsing JSON to Lex values.\n */\nexport type LexParseOptions = {\n  /**\n   * When enabled, forbids the presence of invalid Lex values such as:\n   * - Non-integer numbers (only safe integers are valid in the Lex data model)\n   * - Malformed `$link` objects\n   * - Malformed `$bytes` objects\n   * - Objects with invalid or empty `$type` properties\n   * - Invalid {@link BlobRef} (`$type: 'blob'`) objects\n   *\n   * When disabled (default), invalid special objects are left as plain objects.\n   *\n   * @default false\n   */\n  strict?: boolean\n}\n\n/**\n * Parses a JSON string into Lex values.\n *\n * This function parses JSON and automatically decodes AT Protocol special types:\n * - `{$link: string}` objects are decoded to `Cid` instances\n * - `{$bytes: string}` objects are decoded to `Uint8Array` instances\n * - `{$type: 'blob'}` objects are validated\n *\n * @typeParam T - Type cast for the resulting Lex value. Use when you want to specify the expected structure of the parsed data.\n * @param input - The JSON string to parse\n * @param options - Parsing options (e.g., strict mode)\n * @returns The parsed Lex value\n * @throws {SyntaxError} If the input is not valid JSON\n * @throws {TypeError} If strict mode is enabled and invalid Lex values are found\n *\n * @example\n * ```typescript\n * import { lexParse } from '@atproto/lex'\n *\n * // Parse JSON with $link and $bytes decoding\n * const parsed = lexParse<{\n *   ref: Cid\n *   data: Uint8Array\n * }>(`{\n *   \"ref\": { \"$link\": \"bafyrei...\" },\n *   \"data\": { \"$bytes\": \"SGVsbG8sIHdvcmxkIQ==\" }\n * }`)\n *\n * // Parse a single CID\n * const someCid = lexParse<Cid>('{\"$link\": \"bafyrei...\"}')\n *\n * // Parse binary data\n * const someBytes = lexParse<Uint8Array>('{\"$bytes\": \"SGVsbG8sIHdvcmxkIQ==\"}')\n * ```\n */\nexport function lexParse<T extends LexValue = LexValue>(\n  input: string,\n  options: LexParseOptions = { strict: false },\n): T {\n  return JSON.parse(input, function (key: string, value: JsonValue): LexValue {\n    switch (typeof value) {\n      case 'object':\n        if (value === null) return null\n        if (Array.isArray(value)) return value\n        return parseSpecialJsonObject(value, options) ?? value\n      case 'number':\n        if (Number.isSafeInteger(value)) return value\n        if (options.strict) {\n          throw new TypeError(`Invalid non-integer number: ${value}`)\n        }\n      // fallthrough\n      default:\n        return value\n    }\n  })\n}\n\n/**\n * Converts a parsed JSON representation of Lexicon value to a {@link LexValue}.\n *\n * This function transforms already-parsed JSON objects into Lex values by\n * decoding AT Protocol special types:\n * - `{$link: string}` objects are converted to `Cid` instances\n * - `{$bytes: string}` objects are converted to `Uint8Array` instances\n *\n * Use this when you have a JavaScript object (e.g., from `JSON.parse()`) and\n * need to convert it to the Lex data model. For parsing JSON strings directly,\n * use {@link lexParse} instead.\n *\n * @param value - The JSON value to convert\n * @param options - Parsing options (e.g., strict mode)\n * @returns The converted Lex value\n * @throws {TypeError} If strict mode is enabled and invalid Lex values are found\n * @throws {TypeError} If the value contains unsupported types (e.g., undefined at top level)\n *\n * @example\n * ```typescript\n * import { jsonToLex } from '@atproto/lex'\n *\n * // Convert parsed JSON to Lex values\n * const lex = jsonToLex({\n *   ref: { $link: 'bafyrei...' },  // Converted to Cid\n *   data: { $bytes: 'SGVsbG8sIHdvcmxkIQ==' }  // Converted to Uint8Array\n * })\n * ```\n */\nexport function jsonToLex(\n  value: JsonValue,\n  options: LexParseOptions = { strict: false },\n): LexValue {\n  switch (typeof value) {\n    case 'object': {\n      if (value === null) return null\n      if (Array.isArray(value)) return jsonArrayToLex(value, options)\n      return (\n        parseSpecialJsonObject(value, options) ??\n        jsonObjectToLexMap(value, options)\n      )\n    }\n    case 'number':\n      if (Number.isSafeInteger(value)) return value\n      if (options.strict) {\n        throw new TypeError(`Invalid non-integer number: ${value}`)\n      }\n    // fallthrough\n    case 'boolean':\n    case 'string':\n      return value\n    default:\n      throw new TypeError(`Invalid JSON value: ${typeof value}`)\n  }\n}\n\nfunction jsonArrayToLex(\n  input: JsonValue[],\n  options: LexParseOptions,\n): LexValue[] {\n  // Lazily copy value\n  let copy: LexValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = jsonToLex(inputItem, options)\n    if (item !== inputItem) {\n      copy ??= Array.from(input)\n      copy[i] = item\n    }\n  }\n  return copy ?? input\n}\n\nfunction jsonObjectToLexMap(\n  input: JsonObject,\n  options: LexParseOptions,\n): LexMap {\n  // Lazily copy value\n  let copy: LexMap | undefined = undefined\n  for (const [key, jsonValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (jsonValue === undefined) {\n      copy ??= { ...input }\n      delete copy[key]\n      continue\n    }\n\n    const value = jsonToLex(jsonValue!, options)\n    if (value !== jsonValue) {\n      copy ??= { ...input }\n      copy[key] = value\n    }\n  }\n  return copy ?? input\n}\n\n/**\n * Converts a Lex value to a JSON-compatible value.\n *\n * This function transforms Lex data model values into plain JavaScript objects\n * suitable for JSON serialization:\n * - `Cid` instances are converted to `{$link: string}` objects\n * - `Uint8Array` instances are converted to `{$bytes: string}` objects (base64)\n *\n * Use this when you need to convert Lex values to plain objects (e.g., for\n * custom serialization or inspection). For direct JSON string output, use\n * {@link lexStringify} instead.\n *\n * @param value - The Lex value to convert\n * @returns The JSON-compatible value\n * @throws {TypeError} If the value contains unsupported types\n *\n * @example\n * ```typescript\n * import { lexToJson } from '@atproto/lex'\n *\n * // Convert Lex values to JSON-compatible objects\n * const obj = lexToJson({\n *   ref: someCid,      // Converted to { $link: string }\n *   data: someBytes    // Converted to { $bytes: string }\n * })\n * ```\n */\nexport function lexToJson(value: LexValue): JsonValue {\n  switch (typeof value) {\n    case 'object':\n      if (value === null) {\n        return value\n      } else if (Array.isArray(value)) {\n        return lexArrayToJson(value)\n      } else if (isCid(value)) {\n        return encodeLexLink(value)\n      } else if (ArrayBuffer.isView(value)) {\n        return encodeLexBytes(value)\n      } else {\n        return encodeLexMap(value)\n      }\n    case 'boolean':\n    case 'string':\n    case 'number':\n      return value\n    default:\n      throw new TypeError(`Invalid Lex value: ${typeof value}`)\n  }\n}\n\nfunction lexArrayToJson(input: LexArray): JsonValue[] {\n  // Lazily copy value\n  let copy: JsonValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = lexToJson(inputItem)\n    if (item !== inputItem) {\n      copy ??= Array.from(input) as JsonValue[]\n      copy[i] = item\n    }\n  }\n  return copy ?? (input as JsonValue[])\n}\n\nfunction encodeLexMap(input: LexMap): JsonObject {\n  // Lazily copy value\n  let copy: JsonObject | undefined = undefined\n  for (const [key, lexValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (lexValue === undefined) {\n      copy ??= { ...input } as JsonObject\n      delete copy[key]\n      continue\n    }\n\n    const jsonValue = lexToJson(lexValue!)\n    if (jsonValue !== lexValue) {\n      copy ??= { ...input } as JsonObject\n      copy[key] = jsonValue\n    }\n  }\n  return copy ?? (input as JsonObject)\n}\n\nfunction parseSpecialJsonObject(\n  input: LexMap,\n  options: LexParseOptions,\n): Cid | Uint8Array | BlobRef | undefined {\n  // Hot path: use hints to avoid parsing when possible\n\n  if (input.$link !== undefined) {\n    const cid = parseLexLink(input)\n    if (cid) return cid\n    if (options.strict) throw new TypeError(`Invalid $link object`)\n  } else if (input.$bytes !== undefined) {\n    const bytes = parseLexBytes(input)\n    if (bytes) return bytes\n    if (options.strict) throw new TypeError(`Invalid $bytes object`)\n  } else if (input.$type !== undefined) {\n    // @NOTE Since blobs are \"just\" regular lex objects with a special shape,\n    // and because an object that does not conform to the blob shape would still\n    // result in undefined being returned, we only attempt to parse blobs when\n    // the strict option is enabled.\n    if (options.strict) {\n      if (input.$type === 'blob') {\n        const blob = parseBlobRef(input, options)\n        if (blob) return blob\n        throw new TypeError(`Invalid blob object`)\n      } else if (typeof input.$type !== 'string') {\n        throw new TypeError(`Invalid $type property (${typeof input.$type})`)\n      } else if (input.$type.length === 0) {\n        throw new TypeError(`Empty $type property`)\n      }\n    }\n  }\n\n  // @NOTE We ignore legacy blob representation here. They can be handled at the\n  // application level if needed.\n\n  return undefined\n}\n"]}
+{"version":3,"file":"lex-json.js","sourceRoot":"","sources":["../src/lex-json.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  Cid,\n  LexArray,\n  LexMap,\n  LexValue,\n  isCid,\n  utf8FromBytes,\n} from '@atproto/lex-data'\nimport { parseTypedBlobRef } from './blob.js'\nimport { encodeLexBytes, parseLexBytes } from './bytes.js'\nimport { JsonObject, JsonValue } from './json.js'\nimport { encodeLexLink, parseLexLink } from './link.js'\n\n/**\n * Serialize a Lex value to a JSON string.\n *\n * This function serializes AT Protocol data model values to JSON, automatically\n * encoding special types:\n * - `Cid` instances are encoded as `{$link: string}`\n * - `Uint8Array` instances are encoded as `{$bytes: string}` (base64)\n *\n * @param input - The Lex value to stringify\n * @returns A JSON string representation of the value\n *\n * @example\n * ```typescript\n * import { lexStringify } from '@atproto/lex'\n *\n * // Stringify with CID and bytes encoding\n * const json = lexStringify({\n *   ref: someCid,\n *   data: new Uint8Array([72, 101, 108, 108, 111])\n * })\n * // json is '{\"ref\":{\"$link\":\"bafyrei...\"},\"data\":{\"$bytes\":\"SGVsbG8=\"}}'\n * ```\n */\nexport function lexStringify(input: LexValue): string {\n  // @NOTE Because of the way the \"replacer\" works in JSON.stringify, it's\n  // simpler to convert Lex to JSON first rather than trying to do it\n  // on-the-fly.\n  return JSON.stringify(lexToJson(input))\n}\n\n/**\n * Options for parsing JSON to Lex values.\n */\nexport type LexParseOptions = {\n  /**\n   * When enabled, forbids the presence of invalid Lex values such as:\n   * - Non-integer numbers (only safe integers are valid in the Lex data model)\n   * - Malformed `$link` objects\n   * - Malformed `$bytes` objects\n   * - Objects with invalid or empty `$type` properties\n   * - Invalid {@link BlobRef} (`$type: 'blob'`) objects\n   *\n   * When disabled (default), invalid special objects are left as plain objects.\n   *\n   * @default false\n   */\n  strict?: boolean\n}\n\n/**\n * Parses a JSON string into Lex values.\n *\n * This function parses JSON and automatically decodes AT Protocol special types:\n * - `{$link: string}` objects are decoded to `Cid` instances\n * - `{$bytes: string}` objects are decoded to `Uint8Array` instances\n * - `{$type: 'blob'}` objects are validated\n *\n * @typeParam T - Type cast for the resulting Lex value. Use when you want to specify the expected structure of the parsed data.\n * @param input - The JSON string to parse\n * @param options - Parsing options (e.g., strict mode)\n * @returns The parsed Lex value\n * @throws {SyntaxError} If the input is not valid JSON\n * @throws {TypeError} If strict mode is enabled and invalid Lex values are found\n *\n * @example\n * ```typescript\n * import { lexParse } from '@atproto/lex'\n *\n * // Parse JSON with $link and $bytes decoding\n * const parsed = lexParse<{\n *   ref: Cid\n *   data: Uint8Array\n * }>(`{\n *   \"ref\": { \"$link\": \"bafyrei...\" },\n *   \"data\": { \"$bytes\": \"SGVsbG8sIHdvcmxkIQ==\" }\n * }`)\n *\n * // Parse a single CID\n * const someCid = lexParse<Cid>('{\"$link\": \"bafyrei...\"}')\n *\n * // Parse binary data\n * const someBytes = lexParse<Uint8Array>('{\"$bytes\": \"SGVsbG8sIHdvcmxkIQ==\"}')\n * ```\n */\nexport function lexParse<T extends LexValue = LexValue>(\n  input: string,\n  options: LexParseOptions = { strict: false },\n): T {\n  return JSON.parse(input, function (key: string, value: JsonValue): LexValue {\n    switch (typeof value) {\n      case 'object':\n        if (value === null) return null\n        if (Array.isArray(value)) return value\n        return parseSpecialJsonObject(value, options) ?? value\n      case 'number':\n        if (Number.isSafeInteger(value)) return value\n        if (options.strict) {\n          throw new TypeError(`Invalid non-integer number: ${value}`)\n        }\n      // fallthrough\n      default:\n        return value\n    }\n  })\n}\n\n/**\n * Parses a `Uint8Array` containing JSON data into a Lex value.\n */\nexport function lexParseJsonBytes(\n  jsonBytes: Uint8Array,\n  options?: LexParseOptions,\n): LexValue {\n  // @TODO optimize this to avoid intermediate string. This requires a custom\n  // JSON parser that can operate on binary data, which is non-trivial, but\n  // could be a future improvement if performance is a concern. See the link\n  // below for an example of a JSON parser that operates on binary data in\n  // @ipld/dag-json\n\n  // https://github.com/ipld/js-dag-json/blob/57912da6e9d64a179f7d2384c3b6d7b07fbfb143/src/index.js#L161\n\n  const jsonString = utf8FromBytes(jsonBytes)\n  return lexParse(jsonString, options)\n}\n\n/**\n * Converts a parsed JSON representation of Lexicon value to a {@link LexValue}.\n *\n * This function transforms already-parsed JSON objects into Lex values by\n * decoding AT Protocol special types:\n * - `{$link: string}` objects are converted to `Cid` instances\n * - `{$bytes: string}` objects are converted to `Uint8Array` instances\n *\n * Use this when you have a JavaScript object (e.g., from `JSON.parse()`) and\n * need to convert it to the Lex data model. For parsing JSON strings directly,\n * use {@link lexParse} instead.\n *\n * @param value - The JSON value to convert\n * @param options - Parsing options (e.g., strict mode)\n * @returns The converted Lex value\n * @throws {TypeError} If strict mode is enabled and invalid Lex values are found\n * @throws {TypeError} If the value contains unsupported types (e.g., undefined at top level)\n *\n * @example\n * ```typescript\n * import { jsonToLex } from '@atproto/lex'\n *\n * // Convert parsed JSON to Lex values\n * const lex = jsonToLex({\n *   ref: { $link: 'bafyrei...' },  // Converted to Cid\n *   data: { $bytes: 'SGVsbG8sIHdvcmxkIQ==' }  // Converted to Uint8Array\n * })\n * ```\n */\nexport function jsonToLex(\n  value: JsonValue,\n  options: LexParseOptions = { strict: false },\n): LexValue {\n  switch (typeof value) {\n    case 'object': {\n      if (value === null) return null\n      if (Array.isArray(value)) return jsonArrayToLex(value, options)\n      return (\n        parseSpecialJsonObject(value, options) ??\n        jsonObjectToLexMap(value, options)\n      )\n    }\n    case 'number':\n      if (Number.isSafeInteger(value)) return value\n      if (options.strict) {\n        throw new TypeError(`Invalid non-integer number: ${value}`)\n      }\n    // fallthrough\n    case 'boolean':\n    case 'string':\n      return value\n    default:\n      throw new TypeError(`Invalid JSON value: ${typeof value}`)\n  }\n}\n\nfunction jsonArrayToLex(\n  input: JsonValue[],\n  options: LexParseOptions,\n): LexValue[] {\n  // Lazily copy value\n  let copy: LexValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = jsonToLex(inputItem, options)\n    if (item !== inputItem) {\n      copy ??= Array.from(input)\n      copy[i] = item\n    }\n  }\n  return copy ?? input\n}\n\nfunction jsonObjectToLexMap(\n  input: JsonObject,\n  options: LexParseOptions,\n): LexMap {\n  // Lazily copy value\n  let copy: LexMap | undefined = undefined\n  for (const [key, jsonValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (jsonValue === undefined) {\n      copy ??= { ...input }\n      delete copy[key]\n      continue\n    }\n\n    const value = jsonToLex(jsonValue!, options)\n    if (value !== jsonValue) {\n      copy ??= { ...input }\n      copy[key] = value\n    }\n  }\n  return copy ?? input\n}\n\n/**\n * Converts a Lex value to a JSON-compatible value.\n *\n * This function transforms Lex data model values into plain JavaScript objects\n * suitable for JSON serialization:\n * - `Cid` instances are converted to `{$link: string}` objects\n * - `Uint8Array` instances are converted to `{$bytes: string}` objects (base64)\n *\n * Use this when you need to convert Lex values to plain objects (e.g., for\n * custom serialization or inspection). For direct JSON string output, use\n * {@link lexStringify} instead.\n *\n * @param value - The Lex value to convert\n * @returns The JSON-compatible value\n * @throws {TypeError} If the value contains unsupported types\n *\n * @example\n * ```typescript\n * import { lexToJson } from '@atproto/lex'\n *\n * // Convert Lex values to JSON-compatible objects\n * const obj = lexToJson({\n *   ref: someCid,      // Converted to { $link: string }\n *   data: someBytes    // Converted to { $bytes: string }\n * })\n * ```\n */\nexport function lexToJson(value: LexValue): JsonValue {\n  switch (typeof value) {\n    case 'object':\n      if (value === null) {\n        return value\n      } else if (Array.isArray(value)) {\n        return lexArrayToJson(value)\n      } else if (isCid(value)) {\n        return encodeLexLink(value)\n      } else if (ArrayBuffer.isView(value)) {\n        return encodeLexBytes(value)\n      } else {\n        return encodeLexMap(value)\n      }\n    case 'boolean':\n    case 'string':\n    case 'number':\n      return value\n    default:\n      throw new TypeError(`Invalid Lex value: ${typeof value}`)\n  }\n}\n\nfunction lexArrayToJson(input: LexArray): JsonValue[] {\n  // Lazily copy value\n  let copy: JsonValue[] | undefined\n  for (let i = 0; i < input.length; i++) {\n    const inputItem = input[i]\n    const item = lexToJson(inputItem)\n    if (item !== inputItem) {\n      copy ??= Array.from(input) as JsonValue[]\n      copy[i] = item\n    }\n  }\n  return copy ?? (input as JsonValue[])\n}\n\nfunction encodeLexMap(input: LexMap): JsonObject {\n  // Lazily copy value\n  let copy: JsonObject | undefined = undefined\n  for (const [key, lexValue] of Object.entries(input)) {\n    // Prevent prototype pollution\n    if (key === '__proto__') {\n      throw new TypeError('Invalid key: __proto__')\n    }\n\n    // Ignore (strip) undefined values\n    if (lexValue === undefined) {\n      copy ??= { ...input } as JsonObject\n      delete copy[key]\n      continue\n    }\n\n    const jsonValue = lexToJson(lexValue!)\n    if (jsonValue !== lexValue) {\n      copy ??= { ...input } as JsonObject\n      copy[key] = jsonValue\n    }\n  }\n  return copy ?? (input as JsonObject)\n}\n\nfunction parseSpecialJsonObject(\n  input: LexMap,\n  options: LexParseOptions,\n): Cid | Uint8Array | BlobRef | undefined {\n  // Hot path: use hints to avoid parsing when possible\n\n  if (input.$link !== undefined) {\n    const cid = parseLexLink(input)\n    if (cid) return cid\n    if (options.strict) throw new TypeError(`Invalid $link object`)\n  } else if (input.$bytes !== undefined) {\n    const bytes = parseLexBytes(input)\n    if (bytes) return bytes\n    if (options.strict) throw new TypeError(`Invalid $bytes object`)\n  } else if (input.$type !== undefined) {\n    // @NOTE Since blobs are \"just\" regular lex objects with a special shape,\n    // and because an object that does not conform to the blob shape would still\n    // result in undefined being returned, we only attempt to parse blobs when\n    // the strict option is enabled.\n    if (options.strict) {\n      if (input.$type === 'blob') {\n        const blob = parseTypedBlobRef(input, options)\n        if (blob) return blob\n        throw new TypeError(`Invalid blob object`)\n      } else if (typeof input.$type !== 'string') {\n        throw new TypeError(`Invalid $type property (${typeof input.$type})`)\n      } else if (input.$type.length === 0) {\n        throw new TypeError(`Empty $type property`)\n      }\n    }\n  }\n\n  // @NOTE We ignore legacy blob representation here. They can be handled at the\n  // application level if needed.\n\n  return undefined\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-json",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "license": "MIT",
   "description": "Lexicon encoding utilities for AT Lexicon data in JSON format",
   "keywords": [
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "tslib": "^2.8.1",
-    "@atproto/lex-data": "^0.0.14"
+    "@atproto/lex-data": "^0.0.15"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/blob.ts

@@ -1,8 +1,8 @@
 import {
-  BlobRef,
   BlobRefCheckOptions,
   LexMap,
-  isBlobRef,
+  TypedBlobRef,
+  isTypedBlobRef,
 } from '@atproto/lex-data'
 import { parseLexLink } from './link.js'
 
@@ -26,7 +26,7 @@ import { parseLexLink } from './link.js'
  * @example
  * ```typescript
  * // Parse a blob reference from JSON
- * const blobRef = parseBlobRef({
+ * const blobRef = parseTypedBlobRef({
  *   $type: 'blob',
  *   ref: { $link: 'bafyreib2rxk3rybloqtqwbo' },
  *   mimeType: 'image/png',
@@ -36,14 +36,14 @@ import { parseLexLink } from './link.js'
  * // blobRef.ref is a Cid instance
  *
  * // Returns undefined for non-blob objects
- * const result = parseBlobRef({ foo: 'bar' })
+ * const result = parseTypedBlobRef({ foo: 'bar' })
  * // result is undefined
  * ```
  */
-export function parseBlobRef(
+export function parseTypedBlobRef(
   input: LexMap,
   options?: BlobRefCheckOptions,
-): BlobRef | undefined {
+): TypedBlobRef | undefined {
   if (input.$type !== 'blob') return undefined
 
   const ref = input?.ref
@@ -59,10 +59,10 @@ export function parseBlobRef(
     if (!cid) return undefined
 
     const blob = { ...input, ref: cid }
-    if (isBlobRef(blob, options)) return blob
+    if (isTypedBlobRef(blob, options)) return blob
   }
 
-  if (isBlobRef(input)) {
+  if (isTypedBlobRef(input)) {
     return input
   }
 

package/src/lex-json.test.ts

@@ -1,7 +1,13 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { LexValue, lexEquals, parseCid } from '@atproto/lex-data'
 import { JsonValue } from './json.js'
-import { jsonToLex, lexParse, lexStringify, lexToJson } from './lex-json.js'
+import {
+  jsonToLex,
+  lexParse,
+  lexParseJsonBytes,
+  lexStringify,
+  lexToJson,
+} from './lex-json.js'
 
 export const validVectors: Array<{
   name: string
@@ -364,58 +370,143 @@ export const invalidVectors: Array<{
 
 describe(lexParse, () => {
   describe('valid vectors', () => {
-    for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('parses lex from string', () => {
+    describe('strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(
-            lexEquals(lex, lexParse(JSON.stringify(json), { strict: false })),
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: true })),
           ).toBe(true)
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(
-            lexEquals(lex, lexParse(JSON.stringify(json), { strict: true })),
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: false })),
           ).toBe(true)
         })
-      })
-    }
+      }
+    })
   })
 
   describe('acceptable vectors', () => {
-    for (const { note, json } of acceptableVectors) {
-      describe(note, () => {
-        it('parses lex from string in non-strict mode', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: true }),
+          ).toThrow()
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() =>
             lexParse(JSON.stringify(json), { strict: false }),
           ).not.toThrow()
         })
+      }
+    })
+  })
 
-        it('parses lex from string in strict mode', () => {
+  describe('invalid vectors', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() =>
             lexParse(JSON.stringify(json), { strict: true }),
           ).toThrow()
         })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: false }),
+          ).not.toThrow()
+        })
+      }
+    })
+  })
+})
+
+describe(lexParseJsonBytes, () => {
+  describe('valid vectors', () => {
+    describe('strict mode', () => {
+      describe('with pretty-printed JSON', () => {
+        for (const { name, json, lex } of validVectors) {
+          test(name, () => {
+            const jsonBytes = Buffer.from(JSON.stringify(json, undefined, 4))
+            expect(
+              lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: true })),
+            ).toBe(true)
+          })
+        }
       })
-    }
+      describe('with compact JSON', () => {
+        for (const { name, json, lex } of validVectors) {
+          test(name, () => {
+            const jsonBytes = Buffer.from(JSON.stringify(json))
+            expect(
+              lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: true })),
+            ).toBe(true)
+          })
+        }
+      })
+    })
+
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(
+            lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: false })),
+          ).toBe(true)
+        })
+      }
+    })
+  })
+
+  describe('acceptable vectors', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() => lexParseJsonBytes(jsonBytes, { strict: true })).toThrow()
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() =>
+            lexParseJsonBytes(jsonBytes, { strict: false }),
+          ).not.toThrow()
+        })
+      }
+    })
   })
 
   describe('invalid vectors', () => {
     describe('strict mode', () => {
       for (const { note, json } of invalidVectors) {
-        describe(note, () => {
-          it('throws when parsing malformed JSON', () => {
-            expect(() =>
-              lexParse(JSON.stringify(json), { strict: true }),
-            ).toThrow()
-          })
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() => lexParseJsonBytes(jsonBytes, { strict: true })).toThrow()
         })
       }
     })
     describe('non-strict mode', () => {
       for (const { note, json } of invalidVectors) {
-        describe(note, () => {
-          it('does not throws when parsing malformed JSON', () => {
-            expect(() =>
-              lexParse(JSON.stringify(json), { strict: false }),
-            ).not.toThrow()
-          })
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() =>
+            lexParseJsonBytes(jsonBytes, { strict: false }),
+          ).not.toThrow()
         })
       }
     })
@@ -425,10 +516,8 @@ describe(lexParse, () => {
 describe(lexStringify, () => {
   describe('valid vectors', () => {
     for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('stringifies lex to string', () => {
-          expect(JSON.parse(lexStringify(lex))).toEqual(json)
-        })
+      test(name, () => {
+        expect(JSON.parse(lexStringify(lex))).toStrictEqual(json)
       })
     }
   })
@@ -436,63 +525,66 @@ describe(lexStringify, () => {
 
 describe(jsonToLex, () => {
   describe('valid vectors', () => {
-    for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('converts json to lex (in strict mode)', () => {
+    describe('strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(lexEquals(jsonToLex(json, { strict: true }), lex)).toBe(true)
           expect(lexEquals(lex, jsonToLex(json, { strict: true }))).toBe(true)
         })
+      }
+    })
 
-        it('converts json to lex (in non-strict mode)', () => {
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(lexEquals(jsonToLex(json, { strict: false }), lex)).toBe(true)
           expect(lexEquals(lex, jsonToLex(json, { strict: false }))).toBe(true)
         })
-      })
-    }
+      }
+    })
   })
 
   describe('acceptable vectors', () => {
-    for (const { note, json } of acceptableVectors) {
-      describe(note, () => {
-        it('parses lex from json in strict mode', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: true })).toThrow()
         })
+      }
+    })
 
-        it('parses lex from json in non-strict mode', () => {
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: false })).not.toThrow()
         })
-      })
-    }
+      }
+    })
   })
 
   describe('invalid vectors', () => {
-    for (const { note, json } of invalidVectors) {
-      describe(note, () => {
-        it(`throws for malformed object`, () => {
+    describe('strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: true })).toThrow()
         })
-
-        it('throws for nested malformed object', () => {
-          expect(() => jsonToLex({ nested: json }, { strict: true })).toThrow()
-          expect(() => jsonToLex([json], { strict: true })).toThrow()
-        })
-
-        it('does not throw in non-strict mode', () => {
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: false })).not.toThrow()
         })
-      })
-    }
+      }
+    })
   })
 })
 
 describe(lexToJson, () => {
   describe('valid vectors', () => {
     for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('converts lex to json', () => {
-          expect(lexToJson(lex)).toEqual(json)
-          expect(lexToJson(lex)).toEqual(json)
-        })
+      test(name, () => {
+        expect(lexToJson(lex)).toStrictEqual(json)
       })
     }
   })
@@ -501,10 +593,19 @@ describe(lexToJson, () => {
 describe('json > lex > json', () => {
   describe('valid vectors', () => {
     for (const { name, json } of validVectors) {
-      describe(name, () => {
-        it('converts json to lex', () => {
-          expect(lexToJson(jsonToLex(json))).toEqual(json)
-        })
+      test(name, () => {
+        expect(lexToJson(jsonToLex(json))).toStrictEqual(json)
+      })
+    }
+  })
+})
+
+describe('json (binary) > lex > json', () => {
+  describe('valid vectors', () => {
+    for (const { name, json } of validVectors) {
+      test(name, () => {
+        const jsonBytes = Buffer.from(JSON.stringify(json, undefined, 4))
+        expect(lexToJson(lexParseJsonBytes(jsonBytes))).toStrictEqual(json)
       })
     }
   })
@@ -513,12 +614,9 @@ describe('json > lex > json', () => {
 describe('lex > json > lex', () => {
   describe('valid vectors', () => {
     for (const { name, lex } of validVectors) {
-      describe(name, () => {
-        it('converts lex to json', () => {
-          ;('')
-          expect(lexEquals(jsonToLex(lexToJson(lex)), lex)).toBe(true)
-          expect(lexEquals(lex, jsonToLex(lexToJson(lex)))).toBe(true)
-        })
+      test(name, () => {
+        expect(lexEquals(jsonToLex(lexToJson(lex)), lex)).toBe(true)
+        expect(lexEquals(lex, jsonToLex(lexToJson(lex)))).toBe(true)
       })
     }
   })

package/src/lex-json.ts

@@ -5,8 +5,9 @@ import {
   LexMap,
   LexValue,
   isCid,
+  utf8FromBytes,
 } from '@atproto/lex-data'
-import { parseBlobRef } from './blob.js'
+import { parseTypedBlobRef } from './blob.js'
 import { encodeLexBytes, parseLexBytes } from './bytes.js'
 import { JsonObject, JsonValue } from './json.js'
 import { encodeLexLink, parseLexLink } from './link.js'
@@ -117,6 +118,25 @@ export function lexParse<T extends LexValue = LexValue>(
   })
 }
 
+/**
+ * Parses a `Uint8Array` containing JSON data into a Lex value.
+ */
+export function lexParseJsonBytes(
+  jsonBytes: Uint8Array,
+  options?: LexParseOptions,
+): LexValue {
+  // @TODO optimize this to avoid intermediate string. This requires a custom
+  // JSON parser that can operate on binary data, which is non-trivial, but
+  // could be a future improvement if performance is a concern. See the link
+  // below for an example of a JSON parser that operates on binary data in
+  // @ipld/dag-json
+
+  // https://github.com/ipld/js-dag-json/blob/57912da6e9d64a179f7d2384c3b6d7b07fbfb143/src/index.js#L161
+
+  const jsonString = utf8FromBytes(jsonBytes)
+  return lexParse(jsonString, options)
+}
+
 /**
  * Converts a parsed JSON representation of Lexicon value to a {@link LexValue}.
  *
@@ -328,7 +348,7 @@ function parseSpecialJsonObject(
     // the strict option is enabled.
     if (options.strict) {
       if (input.$type === 'blob') {
-        const blob = parseBlobRef(input, options)
+        const blob = parseTypedBlobRef(input, options)
         if (blob) return blob
         throw new TypeError(`Invalid blob object`)
       } else if (typeof input.$type !== 'string') {