@atproto/lex-cbor 0.0.16 → 0.1.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atproto/lex-cbor
 
+## 0.1.0-next.0
+
+### Minor Changes
+
+- [#4929](https://github.com/bluesky-social/atproto/pull/4929) [`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Drop support for Node.js 18 and 20. Node.js 22 is now the minimum supported version. Docker images now use Node.js 24.
+
+- [#4943](https://github.com/bluesky-social/atproto/pull/4943) [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Convert to pure ESM. All packages now ship `"type": "module"` with ES module output and Node16 module resolution.
+
+  Node.js 22's `require()` compatibility layer can still load these packages in CommonJS code.
+
+- [#4930](https://github.com/bluesky-social/atproto/pull/4930) [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9) Thanks [@devinivy](https://github.com/devinivy)! - Build with TypeScript 6.0. Emitted `.d.ts` files now use TypeScript 6's stricter `Uint8Array<ArrayBuffer>` typing in places where Web/Node APIs require buffer-backed (not shared-memory) byte arrays. Consumers compiling against these types on older TypeScript should see no runtime impact, but may need to widen or cast in spots that previously relied on `Uint8Array` defaulting to `<ArrayBufferLike>`.
+
+  Internal: tsconfig `moduleResolution: "node"` is silenced via `ignoreDeprecations: "6.0"` for now; the proper migration to `node16`/`bundler` resolution is deferred.
+
+### Patch Changes
+
+- Updated dependencies [[`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b), [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028), [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9)]:
+  - @atproto/lex-data@0.1.0-next.0
+
 ## 0.0.16
 
 ### Patch Changes

package/dist/encoding.d.ts

@@ -9,12 +9,12 @@ import { LexValue } from '@atproto/lex-data';
  * - `undefined` values are not permitted (undefined object properties will be stripped)
  * - Only safe integer numbers are allowed (no floats or non-integer values)
  */
-export declare const encodeOptions: Readonly<import("cborg/interface").EncodeOptions>;
+export declare const encodeOptions: any;
 /**
  * Configuration options for CBOR decoding that enforces AT Protocol data model
  * constraints.
  */
-export declare const decodeOptions: Readonly<import("cborg/interface").DecodeOptions>;
+export declare const decodeOptions: any;
 /**
  * Encodes a LexValue to CBOR bytes using the AT Protocol data model (DRISL format).
  *

package/dist/encoding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AAWA,OAAO,EAAO,QAAQ,EAAoB,MAAM,mBAAmB,CAAA;AASnE;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,mDAsCxB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,mDAoBxB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAEzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,CAE1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAiB,SAAS,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EACtD,IAAI,EAAE,UAAU,GACf,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAM7B"}
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AAWA,OAAO,EAAO,QAAQ,EAAoB,MAAM,mBAAmB,CAAA;AASnE;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,KAsCxB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,KAoBxB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAEzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,CAE1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAiB,SAAS,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EACtD,IAAI,EAAE,UAAU,GACf,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAM7B"}

package/dist/encoding.js

@@ -0,0 +1,167 @@
+import { Token, Type, decode as cborgDecode, decodeFirst as cborgDecodeFirst, encode as cborgEncode, } from 'cborg';
+import { decodeCid, ifCid } from '@atproto/lex-data';
+// @NOTE "cborg" version 4 is required to support multi-decoding via the
+// "decodeFirst" function. However, that version only exposes ES modules.
+// Because this package is using "commonjs", "cborg" will be bundled instead of
+// depending on it directly.
+const CID_CBOR_TAG = 42;
+/**
+ * Configuration options for CBOR encoding that enforces AT Protocol data model
+ * constraints.
+ *
+ * This configuration ensures:
+ * - CIDs are encoded using CBOR tag 42 with a leading 0x00 byte prefix
+ * - Map keys must be strings (no numeric or other key types allowed)
+ * - `undefined` values are not permitted (undefined object properties will be stripped)
+ * - Only safe integer numbers are allowed (no floats or non-integer values)
+ */
+export const encodeOptions = Object.freeze({
+    float64: true,
+    ignoreUndefinedProperties: true,
+    typeEncoders: Object.freeze({
+        Map: (map) => {
+            for (const key of map.keys()) {
+                if (typeof key !== 'string') {
+                    throw new Error('Only string keys are allowed in CBOR "map" by the AT Data Model');
+                }
+            }
+            // @NOTE Maps will be encoded as CBOR "map", which will be decoded as object.
+            return null;
+        },
+        Object: (obj) => {
+            const cid = ifCid(obj);
+            if (cid) {
+                const bytes = new Uint8Array(cid.bytes.byteLength + 1);
+                bytes.set(cid.bytes, 1); // prefix is 0x00, for historical reasons
+                return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)];
+            }
+            // Fallback to default object encoder
+            return null;
+        },
+        undefined: () => {
+            throw new Error('`undefined` is not supported by the AT Data Model');
+        },
+        number: (num) => {
+            if (Number.isSafeInteger(num))
+                return null;
+            throw new Error(`Non-integer numbers (${num}) are not supported by the AT Data Model`);
+        },
+    }),
+});
+/**
+ * Configuration options for CBOR decoding that enforces AT Protocol data model
+ * constraints.
+ */
+export const decodeOptions = /*#__PURE__*/ Object.freeze({
+    allowIndefinite: false,
+    coerceUndefinedToNull: true,
+    allowNaN: false,
+    allowInfinity: false,
+    allowBigInt: true,
+    strict: true,
+    useMaps: false,
+    rejectDuplicateMapKeys: true,
+    tags: /*#__PURE__*/ Object.freeze(
+    /*#__PURE__*/ Object.assign([], {
+        [CID_CBOR_TAG]: (bytes) => {
+            if (bytes[0] !== 0) {
+                throw new Error('Invalid CID for CBOR tag 42; expected leading 0x00');
+            }
+            const cibBytes = bytes.subarray(1); // ignore leading 0x00
+            return decodeCid(cibBytes);
+        },
+    })),
+});
+/**
+ * Encodes a LexValue to CBOR bytes using the AT Protocol data model (DRISL format).
+ *
+ * @param data - The LexValue to encode
+ * @returns The CBOR-encoded bytes
+ * @throws {Error} If the data contains non-string map keys, undefined values, or non-integer numbers
+ *
+ * @example
+ * ```typescript
+ * import { encode } from '@atproto/lex-cbor'
+ *
+ * // Encode a simple object
+ * const bytes = encode({ text: 'Hello', count: 42 })
+ *
+ * // Encode an AT Protocol record
+ * const recordBytes = encode({
+ *   $type: 'app.bsky.feed.post',
+ *   text: 'Hello from AT Protocol!',
+ *   createdAt: new Date().toISOString(),
+ * })
+ * ```
+ */
+export function encode(data) {
+    return cborgEncode(data, encodeOptions);
+}
+/**
+ * Decodes CBOR bytes to a LexValue using the AT Protocol data model (DRISL format).
+ *
+ * @typeParam T - Allows casting the decoded values to a specific LexValue subtype
+ * @param bytes - The CBOR bytes to decode
+ * @returns The decoded LexValue
+ * @throws {Error} If the bytes are not valid CBOR or violate AT Protocol constraints
+ *
+ * @example
+ * ```typescript
+ * import { encode, decode } from '@atproto/lex-cbor'
+ * import type { LexValue } from '@atproto/lex'
+ *
+ * // Round-trip encoding and decoding
+ * const original = { text: 'Hello', count: 42 }
+ * const bytes = encode(original)
+ * const decoded: LexValue = decode(bytes)
+ *
+ * // Decode with a specific type
+ * interface Post {
+ *   $type: string
+ *   text: string
+ *   createdAt: string
+ * }
+ * const post = decode<Post>(recordBytes)
+ * ```
+ */
+export function decode(bytes) {
+    return cborgDecode(bytes, decodeOptions);
+}
+/**
+ * Generator that yields multiple decoded LexValues from a buffer containing
+ * concatenated CBOR-encoded values.
+ *
+ * This is useful for processing streams or files containing multiple
+ * CBOR-encoded records back-to-back (e.g., CAR file blocks or event streams).
+ *
+ * @typeParam T - Allows casting the decoded values to a specific LexValue subtype
+ * @param data - The buffer containing one or more CBOR-encoded values
+ * @yields Decoded LexValues one at a time
+ * @throws {Error} If any value in the buffer is not valid CBOR or violates AT Protocol constraints
+ *
+ * @example
+ * ```typescript
+ * import { encode, decodeAll } from '@atproto/lex-cbor'
+ *
+ * // Concatenate multiple encoded values
+ * const bytes1 = encode({ id: 1, text: 'First' })
+ * const bytes2 = encode({ id: 2, text: 'Second' })
+ * const combined = new Uint8Array([...bytes1, ...bytes2])
+ *
+ * // Decode all values from the combined buffer
+ * for (const value of decodeAll(combined)) {
+ *   console.log(value)
+ * }
+ * // Output:
+ * // { id: 1, text: 'First' }
+ * // { id: 2, text: 'Second' }
+ * ```
+ */
+export function* decodeAll(data) {
+    do {
+        const [result, remainingBytes] = cborgDecodeFirst(data, decodeOptions);
+        yield result;
+        data = remainingBytes;
+    } while (data.byteLength > 0);
+}
+//# sourceMappingURL=encoding.js.map

package/dist/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DecodeOptions,\n  EncodeOptions,\n  TagDecoder,\n  Token,\n  Type,\n  decode as cborgDecode,\n  decodeFirst as cborgDecodeFirst,\n  encode as cborgEncode,\n} from 'cborg'\nimport { OptionalTypeEncoder } from 'cborg/interface'\nimport { Cid, LexValue, decodeCid, ifCid } from '@atproto/lex-data'\n\n// @NOTE \"cborg\" version 4 is required to support multi-decoding via the\n// \"decodeFirst\" function. However, that version only exposes ES modules.\n// Because this package is using \"commonjs\", \"cborg\" will be bundled instead of\n// depending on it directly.\n\nconst CID_CBOR_TAG = 42\n\n/**\n * Configuration options for CBOR encoding that enforces AT Protocol data model\n * constraints.\n *\n * This configuration ensures:\n * - CIDs are encoded using CBOR tag 42 with a leading 0x00 byte prefix\n * - Map keys must be strings (no numeric or other key types allowed)\n * - `undefined` values are not permitted (undefined object properties will be stripped)\n * - Only safe integer numbers are allowed (no floats or non-integer values)\n */\nexport const encodeOptions = Object.freeze<EncodeOptions>({\n  float64: true,\n  ignoreUndefinedProperties: true,\n  typeEncoders: Object.freeze<{ [typeName: string]: OptionalTypeEncoder }>({\n    Map: (map: Map<unknown, unknown>): null => {\n      for (const key of map.keys()) {\n        if (typeof key !== 'string') {\n          throw new Error(\n            'Only string keys are allowed in CBOR \"map\" by the AT Data Model',\n          )\n        }\n      }\n\n      // @NOTE Maps will be encoded as CBOR \"map\", which will be decoded as object.\n      return null\n    },\n    Object: (obj: object): Token[] | null => {\n      const cid = ifCid(obj)\n      if (cid) {\n        const bytes = new Uint8Array(cid.bytes.byteLength + 1)\n        bytes.set(cid.bytes, 1) // prefix is 0x00, for historical reasons\n        return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)]\n      }\n\n      // Fallback to default object encoder\n      return null\n    },\n    undefined: (): null => {\n      throw new Error('`undefined` is not supported by the AT Data Model')\n    },\n    number: (num: number): null => {\n      if (Number.isSafeInteger(num)) return null\n\n      throw new Error(\n        `Non-integer numbers (${num}) are not supported by the AT Data Model`,\n      )\n    },\n  }),\n})\n\n/**\n * Configuration options for CBOR decoding that enforces AT Protocol data model\n * constraints.\n */\nexport const decodeOptions = /*#__PURE__*/ Object.freeze<DecodeOptions>({\n  allowIndefinite: false,\n  coerceUndefinedToNull: true,\n  allowNaN: false,\n  allowInfinity: false,\n  allowBigInt: true,\n  strict: true,\n  useMaps: false,\n  rejectDuplicateMapKeys: true,\n  tags: /*#__PURE__*/ Object.freeze<TagDecoder[]>(\n    /*#__PURE__*/ Object.assign([], {\n      [CID_CBOR_TAG]: (bytes: Uint8Array): Cid => {\n        if (bytes[0] !== 0) {\n          throw new Error('Invalid CID for CBOR tag 42; expected leading 0x00')\n        }\n        const cibBytes = bytes.subarray(1) // ignore leading 0x00\n        return decodeCid(cibBytes)\n      },\n    }),\n  ) as TagDecoder[],\n})\n\n/**\n * Encodes a LexValue to CBOR bytes using the AT Protocol data model (DRISL format).\n *\n * @param data - The LexValue to encode\n * @returns The CBOR-encoded bytes\n * @throws {Error} If the data contains non-string map keys, undefined values, or non-integer numbers\n *\n * @example\n * ```typescript\n * import { encode } from '@atproto/lex-cbor'\n *\n * // Encode a simple object\n * const bytes = encode({ text: 'Hello', count: 42 })\n *\n * // Encode an AT Protocol record\n * const recordBytes = encode({\n *   $type: 'app.bsky.feed.post',\n *   text: 'Hello from AT Protocol!',\n *   createdAt: new Date().toISOString(),\n * })\n * ```\n */\nexport function encode<T extends LexValue = LexValue>(data: T): Uint8Array {\n  return cborgEncode(data, encodeOptions)\n}\n\n/**\n * Decodes CBOR bytes to a LexValue using the AT Protocol data model (DRISL format).\n *\n * @typeParam T - Allows casting the decoded values to a specific LexValue subtype\n * @param bytes - The CBOR bytes to decode\n * @returns The decoded LexValue\n * @throws {Error} If the bytes are not valid CBOR or violate AT Protocol constraints\n *\n * @example\n * ```typescript\n * import { encode, decode } from '@atproto/lex-cbor'\n * import type { LexValue } from '@atproto/lex'\n *\n * // Round-trip encoding and decoding\n * const original = { text: 'Hello', count: 42 }\n * const bytes = encode(original)\n * const decoded: LexValue = decode(bytes)\n *\n * // Decode with a specific type\n * interface Post {\n *   $type: string\n *   text: string\n *   createdAt: string\n * }\n * const post = decode<Post>(recordBytes)\n * ```\n */\nexport function decode<T extends LexValue = LexValue>(bytes: Uint8Array): T {\n  return cborgDecode(bytes, decodeOptions)\n}\n\n/**\n * Generator that yields multiple decoded LexValues from a buffer containing\n * concatenated CBOR-encoded values.\n *\n * This is useful for processing streams or files containing multiple\n * CBOR-encoded records back-to-back (e.g., CAR file blocks or event streams).\n *\n * @typeParam T - Allows casting the decoded values to a specific LexValue subtype\n * @param data - The buffer containing one or more CBOR-encoded values\n * @yields Decoded LexValues one at a time\n * @throws {Error} If any value in the buffer is not valid CBOR or violates AT Protocol constraints\n *\n * @example\n * ```typescript\n * import { encode, decodeAll } from '@atproto/lex-cbor'\n *\n * // Concatenate multiple encoded values\n * const bytes1 = encode({ id: 1, text: 'First' })\n * const bytes2 = encode({ id: 2, text: 'Second' })\n * const combined = new Uint8Array([...bytes1, ...bytes2])\n *\n * // Decode all values from the combined buffer\n * for (const value of decodeAll(combined)) {\n *   console.log(value)\n * }\n * // Output:\n * // { id: 1, text: 'First' }\n * // { id: 2, text: 'Second' }\n * ```\n */\nexport function* decodeAll<T extends LexValue = LexValue>(\n  data: Uint8Array,\n): Generator<T, void, unknown> {\n  do {\n    const [result, remainingBytes] = cborgDecodeFirst(data, decodeOptions)\n    yield result\n    data = remainingBytes\n  } while (data.byteLength > 0)\n}\n"]}

package/dist/index.js

@@ -0,0 +1,32 @@
+import { cidForCbor } from '@atproto/lex-data';
+import { encode } from './encoding.js';
+export { decode, decodeAll, encode } from './encoding.js';
+export { decode as cborDecode, decodeAll as cborDecodeAll, decodeOptions, encode as cborEncode, encodeOptions, } from './encoding.js';
+/**
+ * Computes a CID (Content Identifier) for a given LexValue.
+ *
+ * This function first encodes the value to CBOR bytes using the AT Protocol
+ * data model constraints, then computes the CID hash of those bytes. The
+ * resulting CID can be used to uniquely identify and reference the content.
+ *
+ * @param value - The LexValue to compute a CID for
+ * @returns A promise that resolves to the CID for the CBOR-encoded value
+ *
+ * @example
+ * ```typescript
+ * import { cidForLex } from '@atproto/lex-cbor'
+ *
+ * const record = {
+ *   $type: 'app.bsky.feed.post',
+ *   text: 'Hello, AT Protocol!',
+ *   createdAt: new Date().toISOString(),
+ * }
+ *
+ * const cid = await cidForLex(record)
+ * console.log(cid.toString()) // e.g., 'bafyreih...'
+ * ```
+ */
+export async function cidForLex(value) {
+    return cidForCbor(encode(value));
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAKtC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEzD,OAAO,EACL,MAAM,IAAI,UAAU,EACpB,SAAS,IAAI,aAAa,EAC1B,aAAa,EACb,MAAM,IAAI,UAAU,EACpB,aAAa,GACd,MAAM,eAAe,CAAA;AAEtB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,KAAe;IAC7C,OAAO,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;AAClC,CAAC","sourcesContent":["import { CborCid, LexValue, cidForCbor } from '@atproto/lex-data'\nimport { encode } from './encoding.js'\n\nexport type { Cid } from '@atproto/lex-data'\nexport type { CborCid, LexValue }\n\nexport { decode, decodeAll, encode } from './encoding.js'\n\nexport {\n  decode as cborDecode,\n  decodeAll as cborDecodeAll,\n  decodeOptions,\n  encode as cborEncode,\n  encodeOptions,\n} from './encoding.js'\n\n/**\n * Computes a CID (Content Identifier) for a given LexValue.\n *\n * This function first encodes the value to CBOR bytes using the AT Protocol\n * data model constraints, then computes the CID hash of those bytes. The\n * resulting CID can be used to uniquely identify and reference the content.\n *\n * @param value - The LexValue to compute a CID for\n * @returns A promise that resolves to the CID for the CBOR-encoded value\n *\n * @example\n * ```typescript\n * import { cidForLex } from '@atproto/lex-cbor'\n *\n * const record = {\n *   $type: 'app.bsky.feed.post',\n *   text: 'Hello, AT Protocol!',\n *   createdAt: new Date().toISOString(),\n * }\n *\n * const cid = await cidForLex(record)\n * console.log(cid.toString()) // e.g., 'bafyreih...'\n * ```\n */\nexport async function cidForLex(value: LexValue): Promise<CborCid> {\n  return cidForCbor(encode(value))\n}\n"]}

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@atproto/lex-cbor",
-  "version": "0.0.16",
+  "version": "0.1.0-next.0",
+  "engines": {
+    "node": ">=22"
+  },
   "license": "MIT",
   "description": "Lexicon encoding utilities for AT Lexicon data in CBOR format",
   "keywords": [
@@ -26,31 +29,23 @@
     "./CHANGELOG.md"
   ],
   "sideEffects": false,
-  "type": "commonjs",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "browser": "./dist/index.mjs",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.cjs"
+      "default": "./dist/index.js"
     }
   },
   "dependencies": {
+    "cborg": "^4.5.8",
     "tslib": "^2.8.1",
-    "@atproto/lex-data": "^0.0.15"
+    "@atproto/lex-data": "^0.1.0-next.0"
   },
   "devDependencies": {
-    "cborg": "^4.5.8",
-    "vite": "^6.2.0",
     "vitest": "^4.0.16",
-    "@atproto/lex-json": "^0.0.15"
+    "@atproto/lex-json": "^0.1.0-next.0"
   },
   "scripts": {
-    "dev": "vite build --watch",
-    "prebuild": "vite build --emptyOutDir",
     "build": "tsc --build tsconfig.build.json",
     "test": "vitest run"
   }

package/src/encoding.ts

@@ -8,7 +8,7 @@ import {
   decodeFirst as cborgDecodeFirst,
   encode as cborgEncode,
 } from 'cborg'
-import { OptionalTypeEncoder } from 'cborg/lib/encode'
+import { OptionalTypeEncoder } from 'cborg/interface'
 import { Cid, LexValue, decodeCid, ifCid } from '@atproto/lex-data'
 
 // @NOTE "cborg" version 4 is required to support multi-decoding via the

package/tsconfig.build.json

@@ -5,7 +5,6 @@
   "compilerOptions": {
     "noImplicitAny": true,
     "importHelpers": true,
-    "emitDeclarationOnly": true,
     "rootDir": "./src",
     "outDir": "./dist"
   }