@dxos/keys 0.8.4-main.fdfb99ef29 → 0.8.4-staging.60fe92afc8

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

@@ -14,6 +14,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -81,74 +85,144 @@ var require_base32_decode = __commonJS({
   }
 });
 
-// src/dxn.ts
-import * as Schema3 from "effect/Schema";
-import { devtoolsFormatter, inspectCustom } from "@dxos/debug";
-import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
-
-// src/object-id.ts
-import * as Schema from "effect/Schema";
-import { monotonicFactory } 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}$"
+// src/DXN.ts
+var DXN_exports = {};
+__export(DXN_exports, {
+  Schema: () => Schema_,
+  getName: () => getName,
+  getVersion: () => getVersion,
+  isDXN: () => isDXN,
+  make: () => make,
+  tryMake: () => tryMake
 });
-var ObjectId = class extends ObjectIdSchema {
-  static #factory = monotonicFactory();
-  static #seedTime = void 0;
-  static isValid(id) {
-    try {
-      Schema.decodeSync(ObjectId)(id);
-      return true;
-    } catch {
-      return false;
-    }
+import * as Schema from "effect/Schema";
+var DXN_SPEC_REGEXP = /^dxn:[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z][a-zA-Z0-9]{0,62})(:\d+\.\d+\.\d+)?$/;
+var isDXN = (value) => typeof value === "string" && value.startsWith("dxn:");
+var make = (nsid, version) => parse(version != null ? `dxn:${nsid}:${version}` : `dxn:${nsid}`);
+var tryMake = (dxn) => {
+  try {
+    return parse(dxn);
+  } catch {
+    return void 0;
   }
-  static random() {
-    return this.#factory(this.#seedTime);
+};
+var parse = (dxn) => {
+  if (typeof dxn === "string" && DXN_SPEC_REGEXP.test(dxn)) {
+    return dxn;
   }
-  static dangerouslyDisableRandomness() {
-    this.#factory = monotonicFactory(makeTestPRNG());
-    this.#seedTime = (/* @__PURE__ */ new Date("2025-01-01")).getTime();
+  throw new Error(`Invalid DXN: ${dxn}`);
+};
+var getName = (dxn) => {
+  const match = /^dxn:([^:]+)/.exec(dxn);
+  if (!match) {
+    throw new Error(`Invalid DXN: ${dxn}`);
   }
+  return match[1];
 };
-var makeTestPRNG = () => {
-  const rng = new SimplePRNG();
-  return () => {
-    return rng.next();
-  };
+var getVersion = (dxn) => {
+  const match = /^dxn:[^:]+:(\d+\.\d+\.\d+)$/.exec(dxn);
+  return match?.[1];
 };
-var SimplePRNG = class _SimplePRNG {
-  #seed;
-  // LCG parameters (from Numerical Recipes)
-  static #a = 1664525;
-  static #c = 1013904223;
-  static #m = Math.pow(2, 32);
-  /**
-  * Creates a new PRNG instance.
-  * @param seed - Initial seed value. If not provided, uses 0.
-  */
-  constructor(seed = 0) {
-    this.#seed = seed;
-  }
-  /**
-  * Generates the next pseudo-random number in the range [0, 1).
-  * @returns A pseudo-random number between 0 (inclusive) and 1 (exclusive).
-  */
-  next() {
-    this.#seed = (_SimplePRNG.#a * this.#seed + _SimplePRNG.#c) % _SimplePRNG.#m;
-    return this.#seed / _SimplePRNG.#m;
-  }
-  /**
-  * Resets the generator with a new seed.
-  * @param seed - New seed value.
-  */
-  reset(seed) {
-    this.#seed = seed;
+var Schema_ = Schema.String.pipe(Schema.filter((value) => isDXN(value), {
+  message: () => "Invalid DXN"
+}), Schema.annotations({
+  title: "DXN",
+  description: "DXN URI: dxn:<nsid>[:<version>]"
+}));
+
+// src/EID.ts
+var EID_exports = {};
+__export(EID_exports, {
+  Schema: () => Schema_2,
+  equals: () => equals,
+  getEntityId: () => getEntityId,
+  getSpaceId: () => getSpaceId,
+  isEID: () => isEID,
+  isLocal: () => isLocal,
+  make: () => make2,
+  parse: () => parse2,
+  toLocal: () => toLocal,
+  tryParse: () => tryParse
+});
+import * as Schema2 from "effect/Schema";
+var ECHO_URI_REGEXP = /^echo:(?:\/\/[^/]+(?:\/[^/]+)?|(?:\/\/\/|\/)[^/]+)$/;
+var QUALIFIED_RE = /^echo:\/\/([^/]+)\/([^/]+)$/;
+var SPACE_ONLY_RE = /^echo:\/\/([^/]+)$/;
+var LOCAL_RE = /^echo:(?:\/\/\/|\/)([^/]+)$/;
+var isEID = (value) => typeof value === "string" && value.startsWith("echo:");
+var parse2 = (uri) => {
+  if (!ECHO_URI_REGEXP.test(uri)) {
+    throw new Error(`Invalid EID: ${uri}`);
+  }
+  return uri;
+};
+var tryParse = (uri) => {
+  try {
+    return parse2(uri);
+  } catch {
+    return void 0;
   }
 };
+var make2 = ({ spaceId, entityId }) => {
+  let raw;
+  if (spaceId != null && entityId != null) {
+    raw = `echo://${spaceId}/${entityId}`;
+  } else if (entityId != null) {
+    raw = `echo:/${entityId}`;
+  } else if (spaceId != null) {
+    raw = `echo://${spaceId}`;
+  } else {
+    throw new Error("EID.make requires at least one of spaceId or entityId");
+  }
+  return parse2(raw);
+};
+var getSpaceId = (uri) => {
+  const normalized = parse2(uri);
+  const match = QUALIFIED_RE.exec(normalized) ?? SPACE_ONLY_RE.exec(normalized);
+  return match?.[1];
+};
+var getEntityId = (uri) => {
+  const normalized = parse2(uri);
+  const qualMatch = QUALIFIED_RE.exec(normalized);
+  if (qualMatch) {
+    return qualMatch[2];
+  }
+  const localMatch = LOCAL_RE.exec(normalized);
+  return localMatch?.[1];
+};
+var isLocal = (uri) => {
+  const normalized = parse2(uri);
+  return LOCAL_RE.test(normalized);
+};
+var toLocal = (uri) => {
+  const entityId = getEntityId(uri);
+  return entityId != null ? make2({
+    entityId
+  }) : parse2(uri);
+};
+var equals = (a, b) => parse2(a) === parse2(b);
+var Schema_2 = Schema2.String.pipe(Schema2.filter((value) => isEID(value), {
+  message: () => "Invalid EID: must start with echo:"
+}), Schema2.annotations({
+  title: "EID",
+  description: "ECHO object/space URI: echo://<spaceId>[/<objectId>] or echo:/<objectId>"
+}));
 
-// src/space-id.ts
+// src/URI.ts
+var URI_exports = {};
+__export(URI_exports, {
+  Schema: () => Schema_3,
+  isURI: () => isURI,
+  make: () => make3
+});
+import * as Schema3 from "effect/Schema";
+var make3 = (uri) => uri;
+var isURI = (value) => typeof value === "string" && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value);
+var Schema_3 = Schema3.String.pipe(Schema3.filter((value) => isURI(value), {
+  message: () => "Invalid URI"
+}));
+
+// src/identity-did.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
@@ -210,8 +284,8 @@ function base32Encode(data, variant, options) {
   return output;
 }
 
-// src/space-id.ts
-import * as Schema2 from "effect/Schema";
+// src/identity-did.ts
+import * as Schema4 from "effect/Schema";
 import { invariant } from "@dxos/invariant";
 
 // src/random-bytes.ts
@@ -222,313 +296,158 @@ var randomBytes = (length) => {
   return bytes;
 };
 
-// src/space-id.ts
+// src/identity-did.ts
 var MULTIBASE_PREFIX = "B";
-var ENCODED_LENGTH = 33;
+var DID_PREFIX = "did:halo:";
+var DECODED_BYTE_LENGTH = 20;
+var ENCODED_LENGTH = 42;
+var RFC4648_BASE32_PATTERN = /^[A-Z2-7]+$/;
 var isValid = (value) => {
-  return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH;
+  if (typeof value !== "string" || !value.startsWith(DID_PREFIX + MULTIBASE_PREFIX) || value.length !== ENCODED_LENGTH) {
+    return false;
+  }
+  const encoded = value.slice(DID_PREFIX.length + MULTIBASE_PREFIX.length);
+  if (!RFC4648_BASE32_PATTERN.test(encoded)) {
+    return false;
+  }
+  try {
+    return (0, import_base32_decode.default)(encoded, "RFC4648").byteLength === DECODED_BYTE_LENGTH;
+  } catch {
+    return false;
+  }
 };
-var SpaceId = class extends Schema2.String.pipe(Schema2.filter(isValid)) {
-  static byteLength = 20;
+var IdentityDid = class extends Schema4.String.pipe(Schema4.filter(isValid)) {
+  static byteLength = DECODED_BYTE_LENGTH;
   static encode = (value) => {
     invariant(value instanceof Uint8Array, "Invalid type");
-    invariant(value.length === SpaceId.byteLength, "Invalid length");
-    return MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
+    invariant(value.length === IdentityDid.byteLength, "Invalid length");
+    return DID_PREFIX + MULTIBASE_PREFIX + base32Encode(value, "RFC4648");
   };
   static decode = (value) => {
-    invariant(value.startsWith(MULTIBASE_PREFIX), "Invalid multibase32 encoding");
-    return new Uint8Array((0, import_base32_decode.default)(value.slice(1), "RFC4648"));
+    invariant(value.startsWith(DID_PREFIX + MULTIBASE_PREFIX), "Invalid multibase32 encoding");
+    return new Uint8Array((0, import_base32_decode.default)(value.slice(DID_PREFIX.length + MULTIBASE_PREFIX.length), "RFC4648"));
   };
   static isValid = isValid;
   static random = () => {
-    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+    return IdentityDid.encode(randomBytes(IdentityDid.byteLength));
   };
 };
 
-// src/dxn.ts
-var LOCAL_SPACE_TAG = "@";
-var DXN_ECHO_REGEXP = /@(dxn:[a-zA-Z0-p:@]+)/;
-var QueueSubspaceTags = Object.freeze({
-  DATA: "data",
-  TRACE: "trace"
+// src/entity-id.ts
+import * as Schema5 from "effect/Schema";
+import { monotonicFactory } from "ulidx";
+var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var EntityIdSchema = Schema5.String.pipe(Schema5.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 DXN = class _DXN {
-  // TODO(burdon): Rename to DXN (i.e., DXN.DXN).
-  // TODO(dmaretskyi): Should this be a transformation into the DXN type?
-  static 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(TypeFormat.DXN),
-    Schema3.annotations({
-      title: "DXN",
-      description: "DXN URI",
-      examples: [
-        "dxn:type:com.example.type.my-type",
-        "dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6"
-      ]
-    })
-  );
-  static hash(dxn) {
-    return dxn.toString();
-  }
-  /**
-  * Kind constants.
-  */
-  static 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 to update "echo").
-    // 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"
-  });
-  /**
-  * Exactly equals.
-  */
-  static equals(a, b) {
-    return a.kind === b.kind && a.parts.length === b.parts.length && a.parts.every((part, i) => part === b.parts[i]);
-  }
-  static equalsEchoId(a, b) {
-    const a1 = a.asEchoDXN();
-    const b1 = b.asEchoDXN();
-    return !!a1 && !!b1 && a1.echoId === b1.echoId;
+var EntityId = class extends EntityIdSchema {
+  static #factory = monotonicFactory();
+  static #seedTime = void 0;
+  static isValid(id) {
+    try {
+      Schema5.decodeSync(EntityId)(id);
+      return true;
+    } catch {
+      return false;
+    }
   }
-  // TODO(burdon): Rename isValid.
-  static isDXNString(dxn) {
-    return dxn.startsWith("dxn:");
+  static random() {
+    return this.#factory(this.#seedTime);
   }
-  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}`);
+  static deterministic(...seed) {
+    const input = seed.map((value) => String(value)).join("\0");
+    let h1 = 2166136261 >>> 0;
+    let h2 = 461845907 >>> 0;
+    for (let i = 0; i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      h1 = Math.imul(h1 ^ code, 16777619) >>> 0;
+      h2 = Math.imul(h2 ^ (code << 13 | code >>> 3), 16777619) >>> 0;
     }
-    if (!(parts.length > 0)) {
-      throw new Error(`Invalid DXN: ${dxn}`);
+    const time = ALPHABET[0].repeat(10);
+    let bits = BigInt(h1) << 32n | BigInt(h2);
+    let rand = "";
+    for (let i = 0; i < 16; i++) {
+      rand = ALPHABET[Number(bits & 0x1fn)] + rand;
+      bits >>= 5n;
     }
-    return new _DXN(kind, parts);
+    return time + rand;
   }
-  static tryParse(dxn) {
-    try {
-      return _DXN.parse(dxn);
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-  * @example `dxn:type:com.example.type.person`
-  */
-  static fromTypename(typename) {
-    return new _DXN(_DXN.kind.TYPE, [
-      typename
-    ]);
+  static dangerouslyDisableRandomness() {
+    this.#factory = monotonicFactory(makeTestPRNG());
+    this.#seedTime = (/* @__PURE__ */ new Date("2025-01-01")).getTime();
   }
-  /**
-  * @example `dxn:type:com.example.type.person:0.1.0`
-  */
-  // TODO(dmaretskyi): Consider using @ as the version separator.
-  static fromTypenameAndVersion(typename, version) {
-    return new _DXN(_DXN.kind.TYPE, [
-      typename,
-      version
-    ]);
+  static dangerouslySetSeed(time, seed) {
+    this.#factory = monotonicFactory(makeTestPRNG(seed));
+    this.#seedTime = time;
   }
+};
+var makeTestPRNG = (seed = 0) => {
+  const rng = new SimplePRNG(seed);
+  return () => {
+    return rng.next();
+  };
+};
+var SimplePRNG = class _SimplePRNG {
+  #seed;
+  // LCG parameters (from Numerical Recipes)
+  static #a = 1664525;
+  static #c = 1013904223;
+  static #m = Math.pow(2, 32);
   /**
-  * @example `dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6`
+  * Creates a new PRNG instance.
+  * @param seed - Initial seed value. If not provided, uses 0.
   */
-  static fromSpaceAndObjectId(spaceId, objectId) {
-    assertArgument(SpaceId.isValid(spaceId), `Invalid space ID: ${spaceId}`);
-    assertArgument(ObjectId.isValid(objectId), "objectId", `Invalid object ID: ${objectId}`);
-    return new _DXN(_DXN.kind.ECHO, [
-      spaceId,
-      objectId
-    ]);
+  constructor(seed = 0) {
+    this.#seed = seed;
   }
   /**
-  * @example `dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6`
+  * Generates the next pseudo-random number in the range [0, 1).
+  * @returns A pseudo-random number between 0 (inclusive) and 1 (exclusive).
   */
-  static fromLocalObjectId(id) {
-    assertArgument(ObjectId.isValid(id), "id", `Invalid object ID: ${id}`);
-    return new _DXN(_DXN.kind.ECHO, [
-      LOCAL_SPACE_TAG,
-      id
-    ]);
-  }
-  static fromQueue(subspaceTag, spaceId, queueId, objectId) {
-    assertArgument(SpaceId.isValid(spaceId), `Invalid space ID: ${spaceId}`);
-    assertArgument(ObjectId.isValid(queueId), "queueId", `Invalid queue ID: ${queueId}`);
-    assertArgument(!objectId || ObjectId.isValid(objectId), "objectId", `Invalid object ID: ${objectId}`);
-    return new _DXN(_DXN.kind.QUEUE, [
-      subspaceTag,
-      spaceId,
-      queueId,
-      ...objectId ? [
-        objectId
-      ] : []
-    ]);
-  }
-  #kind;
-  #parts;
-  constructor(kind, parts) {
-    assertArgument(parts.length > 0, "parts", `Invalid DXN: ${parts}`);
-    assertArgument(parts.every((part) => typeof part === "string" && part.length > 0 && part.indexOf(":") === -1), "parts", `Invalid DXN: ${parts}`);
-    switch (kind) {
-      case _DXN.kind.TYPE:
-        if (parts.length > 2) {
-          throw new Error("Invalid DXN.kind.TYPE");
-        }
-        break;
-      case _DXN.kind.ECHO:
-        if (parts.length !== 2) {
-          throw new Error("Invalid DXN.kind.ECHO");
-        }
-        break;
-    }
-    this.#kind = kind;
-    this.#parts = parts;
-  }
-  toString() {
-    return `dxn:${this.#kind}:${this.#parts.join(":")}`;
-  }
-  toJSON() {
-    return this.toString();
+  next() {
+    this.#seed = (_SimplePRNG.#a * this.#seed + _SimplePRNG.#c) % _SimplePRNG.#m;
+    return this.#seed / _SimplePRNG.#m;
   }
   /**
-  * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.
+  * Resets the generator with a new seed.
+  * @param seed - New seed value.
   */
-  [inspectCustom](depth, options, inspectFn) {
-    const printControlCode = (code) => {
-      return `\x1B[${code}m`;
-    };
-    return printControlCode(inspectFn.colors.blueBright[0]) + this.toString() + printControlCode(inspectFn.colors.reset[0]);
-  }
-  get [devtoolsFormatter]() {
-    return {
-      header: () => {
-        return [
-          "span",
-          {
-            style: "font-weight: bold;"
-          },
-          this.toString()
-        ];
-      }
-    };
-  }
-  get kind() {
-    return this.#kind;
-  }
-  get parts() {
-    return this.#parts;
-  }
-  // TODO(burdon): Should getters fail?
-  get typename() {
-    invariant2(this.#kind === _DXN.kind.TYPE);
-    return this.#parts[0];
-  }
-  equals(other) {
-    return _DXN.equals(this, other);
-  }
-  hasTypenameOf(typename) {
-    return this.#kind === _DXN.kind.TYPE && this.#parts.length === 1 && this.#parts[0] === typename;
-  }
-  isLocalObjectId() {
-    return this.#kind === _DXN.kind.ECHO && this.#parts[0] === LOCAL_SPACE_TAG && this.#parts.length === 2;
+  reset(seed) {
+    this.#seed = seed;
   }
-  asTypeDXN() {
-    if (this.kind !== _DXN.kind.TYPE) {
-      return void 0;
-    }
-    const [type, version] = this.#parts;
+};
+
+// src/parse-id.ts
+var SPACE_ID_LENGTH = 33;
+var OBJECT_ID_LENGTH = 26;
+var FQ_ID_LENGTH = SPACE_ID_LENGTH + OBJECT_ID_LENGTH + 1;
+var parseId = (id) => {
+  if (!id) {
+    return {};
+  } else if (id.length === SPACE_ID_LENGTH) {
     return {
-      // TODO(wittjosiah): Should be `typename` for consistency.
-      type,
-      version
+      spaceId: id
     };
-  }
-  asEchoDXN() {
-    if (this.kind !== _DXN.kind.ECHO) {
-      return void 0;
-    }
-    const [spaceId, echoId] = this.#parts;
+  } else if (id.length === OBJECT_ID_LENGTH) {
     return {
-      spaceId: spaceId === LOCAL_SPACE_TAG ? void 0 : spaceId,
-      // TODO(burdon): objectId.
-      echoId
+      objectId: id
     };
-  }
-  asQueueDXN() {
-    if (this.kind !== _DXN.kind.QUEUE) {
-      return void 0;
-    }
-    const [subspaceTag, spaceId, queueId, objectId] = this.#parts;
-    if (typeof queueId !== "string") {
-      return void 0;
-    }
+  } else if (id.length === FQ_ID_LENGTH && id.indexOf(":") === SPACE_ID_LENGTH) {
+    const [spaceId, objectId] = id.split(":");
     return {
-      subspaceTag,
       spaceId,
-      queueId,
       objectId
     };
-  }
-  /**
-  * Produces a new DXN with the given parts appended.
-  */
-  extend(parts) {
-    return new _DXN(this.#kind, [
-      ...this.#parts,
-      ...parts
-    ]);
+  } else {
+    return {};
   }
 };
 
-// src/identity-did.ts
-var import_base32_decode2 = __toESM(require_base32_decode(), 1);
-import { invariant as invariant3 } from "@dxos/invariant";
-var IdentityDid = Object.freeze({
-  byteLength: 20,
-  encode: (value) => {
-    invariant3(value instanceof Uint8Array, "Invalid type");
-    invariant3(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");
-    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));
-  }
-});
-var MULTIBASE_PREFIX2 = "B";
-var DID_PREFIX = "did:halo:";
-var ENCODED_LENGTH2 = 42;
-
 // 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 import_base32_decode2 = __toESM(require_base32_decode(), 1);
+import { devtoolsFormatter, equalsSymbol, inspectCustom, truncateKey } from "@dxos/debug";
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
 var PUBLIC_KEY_LENGTH = 32;
 var SECRET_KEY_LENGTH = 64;
 var isLikeArrayBuffer = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value).constructor.name === "ArrayBuffer";
@@ -541,7 +460,7 @@ var PublicKey = class _PublicKey {
   * @returns PublicKey
   */
   static from(source) {
-    invariant4(source);
+    invariant2(source);
     if (source instanceof _PublicKey) {
       return source;
     } else if (source instanceof Buffer) {
@@ -625,7 +544,7 @@ var PublicKey = class _PublicKey {
   * @deprecated All keys should be represented as instances of PublicKey.
   */
   static bufferize(str) {
-    invariant4(typeof str === "string", "Invalid type");
+    assertArgument(typeof str === "string", "str", "Invalid type");
     const buffer = Buffer.from(str, "hex");
     return buffer;
   }
@@ -640,7 +559,7 @@ var PublicKey = class _PublicKey {
     } else if (key instanceof Uint8Array) {
       key = Buffer.from(key.buffer, key.byteOffset, key.byteLength);
     }
-    invariant4(key instanceof Buffer, "Invalid type");
+    invariant2(key instanceof Buffer, "Invalid type");
     return key.toString("hex");
   }
   /**
@@ -651,8 +570,8 @@ var PublicKey = class _PublicKey {
     return key.toHex();
   }
   static fromMultibase32(encoded) {
-    invariant4(encoded.startsWith("B"), "Invalid multibase32 encoding");
-    return new _PublicKey(new Uint8Array((0, import_base32_decode3.default)(encoded.slice(1), "RFC4648")));
+    invariant2(encoded.startsWith("B"), "Invalid multibase32 encoding");
+    return new _PublicKey(new Uint8Array((0, import_base32_decode2.default)(encoded.slice(1), "RFC4648")));
   }
   constructor(_value) {
     this._value = _value;
@@ -693,7 +612,7 @@ var PublicKey = class _PublicKey {
   /**
   * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.
   */
-  [inspectCustom2](depth, options, inspectFn) {
+  [inspectCustom](depth, options, inspectFn) {
     if (!options.colors || typeof process.stdout.hasColors !== "function" || !process.stdout.hasColors()) {
       return `<PublicKey ${this.truncate()}>`;
     }
@@ -718,7 +637,7 @@ var PublicKey = class _PublicKey {
     const color = colors[this.getInsecureHash(colors.length)];
     return `PublicKey(${printControlCode(inspectFn.colors[color][0])}${this.truncate()}${printControlCode(inspectFn.colors.reset[0])})`;
   }
-  get [devtoolsFormatter2]() {
+  get [devtoolsFormatter]() {
     return {
       header: () => {
         const colors = [
@@ -782,17 +701,46 @@ var PublicKey = class _PublicKey {
     return this.equals(other);
   }
 };
+
+// src/space-id.ts
+var import_base32_decode3 = __toESM(require_base32_decode(), 1);
+import * as Schema6 from "effect/Schema";
+import { invariant as invariant3 } from "@dxos/invariant";
+var MULTIBASE_PREFIX2 = "B";
+var ENCODED_LENGTH2 = 33;
+var isValid2 = (value) => {
+  return typeof value === "string" && value.startsWith(MULTIBASE_PREFIX2) && value.length === ENCODED_LENGTH2;
+};
+var SpaceId = class extends Schema6.String.pipe(Schema6.filter(isValid2)) {
+  static byteLength = 20;
+  static encode = (value) => {
+    invariant3(value instanceof Uint8Array, "Invalid type");
+    invariant3(value.length === SpaceId.byteLength, "Invalid length");
+    return MULTIBASE_PREFIX2 + base32Encode(value, "RFC4648");
+  };
+  static decode = (value) => {
+    invariant3(value.startsWith(MULTIBASE_PREFIX2), "Invalid multibase32 encoding");
+    return new Uint8Array((0, import_base32_decode3.default)(value.slice(1), "RFC4648"));
+  };
+  static isValid = isValid2;
+  static random = () => {
+    return SpaceId.encode(randomBytes(SpaceId.byteLength));
+  };
+};
 export {
-  DXN,
-  DXN_ECHO_REGEXP,
+  DXN_exports as DXN,
+  EID_exports as EID,
+  EntityId,
+  FQ_ID_LENGTH,
   IdentityDid,
-  LOCAL_SPACE_TAG,
-  ObjectId,
+  OBJECT_ID_LENGTH,
   PUBLIC_KEY_LENGTH,
   PublicKey,
-  QueueSubspaceTags,
   SECRET_KEY_LENGTH,
+  SPACE_ID_LENGTH,
   SimplePRNG,
-  SpaceId
+  SpaceId,
+  URI_exports as URI,
+  parseId
 };
 //# sourceMappingURL=index.mjs.map