@nymbalhq/contract-tests 0.0.0-stage → 1.2.0

package/dist/index.js

@@ -0,0 +1,2674 @@
+import {
+  CONTRACT_KINDS
+} from "./chunk-ABEL44IM.js";
+
+// src/ai.ts
+import { describe as describe2, expect as expect2, it as it2 } from "vitest";
+
+// src/common.ts
+import { describe, expect, it } from "vitest";
+var BOUND_MS = 6e3;
+var CASE_MS = 3e4;
+async function settle(call, ms = BOUND_MS) {
+  const started = Date.now();
+  let timer;
+  const hung = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ state: "hung" }), ms);
+  });
+  try {
+    const outcome = await Promise.race([
+      Promise.resolve().then(call).then(
+        (value) => ({ state: "resolved", value }),
+        (error) => ({ state: "rejected", error })
+      ),
+      hung
+    ]);
+    return { ...outcome, ms: Date.now() - started };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function release(target) {
+  const close = target?.close;
+  if (typeof close !== "function") return;
+  let timer;
+  await Promise.race([
+    Promise.resolve().then(() => close.call(target)).catch(() => void 0),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, 5e3);
+    })
+  ]);
+  clearTimeout(timer);
+}
+function healthOf(target) {
+  expect(
+    typeof target.healthCheck,
+    "healthCheck() is missing: certification needs it, though the type keeps it optional"
+  ).toBe("function");
+  return settle(() => target.healthCheck());
+}
+async function expectHealthy(target) {
+  const health = await healthOf(target);
+  expect(health.state, `healthCheck() did not resolve within ${BOUND_MS} ms`).toBe("resolved");
+  const status = health.state === "resolved" ? health.value?.status : void 0;
+  expect(["healthy", "degraded"], `healthCheck() reported ${String(status)}`).toContain(status);
+}
+async function expectDown(target) {
+  const health = await healthOf(target);
+  expect(health.state, `healthCheck() did not resolve within ${BOUND_MS} ms`).toBe("resolved");
+  expect(health.state === "resolved" ? health.value?.status : void 0).toBe("down");
+}
+async function expectRejects(call) {
+  const outcome = await settle(call);
+  expect(
+    outcome.state,
+    outcome.state === "hung" ? `still pending after ${BOUND_MS} ms` : "it succeeded"
+  ).toBe("rejected");
+}
+async function using(build, body) {
+  const adapter = await build();
+  try {
+    return await body(adapter);
+  } finally {
+    await release(adapter);
+  }
+}
+function healthAndDowntime(build, unreachable, label, operation) {
+  it(
+    "health: healthCheck() resolves healthy or degraded within 6 s",
+    () => using(build, (adapter) => expectHealthy(adapter)),
+    CASE_MS
+  );
+  if (unreachable === void 0) return;
+  describe("unreachable dependency", () => {
+    it(
+      "down: healthCheck() reports down within 6 s",
+      () => using(unreachable, (adapter) => expectDown(adapter)),
+      CASE_MS
+    );
+    it(
+      `down: ${label} rejects within 6 s instead of hanging`,
+      () => using(unreachable, (adapter) => expectRejects(() => operation(adapter))),
+      CASE_MS
+    );
+  });
+}
+
+// src/ai.ts
+function runAiContract(name, build, options = {}) {
+  describe2(`AiAdapter contract: ${name}`, () => {
+    it2(
+      "embed returns embedding vectors with correct dimensions",
+      async () => {
+        const adapter = await build();
+        const embeddings = await adapter.embed(["hello world", "test text"]);
+        expect2(Array.isArray(embeddings)).toBe(true);
+        expect2(embeddings).toHaveLength(2);
+        expect2(Array.isArray(embeddings[0])).toBe(true);
+        expect2((embeddings[0] ?? []).length).toBeGreaterThan(0);
+      },
+      CASE_MS
+    );
+    it2(
+      "complete returns a non-empty string",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.complete("Write one word: hello", { maxTokens: 10 });
+        expect2(typeof result).toBe("string");
+        expect2(result.length).toBeGreaterThan(0);
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "complete()",
+      (adapter) => adapter.complete("Write one word: hello", { maxTokens: 10 })
+    );
+  });
+}
+
+// src/analytics.ts
+import { describe as describe3, expect as expect3, it as it3 } from "vitest";
+function runAnalyticsContract(name, build, options = {}) {
+  describe3(`AnalyticsAdapter contract: ${name}`, () => {
+    it3(
+      "track resolves without throwing",
+      async () => {
+        const adapter = await build();
+        await expect3(
+          adapter.track("product_viewed", { productId: "prod-1", source: "test" })
+        ).resolves.not.toThrow();
+      },
+      CASE_MS
+    );
+    it3(
+      "identify resolves without throwing",
+      async () => {
+        const adapter = await build();
+        await expect3(
+          adapter.identify("user-1", { email: "test@example.com", plan: "free" })
+        ).resolves.not.toThrow();
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "track()",
+      (adapter) => adapter.track("product_viewed", { productId: "prod-1", source: "contract-down" })
+    );
+  });
+}
+
+// src/document-store.ts
+import { describe as describe5, expect as expect6, it as it6 } from "vitest";
+
+// src/document-store-model.ts
+import fc from "fast-check";
+import { describe as describe4, expect as expect4, it as it4 } from "vitest";
+import {
+  compareDocumentValues,
+  matchesSortKey
+} from "@nymbalhq/types";
+var COLLECTION = "contract-docs";
+var DECOY = "contract-decoy";
+var SLOW = 6e4;
+var valueArb = fc.oneof(
+  fc.constantFrom("a", "A", "\xE1", "b", "B", "\xE9", "e", "ab", "Ab", "1", "10", "2"),
+  fc.integer({ min: -2, max: 10 }),
+  fc.constant(null)
+);
+var fieldArb = fc.option(valueArb, { nil: void 0, freq: 4 });
+var docsArb = (minLength) => fc.uniqueArray(
+  fc.record({
+    // Random keys, so key order is unrelated to value order.
+    key: fc.stringMatching(/^[a-z0-9]{1,6}$/),
+    part: fc.constantFrom("p", "q"),
+    v: fieldArb,
+    n: fieldArb
+  }),
+  { minLength, maxLength: 14, selector: (d) => d.key }
+);
+var sortKeyArb = fc.option(
+  fc.oneof(
+    fc.record({
+      field: fc.constant("v"),
+      operator: fc.constantFrom("eq", "gt", "lt"),
+      value: valueArb
+    }),
+    fc.record({
+      field: fc.constant("v"),
+      operator: fc.constant("between"),
+      value: fc.tuple(valueArb, valueArb)
+    })
+  ),
+  { nil: void 0 }
+);
+var orderByArb = fc.record({
+  field: fc.constantFrom("v", "nested.v"),
+  direction: fc.constantFrom("asc", "desc")
+});
+function stored(g) {
+  return {
+    id: g.key,
+    part: g.part,
+    ...g.v !== void 0 && { v: g.v },
+    nested: g.n !== void 0 ? { v: g.n } : {},
+    label: "\xDCn\xEFc\xF6d\xE9 \u2713"
+  };
+}
+function valueAt(doc, path) {
+  let value = doc;
+  for (const part of path.split(".")) {
+    if (value === null || typeof value !== "object") return void 0;
+    value = value[part];
+  }
+  return value;
+}
+var nullish = (v) => v === null || v === void 0;
+function reference(docs, q) {
+  const hits = docs.filter(
+    (d) => (q.partition === "*" || d.part === q.partition) && (q.sortKey === void 0 || matchesSortKey(d.v, q.sortKey))
+  );
+  const { orderBy } = q;
+  if (orderBy === void 0) return hits.map((d) => d.id).sort();
+  return hits.sort((a, b) => {
+    const x = valueAt(a, orderBy.field);
+    const y = valueAt(b, orderBy.field);
+    if (nullish(x) !== nullish(y)) return nullish(x) ? 1 : -1;
+    let c = nullish(x) ? 0 : compareDocumentValues(x, y);
+    if (orderBy.direction === "desc") c = -c;
+    if (c !== 0) return c;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  }).map((d) => d.id);
+}
+function params(q, limit, cursor) {
+  return {
+    partitionKey: { field: "part", value: q.partition },
+    ...q.sortKey !== void 0 && { sortKey: q.sortKey },
+    ...q.orderBy !== void 0 && { orderBy: { ...q.orderBy, nulls: "last" } },
+    limit,
+    ...cursor !== void 0 && { cursor }
+  };
+}
+async function walk(store, q, limit, maxPages, between) {
+  const pages = [];
+  let cursor;
+  do {
+    const page = await store.query(COLLECTION, params(q, limit, cursor));
+    pages.push(page.items);
+    cursor = page.nextCursor ?? void 0;
+    if (between !== void 0) await between(pages.length);
+  } while (cursor !== void 0 && pages.length <= maxPages);
+  return { pages, ended: cursor === void 0 };
+}
+var idsOf = (docs) => docs.map((d) => d.id);
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+function withoutTrailingEmpty(pages) {
+  return pages.length > 0 && pages[pages.length - 1].length === 0 ? pages.slice(0, -1) : pages;
+}
+async function storeWith(make, generated) {
+  const store = await make();
+  const docs = generated.map(stored);
+  for (const doc of docs) await store.put(COLLECTION, doc.id, doc);
+  for (const doc of docs.slice(0, 3)) {
+    await store.put(DECOY, doc.id, { ...doc, label: "decoy" });
+  }
+  return { store, docs };
+}
+async function closing(store, body) {
+  try {
+    return await body();
+  } finally {
+    await store.close();
+  }
+}
+async function rejection(promise) {
+  return promise.then(
+    () => null,
+    (error) => error ?? new Error("rejected with nothing")
+  );
+}
+var TTL_SECONDS = 1;
+function documentStoreModelCases(make, opts) {
+  describe4("agrees with the reference model", () => {
+    it4(
+      "every query\u2019s page sequence equals the reference: filter by partition and sortKey, order with nulls last and ties by key, slice by limit",
+      async () => {
+        await fc.assert(
+          fc.asyncProperty(
+            docsArb(0),
+            fc.constantFrom("p", "*"),
+            sortKeyArb,
+            orderByArb,
+            fc.integer({ min: 1, max: 5 }),
+            async (generated, partition, sortKey, orderBy, limit) => {
+              const { store, docs } = await storeWith(make, generated);
+              await closing(store, async () => {
+                const q = { partition, sortKey, orderBy };
+                const expected = reference(docs, q);
+                const { pages, ended } = await walk(store, q, limit, docs.length + 2);
+                expect4(ended, "the cursor walk never ended").toBe(true);
+                for (const page of pages) expect4(page.length).toBeLessThanOrEqual(limit);
+                expect4(withoutTrailingEmpty(pages.map(idsOf))).toEqual(chunk(expected, limit));
+                const byId = new Map(docs.map((d) => [d.id, d]));
+                for (const item of pages.flat()) expect4(item).toEqual(byId.get(item.id));
+              });
+            }
+          ),
+          { numRuns: 50 }
+        );
+      },
+      SLOW
+    );
+    it4(
+      "without orderBy, a cursor walk returns exactly the reference\u2019s matches, each once",
+      async () => {
+        await fc.assert(
+          fc.asyncProperty(
+            docsArb(0),
+            fc.constantFrom("p", "*"),
+            sortKeyArb,
+            fc.integer({ min: 1, max: 5 }),
+            async (generated, partition, sortKey, limit) => {
+              const { store, docs } = await storeWith(make, generated);
+              await closing(store, async () => {
+                const q = { partition, sortKey, orderBy: void 0 };
+                const { pages, ended } = await walk(store, q, limit, docs.length + 2);
+                const walked = idsOf(pages.flat());
+                expect4(ended, "the cursor walk never ended").toBe(true);
+                expect4(walked.length, `duplicates in ${walked.join(",")}`).toBe(
+                  new Set(walked).size
+                );
+                expect4([...walked].sort()).toEqual(reference(docs, q));
+              });
+            }
+          ),
+          { numRuns: 40 }
+        );
+      },
+      SLOW
+    );
+    it4(
+      "a cursor walk across a mid-walk delete returns every remaining match exactly once, in the reference order",
+      async () => {
+        await fc.assert(
+          fc.asyncProperty(
+            docsArb(3),
+            fc.option(orderByArb, { nil: void 0 }),
+            fc.integer({ min: 1, max: 3 }),
+            fc.nat(),
+            async (generated, orderBy, limit, pick) => {
+              const { store, docs } = await storeWith(make, generated);
+              await closing(store, async () => {
+                const q = { partition: "*", sortKey: void 0, orderBy };
+                const expected = reference(docs, q);
+                fc.pre(expected.length > limit);
+                const deleted = expected[pick % expected.length];
+                const { pages, ended } = await walk(store, q, limit, docs.length + 2, async (n) => {
+                  if (n === 1) await store.delete(COLLECTION, deleted);
+                });
+                const walked = idsOf(pages.flat());
+                expect4(ended, "the cursor walk never ended").toBe(true);
+                expect4(walked.length, `duplicates in ${walked.join(",")}`).toBe(
+                  new Set(walked).size
+                );
+                expect4(walked.filter((id) => !expected.includes(id))).toEqual([]);
+                expect4(expected.filter((id) => id !== deleted && !walked.includes(id))).toEqual([]);
+                if (orderBy !== void 0) {
+                  expect4(walked).toEqual(expected.filter((id) => walked.includes(id)));
+                }
+              });
+            }
+          ),
+          { numRuns: 50 }
+        );
+      },
+      SLOW
+    );
+    it4(
+      "a cursor issued under one orderBy is refused under another, and continues the walk under its own",
+      async () => {
+        const generated = ["k1", "k2", "k3", "k4", "k5"].map((key, i) => ({
+          key,
+          part: "p",
+          v: 5 - i,
+          n: i
+        }));
+        const { store, docs } = await storeWith(make, generated);
+        await closing(store, async () => {
+          const asc = {
+            partition: "p",
+            sortKey: void 0,
+            orderBy: { field: "v", direction: "asc" }
+          };
+          const first = await store.query(COLLECTION, params(asc, 2));
+          expect4(first.nextCursor).not.toBeNull();
+          const cursor = first.nextCursor;
+          const otherDirection = { ...asc, orderBy: { field: "v", direction: "desc" } };
+          const otherField = { ...asc, orderBy: { field: "nested.v", direction: "asc" } };
+          expect4(
+            await rejection(store.query(COLLECTION, params(otherDirection, 2, cursor)))
+          ).toBeInstanceOf(Error);
+          expect4(
+            await rejection(store.query(COLLECTION, params(otherField, 2, cursor)))
+          ).toBeInstanceOf(Error);
+          const next = await store.query(COLLECTION, params(asc, 2, cursor));
+          expect4(idsOf(next.items)).toEqual(reference(docs, asc).slice(2, 4));
+        });
+      },
+      SLOW
+    );
+    it4(
+      "a document put with a TTL is returned until it expires, then by no get, query or batchGet; one put without stays",
+      async () => {
+        const store = await make();
+        await closing(store, async () => {
+          const short = { id: "short", part: "p", nested: {}, label: "ttl" };
+          const long = { id: "long", part: "p", nested: {}, label: "no ttl" };
+          const putAt = Date.now();
+          await store.put(COLLECTION, short.id, short, { ttl: TTL_SECONDS });
+          await store.put(COLLECTION, long.id, long);
+          expect4(await store.get(COLLECTION, short.id)).toEqual(short);
+          if (opts.clock !== void 0) {
+            await opts.clock.advance(TTL_SECONDS * 1e3 - 1);
+            expect4(await store.get(COLLECTION, short.id)).toEqual(short);
+            await opts.clock.advance(2);
+          } else {
+            const deadline = putAt + TTL_SECONDS * 1e3 + 3e3;
+            while (await store.get(COLLECTION, short.id) !== null && Date.now() < deadline) {
+              await new Promise((r) => setTimeout(r, 25));
+            }
+            expect4(Date.now() - putAt, "expired before its TTL").toBeGreaterThanOrEqual(
+              TTL_SECONDS * 1e3 - 100
+            );
+          }
+          expect4(await store.get(COLLECTION, short.id)).toBeNull();
+          const all = await store.query(COLLECTION, {
+            partitionKey: { field: "part", value: "*" },
+            limit: 100
+          });
+          expect4(idsOf(all.items)).toEqual([long.id]);
+          const batch = await store.batchGet(COLLECTION, [short.id, long.id]);
+          expect4([...batch.keys()]).toEqual([long.id]);
+        });
+      },
+      SLOW
+    );
+    it4("a conditional put applies when the field matches, and otherwise fails condition-failed and changes nothing", async () => {
+      const store = await make();
+      await closing(store, async () => {
+        const v1 = {
+          id: "c",
+          part: "p",
+          nested: {},
+          label: "v1",
+          version: 1
+        };
+        const v2 = { ...v1, label: "v2", version: 2 };
+        await store.put(COLLECTION, "c", v1);
+        await store.put(COLLECTION, "c", v2, { conditionKey: "version", conditionValue: 1 });
+        expect4(await store.get(COLLECTION, "c")).toEqual(v2);
+        const stale = await rejection(
+          store.put(
+            COLLECTION,
+            "c",
+            { ...v1, label: "v3", version: 3 },
+            { conditionKey: "version", conditionValue: 1 }
+          )
+        );
+        expect4(stale?.code).toBe("adapter.condition-failed");
+        expect4(await store.get(COLLECTION, "c")).toEqual(v2);
+        const absent = await rejection(
+          store.put(COLLECTION, "none", v1, { conditionKey: "version", conditionValue: 1 })
+        );
+        expect4(absent?.code).toBe("adapter.condition-failed");
+        expect4(await store.get(COLLECTION, "none")).toBeNull();
+      });
+    }, CASE_MS);
+    it4(
+      "batchPut stores every item and batchGet returns exactly the stored keys, equal to what was put",
+      async () => {
+        await fc.assert(
+          fc.asyncProperty(docsArb(1), async (generated) => {
+            const store = await make();
+            await closing(store, async () => {
+              const docs = generated.map(stored);
+              await store.batchPut(COLLECTION, new Map(docs.map((d) => [d.id, d])));
+              const asked = [...docs.map((d) => d.id), "contract-absent"];
+              const got = await store.batchGet(COLLECTION, asked);
+              expect4(got.size).toBe(docs.length);
+              for (const doc of docs) {
+                expect4(got.get(doc.id)).toEqual(doc);
+                expect4(await store.get(COLLECTION, doc.id)).toEqual(doc);
+              }
+            });
+          }),
+          { numRuns: 15 }
+        );
+      },
+      SLOW
+    );
+    it4("collections are isolated for get, query and delete", async () => {
+      const store = await make();
+      await closing(store, async () => {
+        const a = { id: "same", part: "p", nested: {}, label: "A" };
+        const b = { ...a, label: "B" };
+        const onlyA = { ...a, id: "only-a" };
+        await store.put("contract-col-a", a.id, a);
+        await store.put("contract-col-a", onlyA.id, onlyA);
+        await store.put("contract-col-b", b.id, b);
+        expect4(await store.get("contract-col-a", "same")).toEqual(a);
+        expect4(await store.get("contract-col-b", "same")).toEqual(b);
+        const inB = await store.query("contract-col-b", {
+          partitionKey: { field: "part", value: "*" },
+          limit: 100
+        });
+        expect4(idsOf(inB.items)).toEqual([b.id]);
+        await store.delete("contract-col-a", "same");
+        expect4(await store.get("contract-col-b", "same")).toEqual(b);
+        expect4(await store.get("contract-col-a", "only-a")).toEqual(onlyA);
+      });
+    }, CASE_MS);
+    if (opts.isolation !== void 0) {
+      const isolation = opts.isolation;
+      it4("two instances with different prefixes never see each other\u2019s documents", async () => {
+        const [one, two] = await isolation();
+        try {
+          const mine = { id: "shared-key", part: "p", nested: {}, label: "one" };
+          const theirs = { ...mine, label: "two" };
+          await one.put(COLLECTION, mine.id, mine);
+          await one.put(COLLECTION, "one-only", { ...mine, id: "one-only" });
+          await two.put(COLLECTION, theirs.id, theirs);
+          expect4(await one.get(COLLECTION, mine.id)).toEqual(mine);
+          expect4(await two.get(COLLECTION, theirs.id)).toEqual(theirs);
+          expect4(await two.get(COLLECTION, "one-only")).toBeNull();
+          const inTwo = await two.query(COLLECTION, {
+            partitionKey: { field: "part", value: "*" },
+            limit: 100
+          });
+          expect4(idsOf(inTwo.items)).toEqual([theirs.id]);
+          const batch = await two.batchGet(COLLECTION, [mine.id, "one-only"]);
+          expect4([...batch.values()]).toEqual([theirs]);
+          await one.delete(COLLECTION, mine.id);
+          expect4(await two.get(COLLECTION, theirs.id)).toEqual(theirs);
+        } finally {
+          await one.close();
+          await two.close();
+        }
+      }, CASE_MS);
+    }
+  });
+}
+
+// src/document-store-replace.ts
+import fc2 from "fast-check";
+import { expect as expect5, it as it5 } from "vitest";
+var SLOW2 = 6e4;
+var KEYS = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var macrotask = () => new Promise((resolve) => setImmediate(resolve));
+async function* entriesOf(docs, pause = false) {
+  for (const doc of docs) {
+    if (pause) await macrotask();
+    yield [doc.id, doc];
+  }
+}
+async function snapshot(store, collection) {
+  const all = await store.query(collection, { partitionKey: { field: "part", value: "*" } });
+  return all.items.map((d) => `${d.id}:${d.v}`);
+}
+var shape = (docs) => [...docs].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((d) => `${d.id}:${d.v}`);
+async function putAll(store, collection, docs) {
+  for (const doc of docs) await store.put(collection, doc.id, doc);
+}
+var docsFrom = (keys, v) => keys.map((id) => ({ id, part: "p", v }));
+function documentStoreReplaceCases(make, opts) {
+  it5(
+    "replaceCollection leaves exactly the new set, whatever the old and new sets: no stale key of the old set survives, and another collection is untouched (property)",
+    async () => {
+      await using(make, async (store) => {
+        let run = 0;
+        await fc2.assert(
+          fc2.asyncProperty(
+            fc2.uniqueArray(fc2.constantFrom(...KEYS)),
+            fc2.uniqueArray(fc2.constantFrom(...KEYS)),
+            async (oldKeys, newKeys) => {
+              run += 1;
+              const collection = `contract-replace-${run}`;
+              const decoy = `contract-replace-decoy-${run}`;
+              await putAll(store, collection, docsFrom(oldKeys, 1));
+              await putAll(store, decoy, docsFrom(oldKeys, 3));
+              const next = docsFrom(newKeys, 2);
+              await store.replaceCollection(collection, entriesOf(next));
+              expect5(await snapshot(store, collection)).toEqual(shape(next));
+              for (const key of oldKeys.filter((k) => !newKeys.includes(k))) {
+                expect5(await store.get(collection, key), `stale key ${key}`).toBeNull();
+              }
+              expect5(await snapshot(store, decoy)).toEqual(shape(docsFrom(oldKeys, 3)));
+            }
+          ),
+          { numRuns: 25 }
+        );
+      });
+    },
+    SLOW2
+  );
+  it5(
+    "replaceCollection is atomic to a concurrent reader: polling while the replace runs sees only the full old set or the full new set, never a partial set",
+    async () => {
+      await using(make, async (store) => {
+        const old = docsFrom(["a", "b", "c", "d", "e", "f"], 1);
+        const next = docsFrom(["d", "e", "f", "g", "h", "i"], 2);
+        await putAll(store, "contract-replace-reader", old);
+        const allowed = /* @__PURE__ */ new Set([JSON.stringify(shape(old)), JSON.stringify(shape(next))]);
+        let done = false;
+        const seen = [];
+        const reader = (async () => {
+          while (!done) {
+            seen.push(await snapshot(store, "contract-replace-reader"));
+            await macrotask();
+          }
+        })();
+        await store.replaceCollection("contract-replace-reader", entriesOf(next, true)).finally(() => {
+          done = true;
+        });
+        await reader;
+        expect5(seen.length, "the reader read while the replace ran").toBeGreaterThan(0);
+        for (const observed of seen) {
+          expect5(
+            allowed.has(JSON.stringify(observed)),
+            `a partial set: ${observed.join(" ")}`
+          ).toBe(true);
+        }
+        expect5(await snapshot(store, "contract-replace-reader")).toEqual(shape(next));
+      });
+    },
+    CASE_MS
+  );
+  it5(
+    "replaceCollection whose source throws part-way rejects with the source\u2019s error and leaves the old set intact",
+    async () => {
+      await using(make, async (store) => {
+        const old = docsFrom(["a", "b", "c"], 1);
+        await putAll(store, "contract-replace-failing", old);
+        async function* failing() {
+          yield ["a", { id: "a", part: "p", v: 2 }];
+          yield ["z", { id: "z", part: "p", v: 2 }];
+          throw new Error("contract: the source failed");
+        }
+        const failed = await store.replaceCollection("contract-replace-failing", failing()).then(
+          () => null,
+          (error) => error
+        );
+        expect5(String(failed)).toContain("contract: the source failed");
+        expect5(await snapshot(store, "contract-replace-failing")).toEqual(shape(old));
+      });
+    },
+    CASE_MS
+  );
+  it5(
+    "replaceCollection with an empty source empties the collection",
+    async () => {
+      await using(make, async (store) => {
+        await putAll(store, "contract-replace-empty", docsFrom(["a", "b"], 1));
+        await store.replaceCollection("contract-replace-empty", entriesOf([]));
+        expect5(await snapshot(store, "contract-replace-empty")).toEqual([]);
+        expect5(await store.get("contract-replace-empty", "a")).toBeNull();
+      });
+    },
+    CASE_MS
+  );
+  const clock = opts.clock;
+  if (clock !== void 0) {
+    it5(
+      "replaceCollection writes documents without a TTL: a key whose old document had one is still there after that TTL passes",
+      async () => {
+        await using(make, async (store) => {
+          await store.put("contract-replace-ttl", "a", { id: "a", part: "p", v: 1 }, { ttl: 60 });
+          await store.replaceCollection("contract-replace-ttl", entriesOf(docsFrom(["a", "b"], 2)));
+          await clock.advance(61e3);
+          expect5(await snapshot(store, "contract-replace-ttl")).toEqual(["a:2", "b:2"]);
+        });
+      },
+      CASE_MS
+    );
+  }
+}
+
+// src/document-store.ts
+var SLOW3 = 3e4;
+async function using2(make, body) {
+  const store = await make();
+  try {
+    await body(store);
+  } finally {
+    await store.close();
+  }
+}
+async function rejection2(promise) {
+  return promise.then(
+    () => null,
+    (error) => error ?? new Error("rejected with nothing")
+  );
+}
+async function putAll2(store, collection, docs) {
+  for (const doc of docs) await store.put(collection, doc.id, doc);
+}
+var ids = (docs) => docs.map((d) => d.id);
+async function walk2(store, collection, params2, between) {
+  const pages = [];
+  let cursor;
+  do {
+    const page = await store.query(collection, {
+      ...params2,
+      ...cursor !== void 0 && { cursor }
+    });
+    pages.push(page.items);
+    cursor = page.nextCursor ?? void 0;
+    if (between !== void 0) await between(pages.length);
+  } while (cursor !== void 0 && pages.length < 100);
+  return pages;
+}
+function runDocumentStoreContract(name, make, opts = {}) {
+  describe5(`DocumentStoreAdapter contract: ${name}`, () => {
+    it6(
+      "get is null for a missing key; put then get round-trips; a second put overwrites",
+      async () => {
+        await using2(make, async (store) => {
+          expect6(await store.get("col", "missing")).toBeNull();
+          await store.put("col", "k1", { name: "test", value: 42, nested: { list: [1, "two"] } });
+          expect6(await store.get("col", "k1")).toEqual({
+            name: "test",
+            value: 42,
+            nested: { list: [1, "two"] }
+          });
+          await store.put("col", "k1", { v: 2 });
+          expect6(await store.get("col", "k1")).toEqual({ v: 2 });
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "delete removes the document, and deleting a missing key does not throw",
+      async () => {
+        await using2(make, async (store) => {
+          await store.put("col", "k1", { v: 1 });
+          await store.delete("col", "k1");
+          expect6(await store.get("col", "k1")).toBeNull();
+          await expect6(store.delete("col", "nope")).resolves.toBeUndefined();
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "query narrows by partition, and '*' returns the whole collection",
+      async () => {
+        await using2(make, async (store) => {
+          await putAll2(store, "col", [
+            { id: "a", part: "p" },
+            { id: "b", part: "q" },
+            { id: "c", part: "p" }
+          ]);
+          const p = await store.query("col", { partitionKey: { field: "part", value: "p" } });
+          expect6(ids(p.items).sort()).toEqual(["a", "c"]);
+          const all = await store.query("col", { partitionKey: { field: "part", value: "*" } });
+          expect6(ids(all.items).sort()).toEqual(["a", "b", "c"]);
+          expect6(all.nextCursor).toBeNull();
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "sortKey eq is strict (1 is not '1', 'a' is not 'A'); gt, lt and between follow compareDocumentValues",
+      async () => {
+        await using2(make, async (store) => {
+          await putAll2(store, "col", [
+            { id: "n1", part: "p", v: 1 },
+            { id: "s1", part: "p", v: "1" },
+            { id: "n5", part: "p", v: 5 },
+            { id: "sa", part: "p", v: "a" },
+            { id: "sA", part: "p", v: "A" },
+            { id: "nul", part: "p", v: null }
+          ]);
+          const where = async (sortKey) => ids(
+            (await store.query("col", {
+              partitionKey: { field: "part", value: "p" },
+              sortKey
+            })).items
+          ).sort();
+          expect6(await where({ field: "v", operator: "eq", value: 1 })).toEqual(["n1"]);
+          expect6(await where({ field: "v", operator: "eq", value: "a" })).toEqual(["sa"]);
+          expect6(await where({ field: "v", operator: "lt", value: "0" })).toEqual(["n1", "n5"]);
+          expect6(await where({ field: "v", operator: "gt", value: 5 })).toEqual(
+            ["nul", "s1", "sA", "sa"].sort()
+          );
+          expect6(await where({ field: "v", operator: "between", value: [2, "a"] })).toEqual(
+            ["n5", "s1", "sA", "sa"].sort()
+          );
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "orderBy orders by value with the collator, nulls and missing last, ties by key, on a dotted path too",
+      async () => {
+        await using2(make, async (store) => {
+          await putAll2(store, "col", [
+            { id: "k4", part: "p", nested: { v: "b" } },
+            { id: "k1", part: "p", nested: { v: "B" } },
+            { id: "k2", part: "p", nested: { v: "a" } },
+            { id: "k3", part: "p", nested: {} },
+            { id: "k5", part: "p", nested: { v: 10 } },
+            { id: "k6", part: "p", nested: { v: 9 } },
+            { id: "k0", part: "p", nested: { v: null } }
+          ]);
+          const asc = await store.query("col", {
+            partitionKey: { field: "part", value: "p" },
+            orderBy: { field: "nested.v", direction: "asc", nulls: "last" }
+          });
+          expect6(ids(asc.items)).toEqual(["k6", "k5", "k2", "k1", "k4", "k0", "k3"]);
+          const desc = await store.query("col", {
+            partitionKey: { field: "part", value: "p" },
+            orderBy: { field: "nested.v", direction: "desc", nulls: "last" }
+          });
+          expect6(ids(desc.items)).toEqual(["k1", "k4", "k2", "k5", "k6", "k0", "k3"]);
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "a limit and cursor walk returns every match exactly once, also when a document is deleted mid-walk",
+      async () => {
+        await using2(make, async (store) => {
+          const docs = Array.from({ length: 9 }, (_, i) => ({ id: `k${i}`, part: "p", v: i % 3 }));
+          await putAll2(store, "col", docs);
+          for (const orderBy of [void 0, { field: "v", direction: "asc" }]) {
+            const params2 = {
+              partitionKey: { field: "part", value: "p" },
+              limit: 2,
+              ...orderBy !== void 0 && { orderBy }
+            };
+            const whole = (await walk2(store, "col", params2)).flat();
+            expect6(ids(whole).sort()).toEqual(ids(docs).sort());
+            const anchor = whole[1];
+            const walked = (await walk2(store, "col", params2, async (page) => {
+              if (page === 1) await store.delete("col", anchor.id);
+            })).flat();
+            expect6(new Set(ids(walked)).size).toBe(walked.length);
+            expect6(ids(walked).sort()).toEqual(ids(docs).sort());
+            await store.put("col", anchor.id, anchor);
+          }
+        });
+      },
+      SLOW3
+    );
+    it6(
+      "a cursor issued under one orderBy is refused under another, and continues under its own",
+      async () => {
+        await using2(make, async (store) => {
+          await putAll2(
+            store,
+            "col",
+            Array.from({ length: 5 }, (_, i) => ({ id: `k${i}`, part: "p", v: i }))
+          );
+          const base = {
+            partitionKey: { field: "part", value: "p" },
+            orderBy: { field: "v", direction: "asc" },
+            limit: 2
+          };
+          const first = await store.query("col", base);
+          expect6(first.nextCursor).not.toBeNull();
+          const cursor = first.nextCursor;
+          const other = await rejection2(
+            store.query("col", { ...base, orderBy: { field: "v", direction: "desc" }, cursor })
+          );
+          expect6(other).toBeInstanceOf(Error);
+          const next = await store.query("col", { ...base, cursor });
+          expect6(ids(next.items)).toEqual(["k2", "k3"]);
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "a document put with a ttl (seconds) is gone from get, query and batchGet once it expires",
+      async () => {
+        await using2(make, async (store) => {
+          await store.put("col", "short", { id: "short", part: "p" }, { ttl: 1 });
+          await store.put("col", "kept", { id: "kept", part: "p" });
+          expect6(await store.get("col", "short")).toEqual({ id: "short", part: "p" });
+          if (opts.clock !== void 0) {
+            await opts.clock.advance(1001);
+          } else {
+            const deadline = Date.now() + 4e3;
+            while (await store.get("col", "short") !== null && Date.now() < deadline) {
+              await new Promise((r) => setTimeout(r, 50));
+            }
+          }
+          expect6(await store.get("col", "short")).toBeNull();
+          const all = await store.query("col", { partitionKey: { field: "part", value: "*" } });
+          expect6(ids(all.items)).toEqual(["kept"]);
+          expect6([...(await store.batchGet("col", ["short", "kept"])).keys()]).toEqual(["kept"]);
+        });
+      },
+      SLOW3
+    );
+    it6(
+      "a conditional put applies when the field is strictly equal, and otherwise fails condition-failed",
+      async () => {
+        await using2(make, async (store) => {
+          await store.put("col", "c", { version: 1, label: "v1" });
+          await store.put(
+            "col",
+            "c",
+            { version: 2, label: "v2" },
+            { conditionKey: "version", conditionValue: 1 }
+          );
+          expect6(await store.get("col", "c")).toEqual({ version: 2, label: "v2" });
+          for (const conditionValue of [1, "2"]) {
+            const failed = await rejection2(
+              store.put("col", "c", { version: 3 }, { conditionKey: "version", conditionValue })
+            );
+            expect6(failed?.code).toBe("adapter.condition-failed");
+          }
+          const absent = await rejection2(
+            store.put(
+              "col",
+              "none",
+              { version: 1 },
+              { conditionKey: "version", conditionValue: 1 }
+            )
+          );
+          expect6(absent?.code).toBe("adapter.condition-failed");
+          expect6(await store.get("col", "c")).toEqual({ version: 2, label: "v2" });
+          expect6(await store.get("col", "none")).toBeNull();
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "batchPut stores every item; batchGet returns exactly the stored keys",
+      async () => {
+        await using2(make, async (store) => {
+          await store.batchPut(
+            "col",
+            /* @__PURE__ */ new Map([
+              ["x", { n: 10 }],
+              ["y", { n: 20 }]
+            ])
+          );
+          const got = await store.batchGet("col", ["x", "y", "missing"]);
+          expect6([...got.keys()].sort()).toEqual(["x", "y"]);
+          expect6(got.get("x")).toEqual({ n: 10 });
+          expect6(await store.get("col", "y")).toEqual({ n: 20 });
+          expect6((await store.batchGet("col", [])).size).toBe(0);
+        });
+      },
+      CASE_MS
+    );
+    it6(
+      "collections are isolated for get, query and delete",
+      async () => {
+        await using2(make, async (store) => {
+          await store.put("colA", "key", { id: "key", part: "p", from: "A" });
+          await store.put("colB", "key", { id: "key", part: "p", from: "B" });
+          expect6(await store.get("colA", "key")).toEqual({ id: "key", part: "p", from: "A" });
+          const inB = await store.query("colB", { partitionKey: { field: "part", value: "*" } });
+          expect6(inB.items).toEqual([{ id: "key", part: "p", from: "B" }]);
+          await store.delete("colA", "key");
+          expect6(await store.get("colB", "key")).toEqual({ id: "key", part: "p", from: "B" });
+        });
+      },
+      CASE_MS
+    );
+    const isolation = opts.isolation;
+    if (isolation !== void 0) {
+      it6(
+        "two stores under different prefixes never see each other\u2019s documents",
+        async () => {
+          const [one, two] = await isolation();
+          try {
+            await one.put("col", "shared", { id: "shared", part: "p", owner: "one" });
+            await one.put("col", "one-only", { id: "one-only", part: "p", owner: "one" });
+            await two.put("col", "shared", { id: "shared", part: "p", owner: "two" });
+            expect6(await one.get("col", "shared")).toEqual({
+              id: "shared",
+              part: "p",
+              owner: "one"
+            });
+            expect6(await two.get("col", "one-only")).toBeNull();
+            const inTwo = await two.query("col", { partitionKey: { field: "part", value: "*" } });
+            expect6(inTwo.items).toEqual([{ id: "shared", part: "p", owner: "two" }]);
+            await one.delete("col", "shared");
+            expect6(await two.get("col", "shared")).toEqual({
+              id: "shared",
+              part: "p",
+              owner: "two"
+            });
+          } finally {
+            await one.close();
+            await two.close();
+          }
+        },
+        CASE_MS
+      );
+    }
+    documentStoreModelCases(make, opts);
+    documentStoreReplaceCases(make, opts);
+    healthAndDowntime(make, opts.unreachable, "get()", (store) => store.get("contract-down", "k"));
+  });
+}
+
+// src/email.ts
+import { describe as describe6, expect as expect7, it as it7 } from "vitest";
+var MAIL = {
+  template: "order-confirmation",
+  to: "test@example.com",
+  vars: { orderNumber: "ORD-001" }
+};
+function runEmailContract(name, build, options = {}) {
+  describe6(`EmailAdapter contract: ${name}`, () => {
+    it7(
+      "sendTransactional resolves with accepted or messageId",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.sendTransactional(MAIL);
+        expect7(typeof result.accepted).toBe("boolean");
+      },
+      CASE_MS
+    );
+    it7(
+      "syncCustomerToList resolves without throwing",
+      async () => {
+        const adapter = await build();
+        await expect7(
+          adapter.syncCustomerToList({
+            customerId: "cust-1",
+            orderCount: 0,
+            totalSpentMinor: 0,
+            segment: "new",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        ).resolves.not.toThrow();
+      },
+      CASE_MS
+    );
+    it7(
+      "removeCustomerFromList resolves without throwing",
+      async () => {
+        const adapter = await build();
+        await expect7(adapter.removeCustomerFromList("cust-1")).resolves.not.toThrow();
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "sendTransactional()",
+      (adapter) => adapter.sendTransactional(MAIL)
+    );
+  });
+}
+
+// src/event-bus.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { describe as describe8, expect as expect9, it as it9 } from "vitest";
+
+// src/event-bus-delivery.ts
+import { randomUUID } from "crypto";
+import fc3 from "fast-check";
+import { describe as describe7, expect as expect8, it as it8 } from "vitest";
+var SLOW4 = 6e4;
+function event(type, payload = {}) {
+  return {
+    id: `evt-${randomUUID()}`,
+    type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "contract-contract",
+    correlationId: `corr-${randomUUID()}`,
+    payload,
+    metadata: { storeId: "contract", environment: "development", version: "0.0.0" }
+  };
+}
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+async function until(check, label, ms) {
+  const deadline = Date.now() + ms;
+  while (!check()) {
+    if (Date.now() > deadline) throw new Error(`timed out after ${ms} ms waiting for ${label}`);
+    await delay(10);
+  }
+}
+function gate() {
+  let open;
+  const wait = new Promise((r) => {
+    open = r;
+  });
+  return { wait, open };
+}
+async function closingAll(buses, body) {
+  try {
+    await body();
+  } finally {
+    for (const bus of buses) await bus.close();
+  }
+}
+var TYPES = ["order.created.v1", "order.paid.v1", "cart.updated.v1"];
+function eventBusDeliveryCases(make, opts) {
+  describe7("keeps the delivery contract", () => {
+    it8(
+      "publish resolves only after every matching handler has finished: a 200 ms handler, named and unnamed, is done first",
+      async () => {
+        const bus = await make();
+        await closingAll([bus], async () => {
+          const finished = [];
+          await bus.subscribe("contract.slow.v1", async () => {
+            await delay(200);
+            finished.push("unnamed");
+          });
+          await bus.subscribe(
+            "contract.slow.v1",
+            async () => {
+              await delay(200);
+              finished.push("named");
+            },
+            { name: "contract-slow" }
+          );
+          const startedAt = Date.now();
+          await bus.publish(event("contract.slow.v1"));
+          const elapsed = Date.now() - startedAt;
+          expect8([...finished].sort()).toEqual(["named", "unnamed"]);
+          expect8(elapsed).toBeGreaterThanOrEqual(190);
+        });
+      },
+      SLOW4
+    );
+    it8(
+      "a throwing handler leaves publish resolved and every other matching handler called, event after event",
+      async () => {
+        const bus = await make();
+        await closingAll([bus], async () => {
+          const received = [];
+          await bus.subscribe(
+            "contract.boom.v1",
+            async () => {
+              throw new Error("contract handler failure");
+            },
+            { name: "contract-throws" }
+          );
+          await bus.subscribe("contract.boom.v1", async (e) => {
+            received.push(e.id);
+          });
+          const events = [event("contract.boom.v1"), event("contract.boom.v1"), event("contract.boom.v1")];
+          for (const e of events) await expect8(bus.publish(e)).resolves.toBeUndefined();
+          expect8(received).toEqual(events.map((e) => e.id));
+        });
+      },
+      SLOW4
+    );
+    it8(
+      "replay reaches derived subscriptions only, in order; a later publish still reaches every subscription",
+      async () => {
+        const bus = await make();
+        await closingAll([bus], async () => {
+          const derived = [];
+          const sideNamed = [];
+          const sideUnnamed = [];
+          await bus.subscribe("contract.replay.v1", async (e) => void derived.push(e.id), {
+            name: "contract-projection",
+            derived: true
+          });
+          await bus.subscribe("contract.replay.v1", async (e) => void sideNamed.push(e.id), {
+            name: "contract-side-effect"
+          });
+          await bus.subscribe("contract.replay.v1", async (e) => void sideUnnamed.push(e.id));
+          const replayed = [event("contract.replay.v1"), event("contract.replay.v1")];
+          await bus.replay(replayed);
+          expect8(derived).toEqual(replayed.map((e) => e.id));
+          expect8(sideNamed).toEqual([]);
+          expect8(sideUnnamed).toEqual([]);
+          const live = event("contract.replay.v1");
+          await bus.publish(live);
+          expect8(derived).toEqual([...replayed, live].map((e) => e.id));
+          expect8(sideNamed).toEqual([live.id]);
+          expect8(sideUnnamed).toEqual([live.id]);
+        });
+      },
+      SLOW4
+    );
+    it8(
+      "publishBatch reaches each subscription with exactly its matching events, in batch order (wildcards and pattern arrays)",
+      async () => {
+        await fc3.assert(
+          fc3.asyncProperty(
+            fc3.array(fc3.constantFrom(...TYPES), { minLength: 1, maxLength: 12 }),
+            async (types) => {
+              const bus = await make();
+              await closingAll([bus], async () => {
+                const fence = event("contract.fence.v1");
+                const subs = [
+                  { patterns: ["order.*", fence.type], name: void 0 },
+                  { patterns: ["cart.updated.v1", "order.paid.v1", fence.type], name: "contract-arr" },
+                  { patterns: ["order.created.v1", fence.type], name: "contract-one" }
+                ];
+                const seen = subs.map(() => []);
+                for (const [i, sub] of subs.entries()) {
+                  await bus.subscribe(
+                    sub.patterns,
+                    async (e) => void seen[i].push(e.id),
+                    sub.name === void 0 ? void 0 : { name: sub.name }
+                  );
+                }
+                const events = types.map((type, seq) => event(type, { seq }));
+                await bus.publishBatch(events);
+                await bus.publish(fence);
+                const matches = (patterns, type) => patterns.some(
+                  (p) => p.endsWith("*") ? type.startsWith(p.slice(0, -1)) : p === type
+                );
+                for (const [i, sub] of subs.entries()) {
+                  const expected = events.filter((e) => matches(sub.patterns, e.type));
+                  expect8(seen[i], sub.patterns.join("|")).toEqual([
+                    ...expected.map((e) => e.id),
+                    fence.id
+                  ]);
+                }
+              });
+            }
+          ),
+          { numRuns: 15 }
+        );
+      },
+      SLOW4
+    );
+    it8(
+      "an unsubscribed handler, by bus.unsubscribe or by its own unsubscribe(), receives nothing more",
+      async () => {
+        const bus = await make();
+        await closingAll([bus], async () => {
+          const gone = [];
+          const goneToo = [];
+          const kept = [];
+          const a = await bus.subscribe("contract.unsub.v1", async (e) => void gone.push(e.id), {
+            name: "contract-unsub"
+          });
+          const b = await bus.subscribe("contract.unsub.v1", async (e) => void goneToo.push(e.id));
+          await bus.subscribe("contract.unsub.v1", async (e) => void kept.push(e.id));
+          const before = event("contract.unsub.v1");
+          await bus.publish(before);
+          await bus.unsubscribe(a);
+          await b.unsubscribe();
+          const after = [event("contract.unsub.v1"), event("contract.unsub.v1")];
+          for (const e of after) await bus.publish(e);
+          expect8(kept).toEqual([before, ...after].map((e) => e.id));
+          expect8(gone).toEqual([before.id]);
+          expect8(goneToo).toEqual([before.id]);
+        });
+      },
+      SLOW4
+    );
+    it8(
+      "on one instance, a named and an unnamed subscription each handle every event once",
+      async () => {
+        const bus = await make();
+        await closingAll([bus], async () => {
+          const named = [];
+          const unnamed = [];
+          await bus.subscribe("contract.both.v1", async (e) => void named.push(e.id), {
+            name: "contract-named"
+          });
+          await bus.subscribe("contract.both.v1", async (e) => void unnamed.push(e.id));
+          const events = Array.from({ length: 6 }, () => event("contract.both.v1"));
+          for (const e of events) await bus.publish(e);
+          expect8(named).toEqual(events.map((e) => e.id));
+          expect8(unnamed).toEqual(named);
+        });
+      },
+      SLOW4
+    );
+    const second = opts.second;
+    if (second === void 0) return;
+    describe7("two instances on the same streams", () => {
+      const N = 12;
+      it8(
+        "one named subscription on both instances handles each of N events exactly once in total",
+        async () => {
+          const a = await make();
+          const b = await second();
+          await closingAll([a, b], async () => {
+            const byA = [];
+            const byB = [];
+            await a.subscribe("contract.named.*", async (e) => void byA.push(e.id), {
+              name: "contract-shared"
+            });
+            await b.subscribe("contract.named.*", async (e) => void byB.push(e.id), {
+              name: "contract-shared"
+            });
+            const events = Array.from({ length: N }, (_, seq) => event("contract.named.x", { seq }));
+            for (const [i, e] of events.entries()) await (i % 2 === 0 ? a : b).publish(e);
+            await b.publish(event("contract.named.fence"));
+            await a.publish(event("contract.named.fence"));
+            const ids2 = new Set(events.map((e) => e.id));
+            const handled = [...byA, ...byB].filter((id) => ids2.has(id));
+            expect8(handled.length).toBe(events.length);
+            expect8([...handled].sort()).toEqual(events.map((e) => e.id).sort());
+          });
+        },
+        SLOW4
+      );
+      it8(
+        "an unnamed subscription on each instance receives all N events, in order, on both",
+        async () => {
+          const a = await make();
+          const b = await second();
+          await closingAll([a, b], async () => {
+            const onA = [];
+            const onB = [];
+            await a.subscribe("contract.fanout.*", async (e) => void onA.push(e.id));
+            await b.subscribe("contract.fanout.*", async (e) => void onB.push(e.id));
+            const events = Array.from({ length: N }, (_, seq) => event("contract.fanout.x", { seq }));
+            for (const e of events) await a.publish(e);
+            const fenceB = event("contract.fanout.fence");
+            await b.publish(fenceB);
+            const ids2 = events.map((e) => e.id);
+            expect8(onA.slice(0, N)).toEqual(ids2);
+            expect8(onB.slice(0, N)).toEqual(ids2);
+            expect8(onB[N]).toBe(fenceB.id);
+          });
+        },
+        SLOW4
+      );
+      it8(
+        "replay on one instance reaches its own derived handlers and nothing on the other instance",
+        async () => {
+          const a = await make();
+          const b = await second();
+          await closingAll([a, b], async () => {
+            const derivedA = [];
+            const derivedB = [];
+            const sideB = [];
+            await a.subscribe("contract.rebuild.*", async (e) => void derivedA.push(e.id), {
+              name: "contract-projection",
+              derived: true
+            });
+            await b.subscribe("contract.rebuild.*", async (e) => void derivedB.push(e.id), {
+              name: "contract-projection",
+              derived: true
+            });
+            await b.subscribe("contract.rebuild.*", async (e) => void sideB.push(e.id), {
+              name: "contract-side-effect"
+            });
+            const replayed = [event("contract.rebuild.x"), event("contract.rebuild.x")];
+            await a.replay(replayed);
+            const fence = event("contract.rebuild.fence");
+            await b.publish(fence);
+            expect8(derivedA.slice(0, replayed.length)).toEqual(replayed.map((e) => e.id));
+            const ids2 = new Set(replayed.map((e) => e.id));
+            expect8(derivedB.filter((id) => ids2.has(id))).toEqual([]);
+            expect8(sideB).toEqual([fence.id]);
+          });
+        },
+        SLOW4
+      );
+      const timing = opts.timing;
+      if (timing === void 0) return;
+      const { claimIdleMs, ackTimeoutMs } = timing;
+      it8(
+        "groups left by a stopped instance (never unsubscribed) do not delay publish on the other instance",
+        async () => {
+          const a = await make();
+          const b = await second();
+          await closingAll([a], async () => {
+            await b.subscribe("contract.left.*", async () => void 0, { name: "contract-left-behind" });
+            await b.subscribe("contract.left.*", async () => void 0);
+            await b.close();
+            const handled = [];
+            await a.subscribe("contract.left.*", async (e2) => void handled.push(e2.id), {
+              name: "contract-live"
+            });
+            const e = event("contract.left.x");
+            const startedAt = Date.now();
+            await a.publish(e);
+            const elapsed = Date.now() - startedAt;
+            expect8(handled).toEqual([e.id]);
+            expect8(elapsed).toBeLessThan(ackTimeoutMs / 2);
+          });
+        },
+        SLOW4
+      );
+      it8(
+        "an entry pending on a stopped consumer of a named group is handled by the live one after claimIdleMs and before ackTimeoutMs",
+        async () => {
+          const a = await make();
+          const b = await second();
+          const held = gate();
+          let closingB;
+          try {
+            let receivedByB;
+            await b.subscribe(
+              "contract.claim.*",
+              async () => {
+                receivedByB = Date.now();
+                await held.wait;
+              },
+              { name: "contract-claimed" }
+            );
+            const stranded = event("contract.claim.x");
+            await a.publish(stranded);
+            await until(() => receivedByB !== void 0, "b to receive the entry", ackTimeoutMs);
+            closingB = b.close();
+            const byA = [];
+            await a.subscribe(
+              "contract.claim.*",
+              async (e) => void byA.push({ id: e.id, at: Date.now() }),
+              {
+                name: "contract-claimed"
+              }
+            );
+            const next = event("contract.claim.x");
+            const startedAt = Date.now();
+            await a.publish(next);
+            const publishMs = Date.now() - startedAt;
+            await until(
+              () => byA.some((h) => h.id === stranded.id),
+              "a to take over the stranded entry",
+              ackTimeoutMs * 2
+            );
+            const claimed = byA.find((h) => h.id === stranded.id);
+            const idle = claimed.at - receivedByB;
+            expect8(idle, "taken over before claimIdleMs").toBeGreaterThanOrEqual(claimIdleMs - 50);
+            expect8(idle, "taken over only after ackTimeoutMs").toBeLessThan(ackTimeoutMs);
+            expect8(byA.filter((h) => h.id === stranded.id).length).toBe(1);
+            expect8(publishMs, "a publish on the group waited out the timeout").toBeLessThan(
+              ackTimeoutMs
+            );
+          } finally {
+            held.open();
+            await closingB;
+            await a.close();
+          }
+        },
+        SLOW4
+      );
+      it8(
+        "an unnamed subscription unsubscribed while publish waits on it lets publish resolve well before ackTimeoutMs",
+        async () => {
+          const a = await make();
+          const held = gate();
+          try {
+            let entered = false;
+            const sub = await a.subscribe("contract.wait.*", async () => {
+              entered = true;
+              await held.wait;
+            });
+            const publishing = a.publish(event("contract.wait.x")).then(
+              () => Date.now(),
+              (error) => error
+            );
+            await until(() => entered, "the handler to start", ackTimeoutMs);
+            const unsubscribedAt = Date.now();
+            const unsubscribing = a.unsubscribe(sub);
+            const outcome = await publishing;
+            expect8(typeof outcome, `publish rejected: ${String(outcome)}`).toBe("number");
+            expect8(outcome - unsubscribedAt).toBeLessThan(ackTimeoutMs / 2);
+            held.open();
+            await unsubscribing;
+          } finally {
+            held.open();
+            await a.close();
+          }
+        },
+        SLOW4
+      );
+    });
+  });
+}
+
+// src/event-bus.ts
+var SLOW5 = 3e4;
+function makeEvent(type, payload = {}) {
+  return {
+    id: `evt-${randomUUID2()}`,
+    type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "contract-tests",
+    correlationId: `corr-${randomUUID2()}`,
+    payload,
+    metadata: { storeId: "test", environment: "development", version: "0.0.0" }
+  };
+}
+var delay2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function using3(buses, body) {
+  try {
+    await body();
+  } finally {
+    for (const bus of buses) await bus.close();
+  }
+}
+function runEventBusContract(name, make, opts = {}) {
+  describe8(`EventBusAdapter contract: ${name}`, () => {
+    it9("publish resolves after the matching handler has finished, and never calls a non-matching one", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const received = [];
+        const other = [];
+        await bus.subscribe("test.event.v1", async (e) => {
+          await delay2(50);
+          received.push(e.payload);
+        });
+        await bus.subscribe("test.other.v1", async (e) => void other.push(e));
+        await bus.publish(makeEvent("test.event.v1", { x: 1 }));
+        expect9(received).toEqual([{ x: 1 }]);
+        expect9(other).toEqual([]);
+      });
+    }, CASE_MS);
+    it9("a handler that throws leaves publish resolved and every other handler called", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const results = [];
+        await bus.subscribe("error.test.v1", async () => {
+          throw new Error("boom");
+        });
+        await bus.subscribe("error.test.v1", async () => void results.push("ok"));
+        await expect9(bus.publish(makeEvent("error.test.v1"))).resolves.toBeUndefined();
+        expect9(results).toEqual(["ok"]);
+      });
+    }, CASE_MS);
+    it9("replay reaches derived subscriptions only", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const derived = [];
+        const sideEffect = [];
+        await bus.subscribe("replay.test.v1", async (e) => void derived.push(e.id), {
+          name: "contract-projection",
+          derived: true
+        });
+        await bus.subscribe("replay.test.v1", async (e) => void sideEffect.push(e.id), {
+          name: "contract-side-effect"
+        });
+        const events = [makeEvent("replay.test.v1"), makeEvent("replay.test.v1")];
+        await bus.replay(events);
+        expect9(derived).toEqual(events.map((e) => e.id));
+        expect9(sideEffect).toEqual([]);
+      });
+    }, CASE_MS);
+    it9("publishBatch reaches each subscription in batch order, through wildcards and pattern arrays", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const wildcard = [];
+        const listed = [];
+        await bus.subscribe("batch.*", async (e) => void wildcard.push(e.id));
+        await bus.subscribe(["batch.a.v1", "batch.c.v1"], async (e) => void listed.push(e.id), {
+          name: "contract-listed"
+        });
+        const events = ["batch.a.v1", "batch.b.v1", "batch.c.v1", "batch.a.v1"].map(
+          (t, seq) => makeEvent(t, { seq })
+        );
+        await bus.publishBatch(events);
+        expect9(wildcard).toEqual(events.map((e) => e.id));
+        expect9(listed).toEqual(events.filter((e) => e.type !== "batch.b.v1").map((e) => e.id));
+      });
+    }, CASE_MS);
+    it9("an unsubscribed handler receives nothing more", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const received = [];
+        const sub = await bus.subscribe("unsub.event.v1", async (e) => void received.push(e.id));
+        const before = makeEvent("unsub.event.v1");
+        await bus.publish(before);
+        await bus.unsubscribe(sub);
+        await bus.publish(makeEvent("unsub.event.v1"));
+        expect9(received).toEqual([before.id]);
+      });
+    }, CASE_MS);
+    it9("on one instance, a named and an unnamed subscription each handle every event once", async () => {
+      const bus = await make();
+      await using3([bus], async () => {
+        const named = [];
+        const unnamed = [];
+        await bus.subscribe("both.event.v1", async (e) => void named.push(e.id), {
+          name: "contract-named"
+        });
+        await bus.subscribe("both.event.v1", async (e) => void unnamed.push(e.id));
+        const events = [makeEvent("both.event.v1"), makeEvent("both.event.v1")];
+        for (const e of events) await bus.publish(e);
+        expect9(named).toEqual(events.map((e) => e.id));
+        expect9(unnamed).toEqual(named);
+      });
+    }, CASE_MS);
+    eventBusDeliveryCases(make, opts);
+    healthAndDowntime(
+      make,
+      opts.unreachable,
+      "publish()",
+      (bus) => bus.publish(makeEvent("contract.down.v1"))
+    );
+    const second = opts.second;
+    if (second === void 0) return;
+    it9(
+      "across two instances, a named subscription handles each event once in total, and an unnamed one on each",
+      async () => {
+        const a = await make();
+        const b = await second();
+        await using3([a, b], async () => {
+          const named = [];
+          const onA = [];
+          const onB = [];
+          await a.subscribe("shared.*", async (e) => void named.push(e.id), {
+            name: "contract-shared"
+          });
+          await b.subscribe("shared.*", async (e) => void named.push(e.id), {
+            name: "contract-shared"
+          });
+          await a.subscribe("shared.*", async (e) => void onA.push(e.id));
+          await b.subscribe("shared.*", async (e) => void onB.push(e.id));
+          const events = Array.from({ length: 6 }, (_, seq) => makeEvent("shared.x", { seq }));
+          for (const [i, e] of events.entries()) await (i % 2 === 0 ? a : b).publish(e);
+          const fenceA = makeEvent("shared.fence");
+          const fenceB = makeEvent("shared.fence");
+          await a.publish(fenceA);
+          await b.publish(fenceB);
+          const ids2 = events.map((e) => e.id);
+          expect9(named.filter((id) => ids2.includes(id)).sort()).toEqual([...ids2].sort());
+          expect9(onA.filter((id) => ids2.includes(id))).toEqual(ids2);
+          expect9(onB.filter((id) => ids2.includes(id))).toEqual(ids2);
+        });
+      },
+      SLOW5
+    );
+  });
+}
+
+// src/media-storage.ts
+import { describe as describe9, expect as expect10, it as it10 } from "vitest";
+function runMediaStorageContract(name, make, options) {
+  const { fetchUrl } = options;
+  describe9(`MediaStorage contract: ${name}`, () => {
+    it10("reports put among its capabilities", async () => {
+      const storage = await make();
+      expect10(storage.capabilities()).toContain("put");
+    }, CASE_MS);
+    it10("put then a read of the returned url gives back the same bytes, for nested keys too", async () => {
+      const storage = await make();
+      const bodies = /* @__PURE__ */ new Map([
+        ["image.png", Uint8Array.from([137, 80, 78, 71, 0, 255, 1])],
+        ["products/42/large.jpg", new TextEncoder().encode("jpeg bytes \u2713")],
+        ["empty.txt", new Uint8Array(0)]
+      ]);
+      const urls = /* @__PURE__ */ new Set();
+      for (const [key, body] of bodies) {
+        const { url } = await storage.put(key, body, "application/octet-stream");
+        urls.add(url);
+        expect10([...await fetchUrl(url)]).toEqual([...body]);
+      }
+      expect10(urls.size).toBe(bodies.size);
+    }, CASE_MS);
+    it10("a second put under a key replaces what the url serves", async () => {
+      const storage = await make();
+      await storage.put("replaced.bin", Uint8Array.from([1, 2, 3]), "application/octet-stream");
+      const { url } = await storage.put(
+        "replaced.bin",
+        Uint8Array.from([9]),
+        "application/octet-stream"
+      );
+      expect10([...await fetchUrl(url)]).toEqual([9]);
+    }, CASE_MS);
+    healthAndDowntime(
+      make,
+      options.unreachable,
+      "put()",
+      (storage) => storage.put("contract-down.bin", Uint8Array.from([1]), "application/octet-stream")
+    );
+  });
+}
+
+// src/payments.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { describe as describe10, expect as expect11, it as it11 } from "vitest";
+var TOTAL = 1999;
+async function rejectionCode(call) {
+  return call.then(
+    () => null,
+    (err) => err?.code ?? err
+  );
+}
+function runPaymentsContract(name, build, options = {}) {
+  describe10(`PaymentsAdapter contract: ${name}`, () => {
+    it11(
+      "createPaymentIntent returns a clientSecret and id",
+      async () => {
+        const adapter = await build();
+        const intent = await adapter.createPaymentIntent({
+          amountMinor: 1e3,
+          currency: "GBP",
+          orderRef: `contract-${randomUUID3()}`
+        });
+        expect11(intent.id).toBeTruthy();
+        expect11(intent.clientSecret).toBeTruthy();
+        expect11(intent.amountMinor).toBe(1e3);
+        expect11(intent.currency).toBe("GBP");
+      },
+      CASE_MS
+    );
+    it11(
+      "getPaymentStatus returns a valid status",
+      async () => {
+        const adapter = await build();
+        const intent = await adapter.createPaymentIntent({ amountMinor: 500, currency: "GBP" });
+        const status = await adapter.getPaymentStatus(intent.id);
+        expect11([
+          "requires_payment_method",
+          "requires_confirmation",
+          "requires_action",
+          "processing",
+          "requires_capture",
+          "succeeded",
+          "cancelled",
+          "failed"
+        ]).toContain(status);
+      },
+      CASE_MS
+    );
+    it11(
+      "idempotency: a refund repeated with the same idempotencyKey returns the same refund and refunds once",
+      async () => {
+        const adapter = await build();
+        const intent = await adapter.createPaymentIntent({
+          amountMinor: TOTAL,
+          currency: "GBP",
+          orderRef: `contract-${randomUUID3()}`
+        });
+        if (intent.status !== "succeeded") await adapter.capturePayment(intent.id);
+        const half = Math.floor(TOTAL / 2);
+        const key = `contract-refund-${randomUUID3()}`;
+        const first = await adapter.refund(intent.id, half, "requested_by_customer", {
+          idempotencyKey: key
+        });
+        const again = await adapter.refund(intent.id, half, "requested_by_customer", {
+          idempotencyKey: key
+        });
+        expect11(again.refundId, "the retry under the same key made another refund").toBe(
+          first.refundId
+        );
+        expect11(again.amountMinor).toBe(first.amountMinor);
+        const rest = await adapter.refund(intent.id, TOTAL - half, "requested_by_customer", {
+          idempotencyKey: `${key}-rest`
+        });
+        expect11(rest.amountMinor + first.amountMinor).toBe(TOTAL);
+        const over = await rejectionCode(
+          adapter.refund(intent.id, 1, "requested_by_customer", { idempotencyKey: `${key}-over` })
+        );
+        expect11(over, "a minor unit past the amount was refunded").toBe("payment.refund_rejected");
+      },
+      CASE_MS
+    );
+    const signedWebhook = options.signedWebhook;
+    if (signedWebhook !== void 0) {
+      it11(
+        "idempotency: parsing one signed webhook event twice gives equal results",
+        async () => {
+          const adapter = await build();
+          const { rawBody, signature } = signedWebhook();
+          const first = await adapter.parseWebhook(rawBody, signature);
+          const second = await adapter.parseWebhook(rawBody, signature);
+          expect11(second).toEqual(first);
+        },
+        CASE_MS
+      );
+    }
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "createPaymentIntent()",
+      (adapter) => adapter.createPaymentIntent({ amountMinor: 100, currency: "GBP" })
+    );
+  });
+}
+
+// src/reviews.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import fc4 from "fast-check";
+import { describe as describe11, expect as expect12, it as it12 } from "vitest";
+async function seed(adapter, count) {
+  const productId = `contract-reviews-${randomUUID4()}`;
+  const seeded = [];
+  for (let i = 0; i < count; i++) {
+    const { review } = await adapter.submitReview({
+      productId,
+      customerId: null,
+      orderId: null,
+      rating: i % 5 + 1,
+      title: `review ${i}`,
+      body: `body ${i}`
+    });
+    seeded.push(review);
+  }
+  return seeded;
+}
+async function walk3(adapter, first, limit, maxPages) {
+  const pages = [];
+  let cursor;
+  do {
+    const page = await adapter.getProductReviews(first.productId, {
+      limit,
+      status: first.moderationStatus,
+      ...cursor !== void 0 && { cursor }
+    });
+    pages.push(page);
+    cursor = page.nextCursor ?? void 0;
+  } while (cursor !== void 0 && pages.length < maxPages);
+  return pages;
+}
+function runReviewsContract(name, build, options = {}) {
+  describe11(`ReviewsAdapter contract: ${name}`, () => {
+    it12(
+      "submitReview returns the created review",
+      async () => {
+        const adapter = await build();
+        const productId = `contract-reviews-${randomUUID4()}`;
+        const { review } = await adapter.submitReview({
+          productId,
+          customerId: null,
+          orderId: null,
+          rating: 5,
+          title: "Great!",
+          body: "Really liked it."
+        });
+        expect12(review.productId).toBe(productId);
+        expect12(review.rating).toBe(5);
+        expect12(review.id).toBeTruthy();
+      },
+      CASE_MS
+    );
+    it12(
+      "getProductReviews returns the submitted review, read under the status submitReview reported",
+      async () => {
+        const adapter = await build();
+        const [review] = await seed(adapter, 1);
+        const { items } = await adapter.getProductReviews(review.productId, {
+          status: review.moderationStatus
+        });
+        expect12(items.map((r) => r.id)).toEqual([review.id]);
+        expect12(items[0].productId).toBe(review.productId);
+      },
+      CASE_MS
+    );
+    it12(
+      "getAggregateRating is consistent: its histogram sums to its count, and an approved review is counted",
+      async () => {
+        const adapter = await build();
+        const [review] = await seed(adapter, 1);
+        const agg = await adapter.getAggregateRating(review.productId);
+        expect12(agg.productId).toBe(review.productId);
+        expect12(Object.values(agg.histogram).reduce((a, b) => a + b, 0)).toBe(agg.count);
+        if (agg.count === 0) expect12(agg.average).toBe(0);
+        else {
+          expect12(agg.average).toBeGreaterThanOrEqual(1);
+          expect12(agg.average).toBeLessThanOrEqual(5);
+        }
+        if (review.moderationStatus === "approved") expect12(agg.count).toBeGreaterThanOrEqual(1);
+      },
+      CASE_MS
+    );
+    it12(
+      "pagination: over seeds larger than a page, the cursor walk from page 1 yields each review once, the walk is the seed, no page exceeds limit and nextCursor is null exactly on the last page",
+      async () => {
+        const adapter = await build();
+        await fc4.assert(
+          fc4.asyncProperty(
+            fc4.integer({ min: 1, max: 5 }),
+            fc4.integer({ min: 1, max: 8 }),
+            async (limit, extra) => {
+              const seeded = await seed(adapter, limit + extra);
+              const status = seeded[0].moderationStatus;
+              const expected = seeded.filter((r) => r.moderationStatus === status).map((r) => r.id);
+              const pages = await walk3(
+                adapter,
+                seeded[0],
+                limit,
+                Math.ceil(expected.length / limit) + 2
+              );
+              const walked = pages.flatMap((p) => p.items.map((r) => r.id));
+              expect12(new Set(walked).size, "a review came back on two pages").toBe(walked.length);
+              expect12([...walked].sort()).toEqual([...expected].sort());
+              for (const page of pages) expect12(page.items.length).toBeLessThanOrEqual(limit);
+              expect12(pages.map((p) => p.nextCursor === null)).toEqual(
+                pages.map((_, i) => i === pages.length - 1)
+              );
+            }
+          ),
+          { numRuns: 15 }
+        );
+      },
+      12e4
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "getProductReviews()",
+      (adapter) => adapter.getProductReviews(`contract-reviews-${randomUUID4()}`, { limit: 1 })
+    );
+  });
+}
+
+// src/search.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import fc5 from "fast-check";
+import { describe as describe12, expect as expect13, it as it13 } from "vitest";
+
+// src/search-oracle.ts
+function searchTerms(text) {
+  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+function toSearchDocument(p) {
+  return {
+    id: p.id,
+    type: "product",
+    fields: {
+      slug: p.id,
+      name: p.name,
+      description: p.description,
+      status: "active",
+      categoryIds: p.categoryIds,
+      variants: p.variants.map((v) => ({ sku: v.sku, name: v.name, priceMinor: v.priceMinor }))
+    }
+  };
+}
+function prefixed(queryTerms, docTerms) {
+  return queryTerms.every((q) => docTerms.some((d) => d.startsWith(q)));
+}
+function strongTerms(p) {
+  return [
+    ...searchTerms(p.name),
+    ...p.variants.flatMap((v) => [...searchTerms(v.sku), ...searchTerms(v.name)])
+  ];
+}
+function matchesQuery(p, query) {
+  const q = searchTerms(query);
+  return q.length > 0 && prefixed(q, [...strongTerms(p), ...searchTerms(p.description)]);
+}
+function tierOf(p, query) {
+  const q = searchTerms(query);
+  if (prefixed(q, searchTerms(p.name))) return 2;
+  if (prefixed(q, strongTerms(p))) return 1;
+  return 0;
+}
+
+// src/search.ts
+function runToken() {
+  return `t${randomUUID5().replace(/-/g, "").slice(0, 15)}`;
+}
+var word = fc5.string({
+  unit: fc5.constantFrom("a", "b", "c", "d", "1", "2"),
+  minLength: 1,
+  maxLength: 3
+});
+var words = (max) => fc5.array(word, { maxLength: max }).map((ws) => ws.join(" "));
+var CATEGORIES = 3;
+var genProduct = fc5.record({
+  name: words(3),
+  description: words(6),
+  variants: fc5.array(
+    fc5.record({ sku: word, name: words(2), priceMinor: fc5.integer({ min: 1, max: 2222 }) }),
+    { maxLength: 3 }
+  ),
+  categories: fc5.subarray([0, 1, 2])
+});
+function runCategories(token) {
+  return Array.from({ length: CATEGORIES }, (_, k) => `c${k}${token.slice(1)}`);
+}
+function materialise(token, gen, i, cats) {
+  return {
+    id: `${token}-${i}`,
+    name: gen.name === "" ? token : `${token} ${gen.name}`,
+    description: gen.description,
+    variants: gen.variants,
+    categoryIds: gen.categories.map((k) => cats[k])
+  };
+}
+async function walk4(adapter, query, limit, expectedMatches, filters) {
+  const maxPages = Math.ceil(expectedMatches / limit) + 2;
+  const pages = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cursor;
+  for (; ; ) {
+    const page = await adapter.search(query, {
+      limit,
+      ...cursor !== void 0 && { cursor },
+      ...filters !== void 0 && { filters }
+    });
+    pages.push(page);
+    const again = page.items.map((item) => item.id).filter((id) => seen.has(id));
+    expect13(again, `the walk for "${query}": an id came back on page ${pages.length}`).toEqual([]);
+    for (const item of page.items) seen.add(item.id);
+    if (page.nextCursor === null) return pages;
+    expect13(
+      pages.length,
+      `the walk for "${query}" did not end within ${maxPages} pages`
+    ).toBeLessThan(maxPages);
+    cursor = page.nextCursor;
+  }
+}
+var idsOf2 = (pages) => pages.flatMap((p) => p.items.map((item) => item.id));
+function expectExactWalk(pages, expected, limit, label) {
+  const ids2 = idsOf2(pages);
+  expect13(new Set(ids2).size, `${label}: an id came back on two pages`).toBe(ids2.length);
+  expect13([...ids2].sort(), `${label}: the walk's union is not the oracle's match set`).toEqual(
+    [...expected].sort()
+  );
+  for (const [i, page] of pages.entries()) {
+    expect13(page.total, `${label}: total on page ${i + 1}`).toBe(expected.length);
+    expect13(page.items.length, `${label}: page ${i + 1} exceeds limit`).toBeLessThanOrEqual(limit);
+    expect13(
+      page.nextCursor === null,
+      `${label}: nextCursor is null on page ${i + 1} of ${pages.length}`
+    ).toBe(i === pages.length - 1);
+    if (expected.length > 0)
+      expect13(page.items.length, `${label}: page ${i + 1} is empty`).toBeGreaterThan(0);
+  }
+}
+var SLOW6 = 18e4;
+function runSearchContract(name, build, options = {}) {
+  const numRuns = options.numRuns ?? 25;
+  describe12(`SearchAdapter contract: ${name}`, () => {
+    it13(
+      "index returns count of indexed documents",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.index([
+          { id: "doc-1", type: "product", fields: { name: "Widget" } },
+          { id: "doc-2", type: "product", fields: { name: "Gadget" } }
+        ]);
+        expect13(result.indexed).toBe(2);
+      },
+      CASE_MS
+    );
+    it13(
+      "search returns indexed documents",
+      async () => {
+        const adapter = await build();
+        await adapter.index([
+          { id: "search-doc-1", type: "product", fields: { name: "Searchable Item" } }
+        ]);
+        const result = await adapter.search("Searchable");
+        expect13(result.items.length).toBeGreaterThanOrEqual(1);
+        expect13(result.total).toBeGreaterThanOrEqual(1);
+      },
+      CASE_MS
+    );
+    it13(
+      "remove deletes documents from index",
+      async () => {
+        const adapter = await build();
+        const tag = `remove-${randomUUID5()}`;
+        await adapter.index([{ id: tag, type: "product", fields: { name: "To Remove" } }]);
+        await adapter.remove([tag]);
+        const result = await adapter.search("To Remove");
+        expect13(result.items.find((i) => i.id === tag)).toBeUndefined();
+      },
+      CASE_MS
+    );
+    it13(
+      "facet returns values for a field",
+      async () => {
+        const adapter = await build();
+        await adapter.index([
+          { id: "facet-doc-1", type: "product", fields: { category: "shirts" } },
+          { id: "facet-doc-2", type: "product", fields: { category: "trousers" } },
+          { id: "facet-doc-3", type: "product", fields: { category: "shirts" } }
+        ]);
+        const facet = await adapter.facet("category");
+        expect13(typeof facet.field).toBe("string");
+        expect13(typeof facet.label).toBe("string");
+        expect13(Array.isArray(facet.values)).toBe(true);
+        if (facet.values.length > 0) {
+          expect13(typeof facet.values[0].value).toBe("string");
+        }
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "search()",
+      (adapter) => adapter.search("contract", { limit: 1 })
+    );
+    describe12("pages, ranking, facets and hostile input", () => {
+      it13(
+        "over generated catalogues and page sizes, the cursor walk yields each oracle match exactly once, total is exact on every page, nextCursor is null exactly on the last page and no page exceeds limit, with and without a category filter, after removals and re-indexes",
+        async () => {
+          const adapter = await build();
+          await fc5.assert(
+            fc5.asyncProperty(
+              // The page size first: fast-check shrinks the arguments in order, so a failing walk shrinks its limit
+              // before its catalogue, and the catalogue's products are shrunk once there are few of them.
+              fc5.integer({ min: 1, max: 40 }),
+              fc5.array(fc5.record({ first: genProduct, second: fc5.option(genProduct) }), {
+                maxLength: 300,
+                size: "large"
+              }),
+              fc5.array(word, { maxLength: 2 }),
+              fc5.integer({ min: 0, max: CATEGORIES - 1 }),
+              fc5.func(fc5.boolean()),
+              async (limit, catalogue, queryWords, filterCategory, removeIt) => {
+                const token = runToken();
+                const cats = runCategories(token);
+                const first = catalogue.map((c, i) => materialise(token, c.first, i, cats));
+                try {
+                  const indexed = await adapter.index(first.map(toSearchDocument));
+                  expect13(indexed.indexed).toBe(first.length);
+                  const current = catalogue.map(
+                    (c, i) => c.second === null ? first[i] : materialise(token, c.second, i, cats)
+                  );
+                  const rewritten = current.filter((_, i) => catalogue[i].second !== null);
+                  if (rewritten.length > 0) await adapter.index(rewritten.map(toSearchDocument));
+                  const removed = current.filter((p) => removeIt(p.id));
+                  if (removed.length > 0) await adapter.remove(removed.map((p) => p.id));
+                  const gone = new Set(removed.map((p) => p.id));
+                  const live = current.filter((p) => !gone.has(p.id));
+                  const query = [token, ...queryWords].join(" ");
+                  const matches = live.filter((p) => matchesQuery(p, query));
+                  const all = await walk4(adapter, query, limit, matches.length);
+                  expectExactWalk(
+                    all,
+                    matches.map((p) => p.id),
+                    limit,
+                    `"${query}" limit ${limit}`
+                  );
+                  const category = cats[filterCategory];
+                  const inCategory = matches.filter((p) => p.categoryIds.includes(category));
+                  const filtered = await walk4(adapter, query, limit, inCategory.length, {
+                    categoryIds: category
+                  });
+                  expectExactWalk(
+                    filtered,
+                    inCategory.map((p) => p.id),
+                    limit,
+                    `"${query}" in ${category} limit ${limit}`
+                  );
+                  const shown = [...idsOf2(all), ...idsOf2(filtered)];
+                  expect13(
+                    shown.filter((id) => gone.has(id)),
+                    "a removed id came back"
+                  ).toEqual([]);
+                } finally {
+                  await adapter.remove(first.map((p) => p.id));
+                }
+              }
+            ),
+            { numRuns }
+          );
+        },
+        SLOW6
+      );
+      if (options.ranking) {
+        it13(
+          "for any query, every all-terms-in-name match ranks above every other match and every name/SKU/variant-name match above every description-only match, however often the description repeats the term, and the same query walks in the same order twice",
+          async () => {
+            const adapter = await build();
+            const placed = fc5.record({
+              base: genProduct,
+              inName: fc5.boolean(),
+              inSku: fc5.boolean(),
+              inVariant: fc5.boolean(),
+              descriptionRepeats: fc5.integer({ min: 0, max: 10 })
+            });
+            await fc5.assert(
+              fc5.asyncProperty(
+                fc5.array(placed, { minLength: 1, maxLength: 60 }),
+                word,
+                fc5.option(word),
+                fc5.integer({ min: 1, max: 30 }),
+                fc5.integer({ min: 1, max: 30 }),
+                async (catalogue, term, second, limitA, limitB) => {
+                  const token = runToken();
+                  const cats = runCategories(token);
+                  const products = catalogue.map((c, i) => {
+                    const p = materialise(token, c.base, i, cats);
+                    const variants = p.variants.length > 0 ? [...p.variants] : [{ sku: "zz", name: "", priceMinor: 1 }];
+                    if (c.inSku) variants[0] = { ...variants[0], sku: `${term}9` };
+                    if (c.inVariant)
+                      variants[0] = { ...variants[0], name: `${variants[0].name} ${term}` };
+                    return {
+                      ...p,
+                      name: c.inName ? `${p.name} ${term}` : p.name,
+                      description: `${p.description}${` ${term}`.repeat(c.descriptionRepeats)}`,
+                      variants
+                    };
+                  });
+                  try {
+                    await adapter.index(products.map(toSearchDocument));
+                    const query = [token, term, ...second === null ? [] : [second]].join(" ");
+                    const byId = new Map(products.map((p) => [p.id, p]));
+                    const matches = products.filter((p) => matchesQuery(p, query));
+                    const order = idsOf2(await walk4(adapter, query, limitA, matches.length));
+                    expect13([...order].sort(), "the walk is not the match set").toEqual(
+                      matches.map((p) => p.id).sort()
+                    );
+                    const tiers = order.map((id) => tierOf(byId.get(id), query));
+                    for (let i = 1; i < tiers.length; i++) {
+                      expect13(
+                        tiers[i - 1],
+                        `"${query}": ${order[i - 1]} (tier ${tiers[i - 1]}) ranked above ${order[i]} (tier ${tiers[i]})`
+                      ).toBeGreaterThanOrEqual(tiers[i]);
+                    }
+                    const again = idsOf2(await walk4(adapter, query, limitB, matches.length));
+                    expect13(again, `"${query}" walked at limit ${limitA}, then ${limitB}`).toEqual(
+                      order
+                    );
+                  } finally {
+                    await adapter.remove(products.map((p) => p.id));
+                  }
+                }
+              ),
+              { numRuns }
+            );
+          },
+          SLOW6
+        );
+      }
+      if (options.facets) {
+        it13(
+          "facet('categoryIds', {query, filters}) counts, per category id, exactly the oracle's matches in that category under the filters, lists no category without one, and orders by count descending, then value",
+          async () => {
+            const adapter = await build();
+            expect13(adapter.capabilities()).toContain("facet");
+            await fc5.assert(
+              fc5.asyncProperty(
+                fc5.array(genProduct, { maxLength: 150, size: "medium" }),
+                fc5.array(word, { maxLength: 2 }),
+                fc5.option(fc5.integer({ min: 0, max: CATEGORIES - 1 })),
+                async (catalogue, queryWords, filterCategory) => {
+                  const token = runToken();
+                  const cats = runCategories(token);
+                  const products = catalogue.map((g, i) => materialise(token, g, i, cats));
+                  try {
+                    await adapter.index(products.map(toSearchDocument));
+                    const query = [token, ...queryWords].join(" ");
+                    const filter = filterCategory === null ? void 0 : cats[filterCategory];
+                    const matches = products.filter(
+                      (p) => matchesQuery(p, query) && (filter === void 0 || p.categoryIds.includes(filter))
+                    );
+                    const expected = /* @__PURE__ */ new Map();
+                    for (const p of matches)
+                      for (const c of p.categoryIds) expected.set(c, (expected.get(c) ?? 0) + 1);
+                    const facet = await adapter.facet("categoryIds", {
+                      query,
+                      ...filter !== void 0 && { filters: { categoryIds: filter } }
+                    });
+                    const label = `facet for "${query}"${filter === void 0 ? "" : ` in ${filter}`}`;
+                    expect13(
+                      Object.fromEntries(facet.values.map((v) => [v.value, v.count])),
+                      label
+                    ).toEqual(Object.fromEntries(expected));
+                    const ordered = [...expected.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).map(([value]) => value);
+                    expect13(
+                      facet.values.map((v) => v.value),
+                      `${label}: order`
+                    ).toEqual(ordered);
+                  } finally {
+                    await adapter.remove(products.map((p) => p.id));
+                  }
+                }
+              ),
+              { numRuns }
+            );
+          },
+          SLOW6
+        );
+      }
+      describe12("hostile input", () => {
+        const operator = fc5.constantFrom(
+          '"',
+          "*",
+          "NEAR",
+          "NEAR(",
+          ":",
+          "&",
+          "|",
+          "!",
+          "(",
+          ")",
+          "-",
+          "^",
+          "AND",
+          "OR",
+          "NOT",
+          "'",
+          "\\",
+          "{",
+          "}",
+          "<->",
+          ":*",
+          "+",
+          "%",
+          "_",
+          ";",
+          "\0"
+        );
+        const fragment = fc5.oneof(
+          fc5.string({ unit: "binary", maxLength: 6 }),
+          operator,
+          word,
+          word.map((w) => w.toUpperCase())
+        );
+        const hostile = fc5.array(fragment, { maxLength: 6 }).map((fs) => fs.join(""));
+        const longTerm = "a".repeat(2047);
+        const plain = { name: "a b", description: "c", variants: [], categories: [0] };
+        it13(
+          "any string after the run token, full unicode and FTS operators included, never throws and returns exactly the oracle's matches for the query's normalised terms",
+          async () => {
+            const adapter = await build();
+            await fc5.assert(
+              fc5.asyncProperty(
+                fc5.array(genProduct, { maxLength: 40 }),
+                hostile,
+                async (catalogue, raw) => {
+                  const token = runToken();
+                  const cats = runCategories(token);
+                  const products = catalogue.map((g, i) => materialise(token, g, i, cats));
+                  try {
+                    await adapter.index(products.map(toSearchDocument));
+                    const query = `${token} ${raw}`;
+                    const expected = products.filter((p) => matchesQuery(p, query)).map((p) => p.id);
+                    const result = await adapter.search(query, { limit: 100 });
+                    expect13(result.items.map((d) => d.id).sort(), JSON.stringify(query)).toEqual(
+                      expected.sort()
+                    );
+                    expect13(result.total, JSON.stringify(query)).toBe(expected.length);
+                  } finally {
+                    await adapter.remove(products.map((p) => p.id));
+                  }
+                }
+              ),
+              {
+                numRuns: numRuns * 2,
+                // A term one byte past Postgres's longest lexeme (2046 bytes; terms are ASCII, so bytes are
+                // characters): in the query, in a description, and in both.
+                examples: [
+                  [[plain], longTerm],
+                  [[{ ...plain, description: `c ${longTerm}` }], ""],
+                  [[{ ...plain, description: longTerm }], longTerm]
+                ]
+              }
+            );
+          },
+          SLOW6
+        );
+        it13(
+          "input with no terms returns no items, total 0 and no next page, over an index that holds products",
+          async () => {
+            const adapter = await build();
+            const token = runToken();
+            const products = Array.from({ length: 5 }, (_, i) => ({
+              id: `${token}-${i}`,
+              name: `${token} a b`,
+              description: "c d",
+              variants: [{ sku: "a1", name: "b", priceMinor: 100 }],
+              categoryIds: []
+            }));
+            await adapter.index(products.map(toSearchDocument));
+            try {
+              const termless = fc5.array(
+                fc5.oneof(
+                  operator,
+                  fc5.string({ unit: "binary", maxLength: 4 }),
+                  fc5.constantFrom(" ", "	", "\n")
+                ),
+                { maxLength: 6 }
+              ).map((fs) => fs.join("")).filter((s) => searchTerms(s).length === 0);
+              await fc5.assert(
+                fc5.asyncProperty(termless, async (raw) => {
+                  const result = await adapter.search(raw, { limit: 20 });
+                  expect13(result.items.length, JSON.stringify(raw)).toBe(0);
+                  expect13(result.total, JSON.stringify(raw)).toBe(0);
+                  expect13(result.nextCursor, JSON.stringify(raw)).toBeNull();
+                }),
+                {
+                  numRuns: numRuns * 2,
+                  examples: [[""], [" "], ["   "], ["*"], ['"'], ["-"], ["\xE9"]]
+                }
+              );
+            } finally {
+              await adapter.remove(products.map((p) => p.id));
+            }
+          },
+          SLOW6
+        );
+        it13(
+          "a malformed cursor (undecodable, negative, non-integer) rejects, and a cursor at or past total, as after a removal between two pages, is an empty page with nextCursor null",
+          async () => {
+            const adapter = await build();
+            const token = runToken();
+            const products = Array.from({ length: 6 }, (_, i) => ({
+              id: `${token}-${i}`,
+              name: `${token} cursor ${i}`,
+              description: "",
+              variants: [],
+              categoryIds: []
+            }));
+            await adapter.index(products.map(toSearchDocument));
+            try {
+              const first = await adapter.search(token, { limit: 4 });
+              expect13(first.total).toBe(products.length);
+              expect13(first.nextCursor, "six matches at limit 4 have a second page").not.toBeNull();
+              for (const cursor of ["not a cursor", "%%%", "!!"]) {
+                await expect13(
+                  adapter.search(token, { limit: 2, cursor }),
+                  `cursor ${cursor}`
+                ).rejects.toThrow();
+              }
+              if (options.cursorAt !== void 0) {
+                for (const offset of [-1, -20, 1.5, 0.25]) {
+                  await expect13(
+                    adapter.search(token, { limit: 2, cursor: options.cursorAt(offset) }),
+                    `cursor at offset ${offset}`
+                  ).rejects.toThrow();
+                }
+              }
+              const kept = products.slice(0, 2);
+              await adapter.remove(products.slice(2).map((p) => p.id));
+              const stale = await adapter.search(token, { limit: 4, cursor: first.nextCursor });
+              expect13(stale.items.length).toBe(0);
+              expect13(stale.nextCursor).toBeNull();
+              expect13(stale.total).toBe(kept.length);
+              if (options.cursorAt !== void 0) {
+                for (const offset of [kept.length, kept.length + 7]) {
+                  const past = await adapter.search(token, {
+                    limit: 4,
+                    cursor: options.cursorAt(offset)
+                  });
+                  expect13(past.items.length, `offset ${offset}`).toBe(0);
+                  expect13(past.nextCursor, `offset ${offset}`).toBeNull();
+                  expect13(past.total, `offset ${offset}`).toBe(kept.length);
+                }
+              }
+            } finally {
+              await adapter.remove(products.map((p) => p.id));
+            }
+          },
+          SLOW6
+        );
+      });
+    });
+  });
+}
+
+// src/shipping.ts
+import { describe as describe13, expect as expect14, it as it14 } from "vitest";
+var REQUEST = {
+  fromPostalCode: "SW1A 1AA",
+  toPostalCode: "EC1A 1BB",
+  toCountry: "GB",
+  weightGrams: 500,
+  currency: "GBP"
+};
+function runShippingContract(name, build, options = {}) {
+  describe13(`ShippingAdapter contract: ${name}`, () => {
+    it14(
+      "rate returns an array of shipping options",
+      async () => {
+        const adapter = await build();
+        const rates = await adapter.rate(REQUEST);
+        expect14(Array.isArray(rates)).toBe(true);
+        if (rates.length > 0) {
+          const rate = rates[0];
+          expect14(typeof rate.amountMinor).toBe("number");
+          expect14(typeof rate.carrier).toBe("string");
+          expect14(typeof rate.estimatedDays).toBe("number");
+        }
+      },
+      CASE_MS
+    );
+    healthAndDowntime(build, options.unreachable, "rate()", (adapter) => adapter.rate(REQUEST));
+  });
+}
+
+// src/tax.ts
+import { describe as describe14, expect as expect15, it as it15 } from "vitest";
+var REQUEST2 = {
+  currency: "GBP",
+  shippingCountry: "GB",
+  shippingRegion: "England",
+  lines: [{ amountMinor: 1e3, qty: 2 }]
+};
+function runTaxContract(name, build, options = {}) {
+  describe14(`TaxAdapter contract: ${name}`, () => {
+    it15(
+      "calculate returns totalTaxMinor >= 0",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.calculate(REQUEST2);
+        expect15(typeof result.totalTaxMinor).toBe("number");
+        expect15(result.totalTaxMinor).toBeGreaterThanOrEqual(0);
+        expect15(result.ratePerLine).toHaveLength(1);
+        expect15(typeof result.ratePerLine[0].taxMinor).toBe("number");
+      },
+      CASE_MS
+    );
+    it15(
+      "calculate with zero amount returns zero tax",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.calculate({
+          ...REQUEST2,
+          lines: [{ amountMinor: 0, qty: 1 }]
+        });
+        expect15(result.totalTaxMinor).toBe(0);
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "calculate()",
+      (adapter) => adapter.calculate(REQUEST2)
+    );
+  });
+}
+
+// src/adapter-context.ts
+var silent = {
+  trace: () => void 0,
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  child: () => silent
+};
+function adapterContext(slot, config, env = {}) {
+  return { slot, config, logger: silent, env };
+}
+
+// src/security.ts
+import { describe as describe15, expect as expect16, it as it16 } from "vitest";
+var testConfig = {
+  rateLimit: {
+    api: { requests: 100, window: "1m", action: "block" }
+  },
+  csrf: false,
+  headers: {
+    hsts: true,
+    contentSecurityPolicy: "default-src 'self'",
+    referrerPolicy: "strict-origin-when-cross-origin",
+    xFrameOptions: "DENY"
+  }
+};
+function runSecurityContract(name, build, options = {}) {
+  describe15(`SecurityAdapter contract: ${name}`, () => {
+    it16(
+      "validate accepts a valid config",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.validate(testConfig);
+        expect16(typeof result.valid).toBe("boolean");
+        expect16(Array.isArray(result.errors)).toBe(true);
+      },
+      CASE_MS
+    );
+    it16(
+      "validate of empty config reports errors",
+      async () => {
+        const adapter = await build();
+        const result = await adapter.validate({});
+        if (!result.valid) {
+          expect16(result.errors.length).toBeGreaterThan(0);
+        }
+      },
+      CASE_MS
+    );
+    healthAndDowntime(
+      build,
+      options.unreachable,
+      "validate()",
+      async (adapter) => adapter.validate(testConfig)
+    );
+  });
+}
+
+// src/projection.ts
+import { describe as describe16, it as it17, expect as expect17 } from "vitest";
+function makeEvent2(id) {
+  return {
+    id,
+    type: "test.event.v1",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "test",
+    correlationId: "corr-1",
+    payload: { id },
+    metadata: { storeId: "test", environment: "development", version: "0.0.0" }
+  };
+}
+function runProjectionContract(opts) {
+  describe16("Projection idempotency contract", () => {
+    it17("processing the same event twice applies the mutation only once", async () => {
+      const ctx = await opts.build();
+      const event2 = makeEvent2("dedup-evt-001");
+      await ctx.handle(event2);
+      await ctx.handle(event2);
+      expect17(await ctx.applicationCount()).toBe(1);
+    });
+    it17("distinct events each apply their mutation", async () => {
+      const ctx = await opts.build();
+      await ctx.handle(makeEvent2("distinct-evt-001"));
+      await ctx.handle(makeEvent2("distinct-evt-002"));
+      expect17(await ctx.applicationCount()).toBe(2);
+    });
+    it17("after reprocessing a batch the count equals unique event count", async () => {
+      const ctx = await opts.build();
+      const events = [makeEvent2("batch-001"), makeEvent2("batch-002"), makeEvent2("batch-003")];
+      for (const e of events) await ctx.handle(e);
+      for (const e of events) await ctx.handle(e);
+      expect17(await ctx.applicationCount()).toBe(3);
+    });
+  });
+}
+
+// src/index.ts
+async function fetchOverHttp(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`GET ${url} answered ${response.status}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+var suites = {
+  payments: runPaymentsContract,
+  email: runEmailContract,
+  reviews: runReviewsContract,
+  search: runSearchContract,
+  analytics: runAnalyticsContract,
+  shipping: runShippingContract,
+  tax: runTaxContract,
+  ai: runAiContract,
+  documentStore: runDocumentStoreContract,
+  eventBus: runEventBusContract,
+  media: (name, build, options = {}) => runMediaStorageContract(name, build, {
+    fetchUrl: fetchOverHttp,
+    ...options
+  })
+};
+var contractSuites = suites;
+export {
+  BOUND_MS,
+  CONTRACT_KINDS,
+  adapterContext,
+  contractSuites,
+  matchesQuery,
+  runAiContract,
+  runAnalyticsContract,
+  runDocumentStoreContract,
+  runEmailContract,
+  runEventBusContract,
+  runMediaStorageContract,
+  runPaymentsContract,
+  runProjectionContract,
+  runReviewsContract,
+  runSearchContract,
+  runSecurityContract,
+  runShippingContract,
+  runTaxContract,
+  searchTerms,
+  toSearchDocument
+};
+//# sourceMappingURL=index.js.map