@saasicat/adapter-prisma 0.6.0 → 0.7.0

package/dist/index.js

@@ -86,7 +86,7 @@ PrismaAuditAdapter = _ts_decorate2([
   _ts_param(0, Inject(PRISMA_CLIENT_TOKEN)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditAdapter);
 
@@ -149,7 +149,7 @@ PrismaAuditQueryAdapter = _ts_decorate3([
   _ts_param2(0, Inject2(PRISMA_CLIENT_TOKEN)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditQueryAdapter);
 function toActorTagFilter(actorTag) {
@@ -221,7 +221,7 @@ PrismaAuditStatsAdapter = _ts_decorate4([
   _ts_param3(0, Inject3(PRISMA_CLIENT_TOKEN)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaAuditStatsAdapter);
 
@@ -291,12 +291,149 @@ PrismaMfaAdapter = _ts_decorate5([
   _ts_param4(0, Inject4(PRISMA_CLIENT_TOKEN)),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Pick === "undefined" ? Object : Pick
   ])
 ], PrismaMfaAdapter);
 
 // src/prisma-plan-catalog-import-sink.ts
-import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
+import { Inject as Inject5, Injectable as Injectable6, Optional } from "@nestjs/common";
+
+// src/prisma-plan-binding.ts
+var PRISMA_SCHEMA_OPTIONS_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PrismaSchemaOptions");
+var DEFAULT_SCHEMA_OPTIONS = {
+  planBinding: {
+    mode: "legacy-plan-key"
+  },
+  delegates: {
+    catalogPlanVersion: "planVersion",
+    entitlementPlanVersion: "planVersion"
+  },
+  planVersionFields: {
+    catalog: {
+      validityWindows: false,
+      endsAt: false
+    },
+    entitlement: {
+      validityWindows: false,
+      endsAt: false
+    }
+  },
+  tenantSubscription: {
+    delegate: "subscription",
+    subscriptionBundleDelegate: false,
+    synchronizePlanVersion: false,
+    atomicOnboardingSelection: false,
+    activeVersionSelection: "latest-live",
+    withEndsAt: false
+  }
+};
+function resolvePrismaSchemaOptions(options) {
+  const mode = options?.planBinding?.mode ?? "legacy-plan-key";
+  const projectKey = options?.planBinding?.projectKey;
+  if (mode === "normalized-plan-id" && !projectKey?.trim()) {
+    throw new Error("Prisma plan binding mode 'normalized-plan-id' requires a non-empty projectKey.");
+  }
+  const sharedFields = options?.planVersionFields;
+  const catalogFields = sharedFields?.catalog;
+  const entitlementFields = sharedFields?.entitlement;
+  return {
+    planBinding: {
+      mode,
+      ...projectKey ? {
+        projectKey
+      } : {}
+    },
+    delegates: {
+      catalogPlanVersion: options?.delegates?.catalogPlanVersion ?? DEFAULT_SCHEMA_OPTIONS.delegates.catalogPlanVersion,
+      entitlementPlanVersion: options?.delegates?.entitlementPlanVersion ?? DEFAULT_SCHEMA_OPTIONS.delegates.entitlementPlanVersion
+    },
+    planVersionFields: {
+      catalog: {
+        validityWindows: catalogFields?.validityWindows ?? sharedFields?.validityWindows ?? false,
+        endsAt: catalogFields?.endsAt ?? sharedFields?.endsAt ?? false
+      },
+      entitlement: {
+        validityWindows: entitlementFields?.validityWindows ?? sharedFields?.validityWindows ?? false,
+        endsAt: entitlementFields?.endsAt ?? sharedFields?.endsAt ?? false
+      }
+    },
+    tenantSubscription: {
+      delegate: options?.tenantSubscription?.delegate ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.delegate,
+      subscriptionBundleDelegate: options?.tenantSubscription?.subscriptionBundleDelegate ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.subscriptionBundleDelegate,
+      synchronizePlanVersion: options?.tenantSubscription?.synchronizePlanVersion ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.synchronizePlanVersion,
+      atomicOnboardingSelection: options?.tenantSubscription?.atomicOnboardingSelection ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.atomicOnboardingSelection,
+      activeVersionSelection: options?.tenantSubscription?.activeVersionSelection ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.activeVersionSelection,
+      withEndsAt: options?.tenantSubscription?.withEndsAt ?? DEFAULT_SCHEMA_OPTIONS.tenantSubscription.withEndsAt
+    }
+  };
+}
+__name(resolvePrismaSchemaOptions, "resolvePrismaSchemaOptions");
+function createPrismaPlanBindingResolver(options) {
+  const resolved = resolvePrismaSchemaOptions({
+    planBinding: options
+  }).planBinding;
+  return {
+    mode: resolved.mode,
+    projectKey: resolved.projectKey,
+    async toStoragePlanId(client, planKey, projectKey) {
+      if (resolved.mode === "legacy-plan-key") return planKey;
+      const scope = resolveProjectKey(resolved.projectKey, projectKey);
+      const plan = await asPlanIdentityClient(client).plan.findFirst({
+        where: {
+          projectKey: scope,
+          planKey,
+          deletedAt: null
+        }
+      });
+      if (!plan) {
+        throw new Error(`Plan '${planKey}' not found in project '${scope}'.`);
+      }
+      return plan.id;
+    },
+    async toPlanKey(client, storedPlanId, projectKey) {
+      if (resolved.mode === "legacy-plan-key") return storedPlanId;
+      const scope = resolveProjectKey(resolved.projectKey, projectKey);
+      const plan = await asPlanIdentityClient(client).plan.findUnique({
+        where: {
+          id: storedPlanId
+        }
+      });
+      if (!plan || plan.projectKey !== scope) {
+        throw new Error(`Plan id '${storedPlanId}' not found in project '${scope}'.`);
+      }
+      return plan.planKey;
+    }
+  };
+}
+__name(createPrismaPlanBindingResolver, "createPrismaPlanBindingResolver");
+function getPrismaDelegate(client, delegateName) {
+  const delegate = client?.[delegateName];
+  if (!delegate || typeof delegate !== "object") {
+    throw new Error(`Prisma client has no '${delegateName}' delegate.`);
+  }
+  return delegate;
+}
+__name(getPrismaDelegate, "getPrismaDelegate");
+function resolveProjectKey(configured, requested) {
+  const projectKey = requested ?? configured;
+  if (!projectKey) {
+    throw new Error("Prisma plan binding mode 'normalized-plan-id' requires a projectKey.");
+  }
+  if (configured && requested && configured !== requested) {
+    throw new Error(`Prisma plan binding is configured for project '${configured}', not '${requested}'.`);
+  }
+  return projectKey;
+}
+__name(resolveProjectKey, "resolveProjectKey");
+function asPlanIdentityClient(client) {
+  if (!client || typeof client !== "object" || !("plan" in client)) {
+    throw new Error("Prisma client has no 'plan' delegate.");
+  }
+  return client;
+}
+__name(asPlanIdentityClient, "asPlanIdentityClient");
+
+// src/prisma-plan-catalog-import-sink.ts
 function _ts_decorate6(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -319,11 +456,23 @@ var PrismaPlanCatalogImportSink = class {
     __name(this, "PrismaPlanCatalogImportSink");
   }
   prisma;
-  constructor(prisma) {
+  binding;
+  delegateName;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+  }
+  db() {
+    return this.prisma;
   }
   async upsertPlan(input) {
-    const existing = await this.prisma.plan.findFirst({
+    if (this.binding.mode === "normalized-plan-id" && this.binding.projectKey !== input.projectKey) {
+      throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${input.projectKey}'.`);
+    }
+    const db = this.db();
+    const existing = await db.plan.findFirst({
       where: {
         projectKey: input.projectKey,
         planKey: input.planKey
@@ -333,7 +482,7 @@ var PrismaPlanCatalogImportSink = class {
       created: false,
       skipReason: "exists"
     };
-    await this.prisma.plan.create({
+    await db.plan.create({
       data: {
         projectKey: input.projectKey,
         planKey: input.planKey,
@@ -347,9 +496,11 @@ var PrismaPlanCatalogImportSink = class {
     };
   }
   async upsertPlanVersion(input) {
-    const existing = await this.prisma.planVersion.findFirst({
+    const planVersion = this.planVersions();
+    const storedPlanId = await this.binding.toStoragePlanId(this.prisma, input.planKey);
+    const existing = await planVersion.findFirst({
       where: {
-        planId: input.planKey,
+        planId: storedPlanId,
         version: input.version
       }
     });
@@ -359,9 +510,9 @@ var PrismaPlanCatalogImportSink = class {
     };
     const now = /* @__PURE__ */ new Date();
     if (input.publish) {
-      await this.prisma.planVersion.updateMany({
+      await planVersion.updateMany({
         where: {
-          planId: input.planKey,
+          planId: storedPlanId,
           publishedAt: {
             not: null
           },
@@ -375,9 +526,9 @@ var PrismaPlanCatalogImportSink = class {
         }
       });
     }
-    await this.prisma.planVersion.create({
+    await planVersion.create({
       data: {
-        planId: input.planKey,
+        planId: storedPlanId,
         version: input.version,
         features: input.features,
         quotas: input.quotas,
@@ -392,8 +543,12 @@ var PrismaPlanCatalogImportSink = class {
       created: true
     };
   }
+  planVersions() {
+    return getPrismaDelegate(this.prisma, this.delegateName);
+  }
   async upsertFeatureCatalogEntry(input) {
-    const existing = await this.prisma.featureCatalogEntry.findFirst({
+    const db = this.db();
+    const existing = await db.featureCatalogEntry.findFirst({
       where: {
         projectKey: input.projectKey,
         featureKey: input.featureKey
@@ -403,7 +558,7 @@ var PrismaPlanCatalogImportSink = class {
       created: false,
       skipReason: "exists"
     };
-    await this.prisma.featureCatalogEntry.create({
+    await db.featureCatalogEntry.create({
       data: {
         projectKey: input.projectKey,
         featureKey: input.featureKey,
@@ -422,14 +577,17 @@ var PrismaPlanCatalogImportSink = class {
 PrismaPlanCatalogImportSink = _ts_decorate6([
   Injectable6(),
   _ts_param5(0, Inject5(PRISMA_CLIENT_TOKEN)),
+  _ts_param5(1, Optional()),
+  _ts_param5(1, Inject5(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanCatalogImportClient === "undefined" ? Object : PlanCatalogImportClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanCatalogImportSink);
 
 // src/prisma-plan-catalog-read-sink.ts
-import { Inject as Inject6, Injectable as Injectable7 } from "@nestjs/common";
+import { Inject as Inject6, Injectable as Injectable7, Optional as Optional2 } from "@nestjs/common";
 
 // src/tx.ts
 function resolveClient(client, tx) {
@@ -471,11 +629,25 @@ var PrismaPlanCatalogReadSink = class {
     __name(this, "PrismaPlanCatalogReadSink");
   }
   prisma;
-  constructor(prisma) {
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+    this.fields = schema.planVersionFields.catalog;
+  }
+  db() {
+    return this.prisma;
   }
   async loadSnapshot(projectKey) {
-    const plans = await this.prisma.plan.findMany({
+    if (this.binding.mode === "normalized-plan-id" && this.binding.projectKey !== projectKey) {
+      throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${projectKey}'.`);
+    }
+    const db = this.db();
+    const plans = await db.plan.findMany({
       where: {
         projectKey,
         deletedAt: null
@@ -484,11 +656,17 @@ var PrismaPlanCatalogReadSink = class {
         sortOrder: "asc"
       }
     });
-    const planKeys = plans.map((plan) => plan.planKey);
-    const livePlanVersions = planKeys.length === 0 ? [] : await this.prisma.planVersion.findMany({
+    const planKeysByStoredId = new Map(plans.map((plan) => [
+      this.binding.mode === "normalized-plan-id" ? plan.id : plan.planKey,
+      plan.planKey
+    ]));
+    const storedPlanIds = [
+      ...planKeysByStoredId.keys()
+    ];
+    const livePlanVersions = storedPlanIds.length === 0 ? [] : await this.planVersions().findMany({
       where: {
         planId: {
-          in: planKeys
+          in: storedPlanIds
         },
         publishedAt: {
           not: null
@@ -496,7 +674,7 @@ var PrismaPlanCatalogReadSink = class {
         supersededAt: null
       }
     });
-    const featureEntries = await this.prisma.featureCatalogEntry.findMany({
+    const featureEntries = await db.featureCatalogEntry.findMany({
       where: {
         projectKey,
         deletedAt: null
@@ -507,17 +685,29 @@ var PrismaPlanCatalogReadSink = class {
     });
     return {
       plans: plans.map(toPlanRow),
-      livePlanVersions: livePlanVersions.map(toPlanVersionRow),
+      livePlanVersions: livePlanVersions.map((row) => {
+        const planKey = planKeysByStoredId.get(row.planId);
+        if (!planKey) {
+          throw new Error(`PlanVersion ${row.id} references plan '${row.planId}' outside project '${projectKey}'.`);
+        }
+        return toPlanVersionRow(row, planKey, this.fields);
+      }),
       featureEntries: featureEntries.map(toFeatureCatalogEntryRow)
     };
   }
+  planVersions() {
+    return getPrismaDelegate(this.prisma, this.delegateName);
+  }
 };
 PrismaPlanCatalogReadSink = _ts_decorate7([
   Injectable7(),
   _ts_param6(0, Inject6(PRISMA_CLIENT_TOKEN)),
+  _ts_param6(1, Optional2()),
+  _ts_param6(1, Inject6(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata6("design:type", Function),
   _ts_metadata6("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanCatalogReadClient === "undefined" ? Object : PlanCatalogReadClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanCatalogReadSink);
 function toPlanRow(row) {
@@ -535,10 +725,10 @@ function toPlanRow(row) {
   };
 }
 __name(toPlanRow, "toPlanRow");
-function toPlanVersionRow(row) {
-  return {
+function toPlanVersionRow(row, planKey, fields) {
+  const mapped = {
     id: row.id,
-    planId: row.planId,
+    planId: planKey,
     version: row.version,
     baseVersionId: row.baseVersionId,
     publishedAt: row.publishedAt ? row.publishedAt.toISOString() : null,
@@ -546,8 +736,8 @@ function toPlanVersionRow(row) {
     publishedChanges: row.publishedChanges ?? null,
     changeNote: row.changeNote,
     nonRegressive: row.nonRegressive,
-    validFrom: null,
-    validUntil: null,
+    validFrom: fields.validityWindows && row.validFrom ? row.validFrom.toISOString() : null,
+    validUntil: fields.validityWindows && row.validUntil ? row.validUntil.toISOString() : null,
     createdByUserId: row.createdByUserId,
     publishedByUserId: row.publishedByUserId,
     createdAt: row.createdAt.toISOString(),
@@ -558,6 +748,10 @@ function toPlanVersionRow(row) {
     yearlyNet: String(row.yearlyNet),
     marketed: row.marketed
   };
+  if (fields.endsAt) {
+    mapped.endsAt = row.endsAt?.toISOString() ?? null;
+  }
+  return mapped;
 }
 __name(toPlanVersionRow, "toPlanVersionRow");
 function toFeatureCatalogEntryRow(row) {
@@ -590,7 +784,8 @@ function toFeatureCatalogEntryRow(row) {
 __name(toFeatureCatalogEntryRow, "toFeatureCatalogEntryRow");
 
 // src/prisma-plan-version.repository.ts
-import { Inject as Inject7, Injectable as Injectable8 } from "@nestjs/common";
+import { Inject as Inject7, Injectable as Injectable8, Optional as Optional3 } from "@nestjs/common";
+import { buildActivePlanVersionWhere } from "@saasicat/types";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -613,14 +808,29 @@ var PrismaPlanVersionRepository = class {
     __name(this, "PrismaPlanVersionRepository");
   }
   prisma;
-  constructor(prisma) {
+  findActive;
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.entitlementPlanVersion;
+    this.fields = schema.planVersionFields.entitlement;
+    if (this.fields.validityWindows) {
+      this.findActive = (planId, asOf = /* @__PURE__ */ new Date(), tx) => this.findActivePlanVersion(planId, asOf, tx);
+    }
+  }
+  db(tx) {
+    return tx ?? this.prisma;
   }
   async findLatestLive(planId, tx) {
-    const db = resolveClient(this.prisma, tx);
-    const row = await db.planVersion.findFirst({
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planId);
+    const row = await this.versions(db).findFirst({
       where: {
-        planId,
+        planId: storedPlanId,
         publishedAt: {
           not: null
         },
@@ -631,8 +841,40 @@ var PrismaPlanVersionRepository = class {
       }
     });
     if (!row) return null;
+    return this.toRecord(db, row);
+  }
+  async findActivePlanVersion(planId, asOf, tx) {
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planId);
+    const activeWhere = this.fields.endsAt ? buildActivePlanVersionWhere(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere(asOf);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        ...activeWhere
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    if (!row) return null;
+    return this.toRecord(db, row);
+  }
+  versions(client) {
+    return getPrismaDelegate(client, this.delegateName);
+  }
+  async toRecord(client, row) {
     return {
-      planId: row.planId,
+      planId: await this.binding.toPlanKey(client, row.planId),
       quotas: toQuotaMap(row.quotas),
       features: toStringArray(row.features)
     };
@@ -641,9 +883,12 @@ var PrismaPlanVersionRepository = class {
 PrismaPlanVersionRepository = _ts_decorate8([
   Injectable8(),
   _ts_param7(0, Inject7(PRISMA_CLIENT_TOKEN)),
+  _ts_param7(1, Optional3()),
+  _ts_param7(1, Inject7(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata7("design:type", Function),
   _ts_metadata7("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanVersionRepositoryClient === "undefined" ? Object : PlanVersionRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanVersionRepository);
 
@@ -1084,7 +1329,7 @@ PrismaPromoSubscriptionLookup = _ts_decorate12([
 ], PrismaPromoSubscriptionLookup);
 
 // src/prisma-subscription.repository.ts
-import { Inject as Inject12, Injectable as Injectable13 } from "@nestjs/common";
+import { Inject as Inject12, Injectable as Injectable13, Optional as Optional4 } from "@nestjs/common";
 function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1111,19 +1356,35 @@ var PrismaSubscriptionRepository = class {
     __name(this, "PrismaSubscriptionRepository");
   }
   prisma;
-  constructor(prisma) {
+  countByBundleVersionId;
+  binding;
+  planVersionDelegateName;
+  subscriptionDelegateName;
+  subscriptionBundleDelegateName;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.planVersionDelegateName = schema.delegates.entitlementPlanVersion;
+    this.subscriptionDelegateName = schema.tenantSubscription.delegate;
+    this.subscriptionBundleDelegateName = schema.tenantSubscription.subscriptionBundleDelegate;
+    if (this.subscriptionBundleDelegateName) {
+      this.countByBundleVersionId = (bundleVersionId) => this.countActiveBundleBindings(bundleVersionId);
+    }
+  }
+  db(tx) {
+    return tx ?? this.prisma;
   }
   async findByTenantId(tenantId) {
-    return this.loadByTenantId(this.prisma, tenantId);
+    return this.loadByTenantId(this.db(), tenantId);
   }
   async findByTenantIdLocked(tenantId, tx) {
-    const db = resolveClient(this.prisma, tx);
+    const db = this.db(tx);
     await db.$queryRaw`SELECT id FROM subscriptions WHERE "tenantId" = ${tenantId} FOR UPDATE`;
     return this.loadByTenantId(db, tenantId);
   }
   async countByPlanVersionId(planVersionId) {
-    return this.prisma.subscription.count({
+    return this.subscriptions(this.db()).count({
       where: {
         OR: [
           {
@@ -1136,22 +1397,72 @@ var PrismaSubscriptionRepository = class {
       }
     });
   }
-  async countActiveByPlanKey(_projectKey) {
-    const rows = await this.prisma.subscription.findMany({
+  async countActiveByPlanKey(projectKey) {
+    const db = this.db();
+    const subscriptions = await this.subscriptions(db).findMany({
       where: {
         status: {
           in: ACTIVE_STATUSES
         }
+      },
+      select: {
+        planVersionId: true
+      }
+    });
+    const versionIds = [
+      ...new Set(subscriptions.map((subscription) => subscription.planVersionId))
+    ];
+    if (versionIds.length === 0) return {};
+    const planVersions = await this.planVersions(db).findMany({
+      where: {
+        id: {
+          in: versionIds
+        }
+      },
+      select: {
+        id: true,
+        planId: true
       }
     });
+    const planVersionById = new Map(planVersions.map((planVersion) => [
+      planVersion.id,
+      planVersion
+    ]));
+    const storedPlanIds = [
+      ...new Set(planVersions.map((planVersion) => planVersion.planId))
+    ];
+    const planKeyByStoredId = await this.planKeysForProject(db, storedPlanIds, projectKey);
     const counts = {};
-    for (const row of rows) {
-      counts[row.plan] = (counts[row.plan] ?? 0) + 1;
+    for (const subscription of subscriptions) {
+      const planVersion = planVersionById.get(subscription.planVersionId);
+      const planKey = planVersion ? planKeyByStoredId.get(planVersion.planId) : void 0;
+      if (!planKey) continue;
+      counts[planKey] = (counts[planKey] ?? 0) + 1;
     }
     return counts;
   }
+  async countActiveBundleBindings(bundleVersionId) {
+    if (!this.subscriptionBundleDelegateName) {
+      throw new Error("SubscriptionBundle counting is not configured.");
+    }
+    return getPrismaDelegate(this.prisma, this.subscriptionBundleDelegateName).count({
+      where: {
+        bundleVersionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: /* @__PURE__ */ new Date()
+            }
+          }
+        ]
+      }
+    });
+  }
   async loadByTenantId(db, tenantId) {
-    const row = await db.subscription.findUnique({
+    const row = await this.subscriptions(db).findUnique({
       where: {
         tenantId
       }
@@ -1160,7 +1471,7 @@ var PrismaSubscriptionRepository = class {
     return this.toRecord(db, row);
   }
   async toRecord(db, row) {
-    const planVersion = await db.planVersion.findUnique({
+    const planVersion = await this.planVersions(db).findUnique({
       where: {
         id: row.planVersionId
       }
@@ -1168,10 +1479,13 @@ var PrismaSubscriptionRepository = class {
     if (!planVersion) {
       throw new Error(`Subscription ${row.id} references missing PlanVersion ${row.planVersionId}.`);
     }
+    const planKey = await this.binding.toPlanKey(db, planVersion.planId);
     return {
       id: row.id,
       tenantId: row.tenantId,
-      plan: row.plan,
+      // The concrete PlanVersion is authoritative. This also normalizes
+      // legacy rows whose denormalized `Subscription.plan` drifted.
+      plan: planKey,
       status: row.status,
       isPilot: row.isPilot,
       trialEntitlementPlan: row.trialEntitlementPlan,
@@ -1180,19 +1494,78 @@ var PrismaSubscriptionRepository = class {
       customLimits: row.customLimits ?? null,
       planVersionId: row.planVersionId,
       planVersion: {
-        planId: planVersion.planId,
+        planId: planKey,
         quotas: toQuotaMap(planVersion.quotas),
         features: toStringArray(planVersion.features)
       }
     };
   }
+  planVersions(client) {
+    return getPrismaDelegate(client, this.planVersionDelegateName);
+  }
+  subscriptions(client) {
+    return getPrismaDelegate(client, this.subscriptionDelegateName);
+  }
+  async planKeysForProject(db, storedPlanIds, projectKey) {
+    if (storedPlanIds.length === 0) return /* @__PURE__ */ new Map();
+    if (this.binding.mode === "normalized-plan-id") {
+      if (this.binding.projectKey && this.binding.projectKey !== projectKey) {
+        throw new Error(`Prisma plan binding is configured for project '${this.binding.projectKey}', not '${projectKey}'.`);
+      }
+      const plans2 = await db.plan.findMany({
+        where: {
+          projectKey,
+          id: {
+            in: storedPlanIds
+          }
+        },
+        select: {
+          id: true,
+          planKey: true
+        }
+      });
+      return new Map(plans2.map((plan) => [
+        plan.id,
+        plan.planKey
+      ]));
+    }
+    const plans = await db.plan.findMany({
+      where: {
+        planKey: {
+          in: storedPlanIds
+        }
+      },
+      select: {
+        projectKey: true,
+        planKey: true
+      }
+    });
+    const projectsByPlanKey = /* @__PURE__ */ new Map();
+    for (const plan of plans) {
+      const projects = projectsByPlanKey.get(plan.planKey) ?? /* @__PURE__ */ new Set();
+      projects.add(plan.projectKey);
+      projectsByPlanKey.set(plan.planKey, projects);
+    }
+    return new Map(storedPlanIds.flatMap((planKey) => {
+      const projects = projectsByPlanKey.get(planKey);
+      return projects?.size === 1 && projects.has(projectKey) ? [
+        [
+          planKey,
+          planKey
+        ]
+      ] : [];
+    }));
+  }
 };
 PrismaSubscriptionRepository = _ts_decorate13([
   Injectable13(),
   _ts_param12(0, Inject12(PRISMA_CLIENT_TOKEN)),
+  _ts_param12(1, Optional4()),
+  _ts_param12(1, Inject12(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata12("design:type", Function),
   _ts_metadata12("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof SubscriptionRepositoryClient === "undefined" ? Object : SubscriptionRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaSubscriptionRepository);
 
@@ -1304,7 +1677,8 @@ var PrismaTransactionRunner = class {
     this.prisma = prisma;
   }
   async run(fn) {
-    return this.prisma.$transaction((tx) => fn(tx));
+    const transaction = this.prisma.$transaction.bind(this.prisma);
+    return transaction((tx) => fn(tx));
   }
 };
 PrismaTransactionRunner = _ts_decorate15([
@@ -1312,7 +1686,7 @@ PrismaTransactionRunner = _ts_decorate15([
   _ts_param14(0, Inject14(PRISMA_CLIENT_TOKEN)),
   _ts_metadata14("design:type", Function),
   _ts_metadata14("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof Record === "undefined" ? Object : Record
   ])
 ], PrismaTransactionRunner);
 
@@ -1363,8 +1737,8 @@ function prismaPersistence(options) {
       superAdminProvisioning: buildProvisioning(client, options.passwordHasher)
     },
     entitlement: {
-      subscriptionRepository: provide((prisma) => new PrismaSubscriptionRepository(prisma)),
-      planVersionRepository: provide((prisma) => new PrismaPlanVersionRepository(prisma))
+      subscriptionRepository: provide((prisma) => new PrismaSubscriptionRepository(prisma, options.schema)),
+      planVersionRepository: provide((prisma) => new PrismaPlanVersionRepository(prisma, options.schema))
     },
     promo: {
       promoCodeRepository: provide((prisma) => new PrismaPromoCodeRepository(prisma)),
@@ -1373,8 +1747,8 @@ function prismaPersistence(options) {
       subscriptionLookup: provide((prisma) => new PrismaPromoSubscriptionLookup(prisma)),
       revenueAggregator: new ZeroPromoRevenueDeductionAggregator()
     },
-    planCatalogReadSink: provide((prisma) => new PrismaPlanCatalogReadSink(prisma)),
-    planCatalogImportSink: provide((prisma) => new PrismaPlanCatalogImportSink(prisma))
+    planCatalogReadSink: provide((prisma) => new PrismaPlanCatalogReadSink(prisma, options.schema)),
+    planCatalogImportSink: provide((prisma) => new PrismaPlanCatalogImportSink(prisma, options.schema))
   };
 }
 __name(prismaPersistence, "prismaPersistence");
@@ -1443,7 +1817,7 @@ var PrismaSubscriptionBundleRepository = class {
     this.prisma = prisma;
   }
   db(tx) {
-    return resolveClient(this.prisma, tx);
+    return tx ?? this.prisma;
   }
   async listBySubscription(subscriptionId) {
     const rows = await this.db().subscriptionBundle.findMany({
@@ -1543,7 +1917,7 @@ PrismaSubscriptionBundleRepository = _ts_decorate17([
   _ts_param15(0, Inject15(PRISMA_CLIENT_TOKEN)),
   _ts_metadata15("design:type", Function),
   _ts_metadata15("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof SubscriptionBundleClient === "undefined" ? Object : SubscriptionBundleClient
   ])
 ], PrismaSubscriptionBundleRepository);
 function toRecord3(row) {
@@ -1562,7 +1936,8 @@ function toRecord3(row) {
 __name(toRecord3, "toRecord");
 
 // src/prisma-tenant-subscription-write.adapter.ts
-import { Inject as Inject16, Injectable as Injectable18 } from "@nestjs/common";
+import { Inject as Inject16, Injectable as Injectable18, Optional as Optional5 } from "@nestjs/common";
+import { buildActivePlanVersionWhere as buildActivePlanVersionWhere2 } from "@saasicat/types";
 function _ts_decorate18(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1585,37 +1960,66 @@ var PrismaTenantSubscriptionWriteAdapter = class {
     __name(this, "PrismaTenantSubscriptionWriteAdapter");
   }
   prisma;
-  constructor(prisma) {
+  applyOnboardingSelection;
+  schema;
+  planBinding;
+  constructor(prisma, options) {
     this.prisma = prisma;
-  }
-  db(tx) {
-    return resolveClient(this.prisma, tx);
+    this.schema = resolvePrismaSchemaOptions(options);
+    this.planBinding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.assertConfiguration();
+    if (this.schema.tenantSubscription.atomicOnboardingSelection) {
+      this.applyOnboardingSelection = (tenantId, input, redeemPromo) => this.applyOnboardingSelectionAtomic(tenantId, input, redeemPromo);
+    }
   }
   async changePlanImmediate(tenantId, input) {
-    const updated = await this.db().subscription.update({
+    if (this.schema.tenantSubscription.synchronizePlanVersion) {
+      return this.prisma.$transaction((tx) => this.changePlanImmediateInClient(tx, tenantId, input));
+    }
+    return this.changePlanImmediateInClient(this.prisma, tenantId, input);
+  }
+  async changePlanImmediateInClient(client, tenantId, input) {
+    const subscription = this.subscription(client);
+    const data = {
+      plan: input.planId,
+      billingCycle: input.cycle,
+      pendingPlan: null,
+      pendingBillingCycle: null,
+      pendingEffectiveAt: null,
+      ...input.nextStatus ? {
+        status: input.nextStatus
+      } : {},
+      ...input.periodStart && input.periodEnd ? {
+        currentPeriodStart: input.periodStart,
+        currentPeriodEnd: input.periodEnd
+      } : {},
+      // #17: the platform changePlan path computes the carried-over
+      // trial end and passes it through; null/undefined leaves the
+      // existing trialEndsAt untouched.
+      ...input.trialEndsAt ? {
+        trialEndsAt: input.trialEndsAt
+      } : {}
+    };
+    if (this.schema.tenantSubscription.synchronizePlanVersion) {
+      const current = await subscription.findUnique({
+        where: {
+          tenantId
+        }
+      });
+      if (!current) {
+        throw new Error(`No subscription for tenant ${tenantId}.`);
+      }
+      const storagePlanId = await this.planBinding.toStoragePlanId(client, input.planId);
+      data.planVersionId = await this.findTargetPlanVersionId(client, storagePlanId, input.periodStart ?? /* @__PURE__ */ new Date());
+      if (await this.pendingVersionBelongsToAnotherPlan(client, current.pendingPlanVersionId, storagePlanId)) {
+        Object.assign(data, clearedPendingVersionData());
+      }
+    }
+    const updated = await subscription.update({
       where: {
         tenantId
       },
-      data: {
-        plan: input.planId,
-        billingCycle: input.cycle,
-        pendingPlan: null,
-        pendingBillingCycle: null,
-        pendingEffectiveAt: null,
-        ...input.nextStatus ? {
-          status: input.nextStatus
-        } : {},
-        ...input.periodStart && input.periodEnd ? {
-          currentPeriodStart: input.periodStart,
-          currentPeriodEnd: input.periodEnd
-        } : {},
-        // #17: the platform changePlan path computes the carried-over
-        // trial end and passes it through; null/undefined leaves the
-        // existing trialEndsAt untouched.
-        ...input.trialEndsAt ? {
-          trialEndsAt: input.trialEndsAt
-        } : {}
-      }
+      data
     });
     return {
       plan: updated.plan,
@@ -1623,7 +2027,7 @@ var PrismaTenantSubscriptionWriteAdapter = class {
     };
   }
   async schedulePlanChange(tenantId, input) {
-    await this.db().subscription.update({
+    await this.subscription(this.prisma).update({
       where: {
         tenantId
       },
@@ -1635,7 +2039,8 @@ var PrismaTenantSubscriptionWriteAdapter = class {
     });
   }
   async acceptPendingPlanVersion(tenantId, userId, now) {
-    const sub = await this.db().subscription.findUnique({
+    const subscription = this.subscription(this.prisma);
+    const sub = await subscription.findUnique({
       where: {
         tenantId
       }
@@ -1643,17 +2048,15 @@ var PrismaTenantSubscriptionWriteAdapter = class {
     if (!sub) {
       throw new Error(`No subscription for tenant ${tenantId}.`);
     }
-    if (sub.pendingPlanVersionAccepted) {
-      return {
-        accepted: true,
-        acceptedAt: sub.pendingPlanVersionAcceptedAt,
-        effectiveAt: sub.pendingPlanVersionEffectiveAt,
-        alreadyAccepted: true
-      };
+    if (!sub.pendingPlanVersionId) {
+      throw new Error(`No pending PlanVersion for tenant ${tenantId}.`);
     }
-    const updated = await this.db().subscription.update({
+    const pendingPlanVersionId = sub.pendingPlanVersionId;
+    const claimed = await subscription.updateMany({
       where: {
-        id: sub.id
+        id: sub.id,
+        pendingPlanVersionId,
+        pendingPlanVersionAccepted: false
       },
       data: {
         pendingPlanVersionAccepted: true,
@@ -1661,15 +2064,66 @@ var PrismaTenantSubscriptionWriteAdapter = class {
         pendingPlanVersionAcceptedByUserId: userId
       }
     });
+    const updated = await subscription.findUnique({
+      where: {
+        id: sub.id
+      }
+    });
+    if (!updated) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    if (claimed.count === 0 && (updated.pendingPlanVersionId !== pendingPlanVersionId || !updated.pendingPlanVersionAccepted)) {
+      throw new Error(`Pending PlanVersion changed while accepting it for tenant ${tenantId}.`);
+    }
     return {
       accepted: true,
       acceptedAt: updated.pendingPlanVersionAcceptedAt,
       effectiveAt: updated.pendingPlanVersionEffectiveAt,
-      alreadyAccepted: false
+      alreadyAccepted: claimed.count === 0
     };
   }
+  async applyOnboardingSelectionAtomic(tenantId, input, redeemPromo) {
+    return this.prisma.$transaction(async (tx) => {
+      const data = {
+        plan: input.planId,
+        billingCycle: input.cycle,
+        pendingPlan: null,
+        pendingBillingCycle: null,
+        pendingEffectiveAt: null,
+        ...clearedPendingVersionData(),
+        ...input.nextStatus ? {
+          status: input.nextStatus
+        } : {},
+        ...input.periodStart && input.periodEnd ? {
+          currentPeriodStart: input.periodStart,
+          currentPeriodEnd: input.periodEnd
+        } : {}
+      };
+      if (this.schema.tenantSubscription.synchronizePlanVersion) {
+        const storagePlanId = await this.planBinding.toStoragePlanId(tx, input.planId);
+        data.planVersionId = await this.findTargetPlanVersionId(tx, storagePlanId, input.periodStart ?? /* @__PURE__ */ new Date());
+      }
+      const updated = await this.subscription(tx).update({
+        where: {
+          tenantId
+        },
+        data
+      });
+      let promoRedemption = null;
+      if (redeemPromo) {
+        promoRedemption = await redeemPromo(tx, updated.id);
+      }
+      return {
+        plan: updated.plan,
+        billingCycle: updated.billingCycle,
+        subscriptionId: updated.id,
+        promoRedemption
+      };
+    });
+  }
   async cancelSubscription(tenantId, immediate, now) {
-    const sub = await this.db().subscription.findUnique({
+    const subscription = this.subscription(this.prisma);
+    const sub = await subscription.findUnique({
       where: {
         tenantId
       }
@@ -1678,7 +2132,7 @@ var PrismaTenantSubscriptionWriteAdapter = class {
       throw new Error(`No subscription for tenant ${tenantId}.`);
     }
     const canceledAt = immediate ? now : sub.currentPeriodEnd ?? now;
-    const updated = await this.db().subscription.update({
+    const updated = await subscription.update({
       where: {
         tenantId
       },
@@ -1692,18 +2146,107 @@ var PrismaTenantSubscriptionWriteAdapter = class {
       status: updated.status
     };
   }
+  subscription(client) {
+    return getPrismaDelegate(client, this.schema.tenantSubscription.delegate);
+  }
+  planVersions(client) {
+    return getPrismaDelegate(client, this.schema.delegates.entitlementPlanVersion);
+  }
+  async findTargetPlanVersionId(client, storagePlanId, asOf) {
+    const activeWindow = this.schema.tenantSubscription.activeVersionSelection === "validity-window";
+    const activeVersionWhere = this.schema.tenantSubscription.withEndsAt ? buildActivePlanVersionWhere2(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere2(asOf);
+    const where = activeWindow ? {
+      planId: storagePlanId,
+      ...activeVersionWhere
+    } : {
+      planId: storagePlanId,
+      publishedAt: {
+        not: null
+      },
+      supersededAt: null,
+      ...this.schema.tenantSubscription.withEndsAt ? {
+        OR: [
+          {
+            endsAt: null
+          },
+          {
+            endsAt: {
+              gt: asOf
+            }
+          }
+        ]
+      } : {}
+    };
+    const target = await this.planVersions(client).findFirst({
+      where,
+      orderBy: activeWindow ? [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ] : {
+        version: "desc"
+      }
+    });
+    if (!target) {
+      throw new Error(`No active PlanVersion for plan '${storagePlanId}'.`);
+    }
+    return target.id;
+  }
+  async pendingVersionBelongsToAnotherPlan(client, pendingPlanVersionId, targetStoragePlanId) {
+    if (!pendingPlanVersionId) return false;
+    const pending = await this.planVersions(client).findUnique({
+      where: {
+        id: pendingPlanVersionId
+      }
+    });
+    return !pending || pending.planId !== targetStoragePlanId;
+  }
+  assertConfiguration() {
+    if (!this.schema.tenantSubscription.synchronizePlanVersion) return;
+    const entitlementFields = this.schema.planVersionFields.entitlement;
+    if (this.schema.tenantSubscription.activeVersionSelection === "validity-window" && !entitlementFields.validityWindows) {
+      throw new Error("tenantSubscription.activeVersionSelection='validity-window' requires planVersionFields.entitlement.validityWindows=true.");
+    }
+    if (this.schema.tenantSubscription.withEndsAt && !entitlementFields.endsAt) {
+      throw new Error("tenantSubscription.withEndsAt=true requires planVersionFields.entitlement.endsAt=true.");
+    }
+  }
 };
 PrismaTenantSubscriptionWriteAdapter = _ts_decorate18([
   Injectable18(),
   _ts_param16(0, Inject16(PRISMA_CLIENT_TOKEN)),
+  _ts_param16(1, Optional5()),
+  _ts_param16(1, Inject16(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata16("design:type", Function),
   _ts_metadata16("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof TransactionalPrismaClient === "undefined" ? Object : TransactionalPrismaClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaTenantSubscriptionWriteAdapter);
+function clearedPendingVersionData() {
+  return {
+    pendingPlanVersionId: null,
+    pendingPlanVersionEffectiveAt: null,
+    pendingPlanVersionAccepted: false,
+    pendingPlanVersionAcceptedAt: null,
+    pendingPlanVersionAcceptedByUserId: null,
+    pendingPlanVersionNotifiedAt: null,
+    pendingPlanVersionReminderSentAt: null
+  };
+}
+__name(clearedPendingVersionData, "clearedPendingVersionData");
 
 // src/prisma-plan.repository.ts
-import { Inject as Inject17, Injectable as Injectable19 } from "@nestjs/common";
+import { Inject as Inject17, Injectable as Injectable19, Optional as Optional6 } from "@nestjs/common";
+import { buildActivePlanVersionWhere as buildActivePlanVersionWhere3 } from "@saasicat/types";
 function _ts_decorate19(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1726,30 +2269,105 @@ var PrismaPlanRepository = class {
     __name(this, "PrismaPlanRepository");
   }
   prisma;
-  constructor(prisma) {
+  binding;
+  delegateName;
+  fields;
+  constructor(prisma, options) {
     this.prisma = prisma;
+    const schema = resolvePrismaSchemaOptions(options);
+    this.binding = createPrismaPlanBindingResolver(options?.planBinding);
+    this.delegateName = schema.delegates.catalogPlanVersion;
+    this.fields = schema.planVersionFields.catalog;
   }
   db(tx) {
-    return resolveClient(this.prisma, tx);
+    return tx ?? this.prisma;
+  }
+  versions(client) {
+    return getPrismaDelegate(client, this.delegateName);
   }
   // ─── Stem operations (Pack 1) ───
   async list(filter) {
     const excludeDeleted = filter.excludeDeleted ?? true;
+    const db = this.db();
     let publishedKeys = null;
     if (filter.onlyPublished) {
-      const live = await this.db().planVersion.findMany({
-        where: {
-          publishedAt: {
-            not: null
-          },
-          supersededAt: null
+      if (this.binding.mode === "legacy-plan-key") {
+        const projectPlans = await db.plan.findMany({
+          where: {
+            projectKey: filter.projectKey,
+            ...excludeDeleted ? {
+              deletedAt: null
+            } : {}
+          }
+        });
+        const candidateKeys = [
+          ...new Set(projectPlans.map((plan) => plan.planKey))
+        ];
+        const allMatchingPlans = candidateKeys.length === 0 ? [] : await db.plan.findMany({
+          where: {
+            planKey: {
+              in: candidateKeys
+            }
+          }
+        });
+        const projectsByKey = /* @__PURE__ */ new Map();
+        for (const plan of allMatchingPlans) {
+          const projects = projectsByKey.get(plan.planKey) ?? /* @__PURE__ */ new Set();
+          projects.add(plan.projectKey);
+          projectsByKey.set(plan.planKey, projects);
         }
-      });
-      publishedKeys = [
-        ...new Set(live.map((version) => version.planId))
-      ];
+        const unambiguousKeys = candidateKeys.filter((planKey) => projectsByKey.get(planKey)?.size === 1);
+        const live = await this.versions(db).findMany({
+          where: {
+            planId: {
+              in: unambiguousKeys
+            },
+            publishedAt: {
+              not: null
+            },
+            supersededAt: null
+          }
+        });
+        publishedKeys = [
+          ...new Set(live.map((version) => version.planId))
+        ];
+      } else {
+        const projectPlans = await db.plan.findMany({
+          where: {
+            projectKey: filter.projectKey,
+            ...excludeDeleted ? {
+              deletedAt: null
+            } : {}
+          }
+        });
+        const planKeyById = new Map(projectPlans.map((plan) => [
+          plan.id,
+          plan.planKey
+        ]));
+        const live = await this.versions(db).findMany({
+          where: {
+            planId: {
+              in: [
+                ...planKeyById.keys()
+              ]
+            },
+            publishedAt: {
+              not: null
+            },
+            supersededAt: null
+          }
+        });
+        publishedKeys = [
+          ...new Set(live.flatMap((version) => {
+            const planKey = planKeyById.get(version.planId);
+            return planKey ? [
+              planKey
+            ] : [];
+          }))
+        ];
+      }
     }
-    const rows = await this.db().plan.findMany({
+    const rows = await db.plan.findMany({
       where: {
         projectKey: filter.projectKey,
         ...excludeDeleted ? {
@@ -1844,65 +2462,112 @@ var PrismaPlanRepository = class {
   }
   // ─── Lifecycle operations (Pack 2a) — keyed by planKey ───
   async listVersions(planKey) {
-    const rows = await this.db().planVersion.findMany({
+    const db = this.db();
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const rows = await this.versions(db).findMany({
       where: {
-        planId: planKey
+        planId: storedPlanId
       },
       orderBy: {
         version: "asc"
       }
     });
-    return rows.map(toPlanVersionRow2);
+    return rows.map((row) => this.toPlanVersionRow(row, planKey));
   }
   async findVersionById(versionId) {
-    const row = await this.db().planVersion.findUnique({
+    const db = this.db();
+    const row = await this.versions(db).findUnique({
       where: {
         id: versionId
       }
     });
-    return row ? toPlanVersionRow2(row) : null;
+    return row ? this.toPlanVersionRow(row, await this.binding.toPlanKey(db, row.planId)) : null;
   }
   async findCurrentDraft(planKey) {
-    const row = await this.db().planVersion.findFirst({
+    const db = this.db();
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const row = await this.versions(db).findFirst({
       where: {
-        planId: planKey,
+        planId: storedPlanId,
         publishedAt: null
       }
     });
-    return row ? toPlanVersionRow2(row) : null;
+    return row ? this.toPlanVersionRow(row, planKey) : null;
   }
   async findLatestLivePlanVersion(planKey, tx) {
-    const row = await this.db(tx).planVersion.findFirst({
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const row = await this.versions(db).findFirst({
       where: {
-        planId: planKey,
+        planId: storedPlanId,
         publishedAt: {
           not: null
         },
-        supersededAt: null
+        supersededAt: null,
+        ...this.fields.endsAt ? {
+          OR: [
+            {
+              endsAt: null
+            },
+            {
+              endsAt: {
+                gt: /* @__PURE__ */ new Date()
+              }
+            }
+          ]
+        } : {}
       },
       orderBy: {
         version: "desc"
       }
     });
-    return row ? toPlanVersionRow2(row) : null;
+    return row ? this.toPlanVersionRow(row, planKey) : null;
   }
-  async findActivePlanVersion() {
-    throw new Error("findActivePlanVersion is not supported by the shipped @saasicat/adapter-prisma PlanRepository: the canonical plan_versions schema (03-plan-versions.prisma) has no validFrom/validUntil columns, so a version cannot be resolved by validity window. Use findLatestLivePlanVersion for the newest live version, or provide a custom PlanRepository adapter on a schema that carries the validity-window columns.");
+  async findActivePlanVersion(planKey, asOf = /* @__PURE__ */ new Date(), tx) {
+    if (!this.fields.validityWindows) {
+      throw new Error("findActivePlanVersion requires schema.planVersionFields.catalog.validityWindows=true and the current @saasicat/spec PlanVersion validity columns. Apply the additive schema first, or use findLatestLivePlanVersion for a 0.6-compatible newest-live lookup.");
+    }
+    const db = this.db(tx);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const activeWhere = this.fields.endsAt ? buildActivePlanVersionWhere3(asOf, {
+      withEndsAt: true
+    }) : buildActivePlanVersionWhere3(asOf);
+    const row = await this.versions(db).findFirst({
+      where: {
+        planId: storedPlanId,
+        ...activeWhere
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    return row ? this.toPlanVersionRow(row, planKey) : null;
   }
   async createPlanVersionDraft(data) {
     const planKey = data.planId;
-    const latest = await this.db().planVersion.findFirst({
+    const db = this.db();
+    const planVersion = this.versions(db);
+    const storedPlanId = await this.binding.toStoragePlanId(db, planKey);
+    const latest = await planVersion.findFirst({
       where: {
-        planId: planKey
+        planId: storedPlanId
       },
       orderBy: {
         version: "desc"
       }
     });
     const nextVersion = (latest?.version ?? 0) + 1;
-    const created = await this.db().planVersion.create({
+    const created = await planVersion.create({
       data: {
-        planId: planKey,
+        planId: storedPlanId,
         version: nextVersion,
         baseVersionId: data.baseVersionId ?? null,
         features: data.features,
@@ -1911,13 +2576,17 @@ var PrismaPlanRepository = class {
         yearlyNet: data.yearlyNet,
         marketed: data.marketed ?? true,
         changeNote: data.changeNote ?? "",
-        createdByUserId: data.createdByUserId ?? null
+        createdByUserId: data.createdByUserId ?? null,
+        ...this.fields.validityWindows ? {
+          validFrom: data.validFrom ? new Date(data.validFrom) : null,
+          validUntil: data.validUntil ? new Date(data.validUntil) : null
+        } : {}
       }
     });
-    return toPlanVersionRow2(created);
+    return this.toPlanVersionRow(created, planKey);
   }
   async updatePlanVersionDraft(versionId, data) {
-    const updated = await this.db().planVersion.update({
+    const updated = await this.versions(this.db()).update({
       where: {
         id: versionId
       },
@@ -1939,13 +2608,21 @@ var PrismaPlanRepository = class {
         } : {},
         ...data.changeNote !== void 0 ? {
           changeNote: data.changeNote
+        } : {},
+        ...this.fields.validityWindows && data.validFrom !== void 0 ? {
+          validFrom: data.validFrom ? new Date(data.validFrom) : null
+        } : {},
+        ...this.fields.validityWindows && data.validUntil !== void 0 ? {
+          validUntil: data.validUntil ? new Date(data.validUntil) : null
         } : {}
       }
     });
-    return toPlanVersionRow2(updated);
+    const planKey = await this.binding.toPlanKey(this.db(), updated.planId);
+    return this.toPlanVersionRow(updated, planKey);
   }
   async publishPlanVersionDraft(versionId, publishMeta, tx) {
-    const draft = await this.db(tx).planVersion.findUnique({
+    const operationDb = this.db(tx);
+    const draft = await this.versions(operationDb).findUnique({
       where: {
         id: versionId
       }
@@ -1953,11 +2630,12 @@ var PrismaPlanRepository = class {
     if (!draft) {
       throw new Error(`PlanVersion ${versionId} not found.`);
     }
-    const planKey = draft.planId;
+    const storedPlanId = draft.planId;
     const publish = /* @__PURE__ */ __name(async (db) => {
-      const previous = await db.planVersion.findFirst({
+      const planVersion = this.versions(db);
+      const previous = await planVersion.findFirst({
         where: {
-          planId: planKey,
+          planId: storedPlanId,
           publishedAt: {
             not: null
           },
@@ -1972,16 +2650,20 @@ var PrismaPlanRepository = class {
       });
       const now = /* @__PURE__ */ new Date();
       if (previous) {
-        await db.planVersion.update({
+        const predecessorValidUntil = new Date(publishMeta.validFrom.getTime() - 24 * 60 * 60 * 1e3);
+        await planVersion.update({
           where: {
             id: previous.id
           },
           data: {
-            supersededAt: now
+            supersededAt: now,
+            ...this.fields.validityWindows ? {
+              validUntil: predecessorValidUntil
+            } : {}
           }
         });
       }
-      return db.planVersion.update({
+      return planVersion.update({
         where: {
           id: versionId
         },
@@ -1989,15 +2671,21 @@ var PrismaPlanRepository = class {
           publishedAt: now,
           publishedChanges: publishMeta.publishedChanges,
           nonRegressive: publishMeta.nonRegressive,
-          publishedByUserId: publishMeta.publishedByUserId
+          publishedByUserId: publishMeta.publishedByUserId,
+          ...this.fields.validityWindows ? {
+            validFrom: publishMeta.validFrom,
+            validUntil: publishMeta.validUntil
+          } : {}
         }
       });
     }, "publish");
     const published = tx ? await publish(this.db(tx)) : await this.prisma.$transaction((txClient) => publish(txClient));
-    return toPlanVersionRow2(published);
+    const planKey = await this.binding.toPlanKey(operationDb, storedPlanId);
+    return this.toPlanVersionRow(published, planKey);
   }
   async deletePlanVersionDraft(versionId) {
-    const row = await this.db().planVersion.findUnique({
+    const planVersion = this.versions(this.db());
+    const row = await planVersion.findUnique({
       where: {
         id: versionId
       }
@@ -2006,23 +2694,42 @@ var PrismaPlanRepository = class {
     if (row.publishedAt !== null) {
       throw new Error(`PlanVersion ${versionId} is already published and cannot be discarded (published versions are immutable \u2014 contract protection P1).`);
     }
-    await this.db().planVersion.deleteMany({
+    await planVersion.deleteMany({
       where: {
         id: versionId,
         publishedAt: null
       }
     });
   }
-  async terminate() {
-    throw new Error("terminate is not supported by the shipped @saasicat/adapter-prisma PlanRepository: the canonical plan_versions schema (03-plan-versions.prisma) has no endsAt column. Provide a custom PlanRepository adapter on a schema that carries endsAt to support SuperAdmin-initiated plan-version termination.");
+  async terminate(versionId, endsAt) {
+    if (!this.fields.endsAt) {
+      throw new Error("terminate requires schema.planVersionFields.catalog.endsAt=true and the current @saasicat/spec PlanVersion.endsAt column. Apply the additive schema before enabling SuperAdmin-initiated plan-version termination.");
+    }
+    const db = this.db();
+    const updated = await this.versions(db).update({
+      where: {
+        id: versionId
+      },
+      data: {
+        endsAt
+      }
+    });
+    const planKey = await this.binding.toPlanKey(db, updated.planId);
+    return this.toPlanVersionRow(updated, planKey);
+  }
+  toPlanVersionRow(row, planKey) {
+    return toPlanVersionRow2(row, planKey, this.fields);
   }
 };
 PrismaPlanRepository = _ts_decorate19([
   Injectable19(),
   _ts_param17(0, Inject17(PRISMA_CLIENT_TOKEN)),
+  _ts_param17(1, Optional6()),
+  _ts_param17(1, Inject17(PRISMA_SCHEMA_OPTIONS_TOKEN)),
   _ts_metadata17("design:type", Function),
   _ts_metadata17("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PlanRepositoryClient === "undefined" ? Object : PlanRepositoryClient,
+    typeof PrismaSchemaOptions === "undefined" ? Object : PrismaSchemaOptions
   ])
 ], PrismaPlanRepository);
 function toPlanRow2(row) {
@@ -2040,12 +2747,12 @@ function toPlanRow2(row) {
   };
 }
 __name(toPlanRow2, "toPlanRow");
-function toPlanVersionRow2(row) {
-  return {
+function toPlanVersionRow2(row, planKey, fields) {
+  const mapped = {
     id: row.id,
     version: row.version,
     baseVersionId: row.baseVersionId,
-    planId: row.planId,
+    planId: planKey,
     features: toStringArray(row.features),
     quotas: toQuotaMap(row.quotas),
     monthlyNet: row.monthlyNet.toString(),
@@ -2056,19 +2763,23 @@ function toPlanVersionRow2(row) {
     publishedChanges: Array.isArray(row.publishedChanges) ? row.publishedChanges : null,
     changeNote: row.changeNote,
     nonRegressive: row.nonRegressive,
-    // The canonical plan_versions schema carries no validity-window columns.
-    validFrom: null,
-    validUntil: null,
+    validFrom: fields.validityWindows && row.validFrom ? row.validFrom.toISOString() : null,
+    validUntil: fields.validityWindows && row.validUntil ? row.validUntil.toISOString() : null,
     createdByUserId: row.createdByUserId,
     publishedByUserId: row.publishedByUserId,
     createdAt: row.createdAt.toISOString(),
     updatedAt: row.updatedAt.toISOString()
   };
+  if (fields.endsAt) {
+    mapped.endsAt = row.endsAt?.toISOString() ?? null;
+  }
+  return mapped;
 }
 __name(toPlanVersionRow2, "toPlanVersionRow");
 
 // src/prisma-bundle.repository.ts
-import { Inject as Inject18, Injectable as Injectable20 } from "@nestjs/common";
+import { Inject as Inject18, Injectable as Injectable20, Optional as Optional7 } from "@nestjs/common";
+import { buildActiveVersionWhere } from "@saasicat/types";
 function _ts_decorate20(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2086,16 +2797,32 @@ function _ts_param18(paramIndex, decorator) {
   };
 }
 __name(_ts_param18, "_ts_param");
+var PRISMA_BUNDLE_REPOSITORY_OPTIONS = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PrismaBundleRepositoryOptions");
 var PrismaBundleRepository = class {
   static {
     __name(this, "PrismaBundleRepository");
   }
   prisma;
-  constructor(prisma) {
+  validityWindows;
+  /**
+   * Present only when validity-window mode is enabled. This mirrors the
+   * optional port capability and lets 0.6-schema consumers detect that an
+   * active-at-time lookup is unavailable.
+   */
+  findActiveBundleVersion;
+  constructor(prisma, options = {}) {
     this.prisma = prisma;
+    this.validityWindows = options.validityWindows ?? false;
+    if (this.validityWindows) {
+      this.findActiveBundleVersion = (bundleId, asOf, tx) => this.findActiveBundleVersionWithValidity(bundleId, asOf ?? /* @__PURE__ */ new Date(), tx);
+    }
   }
   db(tx) {
-    return resolveClient(this.prisma, tx);
+    return tx ?? this.prisma;
+  }
+  transaction(work) {
+    const transaction = this.prisma.$transaction;
+    return transaction.call(this.prisma, (tx) => work(tx));
   }
   // ─── Stem operations ───
   async list(filter) {
@@ -2201,7 +2928,7 @@ var PrismaBundleRepository = class {
         version: "asc"
       }
     });
-    return rows.map((row) => toBundleVersionRow(row, bundle));
+    return rows.map((row) => toBundleVersionRow(row, bundle, this.validityWindows));
   }
   async findVersionById(versionId) {
     const row = await this.db().bundleVersion.findUnique({
@@ -2215,7 +2942,7 @@ var PrismaBundleRepository = class {
         id: row.bundleId
       }
     });
-    return toBundleVersionRow(row, bundle);
+    return toBundleVersionRow(row, bundle, this.validityWindows);
   }
   async findCurrentDraft(bundleId) {
     const row = await this.db().bundleVersion.findFirst({
@@ -2230,7 +2957,7 @@ var PrismaBundleRepository = class {
         id: bundleId
       }
     });
-    return toBundleVersionRow(row, bundle);
+    return toBundleVersionRow(row, bundle, this.validityWindows);
   }
   async findLatestLive(bundleId, tx) {
     const db = this.db(tx);
@@ -2252,7 +2979,34 @@ var PrismaBundleRepository = class {
         id: bundleId
       }
     });
-    return toBundleVersionRow(row, bundle);
+    return toBundleVersionRow(row, bundle, this.validityWindows);
+  }
+  async findActiveBundleVersionWithValidity(bundleId, asOf, tx) {
+    const db = this.db(tx);
+    const row = await db.bundleVersion.findFirst({
+      where: {
+        bundleId,
+        ...buildActiveVersionWhere(asOf)
+      },
+      orderBy: [
+        {
+          validFrom: {
+            sort: "desc",
+            nulls: "last"
+          }
+        },
+        {
+          version: "desc"
+        }
+      ]
+    });
+    if (!row) return null;
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle, true);
   }
   async createDraft(data) {
     const db = this.db();
@@ -2287,7 +3041,11 @@ var PrismaBundleRepository = class {
         yearlyNet: data.yearlyNet ?? null,
         marketed: data.marketed ?? true,
         changeNote: data.changeNote ?? "",
-        createdByUserId: data.createdByUserId ?? null
+        createdByUserId: data.createdByUserId ?? null,
+        ...this.validityWindows ? {
+          validFrom: toNullableDate(data.validFrom),
+          validUntil: toNullableDate(data.validUntil)
+        } : {}
       }
     });
     const bundle = await db.bundle.findUnique({
@@ -2295,7 +3053,7 @@ var PrismaBundleRepository = class {
         id: data.bundleId
       }
     });
-    return toBundleVersionRow(created, bundle);
+    return toBundleVersionRow(created, bundle, this.validityWindows);
   }
   async updateDraft(versionId, data) {
     const db = this.db();
@@ -2327,6 +3085,12 @@ var PrismaBundleRepository = class {
         } : {},
         ...data.changeNote !== void 0 ? {
           changeNote: data.changeNote
+        } : {},
+        ...this.validityWindows && data.validFrom !== void 0 ? {
+          validFrom: toNullableDate(data.validFrom)
+        } : {},
+        ...this.validityWindows && data.validUntil !== void 0 ? {
+          validUntil: toNullableDate(data.validUntil)
         } : {}
       }
     });
@@ -2335,9 +3099,15 @@ var PrismaBundleRepository = class {
         id: updated.bundleId
       }
     });
-    return toBundleVersionRow(updated, bundle);
+    return toBundleVersionRow(updated, bundle, this.validityWindows);
   }
   async publishDraft(versionId, publishMeta, tx) {
+    if (this.validityWindows && tx === void 0) {
+      return this.transaction((transaction) => this.publishDraftWithValidity(transaction, versionId, publishMeta));
+    }
+    if (this.validityWindows) {
+      return this.publishDraftWithValidity(this.db(tx), versionId, publishMeta);
+    }
     const db = this.db(tx);
     const draft = await db.bundleVersion.findUnique({
       where: {
@@ -2378,7 +3148,53 @@ var PrismaBundleRepository = class {
         id: published.bundleId
       }
     });
-    return toBundleVersionRow(published, bundle);
+    return toBundleVersionRow(published, bundle, false);
+  }
+  async publishDraftWithValidity(db, versionId, publishMeta) {
+    const draft = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`BundleVersion '${versionId}' not found.`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    await db.bundleVersion.updateMany({
+      where: {
+        bundleId: draft.bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null,
+        NOT: {
+          id: versionId
+        }
+      },
+      data: {
+        supersededAt: now,
+        validUntil: previousUtcDay(publishMeta.validFrom)
+      }
+    });
+    const published = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        publishedAt: now,
+        publishedByUserId: publishMeta.publishedByUserId,
+        publishedChanges: publishMeta.publishedChanges,
+        nonRegressive: publishMeta.nonRegressive,
+        validFrom: publishMeta.validFrom,
+        validUntil: publishMeta.validUntil
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: published.bundleId
+      }
+    });
+    return toBundleVersionRow(published, bundle, true);
   }
   async deleteDraft(versionId) {
     const db = this.db();
@@ -2406,9 +3222,12 @@ var PrismaBundleRepository = class {
 PrismaBundleRepository = _ts_decorate20([
   Injectable20(),
   _ts_param18(0, Inject18(PRISMA_CLIENT_TOKEN)),
+  _ts_param18(1, Optional7()),
+  _ts_param18(1, Inject18(PRISMA_BUNDLE_REPOSITORY_OPTIONS)),
   _ts_metadata18("design:type", Function),
   _ts_metadata18("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof BundlePrismaClient === "undefined" ? Object : BundlePrismaClient,
+    typeof PrismaBundleRepositoryOptions === "undefined" ? Object : PrismaBundleRepositoryOptions
   ])
 ], PrismaBundleRepository);
 function isPlainObject(value) {
@@ -2419,6 +3238,16 @@ function toDecimalString(value) {
   return value == null ? null : value.toString();
 }
 __name(toDecimalString, "toDecimalString");
+function toNullableDate(value) {
+  return value ? new Date(value) : null;
+}
+__name(toNullableDate, "toNullableDate");
+function previousUtcDay(value) {
+  const result = new Date(value);
+  result.setUTCDate(result.getUTCDate() - 1);
+  return result;
+}
+__name(previousUtcDay, "previousUtcDay");
 function toVersionChanges(value) {
   return Array.isArray(value) ? value : null;
 }
@@ -2451,7 +3280,7 @@ function toBundleRow(row) {
   };
 }
 __name(toBundleRow, "toBundleRow");
-function toBundleVersionRow(row, bundle) {
+function toBundleVersionRow(row, bundle, validityWindows) {
   return {
     id: row.id,
     bundleId: row.bundleId,
@@ -2468,10 +3297,8 @@ function toBundleVersionRow(row, bundle) {
     marketed: row.marketed,
     publishedAt: row.publishedAt?.toISOString() ?? null,
     supersededAt: row.supersededAt?.toISOString() ?? null,
-    // The canonical `bundle_versions` table has no validFrom/validUntil
-    // columns; time-aware validity is not expressible on this schema.
-    validFrom: null,
-    validUntil: null,
+    validFrom: validityWindows && row.validFrom instanceof Date ? row.validFrom.toISOString() : null,
+    validUntil: validityWindows && row.validUntil instanceof Date ? row.validUntil.toISOString() : null,
     publishedChanges: toVersionChanges(row.publishedChanges),
     changeNote: row.changeNote,
     nonRegressive: row.nonRegressive,
@@ -2873,7 +3700,7 @@ PrismaCatalogEntryRepository = _ts_decorate21([
   _ts_param19(0, Inject19(PRISMA_CLIENT_TOKEN)),
   _ts_metadata19("design:type", Function),
   _ts_metadata19("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof CatalogEntryRepositoryClient === "undefined" ? Object : CatalogEntryRepositoryClient
   ])
 ], PrismaCatalogEntryRepository);
 function toI18n2(value) {
@@ -3114,7 +3941,7 @@ PrismaMarketingProjectionRepository = _ts_decorate22([
   _ts_param20(0, Inject20(PRISMA_CLIENT_TOKEN)),
   _ts_metadata20("design:type", Function),
   _ts_metadata20("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof MarketingProjectionRepositoryClient === "undefined" ? Object : MarketingProjectionRepositoryClient
   ])
 ], PrismaMarketingProjectionRepository);
 function toTopFeatures(value) {
@@ -3204,7 +4031,7 @@ PrismaMarketingSettingsRepository = _ts_decorate23([
   _ts_param21(0, Inject21(PRISMA_CLIENT_TOKEN)),
   _ts_metadata21("design:type", Function),
   _ts_metadata21("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof MarketingSettingsRepositoryClient === "undefined" ? Object : MarketingSettingsRepositoryClient
   ])
 ], PrismaMarketingSettingsRepository);
 function toRow2(row) {
@@ -3295,7 +4122,8 @@ var PrismaPromotionRepository = class {
   }
   async update(id, data) {
     if (data.onlyLocales === null) {
-      await this.prisma.$executeRaw`
+      const executeRaw = this.prisma.$executeRaw.bind(this.prisma);
+      await executeRaw`
                 UPDATE promotions SET "onlyLocales" = NULL, "updatedAt" = NOW() WHERE id = ${id}`;
     }
     const row = await this.db.promotion.update({
@@ -3362,7 +4190,7 @@ PrismaPromotionRepository = _ts_decorate24([
   _ts_param22(0, Inject22(PRISMA_CLIENT_TOKEN)),
   _ts_metadata22("design:type", Function),
   _ts_metadata22("design:paramtypes", [
-    typeof PrismaLike === "undefined" ? Object : PrismaLike
+    typeof PromotionRepositoryClient === "undefined" ? Object : PromotionRepositoryClient
   ])
 ], PrismaPromotionRepository);
 function toPromotionValue(value) {
@@ -3670,7 +4498,9 @@ __name(toRecord4, "toRecord");
 export {
   AsyncLocalRlsBypassAdapter,
   PASSWORD_HASHER_TOKEN,
+  PRISMA_BUNDLE_REPOSITORY_OPTIONS,
   PRISMA_CLIENT_TOKEN,
+  PRISMA_SCHEMA_OPTIONS_TOKEN,
   PrismaAuditAdapter,
   PrismaAuditQueryAdapter,
   PrismaAuditStatsAdapter,
@@ -3696,5 +4526,8 @@ export {
   PrismaTransactionRunner,
   ZeroPromoRevenueDeductionAggregator,
   buildActorTag,
-  prismaPersistence
+  createPrismaPlanBindingResolver,
+  getPrismaDelegate,
+  prismaPersistence,
+  resolvePrismaSchemaOptions
 };