@synap-core/sdk 1.1.0 → 1.2.0

package/src/templates.ts

@@ -0,0 +1,122 @@
+/**
+ * ensureTemplate — an app asks the pod whether the template it runs on is
+ * installed, and (optionally) asks for it to be installed.
+ *
+ * TEMPLATE-LIFECYCLE Contract B. ONE door: tRPC `workspaces.ensureTemplate`
+ * (Hub REST mirror `POST /api/hub/workspaces/ensure-template`). The pod
+ * resolves the definition from the catalog and installs through its governed
+ * install door — an app NEVER sends a definition. "Installed" means an ACTIVE
+ * workspace whose `settings.packageSlug` is the slug.
+ *
+ * The result union below is HAND-WRITTEN from the contract
+ * (`TEMPLATE-LIFECYCLE/DESIGN.md`, Contract B) because the published
+ * `@synap-core/api-types` does not carry the procedure until the next regen.
+ * Once it does, `EnsureTemplateResult` should become
+ * `RouterOutputs["workspaces"]["ensureTemplate"]`.
+ *
+ * A failed call REJECTS. It is never folded into `missing`: "the pod said the
+ * template is not installed" and "we could not ask the pod" are different
+ * facts, and only the first may offer an install.
+ */
+
+export interface EnsureTemplateInput {
+  slug: string;
+  /** Ask the pod to install it when missing. */
+  install?: boolean;
+  /** One plain sentence: why the app needs it (shown on the install request). */
+  reason?: string;
+}
+
+export interface EnsureTemplateMissingTemplate {
+  slug: string;
+  name: string;
+  description: string | null;
+  icon: string | null;
+}
+
+export type EnsureTemplateResult =
+  /** Installed: an ACTIVE workspace carries the template. */
+  | { status: "installed"; workspaceId: string; version: string | null; drifted: boolean }
+  /** Not installed, and no install was asked. */
+  | { status: "missing"; template: EnsureTemplateMissingTemplate }
+  /** Install asked by an agent or app key: the governed install filed a proposal. */
+  | { status: "proposed"; proposalId: string; reviewUrl: string }
+  /** Install asked by a person: it is being installed now. */
+  | { status: "installing"; workspaceId: string }
+  /**
+   * Another live space already holds this template's domain (one space per
+   * domain), so the pod will not install a twin. The person decides what to
+   * do with that space; `guidance` is the pod's own sentence.
+   */
+  | { status: "exists"; workspaceId: string; workspaceName: string; guidance: string }
+  /** The catalog retired the template; `replacedBy` is its successor, if any. */
+  | { status: "retired"; replacedBy: string | null }
+  /** A COMPLETE catalog sync does not list the slug. */
+  | { status: "not_in_catalog" }
+  /** The pod cannot tell yet (catalog cache cold or last sync incomplete). */
+  | { status: "unknown" };
+
+export type EnsureTemplateStatus = EnsureTemplateResult["status"];
+
+/**
+ * The slice of the tRPC client this helper needs. Structural on purpose: it
+ * accepts `createSynapClient(...)` and a React `trpc.useUtils().client` alike,
+ * and keeps compiling before the procedure lands in the generated types.
+ */
+export interface EnsureTemplateClient {
+  workspaces: {
+    ensureTemplate: {
+      mutate(input: EnsureTemplateInput): Promise<unknown>;
+    };
+  };
+}
+
+export interface EnsureTemplateOptions {
+  install?: boolean;
+  reason?: string;
+}
+
+const STATUSES: ReadonlySet<string> = new Set<EnsureTemplateStatus>([
+  "installed",
+  "missing",
+  "proposed",
+  "installing",
+  "exists",
+  "retired",
+  "not_in_catalog",
+  "unknown",
+]);
+
+/**
+ * Narrow the wire answer. An answer whose `status` is not one the contract
+ * names is a protocol error and throws: guessing "missing" would offer an
+ * install the pod never said was needed.
+ */
+export function parseEnsureTemplateResult(raw: unknown): EnsureTemplateResult {
+  const status =
+    raw && typeof raw === "object" ? (raw as { status?: unknown }).status : undefined;
+  if (typeof status !== "string" || !STATUSES.has(status)) {
+    throw new Error(
+      `ensureTemplate: the pod answered with an unknown status (${String(status)}).`,
+    );
+  }
+  return raw as EnsureTemplateResult;
+}
+
+export async function ensureTemplate(
+  client: EnsureTemplateClient,
+  slug: string,
+  opts: EnsureTemplateOptions = {},
+): Promise<EnsureTemplateResult> {
+  const input: EnsureTemplateInput = { slug };
+  if (opts.install) input.install = true;
+  if (opts.reason) input.reason = opts.reason;
+  return parseEnsureTemplateResult(await client.workspaces.ensureTemplate.mutate(input));
+}
+
+/** The workspace the template lives in, when the answer names one. */
+export function ensuredWorkspaceId(result: EnsureTemplateResult): string | null {
+  return result.status === "installed" || result.status === "installing"
+    ? result.workspaceId
+    : null;
+}

package/src/testing/fixtures.ts

@@ -0,0 +1,132 @@
+/**
+ * Demo data for the mock pod. Shapes are the `@synap-core/sdk/public` wire
+ * types, so a fixture that drifts from the contract fails to compile.
+ */
+import type { PublicForm, PublicRecord, PublicShare } from "../public/client";
+
+export const MOCK_FORM: PublicForm = {
+  title: "Get in touch",
+  fields: [
+    { key: "name", label: "Name", type: "text", required: true, constraints: { maxLength: 120 } },
+    { key: "email", label: "Email", type: "email", required: true },
+    {
+      key: "topic",
+      label: "Topic",
+      type: "enum",
+      constraints: { enum: ["Sales", "Support", "Partnership"] },
+    },
+    { key: "message", label: "Message", type: "richtext", help: "A few lines is plenty." },
+  ],
+  successMessage: "Thanks — we received your message.",
+  honeypotField: "hp",
+  ticket: "mock-ticket",
+  minSubmitMs: 0,
+  captcha: { required: false },
+};
+
+export const MOCK_SHARE: PublicShare = {
+  resourceType: "entity",
+  title: "Launch notes",
+  properties: { status: "open", owner: "Ada", featured: true },
+  body: {
+    format: "markdown",
+    content: [
+      "# Launch notes",
+      "",
+      "This page is a **published snapshot** from a Synap pod.",
+      "",
+      "- Read the [Synap docs](https://synap.live)",
+      "- Links other than http, https and mailto render as plain text: [bad](javascript:alert(1))",
+      "",
+      "<script>raw HTML is shown as text, never run</script>",
+    ].join("\n"),
+  },
+  publishedOn: "2026-09-27",
+};
+
+/** One collection of a mock site: its door config and its live records. */
+export interface MockCollection {
+  /** Default sort keys (`-` = descending); also the sort keys the door accepts. */
+  sort: string[];
+  pageSize: number;
+  addressing: "slug" | "publicId";
+  records: PublicRecord[];
+}
+
+/** A mock published site. The manifest is derived from it (counts included). */
+export interface MockSite {
+  title?: string;
+  description?: string;
+  publishedOn: string;
+  collections: Record<string, MockCollection>;
+}
+
+/** A public id of the door's shape (`p_` + 16 base62), deterministic. */
+function publicId(prefix: string, n: number): string {
+  return `p_${prefix}${String(n).padStart(16 - prefix.length, "0")}`;
+}
+
+function slugify(s: string): string {
+  return s
+    .normalize("NFKD")
+    .replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 96);
+}
+
+const PAPER_TITLES = [
+  "Sparse graphs at scale",
+  "Learning to rank, revisited",
+  "A note on causal tracing",
+  "Small models, long contexts",
+  "Evaluating retrieval honestly",
+  "Robust tokenisation",
+  "Graphs that forget",
+  "Calibration under shift",
+  "Latent space cartography",
+  "Proofs as programs, again",
+  "Cheap uncertainty",
+  "Résumé of a decade",
+];
+const VENUES = ["NeurIPS", "ICML", "ACL", "ICLR"];
+
+const PAPERS: PublicRecord[] = PAPER_TITLES.map((title, i) => ({
+  collection: "paper",
+  publicId: publicId("paper", i + 1),
+  slug: slugify(title),
+  title,
+  properties: {
+    year: 2026 - (i % 5),
+    venue: VENUES[i % VENUES.length],
+    open: i % 3 !== 0,
+  },
+  publishedOn: `2026-09-${String(28 - i).padStart(2, "0")}`,
+  body: i % 4 === 3 ? null : { format: "markdown", content: `# ${title}\n\nAbstract of **${title}**.` },
+}));
+
+const PEOPLE: PublicRecord[] = ["Ada Lovelace", "Alan Turing", "Grace Hopper"].map((name, i) => ({
+  collection: "person",
+  publicId: publicId("person", i + 1),
+  slug: null,
+  title: name,
+  properties: { name, role: i === 0 ? "Lead" : "Researcher" },
+  publishedOn: "2026-09-01",
+  body: null,
+}));
+
+/**
+ * The demo site: `paper` (12 records, 5 per page, by slug: pagination),
+ * `person` (by public id), `event` (nothing published: the empty state).
+ */
+export const MOCK_SITE: MockSite = {
+  title: "Demo lab",
+  description: "What the lab publishes",
+  publishedOn: "2026-09-01",
+  collections: {
+    paper: { sort: ["-year"], pageSize: 5, addressing: "slug", records: PAPERS },
+    person: { sort: ["name"], pageSize: 20, addressing: "publicId", records: PEOPLE },
+    event: { sort: [], pageSize: 10, addressing: "slug", records: [] },
+  },
+};

package/src/testing/index.ts

@@ -0,0 +1,354 @@
+/**
+ * @synap-core/sdk/testing — a mock pod: a fake `fetch` that answers the pod's
+ * public doors (forms, shares, sites) from fixtures, with no network. Inject
+ * it into the REAL client (`createPublicClient({ podUrl, fetch: pod.fetch })`)
+ * so everything above the wire — status handling, typed errors, the models —
+ * is the production path. For unit tests, a site's mock mode and a kit's
+ * states gallery.
+ *
+ * Wire behaviour mirrors the backend doors: the uniform 404 for every miss,
+ * the constant 202 on a submit, the site doors' query bounds (400), weak
+ * ETags with If-None-Match → 304. Like a browser against the real doors, a
+ * `credentials: "include"` request is refused (it rejects, as a CORS failure
+ * does); with `{ browser: true }` a non-safelisted request header is too.
+ *
+ *   tokens MOCK_TOKENS.form / .share / .site   the demo form, share and site
+ *   tokens MOCK_FAILURE_TOKENS.*                one failure on every door
+ *   anything else                               the uniform 404
+ */
+import type {
+  PublicCollectionPage,
+  PublicForm,
+  PublicRecord,
+  PublicRecordSummary,
+  PublicShare,
+  PublicSite,
+} from "../public/client";
+import { MOCK_FORM, MOCK_SHARE, MOCK_SITE, type MockSite } from "./fixtures";
+
+export { MOCK_FORM, MOCK_SHARE, MOCK_SITE };
+export type { MockCollection, MockSite } from "./fixtures";
+
+/** A placeholder origin; never contacted. */
+export const MOCK_POD_URL = "https://mock.synap.invalid";
+
+export const MOCK_TOKENS = { form: "demo-form", share: "demo", site: "demo-site" } as const;
+
+/** The `Retry-After` the `rateLimitedRetryAfter` token sends. */
+export const MOCK_RETRY_AFTER_SEC = 30;
+
+/** Tokens that make every door answer one failure, so each UI state can be rendered. */
+export const MOCK_FAILURE_TOKENS = {
+  /** 429 with no `Retry-After` (what the pod's public doors send today). */
+  rateLimited: "mock-rate-limited",
+  /** 429 with `Retry-After: 30`. */
+  rateLimitedRetryAfter: "mock-rate-limited-retry-after",
+  /** 403 `public_doors_disabled`: the owner switched public pages off. */
+  doorsDisabled: "mock-doors-disabled",
+  /** 500. */
+  serverError: "mock-server-error",
+  /** 503 (a read: `pod_unreachable` / `server`; a submit: `unavailable`). */
+  unavailable: "mock-unavailable",
+  /** No answer: the fetch rejects (`network` / `pod_unreachable`). */
+  unreachable: "mock-unreachable",
+} as const;
+
+export interface MockPodOptions {
+  /** Forms by token (default: the demo form under `MOCK_TOKENS.form`). */
+  forms?: Record<string, PublicForm>;
+  /** Shares by token (default: the demo share under `MOCK_TOKENS.share`). */
+  shares?: Record<string, PublicShare>;
+  /** Sites by token (default: the demo site under `MOCK_TOKENS.site`). */
+  sites?: Record<string, MockSite>;
+  /** Refuse non-safelisted request headers, as a browser's CORS preflight would. */
+  browser?: boolean;
+}
+
+export interface MockRequest {
+  method: string;
+  url: string;
+  /** Lower-cased header names. */
+  headers: Record<string, string>;
+  credentials: RequestCredentials | undefined;
+}
+
+export interface MockSubmission {
+  token: string;
+  /** The parsed envelope (`fields`, `ticket`, `hp`, …). */
+  body: unknown;
+  /** The answer the mock gave. */
+  status: 202 | 422;
+}
+
+export interface MockPod {
+  podUrl: string;
+  fetch: typeof fetch;
+  /** Every request seen, in order (assert credentials and headers on it). */
+  requests: MockRequest[];
+  /** Every submit seen, in order. */
+  submissions: MockSubmission[];
+  /** Forget `requests` and `submissions`. */
+  reset(): void;
+}
+
+const NOT_FOUND = { error: "Not found" };
+const DOORS_DISABLED = {
+  error: "The owner has not turned on public pages and forms for this workspace.",
+  code: "public_doors_disabled",
+};
+/** Request headers a browser sends cross-origin without a preflight. */
+const SAFELISTED = new Set(["accept", "accept-language", "content-language", "content-type"]);
+/** The only request header the real doors allow on a preflight. */
+const PREFLIGHT_ALLOWED = new Set(["content-type"]);
+
+const PUBLIC_ID_RE = /^p_[A-Za-z0-9]{16}$/;
+const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const SLUG_MAX_LENGTH = 96;
+const DIGITS = /^\d{1,9}$/;
+const SORT_TERM = /^(-?)([A-Za-z][A-Za-z0-9_]{0,63})$/;
+const MAX_OFFSET = 10_000;
+const MAX_LIMIT = 100;
+const MAX_SORT_KEYS = 3;
+const PUBLISHED_AT = "publishedAt";
+
+function json(status: number, body: unknown, headers: Record<string, string> = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json", "Cache-Control": "no-cache", ...headers },
+  });
+}
+
+/** FNV-1a, 32 bits: a stable weak validator, no crypto needed. */
+function weakEtag(value: unknown): string {
+  let h = 0x811c9dc5;
+  for (const ch of JSON.stringify(value)) {
+    h ^= ch.charCodeAt(0);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return `W/"${h.toString(16).padStart(8, "0")}"`;
+}
+
+function etagMatches(header: string | null, etag: string): boolean {
+  if (!header) return false;
+  if (header.trim() === "*") return true;
+  const strip = (t: string) => t.trim().replace(/^W\//, "");
+  return header.split(",").some((t) => strip(t) === strip(etag));
+}
+
+function failure(token: string): Response | "reject" | null {
+  switch (token) {
+    case MOCK_FAILURE_TOKENS.rateLimited:
+      return json(429, { error: "Too many requests", retryAfter: "5 minutes" });
+    case MOCK_FAILURE_TOKENS.rateLimitedRetryAfter:
+      return json(429, { error: "Too many requests" }, { "Retry-After": String(MOCK_RETRY_AFTER_SEC) });
+    case MOCK_FAILURE_TOKENS.doorsDisabled:
+      return json(403, DOORS_DISABLED);
+    case MOCK_FAILURE_TOKENS.serverError:
+      return json(500, { error: "Internal error" });
+    case MOCK_FAILURE_TOKENS.unavailable:
+      return json(503, { received: false });
+    case MOCK_FAILURE_TOKENS.unreachable:
+      return "reject";
+    default:
+      return null;
+  }
+}
+
+function summary(record: PublicRecord): PublicRecordSummary {
+  const { body: _body, ...rest } = record;
+  return rest;
+}
+
+function manifest(site: MockSite): PublicSite {
+  return {
+    ...(site.title !== undefined ? { title: site.title } : {}),
+    ...(site.description !== undefined ? { description: site.description } : {}),
+    publishedOn: site.publishedOn,
+    collections: Object.keys(site.collections)
+      .sort()
+      .map((key) => {
+        const c = site.collections[key];
+        return { key, count: c.records.length, sort: [...c.sort], pageSize: c.pageSize, addressing: c.addressing };
+      }),
+  };
+}
+
+type Sort = Array<{ key: string; desc: boolean }>;
+
+/** The door's `parseCollectionQuery`: the same bounds, the same 400s. */
+function parseQuery(params: URLSearchParams, c: { sort: string[]; pageSize: number }): { offset: number; limit: number; sort: Sort } | string {
+  for (const name of params.keys()) {
+    if (name === "embed") return "embed is not available";
+    if (name === "ref" || name.startsWith("ref[")) return "ref filter is not available";
+  }
+  const one = (name: string): string | undefined | null => {
+    const all = params.getAll(name);
+    return all.length === 0 ? undefined : all.length === 1 ? all[0] : null;
+  };
+  const rawOffset = one("offset");
+  if (rawOffset === null || (rawOffset !== undefined && !DIGITS.test(rawOffset))) return "invalid offset";
+  const offset = rawOffset === undefined ? 0 : Number(rawOffset);
+  if (offset > MAX_OFFSET) return "offset too large";
+  const rawLimit = one("limit");
+  if (rawLimit === null || (rawLimit !== undefined && !DIGITS.test(rawLimit))) return "invalid limit";
+  const limit = Math.min(MAX_LIMIT, Math.max(1, rawLimit === undefined ? c.pageSize : Number(rawLimit)));
+  const rawSort = one("sort");
+  if (rawSort === null) return "invalid sort";
+  const terms =
+    rawSort !== undefined ? rawSort.split(",") : c.sort.length > 0 ? [...c.sort] : [`-${PUBLISHED_AT}`];
+  if (terms.length > MAX_SORT_KEYS) return "invalid sort";
+  const allowed = new Set([PUBLISHED_AT, ...c.sort.map((s) => s.replace(/^-/, ""))]);
+  const sort: Sort = [];
+  for (const term of terms) {
+    const m = SORT_TERM.exec(term);
+    if (!m || !allowed.has(m[2]) || sort.some((s) => s.key === m[2])) return "invalid sort";
+    sort.push({ key: m[2], desc: m[1] === "-" });
+  }
+  return { offset, limit, sort };
+}
+
+/** jsonb-like order within a type (strings < numbers < booleans); a missing value sorts last. */
+function compareRecords(sort: Sort) {
+  const rank = (v: unknown) => (typeof v === "string" ? 0 : typeof v === "number" ? 1 : 2);
+  const valueOf = (r: PublicRecord, key: string) => (key === PUBLISHED_AT ? r.publishedOn : r.properties[key]);
+  return (a: PublicRecord, b: PublicRecord): number => {
+    for (const { key, desc } of sort) {
+      const va = valueOf(a, key);
+      const vb = valueOf(b, key);
+      if (va === undefined || vb === undefined) {
+        if (va !== vb) return va === undefined ? 1 : -1;
+        continue;
+      }
+      let d = rank(va) - rank(vb);
+      if (d === 0) d = va < vb ? -1 : va > vb ? 1 : 0;
+      if (d !== 0) return desc ? -d : d;
+    }
+    if (a.publishedOn !== b.publishedOn) return a.publishedOn < b.publishedOn ? 1 : -1;
+    return a.publicId < b.publicId ? -1 : a.publicId > b.publicId ? 1 : 0;
+  };
+}
+
+/** 200 with a weak ETag, or 304 when If-None-Match already holds it. */
+function cached(view: unknown, ifNoneMatch: string | null): Response {
+  const etag = weakEtag(view);
+  if (etagMatches(ifNoneMatch, etag)) {
+    return new Response(null, { status: 304, headers: { ETag: etag, "Cache-Control": "no-cache" } });
+  }
+  return json(200, view, { ETag: etag });
+}
+
+function siteDoor(site: MockSite, rest: string[], params: URLSearchParams, ifNoneMatch: string | null): Response {
+  if (rest.length === 0) return cached(manifest(site), ifNoneMatch);
+  if (rest[0] !== "collections" || rest.length > 3 || !Object.hasOwn(site.collections, rest[1])) {
+    return json(404, NOT_FOUND);
+  }
+  const c = site.collections[rest[1]];
+  if (rest.length === 2) {
+    const q = parseQuery(params, c);
+    if (typeof q === "string") return json(400, { error: q });
+    const sorted = [...c.records].sort(compareRecords(q.sort));
+    const page: PublicCollectionPage = {
+      items: sorted.slice(q.offset, q.offset + q.limit).map(summary),
+      total: sorted.length,
+      offset: q.offset,
+      limit: q.limit,
+    };
+    return cached(page, ifNoneMatch);
+  }
+  const address = rest[2];
+  const byPublicId = PUBLIC_ID_RE.test(address);
+  if (!byPublicId && !(address.length <= SLUG_MAX_LENGTH && SLUG_RE.test(address))) return json(404, NOT_FOUND);
+  const record = c.records.find((r) => (byPublicId ? r.publicId === address : r.slug === address));
+  if (!record) return json(404, NOT_FOUND);
+  if (params.has("embed")) return json(400, { error: "embed is not available" });
+  return cached(record, ifNoneMatch);
+}
+
+/** The door's 422 for answers that do not satisfy the form (required, enum). */
+function invalidKeys(form: PublicForm, body: unknown): string[] {
+  const fields = (body as { fields?: unknown } | null)?.fields;
+  if (typeof fields !== "object" || fields === null) return [];
+  const answers = fields as Record<string, unknown>;
+  return form.fields
+    .filter((f) => {
+      const v = answers[f.key];
+      if (v === undefined || v === "" || v === null) return f.required === true;
+      if (f.type === "boolean") return typeof v !== "boolean" || (f.required === true && v !== true);
+      const allowed = f.constraints?.enum;
+      return allowed !== undefined && !allowed.includes(String(v));
+    })
+    .map((f) => f.key);
+}
+
+export function createMockPod(options: MockPodOptions = {}): MockPod {
+  const forms = options.forms ?? { [MOCK_TOKENS.form]: MOCK_FORM };
+  const shares = options.shares ?? { [MOCK_TOKENS.share]: MOCK_SHARE };
+  const sites = options.sites ?? { [MOCK_TOKENS.site]: MOCK_SITE };
+  const requests: MockRequest[] = [];
+  const submissions: MockSubmission[] = [];
+
+  const mockFetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const request = typeof input === "object" && "method" in input ? input : null;
+    const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+    const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+    const headers: Record<string, string> = {};
+    new Headers(init?.headers ?? request?.headers).forEach((value, name) => {
+      headers[name.toLowerCase()] = value;
+    });
+    const credentials = init?.credentials ?? request?.credentials;
+    requests.push({ method, url: url.href, headers, credentials });
+
+    // What a browser does against the real doors (`Access-Control-Allow-Origin: *`).
+    if (credentials === "include") throw new TypeError("Failed to fetch: credentialed request to a public door");
+    if (options.browser) {
+      const preflighted = Object.keys(headers).filter((h) => !SAFELISTED.has(h) && !PREFLIGHT_ALLOWED.has(h));
+      if (preflighted.length > 0) throw new TypeError(`Failed to fetch: preflight refuses ${preflighted.join(", ")}`);
+    }
+
+    const m = url.pathname.match(/^\/api\/hub\/public\/(forms|shares|sites)\/(.+)$/);
+    if (!m) return json(404, NOT_FOUND);
+    let segments: string[];
+    try {
+      segments = m[2].split("/").map(decodeURIComponent);
+    } catch {
+      return json(404, NOT_FOUND);
+    }
+    const [token, ...rest] = segments;
+    const failed = failure(token);
+    if (failed === "reject") throw new TypeError("Failed to fetch: mock pod unreachable");
+    if (failed) return failed;
+
+    const door = m[1];
+    if (door === "forms" && method === "POST" && rest.length === 0) {
+      let body: unknown = null;
+      try {
+        body = JSON.parse(typeof init?.body === "string" ? init.body : "null");
+      } catch {
+        body = null;
+      }
+      const form = Object.hasOwn(forms, token) ? forms[token] : undefined;
+      const invalid = form ? invalidKeys(form, body) : [];
+      const status = invalid.length > 0 ? 422 : 202;
+      submissions.push({ token, body, status });
+      return status === 422 ? json(422, { received: false, invalid }) : json(202, { received: true });
+    }
+    if (method !== "GET") return json(404, NOT_FOUND);
+    if (door === "forms" && rest.length === 0 && Object.hasOwn(forms, token)) return json(200, forms[token]);
+    if (door === "shares" && rest.length === 0 && Object.hasOwn(shares, token)) return json(200, shares[token]);
+    if (door === "sites" && Object.hasOwn(sites, token)) {
+      return siteDoor(sites[token], rest, url.searchParams, headers["if-none-match"] ?? null);
+    }
+    return json(404, NOT_FOUND);
+  };
+
+  return {
+    podUrl: MOCK_POD_URL,
+    fetch: mockFetch as typeof fetch,
+    requests,
+    submissions,
+    reset() {
+      requests.length = 0;
+      submissions.length = 0;
+    },
+  };
+}