@farthershore/product 0.5.0 → 0.6.1

package/dist/index.js

@@ -146,15 +146,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(),
@@ -166,24 +160,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"],
@@ -195,7 +185,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],
@@ -206,30 +196,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"),
@@ -242,67 +224,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(),
@@ -316,7 +306,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({
@@ -367,99 +357,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:
@@ -473,22 +470,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)
   // ---------------------------------------------------------------------
@@ -502,7 +499,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
@@ -510,8 +507,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+).
    *
@@ -541,9 +538,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.
    *
@@ -555,7 +552,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
@@ -565,11 +562,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) => {
@@ -577,10 +574,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",
@@ -591,26 +588,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
@@ -623,22 +620,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(),
@@ -646,35 +643,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 z13 } 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",
@@ -704,31 +704,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) => {
@@ -760,32 +760,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) {
@@ -796,21 +799,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)) {
@@ -825,18 +828,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) {
@@ -854,23 +857,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"),
@@ -878,43 +881,403 @@ 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 z14 } from "zod";
+var BACKEND_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+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 = z14.enum([
+  "managed_cloudflared",
+  "sidecar"
+]);
+var backendTransportSchema = z14.object({
+  mode: backendTransportModeSchema.default("public_origin"),
+  runner: backendTransportRunnerSchema.optional()
+}).strict();
+var backendVerificationSchema = z14.object({
+  required: z14.boolean().default(false)
+}).strict();
+var backendDefinitionSchema = z14.object({
+  /** Human-friendly label. Defaults to the id when omitted. */
+  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: 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: z14.boolean().optional(),
+  /** Reachable origin for `public_origin` / `mtls`. */
+  originUrl: z14.string().url().optional(),
+  /** Access-protected `*.fs-origin` host for `cloudflare_tunnel`. */
+  originHostname: z14.string().min(1).max(255).optional()
+}).strict();
+var productBackendBlockSchema = z14.record(backendIdSchema, backendDefinitionSchema);
+var routeBackendBindingSchema = backendIdSchema;
+var BACKEND_DIAGNOSTIC_CODES = {
+  unknownBackendInRoute: "UNKNOWN_BACKEND_IN_ROUTE",
+  ambiguousDefaultBackend: "AMBIGUOUS_DEFAULT_BACKEND",
+  routeMeterNotAllowedByBackend: "ROUTE_METER_NOT_ALLOWED_BY_BACKEND",
+  unknownMeterInBackend: "UNKNOWN_METER_IN_BACKEND"
+};
+function resolveDefaultBackendId(backends) {
+  const ids = Object.keys(backends ?? {});
+  if (ids.length === 0)
+    return { defaultId: null, ambiguous: false };
+  if (ids.length === 1)
+    return { defaultId: ids[0], ambiguous: false };
+  const explicit = ids.filter((id) => backends[id]?.default === true);
+  if (explicit.length === 1) {
+    return { defaultId: explicit[0], ambiguous: false };
+  }
+  return { defaultId: null, ambiguous: true };
+}
+
+// ../contracts/dist/plans/spec/routes-layer.js
+import { z as z18 } from "zod";
+
+// ../contracts/dist/plans/spec/policies-layer.js
+import { z as z16 } from "zod";
+
+// ../contracts/dist/plans/spec/policy-types.js
+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
+   * change. The `subscription` dimension is the steady-state default;
+   * `ip` is for unauthenticated probes; `credential` is finer-grained
+   * than subscription (per-key throttling).
+   */
+  dimensions: z15.array(z15.enum(["subscription", "credential", "ip", "route"])).min(1).max(4).default(["subscription"]),
+  limits: z15.array(z15.object({
+    window: rateLimitWindowSchema,
+    max: z15.number().int().positive().max(1e7)
+  })).min(1).max(10),
+  /**
+   * Bounded fail-open behaviour for DO outages. See architecture RFC
+   * "Fail-open guardrails" section. When the policy executor observes
+   * `max_consecutive_failures` DO-call failures within
+   * `max_window_seconds`, it transitions to `degraded_mode` until
+   * `recovery_threshold` consecutive successes restore normal
+   * evaluation.
+   */
+  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"
+    ]).default("safe_mode_throttle")
+  }).default({
+    max_consecutive_failures: 100,
+    max_window_seconds: 60,
+    recovery_threshold: 50,
+    degraded_mode: "safe_mode_throttle"
+  })
+});
+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: 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" }),
+  /**
+   * When `true`, treat the inbound credential's scopes (if any) as
+   * additional gating beyond the entitlement check. v0.3.0 ships with
+   * `strict` as the default.
+   */
+  scope_mode: z15.enum(["strict", "advisory", "off"]).default("strict")
+});
+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: 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: 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: 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"
+    ]).default("safe_mode_throttle")
+  }).default({
+    max_consecutive_failures: 50,
+    max_window_seconds: 60,
+    recovery_threshold: 20,
+    degraded_mode: "safe_mode_throttle"
+  })
+});
+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: 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: 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,
+    jitter: "equal",
+    total_budget_ms: 5e3
+  })
+});
+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: 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: 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 = 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 = 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 = 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: 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
+   * by nature so the default is `runtime`. Marking a policy as
+   * `contractual` signals that changes to it require human approval
+   * (invariant #16).
+   */
+  mutation_class: z16.enum(["runtime", "contractual"]).default("runtime"),
+  cacheProfile: cacheProfileSchema
+}), policyBodySchema);
+
+// ../contracts/dist/framework/actions/index.js
+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: z17.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
+  subject: actionSubjectBindingSchema.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 = 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();
+  if (!trimmed)
+    return false;
+  const [startRaw, endRaw, extra] = trimmed.split("-");
+  if (extra !== void 0 || !/^\d{3}$/.test(startRaw ?? ""))
+    return false;
+  const start = Number(startRaw);
+  const end = endRaw === void 0 ? start : Number(endRaw);
+  if (endRaw !== void 0 && !/^\d{3}$/.test(endRaw))
+    return false;
+  return start >= 100 && start <= 599 && end >= 100 && end <= 599 && start <= end;
+}
+function isRouteStatusCodePolicyString(value) {
+  return value.split(",").every(statusPolicyPartIsValid);
+}
+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"
+  }),
+  z18.array(z18.number().int().min(100).max(599)).min(1).max(100)
+]);
+var routeDefinitionSchema = z18.object({
+  match: routeMatchSchema,
+  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: z18.boolean().optional(),
+  inheritDefaultMeters: z18.boolean().optional(),
+  /** Optional explicit action id. When absent, the compiler derives an
+   *  implicit action from feature + method + path. */
+  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 = z18.object({
+  override_origin: z18.string().url("override_origin must be a valid URL").nullable().default(null)
+});
+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: z18.array(z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(10).optional()
 });
+var routeLayerSchema = z18.object({
+  /**
+   * Feature key — the entitlement unit. Surfaced in dashboards,
+   * subscriptions, and the gateway's matched-route trace.
+   */
+  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: z18.enum(["runtime", "contractual"]).default("contractual"),
+  cacheProfile: cacheProfileSchema,
+  routes: z18.array(routeDefinitionSchema).min(1).max(50),
+  upstream: routeUpstreamSchema.default({ override_origin: null }),
+  /**
+   * Ordered list of policy names to apply. Executed sequentially by
+   * the gateway policy engine; first-deny wins. Referenced policies
+   * MUST declare compatible `compatible_with` envelopes for this
+   * feature's route/meter shape — the compiler enforces.
+   */
+  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: 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: 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. */
+  backend: routeBackendBindingSchema.optional()
+}).strict();
 
 // ../contracts/dist/plans/spec/refinements.js
 function rejectUsagePricing(spec, ctx) {
@@ -1158,6 +1521,68 @@ function validateLimitMeterReachability(spec, ctx) {
     });
   });
 }
+function validateBackendReferences(spec, ctx) {
+  const backends = spec.backend;
+  if (!backends || Object.keys(backends).length === 0)
+    return;
+  const backendIds = new Set(Object.keys(backends));
+  const productMeterKeys = new Set((spec.metering?.meters ?? []).map((m) => m.key).filter((k) => typeof k === "string" && k.length > 0));
+  for (const [backendId, backend] of Object.entries(backends)) {
+    (backend.meters ?? []).forEach((meter, meterIdx) => {
+      if (productMeterKeys.has(meter))
+        return;
+      ctx.addIssue({
+        code: "custom",
+        path: ["backend", backendId, "meters", meterIdx],
+        message: `${BACKEND_DIAGNOSTIC_CODES.unknownMeterInBackend}: backend "${backendId}" allows meter "${meter}" but no metering.meters[] entry declares it.`
+      });
+    });
+  }
+  const { defaultId, ambiguous } = resolveDefaultBackendId(backends);
+  let anyRouteOmitsBinding = false;
+  for (const feature of Object.values(spec.features ?? {})) {
+    for (const route of feature.routes ?? []) {
+      if (route.backend === void 0)
+        anyRouteOmitsBinding = true;
+    }
+  }
+  if (ambiguous && anyRouteOmitsBinding) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["backend"],
+      message: `${BACKEND_DIAGNOSTIC_CODES.ambiguousDefaultBackend}: product declares ${backendIds.size} backends but no single default \u2014 mark exactly one backend \`default: true\` or bind every route explicitly.`
+    });
+  }
+  for (const [featureKey, feature] of Object.entries(spec.features ?? {})) {
+    (feature.routes ?? []).forEach((route, routeIdx) => {
+      const boundId = route.backend ?? defaultId;
+      if (route.backend !== void 0 && !backendIds.has(route.backend)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["features", featureKey, "routes", routeIdx, "backend"],
+          message: `${BACKEND_DIAGNOSTIC_CODES.unknownBackendInRoute}: route binds backend "${route.backend}" which is not declared in the product \`backend\` block.`
+        });
+        return;
+      }
+      if (!boundId)
+        return;
+      const backend = backends[boundId];
+      const allow = backend?.meters;
+      if (!allow)
+        return;
+      const allowed = new Set(allow);
+      for (const meter of routeMeterKeys(route)) {
+        if (allowed.has(meter))
+          continue;
+        ctx.addIssue({
+          code: "custom",
+          path: ["features", featureKey, "routes", routeIdx, "metering"],
+          message: `${BACKEND_DIAGNOSTIC_CODES.routeMeterNotAllowedByBackend}: route meters "${meter}" but backend "${boundId}" does not allow it (backend.meters[] = [${allow.join(", ")}]).`
+        });
+      }
+    });
+  }
+}
 function planMonthlyPrice(plan) {
   return plan.recurring_fee_cents;
 }
@@ -1167,18 +1592,18 @@ function planPriceKey(plan, monthly) {
 }
 
 // ../contracts/dist/plans/spec/product.js
-var productIdentitySchema = z13.object({
-  subdomain: z13.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 = z13.enum([
+var meterEnforcementTypeSchema = z19.enum([
   "exact_pre_request",
   "estimated_then_settled",
   "postpaid",
   "strict_concurrency"
 ]);
-var meterDefinitionSchema = z13.object({
-  key: z13.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Meter key must be lowercase alphanumeric with underscores"),
-  display: z13.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
@@ -1186,11 +1611,11 @@ var meterDefinitionSchema = z13.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: z13.string().max(20).optional(),
+  unit: z19.string().max(20).optional(),
   /** Reusable pre-request estimate for routes that dynamically report this meter. */
-  estimate: z13.number().finite().nonnegative().optional(),
+  estimate: z19.number().finite().nonnegative().optional(),
   /** Fixed per-request default applied by Product SDK helpers. */
-  routeDefault: z13.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,
@@ -1215,7 +1640,7 @@ var meterDefinitionSchema = z13.object({
    * current `window`. Defaults to `COUNT` (one event = one unit) so
    * existing meters that didn't declare aggregation continue to work.
    */
-  aggregation: z13.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.
@@ -1223,91 +1648,65 @@ var meterDefinitionSchema = z13.object({
    * rate-limit-shaped meters where the period boundary is a fixed
    * wall-clock interval, not the subscription anniversary.
    */
-  window: z13.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: z13.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: z13.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: z13.array(z13.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: z13.string().optional()
-});
-var usageMeasureSchema = z13.string().min(1).max(64).regex(/^[a-z0-9_]+$/, "Usage measure must be lowercase alphanumeric with underscores");
-var usageRatingPricePolicySchema = z13.enum([
-  "pass_through",
-  "markup",
-  "fixed_margin",
-  "customer_rate"
-]);
-var fixedRatingSchema = z13.object({
-  source: z13.literal("fixed"),
-  rates: z13.record(z13.string().min(1), z13.record(usageMeasureSchema, z13.number().int().nonnegative()))
-});
-var providerCatalogRatingSchema = z13.object({
-  source: z13.literal("provider_catalog"),
-  catalog: z13.string().min(1).max(100),
-  pricePolicy: usageRatingPricePolicySchema.default("pass_through"),
-  markupPercent: z13.number().nonnegative().max(1e4).optional(),
-  marginMicros: z13.number().int().nonnegative().optional()
-});
-var upstreamReportedRatingSchema = z13.object({
-  source: z13.literal("upstream_reported"),
-  amountField: z13.string().min(1).max(500),
-  currencyField: z13.string().min(1).max(500).optional()
+  eventCode: z19.string().optional()
 });
-var externalRateApiRatingSchema = z13.object({
-  source: z13.literal("external_rate_api"),
-  resolver: z13.string().min(1).max(100),
-  configRef: z13.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 = z13.object({
-  source: z13.literal("custom"),
-  resolver: z13.string().min(1).max(100),
-  configRef: z13.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 = z13.discriminatedUnion("source", [
+var usageRatingSchema = z19.discriminatedUnion("source", [
   fixedRatingSchema,
-  providerCatalogRatingSchema,
-  upstreamReportedRatingSchema,
-  externalRateApiRatingSchema,
-  customRatingSchema
+  providerCatalogRatingSchema
 ]);
-var usageMeterSchema = z13.object({
-  selector: z13.string().min(1).max(100).optional(),
-  measures: z13.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 = z13.object({
-  meters: z13.record(z13.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 = z13.object({
-  defaults: z13.record(z13.string().min(1).max(64), z13.number().finite().nonnegative()).optional(),
-  reports: z13.array(z13.string().min(1).max(64)).max(20).optional(),
-  estimates: z13.record(z13.string().min(1).max(64), z13.number().finite().nonnegative()).optional(),
-  onStatusCodes: z13.union([
-    z13.string().min(1).max(100),
-    z13.array(z13.number().int().min(100).max(599)).min(1).max(100)
-  ]).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 = z13.object({
-  method: z13.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/*
@@ -1315,44 +1714,48 @@ var featureRouteSchema = z13.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: z13.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: z13.boolean().optional(),
+  unmetered: z19.boolean().optional(),
   metering: routeMeteringSchema.optional(),
-  inheritDefaultMeters: z13.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 = z13.object({
+var featureCatalogEntrySchema = z19.object({
   // Optional human-friendly summary; surfaced in dashboards / settings UI.
-  description: z13.string().max(500).optional(),
-  routes: z13.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: z13.array(z13.string().min(1)).min(1).max(20)
+  plans: z19.array(z19.string().min(1)).min(1).max(20)
 });
-var featureCatalogSchema = z13.record(z13.string().min(1).max(100).regex(/^[a-z0-9_.:-]+$/), featureCatalogEntrySchema);
-var productCleanupPolicyModeSchema = z13.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 = z13.enum([
+var productChangeApprovalRiskSchema = z19.enum([
   "safe",
   "non_blocking",
   "economic_risk",
   "blocking"
 ]);
-var productOperatorPoliciesSchema = z13.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: z13.object({
-    enabled: z13.boolean().default(false),
+  cleanup: z19.object({
+    enabled: z19.boolean().default(false),
     mode: productCleanupPolicyModeSchema.default("report")
   }).default({ enabled: false, mode: "report" }),
   /**
@@ -1360,9 +1763,9 @@ var productOperatorPoliciesSchema = z13.object({
    * the policy a first-class product-as-code field even while enforcement is
    * still report/label-only.
    */
-  change_approval: z13.object({
-    auto_merge_max_risk: z13.enum(["none", "safe", "non_blocking"]).default("none"),
-    require_human_for: z13.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"]
@@ -1374,15 +1777,15 @@ var productOperatorPoliciesSchema = z13.object({
     require_human_for: ["economic_risk", "blocking"]
   }
 });
-var customerIdentityRequirementSchema = z13.enum([
+var customerIdentityRequirementSchema = z19.enum([
   "org_only",
   "org_and_user"
 ]);
-var customerPortalAuthStrategySchema = z13.enum([
+var customerPortalAuthStrategySchema = z19.enum([
   "clerk",
   "test-personas"
 ]);
-var productCustomerContextSchema = z13.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
@@ -1394,19 +1797,19 @@ var productCustomerContextSchema = z13.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: z13.object({
-    enabled: z13.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: z13.object({
+  portal_auth: z19.object({
     strategy: customerPortalAuthStrategySchema
   }).optional()
 });
-var productSurfaceTypeSchema = z13.enum([
+var productSurfaceTypeSchema = z19.enum([
   "frontend",
   "api",
   "docs",
@@ -1416,87 +1819,99 @@ var productSurfaceTypeSchema = z13.enum([
   "worker",
   "agent"
 ]);
-var productSurfaceSchema = z13.object({
-  key: z13.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: z13.string().min(1).max(100).optional(),
-  description: z13.string().max(500).optional()
+  display: z19.string().min(1).max(100).optional(),
+  description: z19.string().max(500).optional()
 });
-var productEntitlementSchema = z13.object({
-  key: z13.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Entitlement key must be lowercase alphanumeric with hyphens/underscores"),
-  description: z13.string().max(500).optional(),
-  capabilities: z13.array(z13.string().min(1).max(100)).max(100).optional(),
-  featureGates: z13.record(z13.string().min(1), z13.boolean()).optional(),
-  limits: z13.array(planLimitRuleSchema).max(100).optional(),
-  meters: z13.array(z13.string().min(1).max(64)).max(100).optional()
-});
-var productSurfacesSchema = z13.array(productSurfaceSchema).max(20).default([]);
-var productEntitlementsSchema = z13.array(productEntitlementSchema).max(100).default([]);
-var productWorkflowKindSchema = z13.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 = z13.discriminatedUnion("type", [
-  z13.object({ type: z13.literal("manual") }),
-  z13.object({
-    type: z13.literal("schedule"),
-    cron: z13.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)
   }),
-  z13.object({
-    type: z13.literal("event"),
-    event: z13.string().min(1).max(120)
+  z19.object({
+    type: z19.literal("event"),
+    event: z19.string().min(1).max(120)
   }),
-  z13.object({
-    type: z13.literal("api"),
-    path: z13.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 /")
   }),
-  z13.object({
-    type: z13.literal("lifecycle"),
-    event: z13.string().min(1).max(120)
+  z19.object({
+    type: z19.literal("lifecycle"),
+    event: z19.string().min(1).max(120)
   })
 ]);
-var productWorkflowSchema = z13.object({
-  key: z13.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Workflow key must be lowercase alphanumeric with hyphens/underscores"),
-  title: z13.string().min(1).max(120).optional(),
-  description: z13.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: z13.array(z13.string().min(1).max(100)).max(100).optional(),
-  meters: z13.array(z13.string().min(1).max(64)).max(100).optional(),
-  estimates: z13.record(z13.string().min(1).max(64), z13.number().finite()).optional(),
-  metadata: z13.record(z13.string().min(1), z13.unknown()).optional()
-});
-var productWorkflowsSchema = z13.array(productWorkflowSchema).max(100).default([]);
-var productSpecSchema = z13.object({
-  product: z13.object({
-    name: z13.string().min(1).max(100),
-    displayName: z13.string().max(200).optional(),
-    description: z13.string().max(2e3).optional(),
-    baseUrl: z13.string().url("baseUrl must be a valid URL"),
-    sandboxBaseUrl: z13.string().url("sandboxBaseUrl must be a valid URL").optional(),
-    visibility: z13.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: z13.string().url().optional(),
-    primaryColor: z13.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: z13.string().max(50).nullable().optional()
+    envBranchPrefix: z19.string().max(50).nullable().optional()
   }),
-  gateway: z13.object({
-    authHeader: z13.string().min(1).max(100).default("x-api-key"),
-    upstreamAuth: z13.object({
-      type: z13.enum(["none", "static_bearer"]),
-      token: z13.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: z13.object({
-    meters: z13.array(meterDefinitionSchema).max(10).default([]),
-    billOn4xx: z13.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.
+   * A product may declare MULTIPLE backends; routes bind to one (a default
+   * applies when a product has exactly one backend OR exactly one is marked
+   * `default: true`). Single-backend products stay zero-config.
+   *
+   * OPTIONAL and emits NO key when absent — a product with no `backend`
+   * block hashes byte-identically to the pre-BYOB world. Cross-reference
+   * validation (route→backend resolution, route-meter ∈ backend `meters[]`,
+   * unambiguous default) lives in `validateBackendReferences`.
+   */
+  backend: productBackendBlockSchema.optional(),
   usage: usageBlockSchema.optional(),
-  usagePricing: z13.never({
+  usagePricing: z19.never({
     error: "usagePricing is not supported. Define usage.meters.<key>.rating instead."
   }).optional(),
   features: featureCatalogSchema.optional(),
@@ -1517,53 +1932,51 @@ var productSpecSchema = z13.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: z13.object({
-    gracePeriodDays: z13.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: z13.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: z13.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.
@@ -1606,16 +2019,16 @@ var productSpecSchema = z13.object({
    *       require_deprecation_window_days: 90
    *       require_successor_route: true
    */
-  lifecycle: z13.object({
-    breaking_changes: z13.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: z13.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: z13.boolean().default(false)
+      require_successor_route: z19.boolean().default(false)
     }).default({
       require_deprecation_window_days: 0,
       require_successor_route: false
@@ -1661,8 +2074,8 @@ var productSpecSchema = z13.object({
    * (preserves today's behaviour). Compiler validation pins the
    * value to a real `plans[].key`.
    */
-  ephemeral: z13.object({
-    defaultPlan: z13.string().min(1).optional()
+  ephemeral: z19.object({
+    defaultPlan: z19.string().min(1).optional()
   }).optional()
 }).superRefine((spec, ctx) => {
   rejectUsagePricing(spec, ctx);
@@ -1672,421 +2085,26 @@ var productSpecSchema = z13.object({
   validateFeatureReferences(spec, ctx);
   validateRouteMeters(spec, ctx);
   validateLimitMeterReachability(spec, ctx);
+  validateBackendReferences(spec, ctx);
 });
-var productPhaseSchema = z13.object({
+var productPhaseSchema = z19.object({
   product: productSpecSchema.shape.product
 });
-var gatewayPhaseSchema = z13.object({
+var gatewayPhaseSchema = z19.object({
   gateway: productSpecSchema.shape.gateway
 });
-var meteringPhaseSchema = z13.object({
+var meteringPhaseSchema = z19.object({
   metering: productSpecSchema.shape.metering
 });
-var plansPhaseSchema = z13.object({
+var plansPhaseSchema = z19.object({
   plans: productSpecSchema.shape.plans
 });
 
-// ../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"),
-  /**
-   * Which request dimensions identify the bucket. v0.3.0 supports a
-   * fixed set; extending requires a coordinated gateway/policy-engine
-   * change. The `subscription` dimension is the steady-state default;
-   * `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({
-    window: rateLimitWindowSchema,
-    max: z14.number().int().positive().max(1e7)
-  })).min(1).max(10),
-  /**
-   * Bounded fail-open behaviour for DO outages. See architecture RFC
-   * "Fail-open guardrails" section. When the policy executor observes
-   * `max_consecutive_failures` DO-call failures within
-   * `max_window_seconds`, it transitions to `degraded_mode` until
-   * `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([
-      "safe_mode_block",
-      "safe_mode_throttle",
-      "runtime_killswitch_trigger"
-    ]).default("safe_mode_throttle")
-  }).default({
-    max_consecutive_failures: 100,
-    max_window_seconds: 60,
-    recovery_threshold: 50,
-    degraded_mode: "safe_mode_throttle"
-  })
-});
-var authConfigSchema = z14.object({
-  header_name: z14.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")
-    })
-  ]).default({ type: "none" }),
-  /**
-   * When `true`, treat the inbound credential's scopes (if any) as
-   * additional gating beyond the entitlement check. v0.3.0 ships with
-   * `strict` as the default.
-   */
-  scope_mode: z14.enum(["strict", "advisory", "off"]).default("strict")
-});
-var concurrencyConfigSchema = z14.object({
-  max_in_flight: z14.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"]),
-  /**
-   * 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(),
-  /**
-   * 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([
-      "safe_mode_block",
-      "safe_mode_throttle",
-      "runtime_killswitch_trigger"
-    ]).default("safe_mode_throttle")
-  }).default({
-    max_consecutive_failures: 50,
-    max_window_seconds: 60,
-    recovery_threshold: 20,
-    degraded_mode: "safe_mode_throttle"
-  })
-});
-var retryConfigSchema = z14.object({
-  max_attempts: z14.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]),
-  /**
-   * 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)
-  }).default({
-    initial_ms: 100,
-    multiplier: 2,
-    jitter: "equal",
-    total_budget_ms: 5e3
-  })
-});
-var transformConfigSchema = z14.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"),
-  /**
-   * 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()
-  })).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 })
-]);
-
-// ../contracts/dist/plans/spec/policies-layer.js
-import { z as z15 } from "zod";
-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 policyFileSchema = z15.intersection(z15.object({
-  /**
-   * Policy name. Referenced by routes via `policies: [<name>]`. Must
-   * be unique across the product; the compiler enforces this in the
-   * cross-file 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(),
-  compatible_with: policyCompatibilitySchema.default({}),
-  /**
-   * Mutation class — runtime vs contractual. Policies are operational
-   * by nature so the default is `runtime`. Marking a policy as
-   * `contractual` signals that changes to it require human approval
-   * (invariant #16).
-   */
-  mutation_class: z15.enum(["runtime", "contractual"]).default("runtime"),
-  cacheProfile: cacheProfileSchema
-}), policyBodySchema);
-
-// ../contracts/dist/plans/spec/routes-layer.js
-import { z as z17 } from "zod";
-
-// ../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(),
-  kind: actionKindSchema,
-  actorType: z16.string().min(1).max(64).regex(/^[a-zA-Z0-9_.:-]+$/).optional(),
-  subject: actionSubjectBindingSchema.optional(),
-  inputSchemaRef: z16.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 routeDefinitionSchema = z17.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(),
-    onStatusCodes: z17.union([
-      z17.string().min(1).max(100),
-      z17.array(z17.number().int().min(100).max(599)).min(1).max(100)
-    ]).optional()
-  }).optional(),
-  unmetered: z17.boolean().optional(),
-  inheritDefaultMeters: z17.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()
-}).strict();
-var routeUpstreamSchema = z17.object({
-  override_origin: z17.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(),
-  /**
-   * 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()
-});
-var routesFileSchema = z17.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(),
-  /**
-   * 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"),
-  cacheProfile: cacheProfileSchema,
-  routes: z17.array(routeDefinitionSchema).min(1).max(50),
-  upstream: routeUpstreamSchema.default({ override_origin: null }),
-  /**
-   * Ordered list of policy names to apply. Executed sequentially by
-   * the gateway policy engine; first-deny wins. Referenced policies
-   * 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([]),
-  runtime: routeRuntimeSchema.default({}),
-  /**
-   * Capability groups this feature joins. A plan that includes any
-   * referenced capability grants this feature. Capabilities are
-   * resolved at compile time into the plan's expanded feature set.
-   */
-  capabilities: z17.array(z17.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
-  /**
-   * Plans that grant this feature directly (in addition to capability
-   * membership). Mirrors the legacy `featureCatalogEntrySchema.plans`
-   * field for the common case where the feature isn't part of any
-   * shared capability group.
-   *
-   * v0.3.0 keeps direct-plan binding for migration ergonomics; v0.4
-   * may deprecate this in favour of capability-only composition.
-   */
-  plans: z17.array(z17.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()
-});
-
-// ../contracts/dist/plans/spec/runtime-layer.js
-import { z as z18 } from "zod";
-var keyNameSchema = z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/, "runtime key must be lowercase alphanumeric with hyphens/underscores");
-var dependsOnSchema = z18.object({
-  runtime_flags: z18.array(keyNameSchema).max(10).optional(),
-  capabilities: z18.array(z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(10).optional()
-}).default({});
-var audienceSchema = z18.object({
-  plans: z18.array(z18.string().min(1).max(64)).max(20).optional(),
-  environments: z18.array(z18.string().min(1).max(64)).max(10).optional(),
-  capabilities: z18.array(z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(10).optional()
-}).default({});
-var rolloutDefaultsSchema = z18.object({
-  missing_behavior: z18.enum(["treat_as_zero_percent", "treat_as_full_rollout", "fail_closed"]).default("treat_as_zero_percent"),
-  stale_behavior: z18.enum(["use_last_known", "fail_closed_on_signature"]).default("use_last_known")
-});
-var rolloutEntrySchema = z18.object({
-  description: z18.string().max(500).optional(),
-  audience: audienceSchema,
-  /**
-   * Rollout percentage (0-100). 0 = no subscribers in treatment;
-   * 100 = full rollout. Cohort stability invariant #20: increasing
-   * the percent admits more subscribers (existing stay); decreasing
-   * drops subscribers whose deterministic bucket is above the new
-   * boundary (logged as an audit event).
-   */
-  percent: z18.number().int().min(0).max(100),
-  /**
-   * Seed for the deterministic SHA-256 hash that computes bucket
-   * assignment. Rotating the seed is a destructive rebucketing
-   * operation; the workflow runner refuses without approval metadata
-   * (invariant #16).
-   */
-  assignment_seed: z18.string().min(1).max(120).default("default"),
-  depends_on: dependsOnSchema,
-  defaults: rolloutDefaultsSchema.default({
-    missing_behavior: "treat_as_zero_percent",
-    stale_behavior: "use_last_known"
-  })
-});
-var runtimeRolloutFileSchema = z18.object({
-  cacheProfile: cacheProfileSchema.default("blocking"),
-  rollouts: z18.record(keyNameSchema, rolloutEntrySchema).default({})
-});
-var flagDefaultsSchema = z18.object({
-  missing_behavior: z18.enum(["disabled", "enabled", "fail_closed"]).default("disabled"),
-  stale_behavior: z18.enum(["use_last_known", "fail_closed_on_signature"]).default("use_last_known")
-});
-var flagEntrySchema = z18.object({
-  description: z18.string().max(500).optional(),
-  enabled: z18.boolean(),
-  audience: audienceSchema,
-  depends_on: dependsOnSchema,
-  defaults: flagDefaultsSchema.default({
-    missing_behavior: "disabled",
-    stale_behavior: "use_last_known"
-  }),
-  /**
-   * When set, this flag acts as a killswitch — its `enabled: true`
-   * disables traffic for the referenced subjects. Useful for
-   * incident response (`policy_premium-rate-limit_emergency_off`).
-   */
-  killswitch_target: z18.object({
-    kind: z18.enum(["policy", "route", "rollout"]),
-    name: z18.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)
-  }).optional()
-});
-var runtimeFlagsFileSchema = z18.object({
-  cacheProfile: cacheProfileSchema.default("blocking"),
-  flags: z18.record(keyNameSchema, flagEntrySchema).default({})
-});
-var migrationDefaultsSchema = z18.object({
-  missing_behavior: z18.enum(["disabled", "pending_review"]).default("disabled"),
-  stale_behavior: z18.enum(["use_last_known", "fail_closed_on_signature"]).default("use_last_known")
-});
-var migrationTriggerSchema = z18.object({
-  description: z18.string().max(500).optional(),
-  /**
-   * The (fromPlanKey, toPlanKey) migration this trigger configures.
-   * Compiler validates both keys resolve.
-   */
-  from_plan_key: z18.string().min(1).max(64),
-  to_plan_key: z18.string().min(1).max(64),
-  policy: z18.enum([
-    "GRANDFATHER",
-    "MIGRATE_AT_RENEWAL",
-    "MIGRATE_IMMEDIATELY",
-    "MIGRATE_BY_DATE",
-    "OPT_IN"
-  ]).default("MIGRATE_AT_RENEWAL"),
-  proration_policy: z18.enum(["NONE", "PRORATE", "CREDIT"]).default("NONE"),
-  /**
-   * Wall-clock cutover for `MIGRATE_BY_DATE` policy. Ignored for other
-   * policies. Must be in the future at compile time.
-   */
-  cutover_at: z18.string().datetime().optional(),
-  /**
-   * Freeze window per invariant #8 — while this migration is RUNNING,
-   * contractual mutations to the product are rejected at the webhook
-   * layer with 423 LOCKED. Set to `false` to allow concurrent
-   * contract edits (only for migrations that don't touch entitlement
-   * shape — e.g. pure price corrections).
-   */
-  freeze_contract_mutations: z18.boolean().default(true),
-  depends_on: dependsOnSchema,
-  defaults: migrationDefaultsSchema.default({
-    missing_behavior: "disabled",
-    stale_behavior: "use_last_known"
-  })
-});
-var runtimeMigrationsFileSchema = z18.object({
-  cacheProfile: cacheProfileSchema.default("blocking"),
-  migrations: z18.record(keyNameSchema, migrationTriggerSchema).default({})
-});
-
 // ../contracts/dist/plans/spec/capabilities-layer.js
-import { z as z19 } from "zod";
-var capabilityFileSchema = 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
@@ -2094,214 +2112,56 @@ var capabilityFileSchema = 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/product-v2.js
-import { z as z20 } from "zod";
-var PRODUCT_V2_SCHEMA_VERSION = 1;
-var billingKnobsShape2 = {
-  meters: z20.array(meterSchema).default([]),
-  recurring_fee_cents: z20.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: z20.number().int().nonnegative().default(0),
-  max_monthly_spend_cents: z20.number().int().nonnegative().optional(),
-  min_monthly_spend_cents: z20.number().int().nonnegative().optional(),
-  // Unified grants array — the SINGLE credit surface. Recurring +
-  // one-time credit are canonical entries here (the legacy scalar knobs
-  // were removed).
-  grants: z20.array(grantSchema).max(40).default([])
-};
-var planSpecV2Schema = z20.object({
-  key: z20.string().min(1).max(64).regex(/^[a-z0-9_-]+$/, "Plan key must be lowercase alphanumeric with hyphens/underscores"),
-  name: z20.string().min(1).max(100),
-  description: z20.string().max(500).optional(),
-  details: z20.array(z20.string().max(200)).max(10).optional(),
-  ...billingKnobsShape2,
-  free: z20.boolean().default(false),
-  /**
-   * Capability composition references. The compiler's
-   * `resolve-capabilities` pass walks the graph and expands this into
-   * concrete (features, policies) sets stored on the CompiledPlan.
-   *
-   * Replaces the legacy `featureGates` block (which is now expressed
-   * via capability composition) and the per-plan inverse feature
-   * mapping (`featureCatalogEntry.plans[]`).
-   *
-   * A plan may reference zero capabilities — useful for free / starter
-   * plans that grant access only via direct route bindings.
-   */
-  capabilities: z20.array(z20.string().min(1).max(120).regex(/^[a-z0-9_-]+$/)).max(20).default([]),
-  limits: z20.array(planLimitRuleSchema).max(20).default([]),
-  /**
-   * Control-plane capability caps (count limits + boolean toggles).
-   * Same semantics as the legacy `capability_limits` field.
-   */
-  capability_limits: z20.record(z20.string().min(1).max(120), z20.union([z20.number().int().nonnegative(), z20.boolean()])).default({}),
-  overageBehavior: z20.enum(["block", "allow_and_bill"]).default("block"),
-  selfServeEnabled: z20.boolean().default(true),
-  /**
-   * Marks a plan as the pinned-cohort head (status LEGACY_STABLE). Only
-   * existing subscribers stay on legacy plans; new subscribers cannot
-   * join. Removing a legacy plan while subscribers are pinned is a
-   * compile error.
-   */
-  legacy: z20.boolean().optional().default(false),
-  archive: z20.object({
-    at: z20.string().datetime().optional(),
-    transitionTo: z20.string().optional(),
-    strategy: z20.enum(["auto", "explicit", "block"]).default("auto")
-  }).optional()
-}).superRefine((plan, ctx) => {
-  refineSingleCanonicalGrant(plan.grants, ctx);
-});
-var DEFAULT_SUBSCRIBER_CHANGE_POLICY = {
-  default: "preserve_current_period",
-  proration: "none",
-  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"
-  },
-  allowImmediatePriceIncrease: false,
-  allowImmediateEntitlementReduction: false
-};
-var productSpecV2Schema = z20.object({
-  /**
-   * Schema-version stamp. Forward migrations target a higher value;
-   * readers refuse unsupported versions per invariant #2.
-   */
-  artifactSchemaVersion: z20.literal(PRODUCT_V2_SCHEMA_VERSION).default(PRODUCT_V2_SCHEMA_VERSION),
-  product: z20.object({
-    name: z20.string().min(1).max(100),
-    displayName: z20.string().max(200).optional(),
-    description: z20.string().max(2e3).optional(),
-    baseUrl: z20.string().url("baseUrl must be a valid URL"),
-    sandboxBaseUrl: z20.string().url("sandboxBaseUrl must be a valid URL").optional(),
-    visibility: z20.enum(["public", "private"]).default("public"),
-    logoUrl: z20.string().url().optional(),
-    primaryColor: z20.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
-    envBranchPrefix: z20.string().max(50).nullable().optional()
-  }),
-  /**
-   * Meter catalog. Referenced by route `metering` metadata.
-   * Same shape as the legacy meterDefinitionSchema (re-exported from
-   * product.ts to keep one source of truth during the transition).
-   *
-   * Lifted to a top-level array so the compiler can hash + invalidate
-   * meter changes independently from plan changes (incremental
-   * compilation per invariant #1 + Merkle DAG).
-   */
-  meters: z20.array(meterDefinitionSchema).max(10).default([]),
-  /**
-   * Bill on 4xx responses (independent of meter setup). Stays on the
-   * product spec because it's a contractual choice that affects
-   * billing predictability.
-   */
-  billOn4xx: z20.boolean().default(false),
-  frontend: frontendManifestSchema.optional(),
-  migrations: migrationDeclsSchema.optional(),
-  resources: countedResourcesSchema,
-  policies: productOperatorPoliciesSchema,
-  customer_context: productCustomerContextSchema.optional(),
-  surfaces: productSurfacesSchema,
-  entitlements: productEntitlementsSchema,
-  workflows: productWorkflowsSchema,
-  billing: z20.object({
-    gracePeriodDays: z20.number().int().nonnegative().default(3),
-    // When true (default), a plan limit INCREASE re-projects onto active
-    // subscribers immediately; a DECREASE always defers to period end.
-    // Read by advanceActiveSubscribersToLatestCompiledPlans.
-    applyLimitUpgradesInstantly: z20.boolean().optional(),
-    subscriberChangePolicy: subscriberChangePolicySchema.default(DEFAULT_SUBSCRIBER_CHANGE_POLICY)
-  }).default({
-    gracePeriodDays: 3,
-    subscriberChangePolicy: DEFAULT_SUBSCRIBER_CHANGE_POLICY
-  }),
-  plans: z20.array(planSpecV2Schema).max(4).default([]),
-  add_ons: addOnsBlockSchema,
-  lifecycle: z20.object({
-    breaking_changes: z20.object({
-      require_deprecation_window_days: z20.number().int().nonnegative().default(0),
-      require_successor_route: z20.boolean().default(false)
-    }).default({
-      require_deprecation_window_days: 0,
-      require_successor_route: false
-    })
-  }).default({
-    breaking_changes: {
-      require_deprecation_window_days: 0,
-      require_successor_route: false
-    }
-  }),
-  webhooks: webhooksBlockSchema.optional(),
-  environments: environmentsBlockSchema.optional(),
-  ephemeral: z20.object({
-    defaultPlan: z20.string().min(1).optional()
-  }).optional()
-});
-
-// ../contracts/dist/plans/spec/manifest-ir.js
-import { createHash } from "node:crypto";
-import { z as z21 } from "zod";
-var MANIFEST_IR_VERSION = 1;
-var manifestIrSchema = z21.object({
-  irVersion: z21.literal(MANIFEST_IR_VERSION),
-  /** Version of @farthershore/product that emitted this envelope. */
-  sdkVersion: z21.string().min(1).max(64),
-  /** Legacy unified ProductSpec — the live `CompileProductOptions.sourceSpec`. */
-  product: productSpecSchema,
-  /** One entry per feature, sorted by `feature` (mirrors /routes/<feature>.yaml). */
-  routes: z21.array(routesFileSchema).max(200).default([]),
-  /** Sorted by `name` (mirrors /policies/<name>.yaml). */
-  policies: z21.array(policyFileSchema).max(200).default([]),
-  /** Sorted by `capability` (mirrors /capabilities/<name>.yaml). */
-  capabilities: z21.array(capabilityFileSchema).max(200).default([]),
-  /** Reserved. Always null at irVersion 1 — runtime stays YAML/dashboard. */
-  runtime: z21.object({
-    rollout: z21.null().default(null),
-    flags: z21.null().default(null),
-    migrations: z21.null().default(null)
-  }).default({ rollout: null, flags: null, migrations: null })
-});
-function canonicalManifestJson(value) {
-  return stableJson(JSON.parse(JSON.stringify(value)));
-}
-function hashManifestIr(ir) {
-  return createHash("sha256").update(canonicalManifestJson(ir)).digest("hex");
-}
-function stableJson(value) {
-  if (Array.isArray(value))
-    return `[${value.map(stableJson).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, val]) => `${JSON.stringify(key)}:${stableJson(val)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-
-// ../contracts/dist/plans/presets.js
-var FREE = {
-  kind: "free",
-  label: "Free",
-  description: "No recurring fee and no metered usage. Pure freemium tier.",
-  pricing: {
-    meters: [],
-    recurring_fee_cents: 0,
-    billing_interval: "month",
-    grants: [],
-    trial_days: 0
-  }
+// ../contracts/dist/plans/spec/manifest-ir.js
+import { createHash } from "node:crypto";
+import { z as z21 } from "zod";
+var MANIFEST_IR_VERSION = 1;
+var manifestIrSchema = z21.object({
+  irVersion: z21.literal(MANIFEST_IR_VERSION),
+  /** Version of @farthershore/product that emitted this envelope. */
+  sdkVersion: z21.string().min(1).max(64),
+  /** Legacy unified ProductSpec — the live `CompileProductOptions.sourceSpec`. */
+  product: productSpecSchema,
+  /** One entry per feature, sorted by `feature`. */
+  routes: z21.array(routeLayerSchema).max(200).default([]),
+  /** Sorted by `name`. */
+  policies: z21.array(policyLayerSchema).max(200).default([]),
+  /** Sorted by `capability`. */
+  capabilities: z21.array(capabilityLayerSchema).max(200).default([])
+}).strict();
+function canonicalManifestJson(value) {
+  return stableJson(JSON.parse(JSON.stringify(value)));
+}
+function hashManifestIr(ir) {
+  return createHash("sha256").update(canonicalManifestJson(ir)).digest("hex");
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, val]) => `${JSON.stringify(key)}:${stableJson(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+// ../contracts/dist/plans/presets.js
+var FREE = {
+  kind: "free",
+  label: "Free",
+  description: "No recurring fee and no metered usage. Pure freemium tier.",
+  pricing: {
+    meters: [],
+    recurring_fee_cents: 0,
+    billing_interval: "month",
+    grants: [],
+    trial_days: 0
+  }
 };
 var STARTER = {
   kind: "starter",
@@ -2313,7 +2173,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
   }
 };
@@ -2327,7 +2187,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
   }
 };
@@ -2341,7 +2201,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
   }
 };
@@ -2379,6 +2239,9 @@ var subscriptionPricingOverrideSchema = z22.object({
    * the legacy recurring/one-time scalar knobs were removed).
    */
   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: z22.number().int().nonnegative().optional(),
   /** Override the maximum-spend ceiling. */
@@ -2410,78 +2273,864 @@ function validateManifestIr(candidate) {
   );
   return { ok: true, ir, irHash: hashIr(ir) };
 }
-function hashIr(ir) {
-  return hashManifestIr(ir);
+function hashIr(ir) {
+  return hashManifestIr(ir);
+}
+function canonicalIrJson(ir) {
+  return canonicalManifestJson(ir);
+}
+
+// src/version.ts
+var SDK_VERSION = true ? "0.6.1" : "0.0.0-dev";
+
+// src/refs.ts
+function isCapabilityGrant(value) {
+  return typeof value === "object" && value !== null && value.kind === "capability_grant";
+}
+function keyOf(ref) {
+  return typeof ref === "string" ? ref : ref.key;
+}
+function displayFromKey(key) {
+  return key.split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/backend.ts
+var BACKEND_ID_PATTERN2 = /^[a-z0-9][a-z0-9_-]*$/;
+function createBackendNode(id, options = {}) {
+  if (!BACKEND_ID_PATTERN2.test(id)) {
+    throw new ManifestBuilderError(
+      `backend "${id}": id must be a lowercase slug ([a-z0-9][a-z0-9_-]*)`
+    );
+  }
+  return {
+    id,
+    ...options.name !== void 0 ? { name: options.name } : {},
+    ...options.slug !== void 0 ? { slug: options.slug } : {},
+    ...options.transport !== void 0 ? {
+      transport: {
+        ...options.transport.mode !== void 0 ? { mode: options.transport.mode } : {},
+        ...options.transport.runner !== void 0 ? { runner: options.transport.runner } : {}
+      }
+    } : {},
+    ...options.verification !== void 0 ? { verification: options.verification } : {},
+    ...options.meters?.length ? { meters: options.meters.map(keyOf) } : {},
+    ...options.default !== void 0 ? { default: options.default } : {},
+    ...options.originUrl !== void 0 ? { originUrl: options.originUrl } : {},
+    ...options.originHostname !== void 0 ? { originHostname: options.originHostname } : {}
+  };
+}
+function buildBackendBlock(backendNodes) {
+  const out = {};
+  for (const node of [...backendNodes].sort(
+    (a, b) => a.id.localeCompare(b.id)
+  )) {
+    const { id, ...definition } = node;
+    out[id] = definition;
+  }
+  return out;
+}
+function assertBackendBindingsValid(files, backendNodes, meterDefinitions) {
+  if (backendNodes.length === 0) return;
+  const byId = new Map(backendNodes.map((backend) => [backend.id, backend]));
+  const declaredMeters = new Set(meterDefinitions.map((meter) => meter.key));
+  for (const backend of backendNodes) {
+    for (const meter of backend.meters ?? []) {
+      if (declaredMeters.has(meter)) continue;
+      throw new ManifestBuilderError(
+        `UNKNOWN_METER_IN_BACKEND: backend "${backend.id}" allows meter "${meter}" but it is not declared \u2014 call product.meter("${meter}", ...) first`
+      );
+    }
+  }
+  const ids = backendNodes.map((backend) => backend.id);
+  const explicitDefaults = backendNodes.filter(
+    (backend) => backend.default === true
+  );
+  const defaultId = ids.length === 1 ? ids[0] : explicitDefaults.length === 1 ? explicitDefaults[0].id : null;
+  const ambiguous = defaultId === null;
+  for (const file of files) {
+    const fileBinding = file.backend;
+    if (fileBinding !== void 0 && !byId.has(fileBinding)) {
+      throw new ManifestBuilderError(
+        `UNKNOWN_BACKEND_IN_ROUTE: feature "${file.feature}" binds backend "${fileBinding}" which is not declared \u2014 call product.backend("${fileBinding}", ...) first`
+      );
+    }
+    file.routes.forEach((route, routeIndex) => {
+      const explicit = route.backend ?? fileBinding;
+      if (explicit !== void 0) {
+        if (!byId.has(explicit)) {
+          throw new ManifestBuilderError(
+            `UNKNOWN_BACKEND_IN_ROUTE: feature "${file.feature}" route ${routeIndex} binds backend "${explicit}" which is not declared \u2014 call product.backend("${explicit}", ...) first`
+          );
+        }
+      } else if (ambiguous) {
+        throw new ManifestBuilderError(
+          `AMBIGUOUS_DEFAULT_BACKEND: feature "${file.feature}" route ${routeIndex} has no backend binding and the product declares ${ids.length} backends with no single default \u2014 mark exactly one backend \`default: true\` or bind the route explicitly`
+        );
+      }
+      const boundId = explicit ?? defaultId;
+      if (!boundId) return;
+      const backend = byId.get(boundId);
+      const allow = backend?.meters;
+      if (!allow) return;
+      const allowed = new Set(allow);
+      const routeMeters = /* @__PURE__ */ new Set([
+        ...Object.keys(route.metering?.defaults ?? {}),
+        ...route.metering?.reports ?? [],
+        ...Object.keys(route.metering?.estimates ?? {})
+      ]);
+      for (const meter of routeMeters) {
+        if (allowed.has(meter)) continue;
+        throw new ManifestBuilderError(
+          `ROUTE_METER_NOT_ALLOWED_BY_BACKEND: feature "${file.feature}" route ${routeIndex} meters "${meter}" but backend "${boundId}" does not allow it (backend.meters = [${allow.join(", ")}])`
+        );
+      }
+    });
+  }
+}
+
+// src/product-assembly.ts
+function assembleProductSpec(input) {
+  const { options } = input;
+  const base = {
+    product: {
+      name: input.name,
+      baseUrl: options.origin,
+      ...options.displayName !== void 0 ? { displayName: options.displayName } : {},
+      ...options.description !== void 0 ? { description: options.description } : {},
+      ...options.sandboxOrigin !== void 0 ? { sandboxBaseUrl: options.sandboxOrigin } : {},
+      ...options.visibility !== void 0 ? { visibility: options.visibility } : {},
+      ...options.logoUrl !== void 0 ? { logoUrl: options.logoUrl } : {},
+      ...options.primaryColor !== void 0 ? { primaryColor: options.primaryColor } : {},
+      ...options.envBranchPrefix !== void 0 ? { envBranchPrefix: options.envBranchPrefix } : {}
+    },
+    gateway: {
+      ...options.authHeader !== void 0 ? { authHeader: options.authHeader } : {},
+      ...options.upstreamAuth !== void 0 ? { upstreamAuth: options.upstreamAuth } : {}
+    },
+    metering: {
+      meters: buildMeterDefinitions(
+        input.meters,
+        input.defaultMeterCosts,
+        input.featureLayers,
+        input.workflows
+      ),
+      ...options.billOn4xx !== void 0 ? { billOn4xx: options.billOn4xx } : {}
+    },
+    ...input.backends.length ? { backend: buildBackendBlock(input.backends) } : {},
+    ...options.billing !== void 0 ? { billing: options.billing } : {},
+    ...options.operatorPolicies !== void 0 ? { policies: options.operatorPolicies } : {},
+    ...options.customerContext !== void 0 ? { customer_context: buildCustomerContext(options.customerContext) } : {},
+    ...input.surfaces.length ? { surfaces: sortBy2(input.surfaces, (surface) => surface.key) } : {},
+    ...input.entitlements.length ? {
+      entitlements: sortBy2(
+        input.entitlements,
+        (entitlement) => entitlement.key
+      )
+    } : {},
+    ...input.workflows.length ? { workflows: sortBy2(input.workflows, (workflow) => workflow.key) } : {},
+    ...input.frontendManifest !== void 0 ? { frontend: input.frontendManifest } : {},
+    ...input.migrations.length ? { migrations: sortBy2(input.migrations, (migration) => migration.id) } : {},
+    ...input.resources.length ? { resources: sortBy2(input.resources, (resource) => resource.name) } : {},
+    plans: sortBy2(input.plans, (plan) => plan.key)
+  };
+  return mergeProductPatch(
+    base,
+    input.productPatch
+  );
+}
+function buildMeterDefinitions(meters, defaultMeterCosts, featureLayers, workflows) {
+  const routeValueMeters = routeValueMeterKeys(
+    defaultMeterCosts,
+    featureLayers,
+    workflows
+  );
+  return sortBy2(meters, (meter) => meter.key).map((meter) => {
+    if (meter.aggregation !== void 0) return meter;
+    if (!routeValueMeters.has(meter.key)) return meter;
+    return { ...meter, aggregation: "SUM" };
+  });
+}
+function routeValueMeterKeys(defaultMeterCosts, featureLayers, workflows) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const cost of defaultMeterCosts) {
+    keys.add(cost.meter);
+  }
+  for (const file of featureLayers) {
+    for (const route of file.routes) {
+      for (const meter of Object.keys(route.metering?.defaults ?? {})) {
+        keys.add(meter);
+      }
+      for (const meter of route.metering?.reports ?? []) {
+        keys.add(meter);
+      }
+    }
+  }
+  for (const workflow of workflows) {
+    for (const meter of workflow.meters ?? []) keys.add(meter);
+    for (const meter of Object.keys(workflow.estimates ?? {})) keys.add(meter);
+  }
+  return keys;
+}
+function buildCustomerContext(options) {
+  return {
+    ...options.identityRequirement !== void 0 ? { identity_requirement: options.identityRequirement } : {},
+    ...options.contextTokens !== void 0 ? { context_tokens: options.contextTokens } : {},
+    ...options.customerAuth !== void 0 ? { portal_auth: options.customerAuth } : {}
+  };
+}
+function sortBy2(items, key) {
+  return [...items].sort((a, b) => key(a).localeCompare(key(b)));
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeProductPatch(base, patch) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    const existing = out[key];
+    if (isPlainObject(existing) && isPlainObject(value)) {
+      out[key] = mergeProductPatch(existing, value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+// src/frontend.ts
+function createFrontendManifest() {
+  return { version: 1, nav: [], pages: [] };
+}
+function setFrontendNav(manifest, items) {
+  manifest.nav = items.map((item) => ({
+    label: item.label,
+    path: item.path,
+    ...item.capability !== void 0 ? { capability: keyOf(item.capability) } : {}
+  }));
+}
+function addFrontendPage(manifest, path, options) {
+  if (manifest.pages?.some((page) => page.path === path)) {
+    throw new ManifestBuilderError(
+      `duplicate frontend page "${path}" \u2014 each frontend page path must be declared once`
+    );
+  }
+  manifest.pages ??= [];
+  manifest.pages.push({
+    path,
+    title: options.title,
+    requiresAuth: options.requiresAuth,
+    ...options.capability !== void 0 ? { capability: keyOf(options.capability) } : {},
+    ...options.components?.length ? {
+      components: options.components.map((component) => ({
+        component: component.component,
+        ...component.props !== void 0 ? { props: component.props } : {},
+        ...component.capability !== void 0 ? { capability: keyOf(component.capability) } : {},
+        ...component.gateMode !== void 0 ? { gateMode: component.gateMode } : {}
+      }))
+    } : {}
+  });
+}
+function frontendCapabilityKeys(manifest) {
+  return [
+    ...(manifest.nav ?? []).flatMap(
+      (item) => item.capability ? [item.capability] : []
+    ),
+    ...(manifest.pages ?? []).flatMap((page) => [
+      ...page.capability ? [page.capability] : [],
+      ...(page.components ?? []).flatMap(
+        (component) => component.capability ? [component.capability] : []
+      )
+    ])
+  ];
+}
+
+// src/route-metering.ts
+function parseRouteMatch(match) {
+  const trimmed = match.trim();
+  const space = trimmed.indexOf(" ");
+  if (space === -1) {
+    if (!trimmed.startsWith("/")) {
+      throw new ManifestBuilderError(
+        `route "${match}": expected "METHOD /path" or "/path"`
+      );
+    }
+    return { method: "*", path: trimmed };
+  }
+  const method = trimmed.slice(0, space).toUpperCase();
+  const path = trimmed.slice(space + 1).trim();
+  const methods = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+    "OPTIONS",
+    "*"
+  ];
+  if (!methods.includes(method)) {
+    throw new ManifestBuilderError(
+      `route "${match}": unknown HTTP method "${method}"`
+    );
+  }
+  if (!path.startsWith("/")) {
+    throw new ManifestBuilderError(
+      `route "${match}": path must start with "/"`
+    );
+  }
+  return { method, path };
+}
+function makeMeterRef(key) {
+  return {
+    kind: "meter",
+    key,
+    fixed: (value) => ({ kind: "meter_cost", meter: key, value }),
+    estimate: (value) => ({ kind: "meter_estimate", meter: key, value })
+  };
+}
+function normalizeMeterCost(cost, hasMeter) {
+  if (!cost || cost.kind !== "meter_cost") {
+    throw new ManifestBuilderError(
+      "meter cost must be created by meter.fixed(value)"
+    );
+  }
+  if (!hasMeter(cost.meter)) {
+    throw new ManifestBuilderError(
+      `meter cost references unknown meter "${cost.meter}"`
+    );
+  }
+  if (!Number.isFinite(cost.value) || cost.value < 0) {
+    throw new ManifestBuilderError(
+      `meter "${cost.meter}" fixed value must be a non-negative finite number`
+    );
+  }
+  return cost;
+}
+function normalizeMeterCosts(costs, normalize) {
+  if (!costs) return [];
+  const entries = Array.isArray(costs) ? costs : [costs];
+  return entries.map((cost) => normalize(cost));
+}
+function normalizeMeterRefs(refs) {
+  const entries = Array.isArray(refs) ? refs : [refs];
+  return entries.map(keyOf);
+}
+function statusPolicyPartIsValid2(part) {
+  const trimmed = part.trim();
+  if (!trimmed) return false;
+  const [startRaw, endRaw, extra] = trimmed.split("-");
+  if (extra !== void 0 || !/^\d{3}$/.test(startRaw ?? "")) return false;
+  const start = Number(startRaw);
+  const end = endRaw === void 0 ? start : Number(endRaw);
+  if (endRaw !== void 0 && !/^\d{3}$/.test(endRaw)) return false;
+  return start >= 100 && start <= 599 && end >= 100 && end <= 599 && start <= end;
+}
+function assertStatusCodePolicy(value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new ManifestBuilderError("onStatusCodes cannot be an empty array");
+    }
+    for (const status of value) {
+      if (!Number.isInteger(status) || status < 100 || status > 599) {
+        throw new ManifestBuilderError(
+          `onStatusCodes array contains invalid HTTP status "${status}"`
+        );
+      }
+    }
+    return;
+  }
+  if (!value.split(",").every(statusPolicyPartIsValid2)) {
+    throw new ManifestBuilderError(
+      'onStatusCodes must be comma-separated HTTP status codes or numeric ranges, e.g. "200-299,304"'
+    );
+  }
+}
+function assertEstimateValue(meter, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new ManifestBuilderError(
+      `meter "${meter}" estimate must be a non-negative finite number`
+    );
+  }
+}
+function normalizeMeterEstimate(estimate, hasMeter) {
+  if (!estimate || estimate.kind !== "meter_estimate") {
+    throw new ManifestBuilderError(
+      "meter estimate must be created by meter.estimate(value)"
+    );
+  }
+  if (!hasMeter(estimate.meter)) {
+    throw new ManifestBuilderError(
+      `meter estimate references unknown meter "${estimate.meter}"`
+    );
+  }
+  assertEstimateValue(estimate.meter, estimate.value);
+  return estimate;
+}
+function isMeterEstimate(value) {
+  return typeof value === "object" && value !== null && value.kind === "meter_estimate";
+}
+function normalizeMeterEstimates(estimates, hasMeter) {
+  if (!estimates) return {};
+  if (Array.isArray(estimates)) {
+    return Object.fromEntries(
+      estimates.map((estimate) => {
+        const normalized = normalizeMeterEstimate(estimate, hasMeter);
+        return [normalized.meter, normalized.value];
+      })
+    );
+  }
+  if (isMeterEstimate(estimates)) {
+    const normalized = normalizeMeterEstimate(estimates, hasMeter);
+    return { [normalized.meter]: normalized.value };
+  }
+  const estimateMap = estimates;
+  for (const [meter, value] of Object.entries(estimateMap)) {
+    assertEstimateValue(meter, value);
+  }
+  return { ...estimateMap };
+}
+function buildRouteDefinition(match, options, deps) {
+  const parsed = parseRouteMatch(match);
+  const metering = buildRouteMetering(options, deps);
+  return {
+    match: parsed,
+    ...metering ? { metering } : {},
+    ...options.unmetered !== void 0 ? { unmetered: options.unmetered } : {},
+    ...options.inheritDefaultMeters !== void 0 ? { inheritDefaultMeters: options.inheritDefaultMeters } : {},
+    ...options.action !== void 0 ? { action: keyOf(options.action) } : {},
+    ...options.backend !== void 0 ? { backend: keyOf(options.backend) } : {}
+  };
+}
+function buildRouteMetering(options, deps) {
+  if (options.unmetered === true) return void 0;
+  const defaults = {};
+  for (const cost of normalizeMeterCosts(
+    options.costs,
+    (cost2) => deps.normalizeMeterCost(cost2)
+  )) {
+    defaults[cost.meter] = (defaults[cost.meter] ?? 0) + cost.value;
+  }
+  const reports = [...new Set(normalizeMeterRefs(options.reports ?? []))];
+  const estimates = {};
+  for (const meter of reports) {
+    const definition = deps.getMeterDefinition(meter);
+    if (typeof definition?.estimate === "number") {
+      assertEstimateValue(meter, definition.estimate);
+      estimates[meter] = definition.estimate;
+    }
+  }
+  const explicitEstimates = normalizeMeterEstimates(
+    options.estimates,
+    (meter) => deps.getMeterDefinition(meter) !== void 0
+  );
+  for (const [meter, value] of Object.entries(explicitEstimates)) {
+    estimates[meter] = value;
+  }
+  const out = {};
+  if (Object.keys(defaults).length) out.defaults = defaults;
+  if (reports.length) out.reports = reports;
+  if (Object.keys(estimates).length) out.estimates = estimates;
+  if (options.onStatusCodes !== void 0) {
+    assertStatusCodePolicy(options.onStatusCodes);
+    out.onStatusCodes = options.onStatusCodes;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function materializeRoute(route, defaultMeterCosts) {
+  if (route.unmetered === true) return route;
+  const defaults = {
+    ...route.metering?.defaults ?? {}
+  };
+  if (route.inheritDefaultMeters !== false) {
+    for (const cost of defaultMeterCosts) {
+      defaults[cost.meter] = (defaults[cost.meter] ?? 0) + cost.value;
+    }
+  }
+  const hasMetering = route.metering !== void 0 || Object.keys(defaults).length > 0;
+  const metering = hasMetering ? {
+    ...route.metering ?? {},
+    ...Object.keys(defaults).length ? { defaults } : {}
+  } : void 0;
+  return {
+    ...route,
+    ...metering ? { metering } : {}
+  };
+}
+function routeMeterDependencyKeys(route) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const meter of Object.keys(route.metering?.defaults ?? {})) {
+    keys.add(meter);
+  }
+  for (const meter of route.metering?.reports ?? []) keys.add(meter);
+  for (const meter of Object.keys(route.metering?.estimates ?? {})) {
+    keys.add(meter);
+  }
+  return [...keys];
+}
+function assertRouteMeteringValid(files, meterDefinitions) {
+  const definitions = new Map(
+    Array.from(meterDefinitions, (meter) => [meter.key, meter])
+  );
+  for (const file of files) {
+    file.routes.forEach((route, routeIndex) => {
+      if (route.unmetered === true) return;
+      const defaults = new Set(Object.keys(route.metering?.defaults ?? {}));
+      const reports = new Set(route.metering?.reports ?? []);
+      for (const meter of defaults) {
+        if (definitions.has(meter)) continue;
+        throw new ManifestBuilderError(
+          `feature "${file.feature}" route ${routeIndex}: fixed meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
+        );
+      }
+      for (const meter of route.metering?.reports ?? []) {
+        if (!definitions.has(meter)) {
+          throw new ManifestBuilderError(
+            `feature "${file.feature}" route ${routeIndex}: reported meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
+          );
+        }
+        if (defaults.has(meter)) {
+          throw new ManifestBuilderError(
+            `feature "${file.feature}" route ${routeIndex}: meter "${meter}" cannot be both a fixed route cost and a dynamic report`
+          );
+        }
+      }
+      for (const meter of route.metering?.reports ?? []) {
+        const definition = definitions.get(meter);
+        const enforcement = definition?.enforcementType ?? "estimated_then_settled";
+        const hasEstimate = route.metering?.estimates && Object.prototype.hasOwnProperty.call(route.metering.estimates, meter);
+        if ((enforcement === "exact_pre_request" || enforcement === "estimated_then_settled") && !hasEstimate) {
+          throw new ManifestBuilderError(
+            `feature "${file.feature}" route ${routeIndex}: reported meter "${meter}" needs an estimate for gateway admission`
+          );
+        }
+      }
+      for (const [meter, value] of Object.entries(
+        route.metering?.estimates ?? {}
+      )) {
+        assertEstimateValue(meter, value);
+        if (!definitions.has(meter)) {
+          throw new ManifestBuilderError(
+            `feature "${file.feature}" route ${routeIndex}: estimate meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
+          );
+        }
+        if (reports.has(meter)) continue;
+        throw new ManifestBuilderError(
+          `feature "${file.feature}" route ${routeIndex}: estimate meter "${meter}" must also be listed in reports because estimates are pre-request reservations for dynamic usage`
+        );
+      }
+    });
+  }
+}
+
+// src/dependencies.ts
+function capabilityDependsOn(file) {
+  return [
+    ...dependenciesFor("feature", file.includes_features),
+    ...dependenciesFor("policy", file.includes_policies),
+    ...dependenciesFor("capability", file.includes_capabilities)
+  ];
+}
+function policyDependsOn(file) {
+  return dependenciesFor("meter", file.compatible_with?.meters);
+}
+function entitlementDependsOn(entitlement, hasResource) {
+  const limitDimensions = (entitlement.limits ?? []).map(
+    (limit) => limit.dimension
+  );
+  return [
+    ...dependenciesFor("capability", entitlement.capabilities),
+    ...existingDependenciesFor(
+      "meter",
+      [...entitlement.meters ?? [], ...limitDimensions],
+      hasResource
+    )
+  ];
+}
+function workflowDependsOn(workflow) {
+  return [
+    ...dependenciesFor("capability", workflow.capabilities),
+    ...dependenciesFor("meter", [
+      ...workflow.meters ?? [],
+      ...Object.keys(workflow.estimates ?? {})
+    ])
+  ];
+}
+function featureDependsOn(file) {
+  const meterKeys = file.routes.flatMap(
+    (route) => routeMeterDependencyKeys(route)
+  );
+  const backendKeys = [
+    ...file.backend !== void 0 ? [file.backend] : [],
+    ...file.routes.flatMap(
+      (route) => route.backend !== void 0 ? [route.backend] : []
+    )
+  ];
+  return [
+    ...dependenciesFor("policy", file.policies),
+    ...dependenciesFor("plan", file.plans),
+    ...dependenciesFor("meter", meterKeys),
+    ...dependenciesFor("backend", backendKeys)
+  ];
+}
+function actionDependsOn(featureKey, action) {
+  return [
+    resourceDependency("feature", featureKey),
+    ...action.resource ? [resourceDependency("counted_resource", action.resource.resource)] : []
+  ];
+}
+function planDependsOn(plan, hasResource) {
+  const caps = Array.isArray(plan.capabilities) ? plan.capabilities.map(String) : [];
+  const limitDimensions = (plan.limits ?? []).map((limit) => limit.dimension);
+  const pricedMeterDimensions = (plan.meters ?? []).map(
+    (meter) => meter.dimension
+  );
+  const capacityKeys = Object.keys(plan.capability_limits ?? {});
+  return [
+    ...dependenciesFor("capability", caps),
+    ...existingDependenciesFor(
+      "meter",
+      [...limitDimensions, ...pricedMeterDimensions],
+      hasResource
+    ),
+    ...existingDependenciesFor("counted_resource", capacityKeys, hasResource)
+  ];
+}
+function migrationDependsOn(migration) {
+  return [
+    resourceDependency("plan", migration.from.plan),
+    resourceDependency("plan", migration.to.plan),
+    ...dependenciesFor(
+      "plan",
+      migration.pins?.map((pin) => pin.pinTo.plan)
+    )
+  ];
+}
+function frontendDependsOn(manifest) {
+  return dependenciesFor("capability", frontendCapabilityKeys(manifest));
+}
+function assertResourceDependenciesSatisfied(missing) {
+  if (missing.length === 0) return;
+  const details = missing.slice(0, 8).map(
+    ({ from, missing: dependency }) => `${describeResourceUrn(from)} depends on missing ${describeResourceUrn(
+      dependency
+    )}`
+  ).join("; ");
+  const suffix = missing.length > 8 ? `; plus ${missing.length - 8} more` : "";
+  throw new ManifestBuilderError(
+    `manifest has unresolved resource reference(s): ${details}${suffix}`
+  );
+}
+function dependenciesFor(kind, keys) {
+  return [...new Set(keys ?? [])].map((key) => resourceDependency(kind, key));
+}
+function existingDependenciesFor(kind, keys, hasResource) {
+  return [...new Set(keys)].filter((key) => hasResource(kind, key)).map((key) => resourceDependency(kind, key));
+}
+function describeResourceUrn(urn) {
+  const parts = urn.split(":");
+  const kind = parts[3] ?? "resource";
+  const key = parts.slice(4).join(":");
+  return `${kind} "${decodeURIComponent(key)}"`;
+}
+
+// src/declarations.ts
+function buildCapabilityLayer(key, options = {}) {
+  return {
+    capability: key,
+    ...options.description !== void 0 || options.title !== void 0 ? { description: options.description ?? options.title } : {},
+    ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
+    ...options.includesFeatures?.length ? { includes_features: options.includesFeatures.map(keyOf) } : {},
+    ...options.includesPolicies?.length ? { includes_policies: options.includesPolicies.map(keyOf) } : {},
+    ...options.includesCapabilities?.length ? { includes_capabilities: options.includesCapabilities.map(keyOf) } : {}
+  };
+}
+function buildFeatureLayer(key, options, buildRoute) {
+  const layer = {
+    feature: key,
+    routes: [],
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
+    ...options.cacheProfile !== void 0 ? { cacheProfile: options.cacheProfile } : {},
+    ...options.upstreamOrigin !== void 0 ? { upstream: { override_origin: options.upstreamOrigin } } : {},
+    ...options.policies?.length ? { policies: options.policies.map(keyOf) } : {},
+    ...options.plans?.length ? { plans: options.plans.map(keyOf) } : {},
+    ...options.actions?.length ? {
+      actions: options.actions.map(({ id, ...action }) => ({
+        id,
+        ...action
+      }))
+    } : {},
+    ...options.rolloutKey !== void 0 || options.requiredFlags?.length ? {
+      runtime: {
+        ...options.rolloutKey !== void 0 ? { rollout_key: options.rolloutKey } : {},
+        ...options.requiredFlags?.length ? { required_flags: options.requiredFlags } : {}
+      }
+    } : {}
+  };
+  for (const route of options.routes ?? []) {
+    layer.routes.push(buildRoute(route.match, route));
+  }
+  return layer;
+}
+function buildPolicyLayer(name, options) {
+  return {
+    name,
+    type: options.type,
+    config: options.config,
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
+    ...options.cacheProfile !== void 0 ? { cacheProfile: options.cacheProfile } : {},
+    ...options.compatibleWith ? {
+      compatible_with: {
+        ...options.compatibleWith.routeTypes ? { route_types: options.compatibleWith.routeTypes } : {},
+        ...options.compatibleWith.meters ? { meters: options.compatibleWith.meters.map(keyOf) } : {},
+        ...options.compatibleWith.authModes ? { auth_modes: options.compatibleWith.authModes } : {}
+      }
+    } : {}
+  };
+}
+function buildSurfaceSpec(type, options = {}) {
+  const key = options.key ?? type;
+  return {
+    key,
+    type,
+    ...options.display !== void 0 ? { display: options.display } : {},
+    ...options.description !== void 0 ? { description: options.description } : {}
+  };
+}
+function buildWorkflowSpec(key, options = {}) {
+  return {
+    key,
+    kind: options.kind ?? "async_job",
+    trigger: options.trigger ?? { type: "manual" },
+    ...options.title !== void 0 ? { title: options.title } : {},
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.capabilities?.length ? { capabilities: options.capabilities.map(keyOf) } : {},
+    ...options.meters?.length ? { meters: options.meters.map(keyOf) } : {},
+    ...options.estimates !== void 0 ? { estimates: options.estimates } : {},
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+  };
 }
-function canonicalIrJson(ir) {
-  return canonicalManifestJson(ir);
+function buildEntitlementSpec(key, options = {}) {
+  return {
+    key,
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.capabilities?.length ? { capabilities: options.capabilities.map(keyOf) } : {},
+    ...options.featureGates !== void 0 ? { featureGates: options.featureGates } : {},
+    ...options.limits?.length ? { limits: options.limits } : {},
+    ...options.meters?.length ? { meters: options.meters.map(keyOf) } : {}
+  };
 }
-
-// src/version.ts
-var SDK_VERSION = true ? "0.5.0" : "0.0.0-dev";
-
-// src/product.ts
-var PRODUCT_BRAND = Symbol.for("farthershore.product.product");
-var PRODUCT_MANIFEST_COMPILER = Symbol.for(
-  "farthershore.product.manifestCompiler"
-);
-function isCapabilityGrant(value) {
-  return typeof value === "object" && value !== null && value.kind === "capability_grant";
+function buildPlanSpec(key, options) {
+  const { capabilityKeys, capabilityLimits, creditGrants } = normalizePlanGrants(options);
+  const rawCaps = Array.isArray(options.raw?.capabilities) ? options.raw.capabilities.map(String) : [];
+  const capabilities = [.../* @__PURE__ */ new Set([...capabilityKeys, ...rawCaps])];
+  const spec = {
+    key,
+    name: options.name,
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.details ? { details: options.details } : {},
+    ...options.price ? {
+      recurring_fee_cents: options.price.recurring_fee_cents,
+      billing_interval: options.price.billing_interval,
+      ...options.price.free ? { free: true } : {}
+    } : {},
+    ...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 } : {},
+    ...options.limits ? { limits: options.limits } : {},
+    ...options.featureGates ? { featureGates: options.featureGates } : {},
+    ...Object.keys(capabilityLimits).length ? { capability_limits: capabilityLimits } : {},
+    ...options.overageBehavior !== void 0 ? { overageBehavior: options.overageBehavior } : {},
+    ...options.selfServeEnabled !== void 0 ? { selfServeEnabled: options.selfServeEnabled } : {},
+    ...options.legacy !== void 0 ? { legacy: options.legacy } : {},
+    ...options.archive ? { archive: options.archive } : {},
+    ...options.raw ?? {},
+    ...capabilities.length ? { capabilities } : {}
+  };
+  return spec;
 }
-function keyOf(ref) {
-  return typeof ref === "string" ? ref : ref.key;
+function normalizePlanGrants(options) {
+  const capabilityKeys = (options.capabilities ?? []).map(keyOf);
+  const capabilityLimits = {
+    ...options.capabilityLimits ?? {}
+  };
+  const creditGrants = [];
+  for (const grant of options.grants ?? []) {
+    if (isCapabilityGrant(grant)) {
+      if (!capabilityKeys.includes(grant.capability)) {
+        capabilityKeys.push(grant.capability);
+      }
+      Object.assign(capabilityLimits, grant.limits ?? {});
+    } else {
+      creditGrants.push(grant);
+    }
+  }
+  return { capabilityKeys, capabilityLimits, creditGrants };
 }
-function displayFromKey(key) {
-  return key.split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+function buildMigrationDecl(id, options) {
+  return {
+    id,
+    from: normalizeMigrationPlanRef(options.from),
+    to: normalizeMigrationTargetRef(options.to),
+    newCustomers: options.newCustomers ?? "immediate",
+    existingCustomers: options.existingCustomers,
+    ...options.pins?.length ? {
+      pins: options.pins.map((pin) => ({
+        subscriber: pin.subscriber,
+        pinTo: {
+          plan: keyOf(pin.pinTo.plan),
+          version: pin.pinTo.version
+        },
+        ...pin.until !== void 0 ? { until: pin.until } : {},
+        ...pin.notes !== void 0 ? { notes: pin.notes } : {}
+      }))
+    } : {}
+  };
 }
-function parseRouteMatch(match) {
-  const trimmed = match.trim();
-  const space = trimmed.indexOf(" ");
-  if (space === -1) {
-    if (!trimmed.startsWith("/")) {
+function assertUniqueMigrationIds(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.id)) {
       throw new ManifestBuilderError(
-        `route "${match}": expected "METHOD /path" or "/path"`
+        `duplicate migration "${migration.id}" \u2014 each migration id must be declared once`
       );
     }
-    return { method: "*", path: trimmed };
-  }
-  const method = trimmed.slice(0, space).toUpperCase();
-  const path = trimmed.slice(space + 1).trim();
-  const methods = [
-    "GET",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "HEAD",
-    "OPTIONS",
-    "*"
-  ];
-  if (!methods.includes(method)) {
-    throw new ManifestBuilderError(
-      `route "${match}": unknown HTTP method "${method}"`
-    );
-  }
-  if (!path.startsWith("/")) {
-    throw new ManifestBuilderError(
-      `route "${match}": path must start with "/"`
-    );
+    seen.add(migration.id);
   }
-  return { method, path };
 }
+function normalizeMigrationPlanRef(ref) {
+  return {
+    plan: keyOf(ref.plan),
+    ...ref.version !== void 0 ? { version: ref.version } : {}
+  };
+}
+function normalizeMigrationTargetRef(ref) {
+  return {
+    plan: keyOf(ref.plan),
+    version: ref.version ?? "head"
+  };
+}
+
+// src/product.ts
+var PRODUCT_BRAND = Symbol.for("farthershore.product.product");
+var PRODUCT_MANIFEST_COMPILER = Symbol.for(
+  "farthershore.product.manifestCompiler"
+);
 var Product = class {
   [PRODUCT_BRAND] = true;
   name;
   options;
   graph = new ManifestResourceGraph();
   defaultMeterCosts = [];
-  frontendManifest;
   productPatch = {};
   /** Sugar for binding API routes to features. */
   api;
   frontend;
   lifecycle;
-  offering;
   /** Escape hatches — raw platform-schema JSON, validated by the compiler. */
   raw;
   constructor(name, options) {
@@ -2502,7 +3151,7 @@ var Product = class {
     this.api = {
       route: (match, options2) => {
         const featureKey = keyOf(options2.feature);
-        const file = this.getFeatureFile(featureKey);
+        const file = this.getFeatureLayer(featureKey);
         if (!file) {
           throw new ManifestBuilderError(
             `api.route("${match}"): feature "${featureKey}" is not declared \u2014 call product.feature("${featureKey}", \u2026) first`
@@ -2516,41 +3165,17 @@ var Product = class {
     this.frontend = {
       nav: (items) => {
         const manifest = this.ensureFrontendManifest();
-        manifest.nav = items.map((item) => ({
-          label: item.label,
-          path: item.path,
-          ...item.capability !== void 0 ? { capability: keyOf(item.capability) } : {}
-        }));
+        setFrontendNav(manifest, items);
         this.syncFrontendGraphNode(manifest);
         return this;
       },
       page: (path, options2) => {
         const manifest = this.ensureFrontendManifest();
-        if (manifest.pages?.some((page) => page.path === path)) {
-          throw new ManifestBuilderError(
-            `duplicate frontend page "${path}" \u2014 each frontend page path must be declared once`
-          );
-        }
-        manifest.pages ??= [];
-        manifest.pages.push({
-          path,
-          title: options2.title,
-          requiresAuth: options2.requiresAuth,
-          ...options2.capability !== void 0 ? { capability: keyOf(options2.capability) } : {},
-          ...options2.components?.length ? {
-            components: options2.components.map((component) => ({
-              component: component.component,
-              ...component.props !== void 0 ? { props: component.props } : {},
-              ...component.capability !== void 0 ? { capability: keyOf(component.capability) } : {},
-              ...component.gateMode !== void 0 ? { gateMode: component.gateMode } : {}
-            }))
-          } : {}
-        });
+        addFrontendPage(manifest, path, options2);
         this.syncFrontendGraphNode(manifest);
         return this;
       },
       manifest: (manifest) => {
-        this.frontendManifest = manifest;
         this.syncFrontendGraphNode(manifest);
         return this;
       }
@@ -2558,77 +3183,60 @@ var Product = class {
     this.lifecycle = {
       migration: (id, options2) => {
         this.assertNewKey("lifecycle_migration", id, "migration");
-        const migration = {
-          id,
-          from: this.normalizeMigrationPlanRef(options2.from),
-          to: this.normalizeMigrationTargetRef(options2.to),
-          newCustomers: options2.newCustomers ?? "immediate",
-          existingCustomers: options2.existingCustomers,
-          ...options2.pins?.length ? {
-            pins: options2.pins.map((pin) => ({
-              subscriber: pin.subscriber,
-              pinTo: {
-                plan: keyOf(pin.pinTo.plan),
-                version: pin.pinTo.version
-              },
-              ...pin.until !== void 0 ? { until: pin.until } : {},
-              ...pin.notes !== void 0 ? { notes: pin.notes } : {}
-            }))
-          } : {}
-        };
+        const migration = buildMigrationDecl(id, options2);
         this.graph.register(
           "lifecycle_migration",
           id,
           migration,
-          this.migrationDependsOn(migration)
+          migrationDependsOn(migration)
         );
         return this;
       },
       migrations: (migrations) => {
-        this.assertUniqueMigrationIds(migrations);
+        assertUniqueMigrationIds(migrations);
         this.graph.clearKind("lifecycle_migration");
         for (const migration of migrations) {
           this.graph.register(
             "lifecycle_migration",
             migration.id,
             migration,
-            this.migrationDependsOn(migration)
+            migrationDependsOn(migration)
           );
         }
         return this;
       }
     };
-    this.offering = {
-      plan: (key, options2) => this.plan(key, options2)
-    };
     this.raw = {
       productPatch: (patch) => {
-        this.productPatch = deepMerge(this.productPatch, patch);
+        this.productPatch = mergeProductPatch(this.productPatch, patch);
         return this;
       },
       plan: (spec) => {
         this.assertNewKey("plan", spec.key, "plan");
-        this.graph.register("plan", spec.key, spec, this.planDependsOn(spec));
-        return this;
-      },
-      routesFile: (file) => {
-        this.assertNewKey("feature", file.feature, "feature");
-        this.registerFeatureFile(file);
+        this.graph.register(
+          "plan",
+          spec.key,
+          spec,
+          planDependsOn(
+            spec,
+            (kind, dependencyKey) => this.graph.has(kind, dependencyKey)
+          )
+        );
         return this;
       },
-      policyFile: (file) => {
-        this.assertNewKey("policy", file.name, "policy");
-        this.graph.register("policy", file.name, file);
+      routeLayer: (layer) => {
+        this.assertNewKey("feature", layer.feature, "feature");
+        this.registerFeatureLayer(layer);
         return this;
       },
-      capabilityFile: (file) => {
-        this.assertNewKey("capability", file.capability, "capability");
-        this.graph.register("capability", file.capability, file);
+      policyLayer: (layer) => {
+        this.assertNewKey("policy", layer.name, "policy");
+        this.graph.register("policy", layer.name, layer);
         return this;
       },
-      frontend: (manifest) => {
-        this.frontendManifest = manifest;
-        this.syncFrontendGraphNode(manifest);
+      capabilityLayer: (layer) => {
+        this.assertNewKey("capability", layer.capability, "capability");
+        this.graph.register("capability", layer.capability, layer);
         return this;
       }
     };
@@ -2641,7 +3249,7 @@ var Product = class {
       display: meterOptions.display ?? displayFromKey(key),
       ...meterOptions
     });
-    const ref = this.makeMeterRef(key);
+    const ref = makeMeterRef(key);
     if (routeDefault !== void 0) {
       this.defaultMeterCosts.push(
         this.normalizeMeterCost(ref.fixed(routeDefault))
@@ -2649,6 +3257,18 @@ var Product = class {
     }
     return ref;
   }
+  /**
+   * BYO-Backend V1 — declare a first-class backend (an always-running HTTP
+   * container Farther Shore wraps). Products may declare MULTIPLE backends;
+   * routes bind to one via `route(..., { backend })`. A product with exactly
+   * one backend (or exactly one marked `default: true`) makes it the implicit
+   * default, so single-backend products stay zero-config.
+   */
+  backend(id, options = {}) {
+    this.assertNewKey("backend", id, "backend");
+    this.graph.register("backend", id, createBackendNode(id, options));
+    return { kind: "backend", key: id };
+  }
   requests(options = {}) {
     return this.meter("requests", {
       display: options.display ?? "Requests",
@@ -2674,20 +3294,8 @@ var Product = class {
   }
   capability(key, options = {}) {
     this.assertNewKey("capability", key, "capability");
-    const file = {
-      capability: key,
-      ...options.description !== void 0 || options.title !== void 0 ? { description: options.description ?? options.title } : {},
-      ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
-      ...options.includesFeatures?.length ? { includes_features: options.includesFeatures.map(keyOf) } : {},
-      ...options.includesPolicies?.length ? { includes_policies: options.includesPolicies.map(keyOf) } : {},
-      ...options.includesCapabilities?.length ? { includes_capabilities: options.includesCapabilities.map(keyOf) } : {}
-    };
-    this.graph.register(
-      "capability",
-      key,
-      file,
-      this.capabilityDependsOn(file)
-    );
+    const layer = buildCapabilityLayer(key, options);
+    this.graph.register("capability", key, layer, capabilityDependsOn(layer));
     return {
       kind: "capability",
       key,
@@ -2700,52 +3308,31 @@ var Product = class {
   }
   feature(key, options = {}) {
     this.assertNewKey("feature", key, "feature");
-    const file = {
-      feature: key,
-      routes: [],
-      ...options.description !== void 0 ? { description: options.description } : {},
-      ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
-      ...options.cacheProfile !== void 0 ? { cacheProfile: options.cacheProfile } : {},
-      ...options.upstreamOrigin !== void 0 ? { upstream: { override_origin: options.upstreamOrigin } } : {},
-      ...options.policies?.length ? { policies: options.policies.map(keyOf) } : {},
-      ...options.capabilities?.length ? { capabilities: options.capabilities.map(keyOf) } : {},
-      ...options.plans?.length ? { plans: options.plans.map(keyOf) } : {},
-      ...options.actions?.length ? {
-        actions: options.actions.map(({ id, ...action }) => ({
-          id,
-          ...action
-        }))
-      } : {},
-      ...options.rolloutKey !== void 0 || options.requiredFlags?.length ? {
-        runtime: {
-          ...options.rolloutKey !== void 0 ? { rollout_key: options.rolloutKey } : {},
-          ...options.requiredFlags?.length ? { required_flags: options.requiredFlags } : {}
-        }
-      } : {}
-    };
-    for (const route of options.routes ?? []) {
-      file.routes.push(this.buildRoute(route.match, route));
-    }
-    this.registerFeatureFile(file);
+    const layer = buildFeatureLayer(
+      key,
+      options,
+      (match, routeOptions) => this.buildRoute(match, routeOptions)
+    );
+    this.registerFeatureLayer(layer);
     const ref = {
       kind: "feature",
       key,
       action: (id, actionOptions) => {
-        file.actions ??= [];
-        if (file.actions.some((action2) => action2.id === id) || this.graph.has("action", id)) {
+        layer.actions ??= [];
+        if (layer.actions.some((action2) => action2.id === id) || this.graph.has("action", id)) {
           throw new ManifestBuilderError(
             `duplicate action "${id}" \u2014 each action id must be declared once`
           );
         }
         const action = { id, ...actionOptions };
-        file.actions.push(action);
+        layer.actions.push(action);
         this.registerAction(key, action);
-        this.syncFeatureGraphNode(file);
+        this.syncFeatureGraphNode(layer);
         return { kind: "action", key: id };
       },
       route: (match, routeOptions) => {
-        file.routes.push(this.buildRoute(match, routeOptions ?? {}));
-        this.syncFeatureGraphNode(file);
+        layer.routes.push(this.buildRoute(match, routeOptions ?? {}));
+        this.syncFeatureGraphNode(layer);
         return ref;
       }
     };
@@ -2753,126 +3340,48 @@ var Product = class {
   }
   policy(name, options) {
     this.assertNewKey("policy", name, "policy");
-    const file = {
-      name,
-      type: options.type,
-      config: options.config,
-      ...options.description !== void 0 ? { description: options.description } : {},
-      ...options.mutationClass !== void 0 ? { mutation_class: options.mutationClass } : {},
-      ...options.cacheProfile !== void 0 ? { cacheProfile: options.cacheProfile } : {},
-      ...options.compatibleWith ? {
-        compatible_with: {
-          ...options.compatibleWith.routeTypes ? { route_types: options.compatibleWith.routeTypes } : {},
-          ...options.compatibleWith.meters ? { meters: options.compatibleWith.meters.map(keyOf) } : {},
-          ...options.compatibleWith.authModes ? { auth_modes: options.compatibleWith.authModes } : {}
-        }
-      } : {}
-    };
-    this.graph.register("policy", name, file, this.policyDependsOn(file));
+    const layer = buildPolicyLayer(name, options);
+    this.graph.register("policy", name, layer, policyDependsOn(layer));
     return { kind: "policy", key: name };
   }
   surface(type, options = {}) {
-    const key = options.key ?? type;
-    this.assertNewKey("surface", key, "surface");
-    const surface = {
-      key,
-      type,
-      ...options.display !== void 0 ? { display: options.display } : {},
-      ...options.description !== void 0 ? { description: options.description } : {}
-    };
-    this.graph.register("surface", key, surface);
-    return { kind: "surface", key };
+    const surface = buildSurfaceSpec(type, options);
+    this.assertNewKey("surface", surface.key, "surface");
+    this.graph.register("surface", surface.key, surface);
+    return { kind: "surface", key: surface.key };
   }
   workflow(key, options = {}) {
     this.assertNewKey("workflow", key, "workflow");
-    const workflow = {
-      key,
-      kind: options.kind ?? "async_job",
-      trigger: options.trigger ?? { type: "manual" },
-      ...options.title !== void 0 ? { title: options.title } : {},
-      ...options.description !== void 0 ? { description: options.description } : {},
-      ...options.capabilities?.length ? { capabilities: options.capabilities.map(keyOf) } : {},
-      ...options.meters?.length ? { meters: options.meters.map(keyOf) } : {},
-      ...options.estimates !== void 0 ? { estimates: options.estimates } : {},
-      ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
-    };
-    this.graph.register(
-      "workflow",
-      key,
-      workflow,
-      this.workflowDependsOn(workflow)
-    );
+    const workflow = buildWorkflowSpec(key, options);
+    this.graph.register("workflow", key, workflow, workflowDependsOn(workflow));
     return { kind: "workflow", key };
   }
   entitlement(key, options = {}) {
     this.assertNewKey("entitlement", key, "entitlement");
-    const entitlement = {
-      key,
-      ...options.description !== void 0 ? { description: options.description } : {},
-      ...options.capabilities?.length ? { capabilities: options.capabilities.map(keyOf) } : {},
-      ...options.featureGates !== void 0 ? { featureGates: options.featureGates } : {},
-      ...options.limits?.length ? { limits: options.limits } : {},
-      ...options.meters?.length ? { meters: options.meters.map(keyOf) } : {}
-    };
+    const entitlement = buildEntitlementSpec(key, options);
     this.graph.register(
       "entitlement",
       key,
       entitlement,
-      this.entitlementDependsOn(entitlement)
+      entitlementDependsOn(
+        entitlement,
+        (kind, dependencyKey) => this.graph.has(kind, dependencyKey)
+      )
     );
     return { kind: "entitlement", key };
   }
   plan(key, options) {
     this.assertNewKey("plan", key, "plan");
-    const capabilityKeys = (options.capabilities ?? []).map(keyOf);
-    const capabilityLimits = {
-      ...options.capabilityLimits ?? {}
-    };
-    const creditGrants = [];
-    for (const grant of options.grants ?? []) {
-      if (isCapabilityGrant(grant)) {
-        if (!capabilityKeys.includes(grant.capability)) {
-          capabilityKeys.push(grant.capability);
-        }
-        Object.assign(capabilityLimits, grant.limits ?? {});
-      } else {
-        creditGrants.push(grant);
-      }
-    }
-    const spec = {
+    const spec = buildPlanSpec(key, options);
+    this.graph.register(
+      "plan",
       key,
-      name: options.name,
-      ...options.description !== void 0 ? { description: options.description } : {},
-      ...options.details ? { details: options.details } : {},
-      ...options.price ? {
-        recurring_fee_cents: options.price.recurring_fee_cents,
-        billing_interval: options.price.billing_interval,
-        ...options.price.free ? { free: true } : {}
-      } : {},
-      ...options.meters ? { meters: options.meters } : {},
-      ...creditGrants.length ? { grants: creditGrants } : {},
-      ...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 } : {},
-      ...options.limits ? { limits: options.limits } : {},
-      ...options.featureGates ? { featureGates: options.featureGates } : {},
-      ...Object.keys(capabilityLimits).length ? { capability_limits: capabilityLimits } : {},
-      ...options.overageBehavior !== void 0 ? { overageBehavior: options.overageBehavior } : {},
-      ...options.selfServeEnabled !== void 0 ? { selfServeEnabled: options.selfServeEnabled } : {},
-      ...options.legacy !== void 0 ? { legacy: options.legacy } : {},
-      ...options.archive ? { archive: options.archive } : {},
-      ...options.raw ?? {}
-    };
-    const rawCaps = Array.isArray(
-      spec.capabilities
-    ) ? spec.capabilities.map(
-      String
-    ) : [];
-    const mergedCaps = [.../* @__PURE__ */ new Set([...capabilityKeys, ...rawCaps])];
-    if (mergedCaps.length) {
-      spec.capabilities = mergedCaps;
-    }
-    this.graph.register("plan", key, spec, this.planDependsOn(spec));
+      spec,
+      planDependsOn(
+        spec,
+        (kind, dependencyKey) => this.graph.has(kind, dependencyKey)
+      )
+    );
     return { kind: "plan", key };
   }
   use(...modules) {
@@ -2888,8 +3397,16 @@ var Product = class {
   /** @internal Internal platform compiler entrypoint. Builder code exports the
    *  Product; the bot/CLI/build-runner decide when to compile and apply it. */
   [PRODUCT_MANIFEST_COMPILER]() {
-    const routes = this.materializeFeatureFiles();
-    this.assertRouteMeteringValid(routes);
+    const routes = this.materializeFeatureLayers();
+    assertRouteMeteringValid(
+      routes,
+      this.graph.values("meter")
+    );
+    assertBackendBindingsValid(
+      routes,
+      this.graph.values("backend"),
+      this.graph.values("meter")
+    );
     this.assertGraphDependenciesSatisfied();
     const candidate = {
       irVersion: 1,
@@ -2898,245 +3415,67 @@ var Product = class {
       routes,
       policies: this.graph.sortedValues(
         "policy",
-        (file) => file.name
+        (layer) => layer.name
       ),
       capabilities: this.graph.sortedValues(
         "capability",
-        (file) => file.capability
-      ),
-      runtime: { rollout: null, flags: null, migrations: null }
+        (layer) => layer.capability
+      )
     };
     const result = validateManifestIr(candidate);
     if (!result.ok) throw new ManifestValidationError(result.issues);
     return { ir: result.ir, irHash: result.irHash };
   }
   buildProductSpec() {
-    const options = this.options;
-    const base = {
-      product: {
-        name: this.name,
-        baseUrl: options.origin,
-        ...options.displayName !== void 0 ? { displayName: options.displayName } : {},
-        ...options.description !== void 0 ? { description: options.description } : {},
-        ...options.sandboxOrigin !== void 0 ? { sandboxBaseUrl: options.sandboxOrigin } : {},
-        ...options.visibility !== void 0 ? { visibility: options.visibility } : {},
-        ...options.logoUrl !== void 0 ? { logoUrl: options.logoUrl } : {},
-        ...options.primaryColor !== void 0 ? { primaryColor: options.primaryColor } : {},
-        ...options.envBranchPrefix !== void 0 ? { envBranchPrefix: options.envBranchPrefix } : {}
-      },
-      gateway: {
-        ...options.authHeader !== void 0 ? { authHeader: options.authHeader } : {},
-        ...options.upstreamAuth !== void 0 ? { upstreamAuth: options.upstreamAuth } : {}
-      },
-      metering: {
-        meters: this.buildMeterDefinitions(),
-        ...options.billOn4xx !== void 0 ? { billOn4xx: options.billOn4xx } : {}
-      },
-      ...options.billing !== void 0 ? { billing: options.billing } : {},
-      ...options.operatorPolicies !== void 0 ? { policies: options.operatorPolicies } : {},
-      ...options.customerContext !== void 0 ? { customer_context: buildCustomerContext(options.customerContext) } : {},
-      ...this.graph.values("surface").length ? {
-        surfaces: this.graph.sortedValues(
-          "surface",
-          (surface) => surface.key
-        )
-      } : {},
-      ...this.graph.values("entitlement").length ? {
-        entitlements: this.graph.sortedValues(
-          "entitlement",
-          (entitlement) => entitlement.key
-        )
-      } : {},
-      ...this.graph.values("workflow").length ? {
-        workflows: this.graph.sortedValues(
-          "workflow",
-          (workflow) => workflow.key
-        )
-      } : {},
-      ...this.graph.has("frontend", "manifest") ? {
-        frontend: this.graph.get(
-          "frontend",
-          "manifest"
-        )?.value
-      } : {},
-      ...this.graph.values("lifecycle_migration").length ? {
-        migrations: this.graph.sortedValues(
-          "lifecycle_migration",
-          (migration) => migration.id
-        )
-      } : {},
-      ...this.graph.values("counted_resource").length ? {
-        resources: this.graph.sortedValues(
-          "counted_resource",
-          (resource) => resource.name
-        )
-      } : {},
-      plans: this.graph.sortedValues("plan", (plan) => plan.key)
-    };
-    return deepMerge(
-      base,
-      this.productPatch
-    );
-  }
-  buildMeterDefinitions() {
-    const routeValueMeters = this.routeValueMeterKeys();
-    return this.graph.sortedValues("meter", (meter) => meter.key).map((meter) => {
-      if (meter.aggregation !== void 0) return meter;
-      if (!routeValueMeters.has(meter.key)) return meter;
-      return { ...meter, aggregation: "SUM" };
+    return assembleProductSpec({
+      name: this.name,
+      options: this.options,
+      productPatch: this.productPatch,
+      meters: this.graph.values("meter"),
+      defaultMeterCosts: this.defaultMeterCosts,
+      backends: this.graph.values("backend"),
+      surfaces: this.graph.values("surface"),
+      entitlements: this.graph.values("entitlement"),
+      workflows: this.graph.values("workflow"),
+      frontendManifest: this.graph.get(
+        "frontend",
+        "manifest"
+      )?.value,
+      migrations: this.graph.values("lifecycle_migration"),
+      resources: this.graph.values("counted_resource"),
+      plans: this.graph.values("plan"),
+      featureLayers: this.graph.values("feature")
     });
   }
-  routeValueMeterKeys() {
-    const keys = /* @__PURE__ */ new Set();
-    for (const cost of this.defaultMeterCosts) {
-      keys.add(cost.meter);
-    }
-    for (const file of this.graph.values("feature")) {
-      for (const route of file.routes) {
-        for (const meter of Object.keys(route.metering?.defaults ?? {})) {
-          keys.add(meter);
-        }
-        for (const meter of route.metering?.reports ?? []) {
-          keys.add(meter);
-        }
-      }
-    }
-    for (const workflow of this.graph.values("workflow")) {
-      for (const meter of workflow.meters ?? []) keys.add(meter);
-      for (const meter of Object.keys(workflow.estimates ?? {}))
-        keys.add(meter);
-    }
-    return keys;
-  }
   buildRoute(match, options) {
-    const parsed = parseRouteMatch(match);
-    const metering = this.buildRouteMetering(options);
-    return {
-      match: parsed,
-      ...metering ? { metering } : {},
-      ...options.unmetered !== void 0 ? { unmetered: options.unmetered } : {},
-      ...options.inheritDefaultMeters !== void 0 ? { inheritDefaultMeters: options.inheritDefaultMeters } : {},
-      ...options.action !== void 0 ? { action: keyOf(options.action) } : {}
-    };
-  }
-  makeMeterRef(key) {
-    return {
-      kind: "meter",
-      key,
-      fixed: (value) => ({ kind: "meter_cost", meter: key, value }),
-      estimate: (value) => ({ kind: "meter_cost", meter: key, value })
-    };
+    return buildRouteDefinition(match, options, {
+      normalizeMeterCost: (cost) => this.normalizeMeterCost(cost),
+      getMeterDefinition: (key) => this.graph.get("meter", key)?.value
+    });
   }
-  buildRouteMetering(options) {
-    if (options.unmetered === true) return void 0;
-    const defaults = {};
-    for (const cost of this.normalizeMeterCosts(options.costs)) {
-      defaults[cost.meter] = (defaults[cost.meter] ?? 0) + cost.value;
-    }
-    const reports = [
-      ...new Set(this.normalizeMeterRefs(options.reports ?? []))
-    ];
-    const estimates = {};
-    for (const meter of reports) {
-      const definition = this.graph.get(
-        "meter",
-        meter
-      )?.value;
-      if (typeof definition?.estimate === "number") {
-        estimates[meter] = definition.estimate;
-      }
-    }
-    for (const [meter, value] of Object.entries(options.estimates ?? {})) {
-      estimates[meter] = value;
-    }
-    const out = {};
-    if (Object.keys(defaults).length) out.defaults = defaults;
-    if (reports.length) out.reports = reports;
-    if (Object.keys(estimates).length) out.estimates = estimates;
-    if (options.onStatusCodes !== void 0)
-      out.onStatusCodes = options.onStatusCodes;
-    return Object.keys(out).length ? out : void 0;
-  }
-  materializeFeatureFiles() {
-    return this.graph.sortedValues("feature", (file) => file.feature).map((file) => ({
-      ...file,
-      routes: file.routes.map((route) => this.materializeRoute(route))
+  materializeFeatureLayers() {
+    return this.graph.sortedValues("feature", (layer) => layer.feature).map((layer) => ({
+      ...layer,
+      routes: layer.routes.map(
+        (route) => materializeRoute(route, this.defaultMeterCosts)
+      )
     }));
   }
-  materializeRoute(route) {
-    if (route.unmetered === true) return route;
-    const defaults = {
-      ...route.metering?.defaults ?? {}
-    };
-    if (route.inheritDefaultMeters !== false) {
-      for (const cost of this.defaultMeterCosts) {
-        defaults[cost.meter] = (defaults[cost.meter] ?? 0) + cost.value;
-      }
-    }
-    const hasMetering = route.metering !== void 0 || Object.keys(defaults).length > 0;
-    const metering = hasMetering ? {
-      ...route.metering ?? {},
-      ...Object.keys(defaults).length ? { defaults } : {}
-    } : void 0;
-    return {
-      ...route,
-      ...metering ? { metering } : {}
-    };
-  }
   normalizeMeterCost(cost) {
-    if (!cost || cost.kind !== "meter_cost") {
-      throw new ManifestBuilderError(
-        "meter cost must be created by meter.fixed(value)"
-      );
-    }
-    if (!this.graph.has("meter", cost.meter)) {
-      throw new ManifestBuilderError(
-        `meter cost references unknown meter "${cost.meter}"`
-      );
-    }
-    if (!Number.isFinite(cost.value) || cost.value < 0) {
-      throw new ManifestBuilderError(
-        `meter "${cost.meter}" fixed value must be a non-negative finite number`
-      );
-    }
-    return cost;
-  }
-  normalizeMeterCosts(costs) {
-    if (!costs) return [];
-    const entries = Array.isArray(costs) ? costs : [costs];
-    return entries.map((cost) => this.normalizeMeterCost(cost));
-  }
-  normalizeMeterRefs(refs) {
-    const entries = Array.isArray(refs) ? refs : [refs];
-    return entries.map(keyOf);
+    return normalizeMeterCost(
+      cost,
+      (meter) => this.graph.has("meter", meter)
+    );
   }
   ensureFrontendManifest() {
-    this.frontendManifest ??= { version: 1, nav: [], pages: [] };
-    this.syncFrontendGraphNode(this.frontendManifest);
-    return this.frontendManifest;
-  }
-  normalizeMigrationPlanRef(ref) {
-    return {
-      plan: keyOf(ref.plan),
-      ...ref.version !== void 0 ? { version: ref.version } : {}
-    };
-  }
-  normalizeMigrationTargetRef(ref) {
-    return {
-      plan: keyOf(ref.plan),
-      version: ref.version ?? "head"
-    };
-  }
-  assertUniqueMigrationIds(migrations) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const migration of migrations) {
-      if (seen.has(migration.id)) {
-        throw new ManifestBuilderError(
-          `duplicate migration "${migration.id}" \u2014 each migration id must be declared once`
-        );
-      }
-      seen.add(migration.id);
-    }
+    const existing = this.graph.get(
+      "frontend",
+      "manifest"
+    )?.value;
+    if (existing) return existing;
+    const manifest = createFrontendManifest();
+    this.syncFrontendGraphNode(manifest);
+    return manifest;
   }
   assertNewKey(kind, key, label) {
     if (this.graph.has(kind, key)) {
@@ -3146,39 +3485,24 @@ var Product = class {
     }
   }
   assertGraphDependenciesSatisfied() {
-    const missing = this.graph.missingDependencies();
-    if (missing.length === 0) return;
-    const details = missing.slice(0, 8).map(
-      ({ from, missing: dependency }) => `${describeResourceUrn(from)} depends on missing ${describeResourceUrn(
-        dependency
-      )}`
-    ).join("; ");
-    const suffix = missing.length > 8 ? `; plus ${missing.length - 8} more` : "";
-    throw new ManifestBuilderError(
-      `manifest has unresolved resource reference(s): ${details}${suffix}`
-    );
+    assertResourceDependenciesSatisfied(this.graph.missingDependencies());
   }
-  getFeatureFile(key) {
+  getFeatureLayer(key) {
     return this.graph.get("feature", key)?.value ?? null;
   }
-  registerFeatureFile(file) {
+  registerFeatureLayer(layer) {
     this.graph.register(
       "feature",
-      file.feature,
-      file,
-      this.featureDependsOn(file)
+      layer.feature,
+      layer,
+      featureDependsOn(layer)
     );
-    for (const action of file.actions ?? []) {
-      this.registerAction(file.feature, action);
+    for (const action of layer.actions ?? []) {
+      this.registerAction(layer.feature, action);
     }
   }
-  syncFeatureGraphNode(file) {
-    this.graph.upsert(
-      "feature",
-      file.feature,
-      file,
-      this.featureDependsOn(file)
-    );
+  syncFeatureGraphNode(layer) {
+    this.graph.upsert("feature", layer.feature, layer, featureDependsOn(layer));
   }
   registerAction(featureKey, action) {
     this.assertNewKey("action", action.id, "action");
@@ -3186,7 +3510,7 @@ var Product = class {
       "action",
       action.id,
       action,
-      this.actionDependsOn(featureKey, action)
+      actionDependsOn(featureKey, action)
     );
   }
   syncFrontendGraphNode(manifest) {
@@ -3194,163 +3518,8 @@ var Product = class {
       "frontend",
       "manifest",
       manifest,
-      this.frontendDependsOn(manifest)
-    );
-  }
-  capabilityDependsOn(file) {
-    return [
-      ...this.dependenciesFor("feature", file.includes_features),
-      ...this.dependenciesFor("policy", file.includes_policies),
-      ...this.dependenciesFor("capability", file.includes_capabilities)
-    ];
-  }
-  policyDependsOn(file) {
-    return this.dependenciesFor("meter", file.compatible_with?.meters);
-  }
-  entitlementDependsOn(entitlement) {
-    const limitDimensions = (entitlement.limits ?? []).map(
-      (limit) => limit.dimension
-    );
-    return [
-      ...this.dependenciesFor("capability", entitlement.capabilities),
-      ...this.existingDependenciesFor("meter", [
-        ...entitlement.meters ?? [],
-        ...limitDimensions
-      ])
-    ];
-  }
-  workflowDependsOn(workflow) {
-    return [
-      ...this.dependenciesFor("capability", workflow.capabilities),
-      ...this.dependenciesFor("meter", [
-        ...workflow.meters ?? [],
-        ...Object.keys(workflow.estimates ?? {})
-      ])
-    ];
-  }
-  featureDependsOn(file) {
-    const meterKeys = file.routes.flatMap(
-      (route) => this.routeMeterDependencyKeys(route)
-    );
-    return [
-      ...this.dependenciesFor("policy", file.policies),
-      ...this.dependenciesFor("capability", file.capabilities),
-      ...this.dependenciesFor("plan", file.plans),
-      ...this.dependenciesFor("meter", meterKeys)
-    ];
-  }
-  routeMeterDependencyKeys(route) {
-    const keys = /* @__PURE__ */ new Set();
-    for (const meter of Object.keys(route.metering?.defaults ?? {})) {
-      keys.add(meter);
-    }
-    for (const meter of route.metering?.reports ?? []) keys.add(meter);
-    for (const meter of Object.keys(route.metering?.estimates ?? {})) {
-      keys.add(meter);
-    }
-    return [...keys];
-  }
-  assertRouteMeteringValid(files) {
-    const declaredMeters = new Set(
-      this.graph.values("meter").map((meter) => meter.key)
-    );
-    for (const file of files) {
-      file.routes.forEach((route, routeIndex) => {
-        if (route.unmetered === true) return;
-        const defaults = new Set(Object.keys(route.metering?.defaults ?? {}));
-        for (const meter of defaults) {
-          if (declaredMeters.has(meter)) continue;
-          throw new ManifestBuilderError(
-            `feature "${file.feature}" route ${routeIndex}: fixed meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
-          );
-        }
-        for (const meter of route.metering?.reports ?? []) {
-          if (!declaredMeters.has(meter)) {
-            throw new ManifestBuilderError(
-              `feature "${file.feature}" route ${routeIndex}: reported meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
-            );
-          }
-          if (defaults.has(meter)) {
-            throw new ManifestBuilderError(
-              `feature "${file.feature}" route ${routeIndex}: meter "${meter}" cannot be both a fixed route cost and a dynamic report`
-            );
-          }
-        }
-        for (const meter of route.metering?.reports ?? []) {
-          const definition = this.graph.get(
-            "meter",
-            meter
-          )?.value;
-          const enforcement = definition?.enforcementType ?? "estimated_then_settled";
-          const hasEstimate = route.metering?.estimates && Object.prototype.hasOwnProperty.call(
-            route.metering.estimates,
-            meter
-          );
-          if ((enforcement === "exact_pre_request" || enforcement === "estimated_then_settled") && !hasEstimate) {
-            throw new ManifestBuilderError(
-              `feature "${file.feature}" route ${routeIndex}: reported meter "${meter}" needs an estimate for gateway admission`
-            );
-          }
-        }
-        for (const meter of Object.keys(route.metering?.estimates ?? {})) {
-          if (declaredMeters.has(meter)) continue;
-          throw new ManifestBuilderError(
-            `feature "${file.feature}" route ${routeIndex}: estimate meter "${meter}" is not declared \u2014 declare it with product.meter("${meter}", ...) first`
-          );
-        }
-      });
-    }
-  }
-  actionDependsOn(featureKey, action) {
-    return [
-      resourceDependency("feature", featureKey),
-      ...action.resource ? [resourceDependency("counted_resource", action.resource.resource)] : []
-    ];
-  }
-  planDependsOn(plan) {
-    const caps = Array.isArray(plan.capabilities) ? plan.capabilities.map(String) : [];
-    const limitDimensions = (plan.limits ?? []).map((limit) => limit.dimension);
-    const pricedMeterDimensions = (plan.meters ?? []).map(
-      (meter) => meter.dimension
+      frontendDependsOn(manifest)
     );
-    const capacityKeys = Object.keys(plan.capability_limits ?? {});
-    return [
-      ...this.dependenciesFor("capability", caps),
-      ...this.existingDependenciesFor("meter", [
-        ...limitDimensions,
-        ...pricedMeterDimensions
-      ]),
-      ...this.existingDependenciesFor("counted_resource", capacityKeys)
-    ];
-  }
-  migrationDependsOn(migration) {
-    return [
-      resourceDependency("plan", migration.from.plan),
-      resourceDependency("plan", migration.to.plan),
-      ...this.dependenciesFor(
-        "plan",
-        migration.pins?.map((pin) => pin.pinTo.plan)
-      )
-    ];
-  }
-  frontendDependsOn(manifest) {
-    return this.dependenciesFor("capability", [
-      ...(manifest.nav ?? []).flatMap(
-        (item) => item.capability ? [item.capability] : []
-      ),
-      ...(manifest.pages ?? []).flatMap((page) => [
-        ...page.capability ? [page.capability] : [],
-        ...(page.components ?? []).flatMap(
-          (component) => component.capability ? [component.capability] : []
-        )
-      ])
-    ]);
-  }
-  dependenciesFor(kind, keys) {
-    return [...new Set(keys ?? [])].map((key) => resourceDependency(kind, key));
-  }
-  existingDependenciesFor(kind, keys) {
-    return [...new Set(keys)].filter((key) => this.graph.has(kind, key)).map((key) => resourceDependency(kind, key));
   }
 };
 function isProduct(value) {
@@ -3361,34 +3530,6 @@ function product(name, options, configure) {
   if (configure) instance.use(configure);
   return instance;
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function buildCustomerContext(options) {
-  return {
-    ...options.identityRequirement !== void 0 ? { identity_requirement: options.identityRequirement } : {},
-    ...options.contextTokens !== void 0 ? { context_tokens: options.contextTokens } : {},
-    ...options.customerAuth !== void 0 ? { portal_auth: options.customerAuth } : {}
-  };
-}
-function deepMerge(base, patch) {
-  const out = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    const existing = out[key];
-    if (isPlainObject(existing) && isPlainObject(value)) {
-      out[key] = deepMerge(existing, value);
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-function describeResourceUrn(urn) {
-  const parts = urn.split(":");
-  const kind = parts[3] ?? "resource";
-  const key = parts.slice(4).join(":");
-  return `${kind} "${decodeURIComponent(key)}"`;
-}
 
 // src/price.ts
 function toCents(dollars, label) {