@dxos/keys 0.8.2 → 0.8.3-main.7f5a14c

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

@@ -81,7 +81,33 @@ var require_base32_decode = __commonJS({
   }
 });
 
-// packages/common/keys/src/identity-did.ts
+// packages/common/keys/src/dxn.ts
+import { Schema as Schema3 } from "effect";
+import { devtoolsFormatter, inspectCustom } from "@dxos/debug";
+import { invariant as invariant2 } from "@dxos/invariant";
+
+// packages/common/keys/src/object-id.ts
+import { Schema } from "effect";
+import { ulid } from "ulidx";
+var ObjectIdSchema = Schema.String.pipe(Schema.pattern(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i)).annotations({
+  description: "a Universally Unique Lexicographically Sortable Identifier",
+  pattern: "^[0-7][0-9A-HJKMNP-TV-Z]{25}$"
+});
+var ObjectId = class extends ObjectIdSchema {
+  static isValid(id) {
+    try {
+      Schema.decodeSync(ObjectId)(id);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  static random() {
+    return ulid();
+  }
+};
+
+// packages/common/keys/src/space-id.ts
 var import_base32_decode = __toESM(require_base32_decode(), 1);
 
 // node_modules/.pnpm/to-data-view@2.0.0/node_modules/to-data-view/index.js
@@ -143,7 +169,8 @@ function base32Encode(data, variant, options) {
   return output;
 }
 
-// packages/common/keys/src/identity-did.ts
+// packages/common/keys/src/space-id.ts
+import { Schema as Schema2 } from "effect";
 import { invariant } from "@dxos/invariant";
 
 // packages/common/keys/src/random-bytes.ts
@@ -154,683 +181,672 @@ var randomBytes = (length) => {
   return bytes;
 };
 
-// packages/common/keys/src/identity-did.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/identity-did.ts";
-var IdentityDid = Object.freeze({
-  byteLength: 20,
-  encode: (value) => {
-    invariant(value instanceof Uint8Array, "Invalid type", {
-      F: __dxlog_file,
-      L: 22,
-      S: void 0,
-      A: [
-        "value instanceof Uint8Array",
-        "'Invalid type'"
-      ]
-    });
-    invariant(value.length === IdentityDid.byteLength, "Invalid length", {
-      F: __dxlog_file,
-      L: 23,
-      S: void 0,
-      A: [
-        "value.length === IdentityDid.byteLength",
-        "'Invalid length'"
-      ]
-    });
-    return DID_PREFIX + MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
-  },
-  decode: (value) => {
-    invariant(value.startsWith(DID_PREFIX + MULTIBASE_PREFIX), "Invalid multibase32 encoding", {
-      F: __dxlog_file,
-      L: 28,
-      S: void 0,
-      A: [
-        "value.startsWith(DID_PREFIX + MULTIBASE_PREFIX)",
-        "'Invalid multibase32 encoding'"
-      ]
-    });
-    return new Uint8Array((0, import_base32_decode.default)(value.slice(10), "RFC4648"));
-  },
-  isValid: (value) => {
-    return typeof value === "string" && value.startsWith(DID_PREFIX + MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
-  },
-  random: () => {
-    return IdentityDid.encode(randomBytes(IdentityDid.byteLength));
-  }
-});
+// packages/common/keys/src/space-id.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/keys/src/space-id.ts";
 var MULTIBASE_PREFIX = "B";
-var DID_PREFIX = "did:halo:";
-var ENCODED_LENGTH = 42;
+var ENCODED_LENGTH = 33;
+var isValid = (value) => {
+  return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+};
+var SpaceId = class extends Schema2.String.pipe(Schema2.filter(isValid)) {
+  static {
+    this.byteLength = 20;
+  }
+  static {
+    this.encode = (value) => {
+      invariant(value instanceof Uint8Array, "Invalid type", {
+        F: __dxlog_file,
+        L: 43,
+        S: this,
+        A: [
+          "value instanceof Uint8Array",
+          "'Invalid type'"
+        ]
+      });
+      invariant(value.length === SpaceId.byteLength, "Invalid length", {
+        F: __dxlog_file,
+        L: 44,
+        S: this,
+        A: [
+          "value.length === SpaceId.byteLength",
+          "'Invalid length'"
+        ]
+      });
+      return MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
+    };
+  }
+  static {
+    this.decode = (value) => {
+      invariant(value.startsWith(MULTIBASE_PREFIX), "Invalid multibase32 encoding", {
+        F: __dxlog_file,
+        L: 49,
+        S: this,
+        A: [
+          "value.startsWith(MULTIBASE_PREFIX)",
+          "'Invalid multibase32 encoding'"
+        ]
+      });
+      return new Uint8Array((0, import_base32_decode.default)(value.slice(1), "RFC4648"));
+    };
+  }
+  static {
+    this.isValid = isValid;
+  }
+  static {
+    this.random = () => {
+      return SpaceId.encode(randomBytes(SpaceId.byteLength));
+    };
+  }
+};
 
-// packages/common/keys/src/public-key.ts
-var import_base32_decode2 = __toESM(require_base32_decode(), 1);
-import { devtoolsFormatter, equalsSymbol, inspectCustom, truncateKey } from "@dxos/debug";
-import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file2 = "/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 {
+// packages/common/keys/src/dxn.ts
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/common/keys/src/dxn.ts";
+var LOCAL_SPACE_TAG = "@";
+var QueueSubspaceTags = Object.freeze({
+  DATA: "data",
+  TRACE: "trace"
+});
+var DXN = class _DXN {
   static {
-    this.ZERO = _PublicKey.from("00".repeat(PUBLIC_KEY_LENGTH));
+    // TODO(dmaretskyi): Should this be a transformation into the DXN type?
+    this.Schema = Schema3.NonEmptyString.pipe(
+      Schema3.pattern(/^dxn:([^:]+):(?:[^:]+:?)+[^:]$/),
+      // TODO(dmaretskyi): To set the format we need to move the annotation IDs out of the echo-schema package.
+      // FormatAnnotation.set(FormatEnum.DXN),
+      Schema3.annotations({
+        title: "DXN",
+        description: "DXN URI",
+        examples: [
+          "dxn:type:example.com/type/MyType",
+          "dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6"
+        ]
+      })
+    );
   }
-  /**
-  * 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) {
-    invariant2(source, void 0, {
-      F: __dxlog_file2,
-      L: 49,
-      S: this,
-      A: [
-        "source",
-        ""
-      ]
+  static hash(dxn) {
+    return dxn.toString();
+  }
+  static {
+    /**
+    * Kind constants.
+    */
+    this.kind = Object.freeze({
+      /**
+      * dxn:type:<type name>[:<version>]
+      */
+      TYPE: "type",
+      /**
+      * dxn:echo:<space id>:<echo id>
+      * dxn:echo:@:<echo id>
+      */
+      // TODO(burdon): Rename to OBJECT? (BREAKING CHANGE).
+      // TODO(burdon): Add separate Kind for space.
+      ECHO: "echo",
+      /**
+      * The subspace tag enables us to partition queues by usage within the context of a space.
+      * dxn:queue:<subspace_tag>:<space_id>:<queue_id>[:object_id]
+      * dxn:queue:data:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
+      * dxn:queue:trace:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
+      */
+      QUEUE: "queue"
     });
-    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;
+  get kind() {
+    return this.#kind;
+  }
+  static equals(a, b) {
+    return a.kind === b.kind && a.parts.length === b.parts.length && a.parts.every((part, i) => part === b.parts[i]);
+  }
+  // TODO(burdon): Rename isValid.
+  static isDXNString(dxn) {
+    return dxn.startsWith("dxn:");
+  }
+  static parse(dxn) {
+    if (typeof dxn !== "string") {
+      throw new Error(`Invalid DXN: ${dxn}`);
+    }
+    const [prefix, kind, ...parts] = dxn.split(":");
+    if (!(prefix === "dxn")) {
+      throw new Error(`Invalid DXN: ${dxn}`);
+    }
+    if (!(typeof kind === "string" && kind.length > 0)) {
+      throw new Error(`Invalid DXN: ${dxn}`);
     }
+    if (!(parts.length > 0)) {
+      throw new Error(`Invalid DXN: ${dxn}`);
+    }
+    return new _DXN(kind, parts);
+  }
+  static tryParse(dxn) {
     try {
-      const key = _PublicKey.from(source);
-      return key;
-    } catch (err) {
+      return _DXN.parse(dxn);
+    } catch (error) {
       return void 0;
     }
   }
   /**
-  * Creates new instance of PublicKey from hex string.
+  * @example `dxn:type:example.com/type/Contact`
   */
-  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));
+  static fromTypename(typename) {
+    return new _DXN(_DXN.kind.TYPE, [
+      typename
+    ]);
   }
   /**
-  * Creates a new key.
+  * @example `dxn:type:example.com/type/Contact:0.1.0`
   */
-  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");
-    }
+  // TODO(dmaretskyi): Consider using @ as the version separator.
+  static fromTypenameAndVersion(typename, version) {
+    return new _DXN(_DXN.kind.TYPE, [
+      typename,
+      version
+    ]);
   }
   /**
-  * Tests two keys for equality.
+  * @example `dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6`
   */
-  static equals(left, right) {
-    return _PublicKey.from(left).equals(right);
+  static fromLocalObjectId(id) {
+    return new _DXN(_DXN.kind.ECHO, [
+      LOCAL_SPACE_TAG,
+      id
+    ]);
   }
-  /**
-  * @param str string representation of key.
-  * @return Key buffer.
-  * @deprecated All keys should be represented as instances of PublicKey.
-  */
-  static bufferize(str) {
-    invariant2(typeof str === "string", "Invalid type", {
+  static fromQueue(subspaceTag, spaceId, queueId, objectId) {
+    invariant2(SpaceId.isValid(spaceId), void 0, {
+      F: __dxlog_file2,
+      L: 150,
+      S: this,
+      A: [
+        "SpaceId.isValid(spaceId)",
+        ""
+      ]
+    });
+    invariant2(ObjectId.isValid(queueId), void 0, {
+      F: __dxlog_file2,
+      L: 151,
+      S: this,
+      A: [
+        "ObjectId.isValid(queueId)",
+        ""
+      ]
+    });
+    invariant2(!objectId || ObjectId.isValid(objectId), void 0, {
       F: __dxlog_file2,
       L: 152,
       S: this,
       A: [
-        "typeof str === 'string'",
-        "'Invalid type'"
+        "!objectId || ObjectId.isValid(objectId)",
+        ""
       ]
     });
-    const buffer = Buffer.from(str, "hex");
-    return buffer;
+    return new _DXN(_DXN.kind.QUEUE, [
+      subspaceTag,
+      spaceId,
+      queueId,
+      ...objectId ? [
+        objectId
+      ] : []
+    ]);
   }
-  /**
-  * @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);
-    }
-    invariant2(key instanceof Buffer, "Invalid type", {
+  #kind;
+  #parts;
+  constructor(kind, parts) {
+    invariant2(parts.length > 0, void 0, {
       F: __dxlog_file2,
-      L: 171,
+      L: 161,
       S: this,
       A: [
-        "key instanceof Buffer",
-        "'Invalid type'"
+        "parts.length > 0",
+        ""
       ]
     });
-    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) {
-    invariant2(encoded.startsWith("B"), "Invalid multibase32 encoding", {
+    invariant2(parts.every((part) => typeof part === "string" && part.length > 0 && part.indexOf(":") === -1), void 0, {
       F: __dxlog_file2,
-      L: 184,
+      L: 162,
       S: this,
       A: [
-        "encoded.startsWith('B')",
-        "'Invalid multibase32 encoding'"
+        "parts.every((part) => typeof part === 'string' && part.length > 0 && part.indexOf(':') === -1)",
+        ""
       ]
     });
-    return new _PublicKey(new Uint8Array((0, import_base32_decode2.default)(encoded.slice(1), "RFC4648")));
-  }
-  constructor(_value) {
-    this._value = _value;
-    if (!(_value instanceof Uint8Array)) {
-      throw new TypeError(`Expected Uint8Array, got: ${_value}`);
+    switch (kind) {
+      case _DXN.kind.TYPE:
+        if (parts.length > 2) {
+          throw new Error('Invalid "type" DXN');
+        }
+        break;
+      case _DXN.kind.ECHO:
+        if (parts.length !== 2) {
+          throw new Error('Invalid "echo" DXN');
+        }
+        break;
     }
+    this.#kind = kind;
+    this.#parts = parts;
   }
-  toString() {
-    return this.toHex();
-  }
-  toJSON() {
-    return this.toHex();
-  }
-  toJSONL() {
-    return this.truncate();
+  get parts() {
+    return this.#parts;
   }
-  get length() {
-    return this._value.length;
+  // TODO(burdon): Should getters fail?
+  get typename() {
+    invariant2(this.#kind === _DXN.kind.TYPE, void 0, {
+      F: __dxlog_file2,
+      L: 188,
+      S: this,
+      A: [
+        "this.#kind === DXN.kind.TYPE",
+        ""
+      ]
+    });
+    return this.#parts[0];
   }
-  toHex() {
-    return this.asBuffer().toString("hex");
+  hasTypenameOf(typename) {
+    return this.#kind === _DXN.kind.TYPE && this.#parts.length === 1 && this.#parts[0] === typename;
   }
-  toMultibase32() {
-    return "B" + base32Encode(this._value, "RFC4648");
+  isLocalObjectId() {
+    return this.#kind === _DXN.kind.ECHO && this.#parts[0] === LOCAL_SPACE_TAG && this.#parts.length === 2;
   }
-  truncate(length = void 0) {
-    return truncateKey(this, length);
+  asTypeDXN() {
+    if (this.kind !== _DXN.kind.TYPE) {
+      return void 0;
+    }
+    const [type, version] = this.#parts;
+    return {
+      type,
+      version
+    };
   }
-  asBuffer() {
-    return Buffer.from(this._value.buffer, this._value.byteOffset, this._value.byteLength);
+  asEchoDXN() {
+    if (this.kind !== _DXN.kind.ECHO) {
+      return void 0;
+    }
+    const [spaceId, echoId] = this.#parts;
+    return {
+      spaceId: spaceId === LOCAL_SPACE_TAG ? void 0 : spaceId,
+      echoId
+    };
   }
-  asUint8Array() {
-    return this._value;
+  asQueueDXN() {
+    if (this.kind !== _DXN.kind.QUEUE) {
+      return void 0;
+    }
+    const [subspaceTag, spaceId, queueId, objectId] = this.#parts;
+    if (typeof queueId !== "string") {
+      return void 0;
+    }
+    return {
+      subspaceTag,
+      spaceId,
+      queueId,
+      objectId
+    };
   }
-  getInsecureHash(modulo) {
-    return Math.abs(this._value.reduce((acc, val) => acc ^ val | 0, 0)) % modulo;
+  toString() {
+    return `dxn:${this.#kind}:${this.#parts.join(":")}`;
   }
   /**
   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.
   */
   [inspectCustom](depth, options, inspectFn) {
-    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(inspectFn.colors[color][0])}${this.truncate()}${printControlCode(inspectFn.colors.reset[0])})`;
+    return printControlCode(inspectFn.colors.blueBright[0]) + this.toString() + printControlCode(inspectFn.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",
-            {},
-            ")"
-          ]
+          {
+            style: "font-weight: bold;"
+          },
+          this.toString()
         ];
       }
     };
   }
-  /**
-  * 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_decode3 = __toESM(require_base32_decode(), 1);
-import { Schema } from "effect";
+// packages/common/keys/src/identity-did.ts
+var import_base32_decode2 = __toESM(require_base32_decode(), 1);
 import { invariant as invariant3 } from "@dxos/invariant";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/common/keys/src/space-id.ts";
-var MULTIBASE_PREFIX2 = "B";
-var ENCODED_LENGTH2 = 33;
-var isValid = (value) => {
-  return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX2) && value.length === ENCODED_LENGTH2;
-};
-var SpaceId = class extends Schema.String.pipe(Schema.filter(isValid)) {
-  static {
-    this.byteLength = 20;
-  }
-  static {
-    this.encode = (value) => {
-      invariant3(value instanceof Uint8Array, "Invalid type", {
-        F: __dxlog_file3,
-        L: 43,
-        S: this,
-        A: [
-          "value instanceof Uint8Array",
-          "'Invalid type'"
-        ]
-      });
-      invariant3(value.length === SpaceId.byteLength, "Invalid length", {
-        F: __dxlog_file3,
-        L: 44,
-        S: this,
-        A: [
-          "value.length === SpaceId.byteLength",
-          "'Invalid length'"
-        ]
-      });
-      return MULTIBASE_PREFIX2 + base32Encode(value, "RFC4648");
-    };
-  }
-  static {
-    this.decode = (value) => {
-      invariant3(value.startsWith(MULTIBASE_PREFIX2), "Invalid multibase32 encoding", {
-        F: __dxlog_file3,
-        L: 49,
-        S: this,
-        A: [
-          "value.startsWith(MULTIBASE_PREFIX)",
-          "'Invalid multibase32 encoding'"
-        ]
-      });
-      return new Uint8Array((0, import_base32_decode3.default)(value.slice(1), "RFC4648"));
-    };
-  }
-  static {
-    this.isValid = isValid;
-  }
-  static {
-    this.random = () => {
-      return SpaceId.encode(randomBytes(SpaceId.byteLength));
-    };
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/common/keys/src/identity-did.ts";
+var IdentityDid = Object.freeze({
+  byteLength: 20,
+  encode: (value) => {
+    invariant3(value instanceof Uint8Array, "Invalid type", {
+      F: __dxlog_file3,
+      L: 22,
+      S: void 0,
+      A: [
+        "value instanceof Uint8Array",
+        "'Invalid type'"
+      ]
+    });
+    invariant3(value.length === IdentityDid.byteLength, "Invalid length", {
+      F: __dxlog_file3,
+      L: 23,
+      S: void 0,
+      A: [
+        "value.length === IdentityDid.byteLength",
+        "'Invalid length'"
+      ]
+    });
+    return DID_PREFIX + MULTIBASE_PREFIX2 + base32Encode(value, "RFC4648");
+  },
+  decode: (value) => {
+    invariant3(value.startsWith(DID_PREFIX + MULTIBASE_PREFIX2), "Invalid multibase32 encoding", {
+      F: __dxlog_file3,
+      L: 28,
+      S: void 0,
+      A: [
+        "value.startsWith(DID_PREFIX + MULTIBASE_PREFIX)",
+        "'Invalid multibase32 encoding'"
+      ]
+    });
+    return new Uint8Array((0, import_base32_decode2.default)(value.slice(10), "RFC4648"));
+  },
+  isValid: (value) => {
+    return typeof value === "string" && value.startsWith(DID_PREFIX + MULTIBASE_PREFIX2) && value.length === ENCODED_LENGTH2;
+  },
+  random: () => {
+    return IdentityDid.encode(randomBytes(IdentityDid.byteLength));
   }
-};
-
-// packages/common/keys/src/dxn.ts
-import { Schema as Schema3 } from "effect";
-import { inspectCustom as inspectCustom2 } from "@dxos/debug";
-import { invariant as invariant4 } from "@dxos/invariant";
-
-// packages/common/keys/src/object-id.ts
-import { Schema as Schema2 } from "effect";
-import { ulid } from "ulidx";
-var ObjectIdSchema = Schema2.String.pipe(Schema2.pattern(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i)).annotations({
-  description: "a Universally Unique Lexicographically Sortable Identifier",
-  pattern: "^[0-7][0-9A-HJKMNP-TV-Z]{25}$"
 });
-var ObjectId = class extends ObjectIdSchema {
-  static isValid(id) {
-    try {
-      Schema2.decodeSync(ObjectId)(id);
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-  static random() {
-    return ulid();
-  }
-};
+var MULTIBASE_PREFIX2 = "B";
+var DID_PREFIX = "did:halo:";
+var ENCODED_LENGTH2 = 42;
 
-// packages/common/keys/src/dxn.ts
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/common/keys/src/dxn.ts";
-var LOCAL_SPACE_TAG = "@";
-var QueueSubspaceTags = Object.freeze({
-  DATA: "data",
-  TRACE: "trace"
-});
-var DXN = class _DXN {
+// packages/common/keys/src/public-key.ts
+var import_base32_decode3 = __toESM(require_base32_decode(), 1);
+import { devtoolsFormatter as devtoolsFormatter2, equalsSymbol, inspectCustom as inspectCustom2, truncateKey } from "@dxos/debug";
+import { invariant as invariant4 } from "@dxos/invariant";
+var __dxlog_file4 = "/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 {
-    // TODO(dmaretskyi): Should this be a transformation into the DXN type?
-    this.Schema = Schema3.NonEmptyString.pipe(
-      Schema3.pattern(/^dxn:([^:]+):(?:[^:]+:?)+[^:]$/),
-      // TODO(dmaretskyi): To set the format we need to move the annotation IDs out of the echo-schema package.
-      // FormatAnnotation.set(FormatEnum.DXN),
-      Schema3.annotations({
-        title: "DXN",
-        description: "DXN URI",
-        examples: [
-          "dxn:type:example.com/type/MyType",
-          "dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6"
-        ]
-      })
-    );
+    this.ZERO = _PublicKey.from("00".repeat(PUBLIC_KEY_LENGTH));
   }
-  static {
-    /**
-    * Kind constants.
-    */
-    this.kind = Object.freeze({
-      /**
-      * dxn:type:<type name>[:<version>]
-      */
-      TYPE: "type",
-      /**
-      * dxn:echo:<space id>:<echo id>
-      * dxn:echo:@:<echo id>
-      */
-      // TODO(burdon): Rename to OBJECT? (BREAKING CHANGE).
-      // TODO(burdon): Add separate Kind for space.
-      ECHO: "echo",
-      /**
-      * The subspace tag enables us to partition queues by usage within the context of a space.
-      * dxn:queue:<subspace_tag>:<space_id>:<queue_id>[:object_id]
-      * dxn:queue:data:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
-      * dxn:queue:trace:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
-      */
-      QUEUE: "queue"
+  /**
+  * 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) {
+    invariant4(source, void 0, {
+      F: __dxlog_file4,
+      L: 49,
+      S: this,
+      A: [
+        "source",
+        ""
+      ]
     });
-  }
-  get kind() {
-    return this.#kind;
-  }
-  static equals(a, b) {
-    return a.kind === b.kind && a.parts.length === b.parts.length && a.parts.every((part, i) => part === b.parts[i]);
-  }
-  // TODO(burdon): Rename isValid.
-  static isDXNString(dxn) {
-    return dxn.startsWith("dxn:");
-  }
-  static parse(dxn) {
-    if (typeof dxn !== "string") {
-      throw new Error(`Invalid DXN: ${dxn}`);
+    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}`);
     }
-    const [prefix, kind, ...parts] = dxn.split(":");
-    if (!(prefix === "dxn")) {
-      throw new Error(`Invalid DXN: ${dxn}`);
+  }
+  /**
+  * 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;
     }
-    if (!(typeof kind === "string" && kind.length > 0)) {
-      throw new Error(`Invalid DXN: ${dxn}`);
+    try {
+      const key = _PublicKey.from(source);
+      return key;
+    } catch (err) {
+      return void 0;
     }
-    if (!(parts.length > 0)) {
-      throw new Error(`Invalid DXN: ${dxn}`);
+  }
+  /**
+  * Creates new instance of PublicKey from hex string.
+  */
+  static fromHex(hex) {
+    if (hex.startsWith("0x")) {
+      hex = hex.slice(2);
     }
-    return new _DXN(kind, parts);
+    const buf = Buffer.from(hex, "hex");
+    return new _PublicKey(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
   }
-  static tryParse(dxn) {
-    try {
-      return _DXN.parse(dxn);
-    } catch (error) {
-      return void 0;
+  /**
+  * 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");
   }
   /**
-  * @example `dxn:type:example.com/type/Contact`
+  * Tests if provided values is an instance of PublicKey.
   */
-  static fromTypename(typename) {
-    return new _DXN(_DXN.kind.TYPE, [
-      typename
-    ]);
+  static isPublicKey(value) {
+    return value instanceof _PublicKey;
   }
   /**
-  * @example `dxn:type:example.com/type/Contact:0.1.0`
+  * Asserts that provided values is an instance of PublicKey.
   */
-  // TODO(dmaretskyi): Consider using @ as the version separator.
-  static fromTypenameAndVersion(typename, version) {
-    return new _DXN(_DXN.kind.TYPE, [
-      typename,
-      version
-    ]);
+  static assertValidPublicKey(value) {
+    if (!this.isPublicKey(value)) {
+      throw new TypeError("Invalid PublicKey");
+    }
   }
   /**
-  * @example `dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6`
+  * Tests two keys for equality.
   */
-  static fromLocalObjectId(id) {
-    return new _DXN(_DXN.kind.ECHO, [
-      LOCAL_SPACE_TAG,
-      id
-    ]);
+  static equals(left, right) {
+    return _PublicKey.from(left).equals(right);
   }
-  static fromQueue(subspaceTag, spaceId, queueId, objectId) {
-    invariant4(SpaceId.isValid(spaceId), void 0, {
-      F: __dxlog_file4,
-      L: 146,
-      S: this,
-      A: [
-        "SpaceId.isValid(spaceId)",
-        ""
-      ]
-    });
-    invariant4(ObjectId.isValid(queueId), void 0, {
-      F: __dxlog_file4,
-      L: 147,
-      S: this,
-      A: [
-        "ObjectId.isValid(queueId)",
-        ""
-      ]
-    });
-    invariant4(!objectId || ObjectId.isValid(objectId), void 0, {
+  /**
+  * @param str string representation of key.
+  * @return Key buffer.
+  * @deprecated All keys should be represented as instances of PublicKey.
+  */
+  static bufferize(str) {
+    invariant4(typeof str === "string", "Invalid type", {
       F: __dxlog_file4,
-      L: 148,
+      L: 152,
       S: this,
       A: [
-        "!objectId || ObjectId.isValid(objectId)",
-        ""
+        "typeof str === 'string'",
+        "'Invalid type'"
       ]
     });
-    return new _DXN(_DXN.kind.QUEUE, [
-      subspaceTag,
-      spaceId,
-      queueId,
-      ...objectId ? [
-        objectId
-      ] : []
-    ]);
+    const buffer = Buffer.from(str, "hex");
+    return buffer;
   }
-  #kind;
-  #parts;
-  constructor(kind, parts) {
-    invariant4(parts.length > 0, void 0, {
-      F: __dxlog_file4,
-      L: 157,
-      S: this,
-      A: [
-        "parts.length > 0",
-        ""
-      ]
-    });
-    invariant4(parts.every((part) => typeof part === "string" && part.length > 0 && part.indexOf(":") === -1), void 0, {
+  /**
+  * @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);
+    }
+    invariant4(key instanceof Buffer, "Invalid type", {
       F: __dxlog_file4,
-      L: 158,
+      L: 171,
       S: this,
       A: [
-        "parts.every((part) => typeof part === 'string' && part.length > 0 && part.indexOf(':') === -1)",
-        ""
+        "key instanceof Buffer",
+        "'Invalid type'"
       ]
     });
-    switch (kind) {
-      case _DXN.kind.TYPE:
-        if (parts.length > 2) {
-          throw new Error('Invalid "type" DXN');
-        }
-        break;
-      case _DXN.kind.ECHO:
-        if (parts.length !== 2) {
-          throw new Error('Invalid "echo" DXN');
-        }
-        break;
-    }
-    this.#kind = kind;
-    this.#parts = parts;
+    return key.toString("hex");
   }
-  get parts() {
-    return this.#parts;
+  /**
+  * To be used with ComplexMap and ComplexSet.
+  * Returns a scalar representation for this key.
+  */
+  static hash(key) {
+    return key.toHex();
   }
-  // TODO(burdon): Should getters fail?
-  get typename() {
-    invariant4(this.#kind === _DXN.kind.TYPE, void 0, {
+  static fromMultibase32(encoded) {
+    invariant4(encoded.startsWith("B"), "Invalid multibase32 encoding", {
       F: __dxlog_file4,
       L: 184,
       S: this,
       A: [
-        "this.#kind === DXN.kind.TYPE",
-        ""
+        "encoded.startsWith('B')",
+        "'Invalid multibase32 encoding'"
       ]
     });
-    return this.#parts[0];
+    return new _PublicKey(new Uint8Array((0, import_base32_decode3.default)(encoded.slice(1), "RFC4648")));
   }
-  hasTypenameOf(typename) {
-    return this.#kind === _DXN.kind.TYPE && this.#parts.length === 1 && this.#parts[0] === typename;
+  constructor(_value) {
+    this._value = _value;
+    if (!(_value instanceof Uint8Array)) {
+      throw new TypeError(`Expected Uint8Array, got: ${_value}`);
+    }
   }
-  isLocalObjectId() {
-    return this.#kind === _DXN.kind.ECHO && this.#parts[0] === LOCAL_SPACE_TAG && this.#parts.length === 2;
+  toString() {
+    return this.toHex();
   }
-  asTypeDXN() {
-    if (this.kind !== _DXN.kind.TYPE) {
-      return void 0;
-    }
-    const [type, version] = this.#parts;
-    return {
-      type,
-      version
-    };
+  toJSON() {
+    return this.toHex();
   }
-  asEchoDXN() {
-    if (this.kind !== _DXN.kind.ECHO) {
-      return void 0;
-    }
-    const [spaceId, echoId] = this.#parts;
-    return {
-      spaceId: spaceId === LOCAL_SPACE_TAG ? void 0 : spaceId,
-      echoId
-    };
+  toJSONL() {
+    return this.truncate();
   }
-  asQueueDXN() {
-    if (this.kind !== _DXN.kind.QUEUE) {
-      return void 0;
-    }
-    const [subspaceTag, spaceId, queueId, objectId] = this.#parts;
-    if (typeof queueId !== "string") {
-      return void 0;
-    }
-    return {
-      subspaceTag,
-      spaceId,
-      queueId,
-      objectId
-    };
+  get length() {
+    return this._value.length;
   }
-  toString() {
-    return `dxn:${this.#kind}:${this.#parts.join(":")}`;
+  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.
   */
   [inspectCustom2](depth, options, inspectFn) {
+    if (!options.colors || typeof process.stdout.hasColors !== "function" || !process.stdout.hasColors()) {
+      return `<PublicKey ${this.truncate()}>`;
+    }
     const printControlCode = (code) => {
       return `\x1B[${code}m`;
     };
-    return printControlCode(inspectFn.colors.blueBright[0]) + this.toString() + printControlCode(inspectFn.colors.reset[0]);
+    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(inspectFn.colors[color][0])}${this.truncate()}${printControlCode(inspectFn.colors.reset[0])})`;
+  }
+  get [devtoolsFormatter2]() {
+    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);
   }
 };
 export {