@shirudo/ddd-kit 2.0.0 → 2.2.0

package/dist/testing.js

@@ -14,6 +14,7 @@ var BUILT_IN_TAGS = /* @__PURE__ */ new Set([
   "[object Boolean]",
   "[object Number]",
   "[object String]",
+  "[object BigInt]",
   "[object ArrayBuffer]",
   "[object SharedArrayBuffer]",
   "[object DataView]"
@@ -34,11 +35,113 @@ var arrayBufferByteLengthGet = intrinsicGetter(
   ArrayBuffer.prototype,
   "byteLength"
 );
+var sharedArrayBufferByteLengthGet = typeof SharedArrayBuffer === "undefined" ? void 0 : intrinsicGetter(SharedArrayBuffer.prototype, "byteLength");
 var regExpSourceGet = intrinsicGetter(RegExp.prototype, "source");
 var booleanValueOf = Boolean.prototype.valueOf;
 var numberValueOf = Number.prototype.valueOf;
 var stringValueOf = String.prototype.valueOf;
+var bigIntValueOf = BigInt.prototype.valueOf;
+var functionToString = Function.prototype.toString;
 var PROBE_KEY = {};
+var INTRINSIC_CONSTRUCTOR_NAMES = [
+  "Object",
+  "Array",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "AggregateError",
+  "Boolean",
+  "Number",
+  "String",
+  "BigInt",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+];
+var intrinsicConstructorSources = new Map(
+  INTRINSIC_CONSTRUCTOR_NAMES.flatMap((name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
+    const intrinsic = descriptor?.value;
+    return typeof intrinsic === "function" ? [[name, functionToString.call(intrinsic)]] : [];
+  })
+);
+var intrinsicConstructorSourceSet = new Set(
+  intrinsicConstructorSources.values()
+);
+var ERROR_INTRINSIC_NAMES = [
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "AggregateError"
+];
+function isIntrinsicConstructorPrototype(prototype, expectedName) {
+  const constructorDescriptor = Object.getOwnPropertyDescriptor(
+    prototype,
+    "constructor"
+  );
+  const candidateConstructor = constructorDescriptor?.value;
+  if (constructorDescriptor === void 0 || !("value" in constructorDescriptor) || typeof candidateConstructor !== "function") {
+    return false;
+  }
+  let candidateSource;
+  try {
+    candidateSource = functionToString.call(candidateConstructor);
+  } catch {
+    return false;
+  }
+  const expectedSource = expectedName === void 0 ? void 0 : intrinsicConstructorSources.get(expectedName);
+  if (expectedSource !== void 0 && candidateSource !== expectedSource || expectedSource === void 0 && !intrinsicConstructorSourceSet.has(candidateSource)) {
+    return false;
+  }
+  const nameDescriptor = Object.getOwnPropertyDescriptor(
+    candidateConstructor,
+    "name"
+  );
+  const candidateName = nameDescriptor !== void 0 && "value" in nameDescriptor && typeof nameDescriptor.value === "string" ? nameDescriptor.value : void 0;
+  const intrinsicName = expectedName ?? candidateName;
+  const intrinsicSource = intrinsicName === void 0 ? void 0 : intrinsicConstructorSources.get(intrinsicName);
+  return candidateName === intrinsicName && intrinsicSource !== void 0 && candidateSource === intrinsicSource && Object.getOwnPropertyDescriptor(candidateConstructor, "prototype")?.value === prototype;
+}
+__name(isIntrinsicConstructorPrototype, "isIntrinsicConstructorPrototype");
+function hasNativePrototype(value, expectedName) {
+  const visited = /* @__PURE__ */ new WeakSet();
+  let prototype = Object.getPrototypeOf(value);
+  while (prototype !== null && !visited.has(prototype)) {
+    visited.add(prototype);
+    if (isIntrinsicConstructorPrototype(prototype, expectedName)) {
+      return true;
+    }
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  return false;
+}
+__name(hasNativePrototype, "hasNativePrototype");
 function hasBrand(obj, tag) {
   try {
     switch (tag) {
@@ -66,6 +169,10 @@ function hasBrand(obj, tag) {
       case "[object ArrayBuffer]":
         arrayBufferByteLengthGet.call(obj);
         return true;
+      case "[object SharedArrayBuffer]":
+        if (!sharedArrayBufferByteLengthGet) return false;
+        sharedArrayBufferByteLengthGet.call(obj);
+        return true;
       case "[object Boolean]":
         booleanValueOf.call(obj);
         return true;
@@ -75,8 +182,17 @@ function hasBrand(obj, tag) {
       case "[object String]":
         stringValueOf.call(obj);
         return true;
-      default:
+      case "[object BigInt]":
+        bigIntValueOf.call(obj);
         return true;
+      case "[object Promise]":
+        return hasNativePrototype(obj, "Promise");
+      case "[object Error]":
+        return ERROR_INTRINSIC_NAMES.some(
+          (name) => hasNativePrototype(obj, name)
+        );
+      default:
+        return false;
     }
   } catch {
     return false;
@@ -149,12 +265,17 @@ function deepEqualInner(a, b, visited) {
   }
   if (Array.isArray(objA) || Array.isArray(objB)) {
     if (!Array.isArray(objA) || !Array.isArray(objB)) return false;
+    if (objA.length !== objB.length) return false;
+    const keysA = Reflect.ownKeys(objA).filter((key) => key !== "length");
+    const keysB = Reflect.ownKeys(objB).filter((key) => key !== "length");
+    if (keysA.length !== keysB.length) return false;
     const arrA = objA;
     const arrB = objB;
-    const len = arrA.length;
-    if (len !== arrB.length) return false;
-    for (let i = 0; i < len; i++) {
-      if (!deepEqualInner(arrA[i], arrB[i], visited)) return false;
+    for (const key of keysA) {
+      if (!objHasOwn.call(objB, key)) return false;
+      if (!deepEqualInner(arrA[key], arrB[key], visited)) {
+        return false;
+      }
     }
     return true;
   }
@@ -198,7 +319,8 @@ function deepEqualInner(a, b, visited) {
     }
     case "[object Boolean]":
     case "[object Number]":
-    case "[object String]": {
+    case "[object String]":
+    case "[object BigInt]": {
       return sameValueZero(
         objA.valueOf(),
         objB.valueOf()
@@ -213,8 +335,8 @@ __name(deepEqualInner, "deepEqualInner");
 function comparePlainObjects(objA, objB, visited) {
   const recA = objA;
   const recB = objB;
-  const stringKeysA = Object.keys(objA);
-  const stringKeysB = Object.keys(objB);
+  const stringKeysA = Object.getOwnPropertyNames(objA);
+  const stringKeysB = Object.getOwnPropertyNames(objB);
   if (stringKeysA.length !== stringKeysB.length) return false;
   const symbolKeysA = Object.getOwnPropertySymbols(objA);
   const symbolKeysB = Object.getOwnPropertySymbols(objB);
@@ -240,42 +362,133 @@ function comparePlainObjects(objA, objB, visited) {
 }
 __name(comparePlainObjects, "comparePlainObjects");
 
-// src/testing/repository-contract.ts
-function createRepositoryContractTests(harness) {
-  async function withEnvironment(body) {
-    const env = await harness.createEnvironment();
-    let bodyFailed = false;
-    let bodyError;
-    try {
-      await body(env);
-    } catch (error) {
-      bodyFailed = true;
-      bodyError = error;
+// src/testing/contract-assertions.ts
+async function runInContractEnvironment(createEnvironment, body) {
+  const env = await createEnvironment();
+  let bodyFailed = false;
+  let bodyError;
+  try {
+    await body(env);
+  } catch (error) {
+    bodyFailed = true;
+    bodyError = error;
+  }
+  try {
+    await env.teardown?.();
+  } catch (teardownError) {
+    if (!bodyFailed) {
+      throw teardownError;
     }
+  }
+  if (bodyFailed) {
+    throw bodyError;
+  }
+}
+__name(runInContractEnvironment, "runInContractEnvironment");
+function captureRejection(promise) {
+  return promise.then(
+    () => void 0,
+    (error) => error
+  );
+}
+__name(captureRejection, "captureRejection");
+async function loadAggregateOrFail(repository, id, suspectHint) {
+  const loaded = await repository.getById(id);
+  assert(
+    loaded !== null,
+    `getById(${String(id)}) returned null for an aggregate that must exist: ${suspectHint}`
+  );
+  return loaded;
+}
+__name(loadAggregateOrFail, "loadAggregateOrFail");
+function skippedContractTest(name, capability) {
+  return {
+    name,
+    skipped: { capability },
+    run: /* @__PURE__ */ __name(async () => {
+      throw new Error(
+        `Repository contract test skipped: harness capability '${capability}' is not provided. Bind skipped tests with it.skip ((test.skipped ? it.skip : it)(test.name, test.run)) or provide the capability; each one closes a real OCC hole.`
+      );
+    }, "run")
+  };
+}
+__name(skippedContractTest, "skippedContractTest");
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Repository contract violated: ${message}`);
+  }
+}
+__name(assert, "assert");
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(
+      `Repository contract violated: ${message} (expected ${String(expected)}, got ${String(actual)})`
+    );
+  }
+}
+__name(assertEqual, "assertEqual");
+function chainContainsErrorNamed(error, name) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== null && current !== void 0 && !seen.has(current)) {
+    if (typeof current !== "object") {
+      return false;
+    }
+    if (errorMatchesName(current, name)) {
+      return true;
+    }
+    seen.add(current);
     try {
-      await env.teardown?.();
-    } catch (teardownError) {
-      if (!bodyFailed) {
-        throw teardownError;
-      }
+      current = current.cause;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+__name(chainContainsErrorNamed, "chainContainsErrorNamed");
+function chainContainsErrorNamedAnyOf(error, names) {
+  return names.some((name) => chainContainsErrorNamed(error, name));
+}
+__name(chainContainsErrorNamedAnyOf, "chainContainsErrorNamedAnyOf");
+function errorMatchesName(candidate, name) {
+  try {
+    if (candidate.name === name) {
+      return true;
     }
-    if (bodyFailed) {
-      throw bodyError;
+  } catch {
+  }
+  try {
+    let proto = Object.getPrototypeOf(candidate);
+    for (let depth = 0; proto !== null && depth < 20; depth++) {
+      if (proto.constructor?.name === name) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
     }
+  } catch {
   }
-  __name(withEnvironment, "withEnvironment");
-  async function loadOrFail(repository, id) {
-    const loaded = await repository.getById(id);
-    assert(
-      loaded !== null,
-      `getById(${String(id)}) returned null for an aggregate that must exist - broken hydration or a write that did not commit`
-    );
-    return loaded;
+  return false;
+}
+__name(errorMatchesName, "errorMatchesName");
+function describeError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
   }
-  __name(loadOrFail, "loadOrFail");
+  return String(error);
+}
+__name(describeError, "describeError");
+
+// src/testing/es-repository-contract.ts
+function createEsRepositoryContractTests(harness) {
+  const withEnvironment = /* @__PURE__ */ __name((body) => runInContractEnvironment(() => harness.createEnvironment(), body), "withEnvironment");
+  const loadOrFail = /* @__PURE__ */ __name((repository, id) => loadAggregateOrFail(
+    repository,
+    id,
+    "broken replay read or a write that did not commit"
+  ), "loadOrFail");
   async function seed(env) {
     const aggregate = harness.createAggregate();
-    harness.mutate(aggregate);
     await env.run(async ({ repository }) => {
       await repository.save(aggregate);
     });
@@ -286,13 +499,291 @@ function createRepositoryContractTests(harness) {
     return env.run(({ repository }) => loadOrFail(repository, id));
   }
   __name(reload, "reload");
-  function captureRejection(promise) {
-    return promise.then(
-      () => void 0,
-      (error) => error
-    );
+  const orderedIds = /* @__PURE__ */ __name((events) => events.map((event) => event.eventId), "orderedIds");
+  const sortedIds = /* @__PURE__ */ __name((events) => orderedIds(events).sort(), "sortedIds");
+  const snapshotState = harness.snapshotState;
+  const createAggregateWithId = harness.createAggregateWithId;
+  const skippedTest = /* @__PURE__ */ __name((name, capability) => skippedContractTest(name, capability), "skippedTest");
+  const tests = [
+    {
+      name: "MANDATORY two-writer conflict: the stale writer's append throws ConcurrencyConflictError and the stream is untouched",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const seedStream = await env.committedStreamEvents(seeded.id);
+        assert(
+          seedStream.length > 0,
+          "seeding must have appended the creation event to the stream"
+        );
+        const staleB = await reload(env, seeded.id);
+        const committedA = await env.run(async ({ repository }) => {
+          const a = await loadOrFail(repository, seeded.id);
+          harness.mutate(a);
+          await repository.save(a);
+          return a;
+        });
+        const streamAfterA = await env.committedStreamEvents(seeded.id);
+        assert(
+          streamAfterA.length === seedStream.length + 1,
+          "writer A's event must reach the stream on commit"
+        );
+        harness.mutate(staleB);
+        harness.mutate(staleB);
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(staleB);
+          })
+        );
+        assert(
+          rejection !== void 0,
+          "the second writer's commit must reject; it appended on a stale expectedVersion instead (append guard missing?)"
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "ConcurrencyConflictError"),
+          `the second writer's rejection must be (or wrap, via the cause chain) ConcurrencyConflictError; got: ${describeError(rejection)}`
+        );
+        const finalStream = await env.committedStreamEvents(seeded.id);
+        assert(
+          deepEqual(orderedIds(finalStream), orderedIds(streamAfterA)),
+          "the stream must contain exactly the winning writer's events in order: a rejected append must leave the stream untouched"
+        );
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          committedA.version,
+          "the reloaded version must equal writer A's committed version (version IS the event count)"
+        );
+        if (snapshotState) {
+          assert(
+            deepEqual(
+              snapshotState.call(harness, final),
+              snapshotState.call(harness, committedA)
+            ),
+            "the reloaded state must fold to writer A's state. Suspects: a partial append survived the rejection, or your snapshotState projection is not roundtrip-stable"
+          );
+        }
+        const outbox = await env.committedOutboxEvents();
+        assert(
+          deepEqual(sortedIds(outbox), sortedIds(streamAfterA)),
+          "the outbox must contain exactly the committed events (compared by eventId); nothing from the stale writer"
+        );
+      }), "run")
+    },
+    {
+      name: "replay equality: a reloaded aggregate folds the committed stream in emission order",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const aggregate = harness.createAggregate();
+        harness.mutate(aggregate);
+        harness.mutate(aggregate);
+        const emittedIds = orderedIds(aggregate.pendingEvents);
+        assertEqual(
+          emittedIds.length,
+          3,
+          "harness contract: createAggregate applies ONE creation event and mutate applies ONE event each"
+        );
+        await env.run(async ({ repository }) => {
+          await repository.save(aggregate);
+        });
+        const stream = await env.committedStreamEvents(aggregate.id);
+        assert(
+          deepEqual(orderedIds(stream), emittedIds),
+          "the committed stream must contain exactly the emitted events in emission order; reordering breaks every consumer's fold"
+        );
+        assertEqual(
+          aggregate.pendingEvents.length,
+          0,
+          "pending events must be cleared after a successful commit (markPersisted ran)"
+        );
+        assertEqual(
+          aggregate.persistedVersion,
+          aggregate.version,
+          "after a successful commit, persistedVersion must equal version"
+        );
+        const reloaded = await reload(env, aggregate.id);
+        assertEqual(
+          reloaded.version,
+          aggregate.version,
+          "the reloaded version must equal the event count"
+        );
+        assertEqual(
+          reloaded.persistedVersion,
+          reloaded.version,
+          "a reloaded aggregate's persistedVersion must equal its version"
+        );
+        assertEqual(
+          reloaded.pendingEvents.length,
+          0,
+          "a reloaded aggregate must not carry pending events (replay is not re-recording)"
+        );
+        if (snapshotState) {
+          assert(
+            deepEqual(
+              snapshotState.call(harness, reloaded),
+              snapshotState.call(harness, aggregate)
+            ),
+            "the reloaded aggregate must fold to the same state as the in-memory instance. Suspects: fold order (readStream must return emission order), or a snapshotState projection that is not roundtrip-stable"
+          );
+        }
+      }), "run")
+    },
+    {
+      name: "getById returns null for a stream that does not exist",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const never = harness.createAggregate();
+        const probe = await env.run(
+          ({ repository }) => repository.getById(never.id)
+        );
+        assert(
+          probe === null,
+          "getById of a never-persisted id must return null (empty stream = no aggregate)"
+        );
+      }), "run")
+    },
+    {
+      name: "identity map: two getById calls in one unit of work return the same instance",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        await env.run(async ({ repository }) => {
+          const first = await repository.getById(seeded.id);
+          const second = await repository.getById(seeded.id);
+          assert(
+            first !== null && first === second,
+            "repeated loads within one unit of work must return the SAME instance (identity map); distinct instances double-harvest events"
+          );
+        });
+      }), "run")
+    },
+    {
+      name: "rollback persists nothing: stream and outbox untouched, pending events survive, first save can be retried",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const aggregate = harness.createAggregate();
+        harness.mutate(aggregate);
+        const pendingBefore = aggregate.pendingEvents.length;
+        await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(aggregate);
+            throw new Error("contract rollback probe");
+          })
+        );
+        assertEqual(
+          (await env.committedStreamEvents(aggregate.id)).length,
+          0,
+          "a rolled-back transaction must not leave events in the stream"
+        );
+        assertEqual(
+          (await env.committedOutboxEvents()).length,
+          0,
+          "a rolled-back transaction must not leave events in the outbox"
+        );
+        assertEqual(
+          aggregate.pendingEvents.length,
+          pendingBefore,
+          "pending events must survive a rollback (so the first save can be retried)"
+        );
+        assert(
+          aggregate.persistedVersion === void 0,
+          "a rolled-back first save must leave persistedVersion undefined (the stream does not exist)"
+        );
+        await env.run(async ({ repository }) => {
+          await repository.save(aggregate);
+        });
+        assertEqual(
+          (await env.committedStreamEvents(aggregate.id)).length,
+          pendingBefore,
+          "the retried first save must append the full pending history"
+        );
+        assertEqual(
+          aggregate.persistedVersion,
+          aggregate.version,
+          "after the successful retry, persistedVersion must equal version"
+        );
+      }), "run")
+    },
+    {
+      name: "readStream honors fromVersion: the snapshot catch-up read returns exactly the events after the position",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const aggregate = harness.createAggregate();
+        harness.mutate(aggregate);
+        harness.mutate(aggregate);
+        await env.run(async ({ repository }) => {
+          await repository.save(aggregate);
+        });
+        const full = await env.committedStreamEvents(aggregate.id);
+        assertEqual(full.length, 3, "seeding must have committed 3 events");
+        const afterOne = await env.committedStreamEvents(aggregate.id, 1);
+        assert(
+          deepEqual(orderedIds(afterOne), orderedIds(full.slice(1))),
+          "fromVersion=1 must return exactly the events after stream position 1, in order; restoreFromSnapshotWithEvents replays exactly this window"
+        );
+        const afterAll = await env.committedStreamEvents(
+          aggregate.id,
+          full.length
+        );
+        assertEqual(
+          afterAll.length,
+          0,
+          "fromVersion at the stream head must return no events"
+        );
+      }), "run")
+    }
+  ];
+  tests.push(
+    createAggregateWithId ? {
+      name: "duplicate create: two creators racing on one stream; the second append conflicts and the stream is untouched",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const seedStream = await env.committedStreamEvents(seeded.id);
+        const duplicate = createAggregateWithId.call(
+          harness,
+          seeded.id
+        );
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(duplicate);
+          })
+        );
+        assert(
+          chainContainsErrorNamedAnyOf(rejection, [
+            "ConcurrencyConflictError",
+            "DuplicateAggregateError"
+          ]),
+          `the duplicate creator's append (expectedVersion 0 on an existing stream) must reject with (or wrap) ConcurrencyConflictError or DuplicateAggregateError; got: ${describeError(rejection)}`
+        );
+        const finalStream = await env.committedStreamEvents(seeded.id);
+        assert(
+          deepEqual(orderedIds(finalStream), orderedIds(seedStream)),
+          "the existing stream must be untouched by the rejected duplicate create"
+        );
+      }), "run")
+    } : skippedTest(
+      "duplicate create: two creators racing on one stream; the second append conflicts and the stream is untouched",
+      "createAggregateWithId"
+    )
+  );
+  return tests;
+}
+__name(createEsRepositoryContractTests, "createEsRepositoryContractTests");
+
+// src/testing/repository-contract.ts
+function createRepositoryContractTests(harness) {
+  const withEnvironment = /* @__PURE__ */ __name((body) => runInContractEnvironment(() => harness.createEnvironment(), body), "withEnvironment");
+  const loadOrFail = /* @__PURE__ */ __name((repository, id) => loadAggregateOrFail(
+    repository,
+    id,
+    "broken hydration or a write that did not commit"
+  ), "loadOrFail");
+  async function seed(env) {
+    const aggregate = harness.createAggregate();
+    harness.mutate(aggregate);
+    await env.run(async ({ repository }) => {
+      await repository.save(aggregate);
+    });
+    return aggregate;
   }
-  __name(captureRejection, "captureRejection");
+  __name(seed, "seed");
+  async function reload(env, id) {
+    return env.run(({ repository }) => loadOrFail(repository, id));
+  }
+  __name(reload, "reload");
   const eventIds = /* @__PURE__ */ __name((events) => events.map((event) => event.eventId).sort(), "eventIds");
   const snapshotState = harness.snapshotState;
   const mutateVersionOnly = harness.mutateVersionOnly;
@@ -300,18 +791,7 @@ function createRepositoryContractTests(harness) {
   const createAggregateWithId = harness.createAggregateWithId;
   const deletesAreVersionChecked = harness.deletesAreVersionChecked === true;
   const insertsAreDuplicateChecked = harness.insertsAreDuplicateChecked !== false;
-  function skippedTest(name, capability) {
-    return {
-      name,
-      skipped: { capability },
-      run: /* @__PURE__ */ __name(async () => {
-        throw new Error(
-          `Repository contract test skipped: harness capability '${capability}' is not provided. Bind skipped tests with it.skip ((test.skipped ? it.skip : it)(test.name, test.run)) or provide the capability - each one closes a real OCC hole.`
-        );
-      }, "run")
-    };
-  }
-  __name(skippedTest, "skippedTest");
+  const skippedTest = /* @__PURE__ */ __name((name, capability) => skippedContractTest(name, capability), "skippedTest");
   const tests = [
     {
       name: "MANDATORY two-writer conflict: the stale writer throws ConcurrencyConflictError and persists nothing",
@@ -726,68 +1206,7 @@ function createRepositoryContractTests(harness) {
   return tests;
 }
 __name(createRepositoryContractTests, "createRepositoryContractTests");
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(`Repository contract violated: ${message}`);
-  }
-}
-__name(assert, "assert");
-function assertEqual(actual, expected, message) {
-  if (actual !== expected) {
-    throw new Error(
-      `Repository contract violated: ${message} (expected ${String(expected)}, got ${String(actual)})`
-    );
-  }
-}
-__name(assertEqual, "assertEqual");
-function chainContainsErrorNamed(error, name) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current !== null && current !== void 0 && !seen.has(current)) {
-    if (typeof current !== "object") {
-      return false;
-    }
-    if (errorMatchesName(current, name)) {
-      return true;
-    }
-    seen.add(current);
-    try {
-      current = current.cause;
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
-__name(chainContainsErrorNamed, "chainContainsErrorNamed");
-function errorMatchesName(candidate, name) {
-  try {
-    if (candidate.name === name) {
-      return true;
-    }
-  } catch {
-  }
-  try {
-    let proto = Object.getPrototypeOf(candidate);
-    for (let depth = 0; proto !== null && depth < 20; depth++) {
-      if (proto.constructor?.name === name) {
-        return true;
-      }
-      proto = Object.getPrototypeOf(proto);
-    }
-  } catch {
-  }
-  return false;
-}
-__name(errorMatchesName, "errorMatchesName");
-function describeError(error) {
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  return String(error);
-}
-__name(describeError, "describeError");
 
-export { createRepositoryContractTests };
+export { createEsRepositoryContractTests, createRepositoryContractTests };
 //# sourceMappingURL=testing.js.map
 //# sourceMappingURL=testing.js.map