@atproto/common 0.0.0-spaces-alpha-20260818021221

package/dist/ipld.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+import { Transform } from 'node:stream';
+import { encode as encodeBlock } from 'multiformats/block';
+import { sha256 as hasher } from 'multiformats/hashes/sha2';
+import { cidForLex, decode, encode } from '@atproto/lex-cbor';
+import { CBOR_DATA_CODEC, asMultiformatsCID, 
+// eslint-disable-next-line
+cidForCbor, cidForRawHash, decodeCid, isCidForBytes, isTypedLexMap, validateCidString, } from '@atproto/lex-data';
+/**
+ * @deprecated Use {@link encode} from `@atproto/lex-cbor` instead.
+ */
+const cborEncodeLegacy = encode;
+export { cborEncodeLegacy as cborEncode };
+/**
+ * @deprecated Use {@link decode} from `@atproto/lex-cbor` instead.
+ */
+const cborDecodeLegacy = decode;
+export { cborDecodeLegacy as cborDecode };
+/**
+ * @deprecated Use {@link encode} and {@link cidForCbor} from `@atproto/lex-cbor` instead.
+ */
+export async function dataToCborBlock(value) {
+    return encodeBlock({
+        value,
+        codec: {
+            name: 'at-cbor', // Not actually used
+            code: CBOR_DATA_CODEC,
+            encode: encode,
+        },
+        hasher,
+    });
+}
+/**
+ * @deprecated Use {@link cidForLex} from `@atproto/lex-cbor` instead.
+ */
+async function cidForCborLegacy(data) {
+    return asMultiformatsCID(await cidForLex(data));
+}
+export { cidForCborLegacy as cidForCbor };
+/**
+ * @deprecated Use {@link validateCidString} from '@atproto/lex-data' instead.
+ */
+export async function isValidCid(cidStr) {
+    // @NOTE we keep the wrapper function to return a Promise (for backward
+    // compatibility).
+    return validateCidString(cidStr);
+}
+/**
+ * @deprecated Use {@link decode} from `@atproto/lex-cbor`, and {@link isTypedLexMap} from `@atproto/lex-data` instead.
+ */
+export function cborBytesToRecord(bytes) {
+    const data = decode(bytes);
+    if (isTypedLexMap(data))
+        return data;
+    throw new Error(`Expected record with $type property`);
+}
+/**
+ * @deprecated Use {@link isCidForBytes} from `@atproto/lex-cbor` instead.
+ */
+export async function verifyCidForBytes(cid, bytes) {
+    if (!(await isCidForBytes(cid, bytes))) {
+        throw new Error(`Not a valid CID for bytes (${cid.toString()})`);
+    }
+}
+/**
+ * @deprecated Use {@link cidForRawHash} from `@atproto/lex-cbor` instead.
+ */
+export function sha256RawToCid(hash) {
+    return asMultiformatsCID(cidForRawHash(hash));
+}
+/**
+ * @deprecated Use {@link decodeCid} from `@atproto/lex-cbor` instead.
+ */
+export function parseCidFromBytes(bytes) {
+    return asMultiformatsCID(decodeCid(bytes, { flavor: 'dasl' }));
+}
+export class VerifyCidTransform extends Transform {
+    constructor(cid) {
+        const hasher = createHash('sha256');
+        super({
+            transform(chunk, encoding, callback) {
+                hasher.update(chunk);
+                callback(null, chunk);
+            },
+            flush(callback) {
+                try {
+                    const actual = sha256RawToCid(hasher.digest());
+                    if (actual.equals(cid)) {
+                        return callback();
+                    }
+                    else {
+                        return callback(new VerifyCidError(cid, actual));
+                    }
+                }
+                catch (err) {
+                    return callback(asError(err));
+                }
+            },
+        });
+        this.cid = cid;
+    }
+}
+const asError = (err) => err instanceof Error ? err : new Error('Unexpected error', { cause: err });
+export class VerifyCidError extends Error {
+    constructor(expected, actual) {
+        super('Bad cid check');
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+//# sourceMappingURL=ipld.js.map

package/dist/ipld.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipld.js","sourceRoot":"","sources":["../src/ipld.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto'\nimport { Transform } from 'node:stream'\nimport { encode as encodeBlock } from 'multiformats/block'\nimport type { BlockView, ByteView } from 'multiformats/block/interface'\nimport { sha256 as hasher } from 'multiformats/hashes/sha2'\nimport { cidForLex, decode, encode } from '@atproto/lex-cbor'\nimport {\n  CBOR_DATA_CODEC,\n  type CID,\n  type Cid,\n  type LexValue,\n  asMultiformatsCID,\n  // eslint-disable-next-line\n  cidForCbor,\n  cidForRawHash,\n  decodeCid,\n  isCidForBytes,\n  isTypedLexMap,\n  validateCidString,\n} from '@atproto/lex-data'\n\n/**\n * @deprecated Use {@link encode} from `@atproto/lex-cbor` instead.\n */\nconst cborEncodeLegacy = encode as <T = unknown>(data: T) => ByteView<T>\nexport { cborEncodeLegacy as cborEncode }\n\n/**\n * @deprecated Use {@link decode} from `@atproto/lex-cbor` instead.\n */\nconst cborDecodeLegacy = decode as <T = unknown>(bytes: ByteView<T>) => T\nexport { cborDecodeLegacy as cborDecode }\n\n/**\n * @deprecated Use {@link encode} and {@link cidForCbor} from `@atproto/lex-cbor` instead.\n */\nexport async function dataToCborBlock<T>(\n  value: T,\n): Promise<BlockView<T, 0x71, 0x12, 1>> {\n  return encodeBlock<T, 0x71, 0x12>({\n    value,\n    codec: {\n      name: 'at-cbor', // Not actually used\n      code: CBOR_DATA_CODEC,\n      encode: encode as (data: T) => ByteView<T>,\n    },\n    hasher,\n  })\n}\n\n/**\n * @deprecated Use {@link cidForLex} from `@atproto/lex-cbor` instead.\n */\nasync function cidForCborLegacy(data: unknown): Promise<CID> {\n  return asMultiformatsCID(await cidForLex(data as LexValue))\n}\nexport { cidForCborLegacy as cidForCbor }\n\n/**\n * @deprecated Use {@link validateCidString} from '@atproto/lex-data' instead.\n */\nexport async function isValidCid(cidStr: string): Promise<boolean> {\n  // @NOTE we keep the wrapper function to return a Promise (for backward\n  // compatibility).\n  return validateCidString(cidStr)\n}\n\n/**\n * @deprecated Use {@link decode} from `@atproto/lex-cbor`, and {@link isTypedLexMap} from `@atproto/lex-data` instead.\n */\nexport function cborBytesToRecord(bytes: Uint8Array): Record<string, unknown> {\n  const data = decode(bytes) as LexValue\n  if (isTypedLexMap(data)) return data\n\n  throw new Error(`Expected record with $type property`)\n}\n\n/**\n * @deprecated Use {@link isCidForBytes} from `@atproto/lex-cbor` instead.\n */\nexport async function verifyCidForBytes(\n  cid: Cid,\n  bytes: Uint8Array,\n): Promise<void> {\n  if (!(await isCidForBytes(cid, bytes))) {\n    throw new Error(`Not a valid CID for bytes (${cid.toString()})`)\n  }\n}\n\n/**\n * @deprecated Use {@link cidForRawHash} from `@atproto/lex-cbor` instead.\n */\nexport function sha256RawToCid(hash: Uint8Array): CID {\n  return asMultiformatsCID(cidForRawHash(hash))\n}\n\n/**\n * @deprecated Use {@link decodeCid} from `@atproto/lex-cbor` instead.\n */\nexport function parseCidFromBytes(bytes: Uint8Array): CID {\n  return asMultiformatsCID(decodeCid(bytes, { flavor: 'dasl' }))\n}\n\nexport class VerifyCidTransform extends Transform {\n  constructor(public cid: Cid) {\n    const hasher = createHash('sha256')\n    super({\n      transform(chunk, encoding, callback) {\n        hasher.update(chunk)\n        callback(null, chunk)\n      },\n      flush(callback) {\n        try {\n          const actual = sha256RawToCid(hasher.digest())\n          if (actual.equals(cid)) {\n            return callback()\n          } else {\n            return callback(new VerifyCidError(cid, actual))\n          }\n        } catch (err) {\n          return callback(asError(err))\n        }\n      },\n    })\n  }\n}\n\nconst asError = (err: unknown): Error =>\n  err instanceof Error ? err : new Error('Unexpected error', { cause: err })\n\nexport class VerifyCidError extends Error {\n  constructor(\n    public expected: Cid,\n    public actual: Cid,\n  ) {\n    super('Bad cid check')\n  }\n}\n"]}

package/dist/logger.d.ts

@@ -0,0 +1,16 @@
+import { type Logger, type SerializerFn } from 'pino';
+export declare function createLogger(name: string, options?: {
+    serializers?: {
+        [key: string]: SerializerFn;
+    };
+    msgPrefix?: string;
+}): Logger;
+/**
+ * @deprecated The use of singleton loggers is deprecated as they don't allow
+ * for proper configuration of serializers, and are not really used across the
+ * "atproto" mono repo. Indeed, whenever used, loggers are created and
+ * re-exported from a central place, achieving the same effect as a singleton
+ * logger, but with more flexibility. Use {@link createLogger} instead.
+ */
+export declare function subsystemLogger(name: string): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAqB,MAAM,MAAM,CAAA;AAcxE,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IACR,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAA;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GACA,MAAM,CAOR;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpD"}

package/dist/logger.js

@@ -0,0 +1,31 @@
+import { destination, pino } from 'pino';
+const enabled = /^(true|t|1)$/i.test(process.env.LOG_ENABLED ?? '0');
+const dest = process.env.LOG_DESTINATION;
+const level = process.env.LOG_LEVEL || 'info';
+const systems = process.env.LOG_SYSTEMS?.trim()
+    ? process.env.LOG_SYSTEMS.replace(',', ' ').split(/\s+/).filter(Boolean)
+    : null;
+const rootLogger = /*#__PURE__*/ pino({ enabled, level }, dest ? destination(dest) : undefined);
+export function createLogger(name, options) {
+    // can't disable child loggers, so we just set their level to "silent"
+    // to effectively turn them off
+    const subsystemEnabled = !systems || systems.includes(name);
+    const subsystemLevel = enabled && subsystemEnabled ? level : 'silent';
+    return rootLogger.child({ name }, { ...options, level: subsystemLevel });
+}
+const subsystems = new Map();
+/**
+ * @deprecated The use of singleton loggers is deprecated as they don't allow
+ * for proper configuration of serializers, and are not really used across the
+ * "atproto" mono repo. Indeed, whenever used, loggers are created and
+ * re-exported from a central place, achieving the same effect as a singleton
+ * logger, but with more flexibility. Use {@link createLogger} instead.
+ */
+export function subsystemLogger(name) {
+    if (subsystems.has(name))
+        return subsystems.get(name);
+    const logger = createLogger(name);
+    subsystems.set(name, logger);
+    return logger;
+}
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,WAAW,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAExE,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,CAAA;AACpE,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAA;AACxC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,MAAM,CAAA;AAC7C,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,EAAE;IAC7C,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;IACxE,CAAC,CAAC,IAAI,CAAA;AAER,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CACnC,EAAE,OAAO,EAAE,KAAK,EAAE,EAClB,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CACrC,CAAA;AAED,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,OAGC;IAED,sEAAsE;IACtE,+BAA+B;IAC/B,MAAM,gBAAgB,GAAG,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC3D,MAAM,cAAc,GAAG,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAA;IAErE,OAAO,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAA;AAC1E,CAAC;AAED,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAA;AAE5C;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAE,CAAA;IACtD,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;IACjC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAC5B,OAAO,MAAM,CAAA;AACf,CAAC","sourcesContent":["import { type Logger, type SerializerFn, destination, pino } from 'pino'\n\nconst enabled = /^(true|t|1)$/i.test(process.env.LOG_ENABLED ?? '0')\nconst dest = process.env.LOG_DESTINATION\nconst level = process.env.LOG_LEVEL || 'info'\nconst systems = process.env.LOG_SYSTEMS?.trim()\n  ? process.env.LOG_SYSTEMS.replace(',', ' ').split(/\\s+/).filter(Boolean)\n  : null\n\nconst rootLogger = /*#__PURE__*/ pino(\n  { enabled, level },\n  dest ? destination(dest) : undefined,\n)\n\nexport function createLogger(\n  name: string,\n  options?: {\n    serializers?: { [key: string]: SerializerFn }\n    msgPrefix?: string\n  },\n): Logger {\n  // can't disable child loggers, so we just set their level to \"silent\"\n  // to effectively turn them off\n  const subsystemEnabled = !systems || systems.includes(name)\n  const subsystemLevel = enabled && subsystemEnabled ? level : 'silent'\n\n  return rootLogger.child({ name }, { ...options, level: subsystemLevel })\n}\n\nconst subsystems = new Map<string, Logger>()\n\n/**\n * @deprecated The use of singleton loggers is deprecated as they don't allow\n * for proper configuration of serializers, and are not really used across the\n * \"atproto\" mono repo. Indeed, whenever used, loggers are created and\n * re-exported from a central place, achieving the same effect as a singleton\n * logger, but with more flexibility. Use {@link createLogger} instead.\n */\nexport function subsystemLogger(name: string): Logger {\n  if (subsystems.has(name)) return subsystems.get(name)!\n  const logger = createLogger(name)\n  subsystems.set(name, logger)\n  return logger\n}\n"]}

package/dist/obfuscate.d.ts

@@ -0,0 +1,9 @@
+export declare function obfuscateEmail(email: string): string;
+export declare function obfuscateWord(word: string): string;
+export declare function obfuscateHeaders(headers: Record<string, string>): Record<string, string>;
+export declare function obfuscateAuthHeader(authHeader: string): string;
+export declare function obfuscateBasic(token: string): null | string;
+export declare function obfuscateBearer(token: string): string;
+export declare function obfuscateToken(token: string): string;
+export declare function obfuscateJwt(token: string): null | string;
+//# sourceMappingURL=obfuscate.d.ts.map

package/dist/obfuscate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obfuscate.d.ts","sourceRoot":"","sources":["../src/obfuscate.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,UAG3C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,UAEzC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,0BAY/D;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAgB9D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAS3D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAuBzD"}

package/dist/obfuscate.js

@@ -0,0 +1,85 @@
+export function obfuscateEmail(email) {
+    const [local, domain] = email.split('@');
+    return `${obfuscateWord(local)}@${obfuscateWord(domain)}`;
+}
+export function obfuscateWord(word) {
+    return `${word.charAt(0)}***${word.charAt(word.length - 1)}`;
+}
+export function obfuscateHeaders(headers) {
+    const obfuscatedHeaders = {};
+    for (const key in headers) {
+        if (key.toLowerCase() === 'authorization') {
+            obfuscatedHeaders[key] = obfuscateAuthHeader(headers[key]);
+        }
+        else if (key.toLowerCase() === 'dpop') {
+            obfuscatedHeaders[key] = obfuscateJwt(headers[key]) || 'Invalid';
+        }
+        else {
+            obfuscatedHeaders[key] = headers[key];
+        }
+    }
+    return obfuscatedHeaders;
+}
+export function obfuscateAuthHeader(authHeader) {
+    // This is a hot path (runs on every request). Avoid using split() or regex.
+    const spaceIdx = authHeader.indexOf(' ');
+    if (spaceIdx === -1)
+        return 'Invalid';
+    const type = authHeader.slice(0, spaceIdx);
+    switch (type.toLowerCase()) {
+        case 'bearer':
+        case 'dpop':
+            return `${type} ${obfuscateBearer(authHeader.slice(spaceIdx + 1))}`;
+        case 'basic':
+            return `${type} ${obfuscateBasic(authHeader.slice(spaceIdx + 1)) || 'Invalid'}`;
+        default:
+            return `Invalid`;
+    }
+}
+export function obfuscateBasic(token) {
+    if (!token)
+        return null;
+    const buffer = Buffer.from(token, 'base64');
+    if (!buffer.length)
+        return null; // Buffer.from will silently ignore invalid base64 chars
+    const authHeader = buffer.toString('utf8');
+    const colIdx = authHeader.indexOf(':');
+    if (colIdx === -1)
+        return null;
+    const username = authHeader.slice(0, colIdx);
+    return `${username}:***`;
+}
+export function obfuscateBearer(token) {
+    return obfuscateJwt(token) || obfuscateToken(token);
+}
+export function obfuscateToken(token) {
+    if (token.length >= 12)
+        return obfuscateWord(token);
+    return token ? '***' : '';
+}
+export function obfuscateJwt(token) {
+    const firstDot = token.indexOf('.');
+    if (firstDot === -1)
+        return null;
+    const secondDot = token.indexOf('.', firstDot + 1);
+    if (secondDot === -1)
+        return null;
+    // Expected to be missing
+    const thirdDot = token.indexOf('.', secondDot + 1);
+    if (thirdDot !== -1)
+        return null;
+    try {
+        const payloadEnc = token.slice(firstDot + 1, secondDot);
+        const payloadJson = Buffer.from(payloadEnc, 'base64').toString('utf8');
+        const payload = JSON.parse(payloadJson);
+        if (typeof payload.sub === 'string')
+            return payload.sub;
+    }
+    catch {
+        // Invalid JWT
+        return null;
+    }
+    // Strip the signature
+    return token.slice(0, secondDot) + '.obfuscated';
+}
+//# sourceMappingURL=obfuscate.js.map

package/dist/obfuscate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"obfuscate.js","sourceRoot":"","sources":["../src/obfuscate.ts"],"names":[],"mappings":"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","sourcesContent":["export function obfuscateEmail(email: string) {\n  const [local, domain] = email.split('@')\n  return `${obfuscateWord(local)}@${obfuscateWord(domain)}`\n}\n\nexport function obfuscateWord(word: string) {\n  return `${word.charAt(0)}***${word.charAt(word.length - 1)}`\n}\n\nexport function obfuscateHeaders(headers: Record<string, string>) {\n  const obfuscatedHeaders: Record<string, string> = {}\n  for (const key in headers) {\n    if (key.toLowerCase() === 'authorization') {\n      obfuscatedHeaders[key] = obfuscateAuthHeader(headers[key])\n    } else if (key.toLowerCase() === 'dpop') {\n      obfuscatedHeaders[key] = obfuscateJwt(headers[key]) || 'Invalid'\n    } else {\n      obfuscatedHeaders[key] = headers[key]\n    }\n  }\n  return obfuscatedHeaders\n}\n\nexport function obfuscateAuthHeader(authHeader: string): string {\n  // This is a hot path (runs on every request). Avoid using split() or regex.\n\n  const spaceIdx = authHeader.indexOf(' ')\n  if (spaceIdx === -1) return 'Invalid'\n\n  const type = authHeader.slice(0, spaceIdx)\n  switch (type.toLowerCase()) {\n    case 'bearer':\n    case 'dpop':\n      return `${type} ${obfuscateBearer(authHeader.slice(spaceIdx + 1))}`\n    case 'basic':\n      return `${type} ${obfuscateBasic(authHeader.slice(spaceIdx + 1)) || 'Invalid'}`\n    default:\n      return `Invalid`\n  }\n}\n\nexport function obfuscateBasic(token: string): null | string {\n  if (!token) return null\n  const buffer = Buffer.from(token, 'base64')\n  if (!buffer.length) return null // Buffer.from will silently ignore invalid base64 chars\n  const authHeader = buffer.toString('utf8')\n  const colIdx = authHeader.indexOf(':')\n  if (colIdx === -1) return null\n  const username = authHeader.slice(0, colIdx)\n  return `${username}:***`\n}\n\nexport function obfuscateBearer(token: string): string {\n  return obfuscateJwt(token) || obfuscateToken(token)\n}\n\nexport function obfuscateToken(token: string): string {\n  if (token.length >= 12) return obfuscateWord(token)\n  return token ? '***' : ''\n}\n\nexport function obfuscateJwt(token: string): null | string {\n  const firstDot = token.indexOf('.')\n  if (firstDot === -1) return null\n\n  const secondDot = token.indexOf('.', firstDot + 1)\n  if (secondDot === -1) return null\n\n  // Expected to be missing\n  const thirdDot = token.indexOf('.', secondDot + 1)\n  if (thirdDot !== -1) return null\n\n  try {\n    const payloadEnc = token.slice(firstDot + 1, secondDot)\n    const payloadJson = Buffer.from(payloadEnc, 'base64').toString('utf8')\n    const payload = JSON.parse(payloadJson)\n    if (typeof payload.sub === 'string') return payload.sub\n  } catch {\n    // Invalid JWT\n    return null\n  }\n\n  // Strip the signature\n  return token.slice(0, secondDot) + '.obfuscated'\n}\n"]}

package/dist/streams.d.ts

@@ -0,0 +1,32 @@
+import { type Duplex, Readable, type Stream, Transform, type TransformCallback } from 'node:stream';
+export declare const forwardStreamErrors: (...streams: Stream[]) => void;
+export declare const cloneStream: (stream: Readable) => Readable;
+export declare const streamSize: (stream: Readable) => Promise<number>;
+export declare const streamToBytes: (stream: AsyncIterable<Uint8Array>) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const streamToNodeBuffer: (stream: Iterable<Uint8Array> | AsyncIterable<Uint8Array>) => Promise<Buffer>;
+export declare const byteIterableToStream: (iter: AsyncIterable<Uint8Array>) => Readable;
+/**
+ * Coalesce a stream of Uint8Array chunks into larger chunks of at least the
+ * specified size ({@link minChunkSize}). This is useful for optimizing
+ * downstream processing that benefits from larger chunk sizes, such as
+ * compression or hashing.
+ */
+export declare const coalesceByteStream: (stream: Iterable<Uint8Array> | AsyncIterable<Uint8Array>, minChunkSize: number) => Readable;
+export declare const bytesToStream: (bytes: Uint8Array) => Readable;
+export declare class MaxSizeChecker extends Transform {
+    maxSize: number;
+    createError: () => Error;
+    totalSize: number;
+    constructor(maxSize: number, createError: () => Error);
+    _transform(chunk: Uint8Array, _enc: BufferEncoding, cb: TransformCallback): void;
+}
+export declare function decodeStream(stream: Readable, contentEncoding?: string | string[]): Readable;
+export declare function decodeStream(stream: AsyncIterable<Uint8Array>, contentEncoding?: string | string[]): AsyncIterable<Uint8Array> | Readable;
+/**
+ * Create a series of decoding streams based on the content-encoding header. The
+ * resulting streams should be piped together to decode the content.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export declare function createDecoders(contentEncoding?: string | string[]): Duplex[];
+//# sourceMappingURL=streams.d.ts.map

package/dist/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../src/streams.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAEX,QAAQ,EACR,KAAK,MAAM,EACX,SAAS,EACT,KAAK,iBAAiB,EAEvB,MAAM,aAAa,CAAA;AAGpB,eAAO,MAAM,mBAAmB,eAAgB,MAAM,EAAE,SAOvD,CAAA;AAED,eAAO,MAAM,WAAW,WAAY,QAAQ,KAAG,QAI9C,CAAA;AAED,eAAO,MAAM,UAAU,WAAkB,QAAQ,KAAG,OAAO,CAAC,MAAM,CAMjE,CAAA;AAED,eAAO,MAAM,aAAa,WAAkB,aAAa,CAAC,UAAU,CAAC,qCAInB,CAAA;AAGlD,eAAO,MAAM,kBAAkB,WACrB,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,KACvD,OAAO,CAAC,MAAM,CAYhB,CAAA;AAED,eAAO,MAAM,oBAAoB,SACzB,aAAa,CAAC,UAAU,CAAC,KAC9B,QAEF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,WACrB,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,gBAC1C,MAAM,KACnB,QAkEF,CAAA;AAED,eAAO,MAAM,aAAa,UAAW,UAAU,KAAG,QAKjD,CAAA;AAED,qBAAa,cAAe,SAAQ,SAAS;IAGlC,OAAO,EAAE,MAAM;IACf,WAAW,EAAE,MAAM,KAAK;IAHjC,SAAS,SAAI;IACb,YACS,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,KAAK,EAGhC;IACD,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,iBAAiB,QAOxE;CACF;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,QAAQ,EAChB,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAClC,QAAQ,CAAA;AACX,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAClC,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAA;AAUvC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAqB5E"}

package/dist/streams.js

@@ -0,0 +1,190 @@
+import { PassThrough, Readable, Transform, pipeline, } from 'node:stream';
+import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
+export const forwardStreamErrors = (...streams) => {
+    for (let i = 1; i < streams.length; ++i) {
+        const prev = streams[i - 1];
+        const next = streams[i];
+        prev.once('error', (err) => next.emit('error', err));
+    }
+};
+export const cloneStream = (stream) => {
+    const passthrough = new PassThrough();
+    forwardStreamErrors(stream, passthrough);
+    return stream.pipe(passthrough);
+};
+export const streamSize = async (stream) => {
+    let size = 0;
+    for await (const chunk of stream) {
+        size += Buffer.byteLength(chunk);
+    }
+    return size;
+};
+export const streamToBytes = async (stream) => 
+// @NOTE Though Buffer is a sub-class of Uint8Array, we have observed
+// inconsistencies when using a Buffer in place of Uint8Array. For this
+// reason, we convert the Buffer to a Uint8Array.
+new Uint8Array(await streamToNodeBuffer(stream));
+// streamToBuffer identifier name already taken by @atproto/common-web
+export const streamToNodeBuffer = async (stream) => {
+    const chunks = [];
+    let totalLength = 0; // keep track of total length for Buffer.concat
+    for await (const chunk of stream) {
+        if (chunk instanceof Uint8Array) {
+            chunks.push(chunk);
+            totalLength += Buffer.byteLength(chunk);
+        }
+        else {
+            throw new TypeError('expected Uint8Array');
+        }
+    }
+    return Buffer.concat(chunks, totalLength);
+};
+export const byteIterableToStream = (iter) => {
+    return Readable.from(iter, { objectMode: false });
+};
+/**
+ * Coalesce a stream of Uint8Array chunks into larger chunks of at least the
+ * specified size ({@link minChunkSize}). This is useful for optimizing
+ * downstream processing that benefits from larger chunk sizes, such as
+ * compression or hashing.
+ */
+export const coalesceByteStream = (stream, minChunkSize) => {
+    if (!Number.isInteger(minChunkSize) || minChunkSize < 1) {
+        throw new TypeError('minChunkSize must be a positive integer');
+    }
+    // @NOTE On Node 22, this *does* return a PassThrough ("@types/node"
+    // incorrectly types it as Writable).
+    return pipeline(stream, coalesce, (_err) => {
+        // Errors are expected to be handled through the stream
+    });
+    // @NOTE This implementation is not NodeJS specific and could be exported as
+    // utility (from "@atproto/common-web") if needed. We don't do it now to avoid
+    // increasing the API surface of our packages.
+    async function* coalesce(iter) {
+        // @NOTE This implementation avoids as many un-necessary copies as possible
+        // and only buffers incoming chunks when they are smaller than the
+        // coalescing buffer.
+        let buffer = new Uint8Array(minChunkSize);
+        let offset = 0;
+        for await (const chunk of iter) {
+            const freeSpace = buffer.length - offset;
+            if (freeSpace > chunk.length) {
+                // If the incoming chunk is smaller than the free space, we copy the
+                // entire chunk into the coalescing buffer and continue to the next
+                // chunk
+                buffer.set(chunk, offset);
+                offset += chunk.length;
+            }
+            else if (offset === 0 && chunk.length >= minChunkSize) {
+                // If the coalescing buffer is empty and the incoming chunk is larger
+                // than the coalescing buffer, we can skip any copying and yield the
+                // incoming chunk directly
+                yield chunk;
+            }
+            else {
+                // Otherwise, we need to copy as much of the incoming chunk as we can
+                // into the coalescing buffer and yield the full coalescing buffer.
+                buffer.set(chunk.subarray(0, freeSpace), offset);
+                yield buffer;
+                // We create a new coalescing buffer (for future use)
+                buffer = new Uint8Array(minChunkSize);
+                offset = 0;
+                const remainingBytes = chunk.subarray(freeSpace);
+                if (remainingBytes.length > minChunkSize) {
+                    // If the remaining of chunk is still too big to fit in the
+                    // coalescing buffer, we yield it directly without copying it
+                    yield remainingBytes;
+                }
+                else if (remainingBytes.length > 0) {
+                    // Otherwise, we copy the remaining bytes into the coalescing buffer
+                    // and continue to the next chunk
+                    buffer.set(remainingBytes, offset);
+                    offset += remainingBytes.length;
+                }
+            }
+        }
+        // Yield any remaining bytes in the coalescing buffer
+        if (offset > 0) {
+            yield buffer.subarray(0, offset);
+        }
+    }
+};
+export const bytesToStream = (bytes) => {
+    const stream = new Readable();
+    stream.push(bytes);
+    stream.push(null);
+    return stream;
+};
+export class MaxSizeChecker extends Transform {
+    constructor(maxSize, createError) {
+        super();
+        this.maxSize = maxSize;
+        this.createError = createError;
+        this.totalSize = 0;
+    }
+    _transform(chunk, _enc, cb) {
+        this.totalSize += chunk.length;
+        if (this.totalSize > this.maxSize) {
+            cb(this.createError());
+        }
+        else {
+            cb(null, chunk);
+        }
+    }
+}
+export function decodeStream(stream, contentEncoding) {
+    const decoders = createDecoders(contentEncoding);
+    if (decoders.length === 0)
+        return stream;
+    return pipeline([stream, ...decoders], () => { });
+}
+/**
+ * Create a series of decoding streams based on the content-encoding header. The
+ * resulting streams should be piped together to decode the content.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+ */
+export function createDecoders(contentEncoding) {
+    const decoders = [];
+    if (contentEncoding?.length) {
+        const encodings = Array.isArray(contentEncoding)
+            ? contentEncoding.flatMap(commaSplit)
+            : contentEncoding.split(',');
+        for (const encoding of encodings) {
+            const normalizedEncoding = normalizeEncoding(encoding);
+            // @NOTE
+            // > The default (identity) encoding [...] is used only in the
+            // > Accept-Encoding header, and SHOULD NOT be used in the
+            // > Content-Encoding header.
+            if (normalizedEncoding === 'identity')
+                continue;
+            decoders.push(createDecoder(normalizedEncoding));
+        }
+    }
+    return decoders.reverse();
+}
+function commaSplit(header) {
+    return header.split(',');
+}
+function normalizeEncoding(encoding) {
+    // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
+    // > All content-coding values are case-insensitive...
+    return encoding.trim().toLowerCase();
+}
+function createDecoder(normalizedEncoding) {
+    switch (normalizedEncoding) {
+        // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
+        case 'gzip':
+        case 'x-gzip':
+            return createGunzip();
+        case 'deflate':
+            return createInflate();
+        case 'br':
+            return createBrotliDecompress();
+        case 'identity':
+            return new PassThrough();
+        default:
+            throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
+    }
+}
+//# sourceMappingURL=streams.js.map

package/dist/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","sourceRoot":"","sources":["../src/streams.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Duplex,\n  PassThrough,\n  Readable,\n  type Stream,\n  Transform,\n  type TransformCallback,\n  pipeline,\n} from 'node:stream'\nimport { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib'\n\nexport const forwardStreamErrors = (...streams: Stream[]) => {\n  for (let i = 1; i < streams.length; ++i) {\n    const prev = streams[i - 1]\n    const next = streams[i]\n\n    prev.once('error', (err) => next.emit('error', err))\n  }\n}\n\nexport const cloneStream = (stream: Readable): Readable => {\n  const passthrough = new PassThrough()\n  forwardStreamErrors(stream, passthrough)\n  return stream.pipe(passthrough)\n}\n\nexport const streamSize = async (stream: Readable): Promise<number> => {\n  let size = 0\n  for await (const chunk of stream) {\n    size += Buffer.byteLength(chunk)\n  }\n  return size\n}\n\nexport const streamToBytes = async (stream: AsyncIterable<Uint8Array>) =>\n  // @NOTE Though Buffer is a sub-class of Uint8Array, we have observed\n  // inconsistencies when using a Buffer in place of Uint8Array. For this\n  // reason, we convert the Buffer to a Uint8Array.\n  new Uint8Array(await streamToNodeBuffer(stream))\n\n// streamToBuffer identifier name already taken by @atproto/common-web\nexport const streamToNodeBuffer = async (\n  stream: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n): Promise<Buffer> => {\n  const chunks: Uint8Array[] = []\n  let totalLength = 0 // keep track of total length for Buffer.concat\n  for await (const chunk of stream) {\n    if (chunk instanceof Uint8Array) {\n      chunks.push(chunk)\n      totalLength += Buffer.byteLength(chunk)\n    } else {\n      throw new TypeError('expected Uint8Array')\n    }\n  }\n  return Buffer.concat(chunks, totalLength)\n}\n\nexport const byteIterableToStream = (\n  iter: AsyncIterable<Uint8Array>,\n): Readable => {\n  return Readable.from(iter, { objectMode: false })\n}\n\n/**\n * Coalesce a stream of Uint8Array chunks into larger chunks of at least the\n * specified size ({@link minChunkSize}). This is useful for optimizing\n * downstream processing that benefits from larger chunk sizes, such as\n * compression or hashing.\n */\nexport const coalesceByteStream = (\n  stream: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n  minChunkSize: number,\n): Readable => {\n  if (!Number.isInteger(minChunkSize) || minChunkSize < 1) {\n    throw new TypeError('minChunkSize must be a positive integer')\n  }\n\n  // @NOTE On Node 22, this *does* return a PassThrough (\"@types/node\"\n  // incorrectly types it as Writable).\n  return pipeline(stream, coalesce, (_err) => {\n    // Errors are expected to be handled through the stream\n  }) as PassThrough\n\n  // @NOTE This implementation is not NodeJS specific and could be exported as\n  // utility (from \"@atproto/common-web\") if needed. We don't do it now to avoid\n  // increasing the API surface of our packages.\n  async function* coalesce(\n    iter: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n  ): AsyncGenerator<Uint8Array> {\n    // @NOTE This implementation avoids as many un-necessary copies as possible\n    // and only buffers incoming chunks when they are smaller than the\n    // coalescing buffer.\n\n    let buffer = new Uint8Array(minChunkSize)\n    let offset = 0\n\n    for await (const chunk of iter) {\n      const freeSpace = buffer.length - offset\n      if (freeSpace > chunk.length) {\n        // If the incoming chunk is smaller than the free space, we copy the\n        // entire chunk into the coalescing buffer and continue to the next\n        // chunk\n        buffer.set(chunk, offset)\n        offset += chunk.length\n      } else if (offset === 0 && chunk.length >= minChunkSize) {\n        // If the coalescing buffer is empty and the incoming chunk is larger\n        // than the coalescing buffer, we can skip any copying and yield the\n        // incoming chunk directly\n        yield chunk\n      } else {\n        // Otherwise, we need to copy as much of the incoming chunk as we can\n        // into the coalescing buffer and yield the full coalescing buffer.\n        buffer.set(chunk.subarray(0, freeSpace), offset)\n        yield buffer\n\n        // We create a new coalescing buffer (for future use)\n        buffer = new Uint8Array(minChunkSize)\n        offset = 0\n\n        const remainingBytes = chunk.subarray(freeSpace)\n        if (remainingBytes.length > minChunkSize) {\n          // If the remaining of chunk is still too big to fit in the\n          // coalescing buffer, we yield it directly without copying it\n          yield remainingBytes\n        } else if (remainingBytes.length > 0) {\n          // Otherwise, we copy the remaining bytes into the coalescing buffer\n          // and continue to the next chunk\n          buffer.set(remainingBytes, offset)\n          offset += remainingBytes.length\n        }\n      }\n    }\n\n    // Yield any remaining bytes in the coalescing buffer\n    if (offset > 0) {\n      yield buffer.subarray(0, offset)\n    }\n  }\n}\n\nexport const bytesToStream = (bytes: Uint8Array): Readable => {\n  const stream = new Readable()\n  stream.push(bytes)\n  stream.push(null)\n  return stream\n}\n\nexport class MaxSizeChecker extends Transform {\n  totalSize = 0\n  constructor(\n    public maxSize: number,\n    public createError: () => Error,\n  ) {\n    super()\n  }\n  _transform(chunk: Uint8Array, _enc: BufferEncoding, cb: TransformCallback) {\n    this.totalSize += chunk.length\n    if (this.totalSize > this.maxSize) {\n      cb(this.createError())\n    } else {\n      cb(null, chunk)\n    }\n  }\n}\n\nexport function decodeStream(\n  stream: Readable,\n  contentEncoding?: string | string[],\n): Readable\nexport function decodeStream(\n  stream: AsyncIterable<Uint8Array>,\n  contentEncoding?: string | string[],\n): AsyncIterable<Uint8Array> | Readable\nexport function decodeStream(\n  stream: Readable | AsyncIterable<Uint8Array>,\n  contentEncoding?: string | string[],\n): Readable | AsyncIterable<Uint8Array> {\n  const decoders = createDecoders(contentEncoding)\n  if (decoders.length === 0) return stream\n  return pipeline([stream as Readable, ...decoders], () => {}) as Duplex\n}\n\n/**\n * Create a series of decoding streams based on the content-encoding header. The\n * resulting streams should be piped together to decode the content.\n *\n * @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}\n */\nexport function createDecoders(contentEncoding?: string | string[]): Duplex[] {\n  const decoders: Duplex[] = []\n\n  if (contentEncoding?.length) {\n    const encodings: string[] = Array.isArray(contentEncoding)\n      ? contentEncoding.flatMap(commaSplit)\n      : contentEncoding.split(',')\n    for (const encoding of encodings) {\n      const normalizedEncoding = normalizeEncoding(encoding)\n\n      // @NOTE\n      // > The default (identity) encoding [...] is used only in the\n      // > Accept-Encoding header, and SHOULD NOT be used in the\n      // > Content-Encoding header.\n      if (normalizedEncoding === 'identity') continue\n\n      decoders.push(createDecoder(normalizedEncoding))\n    }\n  }\n\n  return decoders.reverse()\n}\n\nfunction commaSplit(header: string): string[] {\n  return header.split(',')\n}\n\nfunction normalizeEncoding(encoding: string) {\n  // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1\n  // > All content-coding values are case-insensitive...\n  return encoding.trim().toLowerCase()\n}\n\nfunction createDecoder(normalizedEncoding: string): Duplex {\n  switch (normalizedEncoding) {\n    // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2\n    case 'gzip':\n    case 'x-gzip':\n      return createGunzip()\n    case 'deflate':\n      return createInflate()\n    case 'br':\n      return createBrotliDecompress()\n    case 'identity':\n      return new PassThrough()\n    default:\n      throw new TypeError(\n        `Unsupported content-encoding: \"${normalizedEncoding}\"`,\n      )\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@atproto/common",
+  "version": "0.0.0-spaces-alpha-20260818021221",
+  "license": "MIT",
+  "description": "Shared web-platform-friendly code for atproto libraries",
+  "keywords": [
+    "atproto"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/common"
+  },
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "multiformats": "^13.0.0",
+    "pino": "^10.3.1",
+    "varint": "^6.0.0",
+    "@atproto/common-web": "^0.0.0-spaces-alpha-20260818021221",
+    "@atproto/lex-data": "^0.1.7",
+    "@atproto/lex-cbor": "^0.1.6"
+  },
+  "devDependencies": {
+    "jest": "^30.0.0",
+    "uint8arrays": "^5.0.0"
+  },
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build": "tsc --build tsconfig.build.json"
+  }
+}