@farthershore/product 0.6.0 → 0.6.1

package/dist/bin.js

@@ -154,15 +154,9 @@ var planLimitsSchema = z.array(planLimitRuleSchema).max(20);
 
 // ../contracts/dist/plans/spec/subscriber-change-policy.js
 import { z as z2 } from "zod";
-var subscriberChangeActionSchema = z2.enum([
-  "preserve_current_period",
-  "switch_immediately",
-  "switch_immediately_prorate",
-  "new_subscribers_only"
-]);
+var subscriberChangeActionSchema = z2.enum(["immediate", "period_end"]);
 var subscriberChangePolicySchema = z2.object({
-  default: subscriberChangeActionSchema.default("preserve_current_period"),
-  proration: z2.enum(["none", "prorate", "credit"]).default("none"),
+  default: subscriberChangeActionSchema.default("period_end"),
   when: z2.object({
     price_increase: subscriberChangeActionSchema.optional(),
     price_decrease: subscriberChangeActionSchema.optional(),
@@ -174,24 +168,20 @@ var subscriberChangePolicySchema = z2.object({
     credit_reduced: subscriberChangeActionSchema.optional(),
     rating_changed: subscriberChangeActionSchema.optional()
   }).strict().default({
-    price_increase: "preserve_current_period",
-    price_decrease: "switch_immediately",
-    feature_added: "switch_immediately",
-    feature_removed: "preserve_current_period",
-    limit_increased: "switch_immediately",
-    limit_reduced: "preserve_current_period",
-    credit_increased: "switch_immediately",
-    credit_reduced: "preserve_current_period",
-    rating_changed: "preserve_current_period"
+    price_increase: "period_end",
+    price_decrease: "immediate",
+    feature_added: "immediate",
+    feature_removed: "period_end",
+    limit_increased: "immediate",
+    limit_reduced: "period_end",
+    credit_increased: "immediate",
+    credit_reduced: "period_end",
+    rating_changed: "period_end"
   }),
   allowImmediatePriceIncrease: z2.boolean().default(false),
   allowImmediateEntitlementReduction: z2.boolean().default(false)
 }).strict().superRefine((policy, ctx) => {
-  const immediate = /* @__PURE__ */ new Set([
-    "switch_immediately",
-    "switch_immediately_prorate"
-  ]);
-  if (immediate.has(policy.when.price_increase ?? policy.default) && !policy.allowImmediatePriceIncrease) {
+  if ((policy.when.price_increase ?? policy.default) === "immediate" && !policy.allowImmediatePriceIncrease) {
     ctx.addIssue({
       code: "custom",
       path: ["when", "price_increase"],
@@ -203,7 +193,7 @@ var subscriberChangePolicySchema = z2.object({
     "limit_reduced",
     "credit_reduced"
   ]) {
-    if (immediate.has(policy.when[key] ?? policy.default) && !policy.allowImmediateEntitlementReduction) {
+    if ((policy.when[key] ?? policy.default) === "immediate" && !policy.allowImmediateEntitlementReduction) {
       ctx.addIssue({
         code: "custom",
         path: ["when", key],
@@ -214,30 +204,22 @@ var subscriberChangePolicySchema = z2.object({
 });
 
 // ../contracts/dist/plans/spec/plan-pricing.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../contracts/dist/plans/grants.js
 import { z as z3 } from "zod";
-var recurringGrantSchema = z3.object({
-  kind: z3.literal("recurring"),
-  amount_cents: z3.number().int().nonnegative()
-});
-var oneTimeGrantSchema = z3.object({
-  kind: z3.literal("one_time"),
-  amount_cents: z3.number().int().nonnegative()
-});
-var promotionalGrantSchema = z3.object({
-  kind: z3.literal("promotional"),
+var creditGrantSchema = z3.object({
+  kind: z3.literal("credit"),
   amount_cents: z3.number().int().nonnegative(),
-  label: z3.string().min(1).max(120),
-  expires_after_days: z3.number().int().positive().optional()
-});
-var trialGrantSchema = z3.object({
-  kind: z3.literal("trial")
-});
-var rolloverGrantSchema = z3.object({
-  kind: z3.literal("rollover"),
-  percent: z3.number().int().min(0).max(100)
+  /** When true, the credit is re-granted at every period rollover. Default
+   *  false = a one-shot grant at subscription start. */
+  recurs: z3.boolean().optional(),
+  /** Optional expiry — Stripe expires the grant this many days after issue.
+   *  Mainly used by promotional credits to prevent indefinite carry-forward. */
+  expires_after_days: z3.number().int().positive().optional(),
+  /** Optional campaign label. A credit carrying a label is a promotional /
+   *  ops-issued grant rather than the canonical recurring/one-time credit. */
+  label: z3.string().min(1).max(120).optional()
 });
 var topUpGrantSchema = z3.object({
   kind: z3.literal("top_up"),
@@ -250,67 +232,75 @@ var topUpGrantSchema = z3.object({
    *  Typically >= price_cents (the difference is the bulk discount). */
   credit_cents: z3.number().int().positive()
 });
-var autoRechargeGrantSchema = z3.object({
-  kind: z3.literal("auto_recharge"),
-  /** When current balance < this many cents, trigger a refill. */
-  threshold_cents: z3.number().int().nonnegative(),
-  /** Charge + grant this much on each refill, in cents. */
-  refill_cents: z3.number().int().positive()
-});
 var grantSchema = z3.discriminatedUnion("kind", [
-  recurringGrantSchema,
-  oneTimeGrantSchema,
-  promotionalGrantSchema,
-  trialGrantSchema,
-  rolloverGrantSchema,
-  topUpGrantSchema,
-  autoRechargeGrantSchema
+  creditGrantSchema,
+  topUpGrantSchema
 ]);
+function isRecurringCredit(g) {
+  return g.kind === "credit" && g.recurs === true && g.label === void 0;
+}
+function isOneTimeCredit(g) {
+  return g.kind === "credit" && g.recurs !== true && g.label === void 0;
+}
 function refineSingleCanonicalGrant(grants, ctx, path = ["grants"]) {
   if (!grants)
     return;
   let recurringCount = 0;
   let oneTimeCount = 0;
   for (const g of grants) {
-    if (g.kind === "recurring")
+    if (isRecurringCredit(g))
       recurringCount += 1;
-    else if (g.kind === "one_time")
+    else if (isOneTimeCredit(g))
       oneTimeCount += 1;
   }
   if (recurringCount > 1) {
     ctx.addIssue({
       code: "custom",
-      message: "At most one `recurring` grant is allowed \u2014 recurring credit is a single canonical entry.",
+      message: "At most one recurring `credit` grant (recurs:true, no label) is allowed \u2014 recurring credit is a single canonical entry.",
       path
     });
   }
   if (oneTimeCount > 1) {
     ctx.addIssue({
       code: "custom",
-      message: "At most one `one_time` grant is allowed \u2014 one-time credit is a single canonical entry.",
+      message: "At most one one-time `credit` grant (recurs:false, no label) is allowed \u2014 one-time credit is a single canonical entry.",
       path
     });
   }
 }
 
+// ../contracts/dist/plans/credit-policy.js
+import { z as z4 } from "zod";
+var rolloverPolicySchema = z4.object({
+  percent: z4.number().int().min(0).max(100)
+});
+var autoRechargePolicySchema = z4.object({
+  threshold_cents: z4.number().int().nonnegative(),
+  refill_cents: z4.number().int().positive()
+});
+var creditPolicySchema = z4.object({
+  rollover: rolloverPolicySchema.optional(),
+  auto_recharge: autoRechargePolicySchema.optional()
+});
+
 // ../contracts/dist/plans/spec/plan-pricing.js
-var meterKindSchema = z4.enum(["linear", "active_count"]);
-var meterTierSchema = z4.object({
-  up_to: z4.number().int().positive().nullable(),
-  price_per_unit_micros: z4.number().int().nonnegative()
+var meterKindSchema = z5.enum(["linear", "active_count"]);
+var meterTierSchema = z5.object({
+  up_to: z5.number().int().positive().nullable(),
+  price_per_unit_micros: z5.number().int().nonnegative()
 });
-var tieredPricingSchema = z4.object({
-  strategy: z4.enum(["graduated", "volume"]),
-  tiers: z4.array(meterTierSchema).min(1).max(20)
+var tieredPricingSchema = z5.object({
+  strategy: z5.enum(["graduated", "volume"]),
+  tiers: z5.array(meterTierSchema).min(1).max(20)
 });
-var meterSchema = z4.object({
-  dimension: z4.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Meter dimension must be lowercase alphanumeric with underscores"),
+var meterSchema = z5.object({
+  dimension: z5.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Meter dimension must be lowercase alphanumeric with underscores"),
   /** Aggregation kind. `linear` (default) sums event quantities across
    *  the period. `active_count` samples the latest quantity in the
    *  period (use for seats / active-user / occupancy snapshots). */
   kind: meterKindSchema.default("linear"),
   /** Flat per-unit rate. Mutually exclusive with `tiered`. */
-  price_per_unit_micros: z4.number().int().nonnegative().default(0),
+  price_per_unit_micros: z5.number().int().nonnegative().default(0),
   /** Tiered schedule. Mutually exclusive with a non-zero
    *  `price_per_unit_micros`. */
   tiered: tieredPricingSchema.optional(),
@@ -324,7 +314,7 @@ var meterSchema = z4.object({
    *  Mutually exclusive with `tiered` — a tiered schedule already
    *  expresses the full breakpoint ladder (model the free pool as a
    *  zero-priced first tier instead). Only meaningful on a flat meter. */
-  included_units: z4.number().int().positive().optional()
+  included_units: z5.number().int().positive().optional()
 }).superRefine((m, ctx) => {
   if (m.tiered && m.price_per_unit_micros > 0) {
     ctx.addIssue({
@@ -375,99 +365,106 @@ var meterSchema = z4.object({
     }
   }
 });
-var billingIntervalSchema = z4.enum(["month", "year"]);
-var planPricingSchema = z4.object({
+var billingIntervalSchema = z5.enum(["month", "year"]);
+var planPricingSchema = z5.object({
   /** Per-dimension price list. Empty array = no metered billing. */
-  meters: z4.array(meterSchema).default([]),
+  meters: z5.array(meterSchema).default([]),
   /** Flat subscription fee per period, in cents. 0 = no recurring fee. */
-  recurring_fee_cents: z4.number().int().nonnegative().default(0),
+  recurring_fee_cents: z5.number().int().nonnegative().default(0),
   /** Billing cadence for the recurring fee + metered usage. Defaults to
    *  `month`; set `year` for annual billing (drives both the Stripe price
    *  `recurring.interval` and the spend-cap / quota billing-period window
    *  length). */
   billing_interval: billingIntervalSchema.default("month"),
   /** Unified credit-grant array — the SINGLE credit surface. Recurring +
-   *  one-time credit are canonical entries here (the legacy scalar knobs
-   *  were removed). */
-  grants: z4.array(grantSchema).max(40).default([]),
+   *  one-time credit are canonical `credit` entries here (the legacy scalar
+   *  knobs were removed). */
+  grants: z5.array(grantSchema).max(40).default([]),
+  /** Non-grant credit policies (rollover + auto-recharge). Optional; absent =
+   *  no rollover / no auto-recharge. */
+  creditPolicy: creditPolicySchema.optional(),
   /** Free-trial length in days. Trial enforcement runs through Stripe
    *  webhooks → `lifecycle_block` constraint at runtime. */
-  trial_days: z4.number().int().nonnegative().default(0),
+  trial_days: z5.number().int().nonnegative().default(0),
   /** Optional hard cap on monthly spend, in cents. Orthogonal to the
    *  billing math — the gateway blocks once this cap is reached even if
    *  credit balance remains. Stripe doesn't enforce this; the runtime
    *  does, via a `quota`-shaped constraint. */
-  max_monthly_spend_cents: z4.number().int().nonnegative().optional()
+  max_monthly_spend_cents: z5.number().int().nonnegative().optional()
 });
 
 // ../contracts/dist/plans/spec/plan-variant.js
-import { z as z5 } from "zod";
-var proRationOnRollbackSchema = z5.enum(["NONE", "PRORATE", "CREDIT"]).default("NONE");
+import { z as z6 } from "zod";
+var proRationOnRollbackSchema = z6.enum(["NONE", "PRORATE", "CREDIT"]).default("NONE");
 var billingKnobsShape = {
-  meters: z5.array(meterSchema).default([]),
-  recurring_fee_cents: z5.number().int().nonnegative().default(0),
+  meters: z6.array(meterSchema).default([]),
+  recurring_fee_cents: z6.number().int().nonnegative().default(0),
   /** Billing cadence (`month` default / `year`). Drives the Stripe price
    *  `recurring.interval` and the entitlement billing-period window. */
   billing_interval: billingIntervalSchema.default("month"),
-  trial_days: z5.number().int().nonnegative().default(0),
+  trial_days: z6.number().int().nonnegative().default(0),
   /** Hard maximum on metered spend per period. Gateway blocks once
    *  cumulative usage cost reaches this cap. Orthogonal to the
    *  recurring fee — the fee is always charged. */
-  max_monthly_spend_cents: z5.number().int().nonnegative().optional(),
+  max_monthly_spend_cents: z6.number().int().nonnegative().optional(),
   /** Minimum metered spend per period. When set, the invoice floors
    *  the metered total at this value (Railway-style minimum-spend).
    *  Orthogonal to `recurring_fee_cents` — the fee is added on top.
    *  Set to 0 / omit to disable. */
-  min_monthly_spend_cents: z5.number().int().nonnegative().optional(),
+  min_monthly_spend_cents: z6.number().int().nonnegative().optional(),
   /**
-   * Unified grants array — the SINGLE credit surface (v0.56+). Each entry
-   * expresses one credit grant primitive: `recurring`, `one_time`,
-   * `promotional`, `trial`, `rollover`, `top_up`, `auto_recharge`.
+   * Unified grants array — the SINGLE credit surface. Each entry expresses
+   * one credit grant primitive: a parametrized `credit` (recurring /
+   * one-time / promotional, distinguished by `recurs` / `label`) or a
+   * purchasable `top_up` pack.
    *
-   * Recurring + one-time credit are declared here as canonical
-   * `{kind:"recurring"}` / `{kind:"one_time"}` entries (at most one of
-   * each — enforced by `refineSingleCanonicalGrant`). The legacy
-   * `recurring_credit_grant_cents` / `one_time_credit_grant_cents` scalar
-   * knobs were removed; call `getEffectiveGrants(plan)` to read the
-   * consolidated list.
+   * Recurring + one-time credit are declared here as canonical `credit`
+   * entries (at most one recurring + one one-time, enforced by
+   * `refineSingleCanonicalGrant`); call `getEffectiveGrants(plan)` to read
+   * the consolidated list. Trial is driven by `trial_days`; rollover +
+   * auto-recharge live in `creditPolicy`.
    */
-  grants: z5.array(grantSchema).max(40).default([])
+  grants: z6.array(grantSchema).max(40).default([]),
+  /** Non-grant credit policies (rollover + auto-recharge). */
+  creditPolicy: creditPolicySchema.optional()
 };
 var billingKnobsOptionalShape = {
-  meters: z5.array(meterSchema).optional(),
-  recurring_fee_cents: z5.number().int().nonnegative().optional(),
+  meters: z6.array(meterSchema).optional(),
+  recurring_fee_cents: z6.number().int().nonnegative().optional(),
   /** Variant override for the billing cadence. Absent → inherit the
    *  parent plan's `billing_interval`. */
   billing_interval: billingIntervalSchema.optional(),
-  trial_days: z5.number().int().nonnegative().optional(),
-  max_monthly_spend_cents: z5.number().int().nonnegative().optional(),
-  min_monthly_spend_cents: z5.number().int().nonnegative().optional(),
+  trial_days: z6.number().int().nonnegative().optional(),
+  max_monthly_spend_cents: z6.number().int().nonnegative().optional(),
+  min_monthly_spend_cents: z6.number().int().nonnegative().optional(),
   /** Variant override for the grants array — the single credit surface.
    *  When present, fully replaces the parent plan's grants (no shallow
    *  merge — grants are collectively meaningful). */
-  grants: z5.array(grantSchema).max(40).optional()
+  grants: z6.array(grantSchema).max(40).optional(),
+  /** Variant override for the credit-policy block. */
+  creditPolicy: creditPolicySchema.optional()
 };
-var planVariantObjectSchema = z5.object({
+var planVariantObjectSchema = z6.object({
   /**
    * Stable variant id — used as the second half of the CompiledPlan
    * lineage key, so changing it counts as create-new + archive-old.
    * Lower-case kebab-case to match URL-share-link readability.
    */
-  id: z5.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Variant id must be lowercase alphanumeric with hyphens/underscores"),
+  id: z6.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Variant id must be lowercase alphanumeric with hyphens/underscores"),
   /** Human-readable label for dashboards / observability. */
-  label: z5.string().max(200).optional(),
+  label: z6.string().max(200).optional(),
   /**
    * Rollout percentage (0-100). 0 = paused (variant exists but no new
    * assignments); 100 = full takeover (effectively a forced graduation
    * for new subscribers, but legacy subs stay on parent until period end).
    */
-  rolloutPercent: z5.number().int().min(0).max(100),
+  rolloutPercent: z6.number().int().min(0).max(100),
   /**
    * Seed for the deterministic hash function. Rotating the seed
    * invalidates existing variant assignments — useful for re-running an
    * experiment with a fresh cohort.
    */
-  assignmentSeed: z5.string().min(1).max(100).default("default"),
+  assignmentSeed: z6.string().min(1).max(100).default("default"),
   /**
    * What happens to billing when this variant gets rolled back AND the
    * subscriber has already been billed for the experimental price:
@@ -481,22 +478,22 @@ var planVariantObjectSchema = z5.object({
   // plan. The pre-0.53 `pricing: planPricingSchema.optional()` field is
   // gone; variants now override the knobs directly.
   ...billingKnobsOptionalShape,
-  limits: z5.array(planLimitRuleSchema).max(20).optional(),
-  featureGates: z5.record(z5.string(), z5.boolean()).optional(),
+  limits: z6.array(planLimitRuleSchema).max(20).optional(),
+  featureGates: z6.record(z6.string(), z6.boolean()).optional(),
   /** See `planSpecSchema.capability_limits`. Variant overrides are
    *  merged shallowly onto the parent plan's map — missing keys
    *  inherit from the parent. */
-  capability_limits: z5.record(z5.string().min(1).max(120), z5.union([z5.number().int().nonnegative(), z5.boolean()])).optional(),
-  overageBehavior: z5.enum(["block", "allow_and_bill"]).optional()
+  capability_limits: z6.record(z6.string().min(1).max(120), z6.union([z6.number().int().nonnegative(), z6.boolean()])).optional(),
+  overageBehavior: z6.enum(["block", "allow_and_bill"]).optional()
 });
 var planVariantSchema = planVariantObjectSchema.superRefine((variant, ctx) => {
   refineSingleCanonicalGrant(variant.grants, ctx);
 });
-var planSpecObjectSchema = z5.object({
-  key: z5.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Plan key must be lowercase alphanumeric with hyphens/underscores"),
-  name: z5.string().min(1).max(100),
-  description: z5.string().max(500).optional(),
-  details: z5.array(z5.string().max(200)).max(10).optional(),
+var planSpecObjectSchema = z6.object({
+  key: z6.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Plan key must be lowercase alphanumeric with hyphens/underscores"),
+  name: z6.string().min(1).max(100),
+  description: z6.string().max(500).optional(),
+  details: z6.array(z6.string().max(200)).max(10).optional(),
   // ---------------------------------------------------------------------
   // 5-knob billing shape (v0.53.0)
   // ---------------------------------------------------------------------
@@ -510,7 +507,7 @@ var planSpecObjectSchema = z5.object({
   // runs through Stripe webhooks → `lifecycle_block` constraint at
   // runtime; there's no `trial_expiry` constraint kind anymore.
   ...billingKnobsShape,
-  free: z5.boolean().default(false),
+  free: z6.boolean().default(false),
   // `plan.features` removed in feat/feature-plans-link — features
   // declare their plans via `feature.plans[]` (canonical, feature-first
   // direction). Builders writing the manifest now go to the feature
@@ -518,8 +515,8 @@ var planSpecObjectSchema = z5.object({
   // compiler walks `spec.features` and includes a feature's routes for
   // a plan when the plan's key appears in `feature.plans[]`. See
   // shared-types/src/plans/spec/product.ts (featureCatalogEntrySchema).
-  limits: z5.array(planLimitRuleSchema).max(20).default([]),
-  featureGates: z5.record(z5.string(), z5.boolean()).optional(),
+  limits: z6.array(planLimitRuleSchema).max(20).default([]),
+  featureGates: z6.record(z6.string(), z6.boolean()).optional(),
   /**
    * Control-plane capability limits (Phase 1a, v0.56+).
    *
@@ -549,9 +546,9 @@ var planSpecObjectSchema = z5.object({
    *     environments: 1
    *     enterprise_sso: true
    */
-  capability_limits: z5.record(z5.string().min(1).max(120), z5.union([z5.number().int().nonnegative(), z5.boolean()])).default({}),
-  overageBehavior: z5.enum(["block", "allow_and_bill"]).default("block"),
-  selfServeEnabled: z5.boolean().default(true),
+  capability_limits: z6.record(z6.string().min(1).max(120), z6.union([z6.number().int().nonnegative(), z6.boolean()])).default({}),
+  overageBehavior: z6.enum(["block", "allow_and_bill"]).default("block"),
+  selfServeEnabled: z6.boolean().default(true),
   /**
    * Phase A0 — multi-stable plan support.
    *
@@ -563,7 +560,7 @@ var planSpecObjectSchema = z5.object({
    * from YAML while subs are pinned to it is a compile error (would
    * orphan the cohort).
    */
-  legacy: z5.boolean().optional().default(false),
+  legacy: z6.boolean().optional().default(false),
   /**
    * Phase A0 — A/B testing variants of this plan. Each variant compiles
    * into a sibling `CompiledPlan` with status `EXPERIMENTAL` and
@@ -573,11 +570,11 @@ var planSpecObjectSchema = z5.object({
    *   - Cannot coexist with `legacy: true` on the same plan
    *   - Variant `id` must be unique within the variants array
    */
-  variants: z5.array(planVariantSchema).max(4).optional(),
-  archive: z5.object({
-    at: z5.string().datetime().optional(),
-    transitionTo: z5.string().optional(),
-    strategy: z5.enum(["auto", "explicit", "block"]).default("auto")
+  variants: z6.array(planVariantSchema).max(4).optional(),
+  archive: z6.object({
+    at: z6.string().datetime().optional(),
+    transitionTo: z6.string().optional(),
+    strategy: z6.enum(["auto", "explicit", "block"]).default("auto")
   }).optional()
 });
 var planSpecSchema = planSpecObjectSchema.superRefine((plan, ctx) => {
@@ -585,10 +582,10 @@ var planSpecSchema = planSpecObjectSchema.superRefine((plan, ctx) => {
 });
 
 // ../contracts/dist/plans/spec/webhooks.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../contracts/dist/webhooks/events.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var WEBHOOK_EVENT_NAMES = [
   "subscription.created",
   "subscription.updated",
@@ -599,26 +596,26 @@ var WEBHOOK_EVENT_NAMES = [
   "entitlement.changed",
   "usage.threshold_reached"
 ];
-var webhookEventNameSchema = z6.enum(WEBHOOK_EVENT_NAMES);
+var webhookEventNameSchema = z7.enum(WEBHOOK_EVENT_NAMES);
 
 // ../contracts/dist/plans/spec/webhooks.js
 var WEBHOOK_SECRET_PLACEHOLDER_PATTERN = /^\$\{[A-Z][A-Z0-9_]{0,127}\}$/;
-var webhookSecretSchema = z7.string().min(3).max(200).refine((value) => WEBHOOK_SECRET_PLACEHOLDER_PATTERN.test(value), {
+var webhookSecretSchema = z8.string().min(3).max(200).refine((value) => WEBHOOK_SECRET_PLACEHOLDER_PATTERN.test(value), {
   message: "secret must use ${VAR} interpolation syntax (e.g. ${WEBHOOK_SECRET}); raw secrets in YAML are rejected. Define the env var in the per-product secret store and reference it here."
 });
-var webhookRetryPolicySchema = z7.object({
-  maxAttempts: z7.number().int().min(1).max(20).default(5),
-  backoff: z7.enum(["exponential", "fixed"]).default("exponential")
+var webhookRetryPolicySchema = z8.object({
+  maxAttempts: z8.number().int().min(1).max(20).default(5),
+  backoff: z8.enum(["exponential", "fixed"]).default("exponential")
 });
-var webhookEndpointSchema = z7.object({
+var webhookEndpointSchema = z8.object({
   /**
    * Stable endpoint id — used as the third key of the
    * `(productId, environmentId, id)` uniqueness tuple. Idempotent upsert
    * keys on this id; renaming an id is delete + recreate.
    */
-  id: z7.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Webhook endpoint id must be lowercase alphanumeric with hyphens/underscores"),
+  id: z8.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Webhook endpoint id must be lowercase alphanumeric with hyphens/underscores"),
   /** Public HTTPS URL the dispatcher POSTs to. */
-  url: z7.string().url("webhooks.endpoints[].url must be a valid URL"),
+  url: z8.string().url("webhooks.endpoints[].url must be a valid URL"),
   /**
    * Signing secret. MUST be a `${VAR}` placeholder; raw secrets in YAML
    * are rejected by invariant 8. The seal pass resolves this against the
@@ -631,22 +628,22 @@ var webhookEndpointSchema = z7.object({
    * Each value is validated against `webhookEventNameSchema` —
    * unknown events fail invariant 9.
    */
-  events: z7.array(webhookEventNameSchema).min(1, "webhooks.endpoints[].events must subscribe to \u2265 1 event"),
-  enabled: z7.boolean().default(true),
+  events: z8.array(webhookEventNameSchema).min(1, "webhooks.endpoints[].events must subscribe to \u2265 1 event"),
+  enabled: z8.boolean().default(true),
   retryPolicy: webhookRetryPolicySchema.default({
     maxAttempts: 5,
     backoff: "exponential"
   })
 });
-var webhooksBlockSchema = z7.object({
-  endpoints: z7.array(webhookEndpointSchema).max(50).default([])
+var webhooksBlockSchema = z8.object({
+  endpoints: z8.array(webhookEndpointSchema).max(50).default([])
 });
 
 // ../contracts/dist/plans/spec/environments.js
-import { z as z8 } from "zod";
-var planOverrideSchema = z8.object({
-  meters: z8.array(meterSchema).optional(),
-  recurring_fee_cents: z8.number().int().nonnegative().optional(),
+import { z as z9 } from "zod";
+var planOverrideSchema = z9.object({
+  meters: z9.array(meterSchema).optional(),
+  recurring_fee_cents: z9.number().int().nonnegative().optional(),
   /** Per-env override for the billing cadence. Absent → inherit the
    *  base plan's `billing_interval`. */
   billing_interval: billingIntervalSchema.optional(),
@@ -654,35 +651,38 @@ var planOverrideSchema = z8.object({
    *  surface. When present it fully replaces the parent plan's grants
    *  for this environment (the legacy recurring/one-time scalar knobs
    *  were removed). */
-  grants: z8.array(grantSchema).max(40).optional(),
-  trial_days: z8.number().int().nonnegative().optional(),
-  max_monthly_spend_cents: z8.number().int().nonnegative().optional(),
-  limits: z8.array(planLimitRuleSchema).max(20).optional(),
-  featureGates: z8.record(z8.string(), z8.boolean()).optional(),
-  overageBehavior: z8.enum(["block", "allow_and_bill"]).optional(),
-  selfServeEnabled: z8.boolean().optional(),
-  legacy: z8.boolean().optional()
+  grants: z9.array(grantSchema).max(40).optional(),
+  /** Per-env override for the credit-policy block (rollover +
+   *  auto-recharge). */
+  creditPolicy: creditPolicySchema.optional(),
+  trial_days: z9.number().int().nonnegative().optional(),
+  max_monthly_spend_cents: z9.number().int().nonnegative().optional(),
+  limits: z9.array(planLimitRuleSchema).max(20).optional(),
+  featureGates: z9.record(z9.string(), z9.boolean()).optional(),
+  overageBehavior: z9.enum(["block", "allow_and_bill"]).optional(),
+  selfServeEnabled: z9.boolean().optional(),
+  legacy: z9.boolean().optional()
 }).strict();
-var webhookEndpointOverrideSchema = z8.object({
-  url: z8.string().url().optional(),
+var webhookEndpointOverrideSchema = z9.object({
+  url: z9.string().url().optional(),
   secret: webhookSecretSchema.optional(),
-  events: z8.array(webhookEventNameSchema).optional(),
-  enabled: z8.boolean().optional(),
+  events: z9.array(webhookEventNameSchema).optional(),
+  enabled: z9.boolean().optional(),
   retryPolicy: webhookRetryPolicySchema.partial().optional()
 }).strict();
-var environmentOverrideBlockSchema = z8.object({
-  plans: z8.record(z8.string(), planOverrideSchema).optional(),
-  webhooks: z8.object({
-    endpoints: z8.record(z8.string(), webhookEndpointOverrideSchema).optional()
+var environmentOverrideBlockSchema = z9.object({
+  plans: z9.record(z9.string(), planOverrideSchema).optional(),
+  webhooks: z9.object({
+    endpoints: z9.record(z9.string(), webhookEndpointOverrideSchema).optional()
   }).strict().optional()
 }).strict();
-var environmentsBlockSchema = z8.record(z8.string().min(1).max(64), environmentOverrideBlockSchema);
+var environmentsBlockSchema = z9.record(z9.string().min(1).max(64), environmentOverrideBlockSchema);
 
 // ../contracts/dist/plans/spec/product.js
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // ../contracts/dist/plans/spec/frontend-layer.js
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var FRONTEND_MANIFEST_SCHEMA_VERSION = 1;
 var KNOWN_FRONTEND_COMPONENT_IDS = [
   "plans_table",
@@ -712,31 +712,31 @@ var RESERVED_TEMPLATE_PATHS = [
   "/persona",
   "/persona-sign-in"
 ];
-var frontendPathSchema = z9.string().min(1).max(200).regex(/^\/[a-zA-Z0-9_./-]*$/, "path must start with / and contain only [a-zA-Z0-9_./-]");
-var frontendCapabilityRefSchema = z9.string().min(1).max(120).regex(/^[a-z0-9_-]+$/);
-var frontendNavItemSchema = z9.object({
-  label: z9.string().min(1).max(80),
+var frontendPathSchema = z10.string().min(1).max(200).regex(/^\/[a-zA-Z0-9_./-]*$/, "path must start with / and contain only [a-zA-Z0-9_./-]");
+var frontendCapabilityRefSchema = z10.string().min(1).max(120).regex(/^[a-z0-9_-]+$/);
+var frontendNavItemSchema = z10.object({
+  label: z10.string().min(1).max(80),
   path: frontendPathSchema,
   capability: frontendCapabilityRefSchema.optional()
 });
-var frontendComponentIdSchema = z9.enum(KNOWN_FRONTEND_COMPONENT_IDS);
-var frontendComponentSchema = z9.object({
+var frontendComponentIdSchema = z10.enum(KNOWN_FRONTEND_COMPONENT_IDS);
+var frontendComponentSchema = z10.object({
   component: frontendComponentIdSchema,
-  props: z9.record(z9.string().min(1).max(80), z9.unknown()).optional(),
+  props: z10.record(z10.string().min(1).max(80), z10.unknown()).optional(),
   capability: frontendCapabilityRefSchema.optional(),
-  gateMode: z9.enum(["hide", "disable", "upsell"]).default("hide")
+  gateMode: z10.enum(["hide", "disable", "upsell"]).default("hide")
 });
-var frontendPageSchema = z9.object({
+var frontendPageSchema = z10.object({
   path: frontendPathSchema,
-  title: z9.string().min(1).max(120),
-  requiresAuth: z9.boolean(),
+  title: z10.string().min(1).max(120),
+  requiresAuth: z10.boolean(),
   capability: frontendCapabilityRefSchema.optional(),
-  components: z9.array(frontendComponentSchema).max(12).default([])
+  components: z10.array(frontendComponentSchema).max(12).default([])
 });
-var frontendManifestSchema = z9.object({
-  version: z9.literal(FRONTEND_MANIFEST_SCHEMA_VERSION),
-  nav: z9.array(frontendNavItemSchema).max(12).default([]),
-  pages: z9.array(frontendPageSchema).max(24).default([])
+var frontendManifestSchema = z10.object({
+  version: z10.literal(FRONTEND_MANIFEST_SCHEMA_VERSION),
+  nav: z10.array(frontendNavItemSchema).max(12).default([]),
+  pages: z10.array(frontendPageSchema).max(24).default([])
 }).superRefine((manifest, ctx) => {
   const seenPages = /* @__PURE__ */ new Set();
   manifest.pages.forEach((page, index) => {
@@ -768,32 +768,35 @@ function isReservedTemplatePath(path) {
 }
 
 // ../contracts/dist/plans/spec/migrations-layer.js
-import { z as z10 } from "zod";
-var planKeySchema = z10.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Plan key must be lowercase alphanumeric with hyphens/underscores");
-var versionRefSchema = z10.string().min(1).max(100);
-var planVersionRefSchema = z10.object({
+import { z as z11 } from "zod";
+var planKeySchema = z11.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Plan key must be lowercase alphanumeric with hyphens/underscores");
+var versionRefSchema = z11.union([
+  z11.literal("head"),
+  z11.string().regex(/^[1-9][0-9]*$/, 'version must be "head" or a positive integer')
+]);
+var planVersionRefSchema = z11.object({
   plan: planKeySchema,
   version: versionRefSchema.optional()
 });
-var migrationTargetSchema = z10.object({
+var migrationTargetSchema = z11.object({
   plan: planKeySchema,
-  version: z10.literal("head").default("head")
+  version: z11.literal("head").default("head")
 });
-var pinnedPlanVersionSchema = z10.object({
+var pinnedPlanVersionSchema = z11.object({
   plan: planKeySchema,
   version: versionRefSchema
 });
-var migrationEffectiveSchema = z10.enum([
+var migrationEffectiveSchema = z11.enum([
   "grandfather",
   "next_renewal",
   "by_date",
   "immediate",
   "opt_in"
 ]);
-var migrationProrationSchema = z10.enum(["none", "prorate", "credit"]);
-var migrationExistingCustomersSchema = z10.object({
+var migrationProrationSchema = z11.enum(["none", "prorate", "credit"]);
+var migrationExistingCustomersSchema = z11.object({
   effective: migrationEffectiveSchema,
-  date: z10.string().datetime().optional(),
+  date: z11.string().datetime().optional(),
   proration: migrationProrationSchema.optional()
 }).superRefine((policy, ctx) => {
   if (policy.effective === "by_date" && policy.date === void 0) {
@@ -804,21 +807,21 @@ var migrationExistingCustomersSchema = z10.object({
     });
   }
 });
-var migrationPinSchema = z10.object({
-  subscriber: z10.string().min(1).max(200),
+var migrationPinSchema = z11.object({
+  subscriber: z11.string().min(1).max(200),
   pinTo: pinnedPlanVersionSchema,
-  until: z10.string().datetime().optional(),
-  notes: z10.string().max(1e3).optional()
+  until: z11.string().datetime().optional(),
+  notes: z11.string().max(1e3).optional()
 });
-var migrationDeclSchema = z10.object({
-  id: z10.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9_.-]*$/, "Migration id must be lowercase alphanumeric with dots, hyphens, or underscores"),
+var migrationDeclSchema = z11.object({
+  id: z11.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9_.-]*$/, "Migration id must be lowercase alphanumeric with dots, hyphens, or underscores"),
   from: planVersionRefSchema,
   to: migrationTargetSchema,
-  newCustomers: z10.literal("immediate").default("immediate"),
+  newCustomers: z11.literal("immediate").default("immediate"),
   existingCustomers: migrationExistingCustomersSchema,
-  pins: z10.array(migrationPinSchema).max(50).default([])
+  pins: z11.array(migrationPinSchema).max(50).default([])
 });
-var migrationDeclsSchema = z10.array(migrationDeclSchema).superRefine((migrations, ctx) => {
+var migrationDeclsSchema = z11.array(migrationDeclSchema).superRefine((migrations, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   migrations.forEach((migration, index) => {
     if (seen.has(migration.id)) {
@@ -833,18 +836,18 @@ var migrationDeclsSchema = z10.array(migrationDeclSchema).superRefine((migration
 });
 
 // ../contracts/dist/plans/spec/counted-resources.js
-import { z as z11 } from "zod";
-var countedResourceScopeSchema = z11.enum(["subscription", "subject"]);
-var countedResourceCountSourceSchema = z11.enum([
+import { z as z12 } from "zod";
+var countedResourceScopeSchema = z12.enum(["subscription", "subject"]);
+var countedResourceCountSourceSchema = z12.enum([
   "reported",
   "action_inferred"
 ]);
-var countedResourceNameSchema = z11.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/);
-var countedResourceSchema = z11.object({
+var countedResourceNameSchema = z12.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/);
+var countedResourceSchema = z12.object({
   name: countedResourceNameSchema,
-  display: z11.string().min(1).max(120).optional(),
+  display: z12.string().min(1).max(120).optional(),
   scope: countedResourceScopeSchema.default("subscription"),
-  subjectType: z11.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
+  subjectType: z12.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
   countSource: countedResourceCountSourceSchema.default("reported")
 }).superRefine((resource, ctx) => {
   if (resource.scope === "subject" && !resource.subjectType) {
@@ -862,23 +865,23 @@ var countedResourceSchema = z11.object({
     });
   }
 });
-var countedResourcesSchema = z11.array(countedResourceSchema).max(100).default([]);
+var countedResourcesSchema = z12.array(countedResourceSchema).max(100).default([]);
 
 // ../contracts/dist/plans/addons.js
-import { z as z12 } from "zod";
-var addOnSchema = z12.object({
+import { z as z13 } from "zod";
+var addOnSchema = z13.object({
   /** Stable identifier — appears in `SubscriptionAddOn.addOnKey` and in
    *  Stripe metadata. Lowercase alphanumeric with hyphens/underscores
    *  to match the plan-key grammar. */
-  key: z12.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "AddOn key must be lowercase alphanumeric with hyphens/underscores"),
+  key: z13.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "AddOn key must be lowercase alphanumeric with hyphens/underscores"),
   /** Display name (Pricing page chip, settings list, etc.). */
-  name: z12.string().min(1).max(100),
+  name: z13.string().min(1).max(100),
   /** Short description for tooltips / chooser. */
-  description: z12.string().max(500).optional(),
+  description: z13.string().max(500).optional(),
   /** Recurring fee added to the subscription invoice while the AddOn is
    *  active. 0 = no recurring fee (e.g. for boolean feature toggles or
    *  one-time-grant-only packs). */
-  recurring_fee_cents: z12.number().int().nonnegative().default(0),
+  recurring_fee_cents: z13.number().int().nonnegative().default(0),
   /** Billing cadence for this add-on's recurring fee (`month` default /
    *  `year`). Drives the add-on's Stripe price `recurring.interval`. */
   billing_interval: billingIntervalSchema.default("month"),
@@ -886,83 +889,83 @@ var addOnSchema = z12.object({
    *  into the effective entitlement's meter list (by dimension).
    *  Conflict resolution at compile time: AddOn meter wins over base
    *  plan meter for the same dimension (PR 2a-2 implements this). */
-  meters: z12.array(meterSchema).default([]),
+  meters: z13.array(meterSchema).default([]),
   /** Grants issued when the AddOn is activated and/or on each period
    *  rollover (kind-dependent). Same vocabulary as plan grants. */
-  grants: z12.array(grantSchema).max(40).default([]),
+  grants: z13.array(grantSchema).max(40).default([]),
   /** Capability bumps. Numeric limits combine with the base via MAX
    *  (so an "extra seats" addon raises the ceiling without lowering
    *  it). Boolean flags combine with OR (any true wins). */
-  capability_limits: z12.record(z12.string().min(1).max(120), z12.union([z12.number().int().nonnegative(), z12.boolean()])).default({}),
+  capability_limits: z13.record(z13.string().min(1).max(120), z13.union([z13.number().int().nonnegative(), z13.boolean()])).default({}),
   /** Additive feature gates. Keys true here are appended to the
    *  effective entitlement's gate set. */
-  featureGates: z12.record(z12.string(), z12.boolean()).optional(),
+  featureGates: z13.record(z13.string(), z13.boolean()).optional(),
   /** Whether the AddOn is visible in the subscriber-facing catalog.
    *  When false, only admin-issued (not self-serve). Defaults true. */
-  selfServeEnabled: z12.boolean().default(true)
+  selfServeEnabled: z13.boolean().default(true)
 });
-var addOnsBlockSchema = z12.record(z12.string().min(1).max(64), addOnSchema).default({});
-var subscriptionAddOnStatusSchema = z12.enum([
+var addOnsBlockSchema = z13.record(z13.string().min(1).max(64), addOnSchema).default({});
+var subscriptionAddOnStatusSchema = z13.enum([
   "active",
   "canceled",
   "paused",
   "pending_activation"
 ]);
-var subscriptionAddOnSchema = z12.object({
+var subscriptionAddOnSchema = z13.object({
   /** References `product.add_ons.<addOnKey>`. */
-  addOnKey: z12.string().min(1).max(64),
+  addOnKey: z13.string().min(1).max(64),
   /** Status drives entitlement composition: only `active` AddOns
    *  contribute to the effective entitlement. */
   status: subscriptionAddOnStatusSchema.default("active"),
   /** When the AddOn became active (ISO-8601). Drives one-time grant
    *  issuance and recurring-fee start. */
-  activatedAt: z12.string().datetime().optional(),
+  activatedAt: z13.string().datetime().optional(),
   /** When the AddOn was canceled (ISO-8601). Null while active. */
-  canceledAt: z12.string().datetime().nullable().optional(),
+  canceledAt: z13.string().datetime().nullable().optional(),
   /** Stripe subscription-item id for the recurring-fee line, when
    *  the AddOn declares a non-zero `recurring_fee_cents`. */
-  stripeSubscriptionItemId: z12.string().optional()
+  stripeSubscriptionItemId: z13.string().optional()
 });
 
 // ../contracts/dist/plans/spec/backend-layer.js
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var BACKEND_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
-var backendIdSchema = z13.string().min(1).max(64).regex(BACKEND_ID_PATTERN, "backend id must be a lowercase slug ([a-z0-9][a-z0-9_-]*)");
-var backendTransportModeSchema = z13.enum([
+var backendIdSchema = z14.string().min(1).max(64).regex(BACKEND_ID_PATTERN, "backend id must be a lowercase slug ([a-z0-9][a-z0-9_-]*)");
+var backendTransportModeSchema = z14.enum([
   "public_origin",
   "mtls",
   "cloudflare_tunnel"
 ]);
-var backendTransportRunnerSchema = z13.enum([
+var backendTransportRunnerSchema = z14.enum([
   "managed_cloudflared",
   "sidecar"
 ]);
-var backendTransportSchema = z13.object({
+var backendTransportSchema = z14.object({
   mode: backendTransportModeSchema.default("public_origin"),
   runner: backendTransportRunnerSchema.optional()
 }).strict();
-var backendVerificationSchema = z13.object({
-  required: z13.boolean().default(false)
+var backendVerificationSchema = z14.object({
+  required: z14.boolean().default(false)
 }).strict();
-var backendDefinitionSchema = z13.object({
+var backendDefinitionSchema = z14.object({
   /** Human-friendly label. Defaults to the id when omitted. */
-  name: z13.string().min(1).max(120).optional(),
+  name: z14.string().min(1).max(120).optional(),
   /** Stable slug for the backend (origin-hostname / token scoping). Defaults
    *  to the id when omitted. */
   slug: backendIdSchema.optional(),
   transport: backendTransportSchema.default({ mode: "public_origin" }),
   verification: backendVerificationSchema.default({ required: false }),
   /** Meter allow-list. Omitted = all product meters allowed. */
-  meters: z13.array(z13.string().min(1).max(64)).max(100).optional(),
+  meters: z14.array(z14.string().min(1).max(64)).max(100).optional(),
   /** Marks the default backend when a product declares more than one. At
    *  most one backend may set this (compiler enforces / AMBIGUOUS_DEFAULT). */
-  default: z13.boolean().optional(),
+  default: z14.boolean().optional(),
   /** Reachable origin for `public_origin` / `mtls`. */
-  originUrl: z13.string().url().optional(),
+  originUrl: z14.string().url().optional(),
   /** Access-protected `*.fs-origin` host for `cloudflare_tunnel`. */
-  originHostname: z13.string().min(1).max(255).optional()
+  originHostname: z14.string().min(1).max(255).optional()
 }).strict();
-var productBackendBlockSchema = z13.record(backendIdSchema, backendDefinitionSchema);
+var productBackendBlockSchema = z14.record(backendIdSchema, backendDefinitionSchema);
 var routeBackendBindingSchema = backendIdSchema;
 var BACKEND_DIAGNOSTIC_CODES = {
   unknownBackendInRoute: "UNKNOWN_BACKEND_IN_ROUTE",
@@ -984,16 +987,16 @@ function resolveDefaultBackendId(backends) {
 }
 
 // ../contracts/dist/plans/spec/routes-layer.js
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // ../contracts/dist/plans/spec/policies-layer.js
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // ../contracts/dist/plans/spec/policy-types.js
-import { z as z14 } from "zod";
-var rateLimitWindowSchema = z14.string().min(2).max(20).regex(/^\d+(ms|s|m|h)$/, "rate_limit window must look like `60s`, `5m`, `1h`");
-var rateLimitConfigSchema = z14.object({
-  strategy: z14.enum(["token_bucket", "sliding_window", "fixed_window"]).default("token_bucket"),
+import { z as z15 } from "zod";
+var rateLimitWindowSchema = z15.string().min(2).max(20).regex(/^\d+(ms|s|m|h)$/, "rate_limit window must look like `60s`, `5m`, `1h`");
+var rateLimitConfigSchema = z15.object({
+  strategy: z15.enum(["token_bucket", "sliding_window", "fixed_window"]).default("token_bucket"),
   /**
    * Which request dimensions identify the bucket. v0.3.0 supports a
    * fixed set; extending requires a coordinated gateway/policy-engine
@@ -1001,10 +1004,10 @@ var rateLimitConfigSchema = z14.object({
    * `ip` is for unauthenticated probes; `credential` is finer-grained
    * than subscription (per-key throttling).
    */
-  dimensions: z14.array(z14.enum(["subscription", "credential", "ip", "route"])).min(1).max(4).default(["subscription"]),
-  limits: z14.array(z14.object({
+  dimensions: z15.array(z15.enum(["subscription", "credential", "ip", "route"])).min(1).max(4).default(["subscription"]),
+  limits: z15.array(z15.object({
     window: rateLimitWindowSchema,
-    max: z14.number().int().positive().max(1e7)
+    max: z15.number().int().positive().max(1e7)
   })).min(1).max(10),
   /**
    * Bounded fail-open behaviour for DO outages. See architecture RFC
@@ -1014,11 +1017,11 @@ var rateLimitConfigSchema = z14.object({
    * `recovery_threshold` consecutive successes restore normal
    * evaluation.
    */
-  fail_open: z14.object({
-    max_consecutive_failures: z14.number().int().positive().default(100),
-    max_window_seconds: z14.number().int().positive().default(60),
-    recovery_threshold: z14.number().int().positive().default(50),
-    degraded_mode: z14.enum([
+  fail_open: z15.object({
+    max_consecutive_failures: z15.number().int().positive().default(100),
+    max_window_seconds: z15.number().int().positive().default(60),
+    recovery_threshold: z15.number().int().positive().default(50),
+    degraded_mode: z15.enum([
       "safe_mode_block",
       "safe_mode_throttle",
       "runtime_killswitch_trigger"
@@ -1030,19 +1033,19 @@ var rateLimitConfigSchema = z14.object({
     degraded_mode: "safe_mode_throttle"
   })
 });
-var authConfigSchema = z14.object({
-  header_name: z14.string().min(1).max(100).default("x-api-key"),
+var authConfigSchema = z15.object({
+  header_name: z15.string().min(1).max(100).default("x-api-key"),
   /**
    * How the gateway constructs the upstream Authorization header:
    *   - `none`          → no upstream auth header added
    *   - `static_bearer` → forward a configured static token
    *   - `subscriber_jwt` → mint a per-subscriber JWT (out of scope v0.3.0)
    */
-  upstream_token_source: z14.discriminatedUnion("type", [
-    z14.object({ type: z14.literal("none") }),
-    z14.object({
-      type: z14.literal("static_bearer"),
-      token_secret_ref: z14.string().min(1).max(200).describe("Reference into the secret store (e.g. CF Secret name); not the raw token")
+  upstream_token_source: z15.discriminatedUnion("type", [
+    z15.object({ type: z15.literal("none") }),
+    z15.object({
+      type: z15.literal("static_bearer"),
+      token_secret_ref: z15.string().min(1).max(200).describe("Reference into the secret store (e.g. CF Secret name); not the raw token")
     })
   ]).default({ type: "none" }),
   /**
@@ -1050,32 +1053,32 @@ var authConfigSchema = z14.object({
    * additional gating beyond the entitlement check. v0.3.0 ships with
    * `strict` as the default.
    */
-  scope_mode: z14.enum(["strict", "advisory", "off"]).default("strict")
+  scope_mode: z15.enum(["strict", "advisory", "off"]).default("strict")
 });
-var concurrencyConfigSchema = z14.object({
-  max_in_flight: z14.number().int().positive().max(1e4),
+var concurrencyConfigSchema = z15.object({
+  max_in_flight: z15.number().int().positive().max(1e4),
   /**
    * Which dimensions key the lease bucket. Matches the existing
    * ConcurrencyLease DO `idFromName` pattern (subscription | capability
    * tuple).
    */
-  dimensions: z14.array(z14.enum(["subscription", "credential", "capability"])).min(1).max(3).default(["subscription"]),
+  dimensions: z15.array(z15.enum(["subscription", "credential", "capability"])).min(1).max(3).default(["subscription"]),
   /**
    * Optional capability scope. When set, the lease bucket is keyed
    * partly by this capability name — separate buckets per capability.
    */
-  capability: z14.string().min(1).max(120).optional(),
+  capability: z15.string().min(1).max(120).optional(),
   /**
    * Lease TTL — releases automatically after this many seconds even if
    * the request never returns (defensive default 30s, mirrors existing
    * ConcurrencyLease behaviour).
    */
-  lease_ttl_seconds: z14.number().int().positive().max(600).default(30),
-  fail_open: z14.object({
-    max_consecutive_failures: z14.number().int().positive().default(50),
-    max_window_seconds: z14.number().int().positive().default(60),
-    recovery_threshold: z14.number().int().positive().default(20),
-    degraded_mode: z14.enum([
+  lease_ttl_seconds: z15.number().int().positive().max(600).default(30),
+  fail_open: z15.object({
+    max_consecutive_failures: z15.number().int().positive().default(50),
+    max_window_seconds: z15.number().int().positive().default(60),
+    recovery_threshold: z15.number().int().positive().default(20),
+    degraded_mode: z15.enum([
       "safe_mode_block",
       "safe_mode_throttle",
       "runtime_killswitch_trigger"
@@ -1087,22 +1090,22 @@ var concurrencyConfigSchema = z14.object({
     degraded_mode: "safe_mode_throttle"
   })
 });
-var retryConfigSchema = z14.object({
-  max_attempts: z14.number().int().min(1).max(5).default(2),
+var retryConfigSchema = z15.object({
+  max_attempts: z15.number().int().min(1).max(5).default(2),
   /**
    * HTTP status codes that trigger a retry. 5xx is the default; opt
    * into 429 retries only when the upstream understands `Retry-After`.
    */
-  retry_on_status: z14.array(z14.number().int().min(400).max(599)).min(1).max(20).default([502, 503, 504]),
+  retry_on_status: z15.array(z15.number().int().min(400).max(599)).min(1).max(20).default([502, 503, 504]),
   /**
    * Backoff curve. Total wall-clock attempt time is bounded so the
    * gateway worker cannot block past `total_budget_ms`.
    */
-  backoff: z14.object({
-    initial_ms: z14.number().int().positive().max(5e3).default(100),
-    multiplier: z14.number().positive().max(10).default(2),
-    jitter: z14.enum(["none", "full", "equal"]).default("equal"),
-    total_budget_ms: z14.number().int().positive().max(3e4).default(5e3)
+  backoff: z15.object({
+    initial_ms: z15.number().int().positive().max(5e3).default(100),
+    multiplier: z15.number().positive().max(10).default(2),
+    jitter: z15.enum(["none", "full", "equal"]).default("equal"),
+    total_budget_ms: z15.number().int().positive().max(3e4).default(5e3)
   }).default({
     initial_ms: 100,
     multiplier: 2,
@@ -1110,46 +1113,46 @@ var retryConfigSchema = z14.object({
     total_budget_ms: 5e3
   })
 });
-var transformConfigSchema = z14.object({
+var transformConfigSchema = z15.object({
   /**
    * When the transform applies. `request` runs before upstream forward;
    * `response` runs after. Most transforms are one or the other; both
    * is rare.
    */
-  applies_to: z14.enum(["request", "response", "both"]).default("request"),
+  applies_to: z15.enum(["request", "response", "both"]).default("request"),
   /**
    * List of key rewrites. Source path uses dot notation (`a.b.c`);
    * `target` may include the same syntax to move keys around. Drops
    * are expressed as `target: null`.
    */
-  rewrites: z14.array(z14.object({
-    source: z14.string().min(1).max(200),
-    target: z14.string().min(1).max(200).nullable()
+  rewrites: z15.array(z15.object({
+    source: z15.string().min(1).max(200),
+    target: z15.string().min(1).max(200).nullable()
   })).min(1).max(20)
 });
-var policyBodySchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("rate_limit"), config: rateLimitConfigSchema }),
-  z14.object({ type: z14.literal("auth"), config: authConfigSchema }),
-  z14.object({ type: z14.literal("concurrency"), config: concurrencyConfigSchema }),
-  z14.object({ type: z14.literal("retry"), config: retryConfigSchema }),
-  z14.object({ type: z14.literal("transform"), config: transformConfigSchema })
+var policyBodySchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("rate_limit"), config: rateLimitConfigSchema }),
+  z15.object({ type: z15.literal("auth"), config: authConfigSchema }),
+  z15.object({ type: z15.literal("concurrency"), config: concurrencyConfigSchema }),
+  z15.object({ type: z15.literal("retry"), config: retryConfigSchema }),
+  z15.object({ type: z15.literal("transform"), config: transformConfigSchema })
 ]);
 
 // ../contracts/dist/plans/spec/policies-layer.js
-var cacheProfileSchema = z15.enum(["long", "short", "blocking"]).default("long");
-var policyCompatibilitySchema = z15.object({
-  route_types: z15.array(z15.enum(["http"])).max(5).optional(),
-  meters: z15.array(z15.string().min(1).max(64)).max(20).optional(),
-  auth_modes: z15.array(z15.enum(["api_key", "oauth2", "anonymous"])).max(5).optional()
+var cacheProfileSchema = z16.enum(["long", "short", "blocking"]).default("long");
+var policyCompatibilitySchema = z16.object({
+  route_types: z16.array(z16.enum(["http"])).max(5).optional(),
+  meters: z16.array(z16.string().min(1).max(64)).max(20).optional(),
+  auth_modes: z16.array(z16.enum(["api_key", "oauth2", "anonymous"])).max(5).optional()
 });
-var policyLayerSchema = z15.intersection(z15.object({
+var policyLayerSchema = z16.intersection(z16.object({
   /**
    * Policy name. Referenced by routes via `policies: [<name>]`. Must
    * be unique across the product; the compiler enforces this in the
    * cross-layer validation pass.
    */
-  name: z15.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Policy name must be lowercase alphanumeric with hyphens/underscores"),
-  description: z15.string().max(500).optional(),
+  name: z16.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Policy name must be lowercase alphanumeric with hyphens/underscores"),
+  description: z16.string().max(500).optional(),
   compatible_with: policyCompatibilitySchema.default({}),
   /**
    * Mutation class — runtime vs contractual. Policies are operational
@@ -1157,38 +1160,38 @@ var policyLayerSchema = z15.intersection(z15.object({
    * `contractual` signals that changes to it require human approval
    * (invariant #16).
    */
-  mutation_class: z15.enum(["runtime", "contractual"]).default("runtime"),
+  mutation_class: z16.enum(["runtime", "contractual"]).default("runtime"),
   cacheProfile: cacheProfileSchema
 }), policyBodySchema);
 
 // ../contracts/dist/framework/actions/index.js
-import { z as z16 } from "zod";
-var actionKindSchema = z16.enum(["query", "mutation"]);
-var actionAuditPolicySchema = z16.enum(["none", "metadata", "full"]);
-var actionSubjectBindingSchema = z16.object({
-  type: z16.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/),
-  from: z16.enum(["header", "path_param"]),
-  name: z16.string().min(1).max(120)
-});
-var actionResourceEffectSchema = z16.object({
-  resource: z16.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/),
-  effect: z16.enum(["create", "delete"])
-});
-var actionSpecSchema = z16.object({
-  id: z16.string().min(1).max(160).regex(/^[a-z0-9_.:-]+$/),
-  title: z16.string().min(1).max(160).optional(),
+import { z as z17 } from "zod";
+var actionKindSchema = z17.enum(["query", "mutation"]);
+var actionAuditPolicySchema = z17.enum(["none", "metadata", "full"]);
+var actionSubjectBindingSchema = z17.object({
+  type: z17.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/),
+  from: z17.enum(["header", "path_param"]),
+  name: z17.string().min(1).max(120)
+});
+var actionResourceEffectSchema = z17.object({
+  resource: z17.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/),
+  effect: z17.enum(["create", "delete"])
+});
+var actionSpecSchema = z17.object({
+  id: z17.string().min(1).max(160).regex(/^[a-z0-9_.:-]+$/),
+  title: z17.string().min(1).max(160).optional(),
   kind: actionKindSchema,
-  actorType: z16.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
+  actorType: z17.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
   subject: actionSubjectBindingSchema.optional(),
-  inputSchemaRef: z16.string().min(1).max(240).optional(),
+  inputSchemaRef: z17.string().min(1).max(240).optional(),
   audit: actionAuditPolicySchema.default("metadata"),
   resource: actionResourceEffectSchema.optional()
 });
 
 // ../contracts/dist/plans/spec/routes-layer.js
-var routeMatchSchema = z17.object({
-  method: z17.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "*"]).default("*"),
-  path: z17.string().min(1).max(500).regex(/^\/[a-zA-Z0-9_/:.{}*-]*$/, "path must start with / and contain only [a-zA-Z0-9_/:.{}*-]")
+var routeMatchSchema = z18.object({
+  method: z18.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "*"]).default("*"),
+  path: z18.string().min(1).max(500).regex(/^\/[a-zA-Z0-9_/:.{}*-]*$/, "path must start with / and contain only [a-zA-Z0-9_/:.{}*-]")
 });
 function statusPolicyPartIsValid(part) {
   const trimmed = part.trim();
@@ -1206,60 +1209,60 @@ function statusPolicyPartIsValid(part) {
 function isRouteStatusCodePolicyString(value) {
   return value.split(",").every(statusPolicyPartIsValid);
 }
-var routeStatusCodePolicySchema = z17.union([
-  z17.string().min(1).max(100).refine(isRouteStatusCodePolicyString, {
+var routeStatusCodePolicySchema = z18.union([
+  z18.string().min(1).max(100).refine(isRouteStatusCodePolicyString, {
     message: "onStatusCodes must be comma-separated HTTP status codes or numeric ranges, e.g. 200-299,304"
   }),
-  z17.array(z17.number().int().min(100).max(599)).min(1).max(100)
+  z18.array(z18.number().int().min(100).max(599)).min(1).max(100)
 ]);
-var routeDefinitionSchema = z17.object({
+var routeDefinitionSchema = z18.object({
   match: routeMatchSchema,
-  metering: z17.object({
-    defaults: z17.record(z17.string().min(1).max(64), z17.number().finite().nonnegative()).optional(),
-    reports: z17.array(z17.string().min(1).max(64)).max(20).optional(),
-    estimates: z17.record(z17.string().min(1).max(64), z17.number().finite().nonnegative()).optional(),
+  metering: z18.object({
+    defaults: z18.record(z18.string().min(1).max(64), z18.number().finite().nonnegative()).optional(),
+    reports: z18.array(z18.string().min(1).max(64)).max(20).optional(),
+    estimates: z18.record(z18.string().min(1).max(64), z18.number().finite().nonnegative()).optional(),
     onStatusCodes: routeStatusCodePolicySchema.optional()
   }).optional(),
-  unmetered: z17.boolean().optional(),
-  inheritDefaultMeters: z17.boolean().optional(),
+  unmetered: z18.boolean().optional(),
+  inheritDefaultMeters: z18.boolean().optional(),
   /** Optional explicit action id. When absent, the compiler derives an
    *  implicit action from feature + method + path. */
-  action: z17.string().min(1).max(160).regex(/^[a-z0-9_.:-]+$/).optional(),
+  action: z18.string().min(1).max(160).regex(/^[a-z0-9_.:-]+$/).optional(),
   /** BYO-Backend V1 — optional route→backend binding. Omitted = the sole /
    *  default backend (single-backend products stay zero-config). The schema
    *  is `.strict()`, so this key MUST be declared here or `parse` throws on
    *  it (anti-`.strict()`). */
   backend: routeBackendBindingSchema.optional()
 }).strict();
-var routeUpstreamSchema = z17.object({
-  override_origin: z17.string().url("override_origin must be a valid URL").nullable().default(null)
+var routeUpstreamSchema = z18.object({
+  override_origin: z18.string().url("override_origin must be a valid URL").nullable().default(null)
 });
-var routeRuntimeSchema = z17.object({
-  rollout_key: z17.string().min(1).max(120).regex(/^[a-z0-9_-]+$/, "rollout_key must be lowercase alphanumeric with hyphens/underscores").optional(),
+var routeRuntimeSchema = z18.object({
+  rollout_key: z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/, "rollout_key must be lowercase alphanumeric with hyphens/underscores").optional(),
   /**
    * Optional runtime flags this feature depends on. The runtime
    * evaluator AND's the feature's enablement across all referenced
    * flags. If any flag is disabled, the route returns the configured
    * fallback (404 by default — see /runtime failure matrix).
    */
-  required_flags: z17.array(z17.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(10).optional()
+  required_flags: z18.array(z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(10).optional()
 });
-var routeLayerSchema = z17.object({
+var routeLayerSchema = z18.object({
   /**
    * Feature key — the entitlement unit. Surfaced in dashboards,
    * subscriptions, and the gateway's matched-route trace.
    */
-  feature: z17.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/, "feature key must be lowercase alphanumeric with [_.:-]"),
-  description: z17.string().max(500).optional(),
+  feature: z18.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/, "feature key must be lowercase alphanumeric with [_.:-]"),
+  description: z18.string().max(500).optional(),
   /**
    * Route additions are contractual by default — they expose new API
    * surface to subscribers. Internal/non-customer-visible routes can
    * mark themselves `runtime` to allow autonomous agent flips
    * (invariant #16; see RFC approval matrix).
    */
-  mutation_class: z17.enum(["runtime", "contractual"]).default("contractual"),
+  mutation_class: z18.enum(["runtime", "contractual"]).default("contractual"),
   cacheProfile: cacheProfileSchema,
-  routes: z17.array(routeDefinitionSchema).min(1).max(50),
+  routes: z18.array(routeDefinitionSchema).min(1).max(50),
   upstream: routeUpstreamSchema.default({ override_origin: null }),
   /**
    * Ordered list of policy names to apply. Executed sequentially by
@@ -1267,17 +1270,17 @@ var routeLayerSchema = z17.object({
    * MUST declare compatible `compatible_with` envelopes for this
    * feature's route/meter shape — the compiler enforces.
    */
-  policies: z17.array(z17.string().min(1).max(64).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
+  policies: z18.array(z18.string().min(1).max(64).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
   runtime: routeRuntimeSchema.default({}),
   /**
    * Plans that grant this feature directly. Shared feature bundles are
    * expressed in capability layers via `includes_features`; route layers do
    * not declare capability membership.
    */
-  plans: z17.array(z17.string().min(1).max(64)).max(20).default([]),
+  plans: z18.array(z18.string().min(1).max(64)).max(20).default([]),
   /** Explicit actions declared by this feature. Routes reference them by
    *  `route.action`; routes without a binding receive implicit actions. */
-  actions: z17.array(actionSpecSchema).max(100).optional(),
+  actions: z18.array(actionSpecSchema).max(100).optional(),
   /** BYO-Backend V1 — feature-level default backend binding. Routes in this
    *  layer with no explicit `route.backend` inherit this; routes may still
    *  override per-route. Omitted = the product's sole / default backend. */
@@ -1597,18 +1600,18 @@ function planPriceKey(plan, monthly) {
 }
 
 // ../contracts/dist/plans/spec/product.js
-var productIdentitySchema = z18.object({
-  subdomain: z18.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "Subdomain must be lowercase alphanumeric with optional hyphens")
+var productIdentitySchema = z19.object({
+  subdomain: z19.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "Subdomain must be lowercase alphanumeric with optional hyphens")
 });
-var meterEnforcementTypeSchema = z18.enum([
+var meterEnforcementTypeSchema = z19.enum([
   "exact_pre_request",
   "estimated_then_settled",
   "postpaid",
   "strict_concurrency"
 ]);
-var meterDefinitionSchema = z18.object({
-  key: z18.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Meter key must be lowercase alphanumeric with underscores"),
-  display: z18.string().min(1).max(100),
+var meterDefinitionSchema = z19.object({
+  key: z19.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Meter key must be lowercase alphanumeric with underscores"),
+  display: z19.string().min(1).max(100),
   // v0.42.0 — `type: "built-in" | "custom"` removed. The runtime never
   // read it (gateway estimators key on meter NAME, Stripe meter
   // creation keys on meter KEY); it was schema documentation. Wizard
@@ -1616,11 +1619,11 @@ var meterDefinitionSchema = z18.object({
   // ai_usage → `dollars`); Custom template lets builders define keys
   // freely. Old specs with `type: ...` parse cleanly because Zod
   // strips unknown fields by default.
-  unit: z18.string().max(20).optional(),
+  unit: z19.string().max(20).optional(),
   /** Reusable pre-request estimate for routes that dynamically report this meter. */
-  estimate: z18.number().finite().nonnegative().optional(),
+  estimate: z19.number().finite().nonnegative().optional(),
   /** Fixed per-request default applied by Product SDK helpers. */
-  routeDefault: z18.number().finite().nonnegative().optional(),
+  routeDefault: z19.number().finite().nonnegative().optional(),
   /**
    * Runtime enforcement semantics for this meter. This is compiled into
    * signed gateway artifacts so the edge chooses reservation, settlement,
@@ -1645,7 +1648,7 @@ var meterDefinitionSchema = z18.object({
    * current `window`. Defaults to `COUNT` (one event = one unit) so
    * existing meters that didn't declare aggregation continue to work.
    */
-  aggregation: z18.enum(["SUM", "COUNT", "MAX", "UNIQUE_COUNT", "LATEST"]).default("COUNT"),
+  aggregation: z19.enum(["SUM", "COUNT", "MAX", "UNIQUE_COUNT", "LATEST"]).default("COUNT"),
   /**
    * Aggregation window. `billing_period` (the default) makes the
    * meter accumulate across the subscription's billing period.
@@ -1653,88 +1656,65 @@ var meterDefinitionSchema = z18.object({
    * rate-limit-shaped meters where the period boundary is a fixed
    * wall-clock interval, not the subscription anniversary.
    */
-  window: z18.enum(["minute", "hour", "day", "month", "billing_period"]).default("billing_period"),
+  window: z19.enum(["minute", "hour", "day", "month", "billing_period"]).default("billing_period"),
   /**
    * Property on the event payload to read for `SUM` and `MAX`
    * aggregations. Optional at the schema level; core's `validate.ts`
    * (Phase 1b) enforces "required when aggregation is SUM or MAX".
    */
-  valueProperty: z18.string().optional(),
+  valueProperty: z19.string().optional(),
   /**
    * Property on the event payload to dedupe on for `UNIQUE_COUNT`
    * aggregation. Optional at the schema level; core's validate-pass
    * enforces "required when aggregation is UNIQUE_COUNT".
    */
-  uniqueProperty: z18.string().optional(),
+  uniqueProperty: z19.string().optional(),
   /**
    * Optional grouping dimensions. When set, the aggregation is per
    * unique combination of these properties' values, not a single
    * scalar. Used for per-region or per-model breakdowns.
    */
-  groupBy: z18.array(z18.string()).optional(),
+  groupBy: z19.array(z19.string()).optional(),
   /**
    * Lago-side event code for ingress correlation. Matches Lago's
    * BillableMetric `code` so events sent to Lago land on the right
    * meter without a per-meter translation table.
    */
-  eventCode: z18.string().optional()
-});
-var usageMeasureSchema = z18.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Usage measure must be lowercase alphanumeric with underscores");
-var usageRatingPricePolicySchema = z18.enum([
-  "pass_through",
-  "markup",
-  "fixed_margin",
-  "customer_rate"
-]);
-var fixedRatingSchema = z18.object({
-  source: z18.literal("fixed"),
-  rates: z18.record(z18.string().min(1), z18.record(usageMeasureSchema, z18.number().int().nonnegative()))
+  eventCode: z19.string().optional()
 });
-var providerCatalogRatingSchema = z18.object({
-  source: z18.literal("provider_catalog"),
-  catalog: z18.string().min(1).max(100),
-  pricePolicy: usageRatingPricePolicySchema.default("pass_through"),
-  markupPercent: z18.number().nonnegative().max(1e4).optional(),
-  marginMicros: z18.number().int().nonnegative().optional()
-});
-var upstreamReportedRatingSchema = z18.object({
-  source: z18.literal("upstream_reported"),
-  amountField: z18.string().min(1).max(500),
-  currencyField: z18.string().min(1).max(500).optional()
-});
-var externalRateApiRatingSchema = z18.object({
-  source: z18.literal("external_rate_api"),
-  resolver: z18.string().min(1).max(100),
-  configRef: z18.string().min(1).max(200).optional()
+var usageMeasureSchema = z19.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Usage measure must be lowercase alphanumeric with underscores");
+var usageRatingPricePolicySchema = z19.enum(["pass_through", "markup"]);
+var fixedRatingSchema = z19.object({
+  source: z19.literal("fixed"),
+  rates: z19.record(z19.string().min(1), z19.record(usageMeasureSchema, z19.number().int().nonnegative()))
 });
-var customRatingSchema = z18.object({
-  source: z18.literal("custom"),
-  resolver: z18.string().min(1).max(100),
-  configRef: z18.string().min(1).max(200).optional()
+var providerCatalogRatingSchema = z19.object({
+  source: z19.literal("provider_catalog"),
+  catalog: z19.string().min(1).max(100),
+  pricePolicy: usageRatingPricePolicySchema.default("pass_through"),
+  markupPercent: z19.number().nonnegative().max(1e4).optional(),
+  marginMicros: z19.number().int().nonnegative().optional()
 });
-var usageRatingSchema = z18.discriminatedUnion("source", [
+var usageRatingSchema = z19.discriminatedUnion("source", [
   fixedRatingSchema,
-  providerCatalogRatingSchema,
-  upstreamReportedRatingSchema,
-  externalRateApiRatingSchema,
-  customRatingSchema
+  providerCatalogRatingSchema
 ]);
-var usageMeterSchema = z18.object({
-  selector: z18.string().min(1).max(100).optional(),
-  measures: z18.array(usageMeasureSchema).min(1).max(20),
+var usageMeterSchema = z19.object({
+  selector: z19.string().min(1).max(100).optional(),
+  measures: z19.array(usageMeasureSchema).min(1).max(20),
   rating: usageRatingSchema.optional()
 });
-var usageBlockSchema = z18.object({
-  meters: z18.record(z18.string().min(1).max(64).regex(/^[a-z0-9_]+$/), usageMeterSchema)
+var usageBlockSchema = z19.object({
+  meters: z19.record(z19.string().min(1).max(64).regex(/^[a-z0-9_]+$/), usageMeterSchema)
 });
-var routeMeteringSchema = z18.object({
-  defaults: z18.record(z18.string().min(1).max(64), z18.number().finite().nonnegative()).optional(),
-  reports: z18.array(z18.string().min(1).max(64)).max(20).optional(),
-  estimates: z18.record(z18.string().min(1).max(64), z18.number().finite().nonnegative()).optional(),
+var routeMeteringSchema = z19.object({
+  defaults: z19.record(z19.string().min(1).max(64), z19.number().finite().nonnegative()).optional(),
+  reports: z19.array(z19.string().min(1).max(64)).max(20).optional(),
+  estimates: z19.record(z19.string().min(1).max(64), z19.number().finite().nonnegative()).optional(),
   onStatusCodes: routeStatusCodePolicySchema.optional()
 });
-var featureRouteSchema = z18.object({
-  method: z18.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "*"]).default("*"),
+var featureRouteSchema = z19.object({
+  method: z19.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "*"]).default("*"),
   // Path is the route under the product's baseUrl. OpenAPI parameter
   // syntax is supported and translated by the compiler:
   //   /users/:id   → /users/*
@@ -1742,48 +1722,48 @@ var featureRouteSchema = z18.object({
   // Path-globs `*` (one segment) and `**` (any subpath) are passed
   // through. The compiler rejects ambiguous compound segments like
   // `/foo/:a-:b` — parameter names must occupy whole segments.
-  path: z18.string().min(1).max(500).regex(/^\/[a-zA-Z0-9_/:.{}*-]*$/, "path must start with / and contain only [a-zA-Z0-9_/:.{}*-]"),
+  path: z19.string().min(1).max(500).regex(/^\/[a-zA-Z0-9_/:.{}*-]*$/, "path must start with / and contain only [a-zA-Z0-9_/:.{}*-]"),
   // Explicit no-usage route. Dynamic/static route metering is declared
   // exclusively under `metering`.
-  unmetered: z18.boolean().optional(),
+  unmetered: z19.boolean().optional(),
   metering: routeMeteringSchema.optional(),
-  inheritDefaultMeters: z18.boolean().optional(),
+  inheritDefaultMeters: z19.boolean().optional(),
   // BYO-Backend V1 — route→backend binding. The compiler materializes
   // per-feature route layers into this strict route shape, so the key MUST be
   // declared here or `parse` throws on it (anti-`.strict()`).
   backend: routeBackendBindingSchema.optional()
 }).strict();
-var featureCatalogEntrySchema = z18.object({
+var featureCatalogEntrySchema = z19.object({
   // Optional human-friendly summary; surfaced in dashboards / settings UI.
-  description: z18.string().max(500).optional(),
-  routes: z18.array(featureRouteSchema).min(1).max(50),
+  description: z19.string().max(500).optional(),
+  routes: z19.array(featureRouteSchema).min(1).max(50),
   // Plans that grant this feature. Feature-first canonical mapping —
   // builders declare "which plans get this feature" on the feature
   // itself rather than enumerating features per plan. Required and
   // non-empty: a feature with no plans grants nothing and is a likely
   // typo. Cross-reference validation (every key resolves to an
   // existing plan) lives in `validateFeatureReferences` below.
-  plans: z18.array(z18.string().min(1)).min(1).max(20)
+  plans: z19.array(z19.string().min(1)).min(1).max(20)
 });
-var featureCatalogSchema = z18.record(z18.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/), featureCatalogEntrySchema);
-var productCleanupPolicyModeSchema = z18.enum([
+var featureCatalogSchema = z19.record(z19.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/), featureCatalogEntrySchema);
+var productCleanupPolicyModeSchema = z19.enum([
   "report",
   "pull_request"
 ]);
-var productChangeApprovalRiskSchema = z18.enum([
+var productChangeApprovalRiskSchema = z19.enum([
   "safe",
   "non_blocking",
   "economic_risk",
   "blocking"
 ]);
-var productOperatorPoliciesSchema = z18.object({
+var productOperatorPoliciesSchema = z19.object({
   /**
    * Route cleanup operator. Disabled by default; report-mode is the safe
    * default so a product can surface zero-traffic runtime-route candidates
    * before it opts into draft PR mutation.
    */
-  cleanup: z18.object({
-    enabled: z18.boolean().default(false),
+  cleanup: z19.object({
+    enabled: z19.boolean().default(false),
     mode: productCleanupPolicyModeSchema.default("report")
   }).default({ enabled: false, mode: "report" }),
   /**
@@ -1791,9 +1771,9 @@ var productOperatorPoliciesSchema = z18.object({
    * the policy a first-class product-as-code field even while enforcement is
    * still report/label-only.
    */
-  change_approval: z18.object({
-    auto_merge_max_risk: z18.enum(["none", "safe", "non_blocking"]).default("none"),
-    require_human_for: z18.array(productChangeApprovalRiskSchema).default(["economic_risk", "blocking"])
+  change_approval: z19.object({
+    auto_merge_max_risk: z19.enum(["none", "safe", "non_blocking"]).default("none"),
+    require_human_for: z19.array(productChangeApprovalRiskSchema).default(["economic_risk", "blocking"])
   }).default({
     auto_merge_max_risk: "none",
     require_human_for: ["economic_risk", "blocking"]
@@ -1805,15 +1785,15 @@ var productOperatorPoliciesSchema = z18.object({
     require_human_for: ["economic_risk", "blocking"]
   }
 });
-var customerIdentityRequirementSchema = z18.enum([
+var customerIdentityRequirementSchema = z19.enum([
   "org_only",
   "org_and_user"
 ]);
-var customerPortalAuthStrategySchema = z18.enum([
+var customerPortalAuthStrategySchema = z19.enum([
   "clerk",
   "test-personas"
 ]);
-var productCustomerContextSchema = z18.object({
+var productCustomerContextSchema = z19.object({
   /**
    * Edge credential identity policy. This is intentionally Product-scoped:
    * B7 keeps Product as the product boundary and avoids customer-side
@@ -1825,19 +1805,19 @@ var productCustomerContextSchema = z18.object({
    * runtime signing secret in product/product.config.ts. Core generates/preserves the
    * secret when this is true and clears it when explicitly false.
    */
-  context_tokens: z18.object({
-    enabled: z18.boolean().default(true)
+  context_tokens: z19.object({
+    enabled: z19.boolean().default(true)
   }).optional(),
   /**
    * Portal auth strategy for environment-scoped product applies. Production
    * portal auth is provisioner-owned; preview/test environments can opt into
    * test personas through Product-as-Code.
    */
-  portal_auth: z18.object({
+  portal_auth: z19.object({
     strategy: customerPortalAuthStrategySchema
   }).optional()
 });
-var productSurfaceTypeSchema = z18.enum([
+var productSurfaceTypeSchema = z19.enum([
   "frontend",
   "api",
   "docs",
@@ -1847,84 +1827,84 @@ var productSurfaceTypeSchema = z18.enum([
   "worker",
   "agent"
 ]);
-var productSurfaceSchema = z18.object({
-  key: z18.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Surface key must be lowercase alphanumeric with hyphens/underscores"),
+var productSurfaceSchema = z19.object({
+  key: z19.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Surface key must be lowercase alphanumeric with hyphens/underscores"),
   type: productSurfaceTypeSchema,
-  display: z18.string().min(1).max(100).optional(),
-  description: z18.string().max(500).optional()
+  display: z19.string().min(1).max(100).optional(),
+  description: z19.string().max(500).optional()
 });
-var productEntitlementSchema = z18.object({
-  key: z18.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Entitlement key must be lowercase alphanumeric with hyphens/underscores"),
-  description: z18.string().max(500).optional(),
-  capabilities: z18.array(z18.string().min(1).max(100)).max(100).optional(),
-  featureGates: z18.record(z18.string().min(1), z18.boolean()).optional(),
-  limits: z18.array(planLimitRuleSchema).max(100).optional(),
-  meters: z18.array(z18.string().min(1).max(64)).max(100).optional()
-});
-var productSurfacesSchema = z18.array(productSurfaceSchema).max(20).default([]);
-var productEntitlementsSchema = z18.array(productEntitlementSchema).max(100).default([]);
-var productWorkflowKindSchema = z18.enum([
+var productEntitlementSchema = z19.object({
+  key: z19.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Entitlement key must be lowercase alphanumeric with hyphens/underscores"),
+  description: z19.string().max(500).optional(),
+  capabilities: z19.array(z19.string().min(1).max(100)).max(100).optional(),
+  featureGates: z19.record(z19.string().min(1), z19.boolean()).optional(),
+  limits: z19.array(planLimitRuleSchema).max(100).optional(),
+  meters: z19.array(z19.string().min(1).max(64)).max(100).optional()
+});
+var productSurfacesSchema = z19.array(productSurfaceSchema).max(20).default([]);
+var productEntitlementsSchema = z19.array(productEntitlementSchema).max(100).default([]);
+var productWorkflowKindSchema = z19.enum([
   "async_job",
   "agent_task",
   "scheduled",
   "lifecycle",
   "background"
 ]);
-var productWorkflowTriggerSchema = z18.discriminatedUnion("type", [
-  z18.object({ type: z18.literal("manual") }),
-  z18.object({
-    type: z18.literal("schedule"),
-    cron: z18.string().min(1).max(120)
+var productWorkflowTriggerSchema = z19.discriminatedUnion("type", [
+  z19.object({ type: z19.literal("manual") }),
+  z19.object({
+    type: z19.literal("schedule"),
+    cron: z19.string().min(1).max(120)
   }),
-  z18.object({
-    type: z18.literal("event"),
-    event: z18.string().min(1).max(120)
+  z19.object({
+    type: z19.literal("event"),
+    event: z19.string().min(1).max(120)
   }),
-  z18.object({
-    type: z18.literal("api"),
-    path: z18.string().min(1).max(240).regex(/^\//, "path must start with /")
+  z19.object({
+    type: z19.literal("api"),
+    path: z19.string().min(1).max(240).regex(/^\//, "path must start with /")
   }),
-  z18.object({
-    type: z18.literal("lifecycle"),
-    event: z18.string().min(1).max(120)
+  z19.object({
+    type: z19.literal("lifecycle"),
+    event: z19.string().min(1).max(120)
   })
 ]);
-var productWorkflowSchema = z18.object({
-  key: z18.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Workflow key must be lowercase alphanumeric with hyphens/underscores"),
-  title: z18.string().min(1).max(120).optional(),
-  description: z18.string().max(1e3).optional(),
+var productWorkflowSchema = z19.object({
+  key: z19.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Workflow key must be lowercase alphanumeric with hyphens/underscores"),
+  title: z19.string().min(1).max(120).optional(),
+  description: z19.string().max(1e3).optional(),
   kind: productWorkflowKindSchema,
   trigger: productWorkflowTriggerSchema,
-  capabilities: z18.array(z18.string().min(1).max(100)).max(100).optional(),
-  meters: z18.array(z18.string().min(1).max(64)).max(100).optional(),
-  estimates: z18.record(z18.string().min(1).max(64), z18.number().finite()).optional(),
-  metadata: z18.record(z18.string().min(1), z18.unknown()).optional()
-});
-var productWorkflowsSchema = z18.array(productWorkflowSchema).max(100).default([]);
-var productSpecSchema = z18.object({
-  product: z18.object({
-    name: z18.string().min(1).max(100),
-    displayName: z18.string().max(200).optional(),
-    description: z18.string().max(2e3).optional(),
-    baseUrl: z18.string().url("baseUrl must be a valid URL"),
-    sandboxBaseUrl: z18.string().url("sandboxBaseUrl must be a valid URL").optional(),
-    visibility: z18.enum(["public", "private"]).default("public"),
+  capabilities: z19.array(z19.string().min(1).max(100)).max(100).optional(),
+  meters: z19.array(z19.string().min(1).max(64)).max(100).optional(),
+  estimates: z19.record(z19.string().min(1).max(64), z19.number().finite()).optional(),
+  metadata: z19.record(z19.string().min(1), z19.unknown()).optional()
+});
+var productWorkflowsSchema = z19.array(productWorkflowSchema).max(100).default([]);
+var productSpecSchema = z19.object({
+  product: z19.object({
+    name: z19.string().min(1).max(100),
+    displayName: z19.string().max(200).optional(),
+    description: z19.string().max(2e3).optional(),
+    baseUrl: z19.string().url("baseUrl must be a valid URL"),
+    sandboxBaseUrl: z19.string().url("sandboxBaseUrl must be a valid URL").optional(),
+    visibility: z19.enum(["public", "private"]).default("public"),
     // Branding
-    logoUrl: z18.string().url().optional(),
-    primaryColor: z18.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+    logoUrl: z19.string().url().optional(),
+    primaryColor: z19.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
     // Environment
-    envBranchPrefix: z18.string().max(50).nullable().optional()
+    envBranchPrefix: z19.string().max(50).nullable().optional()
   }),
-  gateway: z18.object({
-    authHeader: z18.string().min(1).max(100).default("x-api-key"),
-    upstreamAuth: z18.object({
-      type: z18.enum(["none", "static_bearer"]),
-      token: z18.string().optional()
+  gateway: z19.object({
+    authHeader: z19.string().min(1).max(100).default("x-api-key"),
+    upstreamAuth: z19.object({
+      type: z19.enum(["none", "static_bearer"]),
+      token: z19.string().optional()
     }).default({ type: "none" })
   }),
-  metering: z18.object({
-    meters: z18.array(meterDefinitionSchema).max(10).default([]),
-    billOn4xx: z18.boolean().default(false)
+  metering: z19.object({
+    meters: z19.array(meterDefinitionSchema).max(10).default([]),
+    billOn4xx: z19.boolean().default(false)
   }).default({ meters: [], billOn4xx: false }),
   /**
    * BYO-Backend V1 — first-class backend declarations, keyed by backend id.
@@ -1939,7 +1919,7 @@ var productSpecSchema = z18.object({
    */
   backend: productBackendBlockSchema.optional(),
   usage: usageBlockSchema.optional(),
-  usagePricing: z18.never({
+  usagePricing: z19.never({
     error: "usagePricing is not supported. Define usage.meters.<key>.rating instead."
   }).optional(),
   features: featureCatalogSchema.optional(),
@@ -1960,53 +1940,51 @@ var productSpecSchema = z18.object({
   // billing shape via the unified 5-knob spec (`meters`,
   // `recurring_fee_cents`, `recurring_credit_grant_cents`,
   // `one_time_credit_grant_cents`, `trial_days`,
-  // `max_monthly_spend_cents`). The product-level `billing` block
-  // retains the transition-policy fields (`gracePeriodDays`,
-  // `subscriberChangePolicy`); the strategy enum is gone.
-  billing: z18.object({
-    gracePeriodDays: z18.number().int().nonnegative().default(3),
+  // `max_monthly_spend_cents`). The product-level `billing` block retains
+  // only the live transition-policy fields. v(refactor) — the inert
+  // `gracePeriodDays` knob was deleted (the compiler hardcoded it and
+  // Stripe Smart Retries owns dunning); the block now carries the
+  // subscriber-change timing policy + the limit-upgrade projection flag.
+  billing: z19.object({
     // When true (default), a plan limit INCREASE re-projects onto active
     // subscribers immediately; a DECREASE always defers to period end.
     // Read by advanceActiveSubscribersToLatestCompiledPlans.
-    applyLimitUpgradesInstantly: z18.boolean().optional(),
+    applyLimitUpgradesInstantly: z19.boolean().optional(),
     subscriberChangePolicy: subscriberChangePolicySchema.default({
-      default: "preserve_current_period",
-      proration: "none",
+      default: "period_end",
       when: {
-        price_increase: "preserve_current_period",
-        price_decrease: "switch_immediately",
-        feature_added: "switch_immediately",
-        feature_removed: "preserve_current_period",
-        limit_increased: "switch_immediately",
-        limit_reduced: "preserve_current_period",
-        credit_increased: "switch_immediately",
-        credit_reduced: "preserve_current_period",
-        rating_changed: "preserve_current_period"
+        price_increase: "period_end",
+        price_decrease: "immediate",
+        feature_added: "immediate",
+        feature_removed: "period_end",
+        limit_increased: "immediate",
+        limit_reduced: "period_end",
+        credit_increased: "immediate",
+        credit_reduced: "period_end",
+        rating_changed: "period_end"
       },
       allowImmediatePriceIncrease: false,
       allowImmediateEntitlementReduction: false
     })
   }).default({
-    gracePeriodDays: 3,
     subscriberChangePolicy: {
-      default: "preserve_current_period",
-      proration: "none",
+      default: "period_end",
       when: {
-        price_increase: "preserve_current_period",
-        price_decrease: "switch_immediately",
-        feature_added: "switch_immediately",
-        feature_removed: "preserve_current_period",
-        limit_increased: "switch_immediately",
-        limit_reduced: "preserve_current_period",
-        credit_increased: "switch_immediately",
-        credit_reduced: "preserve_current_period",
-        rating_changed: "preserve_current_period"
+        price_increase: "period_end",
+        price_decrease: "immediate",
+        feature_added: "immediate",
+        feature_removed: "period_end",
+        limit_increased: "immediate",
+        limit_reduced: "period_end",
+        credit_increased: "immediate",
+        credit_reduced: "period_end",
+        rating_changed: "period_end"
       },
       allowImmediatePriceIncrease: false,
       allowImmediateEntitlementReduction: false
     }
   }),
-  plans: z18.array(planSpecSchema).max(4).default([]),
+  plans: z19.array(planSpecSchema).max(4).default([]),
   /**
    * Add-on catalog (v0.56+). Composable economic + entitlement
    * overlays that subscribers can pile on top of their base plan.
@@ -2049,16 +2027,16 @@ var productSpecSchema = z18.object({
    *       require_deprecation_window_days: 90
    *       require_successor_route: true
    */
-  lifecycle: z18.object({
-    breaking_changes: z18.object({
+  lifecycle: z19.object({
+    breaking_changes: z19.object({
       /** Minimum days a route must have been marked for removal
        *  (in main-branch YAML) before the publish gate will let
        *  it actually be removed. Set to 0 to disable. */
-      require_deprecation_window_days: z18.number().int().nonnegative().default(0),
+      require_deprecation_window_days: z19.number().int().nonnegative().default(0),
       /** When true, a route removal must declare a successor
        *  route via the lifecycle metadata (mechanics in core
        *  3b-2) before the publish gate accepts it. */
-      require_successor_route: z18.boolean().default(false)
+      require_successor_route: z19.boolean().default(false)
     }).default({
       require_deprecation_window_days: 0,
       require_successor_route: false
@@ -2104,8 +2082,8 @@ var productSpecSchema = z18.object({
    * (preserves today's behaviour). Compiler validation pins the
    * value to a real `plans[].key`.
    */
-  ephemeral: z18.object({
-    defaultPlan: z18.string().min(1).optional()
+  ephemeral: z19.object({
+    defaultPlan: z19.string().min(1).optional()
   }).optional()
 }).superRefine((spec, ctx) => {
   rejectUsagePricing(spec, ctx);
@@ -2117,24 +2095,24 @@ var productSpecSchema = z18.object({
   validateLimitMeterReachability(spec, ctx);
   validateBackendReferences(spec, ctx);
 });
-var productPhaseSchema = z18.object({
+var productPhaseSchema = z19.object({
   product: productSpecSchema.shape.product
 });
-var gatewayPhaseSchema = z18.object({
+var gatewayPhaseSchema = z19.object({
   gateway: productSpecSchema.shape.gateway
 });
-var meteringPhaseSchema = z18.object({
+var meteringPhaseSchema = z19.object({
   metering: productSpecSchema.shape.metering
 });
-var plansPhaseSchema = z18.object({
+var plansPhaseSchema = z19.object({
   plans: productSpecSchema.shape.plans
 });
 
 // ../contracts/dist/plans/spec/capabilities-layer.js
-import { z as z19 } from "zod";
-var capabilityLayerSchema = z19.object({
-  capability: z19.string().min(1).max(120).regex(/^[a-z0-9_-]+$/, "capability name must be lowercase alphanumeric with hyphens/underscores"),
-  description: z19.string().max(500).optional(),
+import { z as z20 } from "zod";
+var capabilityLayerSchema = z20.object({
+  capability: z20.string().min(1).max(120).regex(/^[a-z0-9_-]+$/, "capability name must be lowercase alphanumeric with hyphens/underscores"),
+  description: z20.string().max(500).optional(),
   /**
    * Capability composition is contractual by default — including a new
    * feature changes the customer's effective entitlement. Mark
@@ -2142,28 +2120,28 @@ var capabilityLayerSchema = z19.object({
    * (e.g. an internal "monitoring" capability that gates dashboard
    * pages without affecting billable behaviour).
    */
-  mutation_class: z19.enum(["runtime", "contractual"]).default("contractual"),
-  includes_features: z19.array(z19.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/)).max(20).default([]),
-  includes_policies: z19.array(z19.string().min(1).max(64).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
-  includes_capabilities: z19.array(z19.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(20).default([])
+  mutation_class: z20.enum(["runtime", "contractual"]).default("contractual"),
+  includes_features: z20.array(z20.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/)).max(20).default([]),
+  includes_policies: z20.array(z20.string().min(1).max(64).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
+  includes_capabilities: z20.array(z20.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(20).default([])
 });
 
 // ../contracts/dist/plans/spec/manifest-ir.js
 import { createHash } from "node:crypto";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var MANIFEST_IR_VERSION = 1;
-var manifestIrSchema = z20.object({
-  irVersion: z20.literal(MANIFEST_IR_VERSION),
+var manifestIrSchema = z21.object({
+  irVersion: z21.literal(MANIFEST_IR_VERSION),
   /** Version of @farthershore/product that emitted this envelope. */
-  sdkVersion: z20.string().min(1).max(64),
+  sdkVersion: z21.string().min(1).max(64),
   /** Legacy unified ProductSpec — the live `CompileProductOptions.sourceSpec`. */
   product: productSpecSchema,
   /** One entry per feature, sorted by `feature`. */
-  routes: z20.array(routeLayerSchema).max(200).default([]),
+  routes: z21.array(routeLayerSchema).max(200).default([]),
   /** Sorted by `name`. */
-  policies: z20.array(policyLayerSchema).max(200).default([]),
+  policies: z21.array(policyLayerSchema).max(200).default([]),
   /** Sorted by `capability`. */
-  capabilities: z20.array(capabilityLayerSchema).max(200).default([])
+  capabilities: z21.array(capabilityLayerSchema).max(200).default([])
 }).strict();
 function canonicalManifestJson(value) {
   return stableJson(JSON.parse(JSON.stringify(value)));
@@ -2203,7 +2181,7 @@ var STARTER = {
     ],
     recurring_fee_cents: 2e3,
     billing_interval: "month",
-    grants: [{ kind: "recurring", amount_cents: 2e3 }],
+    grants: [{ kind: "credit", amount_cents: 2e3, recurs: true }],
     trial_days: 0
   }
 };
@@ -2217,7 +2195,7 @@ var PRO = {
     ],
     recurring_fee_cents: 1e4,
     billing_interval: "month",
-    grants: [{ kind: "recurring", amount_cents: 2e4 }],
+    grants: [{ kind: "credit", amount_cents: 2e4, recurs: true }],
     trial_days: 14
   }
 };
@@ -2231,7 +2209,7 @@ var PREPAID = {
     ],
     recurring_fee_cents: 0,
     billing_interval: "month",
-    grants: [{ kind: "one_time", amount_cents: 5e3 }],
+    grants: [{ kind: "credit", amount_cents: 5e3, recurs: false }],
     trial_days: 0
   }
 };
@@ -2258,28 +2236,31 @@ var PLAN_PRESETS = Object.freeze({
 });
 
 // ../contracts/dist/plans/subscription-pricing-override.js
-import { z as z21 } from "zod";
-var subscriptionPricingOverrideSchema = z21.object({
+import { z as z22 } from "zod";
+var subscriptionPricingOverrideSchema = z22.object({
   /** Override the plan's recurring fee for this subscriber. */
-  recurring_fee_cents: z21.number().int().nonnegative().optional(),
+  recurring_fee_cents: z22.number().int().nonnegative().optional(),
   /**
    * Override the plan's credit grants. `grants[]` is the single credit
    * surface — when present, it fully replaces the plan's grants for this
    * subscriber (recurring + one-time credit are canonical entries here;
    * the legacy recurring/one-time scalar knobs were removed).
    */
-  grants: z21.array(grantSchema).max(40).optional(),
+  grants: z22.array(grantSchema).max(40).optional(),
+  /** Override the plan's credit-policy block (rollover + auto-recharge)
+   *  for this subscriber. */
+  creditPolicy: creditPolicySchema.optional(),
   /** Override the minimum-spend floor. */
-  min_monthly_spend_cents: z21.number().int().nonnegative().optional(),
+  min_monthly_spend_cents: z22.number().int().nonnegative().optional(),
   /** Override the maximum-spend ceiling. */
-  max_monthly_spend_cents: z21.number().int().nonnegative().optional(),
+  max_monthly_spend_cents: z22.number().int().nonnegative().optional(),
   /** Replace the entire meter list for this subscriber. When set, the
    *  full plan meter array is replaced (not merged) — call it explicit
    *  rather than implicit so a deal can also REMOVE billable meters,
    *  not just adjust rates. */
-  meters: z21.array(meterSchema).optional(),
+  meters: z22.array(meterSchema).optional(),
   /** Free-text notes about the deal. Surfaced in admin UI for audit. */
-  notes: z21.string().max(2e3).optional()
+  notes: z22.string().max(2e3).optional()
 });
 
 // src/validate.ts
@@ -2305,7 +2286,7 @@ function hashIr(ir) {
 }
 
 // src/version.ts
-var SDK_VERSION = true ? "0.6.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.6.1" : "0.0.0-dev";
 
 // src/refs.ts
 function isCapabilityGrant(value) {
@@ -3061,6 +3042,7 @@ function buildPlanSpec(key, options) {
     } : {},
     ...options.meters ? { meters: options.meters } : {},
     ...creditGrants.length ? { grants: creditGrants } : {},
+    ...options.creditPolicy ? { creditPolicy: options.creditPolicy } : {},
     ...options.trialDays !== void 0 ? { trial_days: options.trialDays } : {},
     ...options.maxMonthlySpendCents !== void 0 ? { max_monthly_spend_cents: options.maxMonthlySpendCents } : {},
     ...options.minMonthlySpendCents !== void 0 ? { min_monthly_spend_cents: options.minMonthlySpendCents } : {},