@atproto/xrpc 0.0.4 → 0.1.0

package/dist/index.js

@@ -9,14 +9,14 @@ var __commonJS = (cb, mod2) => function __require() {
   return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from3, except, desc) => {
+  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
+    for (let key of __getOwnPropNames(from3))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
   }
   return to;
 };
@@ -76,8 +76,8 @@ var require_dist = __commonJS({
 });
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var src_exports4 = {};
+__export(src_exports4, {
   Client: () => Client,
   ResponseType: () => ResponseType,
   ResponseTypeNames: () => ResponseTypeNames,
@@ -90,7 +90,7 @@ __export(src_exports, {
   defaultFetchHandler: () => defaultFetchHandler,
   errorResponseBody: () => errorResponseBody
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(src_exports4);
 
 // ../../node_modules/zod/lib/index.mjs
 var util;
@@ -557,10 +557,10 @@ function processCreateParams(params2) {
   return { errorMap: customMap, description };
 }
 var ZodType = class {
-  constructor(def) {
+  constructor(def2) {
     this.spa = this.safeParseAsync;
     this.superRefine = this._refinement;
-    this._def = def;
+    this._def = def2;
     this.parse = this.parse.bind(this);
     this.safeParse = this.safeParse.bind(this);
     this.parseAsync = this.parseAsync.bind(this);
@@ -747,8 +747,8 @@ var ZodType = class {
       effect: { type: "transform", transform }
     });
   }
-  default(def) {
-    const defaultValueFunc = typeof def === "function" ? def : () => def;
+  default(def2) {
+    const defaultValueFunc = typeof def2 === "function" ? def2 : () => def2;
     return new ZodDefault({
       innerType: this,
       defaultValue: defaultValueFunc,
@@ -1460,7 +1460,7 @@ ZodVoid.create = (params2) => {
 var ZodArray = class extends ZodType {
   _parse(input) {
     const { ctx, status } = this._processInputParams(input);
-    const def = this._def;
+    const def2 = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -1469,39 +1469,39 @@ var ZodArray = class extends ZodType {
       });
       return INVALID;
     }
-    if (def.minLength !== null) {
-      if (ctx.data.length < def.minLength.value) {
+    if (def2.minLength !== null) {
+      if (ctx.data.length < def2.minLength.value) {
         addIssueToContext(ctx, {
           code: ZodIssueCode.too_small,
-          minimum: def.minLength.value,
+          minimum: def2.minLength.value,
           type: "array",
           inclusive: true,
-          message: def.minLength.message
+          message: def2.minLength.message
         });
         status.dirty();
       }
     }
-    if (def.maxLength !== null) {
-      if (ctx.data.length > def.maxLength.value) {
+    if (def2.maxLength !== null) {
+      if (ctx.data.length > def2.maxLength.value) {
         addIssueToContext(ctx, {
           code: ZodIssueCode.too_big,
-          maximum: def.maxLength.value,
+          maximum: def2.maxLength.value,
           type: "array",
           inclusive: true,
-          message: def.maxLength.message
+          message: def2.maxLength.message
         });
         status.dirty();
       }
     }
     if (ctx.common.async) {
       return Promise.all(ctx.data.map((item, i) => {
-        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+        return def2.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       })).then((result2) => {
         return ParseStatus.mergeArray(status, result2);
       });
     }
     const result = ctx.data.map((item, i) => {
-      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+      return def2.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
     return ParseStatus.mergeArray(status, result);
   }
@@ -1527,9 +1527,9 @@ var ZodArray = class extends ZodType {
     return this.min(1, message);
   }
 };
-ZodArray.create = (schema, params2) => {
+ZodArray.create = (schema2, params2) => {
   return new ZodArray({
-    type: schema,
+    type: schema2,
     minLength: null,
     maxLength: null,
     typeName: ZodFirstPartyTypeKind.ZodArray,
@@ -1545,36 +1545,36 @@ var objectUtil;
     };
   };
 })(objectUtil || (objectUtil = {}));
-var AugmentFactory = (def) => (augmentation) => {
+var AugmentFactory = (def2) => (augmentation) => {
   return new ZodObject({
-    ...def,
+    ...def2,
     shape: () => ({
-      ...def.shape(),
+      ...def2.shape(),
       ...augmentation
     })
   });
 };
-function deepPartialify(schema) {
-  if (schema instanceof ZodObject) {
+function deepPartialify(schema2) {
+  if (schema2 instanceof ZodObject) {
     const newShape = {};
-    for (const key in schema.shape) {
-      const fieldSchema = schema.shape[key];
+    for (const key in schema2.shape) {
+      const fieldSchema = schema2.shape[key];
       newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
     }
     return new ZodObject({
-      ...schema._def,
+      ...schema2._def,
       shape: () => newShape
     });
-  } else if (schema instanceof ZodArray) {
-    return ZodArray.create(deepPartialify(schema.element));
-  } else if (schema instanceof ZodOptional) {
-    return ZodOptional.create(deepPartialify(schema.unwrap()));
-  } else if (schema instanceof ZodNullable) {
-    return ZodNullable.create(deepPartialify(schema.unwrap()));
-  } else if (schema instanceof ZodTuple) {
-    return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+  } else if (schema2 instanceof ZodArray) {
+    return ZodArray.create(deepPartialify(schema2.element));
+  } else if (schema2 instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema2.unwrap()));
+  } else if (schema2 instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema2.unwrap()));
+  } else if (schema2 instanceof ZodTuple) {
+    return ZodTuple.create(schema2.items.map((item) => deepPartialify(item)));
   } else {
-    return schema;
+    return schema2;
   }
 }
 var ZodObject = class extends ZodType {
@@ -1712,8 +1712,8 @@ var ZodObject = class extends ZodType {
       unknownKeys: "passthrough"
     });
   }
-  setKey(key, schema) {
-    return this.augment({ [key]: schema });
+  setKey(key, schema2) {
+    return this.augment({ [key]: schema2 });
   }
   merge(merging) {
     const merged = new ZodObject({
@@ -2106,10 +2106,10 @@ var ZodTuple = class extends ZodType {
       status.dirty();
     }
     const items = ctx.data.map((item, itemIndex) => {
-      const schema = this._def.items[itemIndex] || this._def.rest;
-      if (!schema)
+      const schema2 = this._def.items[itemIndex] || this._def.rest;
+      if (!schema2)
         return null;
-      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+      return schema2._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
     }).filter((x) => !!x);
     if (ctx.common.async) {
       return Promise.all(items).then((results) => {
@@ -2263,27 +2263,27 @@ var ZodSet = class extends ZodType {
       });
       return INVALID;
     }
-    const def = this._def;
-    if (def.minSize !== null) {
-      if (ctx.data.size < def.minSize.value) {
+    const def2 = this._def;
+    if (def2.minSize !== null) {
+      if (ctx.data.size < def2.minSize.value) {
         addIssueToContext(ctx, {
           code: ZodIssueCode.too_small,
-          minimum: def.minSize.value,
+          minimum: def2.minSize.value,
           type: "set",
           inclusive: true,
-          message: def.minSize.message
+          message: def2.minSize.message
         });
         status.dirty();
       }
     }
-    if (def.maxSize !== null) {
-      if (ctx.data.size > def.maxSize.value) {
+    if (def2.maxSize !== null) {
+      if (ctx.data.size > def2.maxSize.value) {
         addIssueToContext(ctx, {
           code: ZodIssueCode.too_big,
-          maximum: def.maxSize.value,
+          maximum: def2.maxSize.value,
           type: "set",
           inclusive: true,
-          message: def.maxSize.message
+          message: def2.maxSize.message
         });
         status.dirty();
       }
@@ -2600,9 +2600,9 @@ var ZodPromise = class extends ZodType {
     }));
   }
 };
-ZodPromise.create = (schema, params2) => {
+ZodPromise.create = (schema2, params2) => {
   return new ZodPromise({
-    type: schema,
+    type: schema2,
     typeName: ZodFirstPartyTypeKind.ZodPromise,
     ...processCreateParams(params2)
   });
@@ -2683,40 +2683,40 @@ var ZodEffects = class extends ZodType {
     }
     if (effect.type === "transform") {
       if (ctx.common.async === false) {
-        const base = this._def.schema._parseSync({
+        const base3 = this._def.schema._parseSync({
           data: ctx.data,
           path: ctx.path,
           parent: ctx
         });
-        if (!isValid(base))
-          return base;
-        const result = effect.transform(base.value, checkCtx);
+        if (!isValid(base3))
+          return base3;
+        const result = effect.transform(base3.value, checkCtx);
         if (result instanceof Promise) {
           throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
         }
         return { status: status.value, value: result };
       } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
-          if (!isValid(base))
-            return base;
-          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base3) => {
+          if (!isValid(base3))
+            return base3;
+          return Promise.resolve(effect.transform(base3.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
         });
       }
     }
     util.assertNever(effect);
   }
 };
-ZodEffects.create = (schema, effect, params2) => {
+ZodEffects.create = (schema2, effect, params2) => {
   return new ZodEffects({
-    schema,
+    schema: schema2,
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     effect,
     ...processCreateParams(params2)
   });
 };
-ZodEffects.createWithPreprocess = (preprocess, schema, params2) => {
+ZodEffects.createWithPreprocess = (preprocess, schema2, params2) => {
   return new ZodEffects({
-    schema,
+    schema: schema2,
     effect: { type: "preprocess", transform: preprocess },
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params2)
@@ -3098,36 +3098,22 @@ var XRPCInvalidResponseError = class extends XRPCError {
 };
 
 // ../nsid/src/index.ts
-var SEGMENT_RE = /^[a-zA-Z]([a-zA-Z0-9-])*$/;
 var NSID = class {
-  constructor(nsid) {
+  constructor(nsid2) {
     this.segments = [];
-    const segments = nsid.split(".");
-    if (segments.length <= 2) {
-      throw new Error(`Invalid NSID: ${nsid}`);
-    }
-    for (let i = 0; i < segments.length; i++) {
-      const segment = segments[i];
-      if (SEGMENT_RE.test(segment)) {
-        continue;
-      }
-      if (i === segments.length - 1 && segment === "*") {
-        continue;
-      }
-      throw new Error(`Invalid NSID: invalid character in segment "${segment}"`);
-    }
-    this.segments = segments;
+    ensureValidNsid(nsid2);
+    this.segments = nsid2.split(".");
   }
-  static parse(nsid) {
-    return new NSID(nsid);
+  static parse(nsid2) {
+    return new NSID(nsid2);
   }
-  static create(authority, name) {
-    const segments = [...authority.split(".").reverse(), name].join(".");
+  static create(authority, name2) {
+    const segments = [...authority.split(".").reverse(), name2].join(".");
     return new NSID(segments);
   }
-  static isValid(nsid) {
+  static isValid(nsid2) {
     try {
-      NSID.parse(nsid);
+      NSID.parse(nsid2);
       return true;
     } catch (e) {
       return false;
@@ -3143,6 +3129,42 @@ var NSID = class {
     return this.segments.join(".");
   }
 };
+var ensureValidNsid = (nsid2) => {
+  const split = nsid2.split(".");
+  const toCheck = split.at(-1) === "*" ? split.slice(0, -1).join(".") : split.join(".");
+  if (!/^[a-zA-Z0-9.-]*$/.test(toCheck)) {
+    throw new InvalidNsidError(
+      "Disallowed characters in NSID (ASCII letters, digits, dashes, periods only)"
+    );
+  }
+  if (toCheck.length > 253 + 1 + 128) {
+    throw new InvalidNsidError("NSID is too long (382 chars max)");
+  }
+  const labels = toCheck.split(".");
+  if (split.length < 3) {
+    throw new InvalidNsidError("NSID needs at least three parts");
+  }
+  for (let i = 0; i < labels.length; i++) {
+    const l = labels[i];
+    if (l.length < 1) {
+      throw new InvalidNsidError("NSID parts can not be empty");
+    }
+    if (l.length > 63 && i + 1 < labels.length) {
+      throw new InvalidNsidError("NSID domain part too long (max 63 chars)");
+    }
+    if (l.length > 128 && i + 1 == labels.length) {
+      throw new InvalidNsidError("NSID name part too long (max 127 chars)");
+    }
+    if (l.endsWith("-")) {
+      throw new InvalidNsidError("NSID parts can not end with hyphen");
+    }
+    if (!/^[a-zA-Z]/.test(l)) {
+      throw new InvalidNsidError("NSID parts must start with ASCII letter");
+    }
+  }
+};
+var InvalidNsidError = class extends Error {
+};
 
 // ../lexicon/src/types.ts
 var lexBoolean = mod.object({
@@ -3151,8 +3173,8 @@ var lexBoolean = mod.object({
   default: mod.boolean().optional(),
   const: mod.boolean().optional()
 });
-var lexNumber = mod.object({
-  type: mod.literal("number"),
+var lexFloat = mod.object({
+  type: mod.literal("float"),
   description: mod.string().optional(),
   default: mod.number().optional(),
   minimum: mod.number().optional(),
@@ -3169,32 +3191,51 @@ var lexInteger = mod.object({
   enum: mod.number().int().array().optional(),
   const: mod.number().int().optional()
 });
+var lexStringFormat = mod.enum([
+  "datetime",
+  "uri",
+  "at-uri",
+  "did",
+  "handle",
+  "at-identifier",
+  "nsid",
+  "cid"
+]);
 var lexString = mod.object({
   type: mod.literal("string"),
+  format: lexStringFormat.optional(),
   description: mod.string().optional(),
   default: mod.string().optional(),
   minLength: mod.number().int().optional(),
   maxLength: mod.number().int().optional(),
+  minGraphemes: mod.number().int().optional(),
+  maxGraphemes: mod.number().int().optional(),
   enum: mod.string().array().optional(),
   const: mod.string().optional(),
   knownValues: mod.string().array().optional()
 });
-var lexDatetime = mod.object({
-  type: mod.literal("datetime"),
-  description: mod.string().optional()
-});
 var lexUnknown = mod.object({
   type: mod.literal("unknown"),
   description: mod.string().optional()
 });
 var lexPrimitive = mod.union([
   lexBoolean,
-  lexNumber,
+  lexFloat,
   lexInteger,
   lexString,
-  lexDatetime,
   lexUnknown
 ]);
+var lexBytes = mod.object({
+  type: mod.literal("bytes"),
+  description: mod.string().optional(),
+  maxLength: mod.number().optional(),
+  minLength: mod.number().optional()
+});
+var lexCidLink = mod.object({
+  type: mod.literal("cid-link"),
+  description: mod.string().optional()
+});
+var lexIpldType = mod.union([lexBytes, lexCidLink]);
 var lexRef = mod.object({
   type: mod.literal("ref"),
   description: mod.string().optional(),
@@ -3213,35 +3254,10 @@ var lexBlob = mod.object({
   accept: mod.string().array().optional(),
   maxSize: mod.number().optional()
 });
-var lexImage = mod.object({
-  type: mod.literal("image"),
-  description: mod.string().optional(),
-  accept: mod.string().array().optional(),
-  maxSize: mod.number().optional(),
-  maxWidth: mod.number().int().optional(),
-  maxHeight: mod.number().int().optional()
-});
-var lexVideo = mod.object({
-  type: mod.literal("video"),
-  description: mod.string().optional(),
-  accept: mod.string().array().optional(),
-  maxSize: mod.number().optional(),
-  maxWidth: mod.number().int().optional(),
-  maxHeight: mod.number().int().optional(),
-  maxLength: mod.number().int().optional()
-});
-var lexAudio = mod.object({
-  type: mod.literal("audio"),
-  description: mod.string().optional(),
-  accept: mod.string().array().optional(),
-  maxSize: mod.number().optional(),
-  maxLength: mod.number().int().optional()
-});
-var lexBlobVariant = mod.union([lexBlob, lexImage, lexVideo, lexAudio]);
 var lexArray = mod.object({
   type: mod.literal("array"),
   description: mod.string().optional(),
-  items: mod.union([lexPrimitive, lexBlobVariant, lexRefVariant]),
+  items: mod.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
   minLength: mod.number().int().optional(),
   maxLength: mod.number().int().optional()
 });
@@ -3258,7 +3274,10 @@ var lexObject = mod.object({
   type: mod.literal("object"),
   description: mod.string().optional(),
   required: mod.string().array().optional(),
-  properties: mod.record(mod.union([lexRefVariant, lexArray, lexBlobVariant, lexPrimitive])).optional()
+  nullable: mod.string().array().optional(),
+  properties: mod.record(
+    mod.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive])
+  ).optional()
 });
 var lexXrpcParameters = mod.object({
   type: mod.literal("params"),
@@ -3271,6 +3290,10 @@ var lexXrpcBody = mod.object({
   encoding: mod.string(),
   schema: mod.union([lexRefVariant, lexObject]).optional()
 });
+var lexXrpcSubscriptionMessage = mod.object({
+  description: mod.string().optional(),
+  schema: mod.union([lexRefVariant, lexObject]).optional()
+});
 var lexXrpcError = mod.object({
   name: mod.string(),
   description: mod.string().optional()
@@ -3290,6 +3313,14 @@ var lexXrpcProcedure = mod.object({
   output: lexXrpcBody.optional(),
   errors: lexXrpcError.array().optional()
 });
+var lexXrpcSubscription = mod.object({
+  type: mod.literal("subscription"),
+  description: mod.string().optional(),
+  parameters: lexXrpcParameters.optional(),
+  message: lexXrpcSubscriptionMessage.optional(),
+  infos: lexXrpcError.array().optional(),
+  errors: lexXrpcError.array().optional()
+});
 var lexRecord = mod.object({
   type: mod.literal("record"),
   description: mod.string().optional(),
@@ -3300,18 +3331,17 @@ var lexUserType = mod.union([
   lexRecord,
   lexXrpcQuery,
   lexXrpcProcedure,
+  lexXrpcSubscription,
   lexBlob,
-  lexImage,
-  lexVideo,
-  lexAudio,
   lexArray,
   lexToken,
   lexObject,
   lexBoolean,
-  lexNumber,
+  lexFloat,
   lexInteger,
   lexString,
-  lexDatetime,
+  lexBytes,
+  lexCidLink,
   lexUnknown
 ]);
 var lexiconDoc = mod.object({
@@ -3324,70 +3354,2522 @@ var lexiconDoc = mod.object({
   defs: mod.record(lexUserType)
 }).superRefine((doc, ctx) => {
   for (const defId in doc.defs) {
-    const def = doc.defs[defId];
-    if (defId !== "main" && (def.type === "record" || def.type === "procedure" || def.type === "query")) {
+    const def2 = doc.defs[defId];
+    if (defId !== "main" && (def2.type === "record" || def2.type === "procedure" || def2.type === "query" || def2.type === "subscription")) {
       ctx.addIssue({
         code: mod.ZodIssueCode.custom,
-        message: `Records, procedures, and queries must be the main definition.`
+        message: `Records, procedures, queries, and subscriptions must be the main definition.`
       });
     }
   }
-});
-function isObj(obj) {
-  return obj !== null && typeof obj === "object";
-}
-function hasProp(data, prop) {
-  return prop in data;
-}
-var discriminatedObject = mod.object({ $type: mod.string() });
-function isDiscriminatedObject(value) {
-  return discriminatedObject.safeParse(value).success;
-}
-var LexiconDocMalformedError = class extends Error {
-  constructor(message, schemaDef, issues) {
-    super(message);
-    this.schemaDef = schemaDef;
-    this.issues = issues;
-    this.schemaDef = schemaDef;
-    this.issues = issues;
+});
+function isObj(obj) {
+  return obj !== null && typeof obj === "object";
+}
+function hasProp(data, prop) {
+  return prop in data;
+}
+var discriminatedObject = mod.object({ $type: mod.string() });
+function isDiscriminatedObject(value) {
+  return discriminatedObject.safeParse(value).success;
+}
+var LexiconDocMalformedError = class extends Error {
+  constructor(message, schemaDef, issues) {
+    super(message);
+    this.schemaDef = schemaDef;
+    this.issues = issues;
+    this.schemaDef = schemaDef;
+    this.issues = issues;
+  }
+};
+var ValidationError = class extends Error {
+};
+var InvalidLexiconError = class extends Error {
+};
+var LexiconDefNotFoundError = class extends Error {
+};
+
+// ../common-web/src/check.ts
+var check_exports = {};
+__export(check_exports, {
+  assure: () => assure,
+  is: () => is,
+  isObject: () => isObject
+});
+var is = (obj, def2) => {
+  return def2.safeParse(obj).success;
+};
+var assure = (def2, obj) => {
+  return def2.parse(obj);
+};
+var isObject = (obj) => {
+  return typeof obj === "object" && obj !== null;
+};
+
+// ../../node_modules/multiformats/esm/vendor/varint.js
+var encode_1 = encode;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/multiformats/esm/src/varint.js
+var decode2 = (data, offset = 0) => {
+  const code2 = varint_default.decode(data, offset);
+  return [
+    code2,
+    varint_default.decode.bytes
+  ];
+};
+var encodeTo = (int, target, offset = 0) => {
+  varint_default.encode(int, target, offset);
+  return target;
+};
+var encodingLength = (int) => {
+  return varint_default.encodingLength(int);
+};
+
+// ../../node_modules/multiformats/esm/src/bytes.js
+var empty = new Uint8Array(0);
+var equals = (aa, bb) => {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+};
+var coerce = (o) => {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+};
+var fromString = (str) => new TextEncoder().encode(str);
+var toString = (b) => new TextDecoder().decode(b);
+
+// ../../node_modules/multiformats/esm/src/hashes/digest.js
+var create = (code2, digest2) => {
+  const size = digest2.byteLength;
+  const sizeOffset = encodingLength(code2);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes2 = new Uint8Array(digestOffset + size);
+  encodeTo(code2, bytes2, 0);
+  encodeTo(size, bytes2, sizeOffset);
+  bytes2.set(digest2, digestOffset);
+  return new Digest(code2, size, digest2, bytes2);
+};
+var decode3 = (multihash) => {
+  const bytes2 = coerce(multihash);
+  const [code2, sizeOffset] = decode2(bytes2);
+  const [size, digestOffset] = decode2(bytes2.subarray(sizeOffset));
+  const digest2 = bytes2.subarray(sizeOffset + digestOffset);
+  if (digest2.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code2, size, digest2, bytes2);
+};
+var equals2 = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    return a.code === b.code && a.size === b.size && equals(a.bytes, b.bytes);
+  }
+};
+var Digest = class {
+  constructor(code2, size, digest2, bytes2) {
+    this.code = code2;
+    this.size = size;
+    this.digest = digest2;
+    this.bytes = bytes2;
+  }
+};
+
+// ../../node_modules/multiformats/esm/src/bases/base58.js
+var base58_exports = {};
+__export(base58_exports, {
+  base58btc: () => base58btc,
+  base58flickr: () => base58flickr
+});
+
+// ../../node_modules/multiformats/esm/vendor/base-x.js
+function base(ALPHABET, name2) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode5(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode6(string3) {
+    var buffer = decodeUnsafe(string3);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name2} character`);
+  }
+  return {
+    encode: encode5,
+    decodeUnsafe,
+    decode: decode6
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/multiformats/esm/src/bases/base.js
+var Encoder = class {
+  constructor(name2, prefix, baseEncode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes2) {
+    if (bytes2 instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes2)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  constructor(name2, prefix, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    if (prefix.codePointAt(0) === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefix.codePointAt(0);
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+var or = (left, right) => new ComposedDecoder({
+  ...left.decoders || { [left.prefix]: left },
+  ...right.decoders || { [right.prefix]: right }
+});
+var Codec = class {
+  constructor(name2, prefix, baseEncode, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name2, prefix, baseEncode);
+    this.decoder = new Decoder(name2, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+var from = ({ name: name2, prefix, encode: encode5, decode: decode6 }) => new Codec(name2, prefix, encode5, decode6);
+var baseX = ({ prefix, name: name2, alphabet: alphabet2 }) => {
+  const { encode: encode5, decode: decode6 } = base_x_default(alphabet2, name2);
+  return from({
+    prefix,
+    name: name2,
+    encode: encode5,
+    decode: (text) => coerce(decode6(text))
+  });
+};
+var decode4 = (string3, alphabet2, bitsPerChar, name2) => {
+  const codes = {};
+  for (let i = 0; i < alphabet2.length; ++i) {
+    codes[alphabet2[i]] = i;
+  }
+  let end = string3.length;
+  while (string3[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string3[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name2} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+};
+var encode2 = (data, alphabet2, bitsPerChar) => {
+  const pad = alphabet2[alphabet2.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet2[mask & buffer >> bits];
+    }
+  }
+  if (bits) {
+    out += alphabet2[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += "=";
+    }
+  }
+  return out;
+};
+var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet: alphabet2 }) => {
+  return from({
+    prefix,
+    name: name2,
+    encode(input) {
+      return encode2(input, alphabet2, bitsPerChar);
+    },
+    decode(input) {
+      return decode4(input, alphabet2, bitsPerChar, name2);
+    }
+  });
+};
+
+// ../../node_modules/multiformats/esm/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base32.js
+var base32_exports = {};
+__export(base32_exports, {
+  base32: () => base32,
+  base32hex: () => base32hex,
+  base32hexpad: () => base32hexpad,
+  base32hexpadupper: () => base32hexpadupper,
+  base32hexupper: () => base32hexupper,
+  base32pad: () => base32pad,
+  base32padupper: () => base32padupper,
+  base32upper: () => base32upper,
+  base32z: () => base32z
+});
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../node_modules/multiformats/esm/src/cid.js
+var CID = class {
+  constructor(version2, code2, multihash, bytes2) {
+    this.code = code2;
+    this.version = version2;
+    this.multihash = multihash;
+    this.bytes = bytes2;
+    this.byteOffset = bytes2.byteOffset;
+    this.byteLength = bytes2.byteLength;
+    this.asCID = this;
+    this._baseCache = /* @__PURE__ */ new Map();
+    Object.defineProperties(this, {
+      byteOffset: hidden,
+      byteLength: hidden,
+      code: readonly,
+      version: readonly,
+      multihash: readonly,
+      bytes: readonly,
+      _baseCache: hidden,
+      asCID: hidden
+    });
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      default: {
+        const { code: code2, multihash } = this;
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return CID.createV0(multihash);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code: code2, digest: digest2 } = this.multihash;
+        const multihash = create(code2, digest2);
+        return CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return other && this.code === other.code && this.version === other.version && equals2(this.multihash, other.multihash);
+  }
+  toString(base3) {
+    const { bytes: bytes2, version: version2, _baseCache } = this;
+    switch (version2) {
+      case 0:
+        return toStringV0(bytes2, _baseCache, base3 || base58btc.encoder);
+      default:
+        return toStringV1(bytes2, _baseCache, base3 || base32.encoder);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return "CID(" + this.toString() + ")";
+  }
+  static isCID(value) {
+    deprecate(/^0\.0/, IS_CID_DEPRECATION);
+    return !!(value && (value[cidSymbol] || value.asCID === value));
+  }
+  get toBaseEncodedString() {
+    throw new Error("Deprecated, use .toString()");
+  }
+  get codec() {
+    throw new Error('"codec" property is deprecated, use integer "code" property instead');
+  }
+  get buffer() {
+    throw new Error("Deprecated .buffer property, use .bytes to get Uint8Array instead");
+  }
+  get multibaseName() {
+    throw new Error('"multibaseName" property is deprecated');
+  }
+  get prefix() {
+    throw new Error('"prefix" property is deprecated');
+  }
+  static asCID(value) {
+    if (value instanceof CID) {
+      return value;
+    } else if (value != null && value.asCID === value) {
+      const { version: version2, code: code2, multihash, bytes: bytes2 } = value;
+      return new CID(version2, code2, multihash, bytes2 || encodeCID(version2, code2, multihash.bytes));
+    } else if (value != null && value[cidSymbol] === true) {
+      const { version: version2, multihash, code: code2 } = value;
+      const digest2 = decode3(multihash);
+      return CID.create(version2, code2, digest2);
+    } else {
+      return null;
+    }
+  }
+  static create(version2, code2, digest2) {
+    if (typeof code2 !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    switch (version2) {
+      case 0: {
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new CID(version2, code2, digest2, digest2.bytes);
+        }
+      }
+      case 1: {
+        const bytes2 = encodeCID(version2, code2, digest2.bytes);
+        return new CID(version2, code2, digest2, bytes2);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest2) {
+    return CID.create(0, DAG_PB_CODE, digest2);
+  }
+  static createV1(code2, digest2) {
+    return CID.create(1, code2, digest2);
+  }
+  static decode(bytes2) {
+    const [cid2, remainder] = CID.decodeFirst(bytes2);
+    if (remainder.length) {
+      throw new Error("Incorrect length");
+    }
+    return cid2;
+  }
+  static decodeFirst(bytes2) {
+    const specs = CID.inspectBytes(bytes2);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes2.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest2 = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid2 = specs.version === 0 ? CID.createV0(digest2) : CID.createV1(specs.codec, digest2);
+    return [
+      cid2,
+      bytes2.subarray(specs.size)
+    ];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode2(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version2 = next();
+    let codec = DAG_PB_CODE;
+    if (version2 === 18) {
+      version2 = 0;
+      offset = 0;
+    } else if (version2 === 1) {
+      codec = next();
+    }
+    if (version2 !== 0 && version2 !== 1) {
+      throw new RangeError(`Invalid CID version ${version2}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return {
+      version: version2,
+      codec,
+      multihashCode,
+      digestSize,
+      multihashSize,
+      size
+    };
+  }
+  static parse(source, base3) {
+    const [prefix, bytes2] = parseCIDtoBytes(source, base3);
+    const cid2 = CID.decode(bytes2);
+    cid2._baseCache.set(prefix, source);
+    return cid2;
+  }
+};
+var parseCIDtoBytes = (source, base3) => {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+    case base32.prefix: {
+      const decoder = base3 || base32;
+      return [
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [
+        source[0],
+        base3.decode(source)
+      ];
+    }
+  }
+};
+var toStringV0 = (bytes2, cache, base3) => {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+  }
+  const cid2 = cache.get(prefix);
+  if (cid2 == null) {
+    const cid3 = base3.encode(bytes2).slice(1);
+    cache.set(prefix, cid3);
+    return cid3;
+  } else {
+    return cid2;
+  }
+};
+var toStringV1 = (bytes2, cache, base3) => {
+  const { prefix } = base3;
+  const cid2 = cache.get(prefix);
+  if (cid2 == null) {
+    const cid3 = base3.encode(bytes2);
+    cache.set(prefix, cid3);
+    return cid3;
+  } else {
+    return cid2;
+  }
+};
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+var encodeCID = (version2, code2, multihash) => {
+  const codeOffset = encodingLength(version2);
+  const hashOffset = codeOffset + encodingLength(code2);
+  const bytes2 = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version2, bytes2, 0);
+  encodeTo(code2, bytes2, codeOffset);
+  bytes2.set(multihash, hashOffset);
+  return bytes2;
+};
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+var readonly = {
+  writable: false,
+  configurable: false,
+  enumerable: true
+};
+var hidden = {
+  writable: false,
+  enumerable: false,
+  configurable: false
+};
+var version = "0.0.0-dev";
+var deprecate = (range, message) => {
+  if (range.test(version)) {
+    console.warn(message);
+  } else {
+    throw new Error(message);
+  }
+};
+var IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.
+Following code pattern:
+
+if (CID.isCID(value)) {
+  doSomethingWithCID(value)
+}
+
+Is replaced with:
+
+const cid = CID.asCID(value)
+if (cid) {
+  // Make sure to use cid instead of value
+  doSomethingWithCID(cid)
+}
+`;
+
+// ../../node_modules/multiformats/esm/src/bases/identity.js
+var identity_exports = {};
+__export(identity_exports, {
+  identity: () => identity
+});
+var identity = from({
+  prefix: "\0",
+  name: "identity",
+  encode: (buf) => toString(buf),
+  decode: (str) => fromString(str)
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base2.js
+var base2_exports = {};
+__export(base2_exports, {
+  base2: () => base2
+});
+var base2 = rfc4648({
+  prefix: "0",
+  name: "base2",
+  alphabet: "01",
+  bitsPerChar: 1
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base8.js
+var base8_exports = {};
+__export(base8_exports, {
+  base8: () => base8
+});
+var base8 = rfc4648({
+  prefix: "7",
+  name: "base8",
+  alphabet: "01234567",
+  bitsPerChar: 3
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base10.js
+var base10_exports = {};
+__export(base10_exports, {
+  base10: () => base10
+});
+var base10 = baseX({
+  prefix: "9",
+  name: "base10",
+  alphabet: "0123456789"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base16.js
+var base16_exports = {};
+__export(base16_exports, {
+  base16: () => base16,
+  base16upper: () => base16upper
+});
+var base16 = rfc4648({
+  prefix: "f",
+  name: "base16",
+  alphabet: "0123456789abcdef",
+  bitsPerChar: 4
+});
+var base16upper = rfc4648({
+  prefix: "F",
+  name: "base16upper",
+  alphabet: "0123456789ABCDEF",
+  bitsPerChar: 4
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base36.js
+var base36_exports = {};
+__export(base36_exports, {
+  base36: () => base36,
+  base36upper: () => base36upper
+});
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base64.js
+var base64_exports = {};
+__export(base64_exports, {
+  base64: () => base64,
+  base64pad: () => base64pad,
+  base64url: () => base64url,
+  base64urlpad: () => base64urlpad
+});
+var base64 = rfc4648({
+  prefix: "m",
+  name: "base64",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  bitsPerChar: 6
+});
+var base64pad = rfc4648({
+  prefix: "M",
+  name: "base64pad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+  bitsPerChar: 6
+});
+var base64url = rfc4648({
+  prefix: "u",
+  name: "base64url",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  bitsPerChar: 6
+});
+var base64urlpad = rfc4648({
+  prefix: "U",
+  name: "base64urlpad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+  bitsPerChar: 6
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base256emoji.js
+var base256emoji_exports = {};
+__export(base256emoji_exports, {
+  base256emoji: () => base256emoji
+});
+var alphabet = Array.from("\u{1F680}\u{1FA90}\u2604\u{1F6F0}\u{1F30C}\u{1F311}\u{1F312}\u{1F313}\u{1F314}\u{1F315}\u{1F316}\u{1F317}\u{1F318}\u{1F30D}\u{1F30F}\u{1F30E}\u{1F409}\u2600\u{1F4BB}\u{1F5A5}\u{1F4BE}\u{1F4BF}\u{1F602}\u2764\u{1F60D}\u{1F923}\u{1F60A}\u{1F64F}\u{1F495}\u{1F62D}\u{1F618}\u{1F44D}\u{1F605}\u{1F44F}\u{1F601}\u{1F525}\u{1F970}\u{1F494}\u{1F496}\u{1F499}\u{1F622}\u{1F914}\u{1F606}\u{1F644}\u{1F4AA}\u{1F609}\u263A\u{1F44C}\u{1F917}\u{1F49C}\u{1F614}\u{1F60E}\u{1F607}\u{1F339}\u{1F926}\u{1F389}\u{1F49E}\u270C\u2728\u{1F937}\u{1F631}\u{1F60C}\u{1F338}\u{1F64C}\u{1F60B}\u{1F497}\u{1F49A}\u{1F60F}\u{1F49B}\u{1F642}\u{1F493}\u{1F929}\u{1F604}\u{1F600}\u{1F5A4}\u{1F603}\u{1F4AF}\u{1F648}\u{1F447}\u{1F3B6}\u{1F612}\u{1F92D}\u2763\u{1F61C}\u{1F48B}\u{1F440}\u{1F62A}\u{1F611}\u{1F4A5}\u{1F64B}\u{1F61E}\u{1F629}\u{1F621}\u{1F92A}\u{1F44A}\u{1F973}\u{1F625}\u{1F924}\u{1F449}\u{1F483}\u{1F633}\u270B\u{1F61A}\u{1F61D}\u{1F634}\u{1F31F}\u{1F62C}\u{1F643}\u{1F340}\u{1F337}\u{1F63B}\u{1F613}\u2B50\u2705\u{1F97A}\u{1F308}\u{1F608}\u{1F918}\u{1F4A6}\u2714\u{1F623}\u{1F3C3}\u{1F490}\u2639\u{1F38A}\u{1F498}\u{1F620}\u261D\u{1F615}\u{1F33A}\u{1F382}\u{1F33B}\u{1F610}\u{1F595}\u{1F49D}\u{1F64A}\u{1F639}\u{1F5E3}\u{1F4AB}\u{1F480}\u{1F451}\u{1F3B5}\u{1F91E}\u{1F61B}\u{1F534}\u{1F624}\u{1F33C}\u{1F62B}\u26BD\u{1F919}\u2615\u{1F3C6}\u{1F92B}\u{1F448}\u{1F62E}\u{1F646}\u{1F37B}\u{1F343}\u{1F436}\u{1F481}\u{1F632}\u{1F33F}\u{1F9E1}\u{1F381}\u26A1\u{1F31E}\u{1F388}\u274C\u270A\u{1F44B}\u{1F630}\u{1F928}\u{1F636}\u{1F91D}\u{1F6B6}\u{1F4B0}\u{1F353}\u{1F4A2}\u{1F91F}\u{1F641}\u{1F6A8}\u{1F4A8}\u{1F92C}\u2708\u{1F380}\u{1F37A}\u{1F913}\u{1F619}\u{1F49F}\u{1F331}\u{1F616}\u{1F476}\u{1F974}\u25B6\u27A1\u2753\u{1F48E}\u{1F4B8}\u2B07\u{1F628}\u{1F31A}\u{1F98B}\u{1F637}\u{1F57A}\u26A0\u{1F645}\u{1F61F}\u{1F635}\u{1F44E}\u{1F932}\u{1F920}\u{1F927}\u{1F4CC}\u{1F535}\u{1F485}\u{1F9D0}\u{1F43E}\u{1F352}\u{1F617}\u{1F911}\u{1F30A}\u{1F92F}\u{1F437}\u260E\u{1F4A7}\u{1F62F}\u{1F486}\u{1F446}\u{1F3A4}\u{1F647}\u{1F351}\u2744\u{1F334}\u{1F4A3}\u{1F438}\u{1F48C}\u{1F4CD}\u{1F940}\u{1F922}\u{1F445}\u{1F4A1}\u{1F4A9}\u{1F450}\u{1F4F8}\u{1F47B}\u{1F910}\u{1F92E}\u{1F3BC}\u{1F975}\u{1F6A9}\u{1F34E}\u{1F34A}\u{1F47C}\u{1F48D}\u{1F4E3}\u{1F942}");
+var alphabetBytesToChars = alphabet.reduce((p, c, i) => {
+  p[i] = c;
+  return p;
+}, []);
+var alphabetCharsToBytes = alphabet.reduce((p, c, i) => {
+  p[c.codePointAt(0)] = i;
+  return p;
+}, []);
+function encode3(data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p;
+  }, "");
+}
+function decode5(str) {
+  const byts = [];
+  for (const char of str) {
+    const byt = alphabetCharsToBytes[char.codePointAt(0)];
+    if (byt === void 0) {
+      throw new Error(`Non-base256emoji character: ${char}`);
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts);
+}
+var base256emoji = from({
+  prefix: "\u{1F680}",
+  name: "base256emoji",
+  encode: encode3,
+  decode: decode5
+});
+
+// ../../node_modules/multiformats/esm/src/hashes/sha2.js
+var sha2_exports = {};
+__export(sha2_exports, {
+  sha256: () => sha256,
+  sha512: () => sha512
+});
+var import_crypto = __toESM(require("crypto"), 1);
+
+// ../../node_modules/multiformats/esm/src/hashes/hasher.js
+var from2 = ({ name: name2, code: code2, encode: encode5 }) => new Hasher(name2, code2, encode5);
+var Hasher = class {
+  constructor(name2, code2, encode5) {
+    this.name = name2;
+    this.code = code2;
+    this.encode = encode5;
+  }
+  digest(input) {
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      return result instanceof Uint8Array ? create(this.code, result) : result.then((digest2) => create(this.code, digest2));
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+
+// ../../node_modules/multiformats/esm/src/hashes/sha2.js
+var sha256 = from2({
+  name: "sha2-256",
+  code: 18,
+  encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
+});
+var sha512 = from2({
+  name: "sha2-512",
+  code: 19,
+  encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
+});
+
+// ../../node_modules/multiformats/esm/src/hashes/identity.js
+var identity_exports2 = {};
+__export(identity_exports2, {
+  identity: () => identity2
+});
+var code = 0;
+var name = "identity";
+var encode4 = coerce;
+var digest = (input) => create(code, encode4(input));
+var identity2 = {
+  code,
+  name,
+  encode: encode4,
+  digest
+};
+
+// ../../node_modules/multiformats/esm/src/codecs/json.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+
+// ../../node_modules/multiformats/esm/src/basics.js
+var bases = {
+  ...identity_exports,
+  ...base2_exports,
+  ...base8_exports,
+  ...base10_exports,
+  ...base16_exports,
+  ...base32_exports,
+  ...base36_exports,
+  ...base58_exports,
+  ...base64_exports,
+  ...base256emoji_exports
+};
+var hashes = {
+  ...sha2_exports,
+  ...identity_exports2
+};
+
+// ../../node_modules/uint8arrays/esm/src/util/bases.js
+function createCodec(name2, prefix, encode5, decode6) {
+  return {
+    name: name2,
+    prefix,
+    encoder: {
+      name: name2,
+      prefix,
+      encode: encode5
+    },
+    decoder: { decode: decode6 }
+  };
+}
+var string = createCodec("utf8", "u", (buf) => {
+  const decoder = new TextDecoder("utf8");
+  return "u" + decoder.decode(buf);
+}, (str) => {
+  const encoder = new TextEncoder();
+  return encoder.encode(str.substring(1));
+});
+var ascii = createCodec("ascii", "a", (buf) => {
+  let string3 = "a";
+  for (let i = 0; i < buf.length; i++) {
+    string3 += String.fromCharCode(buf[i]);
+  }
+  return string3;
+}, (str) => {
+  str = str.substring(1);
+  const buf = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  return buf;
+});
+var BASES = {
+  utf8: string,
+  "utf-8": string,
+  hex: bases.base16,
+  latin1: ascii,
+  ascii,
+  binary: ascii,
+  ...bases
+};
+var bases_default = BASES;
+
+// ../../node_modules/uint8arrays/esm/src/from-string.js
+function fromString2(string3, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (!base3) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.decoder.decode(`${base3.prefix}${string3}`);
+}
+
+// ../../node_modules/uint8arrays/esm/src/to-string.js
+function toString2(array2, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (!base3) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.encoder.encode(array2).substring(1);
+}
+
+// ../common-web/src/ipld.ts
+var jsonToIpld = (val) => {
+  if (Array.isArray(val)) {
+    return val.map((item) => jsonToIpld(item));
+  }
+  if (val && typeof val === "object") {
+    if (typeof val["$link"] === "string" && Object.keys(val).length === 1) {
+      return CID.parse(val["$link"]);
+    }
+    if (typeof val["$bytes"] === "string" && Object.keys(val).length === 1) {
+      return fromString2(val["$bytes"], "base64");
+    }
+    const toReturn = {};
+    for (const key of Object.keys(val)) {
+      toReturn[key] = jsonToIpld(val[key]);
+    }
+    return toReturn;
+  }
+  return val;
+};
+var ipldToJson = (val) => {
+  if (Array.isArray(val)) {
+    return val.map((item) => ipldToJson(item));
+  }
+  if (val && typeof val === "object") {
+    if (val instanceof Uint8Array) {
+      return {
+        $bytes: toString2(val, "base64")
+      };
+    }
+    if (CID.asCID(val)) {
+      return {
+        $link: val.toString()
+      };
+    }
+    const toReturn = {};
+    for (const key of Object.keys(val)) {
+      toReturn[key] = ipldToJson(val[key]);
+    }
+    return toReturn;
+  }
+  return val;
+};
+
+// ../common-web/src/types.ts
+var cidSchema = mod.any().refine((obj) => CID.asCID(obj) !== null, {
+  message: "Not a CID"
+}).transform((obj) => CID.asCID(obj));
+var schema = {
+  cid: cidSchema,
+  bytes: mod.instanceof(Uint8Array),
+  string: mod.string(),
+  array: mod.array(mod.unknown()),
+  map: mod.record(mod.string(), mod.unknown()),
+  unknown: mod.unknown()
+};
+var def = {
+  cid: {
+    name: "cid",
+    schema: schema.cid
+  },
+  bytes: {
+    name: "bytes",
+    schema: schema.bytes
+  },
+  string: {
+    name: "string",
+    schema: schema.string
+  },
+  map: {
+    name: "map",
+    schema: schema.map
+  },
+  unknown: {
+    name: "unknown",
+    schema: schema.unknown
   }
 };
-var ValidationError = class extends Error {
+
+// ../common-web/src/times.ts
+var SECOND = 1e3;
+var MINUTE = SECOND * 60;
+var HOUR = MINUTE * 60;
+var DAY = HOUR * 24;
+
+// ../common-web/src/strings.ts
+var utf8Len = (str) => {
+  return new TextEncoder().encode(str).byteLength;
 };
-var InvalidLexiconError = class extends Error {
+var graphemeLen = (str) => {
+  return [...new Intl.Segmenter().segment(str)].length;
 };
-var LexiconDefNotFoundError = class extends Error {
+
+// ../identifier/src/reserved.ts
+var atpSpecific = [
+  "at",
+  "atp",
+  "plc",
+  "pds",
+  "did",
+  "repo",
+  "tid",
+  "nsid",
+  "xrpc",
+  "lex",
+  "lexicon",
+  "bsky",
+  "bluesky",
+  "handle"
+];
+var commonlyReserved = [
+  "about",
+  "abuse",
+  "access",
+  "account",
+  "accounts",
+  "acme",
+  "activate",
+  "activities",
+  "activity",
+  "ad",
+  "add",
+  "address",
+  "adm",
+  "admanager",
+  "admin",
+  "administration",
+  "administrator",
+  "administrators",
+  "admins",
+  "ads",
+  "adsense",
+  "adult",
+  "advertising",
+  "adwords",
+  "affiliate",
+  "affiliatepage",
+  "affiliates",
+  "afp",
+  "ajax",
+  "all",
+  "alpha",
+  "analysis",
+  "analytics",
+  "android",
+  "anon",
+  "anonymous",
+  "answer",
+  "answers",
+  "ap",
+  "api",
+  "apis",
+  "app",
+  "appengine",
+  "appnews",
+  "apps",
+  "archive",
+  "archives",
+  "article",
+  "asdf",
+  "asset",
+  "assets",
+  "auth",
+  "authentication",
+  "avatar",
+  "backup",
+  "bank",
+  "banner",
+  "banners",
+  "base",
+  "beginners",
+  "beta",
+  "billing",
+  "bin",
+  "binaries",
+  "binary",
+  "blackberry",
+  "blog",
+  "blogs",
+  "blogsearch",
+  "board",
+  "book",
+  "bookmark",
+  "bookmarks",
+  "books",
+  "bot",
+  "bots",
+  "bug",
+  "bugs",
+  "business",
+  "buy",
+  "buzz",
+  "cache",
+  "calendar",
+  "call",
+  "campaign",
+  "cancel",
+  "captcha",
+  "career",
+  "careers",
+  "cart",
+  "catalog",
+  "catalogs",
+  "categories",
+  "category",
+  "cdn",
+  "cgi",
+  "cgi-bin",
+  "changelog",
+  "chart",
+  "charts",
+  "chat",
+  "check",
+  "checked",
+  "checking",
+  "checkout",
+  "client",
+  "cliente",
+  "clients",
+  "clients1",
+  "cnarne",
+  "code",
+  "comercial",
+  "comment",
+  "comments",
+  "communities",
+  "community",
+  "company",
+  "compare",
+  "compras",
+  "config",
+  "configuration",
+  "confirm",
+  "confirmation",
+  "connect",
+  "contact",
+  "contacts",
+  "contactus",
+  "contact-us",
+  "contact_us",
+  "content",
+  "contest",
+  "contribute",
+  "contributor",
+  "contributors",
+  "coppa",
+  "copyright",
+  "copyrights",
+  "core",
+  "corp",
+  "countries",
+  "country",
+  "cpanel",
+  "create",
+  "css",
+  "cssproxy",
+  "customise",
+  "customize",
+  "dashboard",
+  "data",
+  "db",
+  "default",
+  "delete",
+  "demo",
+  "design",
+  "designer",
+  "desktop",
+  "destroy",
+  "dev",
+  "devel",
+  "developer",
+  "developers",
+  "devs",
+  "diagram",
+  "diary",
+  "dict",
+  "dictionary",
+  "die",
+  "dir",
+  "directory",
+  "direct_messages",
+  "direct-messages",
+  "dist",
+  "diversity",
+  "dl",
+  "dmca",
+  "doc",
+  "docs",
+  "documentation",
+  "documentations",
+  "documents",
+  "domain",
+  "domains",
+  "donate",
+  "download",
+  "downloads",
+  "e",
+  "e-mail",
+  "earth",
+  "ecommerce",
+  "edit",
+  "edits",
+  "editor",
+  "edu",
+  "education",
+  "email",
+  "embed",
+  "embedded",
+  "employment",
+  "employments",
+  "empty",
+  "enable",
+  "encrypted",
+  "end",
+  "engine",
+  "enterprise",
+  "enterprises",
+  "entries",
+  "entry",
+  "error",
+  "errorlog",
+  "errors",
+  "eval",
+  "event",
+  "example",
+  "examplecommunity",
+  "exampleopenid",
+  "examplesyn",
+  "examplesyndicated",
+  "exampleusername",
+  "exchange",
+  "exit",
+  "explore",
+  "faq",
+  "faqs",
+  "favorite",
+  "favorites",
+  "favourite",
+  "favourites",
+  "feature",
+  "features",
+  "feed",
+  "feedback",
+  "feedburner",
+  "feedproxy",
+  "feeds",
+  "file",
+  "files",
+  "finance",
+  "folder",
+  "folders",
+  "first",
+  "following",
+  "forgot",
+  "form",
+  "forms",
+  "forum",
+  "forums",
+  "founder",
+  "free",
+  "friend",
+  "friends",
+  "ftp",
+  "fuck",
+  "fun",
+  "fusion",
+  "gadget",
+  "gadgets",
+  "game",
+  "games",
+  "gears",
+  "general",
+  "geographic",
+  "get",
+  "gettingstarted",
+  "gift",
+  "gifts",
+  "gist",
+  "git",
+  "github",
+  "gmail",
+  "go",
+  "golang",
+  "goto",
+  "gov",
+  "graph",
+  "graphs",
+  "group",
+  "groups",
+  "guest",
+  "guests",
+  "guide",
+  "guides",
+  "hack",
+  "hacks",
+  "head",
+  "help",
+  "home",
+  "homepage",
+  "host",
+  "hosting",
+  "hostmaster",
+  "hostname",
+  "howto",
+  "how-to",
+  "how_to",
+  "html",
+  "htrnl",
+  "http",
+  "httpd",
+  "https",
+  "i",
+  "iamges",
+  "icon",
+  "icons",
+  "id",
+  "idea",
+  "ideas",
+  "im",
+  "image",
+  "images",
+  "img",
+  "imap",
+  "inbox",
+  "inboxes",
+  "index",
+  "indexes",
+  "info",
+  "information",
+  "inquiry",
+  "intranet",
+  "investor",
+  "investors",
+  "invitation",
+  "invitations",
+  "invite",
+  "invoice",
+  "invoices",
+  "imac",
+  "ios",
+  "ipad",
+  "iphone",
+  "irc",
+  "irnages",
+  "irng",
+  "is",
+  "issue",
+  "issues",
+  "it",
+  "item",
+  "items",
+  "java",
+  "javascript",
+  "job",
+  "jobs",
+  "join",
+  "js",
+  "json",
+  "jump",
+  "kb",
+  "knowledge-base",
+  "knowledgebase",
+  "lab",
+  "labs",
+  "language",
+  "languages",
+  "last",
+  "ldap_status",
+  "ldap-status",
+  "ldapstatus",
+  "legal",
+  "license",
+  "licenses",
+  "link",
+  "links",
+  "linux",
+  "list",
+  "lists",
+  "livejournal",
+  "lj",
+  "local",
+  "locale",
+  "location",
+  "log",
+  "log-in",
+  "log-out",
+  "login",
+  "logout",
+  "logs",
+  "log_in",
+  "log_out",
+  "m",
+  "mac",
+  "macos",
+  "macosx",
+  "mac-os",
+  "mac-os-x",
+  "mac_os_x",
+  "mail",
+  "mailer",
+  "mailing",
+  "main",
+  "maintenance",
+  "manage",
+  "manager",
+  "manual",
+  "map",
+  "maps",
+  "marketing",
+  "master",
+  "me",
+  "media",
+  "member",
+  "members",
+  "memories",
+  "memory",
+  "merchandise",
+  "message",
+  "messages",
+  "messenger",
+  "mg",
+  "microblog",
+  "microblogs",
+  "mine",
+  "mis",
+  "misc",
+  "mms",
+  "mob",
+  "mobile",
+  "model",
+  "models",
+  "money",
+  "movie",
+  "movies",
+  "mp3",
+  "mp4",
+  "msg",
+  "msn",
+  "music",
+  "mx",
+  "my",
+  "mymme",
+  "mysql",
+  "name",
+  "named",
+  "nan",
+  "navi",
+  "navigation",
+  "net",
+  "network",
+  "networks",
+  "new",
+  "news",
+  "newsletter",
+  "nick",
+  "nickname",
+  "nil",
+  "none",
+  "notes",
+  "noticias",
+  "notification",
+  "notifications",
+  "notify",
+  "ns",
+  "ns1",
+  "ns2",
+  "ns3",
+  "ns4",
+  "ns5",
+  "null",
+  "oauth",
+  "oauth-clients",
+  "oauth_clients",
+  "ocsp",
+  "offer",
+  "offers",
+  "official",
+  "old",
+  "online",
+  "openid",
+  "operator",
+  "option",
+  "options",
+  "order",
+  "orders",
+  "org",
+  "organization",
+  "organizations",
+  "other",
+  "overview",
+  "owner",
+  "owners",
+  "p0rn",
+  "pack",
+  "page",
+  "pager",
+  "pages",
+  "paid",
+  "panel",
+  "partner",
+  "partnerpage",
+  "partners",
+  "password",
+  "patch",
+  "pay",
+  "payment",
+  "people",
+  "perl",
+  "person",
+  "phone",
+  "photo",
+  "photoalbum",
+  "photos",
+  "php",
+  "phpmyadmin",
+  "phppgadmin",
+  "phpredisadmin",
+  "pic",
+  "pics",
+  "picture",
+  "pictures",
+  "ping",
+  "pixel",
+  "places",
+  "plan",
+  "plans",
+  "plugin",
+  "plugins",
+  "podcasts",
+  "policies",
+  "policy",
+  "pop",
+  "pop3",
+  "popular",
+  "porn",
+  "portal",
+  "portals",
+  "post",
+  "postfix",
+  "postmaster",
+  "posts",
+  "pr",
+  "pr0n",
+  "premium",
+  "press",
+  "price",
+  "pricing",
+  "principles",
+  "print",
+  "privacy",
+  "privacy-policy",
+  "privacypolicy",
+  "privacy_policy",
+  "private",
+  "prod",
+  "product",
+  "production",
+  "products",
+  "profile",
+  "profiles",
+  "project",
+  "projects",
+  "promo",
+  "promotions",
+  "proxies",
+  "proxy",
+  "pub",
+  "public",
+  "purchase",
+  "purpose",
+  "put",
+  "python",
+  "queries",
+  "query",
+  "radio",
+  "random",
+  "ranking",
+  "read",
+  "reader",
+  "readme",
+  "recent",
+  "recruit",
+  "recruitment",
+  "redirect",
+  "register",
+  "registration",
+  "release",
+  "remove",
+  "replies",
+  "report",
+  "reports",
+  "repositories",
+  "repository",
+  "req",
+  "request",
+  "requests",
+  "research",
+  "reset",
+  "resolve",
+  "resolver",
+  "review",
+  "rnail",
+  "rnicrosoft",
+  "roc",
+  "root",
+  "rss",
+  "ruby",
+  "rule",
+  "sag",
+  "sale",
+  "sales",
+  "sample",
+  "samples",
+  "sandbox",
+  "save",
+  "scholar",
+  "school",
+  "schools",
+  "script",
+  "scripts",
+  "search",
+  "secure",
+  "security",
+  "self",
+  "seminars",
+  "send",
+  "server",
+  "server-info",
+  "server_info",
+  "server-status",
+  "server_status",
+  "servers",
+  "service",
+  "services",
+  "session",
+  "sessions",
+  "setting",
+  "settings",
+  "setup",
+  "share",
+  "shop",
+  "shopping",
+  "shortcut",
+  "shortcuts",
+  "show",
+  "sign-in",
+  "sign-up",
+  "signin",
+  "signout",
+  "signup",
+  "sign_in",
+  "sign_up",
+  "site",
+  "sitemap",
+  "sitemaps",
+  "sitenews",
+  "sites",
+  "sketchup",
+  "sky",
+  "slash",
+  "slashinvoice",
+  "slut",
+  "smartphone",
+  "sms",
+  "smtp",
+  "soap",
+  "software",
+  "sorry",
+  "source",
+  "spec",
+  "special",
+  "spreadsheet",
+  "spreadsheets",
+  "sql",
+  "src",
+  "srntp",
+  "ssh",
+  "ssl",
+  "ssladmin",
+  "ssladministrator",
+  "sslwebmaster",
+  "ssytem",
+  "staff",
+  "stage",
+  "staging",
+  "start",
+  "stat",
+  "state",
+  "static",
+  "statistics",
+  "stats",
+  "status",
+  "store",
+  "stores",
+  "stories",
+  "style",
+  "styleguide",
+  "styles",
+  "stylesheet",
+  "stylesheets",
+  "subdomain",
+  "subscribe",
+  "subscription",
+  "subscriptions",
+  "suggest",
+  "suggestqueries",
+  "support",
+  "survey",
+  "surveys",
+  "surveytool",
+  "svn",
+  "swf",
+  "syn",
+  "sync",
+  "syndicated",
+  "sys",
+  "sysadmin",
+  "sysadministrator",
+  "sysadmins",
+  "system",
+  "tablet",
+  "tablets",
+  "tag",
+  "tags",
+  "talk",
+  "talkgadget",
+  "task",
+  "tasks",
+  "team",
+  "teams",
+  "tech",
+  "telnet",
+  "term",
+  "terms",
+  "terms-of-service",
+  "termsofservice",
+  "terms_of_service",
+  "test",
+  "testing",
+  "tests",
+  "text",
+  "theme",
+  "themes",
+  "thread",
+  "threads",
+  "ticket",
+  "tickets",
+  "tmp",
+  "todo",
+  "to-do",
+  "to_do",
+  "toml",
+  "tool",
+  "toolbar",
+  "toolbars",
+  "tools",
+  "top",
+  "topic",
+  "topics",
+  "tos",
+  "tour",
+  "trac",
+  "translate",
+  "trace",
+  "translation",
+  "translations",
+  "translator",
+  "trends",
+  "tutorial",
+  "tux",
+  "tv",
+  "twitter",
+  "txt",
+  "ul",
+  "undef",
+  "unfollow",
+  "unsubscribe",
+  "update",
+  "updates",
+  "upgrade",
+  "upgrades",
+  "upi",
+  "upload",
+  "uploads",
+  "url",
+  "usage",
+  "user",
+  "username",
+  "usernames",
+  "users",
+  "uuid",
+  "validation",
+  "validations",
+  "ver",
+  "version",
+  "video",
+  "videos",
+  "video-stats",
+  "visitor",
+  "visitors",
+  "voice",
+  "volunteer",
+  "volunteers",
+  "w",
+  "watch",
+  "wave",
+  "weather",
+  "web",
+  "webdisk",
+  "webhook",
+  "webhooks",
+  "webmail",
+  "webmaster",
+  "webmasters",
+  "webrnail",
+  "website",
+  "websites",
+  "welcome",
+  "whm",
+  "whois",
+  "widget",
+  "widgets",
+  "wifi",
+  "wiki",
+  "wikis",
+  "win",
+  "windows",
+  "word",
+  "work",
+  "works",
+  "workshop",
+  "wpad",
+  "ww",
+  "wws",
+  "www",
+  "wwws",
+  "wwww",
+  "xfn",
+  "xhtml",
+  "xhtrnl",
+  "xml",
+  "xmpp",
+  "xpg",
+  "xxx",
+  "yaml",
+  "year",
+  "yml",
+  "you",
+  "yourdomain",
+  "yourname",
+  "yoursite",
+  "yourusername"
+];
+var famousAccounts = [
+  "10ronaldinho",
+  "3gerardpique",
+  "adele",
+  "akshaykumar",
+  "aliaa08",
+  "aliciakeys",
+  "amitshah",
+  "andresiniesta8",
+  "anushkasharma",
+  "arianagrande",
+  "arrahman",
+  "arvindkejriwal",
+  "avrillavigne",
+  "barackobama",
+  "bbcbreaking",
+  "bbcworld",
+  "beingsalmankhan",
+  "billgates",
+  "britneyspears",
+  "brunomars",
+  "bts_bighit",
+  "bts_twt",
+  "championsleague",
+  "chrisbrown",
+  "cnnbrk",
+  "coldplay",
+  "conanobrien",
+  "cristiano",
+  "danieltosh",
+  "davidguetta",
+  "ddlovato",
+  "deepikapadukone",
+  "drake",
+  "elisapie",
+  "ellendegeneres",
+  "elonmusk",
+  "eminem",
+  "emmawatson",
+  "fcbarcelona",
+  "foxnews",
+  "harry_styles",
+  "hillaryclinton",
+  "iamsrk",
+  "ihrithik",
+  "imvkohli",
+  "instagram",
+  "jimmyfallon",
+  "jlo",
+  "joebiden",
+  "jtimberlake",
+  "justinbieber",
+  "kaka",
+  "kanyewest",
+  "katyperry",
+  "kendalljenner",
+  "kevinhart4real",
+  "khloekardashian",
+  "kimkardashian",
+  "kingjames",
+  "kourtneykardash",
+  "kyliejenner",
+  "ladygaga",
+  "liampayne",
+  "liltunechi",
+  "manutd",
+  "mariahcarey",
+  "mileycyrus",
+  "mohamadalarefe",
+  "narendramodi",
+  "nasa",
+  "nba",
+  "neymarjr",
+  "nfl",
+  "niallofficial",
+  "nickiminaj",
+  "nytimes",
+  "onedirection",
+  "oprah",
+  "pink",
+  "pitbull",
+  "playstation",
+  "pmoindia",
+  "premierleague",
+  "priyankachopra",
+  "realdonaldtrump",
+  "ricky_martin",
+  "rihanna",
+  "sachin_rt",
+  "selenagomez",
+  "shakira",
+  "shawnmendes",
+  "sportscenter",
+  "srbachchan",
+  "subhisharma100",
+  "taylorswift13",
+  "theeconomist",
+  "twitter",
+  "virendersehwag",
+  "whitehouse45",
+  "wizkhalifa",
+  "youtube",
+  "zaynmalik",
+  "beyonce",
+  "billieeilish",
+  "leomessi",
+  "natgeo",
+  "nike",
+  "snoopdogg",
+  "taylorswift",
+  "therock",
+  "10downingstreet",
+  "aoc",
+  "carterjwm",
+  "dril",
+  "gretathunberg",
+  "kamalaharris",
+  "kremlinrussia_e",
+  "potus",
+  "rondesantisfl",
+  "ukraine",
+  "washingtonpost",
+  "yousuck2020",
+  "zelenskyyua"
+];
+var reservedSubdomains = [
+  ...atpSpecific,
+  ...commonlyReserved,
+  ...famousAccounts
+].reduce((acc, cur) => {
+  return {
+    ...acc,
+    [cur]: true
+  };
+}, {});
+
+// ../identifier/src/handle.ts
+var ensureValidHandle = (handle2) => {
+  if (!/^[a-zA-Z0-9.-]*$/.test(handle2)) {
+    throw new InvalidHandleError(
+      "Disallowed characters in handle (ASCII letters, digits, dashes, periods only)"
+    );
+  }
+  if (handle2.length > 253) {
+    throw new InvalidHandleError("Handle is too long (253 chars max)");
+  }
+  const labels = handle2.split(".");
+  if (labels.length < 2) {
+    throw new InvalidHandleError("Handle domain needs at least two parts");
+  }
+  for (let i = 0; i < labels.length; i++) {
+    const l = labels[i];
+    if (l.length < 1) {
+      throw new InvalidHandleError("Handle parts can not be empty");
+    }
+    if (l.length > 63) {
+      throw new InvalidHandleError("Handle part too long (max 63 chars)");
+    }
+    if (l.endsWith("-") || l.startsWith("-")) {
+      throw new InvalidHandleError(
+        "Handle parts can not start or end with hyphens"
+      );
+    }
+    if (i + 1 == labels.length && !/^[a-zA-Z]/.test(l)) {
+      throw new InvalidHandleError(
+        "Handle final component (TLD) must start with ASCII letter"
+      );
+    }
+  }
+};
+var InvalidHandleError = class extends Error {
 };
 
-// ../lexicon/src/validators/primitives.ts
+// ../identifier/src/did.ts
+var ensureValidDid = (did2) => {
+  if (!/^[a-zA-Z0-9._:%-]*$/.test(did2)) {
+    throw new InvalidDidError(
+      "Disallowed characters in DID (ASCII letters, digits, and a couple other characters only)"
+    );
+  }
+  const parts = did2.split(":");
+  if (parts.length < 3) {
+    throw new InvalidDidError(
+      "DID requires prefix, method, and method-specific content"
+    );
+  }
+  if (parts[0] != "did") {
+    throw new InvalidDidError('DID requires "did:" prefix');
+  }
+  if (!/^[a-z]+$/.test(parts[1])) {
+    throw new InvalidDidError("DID method must be lower-case letters");
+  }
+  if (did2.endsWith(":") || did2.endsWith("%")) {
+    throw new InvalidDidError('DID can not end with ":" or "%"');
+  }
+  if (did2.length > 8 * 1024) {
+    throw new InvalidDidError("DID is far too long");
+  }
+};
+var InvalidDidError = class extends Error {
+};
+
+// ../uri/src/validation.ts
+var ensureValidAtUri = (uri2) => {
+  const uriParts = uri2.split("#");
+  if (uriParts.length > 2) {
+    throw new Error('ATURI can have at most one "#", separating fragment out');
+  }
+  const fragmentPart = uriParts[1] || null;
+  uri2 = uriParts[0];
+  if (!/^[a-zA-Z0-9._~:@!$&')(*+,;=%/-]*$/.test(uri2)) {
+    throw new Error("Disallowed characters in ATURI (ASCII)");
+  }
+  const parts = uri2.split("/");
+  if (parts.length >= 3 && (parts[0] != "at:" || parts[1].length != 0)) {
+    throw new Error('ATURI must start with "at://"');
+  }
+  if (parts.length < 3) {
+    throw new Error("ATURI requires at least method and authority sections");
+  }
+  try {
+    ensureValidHandle(parts[2]);
+  } catch {
+    try {
+      ensureValidDid(parts[2]);
+    } catch {
+      throw new Error("ATURI authority must be a valid handle or DID");
+    }
+  }
+  if (parts.length >= 4) {
+    if (parts[3].length == 0) {
+      throw new Error(
+        "ATURI can not have a slash after authority without a path segment"
+      );
+    }
+    try {
+      ensureValidNsid(parts[3]);
+    } catch {
+      throw new Error(
+        "ATURI requires first path segment (if supplied) to be valid NSID"
+      );
+    }
+  }
+  if (parts.length >= 5) {
+    if (parts[4].length == 0) {
+      throw new Error(
+        "ATURI can not have a slash after collection, unless record key is provided"
+      );
+    }
+  }
+  if (parts.length >= 6) {
+    throw new Error(
+      "ATURI path can have at most two parts, and no trailing slash"
+    );
+  }
+  if (uriParts.length >= 2 && fragmentPart == null) {
+    throw new Error("ATURI fragment must be non-empty and start with slash");
+  }
+  if (fragmentPart != null) {
+    if (fragmentPart.length == 0 || fragmentPart[0] != "/") {
+      throw new Error("ATURI fragment must be non-empty and start with slash");
+    }
+    if (!/^\/[a-zA-Z0-9._~:@!$&')(*+,;=%[\]/-]*$/.test(fragmentPart)) {
+      throw new Error("Disallowed characters in ATURI fragment (ASCII)");
+    }
+  }
+  if (uri2.length > 8 * 1024) {
+    throw new Error("ATURI is far too long");
+  }
+};
+
+// ../lexicon/src/validators/formats.ts
 var import_iso_datestring_validator = __toESM(require_dist());
-function validate(lexicons, path, def, value) {
-  switch (def.type) {
+function datetime(path, value) {
+  try {
+    if (!(0, import_iso_datestring_validator.isValidISODateString)(value)) {
+      throw new Error();
+    }
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(
+        `${path} must be an iso8601 formatted datetime`
+      )
+    };
+  }
+  return { success: true, value };
+}
+function uri(path, value) {
+  const isUri = value.match(/^\w+:(?:\/\/)?[^\s/][^\s]*$/) !== null;
+  if (!isUri) {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a uri`)
+    };
+  }
+  return { success: true, value };
+}
+function atUri(path, value) {
+  try {
+    ensureValidAtUri(value);
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid at-uri`)
+    };
+  }
+  return { success: true, value };
+}
+function did(path, value) {
+  try {
+    ensureValidDid(value);
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid did`)
+    };
+  }
+  return { success: true, value };
+}
+function handle(path, value) {
+  try {
+    ensureValidHandle(value);
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid handle`)
+    };
+  }
+  return { success: true, value };
+}
+function atIdentifier(path, value) {
+  const isDid = did(path, value);
+  if (!isDid.success) {
+    const isHandle = handle(path, value);
+    if (!isHandle.success) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be a valid did or a handle`)
+      };
+    }
+  }
+  return { success: true, value };
+}
+function nsid(path, value) {
+  try {
+    ensureValidNsid(value);
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid nsid`)
+    };
+  }
+  return { success: true, value };
+}
+function cid(path, value) {
+  try {
+    CID.parse(value);
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a cid string`)
+    };
+  }
+  return { success: true, value };
+}
+
+// ../lexicon/src/validators/primitives.ts
+function validate(lexicons, path, def2, value) {
+  switch (def2.type) {
     case "boolean":
-      return boolean(lexicons, path, def, value);
-    case "number":
-      return number(lexicons, path, def, value);
+      return boolean(lexicons, path, def2, value);
+    case "float":
+      return float(lexicons, path, def2, value);
     case "integer":
-      return integer(lexicons, path, def, value);
+      return integer(lexicons, path, def2, value);
     case "string":
-      return string(lexicons, path, def, value);
-    case "datetime":
-      return datetime(lexicons, path, def, value);
+      return string2(lexicons, path, def2, value);
+    case "bytes":
+      return bytes(lexicons, path, def2, value);
+    case "cid-link":
+      return cidLink(lexicons, path, def2, value);
     case "unknown":
-      return unknown(lexicons, path, def, value);
+      return unknown(lexicons, path, def2, value);
     default:
       return {
         success: false,
-        error: new ValidationError(`Unexpected lexicon type: ${def.type}`)
+        error: new ValidationError(`Unexpected lexicon type: ${def2.type}`)
       };
   }
 }
-function boolean(lexicons, path, def, value) {
-  def = def;
+function boolean(lexicons, path, def2, value) {
+  def2 = def2;
   const type = typeof value;
-  if (type == "undefined") {
-    if (typeof def.default === "boolean") {
-      return { success: true };
+  if (type === "undefined") {
+    if (typeof def2.default === "boolean") {
+      return { success: true, value: def2.default };
     }
     return {
       success: false,
@@ -3399,22 +5881,22 @@ function boolean(lexicons, path, def, value) {
       error: new ValidationError(`${path} must be a boolean`)
     };
   }
-  if (typeof def.const === "boolean") {
-    if (value !== def.const) {
+  if (typeof def2.const === "boolean") {
+    if (value !== def2.const) {
       return {
         success: false,
-        error: new ValidationError(`${path} must be ${def.const}`)
+        error: new ValidationError(`${path} must be ${def2.const}`)
       };
     }
   }
-  return { success: true };
+  return { success: true, value };
 }
-function number(lexicons, path, def, value) {
-  def = def;
+function float(lexicons, path, def2, value) {
+  def2 = def2;
   const type = typeof value;
-  if (type == "undefined") {
-    if (typeof def.default === "number") {
-      return { success: true };
+  if (type === "undefined") {
+    if (typeof def2.default === "number") {
+      return { success: true, value: def2.default };
     }
     return {
       success: false,
@@ -3426,51 +5908,53 @@ function number(lexicons, path, def, value) {
       error: new ValidationError(`${path} must be a number`)
     };
   }
-  if (typeof def.const === "number") {
-    if (value !== def.const) {
+  if (typeof def2.const === "number") {
+    if (value !== def2.const) {
       return {
         success: false,
-        error: new ValidationError(`${path} must be ${def.const}`)
+        error: new ValidationError(`${path} must be ${def2.const}`)
       };
     }
   }
-  if (Array.isArray(def.enum)) {
-    if (!def.enum.includes(value)) {
+  if (Array.isArray(def2.enum)) {
+    if (!def2.enum.includes(value)) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must be one of (${def.enum.join("|")})`
+          `${path} must be one of (${def2.enum.join("|")})`
         )
       };
     }
   }
-  if (typeof def.maximum === "number") {
-    if (value > def.maximum) {
+  if (typeof def2.maximum === "number") {
+    if (value > def2.maximum) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} can not be greater than ${def.maximum}`
+          `${path} can not be greater than ${def2.maximum}`
         )
       };
     }
   }
-  if (typeof def.minimum === "number") {
-    if (value < def.minimum) {
+  if (typeof def2.minimum === "number") {
+    if (value < def2.minimum) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} can not be less than ${def.minimum}`
+          `${path} can not be less than ${def2.minimum}`
         )
       };
     }
   }
-  return { success: true };
+  return { success: true, value };
 }
-function integer(lexicons, path, def, value) {
-  def = def;
-  const numRes = number(lexicons, path, def, value);
+function integer(lexicons, path, def2, value) {
+  def2 = def2;
+  const numRes = float(lexicons, path, def2, value);
   if (!numRes.success) {
     return numRes;
+  } else {
+    value = numRes.value;
   }
   if (!Number.isInteger(value)) {
     return {
@@ -3478,191 +5962,272 @@ function integer(lexicons, path, def, value) {
       error: new ValidationError(`${path} must be an integer`)
     };
   }
-  return { success: true };
+  return { success: true, value };
 }
-function string(lexicons, path, def, value) {
-  def = def;
-  const type = typeof value;
-  if (type == "undefined") {
-    if (typeof def.default === "string") {
-      return { success: true };
+function string2(lexicons, path, def2, value) {
+  def2 = def2;
+  if (typeof value === "undefined") {
+    if (typeof def2.default === "string") {
+      return { success: true, value: def2.default };
     }
     return {
       success: false,
       error: new ValidationError(`${path} must be a string`)
     };
-  } else if (type !== "string") {
+  } else if (typeof value !== "string") {
     return {
       success: false,
       error: new ValidationError(`${path} must be a string`)
     };
   }
-  if (typeof def.const === "string") {
-    if (value !== def.const) {
+  if (typeof def2.const === "string") {
+    if (value !== def2.const) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be ${def2.const}`)
+      };
+    }
+  }
+  if (Array.isArray(def2.enum)) {
+    if (!def2.enum.includes(value)) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must be one of (${def2.enum.join("|")})`
+        )
+      };
+    }
+  }
+  if (typeof def2.maxLength === "number") {
+    if (utf8Len(value) > def2.maxLength) {
       return {
         success: false,
-        error: new ValidationError(`${path} must be ${def.const}`)
+        error: new ValidationError(
+          `${path} must not be longer than ${def2.maxLength} characters`
+        )
       };
     }
   }
-  if (Array.isArray(def.enum)) {
-    if (!def.enum.includes(value)) {
+  if (typeof def2.minLength === "number") {
+    if (utf8Len(value) < def2.minLength) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must be one of (${def.enum.join("|")})`
+          `${path} must not be shorter than ${def2.minLength} characters`
         )
       };
     }
   }
-  if (typeof def.maxLength === "number") {
-    if (value.length > def.maxLength) {
+  if (typeof def2.maxGraphemes === "number") {
+    if (graphemeLen(value) > def2.maxGraphemes) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must not be longer than ${def.maxLength} characters`
+          `${path} must not be longer than ${def2.maxGraphemes} graphemes`
         )
       };
     }
   }
-  if (typeof def.minLength === "number") {
-    if (value.length < def.minLength) {
+  if (typeof def2.minGraphemes === "number") {
+    if (graphemeLen(value) < def2.minGraphemes) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must not be shorter than ${def.minLength} characters`
+          `${path} must not be shorter than ${def2.minGraphemes} graphemes`
         )
       };
     }
   }
-  return { success: true };
+  if (typeof def2.format === "string") {
+    switch (def2.format) {
+      case "datetime":
+        return datetime(path, value);
+      case "uri":
+        return uri(path, value);
+      case "at-uri":
+        return atUri(path, value);
+      case "did":
+        return did(path, value);
+      case "handle":
+        return handle(path, value);
+      case "at-identifier":
+        return atIdentifier(path, value);
+      case "nsid":
+        return nsid(path, value);
+      case "cid":
+        return cid(path, value);
+    }
+  }
+  return { success: true, value };
 }
-function datetime(lexicons, path, def, value) {
-  def = def;
-  const type = typeof value;
-  if (type !== "string") {
+function bytes(lexicons, path, def2, value) {
+  def2 = def2;
+  if (!value || !(value instanceof Uint8Array)) {
     return {
       success: false,
-      error: new ValidationError(`${path} must be a string`)
+      error: new ValidationError(`${path} must be a byte array`)
     };
   }
-  {
-    try {
-      if (typeof value !== "string" || !(0, import_iso_datestring_validator.isValidISODateString)(value)) {
-        throw new ValidationError(
-          `${path} must be an iso8601 formatted datetime`
-        );
-      }
-    } catch {
-      throw new ValidationError(`${path} must be an iso8601 formatted datetime`);
+  if (typeof def2.maxLength === "number") {
+    if (value.byteLength > def2.maxLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be larger than ${def2.maxLength} bytes`
+        )
+      };
+    }
+  }
+  if (typeof def2.minLength === "number") {
+    if (value.byteLength < def2.minLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be smaller than ${def2.minLength} bytes`
+        )
+      };
     }
   }
-  return { success: true };
+  return { success: true, value };
+}
+function cidLink(lexicons, path, def2, value) {
+  if (CID.asCID(value) === null) {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a CID`)
+    };
+  }
+  return { success: true, value };
 }
-function unknown(lexicons, path, def, value) {
+function unknown(lexicons, path, def2, value) {
   if (!value || typeof value !== "object") {
     return {
       success: false,
       error: new ValidationError(`${path} must be an object`)
     };
   }
-  return { success: true };
+  return { success: true, value };
 }
 
-// ../lexicon/src/validators/blob.ts
-function blob(lexicons, path, def, value) {
-  if (!isObj(value)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} should be an object`)
+// ../lexicon/src/blob-refs.ts
+var typedJsonBlobRef = mod.object({
+  $type: mod.literal("blob"),
+  ref: schema.cid,
+  mimeType: mod.string(),
+  size: mod.number()
+}).strict();
+var untypedJsonBlobRef = mod.object({
+  cid: mod.string(),
+  mimeType: mod.string()
+}).strict();
+var jsonBlobRef = mod.union([typedJsonBlobRef, untypedJsonBlobRef]);
+var BlobRef = class {
+  constructor(ref, mimeType, size, original) {
+    this.ref = ref;
+    this.mimeType = mimeType;
+    this.size = size;
+    this.original = original ?? {
+      $type: "blob",
+      ref,
+      mimeType,
+      size
     };
   }
-  if (!hasProp(value, "cid") || typeof value.cid !== "string") {
+  static asBlobRef(obj) {
+    if (check_exports.is(obj, jsonBlobRef)) {
+      return BlobRef.fromJsonRef(obj);
+    }
+    return null;
+  }
+  static fromJsonRef(json) {
+    if (check_exports.is(json, typedJsonBlobRef)) {
+      return new BlobRef(json.ref, json.mimeType, json.size);
+    } else {
+      return new BlobRef(CID.parse(json.cid), json.mimeType, -1, json);
+    }
+  }
+  ipld() {
     return {
-      success: false,
-      error: new ValidationError(`${path}/cid should be a string`)
+      $type: "blob",
+      ref: this.ref,
+      mimeType: this.mimeType,
+      size: this.size
     };
   }
-  if (!hasProp(value, "mimeType") || typeof value.mimeType !== "string") {
+  toJSON() {
+    return ipldToJson(this.ipld());
+  }
+};
+
+// ../lexicon/src/validators/blob.ts
+function blob(lexicons, path, def2, value) {
+  if (!value || !(value instanceof BlobRef)) {
     return {
       success: false,
-      error: new ValidationError(`${path}/mimeType should be a string`)
+      error: new ValidationError(`${path} should be a blob ref`)
     };
   }
-  return { success: true };
-}
-function image(lexicons, path, def, value) {
-  return blob(lexicons, path, def, value);
-}
-function video(lexicons, path, def, value) {
-  return blob(lexicons, path, def, value);
-}
-function audio(lexicons, path, def, value) {
-  return blob(lexicons, path, def, value);
+  return { success: true, value };
 }
 
 // ../lexicon/src/validators/complex.ts
-function validate2(lexicons, path, def, value) {
-  switch (def.type) {
+function validate2(lexicons, path, def2, value) {
+  switch (def2.type) {
     case "boolean":
-      return boolean(lexicons, path, def, value);
-    case "number":
-      return number(lexicons, path, def, value);
+      return boolean(lexicons, path, def2, value);
+    case "float":
+      return float(lexicons, path, def2, value);
     case "integer":
-      return integer(lexicons, path, def, value);
+      return integer(lexicons, path, def2, value);
     case "string":
-      return string(lexicons, path, def, value);
-    case "datetime":
-      return datetime(lexicons, path, def, value);
+      return string2(lexicons, path, def2, value);
+    case "bytes":
+      return bytes(lexicons, path, def2, value);
+    case "cid-link":
+      return cidLink(lexicons, path, def2, value);
     case "unknown":
-      return unknown(lexicons, path, def, value);
+      return unknown(lexicons, path, def2, value);
     case "object":
-      return object(lexicons, path, def, value);
+      return object(lexicons, path, def2, value);
     case "array":
-      return array(lexicons, path, def, value);
+      return array(lexicons, path, def2, value);
     case "blob":
-      return blob(lexicons, path, def, value);
-    case "image":
-      return image(lexicons, path, def, value);
-    case "video":
-      return video(lexicons, path, def, value);
-    case "audio":
-      return audio(lexicons, path, def, value);
+      return blob(lexicons, path, def2, value);
     default:
       return {
         success: false,
-        error: new ValidationError(`Unexpected lexicon type: ${def.type}`)
+        error: new ValidationError(`Unexpected lexicon type: ${def2.type}`)
       };
   }
 }
-function array(lexicons, path, def, value) {
+function array(lexicons, path, def2, value) {
   if (!Array.isArray(value)) {
     return {
       success: false,
       error: new ValidationError(`${path} must be an array`)
     };
   }
-  if (typeof def.maxLength === "number") {
-    if (value.length > def.maxLength) {
+  if (typeof def2.maxLength === "number") {
+    if (value.length > def2.maxLength) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must not have more than ${def.maxLength} elements`
+          `${path} must not have more than ${def2.maxLength} elements`
         )
       };
     }
   }
-  if (typeof def.minLength === "number") {
-    if (value.length < def.minLength) {
+  if (typeof def2.minLength === "number") {
+    if (value.length < def2.minLength) {
       return {
         success: false,
         error: new ValidationError(
-          `${path} must not have fewer than ${def.minLength} elements`
+          `${path} must not have fewer than ${def2.minLength} elements`
         )
       };
     }
   }
-  const itemsDef = def.items;
+  const itemsDef = def2.items;
   for (let i = 0; i < value.length; i++) {
     const itemValue = value[i];
     const itemPath = `${path}/${i}`;
@@ -3671,41 +6236,46 @@ function array(lexicons, path, def, value) {
       return res;
     }
   }
-  return { success: true };
+  return { success: true, value };
 }
-function object(lexicons, path, def, value) {
-  def = def;
+function object(lexicons, path, def2, value) {
+  def2 = def2;
   if (!value || typeof value !== "object") {
     return {
       success: false,
       error: new ValidationError(`${path} must be an object`)
     };
   }
-  if (Array.isArray(def.required)) {
-    for (const key of def.required) {
-      if (typeof value[key] === "undefined") {
+  const requiredProps = new Set(def2.required);
+  const nullableProps = new Set(def2.nullable);
+  let resultValue = value;
+  if (typeof def2.properties === "object") {
+    for (const key in def2.properties) {
+      if (value[key] === null && nullableProps.has(key)) {
+        continue;
+      }
+      const propDef = def2.properties[key];
+      const propPath = `${path}/${key}`;
+      const validated = validateOneOf(lexicons, propPath, propDef, value[key]);
+      const propValue = validated.success ? validated.value : value[key];
+      const propIsUndefined = typeof propValue === "undefined";
+      if (propIsUndefined && requiredProps.has(key)) {
         return {
           success: false,
           error: new ValidationError(`${path} must have the property "${key}"`)
         };
+      } else if (!propIsUndefined && !validated.success) {
+        return validated;
       }
-    }
-  }
-  if (typeof def.properties === "object") {
-    for (const key in def.properties) {
-      const propValue = value[key];
-      if (typeof propValue === "undefined") {
-        continue;
-      }
-      const propDef = def.properties[key];
-      const propPath = `${path}/${key}`;
-      const res = validateOneOf(lexicons, propPath, propDef, propValue);
-      if (!res.success) {
-        return res;
+      if (propValue !== value[key]) {
+        if (resultValue === value) {
+          resultValue = { ...value };
+        }
+        resultValue[key] = propValue;
       }
     }
   }
-  return { success: true };
+  return { success: true, value: resultValue };
 }
 
 // ../lexicon/src/util.ts
@@ -3721,10 +6291,10 @@ function toLexUri(str, baseUri) {
   }
   return `lex:${str}`;
 }
-function validateOneOf(lexicons, path, def, value, mustBeObj = false) {
+function validateOneOf(lexicons, path, def2, value, mustBeObj = false) {
   let error;
   let concreteDefs;
-  if (def.type === "union") {
+  if (def2.type === "union") {
     if (!isDiscriminatedObject(value)) {
       return {
         success: false,
@@ -3733,16 +6303,16 @@ function validateOneOf(lexicons, path, def, value, mustBeObj = false) {
         )
       };
     }
-    if (!def.refs.includes(toLexUri(value.$type))) {
-      if (def.closed) {
+    if (!def2.refs.includes(toLexUri(value.$type))) {
+      if (def2.closed) {
         return {
           success: false,
           error: new ValidationError(
-            `${path} $type must be one of ${def.refs.join(", ")}`
+            `${path} $type must be one of ${def2.refs.join(", ")}`
           )
         };
       }
-      return { success: true };
+      return { success: true, value };
     } else {
       concreteDefs = toConcreteTypes(lexicons, {
         type: "ref",
@@ -3750,7 +6320,7 @@ function validateOneOf(lexicons, path, def, value, mustBeObj = false) {
       });
     }
   } else {
-    concreteDefs = toConcreteTypes(lexicons, def);
+    concreteDefs = toConcreteTypes(lexicons, def2);
   }
   for (const concreteDef of concreteDefs) {
     const result = mustBeObj ? object(lexicons, path, concreteDef, value) : validate2(lexicons, path, concreteDef, value);
@@ -3769,72 +6339,86 @@ function validateOneOf(lexicons, path, def, value, mustBeObj = false) {
   }
   return { success: false, error };
 }
-function assertValidOneOf(lexicons, path, def, value, mustBeObj = false) {
-  const res = validateOneOf(lexicons, path, def, value, mustBeObj);
-  if (!res.success) {
+function assertValidOneOf(lexicons, path, def2, value, mustBeObj = false) {
+  const res = validateOneOf(lexicons, path, def2, value, mustBeObj);
+  if (!res.success)
     throw res.error;
-  }
+  return res.value;
 }
-function toConcreteTypes(lexicons, def) {
-  if (def.type === "ref") {
-    return [lexicons.getDefOrThrow(def.ref)];
-  } else if (def.type === "union") {
-    return def.refs.map((ref) => lexicons.getDefOrThrow(ref)).flat();
+function toConcreteTypes(lexicons, def2) {
+  if (def2.type === "ref") {
+    return [lexicons.getDefOrThrow(def2.ref)];
+  } else if (def2.type === "union") {
+    return def2.refs.map((ref) => lexicons.getDefOrThrow(ref)).flat();
   } else {
-    return [def];
+    return [def2];
   }
 }
 
 // ../lexicon/src/validators/xrpc.ts
-function params(lexicons, path, def, value) {
-  if (!value || typeof value !== "object") {
-    value = {};
-  }
-  if (Array.isArray(def.required)) {
-    for (const key of def.required) {
-      if (typeof value[key] === "undefined") {
+function params(lexicons, path, def2, val) {
+  const value = val && typeof val === "object" ? val : {};
+  const requiredProps = new Set(def2.required ?? []);
+  let resultValue = value;
+  if (typeof def2.properties === "object") {
+    for (const key in def2.properties) {
+      const propDef = def2.properties[key];
+      const validated = propDef.type === "array" ? array(lexicons, key, propDef, value[key]) : validate(lexicons, key, propDef, value[key]);
+      const propValue = validated.success ? validated.value : value[key];
+      const propIsUndefined = typeof propValue === "undefined";
+      if (propIsUndefined && requiredProps.has(key)) {
         return {
           success: false,
           error: new ValidationError(`${path} must have the property "${key}"`)
         };
+      } else if (!propIsUndefined && !validated.success) {
+        return validated;
+      }
+      if (propValue !== value[key]) {
+        if (resultValue === value) {
+          resultValue = { ...value };
+        }
+        resultValue[key] = propValue;
       }
     }
   }
-  for (const key in def.properties) {
-    if (typeof value[key] === "undefined") {
-      continue;
-    }
-    const paramDef = def.properties[key];
-    const val = value[key];
-    const res = paramDef.type === "array" ? array(lexicons, key, paramDef, val) : validate(lexicons, key, paramDef, val);
-    if (!res.success) {
-      return res;
-    }
-  }
-  return { success: true };
+  return { success: true, value: resultValue };
 }
 
 // ../lexicon/src/validation.ts
-function assertValidRecord(lexicons, def, value) {
-  const res = object(lexicons, "Record", def.record, value);
+function assertValidRecord(lexicons, def2, value) {
+  const res = object(lexicons, "Record", def2.record, value);
   if (!res.success)
     throw res.error;
+  return res.value;
 }
-function assertValidXrpcParams(lexicons, def, value) {
-  if (def.parameters) {
-    const res = params(lexicons, "Params", def.parameters, value);
+function assertValidXrpcParams(lexicons, def2, value) {
+  if (def2.parameters) {
+    const res = params(lexicons, "Params", def2.parameters, value);
     if (!res.success)
       throw res.error;
+    return res.value;
+  }
+}
+function assertValidXrpcInput(lexicons, def2, value) {
+  if (def2.input?.schema) {
+    return assertValidOneOf(lexicons, "Input", def2.input.schema, value, true);
   }
 }
-function assertValidXrpcInput(lexicons, def, value) {
-  if (def.input?.schema) {
-    assertValidOneOf(lexicons, "Input", def.input.schema, value, true);
+function assertValidXrpcOutput(lexicons, def2, value) {
+  if (def2.output?.schema) {
+    return assertValidOneOf(lexicons, "Output", def2.output.schema, value, true);
   }
 }
-function assertValidXrpcOutput(lexicons, def, value) {
-  if (def.output?.schema) {
-    assertValidOneOf(lexicons, "Output", def.output.schema, value, true);
+function assertValidXrpcMessage(lexicons, def2, value) {
+  if (def2.message?.schema) {
+    return assertValidOneOf(
+      lexicons,
+      "Message",
+      def2.message.schema,
+      value,
+      true
+    );
   }
 }
 
@@ -3864,64 +6448,64 @@ var Lexicons = class {
       }
     }
     const validatedDoc = doc;
-    const uri = toLexUri(validatedDoc.id);
-    if (this.docs.has(uri)) {
-      throw new Error(`${uri} has already been registered`);
+    const uri2 = toLexUri(validatedDoc.id);
+    if (this.docs.has(uri2)) {
+      throw new Error(`${uri2} has already been registered`);
     }
-    resolveRefUris(validatedDoc, uri);
-    this.docs.set(uri, validatedDoc);
-    for (const [defUri, def] of iterDefs(validatedDoc)) {
-      this.defs.set(defUri, def);
+    resolveRefUris(validatedDoc, uri2);
+    this.docs.set(uri2, validatedDoc);
+    for (const [defUri, def2] of iterDefs(validatedDoc)) {
+      this.defs.set(defUri, def2);
     }
   }
-  remove(uri) {
-    uri = toLexUri(uri);
-    const doc = this.docs.get(uri);
+  remove(uri2) {
+    uri2 = toLexUri(uri2);
+    const doc = this.docs.get(uri2);
     if (!doc) {
-      throw new Error(`Unable to remove "${uri}": does not exist`);
+      throw new Error(`Unable to remove "${uri2}": does not exist`);
     }
     for (const [defUri, _def] of iterDefs(doc)) {
       this.defs.delete(defUri);
     }
-    this.docs.delete(uri);
+    this.docs.delete(uri2);
   }
-  get(uri) {
-    uri = toLexUri(uri);
-    return this.docs.get(uri);
+  get(uri2) {
+    uri2 = toLexUri(uri2);
+    return this.docs.get(uri2);
   }
-  getDef(uri) {
-    uri = toLexUri(uri);
-    return this.defs.get(uri);
+  getDef(uri2) {
+    uri2 = toLexUri(uri2);
+    return this.defs.get(uri2);
   }
-  getDefOrThrow(uri, types) {
-    const def = this.getDef(uri);
-    if (!def) {
-      throw new LexiconDefNotFoundError(`Lexicon not found: ${uri}`);
+  getDefOrThrow(uri2, types) {
+    const def2 = this.getDef(uri2);
+    if (!def2) {
+      throw new LexiconDefNotFoundError(`Lexicon not found: ${uri2}`);
     }
-    if (types && !types.includes(def.type)) {
+    if (types && !types.includes(def2.type)) {
       throw new InvalidLexiconError(
-        `Not a ${types.join(" or ")} lexicon: ${uri}`
+        `Not a ${types.join(" or ")} lexicon: ${uri2}`
       );
     }
-    return def;
+    return def2;
   }
   validate(lexUri, value) {
     lexUri = toLexUri(lexUri);
-    const def = this.getDefOrThrow(lexUri, ["record", "object"]);
+    const def2 = this.getDefOrThrow(lexUri, ["record", "object"]);
     if (!isObj(value)) {
       throw new ValidationError(`Value must be an object`);
     }
-    if (def.type === "record") {
-      return object(this, "Record", def.record, value);
-    } else if (def.type === "object") {
-      return object(this, "Object", def, value);
+    if (def2.type === "record") {
+      return object(this, "Record", def2.record, value);
+    } else if (def2.type === "object") {
+      return object(this, "Object", def2, value);
     } else {
       throw new InvalidLexiconError("Definition must be a record or object");
     }
   }
   assertValidRecord(lexUri, value) {
     lexUri = toLexUri(lexUri);
-    const def = this.getDefOrThrow(lexUri, ["record"]);
+    const def2 = this.getDefOrThrow(lexUri, ["record"]);
     if (!isObj(value)) {
       throw new ValidationError(`Record must be an object`);
     }
@@ -3934,22 +6518,43 @@ var Lexicons = class {
         `Invalid $type: must be ${lexUri}, got ${$type}`
       );
     }
-    assertValidRecord(this, def, value);
+    return assertValidRecord(this, def2, value);
   }
   assertValidXrpcParams(lexUri, value) {
     lexUri = toLexUri(lexUri);
-    const def = this.getDefOrThrow(lexUri, ["query", "procedure"]);
-    assertValidXrpcParams(this, def, value);
+    const def2 = this.getDefOrThrow(lexUri, [
+      "query",
+      "procedure",
+      "subscription"
+    ]);
+    return assertValidXrpcParams(
+      this,
+      def2,
+      value
+    );
   }
   assertValidXrpcInput(lexUri, value) {
     lexUri = toLexUri(lexUri);
-    const def = this.getDefOrThrow(lexUri, ["procedure"]);
-    assertValidXrpcInput(this, def, value);
+    const def2 = this.getDefOrThrow(lexUri, ["procedure"]);
+    return assertValidXrpcInput(this, def2, value);
   }
   assertValidXrpcOutput(lexUri, value) {
     lexUri = toLexUri(lexUri);
-    const def = this.getDefOrThrow(lexUri, ["query", "procedure"]);
-    assertValidXrpcOutput(this, def, value);
+    const def2 = this.getDefOrThrow(lexUri, ["query", "procedure"]);
+    return assertValidXrpcOutput(
+      this,
+      def2,
+      value
+    );
+  }
+  assertValidXrpcMessage(lexUri, value) {
+    lexUri = toLexUri(lexUri);
+    const def2 = this.getDefOrThrow(lexUri, ["subscription"]);
+    return assertValidXrpcMessage(this, def2, value);
+  }
+  resolveLexUri(lexUri, ref) {
+    lexUri = toLexUri(lexUri);
+    return toLexUri(ref, lexUri);
   }
 };
 function* iterDefs(doc) {
@@ -3982,19 +6587,71 @@ function resolveRefUris(obj, baseUri) {
   return obj;
 }
 
+// ../lexicon/src/serialize.ts
+var lexToIpld = (val) => {
+  if (Array.isArray(val)) {
+    return val.map((item) => lexToIpld(item));
+  }
+  if (val && typeof val === "object") {
+    if (val instanceof BlobRef) {
+      return val.original;
+    }
+    if (CID.asCID(val) || val instanceof Uint8Array) {
+      return val;
+    }
+    const toReturn = {};
+    for (const key of Object.keys(val)) {
+      toReturn[key] = lexToIpld(val[key]);
+    }
+    return toReturn;
+  }
+  return val;
+};
+var ipldToLex = (val) => {
+  if (Array.isArray(val)) {
+    return val.map((item) => ipldToLex(item));
+  }
+  if (val && typeof val === "object") {
+    if ((val["$type"] === "blob" || typeof val["cid"] === "string" && typeof val["mimeType"] === "string") && check_exports.is(val, jsonBlobRef)) {
+      return BlobRef.fromJsonRef(val);
+    }
+    if (CID.asCID(val) || val instanceof Uint8Array) {
+      return val;
+    }
+    const toReturn = {};
+    for (const key of Object.keys(val)) {
+      toReturn[key] = ipldToLex(val[key]);
+    }
+    return toReturn;
+  }
+  return val;
+};
+var lexToJson = (val) => {
+  return ipldToJson(lexToIpld(val));
+};
+var stringifyLex = (val) => {
+  return JSON.stringify(lexToJson(val));
+};
+var jsonToLex = (val) => {
+  return ipldToLex(jsonToIpld(val));
+};
+var jsonStringToLex = (val) => {
+  return jsonToLex(JSON.parse(val));
+};
+
 // src/util.ts
-function getMethodSchemaHTTPMethod(schema) {
-  if (schema.type === "procedure") {
+function getMethodSchemaHTTPMethod(schema2) {
+  if (schema2.type === "procedure") {
     return "post";
   }
   return "get";
 }
-function constructMethodCallUri(nsid, schema, serviceUri, params2) {
-  const uri = new URL(serviceUri);
-  uri.pathname = `/xrpc/${nsid}`;
+function constructMethodCallUri(nsid2, schema2, serviceUri, params2) {
+  const uri2 = new URL(serviceUri);
+  uri2.pathname = `/xrpc/${nsid2}`;
   if (params2) {
     for (const [key, value] of Object.entries(params2)) {
-      const paramSchema = schema.parameters?.properties?.[key];
+      const paramSchema = schema2.parameters?.properties?.[key];
       if (!paramSchema) {
         throw new Error(`Invalid query parameter: ${key}`);
       }
@@ -4002,24 +6659,24 @@ function constructMethodCallUri(nsid, schema, serviceUri, params2) {
         if (paramSchema.type === "array") {
           const vals = [];
           vals.concat(value).forEach((val) => {
-            uri.searchParams.append(
+            uri2.searchParams.append(
               key,
               encodeQueryParam(paramSchema.items.type, val)
             );
           });
         } else {
-          uri.searchParams.set(key, encodeQueryParam(paramSchema.type, value));
+          uri2.searchParams.set(key, encodeQueryParam(paramSchema.type, value));
         }
       }
     }
   }
-  return uri.toString();
+  return uri2.toString();
 }
 function encodeQueryParam(type, value) {
   if (type === "string" || type === "unknown") {
     return String(value);
   }
-  if (type === "number") {
+  if (type === "float") {
     return String(Number(value));
   } else if (type === "integer") {
     return String(Number(value) | 0);
@@ -4033,9 +6690,9 @@ function encodeQueryParam(type, value) {
   }
   throw new Error(`Unsupported query param type: ${type}`);
 }
-function constructMethodCallHeaders(schema, data, opts) {
+function constructMethodCallHeaders(schema2, data, opts) {
   const headers = opts?.headers || {};
-  if (schema.type === "procedure") {
+  if (schema2.type === "procedure") {
     if (opts?.encoding) {
       headers["Content-Type"] = opts.encoding;
     }
@@ -4058,7 +6715,7 @@ function encodeMethodCallBody(headers, data) {
     return new TextEncoder().encode(data.toString());
   }
   if (headers["Content-Type"].startsWith("application/json")) {
-    return new TextEncoder().encode(JSON.stringify(data));
+    return new TextEncoder().encode(stringifyLex(data));
   }
   return data;
 }
@@ -4084,7 +6741,7 @@ function httpResponseBodyParse(mimeType, data) {
     if (mimeType.includes("application/json") && data?.byteLength) {
       try {
         const str = new TextDecoder().decode(data);
-        return JSON.parse(str);
+        return jsonStringToLex(str);
       } catch (e) {
         throw new XRPCError(
           2 /* InvalidResponse */,
@@ -4103,6 +6760,9 @@ function httpResponseBodyParse(mimeType, data) {
       }
     }
   }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
   return data;
 }
 
@@ -4126,8 +6786,8 @@ var Client = class {
       this.addLexicon(doc);
     }
   }
-  removeLexicon(uri) {
-    this.lex.remove(uri);
+  removeLexicon(uri2) {
+    this.lex.remove(uri2);
   }
 };
 var ServiceClient = class {
@@ -4143,15 +6803,15 @@ var ServiceClient = class {
     delete this.headers[key];
   }
   async call(methodNsid, params2, data, opts) {
-    const def = this.baseClient.lex.getDefOrThrow(methodNsid);
-    if (!def || def.type !== "query" && def.type !== "procedure") {
+    const def2 = this.baseClient.lex.getDefOrThrow(methodNsid);
+    if (!def2 || def2.type !== "query" && def2.type !== "procedure") {
       throw new Error(
         `Invalid lexicon: ${methodNsid}. Must be a query or procedure.`
       );
     }
-    const httpMethod = getMethodSchemaHTTPMethod(def);
-    const httpUri = constructMethodCallUri(methodNsid, def, this.uri, params2);
-    const httpHeaders = constructMethodCallHeaders(def, data, {
+    const httpMethod = getMethodSchemaHTTPMethod(def2);
+    const httpUri = constructMethodCallUri(methodNsid, def2, this.uri, params2);
+    const httpHeaders = constructMethodCallHeaders(def2, data, {
       headers: {
         ...this.headers,
         ...opts?.headers