@dxos/keys 0.6.13 → 0.6.14-main.7bd9c89

package/dist/lib/node/meta.json

@@ -1 +1 @@
-{"inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytes":1217,"imports":[],"format":"cjs"},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytes":410,"imports":[],"format":"esm"},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytes":1266,"imports":[{"path":"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js","kind":"import-statement","original":"to-data-view"}],"format":"esm"},"packages/common/keys/src/random-bytes.ts":{"bytes":1792,"imports":[{"path":"node:crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/public-key.ts":{"bytes":30405,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":528,"imports":[],"format":"esm"},"packages/common/keys/src/space-id.ts":{"bytes":5162,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/dxn.ts":{"bytes":8722,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true}],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":746,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"},{"path":"packages/common/keys/src/space-id.ts","kind":"import-statement","original":"./space-id"},{"path":"packages/common/keys/src/dxn.ts","kind":"import-statement","original":"./dxn"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":26396},"packages/common/keys/dist/lib/node/index.cjs":{"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"node:crypto","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"exports":["DXN","LOCAL_SPACE_TAG","PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH","SpaceId"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytesInOutput":1554},"packages/common/keys/src/public-key.ts":{"bytesInOutput":7723},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytesInOutput":395},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytesInOutput":1206},"packages/common/keys/src/random-bytes.ts":{"bytesInOutput":204},"packages/common/keys/src/index.ts":{"bytesInOutput":0},"packages/common/keys/src/space-id.ts":{"bytesInOutput":1431},"packages/common/keys/src/dxn.ts":{"bytesInOutput":2074}},"bytes":16897}}}
+{"inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytes":1217,"imports":[],"format":"cjs"},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytes":410,"imports":[],"format":"esm"},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytes":1266,"imports":[{"path":"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js","kind":"import-statement","original":"to-data-view"}],"format":"esm"},"packages/common/keys/src/random-bytes.ts":{"bytes":1792,"imports":[{"path":"node:crypto","kind":"require-call","external":true}],"format":"esm"},"packages/common/keys/src/public-key.ts":{"bytes":31290,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/types.ts":{"bytes":528,"imports":[],"format":"esm"},"packages/common/keys/src/space-id.ts":{"bytes":5162,"imports":[{"path":"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js","kind":"import-statement","original":"base32-decode"},{"path":"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js","kind":"import-statement","original":"base32-encode"},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"packages/common/keys/src/random-bytes.ts","kind":"import-statement","original":"./random-bytes"}],"format":"esm"},"packages/common/keys/src/dxn.ts":{"bytes":10230,"imports":[{"path":"@dxos/invariant","kind":"import-statement","external":true}],"format":"esm"},"packages/common/keys/src/index.ts":{"bytes":746,"imports":[{"path":"packages/common/keys/src/public-key.ts","kind":"import-statement","original":"./public-key"},{"path":"packages/common/keys/src/types.ts","kind":"import-statement","original":"./types"},{"path":"packages/common/keys/src/space-id.ts","kind":"import-statement","original":"./space-id"},{"path":"packages/common/keys/src/dxn.ts","kind":"import-statement","original":"./dxn"}],"format":"esm"}},"outputs":{"packages/common/keys/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":27806},"packages/common/keys/dist/lib/node/index.cjs":{"imports":[{"path":"node:util","kind":"import-statement","external":true},{"path":"@dxos/debug","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"node:crypto","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"exports":["DXN","LOCAL_SPACE_TAG","PUBLIC_KEY_LENGTH","PublicKey","SECRET_KEY_LENGTH","SpaceId"],"entryPoint":"packages/common/keys/src/index.ts","inputs":{"node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js":{"bytesInOutput":1554},"packages/common/keys/src/public-key.ts":{"bytesInOutput":7899},"node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js":{"bytesInOutput":395},"node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js":{"bytesInOutput":1206},"packages/common/keys/src/random-bytes.ts":{"bytesInOutput":204},"packages/common/keys/src/index.ts":{"bytesInOutput":0},"packages/common/keys/src/space-id.ts":{"bytesInOutput":1431},"packages/common/keys/src/dxn.ts":{"bytesInOutput":2259}},"bytes":17258}}}

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,596 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js
+var require_base32_decode = __commonJS({
+  "node_modules/.pnpm/base32-decode@1.0.0/node_modules/base32-decode/index.js"(exports, module) {
+    var RFC46482 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    var RFC4648_HEX2 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+    var CROCKFORD2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    function readChar(alphabet, char) {
+      var idx = alphabet.indexOf(char);
+      if (idx === -1) {
+        throw new Error("Invalid character found: " + char);
+      }
+      return idx;
+    }
+    module.exports = function base32Decode3(input, variant) {
+      var alphabet;
+      switch (variant) {
+        case "RFC3548":
+        case "RFC4648":
+          alphabet = RFC46482;
+          input = input.replace(/=+$/, "");
+          break;
+        case "RFC4648-HEX":
+          alphabet = RFC4648_HEX2;
+          input = input.replace(/=+$/, "");
+          break;
+        case "Crockford":
+          alphabet = CROCKFORD2;
+          input = input.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1");
+          break;
+        default:
+          throw new Error("Unknown base32 variant: " + variant);
+      }
+      var length = input.length;
+      var bits = 0;
+      var value = 0;
+      var index = 0;
+      var output = new Uint8Array(length * 5 / 8 | 0);
+      for (var i = 0; i < length; i++) {
+        value = value << 5 | readChar(alphabet, input[i]);
+        bits += 5;
+        if (bits >= 8) {
+          output[index++] = value >>> bits - 8 & 255;
+          bits -= 8;
+        }
+      }
+      return output.buffer;
+    };
+  }
+});
+
+// packages/common/keys/src/public-key.ts
+var import_base32_decode = __toESM(require_base32_decode());
+
+// node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js
+function toDataView(data) {
+  if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+    return new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new TypeError("Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray");
+}
+
+// node_modules/.pnpm/base32-encode@2.0.0/node_modules/base32-encode/index.js
+var RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var RFC4648_HEX = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function base32Encode(data, variant, options) {
+  options = options || {};
+  let alphabet, defaultPadding;
+  switch (variant) {
+    case "RFC3548":
+    case "RFC4648":
+      alphabet = RFC4648;
+      defaultPadding = true;
+      break;
+    case "RFC4648-HEX":
+      alphabet = RFC4648_HEX;
+      defaultPadding = true;
+      break;
+    case "Crockford":
+      alphabet = CROCKFORD;
+      defaultPadding = false;
+      break;
+    default:
+      throw new Error("Unknown base32 variant: " + variant);
+  }
+  const padding = options.padding !== void 0 ? options.padding : defaultPadding;
+  const view = toDataView(data);
+  let bits = 0;
+  let value = 0;
+  let output = "";
+  for (let i = 0; i < view.byteLength; i++) {
+    value = value << 8 | view.getUint8(i);
+    bits += 8;
+    while (bits >= 5) {
+      output += alphabet[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    output += alphabet[value << 5 - bits & 31];
+  }
+  if (padding) {
+    while (output.length % 8 !== 0) {
+      output += "=";
+    }
+  }
+  return output;
+}
+
+// packages/common/keys/src/public-key.ts
+import { inspect } from "node:util";
+import { truncateKey, devtoolsFormatter, equalsSymbol } from "@dxos/debug";
+import { invariant } from "@dxos/invariant";
+
+// packages/common/keys/src/random-bytes.ts
+var randomBytes = (length) => {
+  const webCrypto = globalThis.crypto ?? __require("node:crypto").webcrypto;
+  const bytes = new Uint8Array(length);
+  webCrypto.getRandomValues(bytes);
+  return bytes;
+};
+
+// packages/common/keys/src/public-key.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/public-key.ts";
+var PUBLIC_KEY_LENGTH = 32;
+var SECRET_KEY_LENGTH = 64;
+var isLikeArrayBuffer = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value).constructor.name === "ArrayBuffer";
+var PublicKey = class _PublicKey {
+  static {
+    this.ZERO = _PublicKey.from("00".repeat(PUBLIC_KEY_LENGTH));
+  }
+  /**
+  * Creates new instance of PublicKey automatically determining the input format.
+  * @param source A Buffer, or Uint8Array, or hex encoded string, or something with an `asUint8Array` method on it
+  * @returns PublicKey
+  */
+  static from(source) {
+    invariant(source, void 0, {
+      F: __dxlog_file,
+      L: 42,
+      S: this,
+      A: [
+        "source",
+        ""
+      ]
+    });
+    if (source instanceof _PublicKey) {
+      return source;
+    } else if (source instanceof Buffer) {
+      return new _PublicKey(new Uint8Array(source.buffer, source.byteOffset, source.byteLength));
+    } else if (source instanceof Uint8Array) {
+      return new _PublicKey(source);
+    } else if (source instanceof ArrayBuffer || isLikeArrayBuffer(source)) {
+      return new _PublicKey(new Uint8Array(source));
+    } else if (typeof source === "string") {
+      return _PublicKey.fromHex(source);
+    } else if (source.asUint8Array) {
+      return new _PublicKey(source.asUint8Array());
+    } else {
+      throw new TypeError(`Unable to create PublicKey from ${source}`);
+    }
+  }
+  /**
+  * Same as `PublicKey.from` but does not throw and instead returns a `{ key: PublicKey }` or `{ error: Error }`
+  * @param source Same PublicKeyLike argument as for `PublicKey.from`
+  * @returns PublicKey
+  */
+  static safeFrom(source) {
+    if (!source) {
+      return void 0;
+    }
+    try {
+      const key = _PublicKey.from(source);
+      return key;
+    } catch (err) {
+      return void 0;
+    }
+  }
+  /**
+  * Creates new instance of PublicKey from hex string.
+  */
+  static fromHex(hex) {
+    if (hex.startsWith("0x")) {
+      hex = hex.slice(2);
+    }
+    const buf = Buffer.from(hex, "hex");
+    return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+  }
+  /**
+  * Creates a new key.
+  */
+  static random() {
+    return _PublicKey.from(randomBytes(PUBLIC_KEY_LENGTH));
+  }
+  static randomOfLength(length) {
+    return _PublicKey.from(randomBytes(length));
+  }
+  static *randomSequence() {
+    for (let i = 0; i < 1e4; i++) {
+      yield _PublicKey.random();
+    }
+    throw new Error("Too many keys requested");
+  }
+  /**
+  * Tests if provided values is an instance of PublicKey.
+  */
+  static isPublicKey(value) {
+    return value instanceof _PublicKey;
+  }
+  /**
+  * Asserts that provided values is an instance of PublicKey.
+  */
+  static assertValidPublicKey(value) {
+    if (!this.isPublicKey(value)) {
+      throw new TypeError("Invalid PublicKey");
+    }
+  }
+  /**
+  * Tests two keys for equality.
+  */
+  static equals(left, right) {
+    return _PublicKey.from(left).equals(right);
+  }
+  /**
+  * @param str string representation of key.
+  * @return Key buffer.
+  * @deprecated All keys should be represented as instances of PublicKey.
+  */
+  static bufferize(str) {
+    invariant(typeof str === "string", "Invalid type", {
+      F: __dxlog_file,
+      L: 145,
+      S: this,
+      A: [
+        "typeof str === 'string'",
+        "'Invalid type'"
+      ]
+    });
+    const buffer = Buffer.from(str, "hex");
+    return buffer;
+  }
+  /**
+  * @param key key like data structure (but not PublicKey which should use toString).
+  * @return Hex string representation of key.
+  * @deprecated All keys should be represented as instances of PublicKey.
+  */
+  static stringify(key) {
+    if (key instanceof _PublicKey) {
+      key = key.asBuffer();
+    } else if (key instanceof Uint8Array) {
+      key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
+    }
+    invariant(key instanceof Buffer, "Invalid type", {
+      F: __dxlog_file,
+      L: 164,
+      S: this,
+      A: [
+        "key instanceof Buffer",
+        "'Invalid type'"
+      ]
+    });
+    return key.toString("hex");
+  }
+  /**
+  * To be used with ComplexMap and ComplexSet.
+  * Returns a scalar representation for this key.
+  */
+  static hash(key) {
+    return key.toHex();
+  }
+  static fromMultibase32(encoded) {
+    invariant(encoded.startsWith("B"), "Invalid multibase32 encoding", {
+      F: __dxlog_file,
+      L: 177,
+      S: this,
+      A: [
+        "encoded.startsWith('B')",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new _PublicKey(new Uint8Array((0, import_base32_decode.default)(encoded.slice(1), "RFC4648")));
+  }
+  constructor(_value) {
+    this._value = _value;
+    if (!(_value instanceof Uint8Array)) {
+      throw new TypeError(`Expected Uint8Array, got: ${_value}`);
+    }
+  }
+  toString() {
+    return this.toHex();
+  }
+  toJSON() {
+    return this.toHex();
+  }
+  toJSONL() {
+    return this.truncate();
+  }
+  get length() {
+    return this._value.length;
+  }
+  toHex() {
+    return this.asBuffer().toString("hex");
+  }
+  toMultibase32() {
+    return "B" + base32Encode(this._value, "RFC4648");
+  }
+  truncate(length = void 0) {
+    return truncateKey(this, length);
+  }
+  asBuffer() {
+    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);
+  }
+  asUint8Array() {
+    return this._value;
+  }
+  getInsecureHash(modulo) {
+    return Math.abs(this._value.reduce((acc, val) => acc ^ val | 0, 0)) % modulo;
+  }
+  /**
+  * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.
+  */
+  [inspect.custom](depth, options) {
+    if (!options.colors || typeof process.stdout.hasColors !== "function" || !process.stdout.hasColors()) {
+      return `<PublicKey ${this.truncate()}>`;
+    }
+    const printControlCode = (code) => {
+      return `\x1B[${code}m`;
+    };
+    const colors = [
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "redBright",
+      "greenBright",
+      "yellowBright",
+      "blueBright",
+      "magentaBright",
+      "cyanBright",
+      "whiteBright"
+    ];
+    const color = colors[this.getInsecureHash(colors.length)];
+    return `PublicKey(${printControlCode(inspect.colors[color][0])}${this.truncate()}${printControlCode(inspect.colors.reset[0])})`;
+  }
+  get [devtoolsFormatter]() {
+    return {
+      header: () => {
+        const colors = [
+          "darkred",
+          "green",
+          "orange",
+          "blue",
+          "darkmagenta",
+          "darkcyan",
+          "red",
+          "green",
+          "orange",
+          "blue",
+          "magenta",
+          "darkcyan",
+          "black"
+        ];
+        const color = colors[this.getInsecureHash(colors.length)];
+        return [
+          "span",
+          {},
+          [
+            "span",
+            {},
+            "PublicKey("
+          ],
+          [
+            "span",
+            {
+              style: `color: ${color};`
+            },
+            this.truncate()
+          ],
+          [
+            "span",
+            {},
+            ")"
+          ]
+        ];
+      }
+    };
+  }
+  /**
+  * Test this key for equality with some other key.
+  */
+  equals(other) {
+    const otherConverted = _PublicKey.from(other);
+    if (this._value.length !== otherConverted._value.length) {
+      return false;
+    }
+    let equal = true;
+    for (let i = 0; i < this._value.length; i++) {
+      equal &&= this._value[i] === otherConverted._value[i];
+    }
+    return equal;
+  }
+  [equalsSymbol](other) {
+    if (!_PublicKey.isPublicKey(other)) {
+      return false;
+    }
+    return this.equals(other);
+  }
+};
+
+// packages/common/keys/src/space-id.ts
+var import_base32_decode2 = __toESM(require_base32_decode());
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/keys/src/space-id.ts";
+var SpaceId = Object.freeze({
+  byteLength: 20,
+  encode: (value) => {
+    invariant2(value instanceof Uint8Array, "Invalid type", {
+      F: __dxlog_file2,
+      L: 22,
+      S: void 0,
+      A: [
+        "value instanceof Uint8Array",
+        "'Invalid type'"
+      ]
+    });
+    invariant2(value.length === SpaceId.byteLength, "Invalid length", {
+      F: __dxlog_file2,
+      L: 23,
+      S: void 0,
+      A: [
+        "value.length === SpaceId.byteLength",
+        "'Invalid length'"
+      ]
+    });
+    return MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
+  },
+  decode: (value) => {
+    invariant2(value.startsWith(MULTIBASE_PREFIX), "Invalid multibase32 encoding", {
+      F: __dxlog_file2,
+      L: 28,
+      S: void 0,
+      A: [
+        "value.startsWith(MULTIBASE_PREFIX)",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new Uint8Array((0, import_base32_decode2.default)(value.slice(1), "RFC4648"));
+  },
+  isValid: (value) => {
+    return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+  },
+  random: () => {
+    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+  }
+});
+var MULTIBASE_PREFIX = "B";
+var ENCODED_LENGTH = 33;
+
+// packages/common/keys/src/dxn.ts
+import { invariant as invariant3 } from "@dxos/invariant";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/common/keys/src/dxn.ts";
+var DXN = class _DXN {
+  static {
+    /**
+    * Kind constants.
+    */
+    this.kind = Object.freeze({
+      ECHO: "echo",
+      TYPE: "type"
+    });
+  }
+  static parse(dxn) {
+    if (typeof dxn !== "string") {
+      throw new Error("Invalid DXN");
+    }
+    const [prefix, kind, ...parts] = dxn.split(":");
+    if (!(prefix === "dxn")) {
+      throw new Error("Invalid DXN");
+    }
+    if (!(typeof kind === "string" && kind.length > 0)) {
+      throw new Error("Invalid DXN");
+    }
+    if (!(parts.length > 0)) {
+      throw new Error("Invalid DXN");
+    }
+    return new _DXN(kind, parts);
+  }
+  static isDXNString(dxn) {
+    return dxn.startsWith("dxn:");
+  }
+  static localEchoObjectDXN(id) {
+    return new _DXN(_DXN.kind.ECHO, [
+      LOCAL_SPACE_TAG,
+      id
+    ]);
+  }
+  #kind;
+  #parts;
+  constructor(kind, parts) {
+    invariant3(parts.length > 0, void 0, {
+      F: __dxlog_file3,
+      L: 62,
+      S: this,
+      A: [
+        "parts.length > 0",
+        ""
+      ]
+    });
+    invariant3(parts.every((part) => typeof part === "string" && part.length > 0 && part.indexOf(":") === -1), void 0, {
+      F: __dxlog_file3,
+      L: 63,
+      S: this,
+      A: [
+        "parts.every((part) => typeof part === 'string' && part.length > 0 && part.indexOf(':') === -1)",
+        ""
+      ]
+    });
+    switch (kind) {
+      case _DXN.kind.ECHO:
+        if (parts.length !== 2) {
+          throw new Error('Invalid "echo" DXN');
+        }
+        break;
+      case _DXN.kind.TYPE:
+        if (parts.length !== 1) {
+          throw new Error('Invalid "type" DXN');
+        }
+        break;
+    }
+    this.#kind = kind;
+    this.#parts = parts;
+  }
+  get kind() {
+    return this.#kind;
+  }
+  get parts() {
+    return this.#parts;
+  }
+  isTypeDXNOf(typename) {
+    return this.#kind === _DXN.kind.TYPE && this.#parts.length === 1 && this.#parts[0] === typename;
+  }
+  isLocalEchoObjectDXN() {
+    return this.#kind === _DXN.kind.ECHO && this.#parts[0] === LOCAL_SPACE_TAG && this.#parts.length === 2;
+  }
+  toString() {
+    return `dxn:${this.#kind}:${this.#parts.join(":")}`;
+  }
+};
+var LOCAL_SPACE_TAG = "@";
+export {
+  DXN,
+  LOCAL_SPACE_TAG,
+  PUBLIC_KEY_LENGTH,
+  PublicKey,
+  SECRET_KEY_LENGTH,
+  SpaceId
+};
+//# sourceMappingURL=index.mjs.map