@atproto/common 0.3.3 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atproto/common
 
+## 0.3.4
+
+### Patch Changes
+
+- Updated dependencies [[`4eaadc0ac`](https://github.com/bluesky-social/atproto/commit/4eaadc0acb6b73b9745dd7a2b929d02e58083ab0)]:
+  - @atproto/common-web@0.2.4
+
 ## 0.3.3
 
 ### Patch Changes

package/LICENSE.txt

@@ -1,6 +1,6 @@
 Dual MIT/Apache-2.0 License
 
-Copyright (c) 2022-2023 Bluesky PBC, and Contributors
+Copyright (c) 2022-2024 Bluesky PBC, and Contributors
 
 Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
 

package/dist/env.d.ts

@@ -0,0 +1,4 @@
+export declare const envInt: (name: string) => number | undefined;
+export declare const envStr: (name: string) => string | undefined;
+export declare const envBool: (name: string) => boolean | undefined;
+export declare const envList: (name: string) => string[];

package/dist/fs.d.ts

@@ -1 +1,3 @@
 export declare const fileExists: (location: string) => Promise<boolean>;
+export declare const readIfExists: (filepath: string) => Promise<Uint8Array | undefined>;
+export declare const rmIfExists: (filepath: string, recursive?: boolean) => Promise<void>;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from '@atproto/common-web';
 export * from './dates';
+export * from './env';
 export * from './fs';
 export * from './ipld';
 export * from './ipld-multi';

package/dist/index.js

@@ -8866,30 +8866,292 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js"(exports, module2) {
+    "use strict";
+    var isLinux = () => process.platform === "linux";
+    var report = null;
+    var getReport = () => {
+      if (!report) {
+        report = isLinux() && process.report ? process.report.getReport() : {};
+      }
+      return report;
+    };
+    module2.exports = { isLinux, getReport };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
+    "use strict";
+    var fs2 = require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var readFileSync = (path) => fs2.readFileSync(path, "utf-8");
+    var readFile = (path) => new Promise((resolve, reject) => {
+      fs2.readFile(path, "utf-8", (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+    module2.exports = {
+      LDD_PATH,
+      readFileSync,
+      readFile
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js"(exports, module2) {
+    "use strict";
+    var childProcess = require("child_process");
+    var { isLinux, getReport } = require_process();
+    var { LDD_PATH, readFile, readFileSync } = require_filesystem();
+    var cachedFamilyFilesystem;
+    var cachedVersionFilesystem;
+    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+    var commandOut = "";
+    var safeCommand = () => {
+      if (!commandOut) {
+        return new Promise((resolve) => {
+          childProcess.exec(command, (err, out) => {
+            commandOut = err ? " " : out;
+            resolve(commandOut);
+          });
+        });
+      }
+      return commandOut;
+    };
+    var safeCommandSync = () => {
+      if (!commandOut) {
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch (_err) {
+          commandOut = " ";
+        }
+      }
+      return commandOut;
+    };
+    var GLIBC = "glibc";
+    var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
+    var MUSL = "musl";
+    var GLIBC_ON_LDD = GLIBC.toUpperCase();
+    var MUSL_ON_LDD = MUSL.toLowerCase();
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var familyFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return GLIBC;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return MUSL;
+        }
+      }
+      return null;
+    };
+    var familyFromCommand = (out) => {
+      const [getconf, ldd1] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return GLIBC;
+      }
+      if (ldd1 && ldd1.includes(MUSL)) {
+        return MUSL;
+      }
+      return null;
+    };
+    var getFamilyFromLddContent = (content) => {
+      if (content.includes(MUSL_ON_LDD)) {
+        return MUSL;
+      }
+      if (content.includes(GLIBC_ON_LDD)) {
+        return GLIBC;
+      }
+      return null;
+    };
+    var familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var family = async () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var familySync = () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+    var versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return report.header.glibcVersionRuntime;
+      }
+      return null;
+    };
+    var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+    var versionFromCommand = (out) => {
+      const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return versionSuffix(getconf);
+      }
+      if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+        return versionSuffix(ldd2);
+      }
+      return null;
+    };
+    var version2 = async () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = await versionFromFilesystem();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = await safeCommand();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    var versionSync = () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = versionFromFilesystemSync();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = safeCommandSync();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    module2.exports = {
+      GLIBC,
+      MUSL,
+      family,
+      familySync,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version: version2,
+      versionSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js
 var require_node_gyp_build_optional_packages = __commonJS({
-  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
     var fs2 = require("fs");
     var path = require("path");
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    var url = require("url");
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
-    var abi = process.versions.modules;
+    var versions = process.versions;
+    var abi = versions.modules;
+    if (versions.deno || process.isBun) {
+      abi = "unsupported";
+    }
     var runtime = isElectron() ? "electron" : "node";
     var arch = process.arch;
     var platform = process.platform;
-    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
-    var uv = (process.versions.uv || "").split(".")[0];
+    var uv = (versions.uv || "").split(".")[0];
     module2.exports = load;
     function load(dir) {
-      return runtimeRequire(load.path(dir));
+      if (typeof __webpack_require__ === "function")
+        return __non_webpack_require__(load.path(dir));
+      else
+        return require(load.path(dir));
     }
     load.path = function(dir) {
       dir = path.resolve(dir || ".");
-      var packageName;
+      var packageName = "";
       try {
-        packageName = runtimeRequire(path.join(dir, "package.json")).name;
+        if (typeof __webpack_require__ === "function")
+          packageName = __non_webpack_require__(path.join(dir, "package.json")).name;
+        else
+          packageName = require(path.join(dir, "package.json")).name;
         var varName = packageName.toUpperCase().replace(/-/g, "_") + "_PREBUILD";
         if (process.env[varName])
           dir = process.env[varName];
@@ -8911,7 +9173,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return nearby;
       var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
       try {
-        var prebuildPackage = path.dirname(require("module").createRequire(path.join(dir, "package.json")).resolve(platformPackage));
+        var prebuildPackage = path.dirname(require("module").createRequire(url.pathToFileURL(path.join(dir, "package.json"))).resolve(platformPackage));
         return resolveFile(prebuildPackage);
       } catch (error) {
       }
@@ -8927,7 +9189,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         process.versions.electron ? "electron=" + process.versions.electron : "",
         typeof __webpack_require__ === "function" ? "webpack=true" : ""
       ].filter(Boolean).join(" ");
-      throw new Error("No native build was found for " + target2 + "\n    loaded from: " + dir + " and package: " + platformPackage + "\n");
+      throw new Error("No native build was found for " + target2 + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
       function resolve(dir2) {
         var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
@@ -9050,8 +9312,11 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return true;
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
-    function isAlpine(platform2) {
-      return platform2 === "linux" && fs2.existsSync("/etc/alpine-release");
+    function isMusl(platform2) {
+      if (platform2 !== "linux")
+        return false;
+      const { familySync, MUSL } = require_detect_libc();
+      return familySync() === MUSL;
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -9062,9 +9327,9 @@ var require_node_gyp_build_optional_packages = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js
+// ../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js
 var require_cbor_extract = __commonJS({
-  "../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js"(exports, module2) {
     module2.exports = require_node_gyp_build_optional_packages()(__dirname);
   }
 });
@@ -13063,9 +13328,11 @@ __export(src_exports3, {
   TID: () => TID,
   VerifyCidError: () => VerifyCidError,
   VerifyCidTransform: () => VerifyCidTransform,
+  addHoursToDate: () => addHoursToDate,
   allComplete: () => allComplete,
   asyncFilter: () => asyncFilter,
   b64UrlToUtf8: () => b64UrlToUtf8,
+  backoffMs: () => backoffMs,
   bailableWait: () => bailableWait,
   byteIterableToStream: () => byteIterableToStream,
   bytesToStream: () => bytesToStream,
@@ -13083,6 +13350,10 @@ __export(src_exports3, {
   dedupeStrs: () => dedupeStrs,
   def: () => def,
   didDocument: () => didDocument,
+  envBool: () => envBool,
+  envInt: () => envInt,
+  envList: () => envList,
+  envStr: () => envStr,
   errHasMsg: () => errHasMsg,
   fileExists: () => fileExists,
   flattenUint8Arrays: () => flattenUint8Arrays,
@@ -13093,7 +13364,9 @@ __export(src_exports3, {
   getNotifEndpoint: () => getNotifEndpoint,
   getPdsEndpoint: () => getPdsEndpoint,
   getServiceEndpoint: () => getServiceEndpoint,
+  getSigningDidKey: () => getSigningDidKey,
   getSigningKey: () => getSigningKey,
+  getVerificationMaterial: () => getVerificationMaterial,
   graphemeLen: () => graphemeLen,
   handleAllSettledErrors: () => handleAllSettledErrors,
   ipldEquals: () => ipldEquals,
@@ -13103,6 +13376,7 @@ __export(src_exports3, {
   isValidDidDoc: () => isValidDidDoc,
   jitter: () => jitter,
   jsonToIpld: () => jsonToIpld,
+  keyBy: () => keyBy,
   lessThanAgoMs: () => lessThanAgoMs,
   mapDefined: () => mapDefined,
   noUndefinedVals: () => noUndefinedVals,
@@ -13110,6 +13384,9 @@ __export(src_exports3, {
   parseLanguage: () => parseLanguage,
   range: () => range,
   readFromGenerator: () => readFromGenerator,
+  readIfExists: () => readIfExists,
+  retry: () => retry,
+  rmIfExists: () => rmIfExists,
   s32decode: () => s32decode,
   s32encode: () => s32encode,
   schema: () => schema,
@@ -13264,6 +13541,12 @@ var parseIntWithFallback = (value, fallback) => {
 };
 
 // ../common-web/src/arrays.ts
+var keyBy = (arr, key) => {
+  return arr.reduce((acc, cur) => {
+    acc[cur[key]] = cur;
+    return acc;
+  }, {});
+};
 var mapDefined = (arr, fn) => {
   const output = [];
   for (const item of arr) {
@@ -13333,6 +13616,7 @@ var AsyncBuffer = class {
   constructor(maxSize) {
     this.maxSize = maxSize;
     this.buffer = [];
+    this.closed = false;
     this.promise = Promise.resolve();
     this.resolve = () => null;
     this.resetPromise();
@@ -13343,6 +13627,9 @@ var AsyncBuffer = class {
   get size() {
     return this.buffer.length;
   }
+  get isClosed() {
+    return this.closed;
+  }
   resetPromise() {
     this.promise = new Promise((r) => this.resolve = r);
   }
@@ -13356,7 +13643,17 @@ var AsyncBuffer = class {
   }
   async *events() {
     while (true) {
+      if (this.closed && this.buffer.length === 0) {
+        if (this.toThrow) {
+          throw this.toThrow;
+        } else {
+          return;
+        }
+      }
       await this.promise;
+      if (this.toThrow) {
+        throw this.toThrow;
+      }
       if (this.maxSize && this.size > this.maxSize) {
         throw new AsyncBufferFullError(this.maxSize);
       }
@@ -13369,6 +13666,15 @@ var AsyncBuffer = class {
       }
     }
   }
+  throw(err) {
+    this.toThrow = err;
+    this.closed = true;
+    this.resolve();
+  }
+  close() {
+    this.closed = true;
+    this.resolve();
+  }
 };
 var AsyncBufferFullError = class extends Error {
   constructor(maxSize) {
@@ -14684,6 +14990,43 @@ var ipldEquals = (a, b) => {
   return a === b;
 };
 
+// ../common-web/src/retry.ts
+async function retry(fn, opts = {}) {
+  const { maxRetries = 3, retryable = () => true, getWaitMs = backoffMs } = opts;
+  let retries = 0;
+  let doneError;
+  while (!doneError) {
+    try {
+      return await fn();
+    } catch (err) {
+      const waitMs = getWaitMs(retries);
+      const willRetry = retries < maxRetries && waitMs !== null && retryable(err);
+      if (willRetry) {
+        retries += 1;
+        if (waitMs !== 0) {
+          await wait(waitMs);
+        }
+      } else {
+        doneError = err;
+      }
+    }
+  }
+  throw doneError;
+}
+function backoffMs(n, multiplier = 100, max = 1e3) {
+  const exponentialMs = Math.pow(2, n) * multiplier;
+  const ms = Math.min(exponentialMs, max);
+  return jitter2(ms);
+}
+function jitter2(value) {
+  const delta = value * 0.15;
+  return value + randomRange(-delta, delta);
+}
+function randomRange(from3, to) {
+  const rand = Math.random() * (to - from3);
+  return rand + from3;
+}
+
 // ../../node_modules/.pnpm/zod@3.21.4/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
@@ -18311,6 +18654,11 @@ var DAY = HOUR * 24;
 var lessThanAgoMs = (time, range2) => {
   return Date.now() < time.getTime() + range2;
 };
+var addHoursToDate = (hours, startingDate) => {
+  const currentDate = startingDate ? new Date(startingDate) : new Date();
+  currentDate.setHours(currentDate.getHours() + hours);
+  return currentDate;
+};
 
 // ../common-web/src/strings.ts
 var import_graphemer = __toESM(require_lib());
@@ -18369,6 +18717,9 @@ var getHandle = (doc) => {
   return found.slice(5);
 };
 var getSigningKey = (doc) => {
+  return getVerificationMaterial(doc, "atproto");
+};
+var getVerificationMaterial = (doc, keyId) => {
   const did = getDid(doc);
   let keys = doc.verificationMethod;
   if (!keys)
@@ -18378,7 +18729,7 @@ var getSigningKey = (doc) => {
   if (!Array.isArray(keys)) {
     keys = [keys];
   }
-  const found = keys.find((key) => key.id === "#atproto" || key.id === `${did}#atproto`);
+  const found = keys.find((key) => key.id === `#${keyId}` || key.id === `${did}#${keyId}`);
   if (!found?.publicKeyMultibase)
     return void 0;
   return {
@@ -18386,6 +18737,12 @@ var getSigningKey = (doc) => {
     publicKeyMultibase: found.publicKeyMultibase
   };
 };
+var getSigningDidKey = (doc) => {
+  const parsed = getSigningKey(doc);
+  if (!parsed)
+    return;
+  return `did:key:${parsed.publicKeyMultibase}`;
+};
 var getPdsEndpoint = (doc) => {
   return getServiceEndpoint(doc, {
     id: "#atproto_pds",
@@ -18417,7 +18774,7 @@ var getServiceEndpoint = (doc, opts) => {
   const found = services.find((service2) => service2.id === opts.id || service2.id === `${did}${opts.id}`);
   if (!found)
     return void 0;
-  if (found.type !== opts.type) {
+  if (opts.type && found.type !== opts.type) {
     return void 0;
   }
   if (typeof found.serviceEndpoint !== "string") {
@@ -18472,6 +18829,32 @@ function toSimplifiedISOSafe(dateStr) {
   return iso;
 }
 
+// src/env.ts
+var envInt = (name3) => {
+  const str = process.env[name3];
+  return parseIntWithFallback(str, void 0);
+};
+var envStr = (name3) => {
+  const str = process.env[name3];
+  if (str === void 0 || str.length === 0)
+    return void 0;
+  return str;
+};
+var envBool = (name3) => {
+  const str = process.env[name3];
+  if (str === "true" || str === "1")
+    return true;
+  if (str === "false" || str === "0")
+    return false;
+  return void 0;
+};
+var envList = (name3) => {
+  const str = process.env[name3];
+  if (str === void 0 || str.length === 0)
+    return [];
+  return str.split(",");
+};
+
 // src/fs.ts
 var import_fs = require("fs");
 var import_promises = __toESM(require("fs/promises"));
@@ -18486,6 +18869,26 @@ var fileExists = async (location) => {
     throw err;
   }
 };
+var readIfExists = async (filepath) => {
+  try {
+    return await import_promises.default.readFile(filepath);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      return;
+    }
+    throw err;
+  }
+};
+var rmIfExists = async (filepath, recursive = false) => {
+  try {
+    await import_promises.default.rm(filepath, { recursive });
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      return;
+    }
+    throw err;
+  }
+};
 
 // src/ipld.ts
 var import_crypto2 = __toESM(require("crypto"));
@@ -22588,9 +22991,11 @@ function ui8ToArrayBuffer(bytes) {
   TID,
   VerifyCidError,
   VerifyCidTransform,
+  addHoursToDate,
   allComplete,
   asyncFilter,
   b64UrlToUtf8,
+  backoffMs,
   bailableWait,
   byteIterableToStream,
   bytesToStream,
@@ -22608,6 +23013,10 @@ function ui8ToArrayBuffer(bytes) {
   dedupeStrs,
   def,
   didDocument,
+  envBool,
+  envInt,
+  envList,
+  envStr,
   errHasMsg,
   fileExists,
   flattenUint8Arrays,
@@ -22618,7 +23027,9 @@ function ui8ToArrayBuffer(bytes) {
   getNotifEndpoint,
   getPdsEndpoint,
   getServiceEndpoint,
+  getSigningDidKey,
   getSigningKey,
+  getVerificationMaterial,
   graphemeLen,
   handleAllSettledErrors,
   ipldEquals,
@@ -22628,6 +23039,7 @@ function ui8ToArrayBuffer(bytes) {
   isValidDidDoc,
   jitter,
   jsonToIpld,
+  keyBy,
   lessThanAgoMs,
   mapDefined,
   noUndefinedVals,
@@ -22635,6 +23047,9 @@ function ui8ToArrayBuffer(bytes) {
   parseLanguage,
   range,
   readFromGenerator,
+  readIfExists,
+  retry,
+  rmIfExists,
   s32decode,
   s32encode,
   schema,