@saasicat/persistence-testing 1.0.0-rc.15 → 1.0.0-rc.16

package/README.md

@@ -94,7 +94,7 @@ persistenceAdapterContract({
     }),
     // The parts this adapter deliberately does not provide. A part named here
     // that the harness does provide fails the suite as well.
-    gaps: ['subscriptionContracts', 'checkoutOffers', 'appliedSettings'],
+    gaps: ['subscriptionContracts', 'subscribers', 'checkoutOffers', 'appliedSettings'],
 });
 ```
 

package/dist/.build-stamp

@@ -1 +1 @@
-8fdc45ae34c5869710281576820410215b122b89385485ab7973ebfc8359157b
+1ca79840c535585e92be3594dc7e1b240dfd47e78e98d7577fe19a1cd7e51faf

package/dist/index.cjs

@@ -53,9 +53,51 @@ var OFFER = {
     effectiveGross: 58.31
   }
 };
-function contractFromOffer(offerId) {
+function partiesWith(subscriberId, legalName) {
+  return {
+    subscriberId,
+    subscriber: {
+      customerNumber: "K-10001",
+      legalName,
+      vatId: "DE123456789",
+      taxNumber: null,
+      addressLine1: "Hauptstra\xDFe 1",
+      addressLine2: null,
+      postalCode: "10115",
+      city: "Berlin",
+      country: "DE"
+    },
+    issuer: {
+      legalName: "Example Software GmbH",
+      vatId: "DE987654321",
+      taxNumber: "12/345/67890",
+      addressLine1: "Werkstra\xDFe 5",
+      addressLine2: null,
+      postalCode: "80331",
+      city: "M\xFCnchen",
+      country: "DE"
+    }
+  };
+}
+function subscriberFor(tenantId, legalName) {
+  return {
+    tenantId,
+    legalName,
+    vatId: null,
+    taxNumber: null,
+    addressLine1: null,
+    addressLine2: null,
+    postalCode: null,
+    city: null,
+    country: null,
+    invoiceEmail: null,
+    customerNumberPrefix: ""
+  };
+}
+function contractFromOffer(offerId, parties) {
   return {
     tenantId: `tenant-${offerId}`,
+    parties,
     effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
     originalOfferId: offerId,
     priceSnapshot: {
@@ -187,8 +229,12 @@ var CONTRACT_GAPS = {
     present: ({ adapter }) => Boolean(adapter.mfa)
   },
   subscriptionContracts: {
-    reason: "adapter provides no SubscriptionContractRepository",
-    present: ({ adapter }) => Boolean(adapter.subscriptionContractRepository)
+    reason: "adapter provides no SubscriptionContractRepository, or no subscriber seed for it",
+    present: ({ adapter, seed }) => Boolean(adapter.subscriptionContractRepository && seed.createSubscriber)
+  },
+  subscribers: {
+    reason: "adapter provides no SubscriberRepository",
+    present: ({ adapter }) => Boolean(adapter.subscriberRepository)
   },
   checkoutOffers: {
     reason: "adapter provides no CheckoutOfferRepository",
@@ -1383,14 +1429,18 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a contract keeps what was agreed, and ending it does not rewrite it", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-lifecycle";
       const signedAt = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+      const { subscriberId } = await createSubscriber({ legalName: "Meier GmbH" });
+      const parties = partiesWith(subscriberId, "Meier GmbH");
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: signedAt,
         priceSnapshot: {
           currency: "EUR",
@@ -1451,6 +1501,10 @@ function persistenceAdapterContract(options) {
       });
       import_strict.default.equal(created.status, "active");
       import_strict.default.equal(created.tenantId, tenantId);
+      import_strict.default.equal(created.subscriberId, subscriberId);
+      import_strict.default.deepEqual(created.subscriber, parties.subscriber);
+      import_strict.default.deepEqual(created.issuer, parties.issuer);
+      import_strict.default.equal(created.partiesMigrated, false);
       import_strict.default.equal(created.lineItems.length, 2);
       import_strict.default.deepEqual(created.originalBundleVersionIds, ["bundle-version-1"]);
       import_strict.default.deepEqual(created.termsSnapshot, { noticePeriodDays: 30 });
@@ -1483,6 +1537,8 @@ function persistenceAdapterContract(options) {
       import_strict.default.equal(bundleLine.metadata, null);
       const readBack = await contracts.findById(created.id);
       import_strict.default.ok(readBack, "contract expected by id");
+      import_strict.default.deepEqual(readBack.subscriber, parties.subscriber, "the copy is stored");
+      import_strict.default.deepEqual(readBack.issuer, parties.issuer);
       import_strict.default.equal(
         readBack.lineItems.length,
         2,
@@ -1539,11 +1595,14 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a successor takes over without erasing the contract it replaces", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-succession";
+      const { subscriberId } = await createSubscriber({ legalName: "Nachfolger KG" });
+      const parties = partiesWith(subscriberId, "Nachfolger KG");
       const handover = /* @__PURE__ */ new Date("2026-04-01T00:00:00.000Z");
       const lineAt = (priceNet, priceGross) => ({
         kind: "plan",
@@ -1575,6 +1634,7 @@ function persistenceAdapterContract(options) {
       });
       const first = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: priceAt(19.9, 23.68),
         lineItems: [lineAt(19.9, 23.68)]
@@ -1592,6 +1652,7 @@ function persistenceAdapterContract(options) {
       });
       const second = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: handover,
         priceSnapshot: priceAt(24.9, 29.63),
         lineItems: [lineAt(24.9, 29.63)]
@@ -1641,13 +1702,17 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a line keeps the currency and the tax it was booked with", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-money-facts";
+      const { subscriberId } = await createSubscriber({ legalName: "Z\xFCrich AG" });
+      const parties = { ...partiesWith(subscriberId, "Z\xFCrich AG"), issuer: null };
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: {
           currency: "CHF",
@@ -1722,9 +1787,9 @@ function persistenceAdapterContract(options) {
       }
     });
     (0, import_node_test.test)("a contract written on a transaction is undone with it, and found by its offer", async (t) => {
-      const { adapter } = harness;
+      const { adapter, seed } = harness;
       const contracts = adapter.subscriptionContractRepository;
-      if (!contracts) {
+      if (!contracts || !seed.createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
@@ -1732,9 +1797,11 @@ function persistenceAdapterContract(options) {
         t.skip("adapter declares no transaction capability");
         return;
       }
+      const { subscriberId } = await seed.createSubscriber({ legalName: "Angebot GmbH" });
+      const parties = partiesWith(subscriberId, "Angebot GmbH");
       await import_strict.default.rejects(
         adapter.transactionRunner.run(async (tx) => {
-          await contracts.create(contractFromOffer("offer-rolled-back"), tx);
+          await contracts.create(contractFromOffer("offer-rolled-back", parties), tx);
           throw new Error("the conclusion fails after the contract is written");
         })
       );
@@ -1744,13 +1811,339 @@ function persistenceAdapterContract(options) {
         "the contract outlived its transaction"
       );
       const kept = await adapter.transactionRunner.run(
-        (tx) => contracts.create(contractFromOffer("offer-kept"), tx)
+        (tx) => contracts.create(contractFromOffer("offer-kept", parties), tx)
       );
       const found = await contracts.findByOriginalOfferId("offer-kept");
       import_strict.default.equal(found?.id, kept.id);
       import_strict.default.equal(found?.lineItems.length, 1, "with its lines");
       import_strict.default.equal(await contracts.findByOriginalOfferId("offer-nobody-concluded"), null);
     });
+    (0, import_node_test.test)("a subscriber is created live for its tenant, and numbered by the database", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const first = await subscribers.createForTenant({
+        ...subscriberFor("tenant-subscriber-first", "Erste Autohaus GmbH"),
+        vatId: "DE123456789",
+        addressLine1: "Hauptstra\xDFe 1",
+        postalCode: "10115",
+        city: "Berlin",
+        country: "DE",
+        invoiceEmail: "rechnung@erste.example",
+        customerNumberPrefix: "K-"
+      });
+      const second = await subscribers.createForTenant(
+        subscriberFor("tenant-subscriber-second", "Zweiter Verein e.V.")
+      );
+      import_strict.default.ok(first && second, "both tenants had no subscriber");
+      const numberOf = (customerNumber) => Number(customerNumber.replace("K-", ""));
+      import_strict.default.ok(first.customerNumber.startsWith("K-"), first.customerNumber);
+      import_strict.default.equal(numberOf(second.customerNumber), numberOf(first.customerNumber) + 1);
+      import_strict.default.ok(numberOf(first.customerNumber) >= 10001, first.customerNumber);
+      const found = await subscribers.findByTenantId("tenant-subscriber-first");
+      import_strict.default.deepEqual(
+        found && {
+          id: found.id,
+          customerNumber: found.customerNumber,
+          tenantId: found.tenantId,
+          legalName: found.legalName,
+          vatId: found.vatId,
+          taxNumber: found.taxNumber,
+          addressLine1: found.addressLine1,
+          addressLine2: found.addressLine2,
+          postalCode: found.postalCode,
+          city: found.city,
+          country: found.country,
+          invoiceEmail: found.invoiceEmail,
+          migrated: found.migrated
+        },
+        {
+          id: first.id,
+          customerNumber: first.customerNumber,
+          tenantId: "tenant-subscriber-first",
+          legalName: "Erste Autohaus GmbH",
+          vatId: "DE123456789",
+          // The nullable half, so an adapter writing '' is caught too.
+          taxNumber: null,
+          addressLine1: "Hauptstra\xDFe 1",
+          addressLine2: null,
+          postalCode: "10115",
+          city: "Berlin",
+          country: "DE",
+          invoiceEmail: "rechnung@erste.example",
+          migrated: false
+        }
+      );
+      import_strict.default.equal(
+        (await subscribers.findById(second.id))?.tenantId,
+        "tenant-subscriber-second"
+      );
+      import_strict.default.equal(await subscribers.findByTenantId("tenant-without-subscriber"), null);
+      import_strict.default.equal(await subscribers.findById("subscriber-nobody-created"), null);
+    });
+    (0, import_node_test.test)("a tenant has one live subscriber: a second is refused, and the transaction survives it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      const first = await subscribers.createForTenant(
+        subscriberFor("tenant-one-subscriber", "Einzig GmbH")
+      );
+      const afterRefusal = await adapter.transactionRunner.run(async (tx) => {
+        const refused = await subscribers.createForTenant(
+          subscriberFor("tenant-one-subscriber", "Doppelt GmbH"),
+          tx
+        );
+        import_strict.default.equal(refused, null, "a second live subscriber was created");
+        return subscribers.createForTenant(
+          subscriberFor("tenant-after-refusal", "Danach GmbH"),
+          tx
+        );
+      });
+      import_strict.default.equal(
+        (await subscribers.findByTenantId("tenant-one-subscriber"))?.id,
+        first?.id
+      );
+      import_strict.default.equal(
+        (await subscribers.findByTenantId("tenant-after-refusal"))?.id,
+        afterRefusal?.id,
+        "the transaction did not survive the refusal"
+      );
+    });
+    (0, import_node_test.test)("creating a subscriber for one tenant twice at once ends with one", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const results = await Promise.all([
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig A")),
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig B"))
+      ]);
+      const created = results.filter((result) => result !== null);
+      import_strict.default.equal(created.length, 1, `${created.length} subscribers were created`);
+      import_strict.default.equal((await subscribers.findByTenantId("tenant-at-once"))?.id, created[0].id);
+    });
+    (0, import_node_test.test)("a subscriber written on a transaction is undone with it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      await import_strict.default.rejects(
+        adapter.transactionRunner.run(async (tx) => {
+          await subscribers.createForTenant(
+            subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH"),
+            tx
+          );
+          throw new Error("the tenant is not created after all");
+        })
+      );
+      import_strict.default.equal(await subscribers.findByTenantId("tenant-rolled-back"), null);
+      import_strict.default.ok(
+        await subscribers.createForTenant(
+          subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH")
+        )
+      );
+    });
+    (0, import_node_test.test)("a contact change writes what it names and keeps the rest", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant({
+        ...subscriberFor("tenant-contact", "Kontakt GmbH"),
+        addressLine2: "Hinterhaus",
+        city: "Hamburg"
+      });
+      import_strict.default.ok(created);
+      const changed = await subscribers.updateContact(created.id, {
+        city: "Bremen",
+        addressLine2: null,
+        invoiceEmail: "buchhaltung@kontakt.example"
+      });
+      import_strict.default.deepEqual(
+        changed && [
+          changed.city,
+          changed.addressLine2,
+          changed.invoiceEmail,
+          changed.legalName,
+          changed.tenantId
+        ],
+        ["Bremen", null, "buchhaltung@kontakt.example", "Kontakt GmbH", "tenant-contact"]
+      );
+      import_strict.default.equal((await subscribers.findById(created.id))?.city, "Bremen");
+      import_strict.default.equal(
+        await subscribers.updateContact("subscriber-nobody-created", { city: "Kiel" }),
+        null
+      );
+    });
+    (0, import_node_test.test)("a correction records the values it replaced, and nothing when nothing moves", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-correction", "Mueller GmbH")
+      );
+      import_strict.default.ok(created);
+      const at = (day) => new Date(Date.UTC(2026, 8, day));
+      const first = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789", taxNumber: null },
+        reason: "Umlaut lost when the registration was typed",
+        correctedBy: "operator:anna",
+        correctedAt: at(1)
+      });
+      import_strict.default.deepEqual(
+        first?.correction && {
+          previous: first.correction.previous,
+          corrected: first.correction.corrected,
+          reason: first.correction.reason,
+          correctedBy: first.correction.correctedBy,
+          correctedAt: first.correction.correctedAt.getTime()
+        },
+        {
+          previous: { legalName: "Mueller GmbH", vatId: null },
+          corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789" },
+          reason: "Umlaut lost when the registration was typed",
+          correctedBy: "operator:anna",
+          correctedAt: at(1).getTime()
+        }
+      );
+      import_strict.default.equal(first?.subscriber.legalName, "M\xFCller GmbH");
+      import_strict.default.equal((await subscribers.findById(created.id))?.vatId, "DE123456789");
+      const unchanged = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH" },
+        reason: "Clicked twice",
+        correctedBy: "operator:anna",
+        correctedAt: at(2)
+      });
+      import_strict.default.equal(
+        unchanged?.correction,
+        null,
+        "a correction that moved nothing was recorded"
+      );
+      await subscribers.correctIdentity(created.id, {
+        corrected: { vatId: "DE999999999" },
+        reason: "Wrong VAT id on the first correction",
+        correctedBy: "operator:ben",
+        correctedAt: at(3)
+      });
+      const listed = await subscribers.listCorrections(created.id);
+      import_strict.default.deepEqual(
+        listed.map((correction) => correction.reason),
+        [
+          "Wrong VAT id on the first correction",
+          "Umlaut lost when the registration was typed"
+        ],
+        "corrections come back the latest first, and only the two that moved something"
+      );
+      import_strict.default.equal(
+        await subscribers.correctIdentity("subscriber-nobody-created", {
+          corrected: { legalName: "Niemand" },
+          reason: "none",
+          correctedBy: "operator:anna",
+          correctedAt: at(4)
+        }),
+        null
+      );
+    });
+    (0, import_node_test.test)("two corrections at once each record the value the other left behind", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions || !adapter.capabilities.pessimisticLocking) {
+        t.skip("adapter declares no transactions or no row locks");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-corrected-twice", "Original GmbH")
+      );
+      import_strict.default.ok(created);
+      const correctTo = (legalName) => adapter.transactionRunner.run(async (tx) => {
+        await subscribers.correctIdentity(
+          created.id,
+          {
+            corrected: { legalName },
+            reason: `to ${legalName}`,
+            correctedBy: "operator:anna",
+            correctedAt: /* @__PURE__ */ new Date()
+          },
+          tx
+        );
+        await sleep(LOCK_HOLD_MS);
+      });
+      await Promise.all([
+        correctTo("Erste Korrektur GmbH"),
+        correctTo("Zweite Korrektur GmbH")
+      ]);
+      const listed = await subscribers.listCorrections(created.id);
+      import_strict.default.equal(listed.length, 2);
+      const replaced = listed.map((correction) => correction.previous.legalName).sort();
+      const written = listed.map((correction) => correction.corrected.legalName);
+      const current = (await subscribers.findById(created.id))?.legalName;
+      import_strict.default.ok(replaced.includes("Original GmbH"), JSON.stringify(listed));
+      const secondReplaced = replaced.find((name) => name !== "Original GmbH");
+      import_strict.default.ok(
+        secondReplaced !== void 0 && written.includes(secondReplaced),
+        `a correction recorded a value it did not replace: ${JSON.stringify(listed)}`
+      );
+      import_strict.default.ok(current !== void 0 && written.includes(current));
+      import_strict.default.notEqual(secondReplaced, current);
+    });
+    (0, import_node_test.test)("a contract keeps its subscriber's copy after the subscriber is corrected", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      const contracts = adapter.subscriptionContractRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!contracts || !harness.seed.createSubscriber) {
+        missing(t, "subscriptionContracts");
+        return;
+      }
+      const subscriber = await subscribers.createForTenant(
+        subscriberFor("tenant-copy-kept", "Vorher GmbH")
+      );
+      import_strict.default.ok(subscriber);
+      const parties = partiesWith(subscriber.id, "Vorher GmbH");
+      const contract = await contracts.create({
+        ...contractFromOffer("offer-copy-kept", parties),
+        tenantId: "tenant-copy-kept"
+      });
+      await subscribers.correctIdentity(subscriber.id, {
+        corrected: { legalName: "Nachher GmbH" },
+        reason: "Change of name of the same company",
+        correctedBy: "operator:anna",
+        correctedAt: /* @__PURE__ */ new Date()
+      });
+      const readBack = await contracts.findById(contract.id);
+      import_strict.default.equal(readBack?.subscriberId, subscriber.id);
+      import_strict.default.equal(
+        readBack?.subscriber.legalName,
+        "Vorher GmbH",
+        "the contract followed a correction of the live record"
+      );
+    });
     (0, import_node_test.test)("an offer is consumed once, whoever asks first", async (t) => {
       const offers = harness.adapter.checkoutOfferRepository;
       if (!offers) {

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { PersistenceCapabilities, TransactionRunner, SubscriptionRepository, PlanVersionRepository, PromoCodeRepository, PromoCodeRedemptionRepository, MfaPort, AuditPort, AuditQueryPort, SubscriptionContractRepository, CheckoutOfferRepository, TenantSubscriptionWritePort, BundleRepository, SubscriptionBundleRepository, PlanRepository, PromoSubscriptionLookup, AppliedSettingsPort } from '@saasicat/core';
+import { PersistenceCapabilities, TransactionRunner, SubscriptionRepository, PlanVersionRepository, PromoCodeRepository, PromoCodeRedemptionRepository, MfaPort, AuditPort, AuditQueryPort, SubscriptionContractRepository, SubscriberRepository, CheckoutOfferRepository, TenantSubscriptionWritePort, BundleRepository, SubscriptionBundleRepository, PlanRepository, PromoSubscriptionLookup, AppliedSettingsPort } from '@saasicat/core';
 
 /**
  * Port instances under test. Required members define the minimum an adapter
@@ -18,6 +18,14 @@ interface ContractAdapterInstances {
     audit?: AuditPort;
     auditQuery?: AuditQueryPort;
     subscriptionContractRepository?: SubscriptionContractRepository;
+    /**
+     * Enables the subscriber scenarios: a customer number the database
+     * counts, one live subscriber per tenant however many callers create one
+     * at once, and a correction that records the values it replaced. A
+     * contract names its subscriber, so the contract scenarios write theirs
+     * through `seed.createSubscriber` rather than through this port.
+     */
+    subscriberRepository?: SubscriberRepository;
     /**
      * Enables the checkout offer scenarios: an offer is consumed once, and a
      * consume on a transaction that rolls back leaves it open. Neither shipped
@@ -124,6 +132,19 @@ interface ContractSeed {
     }): Promise<{
         promoCodeId: string;
     }>;
+    /**
+     * A subscriber row for a contract scenario to name, linked to no tenant.
+     *
+     * A fixture writer for the reason `createBundleVersion` is one: the
+     * subscriber repository is a subject of its own scenarios, and a contract
+     * scenario that failed because of it would say the wrong thing. Optional
+     * like the port it stands beside; the contract scenarios report it missing.
+     */
+    createSubscriber?(input: {
+        legalName: string;
+    }): Promise<{
+        subscriberId: string;
+    }>;
 }
 interface PersistenceContractHarness {
     adapter: ContractAdapterInstances;
@@ -139,7 +160,7 @@ interface PersistenceContractHarness {
  * Each names the members its scenarios need; `contract.ts` holds the list with
  * what each one checks.
  */
-type ContractGap = 'atomicPlanBinding' | 'atomicOnboarding' | 'promoCodes' | 'promoCodeRedemptions' | 'promoSubscriptionLookup' | 'planRepository' | 'planLifecycle' | 'planRetirement' | 'planVersionReads' | 'planVersionRetirement' | 'bundleRepository' | 'bundleValidity' | 'bundleDraftDiscard' | 'bundleDraftPublish' | 'bundleRetirement' | 'bundleBookings' | 'halfCancelledBookingSeed' | 'countByPlanVersionId' | 'audit' | 'mfa' | 'subscriptionContracts' | 'checkoutOffers' | 'appliedSettings';
+type ContractGap = 'atomicPlanBinding' | 'atomicOnboarding' | 'promoCodes' | 'promoCodeRedemptions' | 'promoSubscriptionLookup' | 'planRepository' | 'planLifecycle' | 'planRetirement' | 'planVersionReads' | 'planVersionRetirement' | 'bundleRepository' | 'bundleValidity' | 'bundleDraftDiscard' | 'bundleDraftPublish' | 'bundleRetirement' | 'bundleBookings' | 'halfCancelledBookingSeed' | 'countByPlanVersionId' | 'audit' | 'mfa' | 'subscriptionContracts' | 'subscribers' | 'checkoutOffers' | 'appliedSettings';
 interface PersistenceAdapterContractOptions {
     /** Display name in the test output, e.g. `'adapter-prisma @ postgres16'`. */
     name: string;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PersistenceCapabilities, TransactionRunner, SubscriptionRepository, PlanVersionRepository, PromoCodeRepository, PromoCodeRedemptionRepository, MfaPort, AuditPort, AuditQueryPort, SubscriptionContractRepository, CheckoutOfferRepository, TenantSubscriptionWritePort, BundleRepository, SubscriptionBundleRepository, PlanRepository, PromoSubscriptionLookup, AppliedSettingsPort } from '@saasicat/core';
+import { PersistenceCapabilities, TransactionRunner, SubscriptionRepository, PlanVersionRepository, PromoCodeRepository, PromoCodeRedemptionRepository, MfaPort, AuditPort, AuditQueryPort, SubscriptionContractRepository, SubscriberRepository, CheckoutOfferRepository, TenantSubscriptionWritePort, BundleRepository, SubscriptionBundleRepository, PlanRepository, PromoSubscriptionLookup, AppliedSettingsPort } from '@saasicat/core';
 
 /**
  * Port instances under test. Required members define the minimum an adapter
@@ -18,6 +18,14 @@ interface ContractAdapterInstances {
     audit?: AuditPort;
     auditQuery?: AuditQueryPort;
     subscriptionContractRepository?: SubscriptionContractRepository;
+    /**
+     * Enables the subscriber scenarios: a customer number the database
+     * counts, one live subscriber per tenant however many callers create one
+     * at once, and a correction that records the values it replaced. A
+     * contract names its subscriber, so the contract scenarios write theirs
+     * through `seed.createSubscriber` rather than through this port.
+     */
+    subscriberRepository?: SubscriberRepository;
     /**
      * Enables the checkout offer scenarios: an offer is consumed once, and a
      * consume on a transaction that rolls back leaves it open. Neither shipped
@@ -124,6 +132,19 @@ interface ContractSeed {
     }): Promise<{
         promoCodeId: string;
     }>;
+    /**
+     * A subscriber row for a contract scenario to name, linked to no tenant.
+     *
+     * A fixture writer for the reason `createBundleVersion` is one: the
+     * subscriber repository is a subject of its own scenarios, and a contract
+     * scenario that failed because of it would say the wrong thing. Optional
+     * like the port it stands beside; the contract scenarios report it missing.
+     */
+    createSubscriber?(input: {
+        legalName: string;
+    }): Promise<{
+        subscriberId: string;
+    }>;
 }
 interface PersistenceContractHarness {
     adapter: ContractAdapterInstances;
@@ -139,7 +160,7 @@ interface PersistenceContractHarness {
  * Each names the members its scenarios need; `contract.ts` holds the list with
  * what each one checks.
  */
-type ContractGap = 'atomicPlanBinding' | 'atomicOnboarding' | 'promoCodes' | 'promoCodeRedemptions' | 'promoSubscriptionLookup' | 'planRepository' | 'planLifecycle' | 'planRetirement' | 'planVersionReads' | 'planVersionRetirement' | 'bundleRepository' | 'bundleValidity' | 'bundleDraftDiscard' | 'bundleDraftPublish' | 'bundleRetirement' | 'bundleBookings' | 'halfCancelledBookingSeed' | 'countByPlanVersionId' | 'audit' | 'mfa' | 'subscriptionContracts' | 'checkoutOffers' | 'appliedSettings';
+type ContractGap = 'atomicPlanBinding' | 'atomicOnboarding' | 'promoCodes' | 'promoCodeRedemptions' | 'promoSubscriptionLookup' | 'planRepository' | 'planLifecycle' | 'planRetirement' | 'planVersionReads' | 'planVersionRetirement' | 'bundleRepository' | 'bundleValidity' | 'bundleDraftDiscard' | 'bundleDraftPublish' | 'bundleRetirement' | 'bundleBookings' | 'halfCancelledBookingSeed' | 'countByPlanVersionId' | 'audit' | 'mfa' | 'subscriptionContracts' | 'subscribers' | 'checkoutOffers' | 'appliedSettings';
 interface PersistenceAdapterContractOptions {
     /** Display name in the test output, e.g. `'adapter-prisma @ postgres16'`. */
     name: string;

package/dist/index.js

@@ -17,9 +17,51 @@ var OFFER = {
     effectiveGross: 58.31
   }
 };
-function contractFromOffer(offerId) {
+function partiesWith(subscriberId, legalName) {
+  return {
+    subscriberId,
+    subscriber: {
+      customerNumber: "K-10001",
+      legalName,
+      vatId: "DE123456789",
+      taxNumber: null,
+      addressLine1: "Hauptstra\xDFe 1",
+      addressLine2: null,
+      postalCode: "10115",
+      city: "Berlin",
+      country: "DE"
+    },
+    issuer: {
+      legalName: "Example Software GmbH",
+      vatId: "DE987654321",
+      taxNumber: "12/345/67890",
+      addressLine1: "Werkstra\xDFe 5",
+      addressLine2: null,
+      postalCode: "80331",
+      city: "M\xFCnchen",
+      country: "DE"
+    }
+  };
+}
+function subscriberFor(tenantId, legalName) {
+  return {
+    tenantId,
+    legalName,
+    vatId: null,
+    taxNumber: null,
+    addressLine1: null,
+    addressLine2: null,
+    postalCode: null,
+    city: null,
+    country: null,
+    invoiceEmail: null,
+    customerNumberPrefix: ""
+  };
+}
+function contractFromOffer(offerId, parties) {
   return {
     tenantId: `tenant-${offerId}`,
+    parties,
     effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
     originalOfferId: offerId,
     priceSnapshot: {
@@ -151,8 +193,12 @@ var CONTRACT_GAPS = {
     present: ({ adapter }) => Boolean(adapter.mfa)
   },
   subscriptionContracts: {
-    reason: "adapter provides no SubscriptionContractRepository",
-    present: ({ adapter }) => Boolean(adapter.subscriptionContractRepository)
+    reason: "adapter provides no SubscriptionContractRepository, or no subscriber seed for it",
+    present: ({ adapter, seed }) => Boolean(adapter.subscriptionContractRepository && seed.createSubscriber)
+  },
+  subscribers: {
+    reason: "adapter provides no SubscriberRepository",
+    present: ({ adapter }) => Boolean(adapter.subscriberRepository)
   },
   checkoutOffers: {
     reason: "adapter provides no CheckoutOfferRepository",
@@ -1347,14 +1393,18 @@ function persistenceAdapterContract(options) {
     });
     test("a contract keeps what was agreed, and ending it does not rewrite it", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-lifecycle";
       const signedAt = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+      const { subscriberId } = await createSubscriber({ legalName: "Meier GmbH" });
+      const parties = partiesWith(subscriberId, "Meier GmbH");
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: signedAt,
         priceSnapshot: {
           currency: "EUR",
@@ -1415,6 +1465,10 @@ function persistenceAdapterContract(options) {
       });
       assert.equal(created.status, "active");
       assert.equal(created.tenantId, tenantId);
+      assert.equal(created.subscriberId, subscriberId);
+      assert.deepEqual(created.subscriber, parties.subscriber);
+      assert.deepEqual(created.issuer, parties.issuer);
+      assert.equal(created.partiesMigrated, false);
       assert.equal(created.lineItems.length, 2);
       assert.deepEqual(created.originalBundleVersionIds, ["bundle-version-1"]);
       assert.deepEqual(created.termsSnapshot, { noticePeriodDays: 30 });
@@ -1447,6 +1501,8 @@ function persistenceAdapterContract(options) {
       assert.equal(bundleLine.metadata, null);
       const readBack = await contracts.findById(created.id);
       assert.ok(readBack, "contract expected by id");
+      assert.deepEqual(readBack.subscriber, parties.subscriber, "the copy is stored");
+      assert.deepEqual(readBack.issuer, parties.issuer);
       assert.equal(
         readBack.lineItems.length,
         2,
@@ -1503,11 +1559,14 @@ function persistenceAdapterContract(options) {
     });
     test("a successor takes over without erasing the contract it replaces", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-succession";
+      const { subscriberId } = await createSubscriber({ legalName: "Nachfolger KG" });
+      const parties = partiesWith(subscriberId, "Nachfolger KG");
       const handover = /* @__PURE__ */ new Date("2026-04-01T00:00:00.000Z");
       const lineAt = (priceNet, priceGross) => ({
         kind: "plan",
@@ -1539,6 +1598,7 @@ function persistenceAdapterContract(options) {
       });
       const first = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: priceAt(19.9, 23.68),
         lineItems: [lineAt(19.9, 23.68)]
@@ -1556,6 +1616,7 @@ function persistenceAdapterContract(options) {
       });
       const second = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: handover,
         priceSnapshot: priceAt(24.9, 29.63),
         lineItems: [lineAt(24.9, 29.63)]
@@ -1605,13 +1666,17 @@ function persistenceAdapterContract(options) {
     });
     test("a line keeps the currency and the tax it was booked with", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-money-facts";
+      const { subscriberId } = await createSubscriber({ legalName: "Z\xFCrich AG" });
+      const parties = { ...partiesWith(subscriberId, "Z\xFCrich AG"), issuer: null };
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: {
           currency: "CHF",
@@ -1686,9 +1751,9 @@ function persistenceAdapterContract(options) {
       }
     });
     test("a contract written on a transaction is undone with it, and found by its offer", async (t) => {
-      const { adapter } = harness;
+      const { adapter, seed } = harness;
       const contracts = adapter.subscriptionContractRepository;
-      if (!contracts) {
+      if (!contracts || !seed.createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
@@ -1696,9 +1761,11 @@ function persistenceAdapterContract(options) {
         t.skip("adapter declares no transaction capability");
         return;
       }
+      const { subscriberId } = await seed.createSubscriber({ legalName: "Angebot GmbH" });
+      const parties = partiesWith(subscriberId, "Angebot GmbH");
       await assert.rejects(
         adapter.transactionRunner.run(async (tx) => {
-          await contracts.create(contractFromOffer("offer-rolled-back"), tx);
+          await contracts.create(contractFromOffer("offer-rolled-back", parties), tx);
           throw new Error("the conclusion fails after the contract is written");
         })
       );
@@ -1708,13 +1775,339 @@ function persistenceAdapterContract(options) {
         "the contract outlived its transaction"
       );
       const kept = await adapter.transactionRunner.run(
-        (tx) => contracts.create(contractFromOffer("offer-kept"), tx)
+        (tx) => contracts.create(contractFromOffer("offer-kept", parties), tx)
       );
       const found = await contracts.findByOriginalOfferId("offer-kept");
       assert.equal(found?.id, kept.id);
       assert.equal(found?.lineItems.length, 1, "with its lines");
       assert.equal(await contracts.findByOriginalOfferId("offer-nobody-concluded"), null);
     });
+    test("a subscriber is created live for its tenant, and numbered by the database", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const first = await subscribers.createForTenant({
+        ...subscriberFor("tenant-subscriber-first", "Erste Autohaus GmbH"),
+        vatId: "DE123456789",
+        addressLine1: "Hauptstra\xDFe 1",
+        postalCode: "10115",
+        city: "Berlin",
+        country: "DE",
+        invoiceEmail: "rechnung@erste.example",
+        customerNumberPrefix: "K-"
+      });
+      const second = await subscribers.createForTenant(
+        subscriberFor("tenant-subscriber-second", "Zweiter Verein e.V.")
+      );
+      assert.ok(first && second, "both tenants had no subscriber");
+      const numberOf = (customerNumber) => Number(customerNumber.replace("K-", ""));
+      assert.ok(first.customerNumber.startsWith("K-"), first.customerNumber);
+      assert.equal(numberOf(second.customerNumber), numberOf(first.customerNumber) + 1);
+      assert.ok(numberOf(first.customerNumber) >= 10001, first.customerNumber);
+      const found = await subscribers.findByTenantId("tenant-subscriber-first");
+      assert.deepEqual(
+        found && {
+          id: found.id,
+          customerNumber: found.customerNumber,
+          tenantId: found.tenantId,
+          legalName: found.legalName,
+          vatId: found.vatId,
+          taxNumber: found.taxNumber,
+          addressLine1: found.addressLine1,
+          addressLine2: found.addressLine2,
+          postalCode: found.postalCode,
+          city: found.city,
+          country: found.country,
+          invoiceEmail: found.invoiceEmail,
+          migrated: found.migrated
+        },
+        {
+          id: first.id,
+          customerNumber: first.customerNumber,
+          tenantId: "tenant-subscriber-first",
+          legalName: "Erste Autohaus GmbH",
+          vatId: "DE123456789",
+          // The nullable half, so an adapter writing '' is caught too.
+          taxNumber: null,
+          addressLine1: "Hauptstra\xDFe 1",
+          addressLine2: null,
+          postalCode: "10115",
+          city: "Berlin",
+          country: "DE",
+          invoiceEmail: "rechnung@erste.example",
+          migrated: false
+        }
+      );
+      assert.equal(
+        (await subscribers.findById(second.id))?.tenantId,
+        "tenant-subscriber-second"
+      );
+      assert.equal(await subscribers.findByTenantId("tenant-without-subscriber"), null);
+      assert.equal(await subscribers.findById("subscriber-nobody-created"), null);
+    });
+    test("a tenant has one live subscriber: a second is refused, and the transaction survives it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      const first = await subscribers.createForTenant(
+        subscriberFor("tenant-one-subscriber", "Einzig GmbH")
+      );
+      const afterRefusal = await adapter.transactionRunner.run(async (tx) => {
+        const refused = await subscribers.createForTenant(
+          subscriberFor("tenant-one-subscriber", "Doppelt GmbH"),
+          tx
+        );
+        assert.equal(refused, null, "a second live subscriber was created");
+        return subscribers.createForTenant(
+          subscriberFor("tenant-after-refusal", "Danach GmbH"),
+          tx
+        );
+      });
+      assert.equal(
+        (await subscribers.findByTenantId("tenant-one-subscriber"))?.id,
+        first?.id
+      );
+      assert.equal(
+        (await subscribers.findByTenantId("tenant-after-refusal"))?.id,
+        afterRefusal?.id,
+        "the transaction did not survive the refusal"
+      );
+    });
+    test("creating a subscriber for one tenant twice at once ends with one", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const results = await Promise.all([
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig A")),
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig B"))
+      ]);
+      const created = results.filter((result) => result !== null);
+      assert.equal(created.length, 1, `${created.length} subscribers were created`);
+      assert.equal((await subscribers.findByTenantId("tenant-at-once"))?.id, created[0].id);
+    });
+    test("a subscriber written on a transaction is undone with it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      await assert.rejects(
+        adapter.transactionRunner.run(async (tx) => {
+          await subscribers.createForTenant(
+            subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH"),
+            tx
+          );
+          throw new Error("the tenant is not created after all");
+        })
+      );
+      assert.equal(await subscribers.findByTenantId("tenant-rolled-back"), null);
+      assert.ok(
+        await subscribers.createForTenant(
+          subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH")
+        )
+      );
+    });
+    test("a contact change writes what it names and keeps the rest", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant({
+        ...subscriberFor("tenant-contact", "Kontakt GmbH"),
+        addressLine2: "Hinterhaus",
+        city: "Hamburg"
+      });
+      assert.ok(created);
+      const changed = await subscribers.updateContact(created.id, {
+        city: "Bremen",
+        addressLine2: null,
+        invoiceEmail: "buchhaltung@kontakt.example"
+      });
+      assert.deepEqual(
+        changed && [
+          changed.city,
+          changed.addressLine2,
+          changed.invoiceEmail,
+          changed.legalName,
+          changed.tenantId
+        ],
+        ["Bremen", null, "buchhaltung@kontakt.example", "Kontakt GmbH", "tenant-contact"]
+      );
+      assert.equal((await subscribers.findById(created.id))?.city, "Bremen");
+      assert.equal(
+        await subscribers.updateContact("subscriber-nobody-created", { city: "Kiel" }),
+        null
+      );
+    });
+    test("a correction records the values it replaced, and nothing when nothing moves", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-correction", "Mueller GmbH")
+      );
+      assert.ok(created);
+      const at = (day) => new Date(Date.UTC(2026, 8, day));
+      const first = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789", taxNumber: null },
+        reason: "Umlaut lost when the registration was typed",
+        correctedBy: "operator:anna",
+        correctedAt: at(1)
+      });
+      assert.deepEqual(
+        first?.correction && {
+          previous: first.correction.previous,
+          corrected: first.correction.corrected,
+          reason: first.correction.reason,
+          correctedBy: first.correction.correctedBy,
+          correctedAt: first.correction.correctedAt.getTime()
+        },
+        {
+          previous: { legalName: "Mueller GmbH", vatId: null },
+          corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789" },
+          reason: "Umlaut lost when the registration was typed",
+          correctedBy: "operator:anna",
+          correctedAt: at(1).getTime()
+        }
+      );
+      assert.equal(first?.subscriber.legalName, "M\xFCller GmbH");
+      assert.equal((await subscribers.findById(created.id))?.vatId, "DE123456789");
+      const unchanged = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH" },
+        reason: "Clicked twice",
+        correctedBy: "operator:anna",
+        correctedAt: at(2)
+      });
+      assert.equal(
+        unchanged?.correction,
+        null,
+        "a correction that moved nothing was recorded"
+      );
+      await subscribers.correctIdentity(created.id, {
+        corrected: { vatId: "DE999999999" },
+        reason: "Wrong VAT id on the first correction",
+        correctedBy: "operator:ben",
+        correctedAt: at(3)
+      });
+      const listed = await subscribers.listCorrections(created.id);
+      assert.deepEqual(
+        listed.map((correction) => correction.reason),
+        [
+          "Wrong VAT id on the first correction",
+          "Umlaut lost when the registration was typed"
+        ],
+        "corrections come back the latest first, and only the two that moved something"
+      );
+      assert.equal(
+        await subscribers.correctIdentity("subscriber-nobody-created", {
+          corrected: { legalName: "Niemand" },
+          reason: "none",
+          correctedBy: "operator:anna",
+          correctedAt: at(4)
+        }),
+        null
+      );
+    });
+    test("two corrections at once each record the value the other left behind", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions || !adapter.capabilities.pessimisticLocking) {
+        t.skip("adapter declares no transactions or no row locks");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-corrected-twice", "Original GmbH")
+      );
+      assert.ok(created);
+      const correctTo = (legalName) => adapter.transactionRunner.run(async (tx) => {
+        await subscribers.correctIdentity(
+          created.id,
+          {
+            corrected: { legalName },
+            reason: `to ${legalName}`,
+            correctedBy: "operator:anna",
+            correctedAt: /* @__PURE__ */ new Date()
+          },
+          tx
+        );
+        await sleep(LOCK_HOLD_MS);
+      });
+      await Promise.all([
+        correctTo("Erste Korrektur GmbH"),
+        correctTo("Zweite Korrektur GmbH")
+      ]);
+      const listed = await subscribers.listCorrections(created.id);
+      assert.equal(listed.length, 2);
+      const replaced = listed.map((correction) => correction.previous.legalName).sort();
+      const written = listed.map((correction) => correction.corrected.legalName);
+      const current = (await subscribers.findById(created.id))?.legalName;
+      assert.ok(replaced.includes("Original GmbH"), JSON.stringify(listed));
+      const secondReplaced = replaced.find((name) => name !== "Original GmbH");
+      assert.ok(
+        secondReplaced !== void 0 && written.includes(secondReplaced),
+        `a correction recorded a value it did not replace: ${JSON.stringify(listed)}`
+      );
+      assert.ok(current !== void 0 && written.includes(current));
+      assert.notEqual(secondReplaced, current);
+    });
+    test("a contract keeps its subscriber's copy after the subscriber is corrected", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      const contracts = adapter.subscriptionContractRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!contracts || !harness.seed.createSubscriber) {
+        missing(t, "subscriptionContracts");
+        return;
+      }
+      const subscriber = await subscribers.createForTenant(
+        subscriberFor("tenant-copy-kept", "Vorher GmbH")
+      );
+      assert.ok(subscriber);
+      const parties = partiesWith(subscriber.id, "Vorher GmbH");
+      const contract = await contracts.create({
+        ...contractFromOffer("offer-copy-kept", parties),
+        tenantId: "tenant-copy-kept"
+      });
+      await subscribers.correctIdentity(subscriber.id, {
+        corrected: { legalName: "Nachher GmbH" },
+        reason: "Change of name of the same company",
+        correctedBy: "operator:anna",
+        correctedAt: /* @__PURE__ */ new Date()
+      });
+      const readBack = await contracts.findById(contract.id);
+      assert.equal(readBack?.subscriberId, subscriber.id);
+      assert.equal(
+        readBack?.subscriber.legalName,
+        "Vorher GmbH",
+        "the contract followed a correction of the live record"
+      );
+    });
     test("an offer is consumed once, whoever asks first", async (t) => {
       const offers = harness.adapter.checkoutOfferRepository;
       if (!offers) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saasicat/persistence-testing",
-  "version": "1.0.0-rc.15",
+  "version": "1.0.0-rc.16",
   "description": "Contract test kit for SaaSiCat persistence adapters: one node:test suite that every adapter (Prisma, Drizzle, ...) must pass against a real database — locks, transaction rollback, atomic promo claims, tenant isolation, audit/MFA roundtrips.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -23,7 +23,7 @@
     "dist"
   ],
   "dependencies": {
-    "@saasicat/core": "^1.0.0-rc.15"
+    "@saasicat/core": "^1.0.0-rc.16"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",