From 4a608ee14ad2cf0f2e79a6e20e45293b8505ffad Mon Sep 17 00:00:00 2001
From: Roscoe Rubin-Rottenberg <roscoe@knotbin.com>
Date: Wed, 26 Nov 2025 11:05:28 -0500
Subject: [PATCH] legacy lexgen improvements and remove new lex for now

---
 .vscode/settings.json                     |   3 +
 data/blob.ts                              |  99 ------
 data/cid.ts                               |  50 ---
 data/deno.json                            |   9 -
 data/language.ts                          |  40 ---
 data/lex.ts                               | 160 ----------
 data/mod.ts                               |   7 -
 data/object.ts                            |  21 --
 data/tests/blob_test.ts                   | 183 -----------
 data/tests/language_test.ts               |  80 -----
 data/tests/lex-equals_test.ts             | 150 ---------
 data/tests/lex_test.ts                    | 122 -------
 data/tests/object_test.ts                 |  76 -----
 data/tests/utf8_test.ts                   |  32 --
 data/uint8array.ts                        |  38 ---
 data/utf8.ts                              |  46 ---
 deno.lock                                 |  81 ++++-
 lex-gen/cmd/gen-api.ts                    |  11 +-
 lex-gen/cmd/gen-md.ts                     |  12 +-
 lex-gen/cmd/gen-server.ts                 |  11 +-
 lex-gen/cmd/gen-ts-obj.ts                 |  19 +-
 lex-gen/util.ts                           |  80 ++++-
 lex/deno.json                             |   9 -
 lex/schema/core.ts                        |   5 -
 lex/schema/core/$type.ts                  |  16 -
 lex/schema/core/record-key.ts             |  15 -
 lex/schema/core/result.ts                 |  75 -----
 lex/schema/core/string-format.ts          | 121 -------
 lex/schema/core/types.ts                  |  22 --
 lex/schema/external.ts                    | 363 ---------------------
 lex/schema/index.ts                       |   3 -
 lex/schema/schema.ts                      |  40 ---
 lex/schema/schema/_parameters.ts          |  26 --
 lex/schema/schema/array.ts                |  55 ----
 lex/schema/schema/blob.ts                 |  86 -----
 lex/schema/schema/boolean.ts              |  28 --
 lex/schema/schema/bytes.ts                |  42 ---
 lex/schema/schema/cid.ts                  |  31 --
 lex/schema/schema/custom.ts               |  36 ---
 lex/schema/schema/dict.ts                 |  67 ----
 lex/schema/schema/discriminated-union.ts  | 143 ---------
 lex/schema/schema/enum.ts                 |  24 --
 lex/schema/schema/integer.ts              |  45 ---
 lex/schema/schema/intersection.ts         |  56 ----
 lex/schema/schema/literal.ts              |  24 --
 lex/schema/schema/never.ts                |  14 -
 lex/schema/schema/null.ts                 |  24 --
 lex/schema/schema/object.ts               | 178 -----------
 lex/schema/schema/params.ts               | 160 ----------
 lex/schema/schema/payload.ts              |  50 ---
 lex/schema/schema/permission-set.ts       |  22 --
 lex/schema/schema/permission.ts           |  15 -
 lex/schema/schema/procedure.ts            |  34 --
 lex/schema/schema/query.ts                |  27 --
 lex/schema/schema/record.ts               | 108 -------
 lex/schema/schema/ref.ts                  |  51 ---
 lex/schema/schema/string.ts               | 143 ---------
 lex/schema/schema/subscription.ts         |  33 --
 lex/schema/schema/token.ts                |  45 ---
 lex/schema/schema/typed-object.ts         |  66 ----
 lex/schema/schema/typed-ref.ts            |  74 -----
 lex/schema/schema/typed-union.ts          | 107 -------
 lex/schema/schema/union.ts                |  42 ---
 lex/schema/schema/unknown-object.ts       |  24 --
 lex/schema/schema/unknown.ts              |  14 -
 lex/schema/tests/array-agg_test.ts        |  40 ---
 lex/schema/tests/object_test.ts           | 131 --------
 lex/schema/util/array-agg.ts              |  43 ---
 lex/schema/validation.ts                  |   4 -
 lex/schema/validation/property-key.ts     |   1 -
 lex/schema/validation/validation-error.ts |  32 --
 lex/schema/validation/validation-issue.ts | 239 --------------
 lex/schema/validation/validator.ts        | 368 ----------------------
 73 files changed, 192 insertions(+), 4559 deletions(-)
 create mode 100644 .vscode/settings.json
 delete mode 100644 data/blob.ts
 delete mode 100644 data/cid.ts
 delete mode 100644 data/deno.json
 delete mode 100644 data/language.ts
 delete mode 100644 data/lex.ts
 delete mode 100644 data/mod.ts
 delete mode 100644 data/object.ts
 delete mode 100644 data/tests/blob_test.ts
 delete mode 100644 data/tests/language_test.ts
 delete mode 100644 data/tests/lex-equals_test.ts
 delete mode 100644 data/tests/lex_test.ts
 delete mode 100644 data/tests/object_test.ts
 delete mode 100644 data/tests/utf8_test.ts
 delete mode 100644 data/uint8array.ts
 delete mode 100644 data/utf8.ts
 delete mode 100644 lex/deno.json
 delete mode 100644 lex/schema/core.ts
 delete mode 100644 lex/schema/core/$type.ts
 delete mode 100644 lex/schema/core/record-key.ts
 delete mode 100644 lex/schema/core/result.ts
 delete mode 100644 lex/schema/core/string-format.ts
 delete mode 100644 lex/schema/core/types.ts
 delete mode 100644 lex/schema/external.ts
 delete mode 100644 lex/schema/index.ts
 delete mode 100644 lex/schema/schema.ts
 delete mode 100644 lex/schema/schema/_parameters.ts
 delete mode 100644 lex/schema/schema/array.ts
 delete mode 100644 lex/schema/schema/blob.ts
 delete mode 100644 lex/schema/schema/boolean.ts
 delete mode 100644 lex/schema/schema/bytes.ts
 delete mode 100644 lex/schema/schema/cid.ts
 delete mode 100644 lex/schema/schema/custom.ts
 delete mode 100644 lex/schema/schema/dict.ts
 delete mode 100644 lex/schema/schema/discriminated-union.ts
 delete mode 100644 lex/schema/schema/enum.ts
 delete mode 100644 lex/schema/schema/integer.ts
 delete mode 100644 lex/schema/schema/intersection.ts
 delete mode 100644 lex/schema/schema/literal.ts
 delete mode 100644 lex/schema/schema/never.ts
 delete mode 100644 lex/schema/schema/null.ts
 delete mode 100644 lex/schema/schema/object.ts
 delete mode 100644 lex/schema/schema/params.ts
 delete mode 100644 lex/schema/schema/payload.ts
 delete mode 100644 lex/schema/schema/permission-set.ts
 delete mode 100644 lex/schema/schema/permission.ts
 delete mode 100644 lex/schema/schema/procedure.ts
 delete mode 100644 lex/schema/schema/query.ts
 delete mode 100644 lex/schema/schema/record.ts
 delete mode 100644 lex/schema/schema/ref.ts
 delete mode 100644 lex/schema/schema/string.ts
 delete mode 100644 lex/schema/schema/subscription.ts
 delete mode 100644 lex/schema/schema/token.ts
 delete mode 100644 lex/schema/schema/typed-object.ts
 delete mode 100644 lex/schema/schema/typed-ref.ts
 delete mode 100644 lex/schema/schema/typed-union.ts
 delete mode 100644 lex/schema/schema/union.ts
 delete mode 100644 lex/schema/schema/unknown-object.ts
 delete mode 100644 lex/schema/schema/unknown.ts
 delete mode 100644 lex/schema/tests/array-agg_test.ts
 delete mode 100644 lex/schema/tests/object_test.ts
 delete mode 100644 lex/schema/util/array-agg.ts
 delete mode 100644 lex/schema/validation.ts
 delete mode 100644 lex/schema/validation/property-key.ts
 delete mode 100644 lex/schema/validation/validation-error.ts
 delete mode 100644 lex/schema/validation/validation-issue.ts
 delete mode 100644 lex/schema/validation/validator.ts

diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..205df23
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "git.enabled": false
+}
\ No newline at end of file
diff --git a/data/blob.ts b/data/blob.ts
deleted file mode 100644
index 62c0d48..0000000
--- a/data/blob.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { CID, RAW_BIN_MULTICODEC, SHA2_256_MULTIHASH_CODE } from "./cid.ts";
-import { isPlainObject } from "./object.ts";
-
-export type BlobRef = {
-  $type: "blob";
-  mimeType: string;
-  ref: CID;
-  size: number;
-};
-
-export function isBlobRef(
-  input: unknown,
-  options?: { strict?: boolean },
-): input is BlobRef {
-  if (!isPlainObject(input)) {
-    return false;
-  }
-
-  if (input?.$type !== "blob") {
-    return false;
-  }
-
-  const { mimeType, size, ref } = input;
-  if (typeof mimeType !== "string") {
-    return false;
-  }
-
-  if (typeof size !== "number" || size < 0 || !Number.isInteger(size)) {
-    return false;
-  }
-
-  if (typeof ref !== "object" || ref === null) {
-    return false;
-  }
-
-  for (const key in input) {
-    if (
-      key !== "$type" &&
-      key !== "mimeType" &&
-      key !== "ref" &&
-      key !== "size"
-    ) {
-      return false;
-    }
-  }
-
-  const cid = CID.asCID(ref);
-  if (!cid) {
-    return false;
-  }
-
-  if (options?.strict) {
-    if (cid.version !== 1) {
-      return false;
-    }
-    if (cid.code !== RAW_BIN_MULTICODEC) {
-      return false;
-    }
-    if (cid.multihash.code !== SHA2_256_MULTIHASH_CODE) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export type LegacyBlobRef = {
-  cid: string;
-  mimeType: string;
-};
-
-export function isLegacyBlobRef(input: unknown): input is LegacyBlobRef {
-  if (!isPlainObject(input)) {
-    return false;
-  }
-
-  const { cid, mimeType } = input;
-  if (typeof cid !== "string") {
-    return false;
-  }
-
-  if (typeof mimeType !== "string") {
-    return false;
-  }
-
-  for (const key in input) {
-    if (key !== "cid" && key !== "mimeType") {
-      return false;
-    }
-  }
-
-  try {
-    CID.parse(cid);
-  } catch {
-    return false;
-  }
-
-  return true;
-}
diff --git a/data/cid.ts b/data/cid.ts
deleted file mode 100644
index 5f7430c..0000000
--- a/data/cid.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { CID } from "multiformats/cid";
-
-export const DAG_CBOR_MULTICODEC = 0x71;
-export const RAW_BIN_MULTICODEC = 0x55;
-
-export const SHA2_256_MULTIHASH_CODE = 0x12;
-
-export { CID };
-
-export function isCid(
-  value: unknown,
-  options?: { strict?: boolean },
-): value is CID {
-  const cid = CID.asCID(value);
-  if (!cid) {
-    return false;
-  }
-
-  if (options?.strict) {
-    if (cid.version !== 1) {
-      return false;
-    }
-    if (cid.code !== RAW_BIN_MULTICODEC && cid.code !== DAG_CBOR_MULTICODEC) {
-      return false;
-    }
-    if (cid.multihash.code !== SHA2_256_MULTIHASH_CODE) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function validateCidString(input: string): boolean {
-  return parseCidString(input)?.toString() === input;
-}
-
-export function parseCidString(input: string): CID | undefined {
-  try {
-    return CID.parse(input);
-  } catch {
-    return undefined;
-  }
-}
-
-export function ensureValidCidString(input: string): void {
-  if (!validateCidString(input)) {
-    throw new Error(`Invalid CID string`);
-  }
-}
diff --git a/data/deno.json b/data/deno.json
deleted file mode 100644
index a81eedd..0000000
--- a/data/deno.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "name": "@atp/data",
-  "version": "0.1.0-alpha.1",
-  "exports": "./mod.ts",
-  "license": "MIT",
-  "imports": {
-    "multiformats": "npm:multiformats@^13.4.1"
-  }
-}
diff --git a/data/language.ts b/data/language.ts
deleted file mode 100644
index ef33d31..0000000
--- a/data/language.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-const BCP47_REGEXP =
-  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/;
-
-export type LanguageTag = {
-  grandfathered?: string;
-  language?: string;
-  extlang?: string;
-  script?: string;
-  region?: string;
-  variant?: string;
-  extension?: string;
-  privateUse?: string;
-};
-
-export function parseLanguage(input: string): LanguageTag | null {
-  const parsed = input.match(BCP47_REGEXP);
-  if (!parsed?.groups) return null;
-
-  const { groups } = parsed;
-  const result: LanguageTag = {};
-  if (groups.grandfathered) result.grandfathered = groups.grandfathered;
-  if (groups.language) result.language = groups.language;
-  if (groups.extlang) result.extlang = groups.extlang;
-  if (groups.script) result.script = groups.script;
-  if (groups.region) result.region = groups.region;
-  if (groups.variant) result.variant = groups.variant;
-  if (groups.extension) result.extension = groups.extension;
-  const privateUse = groups.privateUseA || groups.privateUseB;
-  if (privateUse) result.privateUse = privateUse;
-  return result;
-}
-
-/**
- * Validates well-formed BCP 47 syntax
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
- */
-export function isLanguage(input: string): boolean {
-  return BCP47_REGEXP.test(input);
-}
diff --git a/data/lex.ts b/data/lex.ts
deleted file mode 100644
index 26b658a..0000000
--- a/data/lex.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import { CID, isCid } from "./cid.ts";
-import { isPlainObject } from "./object.ts";
-import { ui8Equals } from "./uint8array.ts";
-
-// @NOTE BlobRef is just a special case of LexMap.
-
-export type LexScalar = number | string | boolean | null | CID | Uint8Array;
-export type LexValue = LexScalar | LexValue[] | { [_ in string]?: LexValue };
-export type LexMap = { [_ in string]?: LexValue };
-export type LexArray = LexValue[];
-
-export function isLexMap(value: unknown): value is LexMap {
-  if (!isPlainObject(value)) return false;
-  for (const key in value) {
-    if (!isLexValue(value[key])) return false;
-  }
-  return true;
-}
-
-export function isLexArray(value: unknown): value is LexArray {
-  if (!Array.isArray(value)) return false;
-  for (let i = 0; i < value.length; i++) {
-    if (!isLexValue(value[i])) return false;
-  }
-  return true;
-}
-
-export function isLexScalar(value: unknown): value is LexScalar {
-  switch (typeof value) {
-    case "object":
-      if (value === null) return true;
-      return value instanceof Uint8Array || isCid(value);
-    case "string":
-    case "boolean":
-      return true;
-    case "number":
-      if (Number.isInteger(value)) return true;
-      throw new TypeError(`Invalid Lex value: ${value}`);
-    default:
-      throw new TypeError(`Invalid Lex value: ${typeof value}`);
-  }
-}
-
-export function isLexValue(value: unknown): value is LexValue {
-  switch (typeof value) {
-    case "number":
-      if (!Number.isInteger(value)) return false;
-    // fallthrough
-    case "string":
-    case "boolean":
-      return true;
-    case "object":
-      if (value === null) return true;
-      if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-          if (!isLexValue(value[i])) return false;
-        }
-        return true;
-      }
-      if (isPlainObject(value)) {
-        for (const key in value) {
-          if (!isLexValue(value[key])) return false;
-        }
-        return true;
-      }
-      if (value instanceof Uint8Array) return true;
-      if (isCid(value)) return true;
-    // fallthrough
-    default:
-      return false;
-  }
-}
-
-export type TypedLexMap = LexMap & { $type: string };
-export function isTypedLexMap(value: LexValue): value is TypedLexMap {
-  return (
-    isLexMap(value) && typeof value.$type === "string" && value.$type.length > 0
-  );
-}
-
-export function lexEquals(a: LexValue, b: LexValue): boolean {
-  if (Object.is(a, b)) {
-    return true;
-  }
-
-  if (
-    a == null ||
-    b == null ||
-    typeof a !== "object" ||
-    typeof b !== "object"
-  ) {
-    return false;
-  }
-
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
-    }
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!lexEquals(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  } else if (Array.isArray(b)) {
-    return false;
-  }
-
-  if (ArrayBuffer.isView(a)) {
-    if (!ArrayBuffer.isView(b)) return false;
-    return ui8Equals(a as Uint8Array, b as Uint8Array);
-  } else if (ArrayBuffer.isView(b)) {
-    return false;
-  }
-
-  if (isCid(a)) {
-    // @NOTE CID.equals returns its argument when it is falsy (e.g. null or
-    // undefined) so we need to explicitly check that the output is "true".
-    return CID.asCID(a)!.equals(CID.asCID(b)) === true;
-  } else if (isCid(b)) {
-    return false;
-  }
-
-  if (!isPlainObject(a) || !isPlainObject(b)) {
-    // Foolproof (should never happen)
-    throw new TypeError(
-      "Invalid LexValue (expected CID, Uint8Array, or LexMap)",
-    );
-  }
-
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-
-  if (aKeys.length !== bKeys.length) {
-    return false;
-  }
-
-  for (const key of aKeys) {
-    const aVal = a[key];
-    const bVal = b[key];
-
-    // Needed because of the optional index signature in the Lex object type
-    // though, in practice, aVal should never be undefined here.
-    if (aVal === undefined) {
-      if (bVal === undefined && bKeys.includes(key)) continue;
-      return false;
-    } else if (bVal === undefined) {
-      return false;
-    }
-
-    if (!lexEquals(aVal, bVal)) {
-      return false;
-    }
-  }
-
-  return true;
-}
diff --git a/data/mod.ts b/data/mod.ts
deleted file mode 100644
index 07b76b5..0000000
--- a/data/mod.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export * from "./blob.ts";
-export * from "./cid.ts";
-export * from "./language.ts";
-export * from "./lex.ts";
-export * from "./object.ts";
-export * from "./uint8array.ts";
-export * from "./utf8.ts";
diff --git a/data/object.ts b/data/object.ts
deleted file mode 100644
index 74cc9e2..0000000
--- a/data/object.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-export function isObject(input: unknown): input is object {
-  return input != null && typeof input === "object";
-}
-
-const ObjectProto = Object.prototype;
-const ObjectToString = Object.prototype.toString;
-
-export function isPlainObject(
-  input: unknown,
-): input is object & Record<string, unknown> {
-  if (!input || typeof input !== "object") return false;
-  const proto = Object.getPrototypeOf(input);
-  if (proto === null) return true;
-  return (
-    (proto === ObjectProto ||
-      // Needed to support NodeJS's `runInNewContext` which produces objects
-      // with a different prototype
-      Object.getPrototypeOf(proto) === null) &&
-    ObjectToString.call(input) === "[object Object]"
-  );
-}
diff --git a/data/tests/blob_test.ts b/data/tests/blob_test.ts
deleted file mode 100644
index 395746a..0000000
--- a/data/tests/blob_test.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-import { assert, assertEquals, assertFalse } from "@std/assert";
-import { isBlobRef, isLegacyBlobRef } from "../blob.ts";
-import { CID } from "../cid.ts";
-
-// await cidForRawBytes(Buffer.from('Hello, World!'))
-const blobCid = CID.parse(
-  "bafkreig77vqcdozl2wyk6z3cscaj5q5fggi53aoh64fewkdiri3cdauyn4",
-);
-// await cidForLex(Buffer.from('Hello, World!'))
-const lexCid = CID.parse(
-  "bafyreic52vzks7wdklat4evp3vimohl55i2unzqpshz2ytka5omzr7exdy",
-);
-
-Deno.test("isBlobRef tests valid blobCid and lexCid", () => {
-  assertEquals(blobCid.code, 0x55); // raw
-  assertEquals(blobCid.multihash.code, 0x12); // sha2-256
-  assertEquals(lexCid.code, 0x71); // dag-cbor
-  assertEquals(lexCid.multihash.code, 0x12); // sha2-256
-});
-
-Deno.test("isBlobRef parses valid blob", () => {
-  assert(
-    isBlobRef({
-      $type: "blob",
-      ref: blobCid,
-      mimeType: "image/jpeg",
-      size: 10000,
-    }),
-  );
-
-  assert(
-    isBlobRef(
-      {
-        $type: "blob",
-        ref: lexCid,
-        mimeType: "image/jpeg",
-        size: 10000,
-      },
-      // In non-strict mode, any CID should be accepted
-      { strict: false },
-    ),
-  );
-});
-
-Deno.test("isBlobRef rejects invalid inputs", () => {
-  assertFalse(
-    isBlobRef({
-      $type: "blob",
-      ref: { $link: blobCid.toString() },
-      mimeType: "image/jpeg",
-      size: "10000",
-    }),
-  );
-  assertFalse(
-    isBlobRef(
-      {
-        $type: "blob",
-        ref: { $link: blobCid.toString() },
-        mimeType: "image/jpeg",
-        size: "10000",
-      },
-      { strict: true },
-    ),
-  );
-
-  assertFalse(
-    isBlobRef({
-      $type: "blob",
-      mimeType: "image/jpeg",
-      size: 10000,
-    }),
-  );
-
-  assertFalse(
-    isBlobRef(
-      {
-        $type: "blob",
-        mimeType: "image/jpeg",
-        size: 10000,
-      },
-      { strict: true },
-    ),
-  );
-});
-
-Deno.test("isBlobRef rejects invalid CID/multihash code", () => {
-  assert(
-    isBlobRef(
-      {
-        $type: "blob",
-        ref: blobCid,
-        mimeType: "image/jpeg",
-        size: 10000,
-      },
-      { strict: true },
-    ),
-  );
-
-  assertFalse(
-    isBlobRef(
-      {
-        $type: "blob",
-        ref: lexCid,
-        mimeType: "image/jpeg",
-        size: 10000,
-      },
-      { strict: true },
-    ),
-  );
-});
-
-Deno.test("isBlobRef rejects extra keys", () => {
-  assertFalse(
-    isBlobRef({
-      $type: "blob",
-      ref: blobCid,
-      mimeType: "image/jpeg",
-      size: 10000,
-      extra: "not allowed",
-    }),
-  );
-
-  assertFalse(
-    isBlobRef(
-      {
-        $type: "blob",
-        ref: blobCid,
-        mimeType: "image/jpeg",
-        size: 10000,
-        extra: "not allowed",
-      },
-      { strict: true },
-    ),
-  );
-});
-
-Deno.test("isLegacyBlobRef parses valid legacy blob", () => {
-  assert(
-    isLegacyBlobRef({
-      cid: blobCid.toString(),
-      mimeType: "image/jpeg",
-    }),
-  );
-
-  assert(
-    isLegacyBlobRef({
-      cid: lexCid.toString(),
-      mimeType: "image/jpeg",
-    }),
-  );
-});
-
-Deno.test("isLegacyBlobRef rejects invalid inputs", () => {
-  assertFalse(
-    isLegacyBlobRef({
-      cid: "babbaaa",
-      mimeType: "image/jpeg",
-    }),
-  );
-
-  assertFalse(
-    isLegacyBlobRef({
-      cid: 12345,
-      mimeType: "image/jpeg",
-    }),
-  );
-
-  assertFalse(
-    isLegacyBlobRef({
-      mimeType: "image/jpeg",
-    }),
-  );
-});
-
-Deno.test("isLegacyBlobRef rejects extra keys", () => {
-  assertFalse(
-    isLegacyBlobRef({
-      cid: blobCid.toString(),
-      mimeType: "image/jpeg",
-      extra: "not allowed",
-    }),
-  );
-});
diff --git a/data/tests/language_test.ts b/data/tests/language_test.ts
deleted file mode 100644
index 8596744..0000000
--- a/data/tests/language_test.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { assert, assertEquals, assertFalse } from "@std/assert";
-import { isLanguage, parseLanguage } from "../language.ts";
-
-Deno.test("languages validates BCP 47", () => {
-  // valid
-  assert(isLanguage("de"));
-  assert(isLanguage("de-CH"));
-  assert(isLanguage("de-DE-1901"));
-  assert(isLanguage("es-419"));
-  assert(isLanguage("sl-IT-nedis"));
-  assert(isLanguage("mn-Cyrl-MN"));
-  assert(isLanguage("x-fr-CH"));
-  assert(isLanguage("en-GB-boont-r-extended-sequence-x-private"));
-  assert(isLanguage("sr-Cyrl"));
-  assert(isLanguage("hy-Latn-IT-arevela"));
-  assert(isLanguage("i-klingon"));
-  // invalid
-  assertFalse(isLanguage(""));
-  assertFalse(isLanguage("x"));
-  assertFalse(isLanguage("de-CH-"));
-  assertFalse(isLanguage("i-bad-grandfathered"));
-});
-
-Deno.test("languages parses BCP 47", () => {
-  // valid
-  assertEquals(parseLanguage("de"), {
-    language: "de",
-  });
-  assertEquals(parseLanguage("de-CH"), {
-    language: "de",
-    region: "CH",
-  });
-  assertEquals(parseLanguage("de-DE-1901"), {
-    language: "de",
-    region: "DE",
-    variant: "1901",
-  });
-  assertEquals(parseLanguage("es-419"), {
-    language: "es",
-    region: "419",
-  });
-  assertEquals(parseLanguage("sl-IT-nedis"), {
-    language: "sl",
-    region: "IT",
-    variant: "nedis",
-  });
-  assertEquals(parseLanguage("mn-Cyrl-MN"), {
-    language: "mn",
-    script: "Cyrl",
-    region: "MN",
-  });
-  assertEquals(parseLanguage("x-fr-CH"), {
-    privateUse: "x-fr-CH",
-  });
-  assertEquals(parseLanguage("en-GB-boont-r-extended-sequence-x-private"), {
-    language: "en",
-    region: "GB",
-    variant: "boont",
-    extension: "r-extended-sequence",
-    privateUse: "x-private",
-  });
-  assertEquals(parseLanguage("sr-Cyrl"), {
-    language: "sr",
-    script: "Cyrl",
-  });
-  assertEquals(parseLanguage("hy-Latn-IT-arevela"), {
-    language: "hy",
-    script: "Latn",
-    region: "IT",
-    variant: "arevela",
-  });
-  assertEquals(parseLanguage("i-klingon"), {
-    grandfathered: "i-klingon",
-  });
-  // invalid
-  assertEquals(parseLanguage(""), null);
-  assertEquals(parseLanguage("x"), null);
-  assertEquals(parseLanguage("de-CH-"), null);
-  assertEquals(parseLanguage("i-bad-grandfathered"), null);
-});
diff --git a/data/tests/lex-equals_test.ts b/data/tests/lex-equals_test.ts
deleted file mode 100644
index 5cd068e..0000000
--- a/data/tests/lex-equals_test.ts
+++ /dev/null
@@ -1,150 +0,0 @@
-import { assertEquals } from "@std/assert";
-import { CID } from "../cid.ts";
-import { lexEquals } from "../lex.ts";
-import type { LexValue } from "../lex.ts";
-import { assertThrows } from "@std/assert/throws";
-
-function expectLexEqual(a: LexValue, b: LexValue, expected: boolean) {
-  assertEquals(lexEquals(a, b), expected);
-  assertEquals(lexEquals(b, a), expected);
-}
-
-Deno.test("lexEquals compares primitive values", () => {
-  expectLexEqual(null, null, true);
-  expectLexEqual(true, true, true);
-  expectLexEqual(false, false, true);
-  expectLexEqual(42, 42, true);
-  expectLexEqual("hello", "hello", true);
-
-  expectLexEqual(null, false, false);
-  expectLexEqual(false, null, false);
-  expectLexEqual(true, false, false);
-  expectLexEqual(false, true, false);
-  expectLexEqual(42, 43, false);
-  expectLexEqual("hello", "world", false);
-});
-
-Deno.test("lexEquals compares NaN and Infinity correctly", () => {
-  expectLexEqual(NaN, NaN, true);
-  expectLexEqual(Infinity, Infinity, true);
-  expectLexEqual(-Infinity, -Infinity, true);
-
-  expectLexEqual(NaN, 0, false);
-  expectLexEqual(NaN, null, false);
-  expectLexEqual(Infinity, -Infinity, false);
-});
-
-Deno.test("lexEquals compares arrays", () => {
-  expectLexEqual([1, 2, 3], [1, 2, 3], true);
-  expectLexEqual([1, 2, 3], [1, 2, 4], false);
-  expectLexEqual([1, 2, 3], [1, 2], false);
-  expectLexEqual([1, 2, 3], "not an array", false);
-});
-
-Deno.test("lexEquals compares Uint8Arrays", () => {
-  expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]), true);
-  expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]), false);
-  expectLexEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2]), false);
-  expectLexEqual(new Uint8Array([1, 2, 3]), "not a Uint8Array", false);
-});
-
-Deno.test("lexEquals compares CIDs", () => {
-  const cid1 = CID.parse(
-    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-  );
-  const cid2 = CID.parse(cid1.toString());
-  const cid3 = CID.parse(cid1.toString());
-
-  expectLexEqual(cid1, cid2, true);
-  expectLexEqual(cid1, cid3, true);
-  expectLexEqual(cid2, cid3, true);
-
-  expectLexEqual(cid1, cid1.toString(), false);
-});
-
-Deno.test("lexEquals compares objects", () => {
-  expectLexEqual({ a: 1, b: 2 }, { a: 1, b: 2 }, true);
-  expectLexEqual(
-    { a: 1, b: { unicode: "a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧" } },
-    { a: 1, b: { unicode: "a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧" } },
-    true,
-  );
-
-  expectLexEqual({ a: 1, b: 2 }, { a: 1, b: 3 }, false);
-  expectLexEqual({ a: 1, b: 2 }, { a: 1 }, false);
-  expectLexEqual({ a: 1, b: 2 }, "not an object", false);
-  expectLexEqual({ a: 1, b: 2 }, null, false);
-});
-
-Deno.test("lexEquals compares nested structures", () => {
-  const lex1 = {
-    foo: [1, 2, { bar: new Uint8Array([3, 4, 5]) }],
-    baz: CID.parse(
-      "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-    ),
-  };
-  const lex2 = {
-    foo: [1, 2, { bar: new Uint8Array([3, 4, 5]) }],
-    baz: CID.parse(
-      "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-    ),
-  };
-  const lex3 = {
-    foo: [1, 2, { bar: new Uint8Array([3, 4, 5 + 1]) }],
-    baz: CID.parse(
-      "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-    ),
-  };
-
-  expectLexEqual(lex1, lex2, true);
-  expectLexEqual(lex1, lex3, false);
-  expectLexEqual(lex2, lex3, false);
-});
-
-Deno.test("lexEquals allows comparing invalid numbers (floats, NaN, Infinity)", () => {
-  expectLexEqual(3.14, 2.71, false);
-  expectLexEqual(NaN, 0, false);
-  expectLexEqual(Infinity, -Infinity, false);
-});
-
-for (const value of [3.14, NaN, Infinity, -Infinity]) {
-  Deno.test(`reference equality returns true for identical references of ${String(value)}`, () => {
-    expectLexEqual(value, value, true);
-    expectLexEqual([value], [value], true);
-    expectLexEqual({ foo: value }, { foo: value }, true);
-    expectLexEqual([{ foo: value }], [{ foo: value }], true);
-  });
-}
-
-Deno.test("lexEquals returns true for identical references", () => {
-  const arr = [1, 2, 3];
-  expectLexEqual(arr, arr, true);
-
-  const obj = { a: 1, b: 2 };
-  expectLexEqual(obj, obj, true);
-
-  const u8 = new Uint8Array([1, 2, 3]);
-  expectLexEqual(u8, u8, true);
-
-  const cid = CID.parse(
-    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-  );
-  expectLexEqual(cid, cid, true);
-});
-
-Deno.test("throws when comparing plain object with non-allowed class instance", () => {
-  // @ts-expect-error should throw
-  assertThrows(() => lexEquals({}, new Map()));
-  // @ts-expect-error should throw
-  assertThrows(() => lexEquals(new Map(), {}));
-  // @ts-expect-error should throw
-  assertThrows(() => lexEquals({ foo: {} }, { foo: new Map() }));
-  // @ts-expect-error should throw
-  assertThrows(() => lexEquals({ foo: new Map() }, { foo: {} }));
-
-  assertThrows(() => lexEquals({ foo: {} }, { foo: new (class {})() }));
-
-  assertThrows(() => lexEquals({ foo: new (class {})() }, { foo: {} }));
-
-  assertThrows(() => lexEquals({ foo: {} }, { foo: new (class Object {})() }));
-});
diff --git a/data/tests/lex_test.ts b/data/tests/lex_test.ts
deleted file mode 100644
index 1a28d1a..0000000
--- a/data/tests/lex_test.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { assert } from "@std/assert";
-import { isTypedLexMap } from "../lex.ts";
-import { assertFalse } from "@std/assert/false";
-
-Deno.test("isLexMap returns true for valid LexMap", () => {
-  const record = {
-    a: 123,
-    b: "blah",
-    c: true,
-    d: null,
-    e: new Uint8Array([1, 2, 3]),
-    f: {
-      nested: "value",
-    },
-    g: [1, 2, 3],
-  };
-  assertFalse(isTypedLexMap(record));
-});
-
-Deno.test("isLexMap returns false for non-records", () => {
-  const values = [
-    123,
-    "blah",
-    true,
-    null,
-    new Uint8Array([1, 2, 3]),
-    [1, 2, 3],
-  ];
-  for (const value of values) {
-    assertFalse(isTypedLexMap(value));
-  }
-});
-
-Deno.test("isLexMap returns false for records with non-Lex values", () => {
-  assertFalse(
-    // @ts-expect-error value passed is not a LexMap
-    isTypedLexMap({
-      a: 123,
-      b: () => {},
-    }),
-  );
-  assertFalse(
-    isTypedLexMap({
-      a: 123,
-      b: undefined,
-    }),
-  );
-});
-
-Deno.test("isTypedLexMap valid records", () => {
-  for (
-    const { json } of [
-      {
-        note: "trivial record",
-        json: {
-          $type: "com.example.blah",
-          a: 123,
-          b: "blah",
-        },
-      },
-      {
-        note: "float, but integer-like",
-        json: {
-          $type: "com.example.blah",
-          a: 123.0,
-          b: "blah",
-        },
-      },
-      {
-        note: "empty list and object",
-        json: {
-          $type: "com.example.blah",
-          a: [],
-          b: {},
-        },
-      },
-    ]
-  ) {
-    assert(isTypedLexMap(json));
-  }
-});
-
-Deno.test("isTypedLexMap invalid records", () => {
-  for (
-    const { json } of [
-      {
-        note: "float",
-        json: {
-          $type: "com.example.blah",
-          a: 123.456,
-          b: "blah",
-        },
-      },
-      {
-        note: "record with $type null",
-        json: {
-          $type: null,
-          a: 123,
-          b: "blah",
-        },
-      },
-      {
-        note: "record with $type wrong type",
-        json: {
-          $type: 123,
-          a: 123,
-          b: "blah",
-        },
-      },
-      {
-        note: "record with empty $type string",
-        json: {
-          $type: "",
-          a: 123,
-          b: "blah",
-        },
-      },
-    ]
-  ) {
-    assertFalse(isTypedLexMap(json));
-  }
-});
diff --git a/data/tests/object_test.ts b/data/tests/object_test.ts
deleted file mode 100644
index 70acb19..0000000
--- a/data/tests/object_test.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { assert, assertFalse } from "@std/assert";
-import { CID } from "../cid.ts";
-import { isObject, isPlainObject } from "../object.ts";
-
-Deno.test("isObject returns true for plain objects", () => {
-  assert(isObject({}));
-  assert(isObject({ a: 1 }));
-});
-
-Deno.test("isObject returns true for CIDs", () => {
-  const cid = CID.parse(
-    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-  );
-  assert(isObject(cid));
-});
-
-Deno.test("isObject returns true for class instances", () => {
-  class MyClass {}
-  assert(isObject(new MyClass()));
-});
-
-Deno.test("isObject returns true for arrays", () => {
-  assert(isObject([]));
-  assert(isObject([1, 2, 3]));
-});
-
-Deno.test("isObject returns false for null", () => {
-  assertFalse(isObject(null));
-});
-
-Deno.test("isObject returns false for non-objects", () => {
-  assertFalse(isObject(42));
-  assertFalse(isObject("string"));
-  assertFalse(isObject(undefined));
-  assertFalse(isObject(true));
-});
-
-Deno.test("isPlainObject returns true for plain objects", () => {
-  assert(isPlainObject({}));
-  assert(isPlainObject({ a: 1 }));
-});
-
-Deno.test("isPlainObject returns true for objects with null prototype", () => {
-  const obj = Object.create(null);
-  obj.a = 1;
-  assert(isPlainObject(obj));
-  assert(isPlainObject({ __proto__: null, foo: "bar" }));
-});
-
-Deno.test("isPlainObject returns false for class instances", () => {
-  class MyClass {}
-  assertFalse(isPlainObject(new MyClass()));
-});
-
-Deno.test("isPlainObject returns false for CIDs", () => {
-  const cid = CID.parse(
-    "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
-  );
-  assertFalse(isPlainObject(cid));
-});
-
-Deno.test("isPlainObject returns false for arrays", () => {
-  assertFalse(isPlainObject([]));
-  assertFalse(isPlainObject([1, 2, 3]));
-});
-
-Deno.test("isPlainObject returns false for null", () => {
-  assertFalse(isPlainObject(null));
-});
-
-Deno.test("isPlainObject returns false for non-objects", () => {
-  assertFalse(isPlainObject(42));
-  assertFalse(isPlainObject("string"));
-  assertFalse(isPlainObject(undefined));
-  assertFalse(isPlainObject(true));
-});
diff --git a/data/tests/utf8_test.ts b/data/tests/utf8_test.ts
deleted file mode 100644
index a6af98c..0000000
--- a/data/tests/utf8_test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { utf8Len } from "@atp/data";
-import { graphemeLen } from "../utf8.ts";
-import { assertEquals } from "@std/assert";
-
-Deno.test("graphemeLen computes grapheme length", () => {
-  assertEquals(graphemeLen("a"), 1);
-  assertEquals(graphemeLen("~"), 1);
-  assertEquals(graphemeLen("ö"), 1);
-  assertEquals(graphemeLen("ñ"), 1);
-  assertEquals(graphemeLen("©"), 1);
-  assertEquals(graphemeLen("⽘"), 1);
-  assertEquals(graphemeLen("☎"), 1);
-  assertEquals(graphemeLen("𓋓"), 1);
-  assertEquals(graphemeLen("😀"), 1);
-  assertEquals(graphemeLen("👨‍👩‍👧‍👧"), 1);
-  assertEquals(graphemeLen("a~öñ©⽘☎𓋓😀👨‍👩‍👧‍👧"), 10);
-  // https://github.com/bluesky-social/atproto/issues/4321
-  assertEquals(graphemeLen("नमस्ते"), 3);
-});
-
-Deno.test("utf8Len computes utf8 string length", () => {
-  assertEquals(utf8Len("a"), 1);
-  assertEquals(utf8Len("~"), 1);
-  assertEquals(utf8Len("ö"), 2);
-  assertEquals(utf8Len("ñ"), 2);
-  assertEquals(utf8Len("©"), 2);
-  assertEquals(utf8Len("⽘"), 3);
-  assertEquals(utf8Len("☎"), 3);
-  assertEquals(utf8Len("𓋓"), 4);
-  assertEquals(utf8Len("😀"), 4);
-  assertEquals(utf8Len("👨‍👩‍👧‍👧"), 25);
-});
diff --git a/data/uint8array.ts b/data/uint8array.ts
deleted file mode 100644
index b21b442..0000000
--- a/data/uint8array.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Coerces various binary data representations into a Uint8Array.
- *
- * @return `undefined` if the input could not be coerced into a {@link Uint8Array}.
- */
-export function asUint8Array(input: unknown): Uint8Array | undefined {
-  if (input instanceof Uint8Array) {
-    return input;
-  }
-
-  if (ArrayBuffer.isView(input)) {
-    return new Uint8Array(
-      input.buffer,
-      input.byteOffset,
-      input.byteLength / Uint8Array.BYTES_PER_ELEMENT,
-    );
-  }
-
-  if (input instanceof ArrayBuffer) {
-    return new Uint8Array(input);
-  }
-
-  return undefined;
-}
-
-export function ui8Equals(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.byteLength !== b.byteLength) {
-    return false;
-  }
-
-  for (let i = 0; i < a.byteLength; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
diff --git a/data/utf8.ts b/data/utf8.ts
deleted file mode 100644
index aa180b7..0000000
--- a/data/utf8.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-const segmenter = new Intl.Segmenter();
-
-export function graphemeLen(str: string): number {
-  let length = 0;
-  for (const _ of segmenter.segment(str)) length++;
-  return length;
-}
-
-export function utf8Len(string: string): number {
-  // similar to TextEncoder's implementation of UTF-8 encoding.
-  // However, using TextEncoder to get the byte length is slower
-  // as it requires allocating a new Uint8Array and copying data:
-
-  // return new TextEncoder().encode(string).byteLength
-
-  // The base length is the string length (all ASCII)
-  let len = string.length;
-  let code: number;
-
-  // The loop calculates the number of additional bytes needed for
-  // non-ASCII characters
-  for (let i = 0; i < string.length; i += 1) {
-    code = string.charCodeAt(i);
-
-    if (code <= 0x7f) {
-      // ASCII, 1 byte
-    } else if (code <= 0x7ff) {
-      // 2 bytes char
-      len += 1;
-    } else {
-      // 3 bytes char
-      len += 2;
-      // If the current char is a high surrogate, and the next char is a low
-      // surrogate, skip the next char as the total is a 4 bytes char
-      // (represented as a surrogate pair in UTF-16) and was already accounted
-      // for.
-      if (code >= 0xd800 && code <= 0xdbff) {
-        code = string.charCodeAt(i + 1);
-        if (code >= 0xdc00 && code <= 0xdfff) {
-          i++;
-        }
-      }
-    }
-  }
-  return len;
-}
diff --git a/deno.lock b/deno.lock
index 4b43184..85bb414 100644
--- a/deno.lock
+++ b/deno.lock
@@ -1,6 +1,13 @@
 {
   "version": "5",
   "specifiers": {
+    "jsr:@cliffy/ansi@^1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@cliffy/command@^1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@cliffy/flags@1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@cliffy/internal@1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@cliffy/table@1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@david/code-block-writer@13": "13.0.3",
+    "jsr:@hono/hono@*": "4.9.9",
     "jsr:@hono/hono@^4.9.8": "4.9.9",
     "jsr:@logtape/file@^1.2.0-dev.344+834f24a9": "1.2.0-dev.344+834f24a9",
     "jsr:@logtape/logtape@^1.2.0-dev.344+834f24a9": "1.2.0-dev.344+834f24a9",
@@ -11,11 +18,19 @@
     "jsr:@std/bytes@^1.0.5": "1.0.6",
     "jsr:@std/cbor@~0.1.8": "0.1.8",
     "jsr:@std/encoding@^1.0.10": "1.0.10",
+    "jsr:@std/fmt@~1.0.2": "1.0.8",
+    "jsr:@std/fs@1": "1.0.20",
     "jsr:@std/fs@^1.0.19": "1.0.20",
     "jsr:@std/internal@^1.0.12": "1.0.12",
     "jsr:@std/json@^1.0.2": "1.0.2",
     "jsr:@std/jsonc@^1.0.1": "1.0.2",
+    "jsr:@std/path@1": "1.1.3",
+    "jsr:@std/path@^1.1.2": "1.1.3",
+    "jsr:@std/path@^1.1.3": "1.1.3",
     "jsr:@std/streams@^1.0.9": "1.0.13",
+    "jsr:@std/text@~1.0.7": "1.0.16",
+    "jsr:@ts-morph/common@0.27": "0.27.0",
+    "jsr:@ts-morph/ts-morph@26": "26.0.0",
     "jsr:@zod/zod@^4.1.11": "4.1.11",
     "npm:@atproto/crypto@*": "0.4.4",
     "npm:@did-plc/lib@^0.0.4": "0.0.4",
@@ -31,6 +46,40 @@
     "npm:zod@^4.1.11": "4.1.11"
   },
   "jsr": {
+    "@cliffy/ansi@1.0.0-rc.8": {
+      "integrity": "ba37f10ce55bbfbdd8ddd987f91f029b17bce88385b98ba3058870f3b007b80c",
+      "dependencies": [
+        "jsr:@std/fmt"
+      ]
+    },
+    "@cliffy/command@1.0.0-rc.8": {
+      "integrity": "758147790797c74a707e5294cc7285df665422a13d2a483437092ffce40b5557",
+      "dependencies": [
+        "jsr:@cliffy/flags",
+        "jsr:@cliffy/internal",
+        "jsr:@cliffy/table",
+        "jsr:@std/fmt",
+        "jsr:@std/text"
+      ]
+    },
+    "@cliffy/flags@1.0.0-rc.8": {
+      "integrity": "0f1043ce6ef037ba1cb5fe6b1bcecb25dc2f29371a1c17f278ab0f45e4b6f46c",
+      "dependencies": [
+        "jsr:@std/text"
+      ]
+    },
+    "@cliffy/internal@1.0.0-rc.8": {
+      "integrity": "34cdf2fad9b084b5aed493b138d573f52d4e988767215f7460daf0b918ff43d8"
+    },
+    "@cliffy/table@1.0.0-rc.8": {
+      "integrity": "8bbcdc2ba5e0061b4b13810a24e6f5c6ab19c09f0cce9eb691ccd76c7c6c9db5",
+      "dependencies": [
+        "jsr:@std/fmt"
+      ]
+    },
+    "@david/code-block-writer@13.0.3": {
+      "integrity": "f98c77d320f5957899a61bfb7a9bead7c6d83ad1515daee92dbacc861e13bb7f"
+    },
     "@hono/hono@4.9.8": {
       "integrity": "908150f13e90181a051a3af3bf15203aff00190682afedfd38824d0cb9299a95"
     },
@@ -74,8 +123,15 @@
     "@std/encoding@1.0.10": {
       "integrity": "8783c6384a2d13abd5e9e87a7ae0520a30e9f56aeeaa3bdf910a3eaaf5c811a1"
     },
+    "@std/fmt@1.0.8": {
+      "integrity": "71e1fc498787e4434d213647a6e43e794af4fd393ef8f52062246e06f7e372b7"
+    },
     "@std/fs@1.0.20": {
-      "integrity": "e953206aae48d46ee65e8783ded459f23bec7dd1f3879512911c35e5484ea187"
+      "integrity": "e953206aae48d46ee65e8783ded459f23bec7dd1f3879512911c35e5484ea187",
+      "dependencies": [
+        "jsr:@std/internal",
+        "jsr:@std/path@^1.1.3"
+      ]
     },
     "@std/internal@1.0.12": {
       "integrity": "972a634fd5bc34b242024402972cd5143eac68d8dffaca5eaa4dba30ce17b027"
@@ -89,12 +145,35 @@
         "jsr:@std/json"
       ]
     },
+    "@std/path@1.1.3": {
+      "integrity": "b015962d82a5e6daea980c32b82d2c40142149639968549c649031a230b1afb3",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
     "@std/streams@1.0.10": {
       "integrity": "75c0b1431873cd0d8b3d679015220204d36d3c7420d93b60acfc379eb0dc30af"
     },
     "@std/streams@1.0.13": {
       "integrity": "772d208cd0d3e5dac7c1d9e6cdb25842846d136eea4a41a62e44ed4ab0c8dd9e"
     },
+    "@std/text@1.0.16": {
+      "integrity": "ddb9853b75119a2473857d691cf1ec02ad90793a2e8b4a4ac49d7354281a0cf8"
+    },
+    "@ts-morph/common@0.27.0": {
+      "integrity": "c7b73592d78ce8479b356fd4f3d6ec3c460d77753a8680ff196effea7a939052",
+      "dependencies": [
+        "jsr:@std/fs@1",
+        "jsr:@std/path@1"
+      ]
+    },
+    "@ts-morph/ts-morph@26.0.0": {
+      "integrity": "f2b1ca67b4d1a6332d00c00dd48496b20879c899a702c1b92bcce1c552a168df",
+      "dependencies": [
+        "jsr:@david/code-block-writer",
+        "jsr:@ts-morph/common"
+      ]
+    },
     "@zod/zod@4.1.5": {
       "integrity": "e995ca7d588a835ce333de626c940e242c55b6763c5190e8cbb9fefb7d0fb4ef"
     },
diff --git a/lex-gen/cmd/gen-api.ts b/lex-gen/cmd/gen-api.ts
index f4b3e2a..7fed63b 100644
--- a/lex-gen/cmd/gen-api.ts
+++ b/lex-gen/cmd/gen-api.ts
@@ -4,6 +4,7 @@ import {
   genFileDiff,
   printFileDiff,
   readAllLexicons,
+  shouldPullLexicons,
 } from "../util.ts";
 import { genClientApi } from "../codegen/client.ts";
 import { formatGeneratedFiles } from "../codegen/util.ts";
@@ -43,7 +44,13 @@ const command = new Command()
         }
       }
 
-      if (config?.pull) {
+      const filesProvidedViaCli = input !== undefined;
+      const needsPull = shouldPullLexicons(
+        config,
+        filesProvidedViaCli,
+        finalInput,
+      );
+      if (needsPull && config?.pull) {
         await pullLexicons(config.pull);
       }
 
@@ -65,7 +72,7 @@ const command = new Command()
       }
       console.log("API generated.");
 
-      if (config?.pull) {
+      if (needsPull && config?.pull) {
         cleanupPullDirectory(config.pull);
       }
     },
diff --git a/lex-gen/cmd/gen-md.ts b/lex-gen/cmd/gen-md.ts
index d4820eb..c67a6c9 100644
--- a/lex-gen/cmd/gen-md.ts
+++ b/lex-gen/cmd/gen-md.ts
@@ -1,5 +1,5 @@
 import { Command } from "@cliffy/command";
-import { readAllLexicons } from "../util.ts";
+import { readAllLexicons, shouldPullLexicons } from "../util.ts";
 import * as mdGen from "../mdgen/index.ts";
 import { loadLexiconConfig } from "../config.ts";
 import { cleanupPullDirectory, pullLexicons } from "../pull.ts";
@@ -50,14 +50,20 @@ const command = new Command()
         }
       }
 
-      if (config?.pull) {
+      const filesProvidedViaCli = input !== undefined;
+      const needsPull = shouldPullLexicons(
+        config,
+        filesProvidedViaCli,
+        [finalInput],
+      );
+      if (needsPull && config?.pull) {
         await pullLexicons(config.pull);
       }
 
       const lexicons = readAllLexicons(finalInput);
       await mdGen.process(finalOutput, lexicons);
 
-      if (config?.pull) {
+      if (needsPull && config?.pull) {
         cleanupPullDirectory(config.pull);
       }
     },
diff --git a/lex-gen/cmd/gen-server.ts b/lex-gen/cmd/gen-server.ts
index 7ead8c0..21e8114 100644
--- a/lex-gen/cmd/gen-server.ts
+++ b/lex-gen/cmd/gen-server.ts
@@ -4,6 +4,7 @@ import {
   genFileDiff,
   printFileDiff,
   readAllLexicons,
+  shouldPullLexicons,
 } from "../util.ts";
 import { formatGeneratedFiles } from "../codegen/util.ts";
 import { genServerApi } from "../codegen/server.ts";
@@ -45,7 +46,13 @@ const command = new Command()
         }
       }
 
-      if (config?.pull) {
+      const filesProvidedViaCli = input !== undefined;
+      const needsPull = shouldPullLexicons(
+        config,
+        filesProvidedViaCli,
+        finalInput,
+      );
+      if (needsPull && config?.pull) {
         await pullLexicons(config.pull);
       }
 
@@ -69,7 +76,7 @@ const command = new Command()
       }
       console.log("API generated.");
 
-      if (config?.pull) {
+      if (needsPull && config?.pull) {
         cleanupPullDirectory(config.pull);
       }
     },
diff --git a/lex-gen/cmd/gen-ts-obj.ts b/lex-gen/cmd/gen-ts-obj.ts
index 2c4159d..a5a90c9 100644
--- a/lex-gen/cmd/gen-ts-obj.ts
+++ b/lex-gen/cmd/gen-ts-obj.ts
@@ -1,5 +1,9 @@
 import { Command } from "@cliffy/command";
-import { genTsObj, readAllLexicons } from "../util.ts";
+import {
+  genTsObj,
+  readAllLexicons,
+  shouldPullLexicons,
+} from "../util.ts";
 import { loadLexiconConfig } from "../config.ts";
 import { cleanupPullDirectory, pullLexicons } from "../pull.ts";
 import process from "node:process";
@@ -25,14 +29,23 @@ const command = new Command()
       }
     }
 
-    if (config?.pull) {
+    const filesProvidedViaCli = input !== undefined;
+    const finalInputArray = Array.isArray(finalInput)
+      ? finalInput
+      : [finalInput];
+    const needsPull = shouldPullLexicons(
+      config,
+      filesProvidedViaCli,
+      finalInputArray,
+    );
+    if (needsPull && config?.pull) {
       await pullLexicons(config.pull);
     }
 
     const lexicons = readAllLexicons(finalInput);
     console.log(genTsObj(lexicons));
 
-    if (config?.pull) {
+    if (needsPull && config?.pull) {
       cleanupPullDirectory(config.pull);
     }
   });
diff --git a/lex-gen/util.ts b/lex-gen/util.ts
index ba988b8..0d6e90c 100644
--- a/lex-gen/util.ts
+++ b/lex-gen/util.ts
@@ -9,7 +9,7 @@ import { readDirSync } from "@std/fs/unstable-read-dir";
 import { colors } from "@cliffy/ansi/colors";
 import { ZodError } from "zod";
 import { type LexiconDoc, parseLexiconDoc } from "@atp/lexicon";
-import type { FileDiff, GeneratedAPI } from "./types.ts";
+import type { FileDiff, GeneratedAPI, LexiconConfig } from "./types.ts";
 import process from "node:process";
 
 type RecursiveZodError = {
@@ -23,7 +23,7 @@ export function expandGlobPatterns(patterns: string[]): string[] {
 
   function walkDir(
     dir: string,
-    relativePath: string,
+    relativeToCwd: string,
     regex: RegExp,
     files: string[],
   ): void {
@@ -32,14 +32,14 @@ export function expandGlobPatterns(patterns: string[]): string[] {
       const entries = Array.from(readDirSync(dir));
       for (const entry of entries) {
         const fullPath = join(dir, entry.name);
-        const relPath = relativePath
-          ? join(relativePath, entry.name)
+        const relToCwd = relativeToCwd
+          ? join(relativeToCwd, entry.name)
           : entry.name;
         if (statSync(fullPath).isDirectory) {
-          walkDir(fullPath, relPath, regex, files);
+          walkDir(fullPath, relToCwd, regex, files);
         } else if (entry.name.endsWith(".json")) {
-          const testPath = relPath.startsWith("/") ? relPath : `/${relPath}`;
-          if (regex.test(testPath) || regex.test(relPath)) {
+          const testPath = relToCwd.startsWith("/") ? relToCwd : `/${relToCwd}`;
+          if (regex.test(testPath) || regex.test(relToCwd)) {
             files.push(fullPath);
           }
         }
@@ -59,14 +59,18 @@ export function expandGlobPatterns(patterns: string[]): string[] {
     });
     const basePath = normalizedPattern.split("*")[0] ||
       normalizedPattern.split("?")[0] || "";
-    const searchDir = basePath.includes("/")
-      ? join(
-        cwd,
-        basePath.substring(0, basePath.lastIndexOf("/") || basePath.length),
-      )
-      : cwd;
+    let searchDir = cwd;
+    let relativeToCwd = "";
+    if (basePath.includes("/")) {
+      const lastSlashIndex = basePath.lastIndexOf("/");
+      if (lastSlashIndex >= 0) {
+        const baseDir = basePath.substring(0, lastSlashIndex);
+        searchDir = join(cwd, baseDir);
+        relativeToCwd = baseDir;
+      }
+    }
 
-    walkDir(searchDir, "", regex, files);
+    walkDir(searchDir, relativeToCwd, regex, files);
   }
 
   return Array.from(new Set(files));
@@ -236,3 +240,51 @@ function readdirRecursiveSync(root: string, files: string[] = [], prefix = "") {
 function dedup(arr: string[]): string[] {
   return Array.from(new Set(arr));
 }
+
+export function shouldPullLexicons(
+  config: LexiconConfig | null,
+  filesProvidedViaCli: boolean,
+  files: string[],
+): boolean {
+  if (!config?.pull) {
+    return false;
+  }
+
+  if (filesProvidedViaCli) {
+    return false;
+  }
+
+  const cwd = typeof Deno !== "undefined" ? Deno.cwd() : process.cwd();
+
+  for (const filePattern of files) {
+    const normalizedPattern = filePattern.startsWith("./")
+      ? filePattern.slice(2)
+      : filePattern;
+    const filePath = normalizedPattern.startsWith("/")
+      ? normalizedPattern
+      : join(cwd, normalizedPattern);
+
+    if (filePattern.includes("*") || filePattern.includes("?")) {
+      const expanded = expandGlobPatterns([filePattern]);
+      if (expanded.length === 0) {
+        return true;
+      }
+      let allExist = true;
+      for (const file of expanded) {
+        if (!existsSync(file)) {
+          allExist = false;
+          break;
+        }
+      }
+      if (!allExist) {
+        return true;
+      }
+    } else {
+      if (!existsSync(filePath)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
diff --git a/lex/deno.json b/lex/deno.json
deleted file mode 100644
index fecf9f1..0000000
--- a/lex/deno.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "name": "@atp/lex",
-  "version": "0.1.0-alpha.1",
-  "exports": "./mod.ts",
-  "license": "MIT",
-  "imports": {
-    "multiformats": "npm:multiformats@^13.4.1"
-  }
-}
diff --git a/lex/schema/core.ts b/lex/schema/core.ts
deleted file mode 100644
index c4690a9..0000000
--- a/lex/schema/core.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export * from "./core/$type.ts";
-export * from "./core/record-key.ts";
-export * from "./core/result.ts";
-export * from "./core/string-format.ts";
-export * from "./core/types.ts";
diff --git a/lex/schema/core/$type.ts b/lex/schema/core/$type.ts
deleted file mode 100644
index fc283ff..0000000
--- a/lex/schema/core/$type.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import type { Nsid } from "./string-format.ts";
-
-export type $Type<
-  N extends Nsid = Nsid,
-  H extends string = string,
-> = N extends Nsid ? string extends H ? N | `${N}#${string}`
-  : H extends "main" ? N
-  : `${N}#${H}`
-  : never;
-
-export function $type<N extends Nsid, H extends string>(
-  nsid: N,
-  hash: H,
-): $Type<N, H> {
-  return (hash === "main" ? nsid : `${nsid}#${hash}`) as $Type<N, H>;
-}
diff --git a/lex/schema/core/record-key.ts b/lex/schema/core/record-key.ts
deleted file mode 100644
index 89b448b..0000000
--- a/lex/schema/core/record-key.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-export type RecordKey = "any" | "nsid" | "tid" | `literal:${string}`;
-
-export function isRecordKey<T>(key: T): key is T & RecordKey {
-  return (
-    key === "any" ||
-    key === "nsid" ||
-    key === "tid" ||
-    (typeof key === "string" && key.startsWith("literal:"))
-  );
-}
-
-export function asRecordKey(key: unknown): RecordKey {
-  if (isRecordKey(key)) return key;
-  throw new Error(`Invalid record key: ${String(key)}`);
-}
diff --git a/lex/schema/core/result.ts b/lex/schema/core/result.ts
deleted file mode 100644
index 9bcf70e..0000000
--- a/lex/schema/core/result.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-export type ResultSuccess<V = unknown> = { success: true; value: V };
-export type ResultFailure<E = Error> = { success: false; error: E };
-
-export type Result<V = unknown, E = Error> =
-  | ResultSuccess<V>
-  | ResultFailure<E>;
-
-export function success<V>(value: V): ResultSuccess<V> {
-  return { success: true, value };
-}
-
-export function failure<E>(error: E): ResultFailure<E> {
-  return { success: false, error };
-}
-
-export function failureError<T>(result: ResultFailure<T>): T {
-  return result.error;
-}
-
-export function successValue<T>(result: ResultSuccess<T>): T {
-  return result.value;
-}
-
-/**
- * Catches any error and wraps it in a {@link ResultFailure<Error>}.
- *
- * @param err - The error to catch.
- * @returns A {@link ResultFailure<Error>} containing the caught error.
- * @example
- *
- * ```ts
- * declare function someFunction(): Promise<ResultSuccess<string>>
- *
- * const result = await someFunction().catch(catchall)
- * if (result.success) {
- *   console.log(result.value) // string
- * } else {
- *   console.error(result.error instanceof Error) // true
- *   console.error(result.error.message) // string
- * }
- * ```
- */
-export function catchall(err: unknown): ResultFailure<Error> {
-  if (err instanceof Error) return failure(err);
-  return failure(new Error("Unknown error", { cause: err }));
-}
-
-/**
- * Creates a catcher function for the given constructor that wraps caught errors
- * in a {@link ResultFailure}.
- *
- * @example
- *
- * ```ts
- * class FooError extends Error {}
- * class BarError extends Error {}
- *
- * declare function someFunction(): Promise<ResultSuccess<string>>
- *
- * const result = await someFunction()
- *   .catch(createCatcher(FooError))
- *   .catch(createCatcher(BarError))
- *
- * if (result.success) {
- *   console.log(result.value) // string
- * } else {
- *   console.error(result.error) // FooError | BarError
- * }
- */
-export function createCatcher<T>(Ctor: new (...args: unknown[]) => T) {
-  return (err: unknown): ResultFailure<T> => {
-    if (err instanceof Ctor) return failure(err);
-    throw err;
-  };
-}
diff --git a/lex/schema/core/string-format.ts b/lex/schema/core/string-format.ts
deleted file mode 100644
index 6592b78..0000000
--- a/lex/schema/core/string-format.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-import { ensureValidCidString, isLanguage } from "@atp/data";
-import {
-  ensureValidAtUri,
-  ensureValidDatetime,
-  ensureValidDid,
-  ensureValidHandle,
-  ensureValidNsid,
-  ensureValidRecordKey,
-  ensureValidTid,
-} from "@atp/syntax";
-
-// Allow (date as Date).toISOString() to be used where datetime format is expected
-declare global {
-  interface Date {
-    toISOString(): `${string}T${string}Z`;
-  }
-}
-
-export const STRING_FORMATS = Object.freeze(
-  [
-    "datetime",
-    "uri",
-    "at-uri",
-    "did",
-    "handle",
-    "at-identifier",
-    "nsid",
-    "cid",
-    "language",
-    "tid",
-    "record-key",
-  ] as const,
-);
-
-export type StringFormat = (typeof STRING_FORMATS)[number];
-
-export type Did<M extends string = string> = `did:${M}:${string}`;
-export type Uri = `${string}:${string}`;
-export type Nsid = `${string}.${string}.${string}`;
-/** An ISO 8601 formatted datetime string (YYYY-MM-DDTHH:mm:ss.sssZ) */
-export type Datetime = `${string}T${string}`;
-export type Handle = `${string}.${string}`;
-export type AtIdentifier = Did | Handle;
-export type AtUri = `at://${AtIdentifier}/${Nsid}/${string}`;
-
-export type InferStringFormat<F> =
-  //
-  F extends "datetime" ? Datetime
-    : F extends "uri" ? Uri
-    : F extends "at-uri" ? AtUri
-    : F extends "did" ? Did
-    : F extends "handle" ? Handle
-    : F extends "at-identifier" ? AtIdentifier
-    : F extends "nsid" ? Nsid
-    : string;
-
-type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T;
-
-// Re-export utility typed as assertion functions so that TypeScript can
-// infer the narrowed type after calling them.
-
-export const assertDid: AssertFn<Did> = ensureValidDid;
-export const assertAtUri: AssertFn<AtUri> = ensureValidAtUri;
-export const assertNsid: AssertFn<Nsid> = ensureValidNsid;
-export const assertTid: AssertFn<string> = ensureValidTid;
-export const assertRecordKey: AssertFn<string> = ensureValidRecordKey;
-export const assertDatetime: AssertFn<Datetime> = ensureValidDatetime;
-export const assertCidString: AssertFn<string> = ensureValidCidString;
-export const assertHandle: AssertFn<Handle> = ensureValidHandle;
-
-// Export utilities for formats missing from @atproto/syntax
-
-export const assertUri: AssertFn<Uri> = (input) => {
-  if (!/^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)) {
-    throw new Error("Invalid URI");
-  }
-};
-export const assertLanguage: AssertFn<string> = (input) => {
-  if (!isLanguage(input)) {
-    throw new Error("Invalid BCP 47 string");
-  }
-};
-export const assertAtIdentifier: AssertFn<AtIdentifier> = (input) => {
-  if (input.startsWith("did:web:") || input.startsWith("did:plc:")) {
-    assertDid(input);
-  } else if (input.startsWith("did:")) {
-    throw new Error("Invalid DID method");
-  } else {
-    try {
-      assertHandle(input);
-    } catch (cause) {
-      throw new Error("Invalid DID or handle", { cause });
-    }
-  }
-};
-
-const formatters = /*#__PURE__*/ new Map<StringFormat, (str: string) => void>(
-  [
-    ["datetime", assertDatetime],
-    ["uri", assertUri],
-    ["at-uri", assertAtUri],
-    ["did", assertDid],
-    ["handle", assertHandle],
-    ["at-identifier", assertAtIdentifier],
-    ["nsid", assertNsid],
-    ["cid", assertCidString],
-    ["language", assertLanguage],
-    ["tid", assertTid],
-    ["record-key", assertRecordKey],
-  ] as const,
-);
-
-export function assertStringFormat<F extends StringFormat>(
-  input: string,
-  format: F,
-): asserts input is InferStringFormat<F> {
-  const assertFn = formatters.get(format);
-  if (assertFn) assertFn(input);
-  // Fool-proof
-  else throw new Error(`Unknown string format: ${format}`);
-}
diff --git a/lex/schema/core/types.ts b/lex/schema/core/types.ts
deleted file mode 100644
index 6b329a3..0000000
--- a/lex/schema/core/types.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Same as {@link string} but prevents TypeScript allowing union types to
- * be widened to `string` in IDEs.
- */
-export type UnknownString = string & NonNullable<unknown>;
-
-export type Simplify<T> = { [K in keyof T]: T[K] } & NonNullable<unknown>;
-
-// @NOTE there is no way to express "array containing at least one P", so we use
-// "array that contains P at first or last position" as a workaround.
-export type ArrayContaining<T, Items = unknown> =
-  | readonly [T, ...Items[]]
-  | readonly [...Items[], T];
-
-declare const __restricted: unique symbol;
-/**
- * A type that represents a value that cannot be used, with a custom
- * message explaining the restriction.
- */
-export type Restricted<Message extends string> = typeof __restricted & {
-  [__restricted]: Message;
-};
diff --git a/lex/schema/external.ts b/lex/schema/external.ts
deleted file mode 100644
index 053ac6c..0000000
--- a/lex/schema/external.ts
+++ /dev/null
@@ -1,363 +0,0 @@
-import { type $Type, $type, type Nsid, type RecordKey } from "./core.ts";
-import {
-  ArraySchema,
-  type ArraySchemaOptions,
-  BlobSchema,
-  type BlobSchemaOptions,
-  BooleanSchema,
-  type BooleanSchemaOptions,
-  BytesSchema,
-  type BytesSchemaOptions,
-  CidSchema,
-  type CustomAssertion,
-  CustomSchema,
-  DictSchema,
-  DiscriminatedUnionSchema,
-  type DiscriminatedUnionSchemaVariants,
-  EnumSchema,
-  IntegerSchema,
-  type IntegerSchemaOptions,
-  IntersectionSchema,
-  type IntersectionSchemaValidators,
-  LiteralSchema,
-  NeverSchema,
-  NullSchema,
-  ObjectSchema,
-  type ObjectSchemaOptions,
-  type ObjectSchemaProperties,
-  ParamsSchema,
-  type ParamsSchemaOptions,
-  type ParamsSchemaProperties,
-  Payload,
-  type PayloadBody,
-  Permission,
-  type PermissionOptions,
-  PermissionSet,
-  type PermissionSetOptions,
-  Procedure,
-  Query,
-  RecordSchema,
-  RefSchema,
-  type RefSchemaGetter,
-  StringSchema,
-  type StringSchemaOptions,
-  Subscription,
-  TokenSchema,
-  TypedObjectSchema,
-  type TypedRefGetter,
-  TypedRefSchema,
-  TypedUnionSchema,
-  UnionSchema,
-  type UnionSchemaValidators,
-  type UnknownObjectOutput,
-  UnknownObjectSchema,
-  UnknownSchema,
-} from "./schema.ts";
-import type { Infer, PropertyKey, Validator } from "./validation.ts";
-
-export * from "./core.ts";
-export * from "./schema.ts";
-export * from "./validation.ts";
-
-/*@__NO_SIDE_EFFECTS__*/
-export function never() {
-  return new NeverSchema();
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function unknown() {
-  return new UnknownSchema();
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function _null() {
-  return new NullSchema();
-}
-
-export { _null as null };
-
-/*@__NO_SIDE_EFFECTS__*/
-export function literal<const V extends null | string | number | boolean>(
-  value: V,
-) {
-  return new LiteralSchema<V>(value);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function _enum<const V extends null | string | number | boolean>(
-  value: readonly V[],
-) {
-  return new EnumSchema<V>(value);
-}
-
-// @NOTE "enum" is a reserved keyword in JS/TS
-export { _enum as enum };
-
-/*@__NO_SIDE_EFFECTS__*/
-export function boolean(options: BooleanSchemaOptions = {}) {
-  return new BooleanSchema(options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function integer(options: IntegerSchemaOptions = {}) {
-  return new IntegerSchema(options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function cidLink() {
-  return new CidSchema();
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function bytes(options: BytesSchemaOptions = {}) {
-  return new BytesSchema(options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function blob(options: BlobSchemaOptions = {}) {
-  return new BlobSchema(options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function string<
-  const O extends StringSchemaOptions = NonNullable<unknown>,
->(options: StringSchemaOptions & O = {} as O) {
-  return new StringSchema<O>(options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function array<const T>(
-  items: Validator<T>,
-  options: ArraySchemaOptions = {},
-) {
-  return new ArraySchema(items, options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function object<
-  const P extends ObjectSchemaProperties,
-  const O extends ObjectSchemaOptions = NonNullable<unknown>,
->(
-  properties: ObjectSchemaProperties & P,
-  options: ObjectSchemaOptions & O = {} as O,
-) {
-  return new ObjectSchema<P, O>(properties, options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function dict<const K extends Validator, const V extends Validator>(
-  key: K,
-  value: V,
-) {
-  return new DictSchema<K, V>(key, value);
-}
-
-// Utility
-export type { UnknownObjectOutput as UnknownObject };
-
-/*@__NO_SIDE_EFFECTS__*/
-export function unknownObject() {
-  return new UnknownObjectSchema();
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function ref<T>(get: RefSchemaGetter<T>) {
-  return new RefSchema<T>(get);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function custom<T>(
-  assertion: CustomAssertion<T>,
-  message: string,
-  path?: PropertyKey | readonly PropertyKey[],
-) {
-  return new CustomSchema<T>(assertion, message, path);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function union<const V extends UnionSchemaValidators>(validators: V) {
-  return new UnionSchema<V>(validators);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function intersection<const V extends IntersectionSchemaValidators>(
-  validators: V,
-) {
-  return new IntersectionSchema<V>(validators);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function discriminatedUnion<
-  const Discriminator extends string,
-  const Options extends DiscriminatedUnionSchemaVariants<Discriminator>,
->(discriminator: Discriminator, variants: Options) {
-  return new DiscriminatedUnionSchema<Discriminator, Options>(
-    discriminator,
-    variants,
-  );
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function token<const N extends Nsid, const H extends string>(
-  nsid: N,
-  hash: H,
-) {
-  return new TokenSchema($type(nsid, hash));
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function typedRef<const V extends { $type?: string }>(
-  get: TypedRefGetter<V>,
-) {
-  return new TypedRefSchema<V>(get);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function typedUnion<
-  const R extends readonly TypedRefSchema[],
-  const C extends boolean,
->(refs: R, closed: C) {
-  return new TypedUnionSchema<R, C>(refs, closed);
-}
-
-/**
- * This function offers two overloads:
- * - One that allows creating a {@link TypedObjectSchema}, and infer the output
- *   type from the provided arguments, without requiring to specify any of the
- *   generics. This is useful when you want to define a record without
- *   explicitly defining its interface. This version does not support circular
- *   references, as TypeScript cannot infer types in such cases.
- * - One allows creating a {@link TypedObjectSchema} with an explicitly defined
- *   interface. This will typically be used by codegen (`lex build`) to generate
- *   schemas that work even if they contain circular references.
- */
-export function typedObject<
-  const N extends Nsid,
-  const H extends string,
-  const Schema extends Validator<{ [_ in string]?: unknown }>,
->(nsid: N, hash: H, schema: Schema): TypedObjectSchema<$Type<N, H>, Schema>;
-export function typedObject<const V extends { $type?: $Type }>(
-  nsid: V extends { $type?: infer T extends string }
-    ? T extends `${infer N}#${string}` ? N
-    : T // (T is a "main" type, so already an NSID)
-    : never,
-  hash: V extends { $type?: infer T extends string }
-    ? T extends `${string}#${infer H}` ? H
-    : "main"
-    : never,
-  schema: Validator<Omit<V, "$type">>,
-): TypedObjectSchema<NonNullable<V["$type"]>, typeof schema, V>;
-/*@__NO_SIDE_EFFECTS__*/
-export function typedObject<
-  const N extends Nsid,
-  const H extends string,
-  const Schema extends Validator<{ [_ in string]?: unknown }>,
->(nsid: N, hash: H, schema: Schema) {
-  return new TypedObjectSchema<$Type<N, H>, Schema>($type(nsid, hash), schema);
-}
-
-/**
- * Ensures that a `$type` used in a record is a valid NSID (i.e. no fragment).
- */
-type AsNsid<T> = T extends `${string}#${string}` ? never : T;
-
-/**
- * This function offers two overloads:
- * - One that allows creating a {@link RecordSchema}, and infer the output type
- *   from the provided arguments, without requiring to specify any of the
- *   generics. This is useful when you want to define a record without
- *   explicitly defining its interface. This version does not support circular
- *   references, as TypeScript cannot infer types in such cases.
- * - One allows creating a {@link RecordSchema} with an explicitly defined
- *   interface. This will typically be used by codegen (`lex build`) to generate
- *   schemas that work even if they contain circular references.
- */
-export function record<
-  const K extends RecordKey,
-  const T extends Nsid,
-  const S extends Validator<{ [_ in string]?: unknown }>,
->(
-  key: K,
-  type: AsNsid<T>,
-  schema: S,
-): RecordSchema<K, T, S, Infer<S> & { $type: T }>;
-export function record<
-  const K extends RecordKey,
-  const V extends { $type: Nsid },
->(
-  key: K,
-  type: AsNsid<V["$type"]>,
-  schema: Validator<Omit<V, "$type">>,
-): RecordSchema<K, V["$type"], typeof schema, V>;
-/*@__NO_SIDE_EFFECTS__*/
-export function record<
-  const K extends RecordKey,
-  const T extends Nsid,
-  const S extends Validator<{ [_ in string]?: unknown }>,
->(key: K, type: T, schema: S) {
-  return new RecordSchema<K, T, S, Infer<S> & { $type: T }>(key, type, schema);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function params<
-  const P extends ParamsSchemaProperties = NonNullable<unknown>,
-  const O extends ParamsSchemaOptions = ParamsSchemaOptions,
->(properties: P = {} as P, options: ParamsSchemaOptions & O = {} as O) {
-  return new ParamsSchema<P, O>(properties, options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function payload<
-  const E extends string | undefined = undefined,
-  const S extends PayloadBody<E> = undefined,
->(encoding: E = undefined as E, schema: S = undefined as S) {
-  return new Payload<E, S>(encoding, schema);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function query<
-  const N extends Nsid,
-  const P extends ParamsSchema,
-  const O extends Payload,
-  const E extends undefined | readonly string[] = undefined,
->(nsid: N, parameters: P, output: O, errors: E = undefined as E) {
-  return new Query<N, P, O, E>(nsid, parameters, output, errors);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function procedure<
-  const N extends Nsid,
-  const P extends ParamsSchema,
-  const I extends Payload,
-  const O extends Payload,
-  const E extends undefined | readonly string[] = undefined,
->(nsid: N, parameters: P, input: I, output: O, errors: E = undefined as E) {
-  return new Procedure<N, P, I, O, E>(nsid, parameters, input, output, errors);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function subscription<
-  const N extends string,
-  const P extends ParamsSchema,
-  const M extends undefined | RefSchema | TypedUnionSchema | ObjectSchema,
-  const E extends undefined | readonly string[] = undefined,
->(nsid: N, parameters: P, message: M, errors: E = undefined as E) {
-  return new Subscription<N, P, M, E>(nsid, parameters, message, errors);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function permission<
-  const R extends string,
-  const O extends PermissionOptions,
->(resource: R, options: PermissionOptions & O = {} as O) {
-  return new Permission<R, O>(resource, options);
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function permissionSet<
-  const N extends string,
-  const P extends readonly Permission[],
-  const O extends PermissionSetOptions,
->(nsid: N, permissions: P, options: PermissionSetOptions & O = {} as O) {
-  return new PermissionSet<N, P, O>(nsid, permissions, options);
-}
diff --git a/lex/schema/index.ts b/lex/schema/index.ts
deleted file mode 100644
index e3ca22e..0000000
--- a/lex/schema/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import * as l from "./external.ts";
-export * from "./external.ts";
-export { l };
diff --git a/lex/schema/schema.ts b/lex/schema/schema.ts
deleted file mode 100644
index 6e905a8..0000000
--- a/lex/schema/schema.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-// Utilities (that depend on *and* are used by schemas)
-export * from "./schema/_parameters.ts";
-
-// Concrete Types
-export * from "./schema/array.ts";
-export * from "./schema/blob.ts";
-export * from "./schema/boolean.ts";
-export * from "./schema/bytes.ts";
-export * from "./schema/cid.ts";
-export * from "./schema/dict.ts";
-export * from "./schema/enum.ts";
-export * from "./schema/integer.ts";
-export * from "./schema/literal.ts";
-export * from "./schema/never.ts";
-export * from "./schema/null.ts";
-export * from "./schema/object.ts";
-export * from "./schema/string.ts";
-export * from "./schema/unknown-object.ts";
-export * from "./schema/unknown.ts";
-
-// Composite Types
-export * from "./schema/custom.ts";
-export * from "./schema/discriminated-union.ts";
-export * from "./schema/intersection.ts";
-export * from "./schema/ref.ts";
-export * from "./schema/union.ts";
-
-// Lexicon specific Types
-export * from "./schema/params.ts";
-export * from "./schema/payload.ts";
-export * from "./schema/permission-set.ts";
-export * from "./schema/permission.ts";
-export * from "./schema/procedure.ts";
-export * from "./schema/query.ts";
-export * from "./schema/record.ts";
-export * from "./schema/subscription.ts";
-export * from "./schema/token.ts";
-export * from "./schema/typed-object.ts";
-export * from "./schema/typed-ref.ts";
-export * from "./schema/typed-union.ts";
diff --git a/lex/schema/schema/_parameters.ts b/lex/schema/schema/_parameters.ts
deleted file mode 100644
index 462f958..0000000
--- a/lex/schema/schema/_parameters.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import type { Infer, Validator } from "../validation.ts";
-import { ArraySchema } from "./array.ts";
-import { BooleanSchema } from "./boolean.ts";
-import { DictSchema } from "./dict.ts";
-import { IntegerSchema } from "./integer.ts";
-import { StringSchema } from "./string.ts";
-import { UnionSchema } from "./union.ts";
-
-export type ParamScalar = Infer<typeof paramScalarSchema>;
-const paramScalarSchema = new UnionSchema([
-  new BooleanSchema({}),
-  new IntegerSchema({}),
-  new StringSchema({}),
-]);
-
-export type Param = Infer<typeof paramSchema>;
-export const paramSchema = new UnionSchema([
-  paramScalarSchema,
-  new ArraySchema(paramScalarSchema, {}),
-]);
-
-export type Params = { [_: string]: undefined | Param };
-export const paramsSchema = new DictSchema(
-  new StringSchema({}),
-  paramSchema,
-) satisfies Validator<Params>;
diff --git a/lex/schema/schema/array.ts b/lex/schema/schema/array.ts
deleted file mode 100644
index c8b524c..0000000
--- a/lex/schema/schema/array.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type ArraySchemaOptions = {
-  minLength?: number;
-  maxLength?: number;
-};
-
-export class ArraySchema<Item = unknown> extends Validator<Array<Item>> {
-  override readonly lexiconType = "array" as const;
-
-  constructor(
-    readonly items: Validator<Item>,
-    readonly options: ArraySchemaOptions,
-  ) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Array<Item>> {
-    if (!Array.isArray(input)) {
-      return ctx.issueInvalidType(input, "array");
-    }
-
-    const { minLength, maxLength } = this.options;
-
-    if (minLength != null && input.length < minLength) {
-      return ctx.issueTooSmall(input, "array", minLength, input.length);
-    }
-
-    if (maxLength != null && input.length > maxLength) {
-      return ctx.issueTooBig(input, "array", maxLength, input.length);
-    }
-
-    let copy: undefined | Array<Item>;
-
-    for (let i = 0; i < input.length; i++) {
-      const result = ctx.validateChild(input, i, this.items);
-      if (!result.success) return result;
-
-      if (result.value !== input[i]) {
-        // Copy on write (but only if we did not already make a copy)
-        copy ??= Array.from(input);
-        copy[i] = result.value;
-      }
-    }
-
-    return ctx.success(copy ?? input) as ValidationResult<Array<Item>>;
-  }
-}
diff --git a/lex/schema/schema/blob.ts b/lex/schema/schema/blob.ts
deleted file mode 100644
index 447dfb7..0000000
--- a/lex/schema/schema/blob.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import {
-  type BlobRef,
-  isBlobRef,
-  isLegacyBlobRef,
-  type LegacyBlobRef,
-} from "@atp/data";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type BlobSchemaOptions = {
-  /**
-   * Whether to allow legacy blob references format
-   * @see {@link LegacyBlobRef}
-   */
-  allowLegacy?: boolean;
-  /**
-   * Whether to enforce strict validation on the blob reference (CID version, codec, hash function)
-   */
-  strict?: boolean;
-  /**
-   * List of accepted mime types
-   */
-  accept?: string[];
-  /**
-   * Maximum size in bytes
-   */
-  maxSize?: number;
-};
-
-export type { BlobRef, LegacyBlobRef };
-
-export type BlobSchemaOutput<Options> = Options extends { allowLegacy: true }
-  ? BlobRef | LegacyBlobRef
-  : BlobRef;
-
-export class BlobSchema<O extends BlobSchemaOptions> extends Validator<
-  BlobSchemaOutput<O>
-> {
-  override readonly lexiconType = "blob" as const;
-
-  constructor(readonly options: O) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<BlobSchemaOutput<O>> {
-    if (!isBlob(input, this.options)) {
-      return ctx.issueInvalidType(input, "blob");
-    }
-
-    // @NOTE Historically, we did not enforce constraints on blob references
-    // https://github.com/bluesky-social/atproto/blob/4c15fb47cec26060bff2e710e95869a90c9d7fdd/packages/lexicon/src/validators/blob.ts#L5-L19
-
-    // const { accept } = this.options
-    // if (accept && !accept.includes(input.mimeType)) {
-    //   return ctx.issueInvalidValue(input, accept)
-    // }
-
-    // const { maxSize } = this.options
-    // if (maxSize != null && input.size != -1 && input.size > maxSize) {
-    //   return ctx.issueTooBig(input, 'blob', maxSize, input.size)
-    // }
-
-    return ctx.success(input);
-  }
-}
-
-function isBlob<O extends BlobSchemaOptions>(
-  input: unknown,
-  options: O,
-): input is BlobSchemaOutput<O> {
-  if ((input as { $type: string })?.$type !== undefined) {
-    return isBlobRef(input, options);
-  }
-
-  if (options.allowLegacy === true) {
-    return isLegacyBlobRef(input);
-  }
-
-  return false;
-}
diff --git a/lex/schema/schema/boolean.ts b/lex/schema/schema/boolean.ts
deleted file mode 100644
index f92abf3..0000000
--- a/lex/schema/schema/boolean.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type BooleanSchemaOptions = {
-  default?: boolean;
-};
-
-export class BooleanSchema extends Validator<boolean> {
-  override readonly lexiconType = "boolean" as const;
-
-  constructor(readonly options: BooleanSchemaOptions) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown = this.options.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<boolean> {
-    if (typeof input === "boolean") {
-      return ctx.success(input);
-    }
-
-    return ctx.issueInvalidType(input, "boolean");
-  }
-}
diff --git a/lex/schema/schema/bytes.ts b/lex/schema/schema/bytes.ts
deleted file mode 100644
index 7bdcf5d..0000000
--- a/lex/schema/schema/bytes.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { asUint8Array } from "@atp/data";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type BytesSchemaOptions = {
-  minLength?: number;
-  maxLength?: number;
-};
-
-export class BytesSchema extends Validator<Uint8Array> {
-  override readonly lexiconType = "bytes" as const;
-
-  constructor(readonly options: BytesSchemaOptions) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Uint8Array> {
-    // Coerce different binary formats into Uint8Array
-    const bytes = asUint8Array(input);
-    if (!bytes) {
-      return ctx.issueInvalidType(input, "bytes");
-    }
-
-    const { minLength } = this.options;
-    if (minLength != null && bytes.length < minLength) {
-      return ctx.issueTooSmall(bytes, "bytes", minLength, bytes.length);
-    }
-
-    const { maxLength } = this.options;
-    if (maxLength != null && bytes.length > maxLength) {
-      return ctx.issueTooBig(bytes, "bytes", maxLength, bytes.length);
-    }
-
-    return ctx.success(bytes);
-  }
-}
diff --git a/lex/schema/schema/cid.ts b/lex/schema/schema/cid.ts
deleted file mode 100644
index e0f297e..0000000
--- a/lex/schema/schema/cid.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { CID, isCid } from "@atp/data";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export { CID };
-
-export type CidSchemaOptions = {
-  strict?: boolean;
-};
-
-export class CidSchema extends Validator<CID> {
-  override readonly lexiconType = "cid-link" as const;
-
-  constructor(readonly options: CidSchemaOptions = {}) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<CID> {
-    if (!isCid(input, this.options)) {
-      return ctx.issueInvalidType(input, "cid");
-    }
-
-    return ctx.success(input);
-  }
-}
diff --git a/lex/schema/schema/custom.ts b/lex/schema/schema/custom.ts
deleted file mode 100644
index 5c1a652..0000000
--- a/lex/schema/schema/custom.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import type { PropertyKey } from "../validation/property-key.ts";
-import {
-  type ContextualIssue,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation/validator.ts";
-
-export type CustomAssertionContext = {
-  path: PropertyKey[];
-  addIssue(issue: ContextualIssue): void;
-};
-
-export type CustomAssertion<T = unknown> = (
-  this: null,
-  input: unknown,
-  ctx: CustomAssertionContext,
-) => input is T;
-
-export class CustomSchema<T = unknown> extends Validator<T> {
-  constructor(
-    private readonly assertion: CustomAssertion<T>,
-    private readonly message: string,
-    private readonly path?: PropertyKey | readonly PropertyKey[],
-  ) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<T> {
-    if (this.assertion.call(null, input, ctx)) return ctx.success(input as T);
-    return ctx.custom(input, this.message, this.path);
-  }
-}
diff --git a/lex/schema/schema/dict.ts b/lex/schema/schema/dict.ts
deleted file mode 100644
index edb3f58..0000000
--- a/lex/schema/schema/dict.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type DictSchemaOutput<
-  KeySchema extends Validator,
-  ValueSchema extends Validator,
-> = Infer<KeySchema> extends never ? Record<string, never>
-  : Record<Infer<KeySchema> & string, Infer<ValueSchema>>;
-
-/**
- * @note There is no dictionary in Lexicon schemas. This is a custom extension
- * to allow map-like objects when using the lex library programmatically (i.e.
- * not code generated from a lexicon schema).
- */
-export class DictSchema<
-  const KeySchema extends Validator,
-  const ValueSchema extends Validator,
-> extends Validator<DictSchemaOutput<KeySchema, ValueSchema>> {
-  constructor(
-    readonly keySchema: KeySchema,
-    readonly valueSchema: ValueSchema,
-  ) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-    options?: { ignoredKeys?: { has(k: string): boolean } },
-  ): ValidationResult<DictSchemaOutput<KeySchema, ValueSchema>> {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, "dict");
-    }
-
-    let copy: undefined | Record<string, unknown>;
-
-    for (const key in input) {
-      if (options?.ignoredKeys?.has(key)) continue;
-
-      const keyResult = ctx.validate(key, this.keySchema);
-      if (!keyResult.success) return keyResult;
-      if (keyResult.value !== key) {
-        // We can't safely "move" the key to a different name in the output
-        // object (because there may already be something there), so we issue a
-        // "required key" error if the key validation changes the key
-        return ctx.issueRequiredKey(input, key);
-      }
-
-      const valueResult = ctx.validateChild(input, key, this.valueSchema);
-      if (!valueResult.success) return valueResult;
-
-      if (valueResult.value !== input[key]) {
-        copy ??= { ...input };
-        copy[key] = valueResult.value;
-      }
-    }
-
-    return ctx.success(
-      (copy ?? input) as DictSchemaOutput<KeySchema, ValueSchema>,
-    );
-  }
-}
diff --git a/lex/schema/schema/discriminated-union.ts b/lex/schema/schema/discriminated-union.ts
deleted file mode 100644
index f992562..0000000
--- a/lex/schema/schema/discriminated-union.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import type { ArrayContaining } from "../core.ts";
-import {
-  ValidationError,
-  type ValidationFailure,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import { EnumSchema } from "./enum.ts";
-import { LiteralSchema } from "./literal.ts";
-import type { ObjectSchema } from "./object.ts";
-
-export type DiscriminatedUnionSchemaVariant<Discriminator extends string> =
-  ObjectSchema<
-    { [_ in Discriminator]: Validator },
-    { required: ArrayContaining<Discriminator, string> }
-  >;
-
-export type DiscriminatedUnionSchemaVariants<Discriminator extends string> =
-  readonly [
-    DiscriminatedUnionSchemaVariant<Discriminator>,
-    ...DiscriminatedUnionSchemaVariant<Discriminator>[],
-  ];
-
-export type DiscriminatedUnionSchemaOutput<
-  Options extends readonly Validator[],
-> = Options extends readonly [Validator<infer V>] ? V
-  : Options extends readonly [
-    Validator<infer V>,
-    ...infer Rest extends Validator[],
-  ] ? V | DiscriminatedUnionSchemaOutput<Rest>
-  : never;
-
-/**
- * @note There is no discriminated union in Lexicon schemas. This is a custom
- * extension to allow optimized validation of union of objects when using the
- * lex library programmatically (i.e. not code generated from a lexicon schema).
- */
-export class DiscriminatedUnionSchema<
-  const Discriminator extends string = string,
-  const Options extends DiscriminatedUnionSchemaVariants<Discriminator> =
-    DiscriminatedUnionSchemaVariants<Discriminator>,
-> extends Validator<DiscriminatedUnionSchemaOutput<Options>> {
-  constructor(
-    readonly discriminator: Discriminator,
-    readonly variants: Options,
-  ) {
-    super();
-  }
-
-  /**
-   * If all variants have a literal or enum for the discriminator property,
-   * and there are no overlapping values, returns a map of discriminator values
-   * to variants. Otherwise, returns null.
-   */
-  protected get variantsMap() {
-    const map = new Map<
-      unknown,
-      DiscriminatedUnionSchemaVariant<Discriminator>
-    >();
-    for (const variant of this.variants) {
-      const schema = variant.validators[this.discriminator];
-      if (schema instanceof LiteralSchema) {
-        if (map.has(schema.value)) return null; // overlapping value
-        map.set(schema.value, variant);
-      } else if (schema instanceof EnumSchema) {
-        for (const val of schema.values) {
-          if (map.has(val)) return null; // overlapping value
-          map.set(val, variant);
-        }
-      } else {
-        return null; // not a literal or enum
-      }
-    }
-
-    // Cache the map on the instance (to avoid re-computing)
-    Object.defineProperty(this, "variantsMap", {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return map;
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<DiscriminatedUnionSchemaOutput<Options>> {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, "object");
-    }
-
-    if (!Object.hasOwn(input, this.discriminator)) {
-      return ctx.issueRequiredKey(input, this.discriminator);
-    }
-
-    // Fast path: if we have a mapping of discriminator values to variants,
-    // we can directly select the correct variant to validate against. This also
-    // outputs a better error (with a single failure issue) when the discriminator.
-    if (this.variantsMap) {
-      const variant = this.variantsMap.get(input[this.discriminator]);
-      if (!variant) {
-        return ctx.issueInvalidPropertyValue(input, this.discriminator, [
-          ...this.variantsMap.keys(),
-        ]);
-      }
-
-      return ctx.validate(input, variant) as ValidationResult<
-        DiscriminatedUnionSchemaOutput<Options>
-      >;
-    }
-
-    // Slow path: try validating against each variant and return the first
-    // successful one (or aggregate all failures if none match).
-    const failures: ValidationFailure[] = [];
-
-    for (const variant of this.variants) {
-      const discSchema = variant.validators[this.discriminator];
-      const discResult = ctx.validateChild(
-        input,
-        this.discriminator,
-        discSchema,
-      );
-
-      if (!discResult.success) {
-        failures.push(discResult);
-        continue;
-      }
-
-      return ctx.validate(input, variant) as ValidationResult<
-        DiscriminatedUnionSchemaOutput<Options>
-      >;
-    }
-
-    return {
-      success: false,
-      error: ValidationError.fromFailures(failures),
-    };
-  }
-}
diff --git a/lex/schema/schema/enum.ts b/lex/schema/schema/enum.ts
deleted file mode 100644
index c2a6261..0000000
--- a/lex/schema/schema/enum.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class EnumSchema<
-  Output extends null | string | number | boolean = string,
-> extends Validator<Output> {
-  constructor(readonly values: readonly Output[]) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    if (!(this.values as readonly unknown[]).includes(input)) {
-      return ctx.issueInvalidValue(input, this.values);
-    }
-
-    return ctx.success(input as Output);
-  }
-}
diff --git a/lex/schema/schema/integer.ts b/lex/schema/schema/integer.ts
deleted file mode 100644
index b17106b..0000000
--- a/lex/schema/schema/integer.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type IntegerSchemaOptions = {
-  default?: number;
-  minimum?: number;
-  maximum?: number;
-};
-
-export class IntegerSchema extends Validator<number> {
-  override readonly lexiconType = "integer" as const;
-
-  constructor(readonly options: IntegerSchemaOptions) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown = this.options.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<number> {
-    if (!isInteger(input)) {
-      return ctx.issueInvalidType(input, "integer");
-    }
-
-    if (this.options.minimum !== undefined && input < this.options.minimum) {
-      return ctx.issueTooSmall(input, "integer", this.options.minimum, input);
-    }
-
-    if (this.options.maximum !== undefined && input > this.options.maximum) {
-      return ctx.issueTooBig(input, "integer", this.options.maximum, input);
-    }
-
-    return ctx.success(input);
-  }
-}
-
-/**
- * Simple wrapper around {@link Number.isInteger} that acts as a type guard.
- */
-function isInteger(input: unknown): input is number {
-  return Number.isInteger(input);
-}
diff --git a/lex/schema/schema/intersection.ts b/lex/schema/schema/intersection.ts
deleted file mode 100644
index 01d5476..0000000
--- a/lex/schema/schema/intersection.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type IntersectionSchemaValidators = readonly [
-  Validator,
-  Validator,
-  ...Validator[],
-];
-export type IntersectionSchemaOutput<
-  V extends readonly Validator[],
-  Base = unknown,
-> = V extends readonly [
-  infer First extends Validator,
-  ...infer Rest extends Validator[],
-] ? IntersectionSchemaOutput<Rest, Base & Infer<First>>
-  : Base;
-
-export class IntersectionSchema<
-  V extends IntersectionSchemaValidators = IntersectionSchemaValidators,
-> extends Validator<IntersectionSchemaOutput<V>> {
-  constructor(protected readonly validators: V) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<IntersectionSchemaOutput<V>> {
-    for (let i = 0; i < this.validators.length; i++) {
-      const result = ctx.validate(input, this.validators[i]);
-
-      if (!result.success) {
-        return result;
-      }
-
-      // @NOTE because transforming the value could make it invalid for previous
-      // validators, we need to ensure the input remains unchanged only gets
-      // transformed by the first validator.
-      if (i !== 0 && input !== result.value) {
-        // The alternative would be to allow transforms on a first pass
-        // (ignoring errors) and then re-validate the final value against all
-        // validators (without allowing further transforms). This would be way
-        // less efficient (we could make this optional).
-        return ctx.issueInvalidValue(input, [result.value]);
-      }
-
-      input = result.value;
-    }
-
-    return ctx.success(input as IntersectionSchemaOutput<V>);
-  }
-}
diff --git a/lex/schema/schema/literal.ts b/lex/schema/schema/literal.ts
deleted file mode 100644
index 8881219..0000000
--- a/lex/schema/schema/literal.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class LiteralSchema<
-  Output extends null | string | number | boolean = string,
-> extends Validator<Output> {
-  constructor(readonly value: Output) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    if (input !== this.value) {
-      return ctx.issueInvalidValue(input, [this.value]);
-    }
-
-    return ctx.success(this.value);
-  }
-}
diff --git a/lex/schema/schema/never.ts b/lex/schema/schema/never.ts
deleted file mode 100644
index 8a0ab86..0000000
--- a/lex/schema/schema/never.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import {
-  type ValidationFailure,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class NeverSchema extends Validator<never> {
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationFailure {
-    return ctx.issueInvalidType(input, "never");
-  }
-}
diff --git a/lex/schema/schema/null.ts b/lex/schema/schema/null.ts
deleted file mode 100644
index 7a52f0b..0000000
--- a/lex/schema/schema/null.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class NullSchema extends Validator<null> {
-  override readonly lexiconType = "null" as const;
-
-  constructor() {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<null> {
-    if (input !== null) {
-      return ctx.issueInvalidType(input, "null");
-    }
-
-    return ctx.success(null);
-  }
-}
diff --git a/lex/schema/schema/object.ts b/lex/schema/schema/object.ts
deleted file mode 100644
index abec564..0000000
--- a/lex/schema/schema/object.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import type { Simplify } from "../core.ts";
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import type { DictSchema } from "./dict.ts";
-
-export type ObjectSchemaProperties = { [_ in string]: Validator };
-export type ObjectSchemaOptions = {
-  required?: readonly string[];
-  nullable?: readonly string[];
-  unknownProperties?: "strict" | DictSchema<Validator, Validator>;
-};
-
-export type ObjectSchemaNullValue<
-  O extends ObjectSchemaOptions,
-  K extends string,
-> = O extends { nullable: readonly (infer N extends string)[] }
-  ? K extends N ? null
-  : never
-  : never;
-
-export type ObjectSchemaPropertiesOutput<
-  P extends ObjectSchemaProperties,
-  O extends ObjectSchemaOptions,
-> = O extends { required: readonly (infer R extends string)[] } ?
-    & {
-      -readonly [K in string & keyof P & R]-?:
-        | Infer<P[K]>
-        | ObjectSchemaNullValue<O, K>;
-    }
-    & {
-      -readonly [K in Exclude<string & keyof P, R>]?:
-        | Infer<P[K]>
-        | ObjectSchemaNullValue<O, K>;
-    }
-  : {
-    -readonly [K in string & keyof P]?:
-      | Infer<P[K]>
-      | ObjectSchemaNullValue<O, K>;
-  };
-
-/**
- * Allows to more accurately represent the intersection of two object types
- * where both types may share some keys, and one of them uses an index
- * signature.
- *
- * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
- */
-type Intersect<
-  A extends Record<string, unknown>,
-  B extends Record<string, unknown>,
-> = B[keyof B] extends never ? A
-  : keyof A & keyof B extends never
-  // If A and B don't overlap, just return A & B
-    ? A & B
-  // Otherwise, properly represent the fact that accessing using an
-  // index signature could return a value from either A or B
-  : A & { [K in keyof B]: B[K] | A[keyof A & K] };
-
-export type ObjectSchemaOutput<
-  P extends ObjectSchemaProperties,
-  O extends ObjectSchemaOptions,
-> = O extends {
-  unknownProperties: Validator<infer D extends Record<string, unknown>>;
-} ? Simplify<Intersect<ObjectSchemaPropertiesOutput<P, O>, D>>
-  : Simplify<ObjectSchemaPropertiesOutput<P, O>>;
-
-export class ObjectSchema<
-  const Validators extends ObjectSchemaProperties = ObjectSchemaProperties,
-  const Options extends ObjectSchemaOptions = ObjectSchemaOptions,
-  const Output extends ObjectSchemaOutput<
-    Validators,
-    Options
-  > = ObjectSchemaOutput<Validators, Options>,
-> extends Validator<Output> {
-  constructor(
-    readonly validators: Validators,
-    readonly options: Options,
-  ) {
-    super();
-  }
-
-  get validatorsMap(): Map<string, Validator> {
-    const map = new Map(Object.entries(this.validators));
-
-    // Cache the map on the instance (to avoid re-creating it)
-    Object.defineProperty(this, "validatorsMap", {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return map;
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, ["object"]);
-    }
-
-    // Lazily copy value
-    let copy: undefined | Record<string, unknown>;
-
-    for (const [key, propDef] of this.validatorsMap) {
-      if (input[key] === null && this.options.nullable?.includes(key)) {
-        continue;
-      }
-
-      const result = ctx.validateChild(input, key, propDef);
-      if (!result.success) {
-        // Because default values are provided by child validators, we need to
-        // run the validator to get the default value and, in case of failure,
-        // ignore validation error that were caused by missing keys.
-        if (!(key in input)) {
-          if (this.options.required?.includes(key)) {
-            // Transform into "required key" issue
-            return ctx.issueRequiredKey(input, key);
-          }
-
-          // Ignore missing non-required key
-          continue;
-        }
-
-        return result;
-      } else if (result.value === undefined) {
-        // Special case for validators that output "undefined" values (typically
-        // UnknownSchema) since they cannot differentiate between "missing key"
-        // and "key with undefined value"
-
-        if (!(key in input)) {
-          // Input was missing the key (was "undefined")
-          if (this.options.required?.includes(key)) {
-            return ctx.issueRequiredKey(input, key);
-          }
-
-          // Ignore missing non-required key
-          continue;
-        }
-
-        // if "key" existed in input (would typically be "undefined"), we keep
-        // it as-is by continuing processing as if it was any other value.
-      }
-
-      if (result.value !== input[key]) {
-        copy ??= { ...input };
-        copy[key] = result.value;
-      }
-    }
-
-    if (this.options.unknownProperties === "strict") {
-      for (const key of Object.keys(input)) {
-        if (!this.validatorsMap.has(key)) {
-          return ctx.issueInvalidPropertyType(input, key, "undefined");
-        }
-      }
-    } else if (this.options.unknownProperties) {
-      const result = this.options.unknownProperties.validateInContext(
-        copy ?? input,
-        ctx,
-        { ignoredKeys: this.validatorsMap },
-      );
-      if (!result.success) return result;
-      if (result.value !== input) copy = result.value;
-    }
-
-    const output = (copy ?? input) as Output;
-
-    return ctx.success(output);
-  }
-}
diff --git a/lex/schema/schema/params.ts b/lex/schema/schema/params.ts
deleted file mode 100644
index bcf5027..0000000
--- a/lex/schema/schema/params.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import { type Param, type ParamScalar, paramSchema } from "./_parameters.ts";
-import type { ObjectSchemaPropertiesOutput } from "./object.ts";
-import { StringSchema } from "./string.ts";
-
-export type ParamsSchemaProperties = {
-  [_ in string]: Validator<Param>;
-};
-
-export type ParamsSchemaOptions = {
-  required?: readonly string[];
-};
-
-export type ParamsSchemaOutput<
-  P extends ParamsSchemaProperties,
-  O extends ParamsSchemaOptions,
-> = ObjectSchemaPropertiesOutput<P, O>;
-
-export type InferParamsSchema<T> = T extends ParamsSchema<infer P, infer O>
-  ? NonNullable<unknown> extends ParamsSchemaOutput<P, O>
-    ? ParamsSchemaOutput<P, O> | undefined
-  : ParamsSchemaOutput<P, O>
-  : never;
-
-export class ParamsSchema<
-  const Validators extends ParamsSchemaProperties = ParamsSchemaProperties,
-  const Options extends ParamsSchemaOptions = ParamsSchemaOptions,
-  Output extends ParamsSchemaOutput<Validators, Options> = ParamsSchemaOutput<
-    Validators,
-    Options
-  >,
-> extends Validator<Output> {
-  override readonly lexiconType = "params" as const;
-
-  constructor(
-    readonly validators: Validators,
-    readonly options: Options,
-  ) {
-    super();
-  }
-
-  get validatorsMap(): Map<string, Validator<Param>> {
-    const map = new Map(Object.entries(this.validators));
-
-    // Cache the map on the instance (to avoid re-creating it)
-    Object.defineProperty(this, "validatorsMap", {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return map;
-  }
-
-  override validateInContext(
-    input: unknown = {},
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, "object");
-    }
-
-    // Lazily copy value
-    let copy: undefined | Record<string, unknown>;
-
-    // Ensure that non-specified params conform to param schema
-    for (const key in input) {
-      if (this.validatorsMap.has(key)) continue;
-
-      const result = ctx.validateChild(input, key, paramSchema);
-      if (!result.success) return result;
-
-      if (result.value !== input[key]) {
-        copy ??= { ...input };
-        copy[key] = result.value;
-      }
-    }
-
-    for (const [key, propDef] of this.validatorsMap) {
-      const result = ctx.validateChild(input, key, propDef);
-      if (!result.success) {
-        // Because default values are provided by child validators, we need to
-        // run the validator to get the default value and, in case of failure,
-        // ignore validation error that were caused by missing keys.
-        if (!(key in input)) {
-          if (!this.options.required?.includes(key)) {
-            // Ignore missing non-required key
-            continue;
-          } else {
-            // Transform into "required key" issue
-            return ctx.issueRequiredKey(input, key);
-          }
-        }
-
-        return result;
-      }
-
-      if (result.value !== input[key]) {
-        // Copy on write
-        copy ??= { ...input };
-        copy![key] = result.value;
-      }
-    }
-
-    return ctx.success((copy ?? input) as Output);
-  }
-
-  fromURLSearchParams(urlSearchParams: URLSearchParams): Output {
-    const params: Record<string, Param> = {};
-
-    for (const [key, value] of urlSearchParams.entries()) {
-      const validator = this.validatorsMap.get(key);
-
-      const coerced: ParamScalar =
-        validator != null && validator instanceof StringSchema
-          ? value
-          : value === "true"
-          ? true
-          : value === "false"
-          ? false
-          : /^-?\d+$/.test(value)
-          ? Number(value)
-          : value;
-
-      if (params[key] === undefined) {
-        params[key] = coerced;
-      } else if (Array.isArray(params[key])) {
-        params[key].push(coerced);
-      } else {
-        params[key] = [params[key] as ParamScalar, coerced];
-      }
-    }
-
-    return this.parse(params);
-  }
-
-  toURLSearchParams(input: Output): URLSearchParams {
-    const urlSearchParams = new URLSearchParams();
-
-    if (input !== undefined) {
-      for (const [key, value] of Object.entries(input)) {
-        if (Array.isArray(value)) {
-          for (const v of value) {
-            urlSearchParams.append(key, String(v));
-          }
-        } else if (value !== undefined) {
-          urlSearchParams.append(key, String(value));
-        }
-      }
-    }
-
-    return urlSearchParams;
-  }
-}
diff --git a/lex/schema/schema/payload.ts b/lex/schema/schema/payload.ts
deleted file mode 100644
index d87bd68..0000000
--- a/lex/schema/schema/payload.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { LexValue } from "@atp/data";
-import type { Validator } from "../validation.ts";
-
-export type LexBody<E extends string = string> = E extends `text/${string}`
-  ? string // Text encodings always yield string bodies
-  : E extends "application/json" ? LexValue
-  : Uint8Array;
-
-export type InferPayloadEncoding<P extends Payload> = P extends Payload<infer E>
-  ? E
-  : undefined;
-
-export type InferPayloadBody<P extends Payload> = P extends
-  Payload<string, infer S> ? S extends Validator<infer V> ? V
-  : P extends Payload<infer E extends string> ? LexBody<E>
-  : undefined
-  : undefined;
-
-export type PayloadOutput<
-  E extends string | undefined = string,
-  S extends Validator | undefined = Validator,
-> = E extends string ? S extends Validator<infer V> ? {
-      encoding: E;
-      body: V;
-    }
-  : {
-    encoding: E;
-    body: LexBody<E>;
-  }
-  : void;
-
-export type PayloadBody<E extends string | undefined> = E extends undefined
-  ? undefined
-  : Validator | undefined;
-
-export class Payload<
-  const Encoding extends string | undefined = string | undefined,
-  const Body extends PayloadBody<Encoding> = PayloadBody<Encoding>,
-> {
-  constructor(
-    readonly encoding: Encoding,
-    readonly schema: Body,
-  ) {
-    if (encoding === undefined && schema !== undefined) {
-      throw new TypeError(
-        "schema cannot be defined when encoding is undefined",
-      );
-    }
-  }
-}
diff --git a/lex/schema/schema/permission-set.ts b/lex/schema/schema/permission-set.ts
deleted file mode 100644
index 8409a65..0000000
--- a/lex/schema/schema/permission-set.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import type { Permission } from "./permission.ts";
-
-export type PermissionSetOptions = {
-  title?: string;
-  "title:lang"?: Record<string, undefined | string>;
-  detail?: string;
-  "detail:lang"?: Record<string, undefined | string>;
-};
-
-export class PermissionSet<
-  const Nsid extends string = string,
-  const Permissions extends readonly Permission[] = readonly Permission[],
-  const Options extends PermissionSetOptions = PermissionSetOptions,
-> {
-  readonly lexiconType = "permission-set" as const;
-
-  constructor(
-    readonly nsid: Nsid,
-    readonly permissions: Permissions,
-    readonly options: Options,
-  ) {}
-}
diff --git a/lex/schema/schema/permission.ts b/lex/schema/schema/permission.ts
deleted file mode 100644
index f6fea3f..0000000
--- a/lex/schema/schema/permission.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { Params } from "./_parameters.ts";
-
-export type PermissionOptions = Params;
-
-export class Permission<
-  const Resource extends string = string,
-  const Options extends PermissionOptions = PermissionOptions,
-> {
-  readonly lexiconType = "permission" as const;
-
-  constructor(
-    readonly resource: Resource,
-    readonly options: Options,
-  ) {}
-}
diff --git a/lex/schema/schema/procedure.ts b/lex/schema/schema/procedure.ts
deleted file mode 100644
index 1f7fb41..0000000
--- a/lex/schema/schema/procedure.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import type { Nsid } from "../core.ts";
-import type { Infer } from "../validation.ts";
-import type { ParamsSchema } from "./params.ts";
-import type { InferPayloadBody, Payload } from "./payload.ts";
-
-export type InferProcedureParameters<Q extends Procedure> = Q extends
-  Procedure<Nsid, infer P extends ParamsSchema> ? Infer<P> : never;
-
-export type InferProcedureInputBody<Q extends Procedure> = Q extends
-  Procedure<Nsid, ParamsSchema, infer I extends Payload> ? InferPayloadBody<I>
-  : never;
-
-export type InferProcedureOutputBody<Q extends Procedure> = Q extends
-  Procedure<Nsid, ParamsSchema, Payload, infer O extends Payload>
-  ? InferPayloadBody<O>
-  : never;
-
-export class Procedure<
-  N extends Nsid = Nsid,
-  P extends ParamsSchema = ParamsSchema,
-  I extends Payload = Payload,
-  O extends Payload = Payload,
-  E extends undefined | readonly string[] = undefined,
-> {
-  readonly lexiconType = "procedure" as const;
-
-  constructor(
-    readonly nsid: N,
-    readonly parameters: P,
-    readonly input: I,
-    readonly output: O,
-    readonly errors: E,
-  ) {}
-}
diff --git a/lex/schema/schema/query.ts b/lex/schema/schema/query.ts
deleted file mode 100644
index 12e6b37..0000000
--- a/lex/schema/schema/query.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { Nsid } from "../core.ts";
-import type { Infer } from "../validation.ts";
-import type { ParamsSchema } from "./params.ts";
-import type { InferPayloadBody, Payload } from "./payload.ts";
-
-export type InferQueryParameters<Q extends Query> = Q extends
-  Query<Nsid, infer P extends ParamsSchema> ? Infer<P> : never;
-
-export type InferQueryOutputBody<Q extends Query> = Q extends
-  Query<Nsid, ParamsSchema, infer O extends Payload> ? InferPayloadBody<O>
-  : never;
-
-export class Query<
-  N extends Nsid = Nsid,
-  P extends ParamsSchema = ParamsSchema,
-  O extends Payload = Payload,
-  E extends undefined | readonly string[] = undefined,
-> {
-  readonly lexiconType = "query" as const;
-
-  constructor(
-    readonly nsid: N,
-    readonly parameters: P,
-    readonly output: O,
-    readonly errors: E,
-  ) {}
-}
diff --git a/lex/schema/schema/record.ts b/lex/schema/schema/record.ts
deleted file mode 100644
index afeb9dd..0000000
--- a/lex/schema/schema/record.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import type { Nsid, RecordKey, Simplify } from "../core.ts";
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import { LiteralSchema } from "./literal.ts";
-import { StringSchema } from "./string.ts";
-
-export type InferRecordKey<R extends RecordSchema> = R extends RecordSchema<
-  infer K,
-  Nsid,
-  Validator<object>,
-  Infer<Validator<object>> & { $type: Nsid }
-> ? RecordKeySchemaOutput<K>
-  : never;
-
-export class RecordSchema<
-  Key extends RecordKey = RecordKey,
-  Type extends Nsid = Nsid,
-  Schema extends Validator<object> = Validator<object>,
-  Output extends Infer<Schema> & { $type: Type } = Infer<Schema> & {
-    $type: Type;
-  },
-> extends Validator<Output> {
-  override readonly lexiconType = "record" as const;
-
-  keySchema: RecordKeySchema<Key>;
-
-  constructor(
-    readonly key: Key,
-    readonly $type: Type,
-    readonly schema: Schema,
-  ) {
-    super();
-    this.keySchema = recordKey(key);
-  }
-
-  isTypeOf<X extends { $type?: unknown }>(
-    value: X,
-  ): value is X extends { $type: Type } ? X : never {
-    return value.$type === this.$type;
-  }
-
-  build<X extends Omit<Output, "$type">>(
-    input: X,
-  ): Simplify<Omit<X, "$type"> & { $type: Type }> {
-    return { ...input, $type: this.$type };
-  }
-
-  $isTypeOf<X extends { $type?: unknown }>(value: X) {
-    return this.isTypeOf<X>(value);
-  }
-
-  $build<X extends Omit<Output, "$type">>(input: X) {
-    return this.build<X>(input);
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    const result = ctx.validate(input, this.schema) as ValidationResult<Output>;
-
-    if (!result.success) {
-      return result;
-    }
-
-    if (this.$type !== result.value.$type) {
-      return ctx.issueInvalidPropertyValue(result.value, "$type", [this.$type]);
-    }
-
-    return result;
-  }
-}
-
-export type RecordKeySchemaOutput<Key extends RecordKey> = Key extends "any"
-  ? string
-  : Key extends "tid" ? string
-  : Key extends "nsid" ? Nsid
-  : Key extends `literal:${infer L extends string}` ? L
-  : never;
-
-export type RecordKeySchema<Key extends RecordKey> = Validator<
-  RecordKeySchemaOutput<Key>
->;
-
-const keySchema = new StringSchema({ minLength: 1 });
-const tidSchema = new StringSchema({ format: "tid" });
-const nsidSchema = new StringSchema({ format: "nsid" });
-const selfLiteralSchema = new LiteralSchema("self");
-
-function recordKey<Key extends RecordKey>(key: Key): RecordKeySchema<Key> {
-  // @NOTE Use cached instances for common schemas
-  if (key === "any") return keySchema as unknown as RecordKeySchema<Key>;
-  if (key === "tid") return tidSchema as unknown as RecordKeySchema<Key>;
-  if (key === "nsid") return nsidSchema as unknown as RecordKeySchema<Key>;
-  if (key.startsWith("literal:")) {
-    const value = key.slice(8) as RecordKeySchemaOutput<Key>;
-    if (value === "self") {
-      return selfLiteralSchema as unknown as RecordKeySchema<Key>;
-    }
-    return new LiteralSchema(value);
-  }
-
-  throw new Error(`Unsupported record key type: ${key}`);
-}
diff --git a/lex/schema/schema/ref.ts b/lex/schema/schema/ref.ts
deleted file mode 100644
index ef4823e..0000000
--- a/lex/schema/schema/ref.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type RefSchemaGetter<V> = () => Validator<V>;
-
-export class RefSchema<V = unknown> extends Validator<V> {
-  override readonly lexiconType = "ref" as const;
-
-  #getter: RefSchemaGetter<V>;
-
-  constructor(getter: RefSchemaGetter<V>) {
-    // @NOTE In order to avoid circular dependency issues, we don't resolve
-    // the schema here. Instead, we resolve it lazily when first accessed.
-
-    super();
-
-    this.#getter = getter;
-  }
-
-  get schema(): Validator<V> {
-    const value = this.#getter.call(null);
-
-    // Prevents a getter from depending on itself recursively, also allows GC to
-    // clean up the getter function.
-    this.#getter = throwAlreadyCalled;
-
-    // Disable the getter and cache the resolved schema on the instance
-    Object.defineProperty(this, "schema", {
-      value,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return value;
-  }
-
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<V> {
-    return ctx.validate(input, this.schema);
-  }
-}
-
-function throwAlreadyCalled(): never {
-  throw new Error("RefSchema getter called multiple times");
-}
diff --git a/lex/schema/schema/string.ts b/lex/schema/schema/string.ts
deleted file mode 100644
index 64dd295..0000000
--- a/lex/schema/schema/string.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-import { CID, graphemeLen, utf8Len } from "@atp/data";
-import {
-  assertStringFormat,
-  type InferStringFormat,
-  type StringFormat,
-  type UnknownString,
-} from "../core.ts";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import { TokenSchema } from "./token.ts";
-
-export type StringSchemaOptions = {
-  default?: string;
-  knownValues?: readonly string[];
-  format?: StringFormat;
-  minLength?: number;
-  maxLength?: number;
-  minGraphemes?: number;
-  maxGraphemes?: number;
-};
-
-export type StringSchemaOutput<Options> =
-  //
-  Options extends { format: infer F extends StringFormat }
-    ? InferStringFormat<F>
-    : Options extends { knownValues: readonly (infer K extends string)[] }
-      ? K | UnknownString
-    : string;
-
-export class StringSchema<
-  const Options extends StringSchemaOptions = StringSchemaOptions,
-> extends Validator<StringSchemaOutput<Options>> {
-  override readonly lexiconType = "string" as const;
-
-  constructor(readonly options: Options) {
-    super();
-  }
-
-  override validateInContext(
-    // @NOTE validation will be applied on the default value as well
-    input: unknown = this.options.default,
-    ctx: ValidatorContext,
-  ): ValidationResult<StringSchemaOutput<Options>> {
-    const { options } = this;
-
-    const str = coerceToString(input);
-    if (str == null) {
-      return ctx.issueInvalidType(input, "string");
-    }
-
-    let lazyUtf8Len: number;
-
-    const { minLength } = options;
-    if (minLength != null) {
-      if ((lazyUtf8Len ??= utf8Len(str)) < minLength) {
-        return ctx.issueTooSmall(str, "string", minLength, lazyUtf8Len);
-      }
-    }
-
-    const { maxLength } = options;
-    if (maxLength != null) {
-      // Optimization: we can avoid computing the UTF-8 length if the maximum
-      // possible length, in bytes, of the input JS string is smaller than the
-      // maxLength (in UTF-8 string bytes).
-      if (str.length * 3 <= maxLength) {
-        // Input string so small it can't possibly exceed maxLength
-      } else if ((lazyUtf8Len ??= utf8Len(str)) > maxLength) {
-        return ctx.issueTooBig(str, "string", maxLength, lazyUtf8Len);
-      }
-    }
-
-    let lazyGraphLen: number;
-
-    const { minGraphemes } = options;
-    if (minGraphemes != null) {
-      // Optimization: avoid counting graphemes if the length check already fails
-      if (str.length < minGraphemes) {
-        return ctx.issueTooSmall(str, "grapheme", minGraphemes, str.length);
-      } else if ((lazyGraphLen ??= graphemeLen(str)) < minGraphemes) {
-        return ctx.issueTooSmall(str, "grapheme", minGraphemes, lazyGraphLen);
-      }
-    }
-
-    const { maxGraphemes } = options;
-    if (maxGraphemes != null) {
-      if ((lazyGraphLen ??= graphemeLen(str)) > maxGraphemes) {
-        return ctx.issueTooBig(str, "grapheme", maxGraphemes, lazyGraphLen);
-      }
-    }
-
-    if (options.format !== undefined) {
-      try {
-        // @TODO optimize to avoid throw cost (requires re-writing utilities
-        // from @atproto/syntax)
-        assertStringFormat(str, options.format);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : undefined;
-        return ctx.issueInvalidFormat(str, options.format, message);
-      }
-    }
-
-    return ctx.success(str as StringSchemaOutput<Options>);
-  }
-}
-
-export function coerceToString(input: unknown): string | null {
-  switch (typeof input) {
-    case "string":
-      return input;
-    case "object": {
-      if (input == null) return null;
-
-      // @NOTE Allow using TokenSchema instances in places expecting strings,
-      // converting them to their string value.
-      if (input instanceof TokenSchema) {
-        return input.toString();
-      }
-
-      if (input instanceof Date) {
-        if (Number.isNaN(input.getTime())) return null;
-        return input.toISOString();
-      }
-
-      if (input instanceof URL) {
-        return input.toString();
-      }
-
-      const cid = CID.asCID(input);
-      if (cid) return cid.toString();
-
-      if (input instanceof String) {
-        return input.valueOf();
-      }
-    }
-
-    // falls through
-    default:
-      return null;
-  }
-}
diff --git a/lex/schema/schema/subscription.ts b/lex/schema/schema/subscription.ts
deleted file mode 100644
index b8ba052..0000000
--- a/lex/schema/schema/subscription.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import type { Infer } from "../validation.ts";
-import type { ObjectSchema } from "./object.ts";
-import type { ParamsSchema } from "./params.ts";
-import type { RefSchema } from "./ref.ts";
-import type { TypedUnionSchema } from "./typed-union.ts";
-
-export type InferSubscriptionParameters<S extends Subscription> = S extends
-  Subscription<string, infer P extends ParamsSchema> ? Infer<P>
-  : never;
-
-export type InferSubscriptionMessage<S extends Subscription> = S extends
-  Subscription<
-    string,
-    ParamsSchema,
-    infer M extends RefSchema | TypedUnionSchema | ObjectSchema
-  > ? Infer<M>
-  : unknown;
-
-export class Subscription<
-  N extends string = string,
-  P extends ParamsSchema = ParamsSchema,
-  M extends undefined | RefSchema | TypedUnionSchema | ObjectSchema = undefined,
-  E extends undefined | readonly string[] = undefined,
-> {
-  readonly type = "subscription" as const;
-
-  constructor(
-    readonly nsid: N,
-    readonly parameters: P,
-    readonly message: M,
-    readonly errors: E,
-  ) {}
-}
diff --git a/lex/schema/schema/token.ts b/lex/schema/schema/token.ts
deleted file mode 100644
index f3906b9..0000000
--- a/lex/schema/schema/token.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class TokenSchema<V extends string = string> extends Validator<V> {
-  override readonly lexiconType = "token" as const;
-
-  constructor(protected readonly value: V) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<V> {
-    if (input === this.value) {
-      return ctx.success(this.value);
-    }
-
-    // @NOTE: allow using the token instance itself (but convert to the actual
-    // token value)
-    if (input instanceof TokenSchema && input.value === this.value) {
-      return ctx.success(this.value);
-    }
-
-    if (typeof input !== "string") {
-      return ctx.issueInvalidType(input, "token");
-    }
-
-    return ctx.issueInvalidValue(input, [this.value]);
-  }
-
-  // When using the TokenSchema instance as data, let's serialize it to the
-  // token value
-
-  toJSON(): string {
-    return this.value;
-  }
-
-  override toString(): string {
-    return this.value;
-  }
-}
diff --git a/lex/schema/schema/typed-object.ts b/lex/schema/schema/typed-object.ts
deleted file mode 100644
index 870ee28..0000000
--- a/lex/schema/schema/typed-object.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import type { $Type, Simplify } from "../core.ts";
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class TypedObjectSchema<
-  Type extends $Type = $Type,
-  Schema extends Validator<Record<string, unknown>> = Validator<
-    Record<string, unknown>
-  >,
-  Output extends Infer<Schema> & { $type?: Type } = Infer<Schema> & {
-    $type?: Type;
-  },
-> extends Validator<Output> {
-  override readonly lexiconType = "object" as const;
-
-  constructor(
-    readonly $type: Type,
-    readonly schema: Schema,
-  ) {
-    super();
-  }
-
-  isTypeOf<X extends { $type?: unknown }>(
-    value: X,
-  ): value is X extends { $type?: Type } ? X : never {
-    return value.$type === undefined || value.$type === this.$type;
-  }
-
-  build<X extends Omit<Output, "$type">>(
-    input: X,
-  ): Simplify<Omit<X, "$type"> & { $type: Type }> {
-    return { ...input, $type: this.$type };
-  }
-
-  $isTypeOf<X extends { $type?: unknown }>(value: X) {
-    return this.isTypeOf<X>(value);
-  }
-
-  $build<X extends Omit<Output, "$type">>(input: X) {
-    return this.build<X>(input);
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output> {
-    if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, "object");
-    }
-
-    if (
-      "$type" in input &&
-      input.$type !== undefined &&
-      input.$type !== this.$type
-    ) {
-      return ctx.issueInvalidPropertyValue(input, "$type", [this.$type]);
-    }
-
-    return ctx.validate(input, this.schema as Validator<Output>);
-  }
-}
diff --git a/lex/schema/schema/typed-ref.ts b/lex/schema/schema/typed-ref.ts
deleted file mode 100644
index 260ff5c..0000000
--- a/lex/schema/schema/typed-ref.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-// Basically a RecordSchema or TypedObjectSchema
-export type TypedRefSchemaValidator<
-  V extends { $type?: string } = { $type?: string },
-> = V extends { $type?: infer T extends string }
-  ? { $type: T } & Validator<V & { $type?: T }>
-  : never;
-
-export type TypedRefGetter<V extends { $type?: string } = { $type?: string }> =
-  () => TypedRefSchemaValidator<V>;
-
-export type TypedRefSchemaOutput<
-  V extends { $type?: string } = { $type?: string },
-> = V extends { $type?: infer T extends string } ? V & { $type: T } : never;
-
-export class TypedRefSchema<
-  V extends { $type?: string } = { $type?: string },
-> extends Validator<TypedRefSchemaOutput<V>> {
-  #getter: TypedRefGetter<V>;
-
-  constructor(getter: TypedRefGetter<V>) {
-    // @NOTE In order to avoid circular dependency issues, we don't resolve
-    // the schema here. Instead, we resolve it lazily when first accessed.
-
-    super();
-
-    this.#getter = getter;
-  }
-
-  get schema(): TypedRefSchemaValidator<V> {
-    const value = this.#getter.call(null);
-
-    // Prevents a getter from depending on itself recursively, also allows GC to
-    // clean up the getter function.
-    this.#getter = throwAlreadyCalled;
-
-    // Cache the resolved schema on the instance
-    Object.defineProperty(this, "schema", {
-      value,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return value;
-  }
-
-  get $type(): TypedRefSchemaOutput<V>["$type"] {
-    return this.schema.$type;
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<TypedRefSchemaOutput<V>> {
-    const result = ctx.validate(input, this.schema);
-    if (!result.success) return result;
-
-    if (result.value.$type !== this.$type) {
-      return ctx.issueInvalidPropertyValue(result.value, "$type", [this.$type]);
-    }
-
-    return result as ValidationResult<TypedRefSchemaOutput<V>>;
-  }
-}
-
-function throwAlreadyCalled(): never {
-  throw new Error("TypedRefSchema getter called multiple times");
-}
diff --git a/lex/schema/schema/typed-union.ts b/lex/schema/schema/typed-union.ts
deleted file mode 100644
index c328f95..0000000
--- a/lex/schema/schema/typed-union.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import { isPlainObject } from "@atp/data";
-import type { Restricted, UnknownString } from "../core.ts";
-import {
-  type Infer,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-import type { TypedRefSchema, TypedRefSchemaOutput } from "./typed-ref.ts";
-
-export type TypedRef<T extends { $type?: string }> = TypedRefSchemaOutput<T>;
-
-export type TypedObject =
-  & { $type: UnknownString }
-  & {
-    // In order to prevent places that expect an open union from accepting an
-    // invalid version of the known typed objects, we need to prevent any other
-    // properties from being present.
-    //
-    // For example, if an open union expects:
-    // ```ts
-    // TypedObject | { $type: 'A'; a: number }
-    // ```
-    // we don't want it to accept:
-    // ```ts
-    // { $type: 'A' }
-    // ```
-    // Which would be the case as `{ $type: 'A' }` is a valid
-    // `TypedObject`. By adding an index signature that forbids any
-    // property, we ensure that only valid known typed objects can be used.
-    [K in string]: Restricted<"Unknown property">;
-  };
-
-type TypedRefSchemasToUnion<T extends readonly TypedRefSchema[]> = {
-  [K in keyof T]: Infer<T[K]>;
-}[number];
-
-export type TypedUnionSchemaOutput<
-  TypedRefs extends readonly TypedRefSchema[],
-  Closed extends boolean,
-> = Closed extends true ? TypedRefSchemasToUnion<TypedRefs>
-  : TypedRefSchemasToUnion<TypedRefs> | TypedObject;
-
-export class TypedUnionSchema<
-  TypedRefs extends readonly TypedRefSchema[] = TypedRefSchema[],
-  Closed extends boolean = boolean,
-> extends Validator<TypedUnionSchemaOutput<TypedRefs, Closed>> {
-  override readonly lexiconType = "union" as const;
-
-  constructor(
-    protected readonly refs: TypedRefs,
-    public readonly closed: Closed,
-  ) {
-    // @NOTE In order to avoid circular dependency issues, we don't access the
-    // refs's schema (or $type) here. Instead, we access them lazily when first
-    // needed.
-
-    super();
-  }
-
-  protected get refsMap() {
-    const map = new Map<unknown, TypedRefs[number]>();
-    for (const ref of this.refs) map.set(ref.$type, ref);
-
-    // Cache the map on the instance
-    Object.defineProperty(this, "refsMap", {
-      value: map,
-      writable: false,
-      enumerable: false,
-      configurable: true,
-    });
-
-    return map;
-  }
-
-  get $types() {
-    return Array.from(this.refsMap.keys());
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<TypedUnionSchemaOutput<TypedRefs, Closed>> {
-    if (!isPlainObject(input) || !("$type" in input)) {
-      return ctx.issueInvalidType(input, "$typed");
-    }
-
-    const { $type } = input;
-
-    const def = this.refsMap.get($type);
-    if (def) {
-      const result = ctx.validate(input, def);
-      return result as ValidationResult<
-        TypedUnionSchemaOutput<TypedRefs, Closed>
-      >;
-    }
-
-    if (this.closed) {
-      return ctx.issueInvalidPropertyValue(input, "$type", this.$types);
-    }
-    if (typeof $type !== "string") {
-      return ctx.issueInvalidPropertyType(input, "$type", "string");
-    }
-
-    return ctx.success(input as TypedUnionSchemaOutput<TypedRefs, Closed>);
-  }
-}
diff --git a/lex/schema/schema/union.ts b/lex/schema/schema/union.ts
deleted file mode 100644
index 8c391b1..0000000
--- a/lex/schema/schema/union.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import {
-  type Infer,
-  ValidationError,
-  type ValidationFailure,
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type UnionSchemaValidators = readonly [Validator, ...Validator[]];
-export type UnionSchemaOutput<V extends readonly Validator[]> = Infer<
-  V[number]
->;
-
-export class UnionSchema<
-  V extends UnionSchemaValidators = UnionSchemaValidators,
-> extends Validator<UnionSchemaOutput<V>> {
-  constructor(protected readonly validators: V) {
-    super();
-  }
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<UnionSchemaOutput<V>> {
-    const failures: ValidationFailure[] = [];
-
-    for (const validator of this.validators) {
-      const result = ctx.validate(input, validator);
-      if (result.success) {
-        return result as ValidationResult<UnionSchemaOutput<V>>;
-      } else {
-        failures.push(result);
-      }
-    }
-
-    return {
-      success: false,
-      error: ValidationError.fromFailures(failures),
-    };
-  }
-}
diff --git a/lex/schema/schema/unknown-object.ts b/lex/schema/schema/unknown-object.ts
deleted file mode 100644
index e30480c..0000000
--- a/lex/schema/schema/unknown-object.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { isLexMap, type LexMap } from "@atp/data";
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export type { LexMap };
-export type UnknownObjectOutput = LexMap;
-
-export class UnknownObjectSchema extends Validator<UnknownObjectOutput> {
-  override readonly lexiconType = "unknown" as const;
-
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<UnknownObjectOutput> {
-    if (isLexMap(input)) {
-      return ctx.success(input);
-    }
-
-    return ctx.issueInvalidType(input, "unknown");
-  }
-}
diff --git a/lex/schema/schema/unknown.ts b/lex/schema/schema/unknown.ts
deleted file mode 100644
index 8fedc15..0000000
--- a/lex/schema/schema/unknown.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import {
-  type ValidationResult,
-  Validator,
-  type ValidatorContext,
-} from "../validation.ts";
-
-export class UnknownSchema extends Validator<unknown> {
-  override validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<unknown> {
-    return ctx.success(input);
-  }
-}
diff --git a/lex/schema/tests/array-agg_test.ts b/lex/schema/tests/array-agg_test.ts
deleted file mode 100644
index 8220a50..0000000
--- a/lex/schema/tests/array-agg_test.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { assertEquals } from "@std/assert";
-import { arrayAgg } from "../util/array-agg.ts";
-
-Deno.test("arrayAgg aggregates items based on comparison and aggregation functions", () => {
-  const input = [1, 1, 2, 2, 3, 3, 3];
-  const result = arrayAgg(
-    input,
-    (a, b) => a === b,
-    (items) => ({ value: items[0], count: items.length }),
-  );
-  assertEquals(result, [
-    { value: 1, count: 2 },
-    { value: 2, count: 2 },
-    { value: 3, count: 3 },
-  ]);
-});
-
-Deno.test("arrayAgg returns an empty array when input is empty", () => {
-  const input: number[] = [];
-  const result = arrayAgg(
-    input,
-    (a, b) => a === b,
-    (items) => ({ value: items[0], count: items.length }),
-  );
-  assertEquals(result, []);
-});
-
-Deno.test("arrayAgg handles non-consecutive grouping", () => {
-  const input = [1, 2, 1, 2, 3, 1];
-  const result = arrayAgg(
-    input,
-    (a, b) => a === b,
-    (items) => ({ value: items[0], count: items.length }),
-  );
-  assertEquals(result, [
-    { value: 1, count: 3 },
-    { value: 2, count: 2 },
-    { value: 3, count: 1 },
-  ]);
-});
diff --git a/lex/schema/tests/object_test.ts b/lex/schema/tests/object_test.ts
deleted file mode 100644
index 63efcec..0000000
--- a/lex/schema/tests/object_test.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-import { assertEquals } from "@std/assert";
-import { BooleanSchema } from "../schema/boolean.ts";
-import { DictSchema } from "../schema/dict.ts";
-import { EnumSchema } from "../schema/enum.ts";
-import { IntegerSchema } from "../schema/integer.ts";
-import { ObjectSchema } from "../schema/object.ts";
-import { StringSchema } from "../schema/string.ts";
-
-const simpleSchema = new ObjectSchema(
-  {
-    name: new StringSchema({}),
-    age: new IntegerSchema({}),
-    gender: new EnumSchema(["male", "female"]),
-  },
-  {
-    required: ["name"],
-    nullable: ["gender"],
-  },
-);
-
-Deno.test("ObjectSchema simple schema validates plain objects", () => {
-  const result = simpleSchema.validate({
-    name: "Alice",
-    age: 30,
-    gender: "female",
-  });
-  assertEquals(result.success, true);
-});
-
-Deno.test("ObjectSchema simple schema rejects non-objects", () => {
-  const result = simpleSchema.validate("not an object");
-  assertEquals(result.success, false);
-});
-
-Deno.test("ObjectSchema simple schema rejects missing properties", () => {
-  const result = simpleSchema.validate({
-    age: 30,
-    gender: "female",
-  });
-  assertEquals(result.success, false);
-});
-
-Deno.test("ObjectSchema simple schema validates optional properties", () => {
-  const result = simpleSchema.validate({
-    name: "Alice",
-  });
-  assertEquals(result.success, true);
-});
-
-Deno.test("ObjectSchema simple schema validates nullable properties", () => {
-  const result = simpleSchema.validate({
-    name: "Alice",
-    gender: null,
-  });
-  assertEquals(result.success, true);
-});
-
-Deno.test("ObjectSchema simple schema rejects invalid property types", () => {
-  const result = simpleSchema.validate({
-    name: "Alice",
-    age: "thirty",
-  });
-  assertEquals(result.success, false);
-});
-
-Deno.test("ObjectSchema simple schema ignores extra properties", () => {
-  const result = simpleSchema.validate({
-    name: "Alice",
-    age: 30,
-    extra: "value",
-  });
-  assertEquals(result.success, true);
-});
-
-const strictSchema = new ObjectSchema(
-  {
-    id: new StringSchema({}),
-    score: new IntegerSchema({}),
-  },
-  {
-    required: ["id", "score"],
-    unknownProperties: "strict",
-  },
-);
-
-Deno.test("ObjectSchema strict schema rejects extra properties", () => {
-  const result = strictSchema.validate({
-    id: "item1",
-    score: 100,
-    extra: "not allowed",
-  });
-  assertEquals(result.success, false);
-});
-
-Deno.test("ObjectSchema strict schema accepts only defined properties", () => {
-  const result = strictSchema.validate({
-    id: "item1",
-    score: 100,
-  });
-  assertEquals(result.success, true);
-});
-
-const unknownPropertiesSchema = new ObjectSchema(
-  {
-    title: new StringSchema({}),
-  },
-  {
-    required: ["title"],
-    unknownProperties: new DictSchema(
-      new EnumSchema(["tag1", "tag2"]),
-      new BooleanSchema({}),
-    ),
-  },
-);
-
-Deno.test("schema with unknownProperties validator validates extra properties with the provided validator", () => {
-  const result = unknownPropertiesSchema.validate({
-    title: "My Post",
-    tag1: true,
-    tag2: false,
-  });
-  assertEquals(result.success, true);
-});
-
-Deno.test("schema with unknownProperties rejects extra properties that fail the provided validator", () => {
-  const result = unknownPropertiesSchema.validate({
-    title: "My Post",
-    tag1: "not a boolean",
-  });
-  assertEquals(result.success, false);
-});
diff --git a/lex/schema/util/array-agg.ts b/lex/schema/util/array-agg.ts
deleted file mode 100644
index c024c86..0000000
--- a/lex/schema/util/array-agg.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Aggregates items in an array based on a comparison function and an aggregation function.
- *
- * @param arr - The input array to aggregate.
- * @param cmp - A comparison function that determines if two items belong to the same group.
- * @param agg - An aggregation function that combines items in a group into a single item.
- * @returns An array of aggregated items.
- * @example
- * ```ts
- * const input = [1, 1, 2, 2, 3, 3, 3]
- * const result = arrayAgg(
- *   input,
- *   (a, b) => a === b,
- *   (items) => { value: items[0], sum: items.reduce((sum, item) => sum + item, 0) },
- * )
- * // result is [{ value: 1, sum: 2 }, { value: 2, sum: 4 }, { value: 3, sum: 6 }]
- * ```
- */
-export function arrayAgg<T, O>(
-  arr: readonly T[],
-  cmp: (a: T, b: T) => boolean,
-  agg: (items: [T, ...T[]]) => O,
-): O[] {
-  if (arr.length === 0) return [];
-
-  const groups: [T, ...T[]][] = [[arr[0]]];
-  const skipped = Array<undefined | boolean>(arr.length);
-
-  outer: for (let i = 1; i < arr.length; i++) {
-    if (skipped[i]) continue;
-    const item = arr[i];
-    for (let j = 0; j < groups.length; j++) {
-      if (cmp(item, groups[j][0])) {
-        groups[j].push(item);
-        skipped[i] = true;
-        continue outer;
-      }
-    }
-    groups.push([item]);
-  }
-
-  return groups.map(agg);
-}
diff --git a/lex/schema/validation.ts b/lex/schema/validation.ts
deleted file mode 100644
index d75d36b..0000000
--- a/lex/schema/validation.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from "./validation/property-key.ts";
-export * from "./validation/validation-error.ts";
-export * from "./validation/validation-issue.ts";
-export * from "./validation/validator.ts";
diff --git a/lex/schema/validation/property-key.ts b/lex/schema/validation/property-key.ts
deleted file mode 100644
index 361ed92..0000000
--- a/lex/schema/validation/property-key.ts
+++ /dev/null
@@ -1 +0,0 @@
-export type PropertyKey = string | number;
diff --git a/lex/schema/validation/validation-error.ts b/lex/schema/validation/validation-error.ts
deleted file mode 100644
index 9a6218f..0000000
--- a/lex/schema/validation/validation-error.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { failureError, type ResultFailure } from "../core.ts";
-import {
-  aggregateIssues,
-  stringifyIssue,
-  type ValidationIssue,
-} from "./validation-issue.ts";
-
-export class ValidationError extends Error {
-  override name = "ValidationError";
-
-  constructor(
-    readonly issues: ValidationIssue[],
-    options?: ErrorOptions,
-  ) {
-    super(issues.map(stringifyIssue).join(", "), options);
-  }
-
-  static fromFailures(
-    failures: ResultFailure<ValidationError>[],
-  ): ValidationError {
-    if (failures.length === 1) return failures[0].error;
-    const issues = failures.flatMap(extractFailureIssues);
-    return new ValidationError(aggregateIssues(issues), {
-      // Keep the original errors as the cause chain
-      cause: failures.map(failureError),
-    });
-  }
-}
-
-function extractFailureIssues(result: ResultFailure<ValidationError>) {
-  return result.error.issues;
-}
diff --git a/lex/schema/validation/validation-issue.ts b/lex/schema/validation/validation-issue.ts
deleted file mode 100644
index 4422dbe..0000000
--- a/lex/schema/validation/validation-issue.ts
+++ /dev/null
@@ -1,239 +0,0 @@
-import { CID, isPlainObject } from "@atp/data";
-import { arrayAgg } from "../util/array-agg.ts";
-import type { PropertyKey } from "./property-key.ts";
-
-export interface Issue<I = unknown> {
-  readonly input: I;
-  readonly code: string;
-  readonly message?: string;
-  readonly path: readonly PropertyKey[];
-}
-
-export interface IssueCustom extends Issue {
-  readonly code: "custom";
-  readonly message: string;
-}
-
-export interface IssueInvalidFormat extends Issue {
-  readonly code: "invalid_format";
-  readonly format: string;
-}
-
-export interface IssueInvalidType extends Issue {
-  readonly code: "invalid_type";
-  readonly expected: readonly string[];
-}
-
-export interface IssueInvalidValue extends Issue {
-  readonly code: "invalid_value";
-  readonly values: readonly unknown[];
-}
-
-export interface IssueRequiredKey extends Issue {
-  readonly code: "required_key";
-  readonly key: PropertyKey;
-}
-
-export interface IssueTooBig extends Issue {
-  readonly code: "too_big";
-  readonly maximum: number;
-  readonly type: "array" | "string" | "integer" | "grapheme" | "bytes" | "blob";
-  readonly actual: number;
-}
-
-export interface IssueTooSmall extends Issue {
-  readonly code: "too_small";
-  readonly minimum: number;
-  readonly type: "array" | "string" | "integer" | "grapheme" | "bytes";
-  readonly actual: number;
-}
-
-export type ValidationIssue =
-  | IssueCustom
-  | IssueInvalidFormat
-  | IssueInvalidType
-  | IssueInvalidValue
-  | IssueRequiredKey
-  | IssueTooBig
-  | IssueTooSmall;
-
-export function stringifyIssue(issue: ValidationIssue): string {
-  const pathStr = issue.path.length ? ` at ${buildJsonPath(issue.path)}` : "";
-
-  switch (issue.code) {
-    case "invalid_format":
-      return `Invalid ${stringifyStringFormat(issue.format)} format${
-        issue.message ? ` (${issue.message})` : ""
-      }${pathStr} (got ${stringifyValue(issue.input)})`;
-    case "invalid_type":
-      return `Expected ${
-        oneOf(issue.expected.map(stringifyExpectedType))
-      } value type${pathStr} (got ${stringifyType(issue.input)})`;
-    case "invalid_value":
-      return `Expected ${
-        oneOf(issue.values.map(stringifyValue))
-      }${pathStr} (got ${stringifyValue(issue.input)})`;
-    case "required_key":
-      return `Missing required key "${String(issue.key)}"${pathStr}`;
-    case "too_big":
-      return `${issue.type} too big (maximum ${issue.maximum})${pathStr} (got ${issue.actual})`;
-    case "too_small":
-      return `${issue.type} too small (minimum ${issue.minimum})${pathStr} (got ${issue.actual})`;
-    case "custom":
-      return `${issue.message}${pathStr}`;
-    default:
-      // @ts-expect-error fool-proofing
-      return `${issue.code} validation error${pathStr}`;
-  }
-}
-
-function stringifyExpectedType(expected: string): string {
-  if (expected === "$typed") {
-    return 'an object or record which includes a "$type" property';
-  }
-
-  return expected;
-}
-
-function buildJsonPath(path: readonly PropertyKey[]): string {
-  let jsonPath = "$";
-  for (const segment of path) {
-    if (typeof segment === "number") {
-      jsonPath += `[${segment}]`;
-    } else if (/^[a-zA-Z_$][a-zA-Z0-9_]*$/.test(segment as string)) {
-      jsonPath += `.${segment}`;
-    } else {
-      jsonPath += `[${JSON.stringify(segment)}]`;
-    }
-  }
-  return jsonPath;
-}
-
-function oneOf(arr: readonly string[]): string {
-  if (arr.length === 0) return "";
-  if (arr.length === 1) return arr[0];
-  return `one of ${arr.slice(0, -1).join(", ")} or ${arr.at(-1)}`;
-}
-
-function stringifyStringFormat(format: string): string {
-  switch (format) {
-    case "datetime":
-      return "datetime";
-    case "language":
-      return "language";
-    case "at-identifier":
-      return `AT identifier`;
-    case "did":
-      return `DID`;
-    case "handle":
-      return `handle`;
-    case "nsid":
-      return `NSID`;
-    case "cid":
-      return `CID string`;
-    case "tid":
-      return `TID string`;
-    case "record-key":
-      return `record key`;
-    default:
-      return format;
-  }
-}
-
-export function stringifyType(value: unknown): string {
-  switch (typeof value) {
-    case "object":
-      if (value === null) return "null";
-      if (Array.isArray(value)) return "array";
-      if (CID.asCID(value)) return "cid";
-      if (value instanceof Date) return "date";
-      if (value instanceof RegExp) return "regexp";
-      if (value instanceof Map) return "map";
-      if (value instanceof Set) return "set";
-      return "object";
-    case "number":
-      if (Number.isInteger(value)) return "integer";
-      if (Number.isNaN(value)) return "NaN";
-      return "float";
-    default:
-      return typeof value;
-  }
-}
-
-export function stringifyValue(value: unknown): string {
-  switch (typeof value) {
-    case "bigint":
-      return `${value}n`;
-    case "number":
-    case "string":
-    case "boolean":
-      return JSON.stringify(value);
-    case "object":
-      if (Array.isArray(value)) {
-        return `[${stringifyArray(value, stringifyValue)}]`;
-      }
-      if (isPlainObject(value)) {
-        return `{${
-          stringifyArray(Object.entries(value), stringifyObjectEntry)
-        }}`;
-      }
-    // fallthrough
-    default:
-      return stringifyType(value);
-  }
-}
-
-function stringifyObjectEntry([key, _value]: [PropertyKey, unknown]): string {
-  return `${JSON.stringify(key)}: ...`;
-}
-
-function stringifyArray<T>(
-  arr: readonly T[],
-  fn: (item: T) => string,
-  n = 2,
-): string {
-  return arr.slice(0, n).map(fn).join(", ") + (arr.length > n ? ", ..." : "");
-}
-
-export function aggregateIssues(issues: ValidationIssue[]): ValidationIssue[] {
-  // Quick path for common cases
-  if (issues.length <= 1) return issues;
-  if (issues.length === 2 && issues[0].code !== issues[1].code) return issues;
-
-  return [
-    // Aggregate invalid_type with identical paths
-    ...arrayAgg(
-      issues.filter((issue) => issue.code === "invalid_type"),
-      (a, b) => comparePropertyPaths(a.path, b.path),
-      (issues) => ({
-        ...issues[0],
-        expected: Array.from(new Set(issues.flatMap((iss) => iss.expected))),
-      }),
-    ),
-    // Aggregate invalid_value with identical paths
-    ...arrayAgg(
-      issues.filter((issue) => issue.code === "invalid_value"),
-      (a, b) => comparePropertyPaths(a.path, b.path),
-      (issues) => ({
-        ...issues[0],
-        values: Array.from(new Set(issues.flatMap((iss) => iss.values))),
-      }),
-    ),
-    // Pass through other issues
-    ...issues.filter(
-      (issue) =>
-        issue.code !== "invalid_type" && issue.code !== "invalid_value",
-    ),
-  ];
-}
-
-function comparePropertyPaths(
-  a: readonly PropertyKey[],
-  b: readonly PropertyKey[],
-) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
diff --git a/lex/schema/validation/validator.ts b/lex/schema/validation/validator.ts
deleted file mode 100644
index 5c13a1e..0000000
--- a/lex/schema/validation/validator.ts
+++ /dev/null
@@ -1,368 +0,0 @@
-import {
-  failure,
-  type ResultFailure,
-  type ResultSuccess,
-  success,
-} from "../core.ts";
-import type { PropertyKey } from "./property-key.ts";
-import { ValidationError } from "./validation-error.ts";
-import type {
-  IssueTooBig,
-  IssueTooSmall,
-  ValidationIssue,
-} from "./validation-issue.ts";
-
-export type ValidationSuccess<Value = unknown> = ResultSuccess<Value>;
-export type ValidationFailure = ResultFailure<ValidationError>;
-export type ValidationResult<Value = unknown> =
-  | ValidationSuccess<Value>
-  | ValidationFailure;
-
-type ValidationOptions = {
-  path?: PropertyKey[];
-
-  /** @default true */
-  allowTransform?: boolean;
-};
-
-export type Infer<T extends Validator> = T["_lex"]["output"];
-
-export abstract class Validator<Output = unknown> {
-  /**
-   * This property is used for type inference purposes and does not actually
-   * exist at runtime.
-   *
-   * @deprecated For internal use only (not actually deprecated)
-   */
-  _lex!: { output: Output };
-
-  readonly lexiconType?: string;
-
-  /**
-   * @internal **INTERNAL API, DO NOT USE**.
-   *
-   * Use {@link Validator.assert assert}, {@link Validator.check check},
-   * {@link Validator.parse parse} or {@link Validator.validate validate}
-   * instead.
-   *
-   * This method is implemented by subclasses to perform transformation and
-   * validation of the input value. Do not call this method directly; as the
-   * {@link ValidatorContext.options.allowTransform} option will **not** be
-   * enforced. See {@link ValidatorContext.validate} for details. When
-   * delegating validation from one validator sub-class implementation to
-   * another schema, {@link ValidatorContext.validate} should be used instead
-   * of calling {@link Validator.validateInContext}. This will allow to stop the
-   * validation process if the value was transformed (by the other schema) but
-   * transformations are not allowed.
-   *
-   * By convention, the {@link ValidationResult} must return the original input
-   * value if validation was successful and no transformation was applied (i.e.
-   * the input already conformed to the schema). If a default value, or any
-   * other transformation was applied, the returned value c&an be different from
-   * the input.
-   *
-   * This convention allows the {@link Validator.check check} and
-   * {@link Validator.assert assert} methods to check whether the input value
-   * exactly matches the schema (without defaults or transformations), by
-   * checking if the returned value is strictly equal to the input.
-   *
-   * @see {@link ValidatorContext.validate}
-   */
-  abstract validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<Output>;
-
-  assert(input: unknown): asserts input is Output {
-    const result = this.validate(input, { allowTransform: false });
-    if (!result.success) throw result.error;
-  }
-
-  check(input: unknown): input is Output {
-    const result = this.validate(input, { allowTransform: false });
-    return result.success;
-  }
-
-  maybe<I>(input: I): (I & Output) | undefined {
-    return this.check(input) ? input : undefined;
-  }
-
-  parse<I>(
-    input: I,
-    options: ValidationOptions & { allowTransform: false },
-  ): I & Output;
-  parse(input: unknown, options?: ValidationOptions): Output;
-  parse(input: unknown, options?: ValidationOptions): Output {
-    const result = ValidatorContext.validate(input, this, options);
-    if (!result.success) throw result.error;
-    return result.value;
-  }
-
-  validate<I>(
-    input: I,
-    options: ValidationOptions & { allowTransform: false },
-  ): ValidationResult<I & Output>;
-  validate(
-    input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output>;
-  validate(
-    input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output> {
-    return ValidatorContext.validate(input, this, options);
-  }
-
-  // @NOTE The built lexicons namespaces will export utility functions that
-  // allow accessing the schema's methods without the need to specify ".main."
-  // as part of the namespace. This way, a utility for a particular record type
-  // can be called like "app.bsky.feed.post.<utility>()" instead of
-  // "app.bsky.feed.post.main.<utility>()". Because those utilities could
-  // conflict with other schemas (e.g. if there is a lexicon definition at
-  // "#<utility>"), those exported utilities will be prefixed with "$". In order
-  // to be able to consistently call the utilities, when using the "main" and
-  // non "main" definitions, we also expose the same methods with a "$" prefix.
-  // Thanks to this, both of the following call will be possible:
-  //
-  // - "app.bsky.feed.post.$parse(...)" // calls a utility function created by "lex build"
-  // - "app.bsky.feed.defs.postView.$parse(...)" // uses the alias defined below on the schema instance
-
-  $assert(input: unknown): asserts input is Output {
-    return this.assert(input);
-  }
-
-  $check(input: unknown): input is Output {
-    return this.check(input);
-  }
-
-  $maybe<I>(input: I): (I & Output) | undefined {
-    return this.maybe(input);
-  }
-
-  $parse(input: unknown, options?: ValidationOptions): Output {
-    return this.parse(input, options);
-  }
-
-  $validate(
-    input: unknown,
-    options?: ValidationOptions,
-  ): ValidationResult<Output> {
-    return this.validate(input, options);
-  }
-}
-
-export type ContextualIssue = {
-  [Code in ValidationIssue["code"]]:
-    & Omit<
-      Extract<ValidationIssue, { code: Code }>,
-      "path"
-    >
-    & { path?: PropertyKey | readonly PropertyKey[] };
-}[ValidationIssue["code"]];
-
-const asIssue = (
-  { path, ...issue }: ContextualIssue,
-  currentPath: readonly PropertyKey[],
-): ValidationIssue & { path: PropertyKey[] } => ({
-  ...issue,
-  path: path != null ? currentPath.concat(path) : [...currentPath],
-});
-
-export class ValidatorContext {
-  /**
-   * Creates a new validation context and validates the input using the
-   * provided validator.
-   */
-  static validate<V>(
-    input: unknown,
-    validator: Validator<V>,
-    options: ValidationOptions = {},
-  ): ValidationResult<V> {
-    const context = new ValidatorContext(options);
-    return context.validate(input, validator);
-  }
-
-  private readonly currentPath: PropertyKey[];
-  private readonly issues: ValidationIssue[] = [];
-
-  protected constructor(readonly options: ValidationOptions) {
-    // Create a copy because we will be mutating the array during validation.
-    this.currentPath = options?.path != null ? [...options.path] : [];
-  }
-
-  get path() {
-    return [...this.currentPath];
-  }
-
-  get allowTransform() {
-    // Default to true
-    return this.options?.allowTransform !== false;
-  }
-
-  /**
-   * This is basically the entry point for validation within a context. Use this
-   * method instead of {@link Validator.validateInContext} directly, because
-   * this method enforces the {@link ValidationOptions.allowTransform} option.
-   */
-  validate<V>(input: unknown, validator: Validator<V>): ValidationResult<V> {
-    const result = validator.validateInContext(input, this);
-
-    if (result.success) {
-      if (!this.allowTransform && !Object.is(result.value, input)) {
-        // If the value changed, it means that a default (or some other
-        // transformation) was applied, meaning that the original value did
-        // *not* match the (output) schema. When "allowTransform" is false, we
-        // consider this a failure.
-
-        // This check is the reason why Validator.validateInContext should not
-        // be used directly, and ValidatorContext.validate should be used
-        // instead, even when delegating validation from one validator to
-        // another.
-
-        // This if block comes before the next one because 'this.issues' will
-        // end-up being appended to the returned ValidationError (see the
-        // "failure" method below), resulting in a more complete error report.
-        return this.issueInvalidValue(input, [result.value]);
-      }
-
-      if (this.issues.length > 0) {
-        // Validator returned a success but issues were added via the context.
-        // This means the overall validation failed.
-        return { success: false, error: new ValidationError(this.issues) };
-      }
-    }
-
-    return result;
-  }
-
-  validateChild<I extends object, K extends PropertyKey & keyof I, V>(
-    input: I,
-    key: K,
-    validator: Validator<V>,
-  ): ValidationResult<V> {
-    // Instead of creating a new context, we just push/pop the path segment.
-    this.currentPath.push(key);
-    try {
-      return this.validate(input[key], validator);
-    } finally {
-      this.currentPath.length--;
-    }
-  }
-
-  addIssue(issue: ContextualIssue): void {
-    this.issues.push(asIssue(issue, this.currentPath));
-  }
-
-  success<V>(value: V): ValidationResult<V> {
-    return success(value);
-  }
-
-  failure(issue: ContextualIssue): ValidationFailure {
-    return failure(
-      new ValidationError([...this.issues, asIssue(issue, this.currentPath)]),
-    );
-  }
-
-  issueInvalidValue(
-    input: unknown,
-    values: readonly unknown[],
-    path?: PropertyKey | readonly PropertyKey[],
-  ) {
-    return this.failure({
-      code: "invalid_value",
-      input,
-      values,
-      path,
-    });
-  }
-
-  issueInvalidType(
-    input: unknown,
-    expected: string | readonly string[],
-    path?: PropertyKey | readonly PropertyKey[],
-  ) {
-    return this.failure({
-      code: "invalid_type",
-      input,
-      expected: Array.isArray(expected) ? expected : [expected],
-      path,
-    });
-  }
-
-  issueInvalidPropertyValue<I>(
-    input: I,
-    property: keyof I & PropertyKey,
-    values: readonly unknown[],
-  ) {
-    return this.issueInvalidValue(input[property], values, property);
-  }
-
-  issueInvalidPropertyType<I>(
-    input: I,
-    property: keyof I & PropertyKey,
-    expected: string | readonly string[],
-  ) {
-    return this.issueInvalidType(input[property], expected, property);
-  }
-
-  issueRequiredKey(input: object, key: PropertyKey) {
-    return this.failure({
-      code: "required_key",
-      key,
-      input,
-      path: key,
-    });
-  }
-
-  issueInvalidFormat(input: unknown, format: string, message?: string) {
-    return this.failure({
-      code: "invalid_format",
-      message,
-      format,
-      input,
-    });
-  }
-
-  issueTooBig(
-    input: unknown,
-    type: IssueTooBig["type"],
-    maximum: number,
-    actual: number,
-  ) {
-    return this.failure({
-      code: "too_big",
-      type,
-      maximum,
-      actual,
-      input,
-    });
-  }
-
-  issueTooSmall(
-    input: unknown,
-    type: IssueTooSmall["type"],
-    minimum: number,
-    actual: number,
-  ) {
-    return this.failure({
-      code: "too_small",
-      type,
-      minimum,
-      actual,
-      input,
-    });
-  }
-
-  custom(
-    input: unknown,
-    message: string,
-    path?: PropertyKey | readonly PropertyKey[],
-  ) {
-    return this.failure({
-      code: "custom",
-      input,
-      message,
-      path,
-    });
-  }
-}
-- 
2.51.2