diff --git a/common-web/async.ts b/common-web/async.ts
new file mode 100644
index 0000000..300f3c2
--- /dev/null
+++ b/common-web/async.ts
@@ -0,0 +1,201 @@
+import { bailableWait } from "./util.ts";
+
+export const readFromGenerator = async <T>(
+  gen: AsyncGenerator<T>,
+  isDone: (last?: T) => Promise<boolean> | boolean,
+  waitFor: Promise<unknown> = Promise.resolve(),
+  maxLength = Number.MAX_SAFE_INTEGER,
+): Promise<T[]> => {
+  const evts: T[] = [];
+  let bail: undefined | (() => void);
+  let hasBroke = false;
+  const awaitDone = async () => {
+    if (await isDone(evts.at(-1))) {
+      return true;
+    }
+    const bailable = bailableWait(20);
+    await bailable.wait();
+    bail = bailable.bail;
+    if (hasBroke) return false;
+    return await awaitDone();
+  };
+  const breakOn: Promise<void> = new Promise((resolve) => {
+    waitFor.then(() => {
+      awaitDone().then(() => resolve());
+    });
+  });
+
+  try {
+    while (evts.length < maxLength) {
+      const maybeEvt = await Promise.race([gen.next(), breakOn]);
+      if (!maybeEvt) break;
+      const evt = maybeEvt as IteratorResult<T>;
+      if (evt.done) break;
+      evts.push(evt.value);
+    }
+  } finally {
+    hasBroke = true;
+    bail && bail();
+  }
+  return evts;
+};
+
+export type Deferrable = {
+  resolve: () => void;
+  complete: Promise<void>;
+};
+
+export const createDeferrable = (): Deferrable => {
+  let resolve!: () => void;
+  const promise: Promise<void> = new Promise((res) => {
+    resolve = () => res();
+  });
+  return { resolve, complete: promise };
+};
+
+export const createDeferrables = (count: number): Deferrable[] => {
+  const list: Deferrable[] = [];
+  for (let i = 0; i < count; i++) {
+    list.push(createDeferrable());
+  }
+  return list;
+};
+
+export const allComplete = async (deferrables: Deferrable[]): Promise<void> => {
+  await Promise.all(deferrables.map((d) => d.complete));
+};
+
+export class AsyncBuffer<T> {
+  private buffer: T[] = [];
+  private promise: Promise<void>;
+  private resolve: () => void;
+  private closed = false;
+  private toThrow: unknown | undefined;
+
+  constructor(public maxSize?: number) {
+    this.promise = Promise.resolve();
+    this.resolve = () => null;
+    this.resetPromise();
+  }
+
+  get curr(): T[] {
+    return this.buffer;
+  }
+
+  get size(): number {
+    return this.buffer.length;
+  }
+
+  get isClosed(): boolean {
+    return this.closed;
+  }
+
+  resetPromise() {
+    this.promise = new Promise<void>((r) => (this.resolve = r));
+  }
+
+  push(item: T) {
+    this.buffer.push(item);
+    this.resolve();
+  }
+
+  pushMany(items: T[]) {
+    items.forEach((i) => this.buffer.push(i));
+    this.resolve();
+  }
+
+  async *events(): AsyncGenerator<T> {
+    while (true) {
+      if (this.closed && this.buffer.length === 0) {
+        if (this.toThrow) {
+          throw this.toThrow;
+        } else {
+          return;
+        }
+      }
+      await this.promise;
+      if (this.toThrow) {
+        throw this.toThrow;
+      }
+      if (this.maxSize && this.size > this.maxSize) {
+        throw new AsyncBufferFullError(this.maxSize);
+      }
+      const [first, ...rest] = this.buffer;
+      if (first) {
+        this.buffer = rest;
+        yield first;
+      } else {
+        this.resetPromise();
+      }
+    }
+  }
+
+  throw(err: unknown) {
+    this.toThrow = err;
+    this.closed = true;
+    this.resolve();
+  }
+
+  close() {
+    this.closed = true;
+    this.resolve();
+  }
+}
+
+export class AsyncBufferFullError extends Error {
+  constructor(maxSize: number) {
+    super(`ReachedMaxBufferSize: ${maxSize}`);
+  }
+}
+
+export function allFulfilled<T extends readonly unknown[] | []>(
+  promises: T,
+): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
+export function allFulfilled<T>(
+  promises: Iterable<T | PromiseLike<T>>,
+): Promise<Awaited<T>[]>;
+export function allFulfilled(
+  promises: Iterable<Promise<unknown>>,
+): Promise<unknown[]> {
+  return Promise.allSettled(promises).then(handleAllSettledErrors);
+}
+
+export function handleAllSettledErrors<
+  T extends readonly PromiseSettledResult<unknown>[] | [],
+>(
+  results: T,
+): {
+  -readonly [P in keyof T]: T[P] extends PromiseSettledResult<infer U> ? U
+    : never;
+};
+export function handleAllSettledErrors<T>(
+  results: PromiseSettledResult<T>[],
+): T[];
+export function handleAllSettledErrors(
+  results: PromiseSettledResult<unknown>[],
+): unknown[] {
+  if (results.every(isFulfilledResult)) return results.map(extractValue);
+
+  const errors = results.filter(isRejectedResult).map(extractReason);
+  throw errors;
+}
+
+export function isRejectedResult(
+  result: PromiseSettledResult<unknown>,
+): result is PromiseRejectedResult {
+  return result.status === "rejected";
+}
+
+function extractReason(result: PromiseRejectedResult): unknown {
+  return result.reason;
+}
+
+export function isFulfilledResult<T>(
+  result: PromiseSettledResult<T>,
+): result is PromiseFulfilledResult<T> {
+  return result.status === "fulfilled";
+}
+
+function extractValue<T>(result: PromiseFulfilledResult<T>): T {
+  return result.value;
+}
diff --git a/common-web/check.ts b/common-web/check.ts
new file mode 100644
index 0000000..2f5d17d
--- /dev/null
+++ b/common-web/check.ts
@@ -0,0 +1,26 @@
+export interface Checkable<T> {
+  parse: (obj: unknown) => T;
+  safeParse: (
+    obj: unknown,
+  ) => { success: true; data: T } | { success: false; error: Error };
+}
+
+export interface Def<T> {
+  name: string;
+  schema: Checkable<T>;
+}
+
+export const is = <T>(obj: unknown, def: Checkable<T>): obj is T => {
+  return def.safeParse(obj).success;
+};
+
+export const create = <T>(def: Checkable<T>) => (v: unknown): v is T =>
+  def.safeParse(v).success;
+
+export const assure = <T>(def: Checkable<T>, obj: unknown): T => {
+  return def.parse(obj);
+};
+
+export const isObject = (obj: unknown): obj is Record<string, unknown> => {
+  return typeof obj === "object" && obj !== null;
+};
diff --git a/common-web/dates.ts b/common-web/dates.ts
new file mode 100644
index 0000000..35b8e9a
--- /dev/null
+++ b/common-web/dates.ts
@@ -0,0 +1,118 @@
+export const SECOND = 1000;
+export const MINUTE = SECOND * 60;
+export const HOUR = MINUTE * 60;
+export const DAY = HOUR * 24;
+
+const SEPARATORS_TO_ESCAPE = new Set([
+  "\\",
+  "^",
+  "$",
+  ".",
+  "|",
+  "?",
+  "*",
+  "+",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+]);
+
+function getStringSeparator(dateString: string): string {
+  const separator = /\D/.exec(dateString);
+  return separator ? separator[0] : "";
+}
+
+function getTimeStringSeparator(timeString: string): string {
+  const matches = timeString.match(/([^Z+\-\d])(?=\d+\1)/);
+  return Array.isArray(matches) ? matches[0] : "";
+}
+
+export function isValidDate(date: string, s = "-"): boolean {
+  if (SEPARATORS_TO_ESCAPE.has(s)) {
+    s = `\\${s}`;
+  }
+
+  const validator = new RegExp(
+    `^(?!0{4}${s}0{2}${s}0{2})((?=[0-9]{4}${s}(((0[^2])|1[0-2])|02(?=${s}(([0-1][0-9])|2[0-8])))${s}[0-9]{2})|(?=((([13579][26])|([2468][048])|(0[48]))0{2})|([0-9]{2}((((0|[2468])[48])|[2468][048])|([13579][26])))${s}02${s}29))([0-9]{4})${s}(?!((0[469])|11)${s}31)((0[1,3-9]|1[0-2])|(02(?!${s}3)))${s}(0[1-9]|[1-2][0-9]|3[0-1])$`,
+  );
+  return validator.test(date);
+}
+
+function isValidTime(
+  timeWithOffset: string,
+  s = ":",
+  isTimezoneCheckOn = false,
+): boolean {
+  const validator = new RegExp(
+    `^([0-1]|2(?=([0-3])|4${s}00))[0-9]${s}[0-5][0-9](${s}([0-5]|6(?=0))[0-9])?(\.[0-9]{1,9})?$`,
+  );
+
+  if (!isTimezoneCheckOn || !/[Z+\-]/.test(timeWithOffset)) {
+    return validator.test(timeWithOffset);
+  }
+
+  if (/Z$/.test(timeWithOffset)) {
+    return validator.test(timeWithOffset.replace("Z", ""));
+  }
+
+  const isPositiveTimezoneOffset = timeWithOffset.includes("+");
+  const [time, offset] = timeWithOffset.split(/[+-]/);
+
+  return validator.test(time) &&
+    isValidZoneOffset(
+      offset,
+      isPositiveTimezoneOffset,
+      getStringSeparator(offset),
+    );
+}
+
+function isValidZoneOffset(
+  offset: string,
+  isPositiveOffset: boolean,
+  s = ":",
+): boolean {
+  const validator = new RegExp(
+    isPositiveOffset
+      ? `^(0(?!(2${s}4)|0${s}3)|1(?=([0-1]|2(?=${s}[04])|[34](?=${s}0))))([03469](?=${s}[03])|[17](?=${s}0)|2(?=${s}[04])|5(?=${s}[034])|8(?=${s}[04]))${s}([03](?=0)|4(?=5))[05]$`
+      : `^(0(?=[^0])|1(?=[0-2]))([39](?=${s}[03])|[0-24-8](?=${s}00))${s}[03]0$`,
+  );
+  return validator.test(offset);
+}
+
+export function isValidISODateString(dateString: string): boolean {
+  const [date, timeWithOffset] = dateString.split("T");
+  const dateSeparator = getStringSeparator(date);
+  const isDateValid = isValidDate(date, dateSeparator);
+
+  if (!timeWithOffset) {
+    return false;
+  }
+
+  const timeStringSeparator = getTimeStringSeparator(timeWithOffset);
+  return isDateValid && isValidTime(timeWithOffset, timeStringSeparator, true);
+}
+
+export const lessThanAgoMs = (time: Date, range: number): boolean => {
+  return Date.now() < time.getTime() + range;
+};
+
+export const addHoursToDate = (hours: number, startingDate?: Date): Date => {
+  const currentDate = startingDate ? new Date(startingDate) : new Date();
+  currentDate.setHours(currentDate.getHours() + hours);
+  return currentDate;
+};
+
+export function toSimplifiedISOSafe(dateStr: string): string {
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) {
+    return new Date(0).toISOString();
+  }
+  const iso = date.toISOString();
+  if (!isValidISODateString(iso)) {
+    return new Date(0).toISOString();
+  }
+  return iso;
+}
diff --git a/common-web/deno.json b/common-web/deno.json
new file mode 100644
index 0000000..6defbc9
--- /dev/null
+++ b/common-web/deno.json
@@ -0,0 +1,19 @@
+{
+  "name": "@atp/common-web",
+  "version": "0.1.0-alpha.1",
+  "exports": {
+    ".": "./mod.ts",
+    "./async": "./async.ts",
+    "./check": "./check.ts",
+    "./dates": "./dates.ts",
+    "./did-doc": "./did-doc.ts",
+    "./retry": "./retry.ts",
+    "./strings": "./strings.ts",
+    "./tid": "./tid.ts",
+    "./util": "./util.ts"
+  },
+  "license": "MIT",
+  "imports": {
+    "zod": "jsr:@zod/zod@^4.1.13"
+  }
+}
diff --git a/common-web/did-doc.ts b/common-web/did-doc.ts
new file mode 100644
index 0000000..3d5b5fb
--- /dev/null
+++ b/common-web/did-doc.ts
@@ -0,0 +1,193 @@
+import { z } from "zod";
+
+export const isValidDidDoc = (doc: unknown): doc is DidDocument => {
+  return didDocument.safeParse(doc).success;
+};
+
+export const getDid = (doc: DidDocument): string => {
+  const id = doc.id;
+  if (typeof id !== "string") {
+    throw new Error("No `id` on document");
+  }
+  return id;
+};
+
+export const getHandle = (doc: DidDocument): string | undefined => {
+  const aka = doc.alsoKnownAs;
+  if (aka) {
+    for (let i = 0; i < aka.length; i++) {
+      const alias = aka[i];
+      if (alias.startsWith("at://")) {
+        return alias.slice(5);
+      }
+    }
+  }
+  return undefined;
+};
+
+export const getSigningKey = (
+  doc: DidDocument,
+): { type: string; publicKeyMultibase: string } | undefined => {
+  return getVerificationMaterial(doc, "atproto");
+};
+
+export const getVerificationMaterial = (
+  doc: DidDocument,
+  keyId: string,
+): { type: string; publicKeyMultibase: string } | undefined => {
+  const key = findItemById(doc, "verificationMethod", `#${keyId}`);
+  if (!key) {
+    return undefined;
+  }
+
+  if (!key.publicKeyMultibase) {
+    return undefined;
+  }
+
+  return {
+    type: key.type,
+    publicKeyMultibase: key.publicKeyMultibase,
+  };
+};
+
+export const getSigningDidKey = (doc: DidDocument): string | undefined => {
+  const parsed = getSigningKey(doc);
+  if (!parsed) return;
+  return `did:key:${parsed.publicKeyMultibase}`;
+};
+
+export const getPdsEndpoint = (doc: DidDocument): string | undefined => {
+  return getServiceEndpoint(doc, {
+    id: "#atproto_pds",
+    type: "AtprotoPersonalDataServer",
+  });
+};
+
+export const getFeedGenEndpoint = (doc: DidDocument): string | undefined => {
+  return getServiceEndpoint(doc, {
+    id: "#bsky_fg",
+    type: "BskyFeedGenerator",
+  });
+};
+
+export const getNotifEndpoint = (doc: DidDocument): string | undefined => {
+  return getServiceEndpoint(doc, {
+    id: "#bsky_notif",
+    type: "BskyNotificationService",
+  });
+};
+
+export const getServiceEndpoint = (
+  doc: DidDocument,
+  opts: { id: string; type?: string },
+): string | undefined => {
+  const service = findItemById(doc, "service", opts.id);
+  if (!service) {
+    return undefined;
+  }
+
+  if (opts.type && service.type !== opts.type) {
+    return undefined;
+  }
+
+  if (typeof service.serviceEndpoint !== "string") {
+    return undefined;
+  }
+
+  return validateUrl(service.serviceEndpoint);
+};
+
+function findItemById<
+  D extends DidDocument,
+  T extends "verificationMethod" | "service",
+>(doc: D, type: T, id: string): NonNullable<D[T]>[number] | undefined;
+function findItemById(
+  doc: DidDocument,
+  type: "verificationMethod" | "service",
+  id: string,
+) {
+  const items = doc[type];
+  if (items) {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const itemId = item.id;
+
+      if (
+        itemId[0] === "#"
+          ? itemId === id
+          : itemId.length === doc.id.length + id.length &&
+            itemId[doc.id.length] === "#" &&
+            itemId.endsWith(id) &&
+            itemId.startsWith(doc.id)
+      ) {
+        return item;
+      }
+    }
+  }
+  return undefined;
+}
+
+const validateUrl = (urlStr: string): string | undefined => {
+  if (!urlStr.startsWith("http://") && !urlStr.startsWith("https://")) {
+    return undefined;
+  }
+
+  if (!canParseUrl(urlStr)) {
+    return undefined;
+  }
+
+  return urlStr;
+};
+
+const canParseUrl = URL.canParse ??
+  ((urlStr: string): boolean => {
+    try {
+      new URL(urlStr);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+
+const verificationMethod: VerificationMethod = z.object({
+  id: z.string(),
+  type: z.string(),
+  controller: z.string(),
+  publicKeyMultibase: z.string().optional(),
+});
+
+type VerificationMethod = z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodString;
+  controller: z.ZodString;
+  publicKeyMultibase: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+const service: Service = z.object({
+  id: z.string(),
+  type: z.string(),
+  serviceEndpoint: z.union([z.string(), z.record(z.string(), z.unknown())]),
+});
+
+type Service = z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodString;
+  serviceEndpoint: z.ZodUnion<
+    readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]
+  >;
+}, z.core.$strip>;
+
+export const didDocument: DidDocumentType = z.object({
+  id: z.string(),
+  alsoKnownAs: z.array(z.string()).optional(),
+  verificationMethod: z.array(verificationMethod).optional(),
+  service: z.array(service).optional(),
+});
+type DidDocumentType = z.ZodObject<{
+  id: z.ZodString;
+  alsoKnownAs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  verificationMethod: z.ZodOptional<z.ZodArray<VerificationMethod>>;
+  service: z.ZodOptional<z.ZodArray<Service>>;
+}, z.core.$strip>;
+
+export type DidDocument = z.infer<DidDocumentType>;
diff --git a/common-web/mod.ts b/common-web/mod.ts
new file mode 100644
index 0000000..375d210
--- /dev/null
+++ b/common-web/mod.ts
@@ -0,0 +1,17 @@
+/**
+ * # AT Protocol Common Utilities (Web)
+ *
+ * Shared web-safe TypeScript utilities for other @atp/* packages.
+ *
+ * @module
+ */
+export * as check from "./check.ts";
+export * as util from "./util.ts";
+
+export * from "./async.ts";
+export * from "./dates.ts";
+export * from "./did-doc.ts";
+export * from "./retry.ts";
+export * from "./strings.ts";
+export * from "./tid.ts";
+export * from "./util.ts";
diff --git a/common-web/retry.ts b/common-web/retry.ts
new file mode 100644
index 0000000..341142f
--- /dev/null
+++ b/common-web/retry.ts
@@ -0,0 +1,59 @@
+import { wait } from "./util.ts";
+
+export type RetryOptions = {
+  maxRetries?: number;
+  getWaitMs?: (n: number) => number | null;
+};
+
+export async function retry<T>(
+  fn: () => Promise<T> | T,
+  opts: RetryOptions & {
+    retryable?: (err: unknown) => boolean;
+  } = {},
+): Promise<T> {
+  const { maxRetries = 3, retryable = () => true, getWaitMs = backoffMs } =
+    opts;
+  let retries = 0;
+  let doneError: unknown;
+  while (!doneError) {
+    try {
+      return await fn();
+    } catch (err) {
+      const waitMs = getWaitMs(retries);
+      const willRetry = retries < maxRetries && waitMs !== null &&
+        retryable(err);
+      if (willRetry) {
+        retries += 1;
+        if (waitMs !== 0) {
+          await wait(waitMs);
+        }
+      } else {
+        doneError = err;
+      }
+    }
+  }
+  throw doneError;
+}
+
+export function createRetryable(retryable: (err: unknown) => boolean): {
+  <T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+} {
+  return <T>(fn: () => Promise<T>, opts?: RetryOptions) =>
+    retry(fn, { ...opts, retryable });
+}
+
+export function backoffMs(n: number, multiplier = 100, max = 1000): number {
+  const exponentialMs = Math.pow(2, n) * multiplier;
+  const ms = Math.min(exponentialMs, max);
+  return jitter(ms);
+}
+
+function jitter(value: number) {
+  const delta = value * 0.15;
+  return value + randomRange(-delta, delta);
+}
+
+function randomRange(from: number, to: number) {
+  const rand = Math.random() * (to - from);
+  return rand + from;
+}
diff --git a/common-web/strings.ts b/common-web/strings.ts
new file mode 100644
index 0000000..4fc9fd4
--- /dev/null
+++ b/common-web/strings.ts
@@ -0,0 +1,75 @@
+export const utf8Len = (str: string): number => {
+  return new TextEncoder().encode(str).byteLength;
+};
+
+export const graphemeLen = (str: string): number => {
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(undefined, {
+      granularity: "grapheme",
+    });
+    return Array.from(segmenter.segment(str)).length;
+  }
+
+  return Array.from(str).length;
+};
+
+export const utf8ToB64Url = (utf8: string): string => {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(utf8);
+  return btoa(String.fromCharCode(...bytes))
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+};
+
+export const b64UrlToUtf8 = (b64: string): string => {
+  const base64 = b64.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+
+  const binaryString = atob(padded);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+
+  const decoder = new TextDecoder();
+  return decoder.decode(bytes);
+};
+
+export const parseLanguage = (langTag: string): LanguageTag | null => {
+  const parsed = langTag.match(bcp47Regexp);
+  if (!parsed?.groups) return null;
+  const parts = parsed.groups;
+  const result: LanguageTag = {};
+
+  if (parts.grandfathered) result.grandfathered = parts.grandfathered;
+  if (parts.language) result.language = parts.language;
+  if (parts.extlang) result.extlang = parts.extlang;
+  if (parts.script) result.script = parts.script;
+  if (parts.region) result.region = parts.region;
+  if (parts.variant) result.variant = parts.variant;
+  if (parts.extension) result.extension = parts.extension;
+  if (parts.privateUseA || parts.privateUseB) {
+    result.privateUse = parts.privateUseA || parts.privateUseB;
+  }
+
+  return result;
+};
+
+export const validateLanguage = (langTag: string): boolean => {
+  return bcp47Regexp.test(langTag);
+};
+
+export type LanguageTag = {
+  grandfathered?: string;
+  language?: string;
+  extlang?: string;
+  script?: string;
+  region?: string;
+  variant?: string;
+  extension?: string;
+  privateUse?: string;
+};
+
+const bcp47Regexp =
+  /^((?<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})+))$/;
diff --git a/common-web/tid.ts b/common-web/tid.ts
new file mode 100644
index 0000000..c8a9c8e
--- /dev/null
+++ b/common-web/tid.ts
@@ -0,0 +1,105 @@
+import { s32decode, s32encode } from "./util.ts";
+
+const TID_LEN = 13;
+
+let lastTimestamp = 0;
+let timestampCount = 0;
+let clockid: number | null = null;
+
+function dedash(str: string): string {
+  return str.replaceAll("-", "");
+}
+
+export class TID {
+  str: string;
+
+  constructor(str: string) {
+    const noDashes = dedash(str);
+    if (noDashes.length !== TID_LEN) {
+      throw new Error(`Poorly formatted TID: ${noDashes.length} length`);
+    }
+    this.str = noDashes;
+  }
+
+  static next(prev?: TID): TID {
+    const time = Math.max(Date.now(), lastTimestamp);
+    if (time === lastTimestamp) {
+      timestampCount++;
+    }
+    lastTimestamp = time;
+    const timestamp = time * 1000 + timestampCount;
+    if (clockid === null) {
+      clockid = Math.floor(Math.random() * 32);
+    }
+    const tid = TID.fromTime(timestamp, clockid);
+    if (!prev || tid.newerThan(prev)) {
+      return tid;
+    }
+    return TID.fromTime(prev.timestamp() + 1, clockid);
+  }
+
+  static nextStr(prev?: string): string {
+    return TID.next(prev ? new TID(prev) : undefined).toString();
+  }
+
+  static fromTime(timestamp: number, clockid: number): TID {
+    const str = `${s32encode(timestamp)}${s32encode(clockid).padStart(2, "2")}`;
+    return new TID(str);
+  }
+
+  static fromStr(str: string): TID {
+    return new TID(str);
+  }
+
+  static oldestFirst(a: TID, b: TID): number {
+    return a.compareTo(b);
+  }
+
+  static newestFirst(a: TID, b: TID): number {
+    return b.compareTo(a);
+  }
+
+  static is(str: string): boolean {
+    return dedash(str).length === TID_LEN;
+  }
+
+  timestamp(): number {
+    return s32decode(this.str.slice(0, 11));
+  }
+
+  clockid(): number {
+    return s32decode(this.str.slice(11, 13));
+  }
+
+  formatted(): string {
+    const str = this.toString();
+    return `${str.slice(0, 4)}-${str.slice(4, 7)}-${
+      str.slice(
+        7,
+        11,
+      )
+    }-${str.slice(11, 13)}`;
+  }
+
+  toString(): string {
+    return this.str;
+  }
+
+  compareTo(other: TID): number {
+    if (this.str > other.str) return 1;
+    if (this.str < other.str) return -1;
+    return 0;
+  }
+
+  equals(other: TID): boolean {
+    return this.str === other.str;
+  }
+
+  newerThan(other: TID): boolean {
+    return this.compareTo(other) > 0;
+  }
+
+  olderThan(other: TID): boolean {
+    return this.compareTo(other) < 0;
+  }
+}
diff --git a/common-web/util.ts b/common-web/util.ts
new file mode 100644
index 0000000..f9deeee
--- /dev/null
+++ b/common-web/util.ts
@@ -0,0 +1,177 @@
+export const noUndefinedVals = <T>(
+  obj: Record<string, T | undefined>,
+): Record<string, T> => {
+  Object.keys(obj).forEach((k) => {
+    if (obj[k] === undefined) {
+      delete obj[k];
+    }
+  });
+  return obj as Record<string, T>;
+};
+
+export function omit<
+  T extends undefined | null | Record<string, unknown>,
+  K extends keyof NonNullable<T>,
+>(
+  object: T,
+  rejectedKeys: readonly K[],
+): T extends undefined ? undefined : T extends null ? null : Omit<T, K>;
+export function omit(
+  src: undefined | null | Record<string, unknown>,
+  rejectedKeys: readonly string[],
+): undefined | null | Record<string, unknown> {
+  if (!src) return src;
+
+  const dst: Record<string, unknown> = {};
+  const srcKeys = Object.keys(src);
+  for (let i = 0; i < srcKeys.length; i++) {
+    const key = srcKeys[i];
+    if (!rejectedKeys.includes(key)) {
+      dst[key] = src[key];
+    }
+  }
+  return dst;
+}
+
+export const jitter = (maxMs: number): number => {
+  return Math.round((Math.random() - 0.5) * maxMs * 2);
+};
+
+export const wait = (ms: number): Promise<void> => {
+  return new Promise((res) => setTimeout(res, ms));
+};
+
+export type BailableWait = {
+  bail: () => void;
+  wait: () => Promise<void>;
+};
+
+export const bailableWait = (ms: number): BailableWait => {
+  let bail!: () => void;
+  const waitPromise = new Promise<void>((res) => {
+    const timeout = setTimeout(res, ms);
+    bail = () => {
+      clearTimeout(timeout);
+      res();
+    };
+  });
+  return { bail, wait: () => waitPromise };
+};
+
+export const flattenUint8Arrays = (arrs: Uint8Array[]): Uint8Array => {
+  const length = arrs.reduce((acc, cur) => {
+    return acc + cur.length;
+  }, 0);
+  const flattened = new Uint8Array(length);
+  let offset = 0;
+  arrs.forEach((arr) => {
+    flattened.set(arr, offset);
+    offset += arr.length;
+  });
+  return flattened;
+};
+
+export const streamToUI8Array = async (
+  stream: AsyncIterable<Uint8Array>,
+): Promise<Uint8Array> => {
+  const arrays: Uint8Array[] = [];
+  for await (const chunk of stream) {
+    arrays.push(chunk);
+  }
+  return flattenUint8Arrays(arrays);
+};
+
+const S32_CHAR = "234567abcdefghijklmnopqrstuvwxyz";
+
+export const s32encode = (i: number): string => {
+  let s = "";
+  while (i) {
+    const c = i % 32;
+    i = Math.floor(i / 32);
+    s = S32_CHAR.charAt(c) + s;
+  }
+  return s;
+};
+
+export const s32decode = (s: string): number => {
+  let i = 0;
+  for (const c of s) {
+    i = i * 32 + S32_CHAR.indexOf(c);
+  }
+  return i;
+};
+
+export const asyncFilter = async <T>(
+  arr: T[],
+  fn: (t: T) => Promise<boolean>,
+): Promise<T[]> => {
+  const results = await Promise.all(arr.map((t) => fn(t)));
+  return arr.filter((_, i) => results[i]);
+};
+
+export const errHasMsg = (err: unknown, msg: string): boolean => {
+  return !!err && typeof err === "object" && "message" in err &&
+    (err as { message: unknown }).message === msg;
+};
+
+export const chunkArray = <T>(arr: T[], chunkSize: number): T[][] => {
+  return arr.reduce((acc, cur, i) => {
+    const chunkI = Math.floor(i / chunkSize);
+    if (!acc[chunkI]) {
+      acc[chunkI] = [];
+    }
+    acc[chunkI].push(cur);
+    return acc;
+  }, [] as T[][]);
+};
+
+export const range = (num: number): number[] => {
+  const nums: number[] = [];
+  for (let i = 0; i < num; i++) {
+    nums.push(i);
+  }
+  return nums;
+};
+
+export const dedupeStrs = (strs: string[]): string[] => {
+  return [...new Set(strs)];
+};
+
+export const parseIntWithFallback = <T>(
+  value: string | undefined,
+  fallback: T,
+): number | T => {
+  const parsed = parseInt(value || "", 10);
+  return isNaN(parsed) ? fallback : parsed;
+};
+
+export function ui8ToArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  return bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteLength + bytes.byteOffset,
+  ) as ArrayBuffer;
+}
+
+export function keyBy<T, K extends keyof T>(
+  arr: readonly T[],
+  key: K,
+): Map<T[K], T> {
+  return arr.reduce((acc, cur) => {
+    acc.set(cur[key], cur);
+    return acc;
+  }, new Map<T[K], T>());
+}
+
+export const mapDefined = <T, S>(
+  arr: T[],
+  fn: (obj: T) => S | undefined,
+): S[] => {
+  const output: S[] = [];
+  for (const item of arr) {
+    const val = fn(item);
+    if (val !== undefined) {
+      output.push(val);
+    }
+  }
+  return output;
+};
diff --git a/common/async.ts b/common/async.ts
index b30ee3f..76422eb 100644
--- a/common/async.ts
+++ b/common/async.ts
@@ -1,210 +1 @@
-import { bailableWait } from "./util.ts";
-
-// reads values from a generator into a list
-// breaks when isDone signals `true` AND `waitFor` completes OR when a max length is reached
-// NOTE: does not signal generator to close. it *will* continue to produce values
-export const readFromGenerator = async <T>(
-  gen: AsyncGenerator<T>,
-  isDone: (last?: T) => Promise<boolean> | boolean,
-  waitFor: Promise<unknown> = Promise.resolve(),
-  maxLength = Number.MAX_SAFE_INTEGER,
-): Promise<T[]> => {
-  const evts: T[] = [];
-  let bail: undefined | (() => void);
-  let hasBroke = false;
-  const awaitDone = async () => {
-    if (await isDone(evts.at(-1))) {
-      return true;
-    }
-    const bailable = bailableWait(20);
-    await bailable.wait();
-    bail = bailable.bail;
-    if (hasBroke) return false;
-    return await awaitDone();
-  };
-  const breakOn: Promise<void> = new Promise((resolve) => {
-    waitFor.then(() => {
-      awaitDone().then(() => resolve());
-    });
-  });
-
-  try {
-    while (evts.length < maxLength) {
-      const maybeEvt = await Promise.race([gen.next(), breakOn]);
-      if (!maybeEvt) break;
-      const evt = maybeEvt as IteratorResult<T>;
-      if (evt.done) break;
-      evts.push(evt.value);
-    }
-  } finally {
-    hasBroke = true;
-    bail && bail();
-  }
-  return evts;
-};
-
-export type Deferrable = {
-  resolve: () => void;
-  complete: Promise<void>;
-};
-
-export const createDeferrable = (): Deferrable => {
-  let resolve!: () => void;
-  const promise: Promise<void> = new Promise((res) => {
-    resolve = () => res();
-  });
-  return { resolve, complete: promise };
-};
-
-export const createDeferrables = (count: number): Deferrable[] => {
-  const list: Deferrable[] = [];
-  for (let i = 0; i < count; i++) {
-    list.push(createDeferrable());
-  }
-  return list;
-};
-
-export const allComplete = async (deferrables: Deferrable[]): Promise<void> => {
-  await Promise.all(deferrables.map((d) => d.complete));
-};
-
-export class AsyncBuffer<T> {
-  private buffer: T[] = [];
-  private promise: Promise<void>;
-  private resolve: () => void;
-  private closed = false;
-  private toThrow: unknown | undefined;
-
-  constructor(public maxSize?: number) {
-    // Initializing to satisfy types/build, immediately reset by resetPromise()
-    this.promise = Promise.resolve();
-    this.resolve = () => null;
-    this.resetPromise();
-  }
-
-  get curr(): T[] {
-    return this.buffer;
-  }
-
-  get size(): number {
-    return this.buffer.length;
-  }
-
-  get isClosed(): boolean {
-    return this.closed;
-  }
-
-  resetPromise() {
-    this.promise = new Promise<void>((r) => (this.resolve = r));
-  }
-
-  push(item: T) {
-    this.buffer.push(item);
-    this.resolve();
-  }
-
-  pushMany(items: T[]) {
-    items.forEach((i) => this.buffer.push(i));
-    this.resolve();
-  }
-
-  async *events(): AsyncGenerator<T> {
-    while (true) {
-      if (this.closed && this.buffer.length === 0) {
-        if (this.toThrow) {
-          throw this.toThrow;
-        } else {
-          return;
-        }
-      }
-      await this.promise;
-      if (this.toThrow) {
-        throw this.toThrow;
-      }
-      if (this.maxSize && this.size > this.maxSize) {
-        throw new AsyncBufferFullError(this.maxSize);
-      }
-      const [first, ...rest] = this.buffer;
-      if (first) {
-        this.buffer = rest;
-        yield first;
-      } else {
-        this.resetPromise();
-      }
-    }
-  }
-
-  throw(err: unknown) {
-    this.toThrow = err;
-    this.closed = true;
-    this.resolve();
-  }
-
-  close() {
-    this.closed = true;
-    this.resolve();
-  }
-}
-
-export class AsyncBufferFullError extends Error {
-  constructor(maxSize: number) {
-    super(`ReachedMaxBufferSize: ${maxSize}`);
-  }
-}
-
-/**
- * Utility function that behaves like {@link Promise.allSettled} but returns the
- * same result as {@link Promise.all} in case every promise is fulfilled, and
- * throws an {@link AggregateError} if there are more than one errors.
- */
-export function allFulfilled<T extends readonly unknown[] | []>(
-  promises: T,
-): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
-export function allFulfilled<T>(
-  promises: Iterable<T | PromiseLike<T>>,
-): Promise<Awaited<T>[]>;
-export function allFulfilled(
-  promises: Iterable<Promise<unknown>>,
-): Promise<unknown[]> {
-  return Promise.allSettled(promises).then(handleAllSettledErrors);
-}
-
-export function handleAllSettledErrors<
-  T extends readonly PromiseSettledResult<unknown>[] | [],
->(
-  results: T,
-): {
-  -readonly [P in keyof T]: T[P] extends PromiseSettledResult<infer U> ? U
-    : never;
-};
-export function handleAllSettledErrors<T>(
-  results: PromiseSettledResult<T>[],
-): T[];
-export function handleAllSettledErrors(
-  results: PromiseSettledResult<unknown>[],
-): unknown[] {
-  if (results.every(isFulfilledResult)) return results.map(extractValue);
-
-  const errors = results.filter(isRejectedResult).map(extractReason);
-  throw errors;
-}
-
-export function isRejectedResult(
-  result: PromiseSettledResult<unknown>,
-): result is PromiseRejectedResult {
-  return result.status === "rejected";
-}
-
-function extractReason(result: PromiseRejectedResult): unknown {
-  return result.reason;
-}
-
-export function isFulfilledResult<T>(
-  result: PromiseSettledResult<T>,
-): result is PromiseFulfilledResult<T> {
-  return result.status === "fulfilled";
-}
-
-function extractValue<T>(result: PromiseFulfilledResult<T>): T {
-  return result.value;
-}
+export * from "@atp/common-web/async";
diff --git a/common/check.ts b/common/check.ts
index d822ea3..a3dc89d 100644
--- a/common/check.ts
+++ b/common/check.ts
@@ -1,29 +1 @@
-// Explicitly not using "zod" types here to avoid mismatching types due to
-// version differences.
-
-export interface Checkable<T> {
-  parse: (obj: unknown) => T;
-  safeParse: (
-    obj: unknown,
-  ) => { success: true; data: T } | { success: false; error: Error };
-}
-
-export interface Def<T> {
-  name: string;
-  schema: Checkable<T>;
-}
-
-export const is = <T>(obj: unknown, def: Checkable<T>): obj is T => {
-  return def.safeParse(obj).success;
-};
-
-export const create = <T>(def: Checkable<T>) => (v: unknown): v is T =>
-  def.safeParse(v).success;
-
-export const assure = <T>(def: Checkable<T>, obj: unknown): T => {
-  return def.parse(obj);
-};
-
-export const isObject = (obj: unknown): obj is Record<string, unknown> => {
-  return typeof obj === "object" && obj !== null;
-};
+export * from "@atp/common-web/check";
diff --git a/common/dates.ts b/common/dates.ts
index 51a626a..f2aeda6 100644
--- a/common/dates.ts
+++ b/common/dates.ts
@@ -1,129 +1 @@
-// Time constants
-export const SECOND = 1000;
-export const MINUTE = SECOND * 60;
-export const HOUR = MINUTE * 60;
-export const DAY = HOUR * 24;
-
-// Characters that need escaping in regex
-const SEPARATORS_TO_ESCAPE = new Set([
-  "\\",
-  "^",
-  "$",
-  ".",
-  "|",
-  "?",
-  "*",
-  "+",
-  "(",
-  ")",
-  "[",
-  "]",
-  "{",
-  "}",
-]);
-
-// Helper Functions
-
-function getStringSeparator(dateString: string): string {
-  const separator = /\D/.exec(dateString);
-  return separator ? separator[0] : "";
-}
-
-function getTimeStringSeparator(timeString: string): string {
-  const matches = timeString.match(/([^Z+\-\d])(?=\d+\1)/);
-  return Array.isArray(matches) ? matches[0] : "";
-}
-
-// Validation Functions
-
-export function isValidDate(date: string, s = "-"): boolean {
-  if (SEPARATORS_TO_ESCAPE.has(s)) {
-    s = `\\${s}`;
-  }
-
-  const validator = new RegExp(
-    `^(?!0{4}${s}0{2}${s}0{2})((?=[0-9]{4}${s}(((0[^2])|1[0-2])|02(?=${s}(([0-1][0-9])|2[0-8])))${s}[0-9]{2})|(?=((([13579][26])|([2468][048])|(0[48]))0{2})|([0-9]{2}((((0|[2468])[48])|[2468][048])|([13579][26])))${s}02${s}29))([0-9]{4})${s}(?!((0[469])|11)${s}31)((0[1,3-9]|1[0-2])|(02(?!${s}3)))${s}(0[1-9]|[1-2][0-9]|3[0-1])$`,
-  );
-  return validator.test(date);
-}
-
-function isValidTime(
-  timeWithOffset: string,
-  s = ":",
-  isTimezoneCheckOn = false,
-): boolean {
-  const validator = new RegExp(
-    `^([0-1]|2(?=([0-3])|4${s}00))[0-9]${s}[0-5][0-9](${s}([0-5]|6(?=0))[0-9])?(\.[0-9]{1,9})?$`,
-  );
-
-  if (!isTimezoneCheckOn || !/[Z+\-]/.test(timeWithOffset)) {
-    return validator.test(timeWithOffset);
-  }
-
-  // Case we got time in Zulu tz
-  if (/Z$/.test(timeWithOffset)) {
-    return validator.test(timeWithOffset.replace("Z", ""));
-  }
-
-  const isPositiveTimezoneOffset = timeWithOffset.includes("+");
-  const [time, offset] = timeWithOffset.split(/[+-]/);
-
-  return validator.test(time) &&
-    isValidZoneOffset(
-      offset,
-      isPositiveTimezoneOffset,
-      getStringSeparator(offset),
-    );
-}
-
-function isValidZoneOffset(
-  offset: string,
-  isPositiveOffset: boolean,
-  s = ":",
-): boolean {
-  const validator = new RegExp(
-    isPositiveOffset
-      ? `^(0(?!(2${s}4)|0${s}3)|1(?=([0-1]|2(?=${s}[04])|[34](?=${s}0))))([03469](?=${s}[03])|[17](?=${s}0)|2(?=${s}[04])|5(?=${s}[034])|8(?=${s}[04]))${s}([03](?=0)|4(?=5))[05]$`
-      : `^(0(?=[^0])|1(?=[0-2]))([39](?=${s}[03])|[0-24-8](?=${s}00))${s}[03]0$`,
-  );
-  return validator.test(offset);
-}
-
-export function isValidISODateString(dateString: string): boolean {
-  const [date, timeWithOffset] = dateString.split("T");
-  const dateSeparator = getStringSeparator(date);
-  const isDateValid = isValidDate(date, dateSeparator);
-
-  if (!timeWithOffset) {
-    return false;
-  }
-
-  const timeStringSeparator = getTimeStringSeparator(timeWithOffset);
-  return isDateValid && isValidTime(timeWithOffset, timeStringSeparator, true);
-}
-
-// Utility Functions
-
-export const lessThanAgoMs = (time: Date, range: number): boolean => {
-  return Date.now() < time.getTime() + range;
-};
-
-export const addHoursToDate = (hours: number, startingDate?: Date): Date => {
-  // When date is passed, clone before calling `setHours()` so that we are not mutating the original date
-  const currentDate = startingDate ? new Date(startingDate) : new Date();
-  currentDate.setHours(currentDate.getHours() + hours);
-  return currentDate;
-};
-
-export function toSimplifiedISOSafe(dateStr: string): string {
-  const date = new Date(dateStr);
-  if (isNaN(date.getTime())) {
-    return new Date(0).toISOString();
-  }
-  const iso = date.toISOString();
-  if (!isValidISODateString(iso)) {
-    // Occurs in rare cases, e.g. where resulting UTC year is negative. These also don't preserve lexical sort.
-    return new Date(0).toISOString();
-  }
-  return iso; // YYYY-MM-DDTHH:mm:ss.sssZ
-}
+export * from "@atp/common-web/dates";
diff --git a/common/did-doc.ts b/common/did-doc.ts
index df5f3f7..f410042 100644
--- a/common/did-doc.ts
+++ b/common/did-doc.ts
@@ -1,210 +1 @@
-import { z } from "zod";
-
-// Parsing atproto data
-// --------
-
-export const isValidDidDoc = (doc: unknown): doc is DidDocument => {
-  return didDocument.safeParse(doc).success;
-};
-
-export const getDid = (doc: DidDocument): string => {
-  const id = doc.id;
-  if (typeof id !== "string") {
-    throw new Error("No `id` on document");
-  }
-  return id;
-};
-
-export const getHandle = (doc: DidDocument): string | undefined => {
-  const aka = doc.alsoKnownAs;
-  if (aka) {
-    for (let i = 0; i < aka.length; i++) {
-      const alias = aka[i];
-      if (alias.startsWith("at://")) {
-        // strip off "at://" prefix
-        return alias.slice(5);
-      }
-    }
-  }
-  return undefined;
-};
-
-// @NOTE we parse to type/publicKeyMultibase to avoid the dependency on @atproto/crypto
-export const getSigningKey = (
-  doc: DidDocument,
-): { type: string; publicKeyMultibase: string } | undefined => {
-  return getVerificationMaterial(doc, "atproto");
-};
-
-export const getVerificationMaterial = (
-  doc: DidDocument,
-  keyId: string,
-): { type: string; publicKeyMultibase: string } | undefined => {
-  // /!\ Hot path
-
-  const key = findItemById(doc, "verificationMethod", `#${keyId}`);
-  if (!key) {
-    return undefined;
-  }
-
-  if (!key.publicKeyMultibase) {
-    return undefined;
-  }
-
-  return {
-    type: key.type,
-    publicKeyMultibase: key.publicKeyMultibase,
-  };
-};
-
-export const getSigningDidKey = (doc: DidDocument): string | undefined => {
-  const parsed = getSigningKey(doc);
-  if (!parsed) return;
-  return `did:key:${parsed.publicKeyMultibase}`;
-};
-
-export const getPdsEndpoint = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: "#atproto_pds",
-    type: "AtprotoPersonalDataServer",
-  });
-};
-
-export const getFeedGenEndpoint = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: "#bsky_fg",
-    type: "BskyFeedGenerator",
-  });
-};
-
-export const getNotifEndpoint = (doc: DidDocument): string | undefined => {
-  return getServiceEndpoint(doc, {
-    id: "#bsky_notif",
-    type: "BskyNotificationService",
-  });
-};
-
-export const getServiceEndpoint = (
-  doc: DidDocument,
-  opts: { id: string; type?: string },
-): string | undefined => {
-  // /!\ Hot path
-
-  const service = findItemById(doc, "service", opts.id);
-  if (!service) {
-    return undefined;
-  }
-
-  if (opts.type && service.type !== opts.type) {
-    return undefined;
-  }
-
-  if (typeof service.serviceEndpoint !== "string") {
-    return undefined;
-  }
-
-  return validateUrl(service.serviceEndpoint);
-};
-
-function findItemById<
-  D extends DidDocument,
-  T extends "verificationMethod" | "service",
->(doc: D, type: T, id: string): NonNullable<D[T]>[number] | undefined;
-function findItemById(
-  doc: DidDocument,
-  type: "verificationMethod" | "service",
-  id: string,
-) {
-  // /!\ Hot path
-
-  const items = doc[type];
-  if (items) {
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const itemId = item.id;
-
-      if (
-        itemId[0] === "#"
-          ? itemId === id
-          // Optimized version of: itemId === `${doc.id}${id}`
-          : itemId.length === doc.id.length + id.length &&
-            itemId[doc.id.length] === "#" &&
-            itemId.endsWith(id) &&
-            itemId.startsWith(doc.id) // <== We could probably skip this check
-      ) {
-        return item;
-      }
-    }
-  }
-  return undefined;
-}
-
-// Check protocol and hostname to prevent potential SSRF
-const validateUrl = (urlStr: string): string | undefined => {
-  if (!urlStr.startsWith("http://") && !urlStr.startsWith("https://")) {
-    return undefined;
-  }
-
-  if (!canParseUrl(urlStr)) {
-    return undefined;
-  }
-
-  return urlStr;
-};
-
-const canParseUrl = URL.canParse ??
-  // URL.canParse is not available in Node.js < 18.17.0
-  ((urlStr: string): boolean => {
-    try {
-      new URL(urlStr);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-
-// Types
-// --------
-
-const verificationMethod: VerificationMethod = z.object({
-  id: z.string(),
-  type: z.string(),
-  controller: z.string(),
-  publicKeyMultibase: z.string().optional(),
-});
-
-type VerificationMethod = z.ZodObject<{
-  id: z.ZodString;
-  type: z.ZodString;
-  controller: z.ZodString;
-  publicKeyMultibase: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-const service: Service = z.object({
-  id: z.string(),
-  type: z.string(),
-  serviceEndpoint: z.union([z.string(), z.record(z.string(), z.unknown())]),
-});
-
-type Service = z.ZodObject<{
-  id: z.ZodString;
-  type: z.ZodString;
-  serviceEndpoint: z.ZodUnion<
-    readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]
-  >;
-}, z.core.$strip>;
-
-export const didDocument: DidDocumentType = z.object({
-  id: z.string(),
-  alsoKnownAs: z.array(z.string()).optional(),
-  verificationMethod: z.array(verificationMethod).optional(),
-  service: z.array(service).optional(),
-});
-type DidDocumentType = z.ZodObject<{
-  id: z.ZodString;
-  alsoKnownAs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  verificationMethod: z.ZodOptional<z.ZodArray<VerificationMethod>>;
-  service: z.ZodOptional<z.ZodArray<Service>>;
-}, z.core.$strip>;
-
-export type DidDocument = z.infer<DidDocumentType>;
+export * from "@atp/common-web/did-doc";
diff --git a/common/mod.ts b/common/mod.ts
index eb1730f..41b2453 100644
--- a/common/mod.ts
+++ b/common/mod.ts
@@ -8,18 +8,9 @@
  *
  * @module
  */
-export * as check from "./check.ts";
-export * as util from "./util.ts";
-
+export * from "@atp/common-web";
 export * from "./ipld.ts";
 export * from "./ipld-multi.ts";
 export * from "./obfuscate.ts";
 export * from "./streams.ts";
-export * from "./async.ts";
 export * from "./types.ts";
-export * from "./tid.ts";
-export * from "./strings.ts";
-export * from "./dates.ts";
-export * from "./util.ts";
-export * from "./retry.ts";
-export * from "./did-doc.ts";
diff --git a/common/retry.ts b/common/retry.ts
index 747441c..c8be157 100644
--- a/common/retry.ts
+++ b/common/retry.ts
@@ -1,61 +1 @@
-import { wait } from "./util.ts";
-
-export type RetryOptions = {
-  maxRetries?: number;
-  getWaitMs?: (n: number) => number | null;
-};
-
-export async function retry<T>(
-  fn: () => Promise<T> | T,
-  opts: RetryOptions & {
-    retryable?: (err: unknown) => boolean;
-  } = {},
-): Promise<T> {
-  const { maxRetries = 3, retryable = () => true, getWaitMs = backoffMs } =
-    opts;
-  let retries = 0;
-  let doneError: unknown;
-  while (!doneError) {
-    try {
-      return await fn();
-    } catch (err) {
-      const waitMs = getWaitMs(retries);
-      const willRetry = retries < maxRetries && waitMs !== null &&
-        retryable(err);
-      if (willRetry) {
-        retries += 1;
-        if (waitMs !== 0) {
-          await wait(waitMs);
-        }
-      } else {
-        doneError = err;
-      }
-    }
-  }
-  throw doneError;
-}
-
-export function createRetryable(retryable: (err: unknown) => boolean): {
-  <T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
-} {
-  return <T>(fn: () => Promise<T>, opts?: RetryOptions) =>
-    retry(fn, { ...opts, retryable });
-}
-
-// Waits exponential backoff with max and jitter: ~100, ~200, ~400, ~800, ~1000, ~1000, ...
-export function backoffMs(n: number, multiplier = 100, max = 1000): number {
-  const exponentialMs = Math.pow(2, n) * multiplier;
-  const ms = Math.min(exponentialMs, max);
-  return jitter(ms);
-}
-
-// Adds randomness +/-15% of value
-function jitter(value: number) {
-  const delta = value * 0.15;
-  return value + randomRange(-delta, delta);
-}
-
-function randomRange(from: number, to: number) {
-  const rand = Math.random() * (to - from);
-  return rand + from;
-}
+export * from "@atp/common-web/retry";
diff --git a/common/strings.ts b/common/strings.ts
index 0526133..732c127 100644
--- a/common/strings.ts
+++ b/common/strings.ts
@@ -1,83 +1 @@
-// counts the number of bytes in a utf8 string
-export const utf8Len = (str: string): number => {
-  return new TextEncoder().encode(str).byteLength;
-};
-
-// counts the number of graphemes (user-displayed characters) in a string
-// Using Intl.Segmenter which is supported in Deno and modern browsers
-export const graphemeLen = (str: string): number => {
-  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
-    const segmenter = new Intl.Segmenter(undefined, {
-      granularity: "grapheme",
-    });
-    return Array.from(segmenter.segment(str)).length;
-  }
-
-  // Fallback for environments without Intl.Segmenter
-  // This is a simplified approach that handles basic cases
-  return Array.from(str).length;
-};
-
-export const utf8ToB64Url = (utf8: string): string => {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(utf8);
-  return btoa(String.fromCharCode(...bytes))
-    .replace(/\+/g, "-")
-    .replace(/\//g, "_")
-    .replace(/=/g, "");
-};
-
-export const b64UrlToUtf8 = (b64: string): string => {
-  // Convert base64url to base64
-  const base64 = b64.replace(/-/g, "+").replace(/_/g, "/");
-  // Add padding if needed
-  const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
-
-  const binaryString = atob(padded);
-  const bytes = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-
-  const decoder = new TextDecoder();
-  return decoder.decode(bytes);
-};
-
-export const parseLanguage = (langTag: string): LanguageTag | null => {
-  const parsed = langTag.match(bcp47Regexp);
-  if (!parsed?.groups) return null;
-  const parts = parsed.groups;
-  const result: LanguageTag = {};
-
-  if (parts.grandfathered) result.grandfathered = parts.grandfathered;
-  if (parts.language) result.language = parts.language;
-  if (parts.extlang) result.extlang = parts.extlang;
-  if (parts.script) result.script = parts.script;
-  if (parts.region) result.region = parts.region;
-  if (parts.variant) result.variant = parts.variant;
-  if (parts.extension) result.extension = parts.extension;
-  if (parts.privateUseA || parts.privateUseB) {
-    result.privateUse = parts.privateUseA || parts.privateUseB;
-  }
-
-  return result;
-};
-
-export const validateLanguage = (langTag: string): boolean => {
-  return bcp47Regexp.test(langTag);
-};
-
-export type LanguageTag = {
-  grandfathered?: string;
-  language?: string;
-  extlang?: string;
-  script?: string;
-  region?: string;
-  variant?: string;
-  extension?: string;
-  privateUse?: string;
-};
-
-// Validates well-formed BCP 47 syntax: https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1
-const bcp47Regexp =
-  /^((?<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 * from "@atp/common-web/strings";
diff --git a/common/tid.ts b/common/tid.ts
index c909fbc..8d06964 100644
--- a/common/tid.ts
+++ b/common/tid.ts
@@ -1,111 +1 @@
-import { s32decode, s32encode } from "./util.ts";
-
-const TID_LEN = 13;
-
-let lastTimestamp = 0;
-let timestampCount = 0;
-let clockid: number | null = null;
-
-function dedash(str: string): string {
-  return str.replaceAll("-", "");
-}
-
-export class TID {
-  str: string;
-
-  constructor(str: string) {
-    const noDashes = dedash(str);
-    if (noDashes.length !== TID_LEN) {
-      throw new Error(`Poorly formatted TID: ${noDashes.length} length`);
-    }
-    this.str = noDashes;
-  }
-
-  static next(prev?: TID): TID {
-    // javascript does not have microsecond precision
-    // instead, we append a counter to the timestamp to indicate if multiple timestamps were created within the same millisecond
-    // take max of current time & last timestamp to prevent tids moving backwards if system clock drifts backwards
-    const time = Math.max(Date.now(), lastTimestamp);
-    if (time === lastTimestamp) {
-      timestampCount++;
-    }
-    lastTimestamp = time;
-    const timestamp = time * 1000 + timestampCount;
-    // the bottom 32 clock ids can be randomized & are not guaranteed to be collision resistant
-    // we use the same clockid for all tids coming from this machine
-    if (clockid === null) {
-      clockid = Math.floor(Math.random() * 32);
-    }
-    const tid = TID.fromTime(timestamp, clockid);
-    if (!prev || tid.newerThan(prev)) {
-      return tid;
-    }
-    return TID.fromTime(prev.timestamp() + 1, clockid);
-  }
-
-  static nextStr(prev?: string): string {
-    return TID.next(prev ? new TID(prev) : undefined).toString();
-  }
-
-  static fromTime(timestamp: number, clockid: number): TID {
-    // base32 encode with encoding variant sort (s32)
-    const str = `${s32encode(timestamp)}${s32encode(clockid).padStart(2, "2")}`;
-    return new TID(str);
-  }
-
-  static fromStr(str: string): TID {
-    return new TID(str);
-  }
-
-  static oldestFirst(a: TID, b: TID): number {
-    return a.compareTo(b);
-  }
-
-  static newestFirst(a: TID, b: TID): number {
-    return b.compareTo(a);
-  }
-
-  static is(str: string): boolean {
-    return dedash(str).length === TID_LEN;
-  }
-
-  timestamp(): number {
-    return s32decode(this.str.slice(0, 11));
-  }
-
-  clockid(): number {
-    return s32decode(this.str.slice(11, 13));
-  }
-
-  formatted(): string {
-    const str = this.toString();
-    return `${str.slice(0, 4)}-${str.slice(4, 7)}-${
-      str.slice(
-        7,
-        11,
-      )
-    }-${str.slice(11, 13)}`;
-  }
-
-  toString(): string {
-    return this.str;
-  }
-
-  compareTo(other: TID): number {
-    if (this.str > other.str) return 1;
-    if (this.str < other.str) return -1;
-    return 0;
-  }
-
-  equals(other: TID): boolean {
-    return this.str === other.str;
-  }
-
-  newerThan(other: TID): boolean {
-    return this.compareTo(other) > 0;
-  }
-
-  olderThan(other: TID): boolean {
-    return this.compareTo(other) < 0;
-  }
-}
+export * from "@atp/common-web/tid";
diff --git a/common/util.ts b/common/util.ts
index 224e30b..44634ad 100644
--- a/common/util.ts
+++ b/common/util.ts
@@ -1,183 +1 @@
-export const noUndefinedVals = <T>(
-  obj: Record<string, T | undefined>,
-): Record<string, T> => {
-  Object.keys(obj).forEach((k) => {
-    if (obj[k] === undefined) {
-      delete obj[k];
-    }
-  });
-  return obj as Record<string, T>;
-};
-
-/**
- * Returns a shallow copy of the object without the specified keys. If the input
- * is nullish, it returns the input.
- */
-export function omit<
-  T extends undefined | null | Record<string, unknown>,
-  K extends keyof NonNullable<T>,
->(
-  object: T,
-  rejectedKeys: readonly K[],
-): T extends undefined ? undefined : T extends null ? null : Omit<T, K>;
-export function omit(
-  src: undefined | null | Record<string, unknown>,
-  rejectedKeys: readonly string[],
-): undefined | null | Record<string, unknown> {
-  // Hot path
-
-  if (!src) return src;
-
-  const dst: Record<string, unknown> = {};
-  const srcKeys = Object.keys(src);
-  for (let i = 0; i < srcKeys.length; i++) {
-    const key = srcKeys[i];
-    if (!rejectedKeys.includes(key)) {
-      dst[key] = src[key];
-    }
-  }
-  return dst;
-}
-
-export const jitter = (maxMs: number): number => {
-  return Math.round((Math.random() - 0.5) * maxMs * 2);
-};
-
-export const wait = (ms: number): Promise<void> => {
-  return new Promise((res) => setTimeout(res, ms));
-};
-
-export type BailableWait = {
-  bail: () => void;
-  wait: () => Promise<void>;
-};
-
-export const bailableWait = (ms: number): BailableWait => {
-  let bail!: () => void;
-  const waitPromise = new Promise<void>((res) => {
-    const timeout = setTimeout(res, ms);
-    bail = () => {
-      clearTimeout(timeout);
-      res();
-    };
-  });
-  return { bail, wait: () => waitPromise };
-};
-
-export const flattenUint8Arrays = (arrs: Uint8Array[]): Uint8Array => {
-  const length = arrs.reduce((acc, cur) => {
-    return acc + cur.length;
-  }, 0);
-  const flattened = new Uint8Array(length);
-  let offset = 0;
-  arrs.forEach((arr) => {
-    flattened.set(arr, offset);
-    offset += arr.length;
-  });
-  return flattened;
-};
-
-export const streamToUI8Array = async (
-  stream: AsyncIterable<Uint8Array>,
-): Promise<Uint8Array> => {
-  const arrays: Uint8Array[] = [];
-  for await (const chunk of stream) {
-    arrays.push(chunk);
-  }
-  return flattenUint8Arrays(arrays);
-};
-
-const S32_CHAR = "234567abcdefghijklmnopqrstuvwxyz";
-
-export const s32encode = (i: number): string => {
-  let s = "";
-  while (i) {
-    const c = i % 32;
-    i = Math.floor(i / 32);
-    s = S32_CHAR.charAt(c) + s;
-  }
-  return s;
-};
-
-export const s32decode = (s: string): number => {
-  let i = 0;
-  for (const c of s) {
-    i = i * 32 + S32_CHAR.indexOf(c);
-  }
-  return i;
-};
-
-export const asyncFilter = async <T>(
-  arr: T[],
-  fn: (t: T) => Promise<boolean>,
-): Promise<T[]> => {
-  const results = await Promise.all(arr.map((t) => fn(t)));
-  return arr.filter((_, i) => results[i]);
-};
-
-export const errHasMsg = (err: unknown, msg: string): boolean => {
-  return !!err && typeof err === "object" && "message" in err &&
-    (err as { message: unknown }).message === msg;
-};
-
-export const chunkArray = <T>(arr: T[], chunkSize: number): T[][] => {
-  return arr.reduce((acc, cur, i) => {
-    const chunkI = Math.floor(i / chunkSize);
-    if (!acc[chunkI]) {
-      acc[chunkI] = [];
-    }
-    acc[chunkI].push(cur);
-    return acc;
-  }, [] as T[][]);
-};
-
-export const range = (num: number): number[] => {
-  const nums: number[] = [];
-  for (let i = 0; i < num; i++) {
-    nums.push(i);
-  }
-  return nums;
-};
-
-export const dedupeStrs = (strs: string[]): string[] => {
-  return [...new Set(strs)];
-};
-
-export const parseIntWithFallback = <T>(
-  value: string | undefined,
-  fallback: T,
-): number | T => {
-  const parsed = parseInt(value || "", 10);
-  return isNaN(parsed) ? fallback : parsed;
-};
-
-export function ui8ToArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-  return bytes.buffer.slice(
-    bytes.byteOffset,
-    bytes.byteLength + bytes.byteOffset,
-  ) as ArrayBuffer;
-}
-
-export function keyBy<T, K extends keyof T>(
-  arr: readonly T[],
-  key: K,
-): Map<T[K], T> {
-  return arr.reduce((acc, cur) => {
-    acc.set(cur[key], cur);
-    return acc;
-  }, new Map<T[K], T>());
-}
-
-export const mapDefined = <T, S>(
-  arr: T[],
-  fn: (obj: T) => S | undefined,
-): S[] => {
-  const output: S[] = [];
-  for (const item of arr) {
-    const val = fn(item);
-    if (val !== undefined) {
-      output.push(val);
-    }
-  }
-  return output;
-};
+export * from "@atp/common-web/util";
diff --git a/deno.json b/deno.json
index 1353991..0ebb84e 100644
--- a/deno.json
+++ b/deno.json
@@ -1,5 +1,6 @@
 {
   "workspace": [
+    "common-web",
     "common",
     "bytes",
     "syntax",
diff --git a/deno.lock b/deno.lock
index c89cca5..150f214 100644
--- a/deno.lock
+++ b/deno.lock
@@ -1135,6 +1135,11 @@
           "npm:multiformats@^13.4.1"
         ]
       },
+      "common-web": {
+        "dependencies": [
+          "jsr:@zod/zod@^4.1.13"
+        ]
+      },
       "crypto": {
         "dependencies": [
           "jsr:@noble/curves@^2.0.1",
diff --git a/identity/did/atproto-data.ts b/identity/did/atproto-data.ts
index 1d834b5..c0a4c29 100644
--- a/identity/did/atproto-data.ts
+++ b/identity/did/atproto-data.ts
@@ -5,7 +5,7 @@ import {
   getNotifEndpoint,
   getPdsEndpoint,
   getSigningKey,
-} from "@atp/common";
+} from "@atp/common-web";
 import * as crypto from "@atp/crypto";
 import type { AtprotoData, DidDocument } from "../types.ts";
 
diff --git a/identity/did/base-resolver.ts b/identity/did/base-resolver.ts
index 43a5118..233683b 100644
--- a/identity/did/base-resolver.ts
+++ b/identity/did/base-resolver.ts
@@ -1,4 +1,4 @@
-import { check } from "@atp/common";
+import { check } from "@atp/common-web";
 import * as crypto from "@atp/crypto";
 import {
   DidNotFoundError,
diff --git a/identity/did/memory-cache.ts b/identity/did/memory-cache.ts
index 46b887d..43c22be 100644
--- a/identity/did/memory-cache.ts
+++ b/identity/did/memory-cache.ts
@@ -1,4 +1,4 @@
-import { DAY, HOUR } from "@atp/common";
+import { DAY, HOUR } from "@atp/common-web";
 import type { CacheResult, DidCache, DidDocument } from "../types.ts";
 
 /**
diff --git a/identity/tests/did-cache_test.ts b/identity/tests/did-cache_test.ts
index c1f48cb..c04f980 100644
--- a/identity/tests/did-cache_test.ts
+++ b/identity/tests/did-cache_test.ts
@@ -1,7 +1,7 @@
 import * as plc from "@did-plc/lib";
 import { Database as DidPlcDb, PlcServer } from "@did-plc/server";
 import getPort from "get-port";
-import { wait } from "@atp/common";
+import { wait } from "@atp/common-web";
 // deno-lint-ignore no-import-prefix no-unversioned-import
 import { Secp256k1Keypair } from "npm:@atproto/crypto";
 import { DidResolver } from "../mod.ts";
diff --git a/identity/types.ts b/identity/types.ts
index f79fff5..50a264e 100644
--- a/identity/types.ts
+++ b/identity/types.ts
@@ -1,7 +1,7 @@
-import type { DidDocument } from "@atp/common";
+import type { DidDocument } from "@atp/common-web";
 
-export { didDocument } from "@atp/common";
-export type { DidDocument } from "@atp/common";
+export { didDocument } from "@atp/common-web";
+export type { DidDocument } from "@atp/common-web";
 
 /**
  * Options for a combined handle and did resolver.