@auth-gate/billing 0.8.0

package/dist/index.d.cts

@@ -0,0 +1,302 @@
+/** A tier definition for tiered/graduated pricing. */
+interface PriceTier {
+    /** Upper bound of this tier (units). Use Infinity or omit for the last tier. */
+    upTo?: number | "inf";
+    /** Per-unit amount in cents for this tier. */
+    unitAmount: number;
+    /** Flat fee in cents for this tier (optional). */
+    flatAmount?: number;
+}
+/** Base price fields shared by all pricing types. */
+interface PriceBase {
+    /** ISO 4217 currency code (e.g., "usd") */
+    currency: string;
+    /** Billing interval */
+    interval: "monthly" | "yearly";
+    /** Billing interval count (default: 1). E.g., 2 + "monthly" = every 2 months */
+    intervalCount?: number;
+}
+/** Standard recurring price (flat-rate). Type is optional for backward compat. */
+interface RecurringPriceConfig extends PriceBase {
+    type?: "recurring";
+    /** Price amount in cents (e.g., 1999 = $19.99) */
+    amount: number;
+}
+/** Per-seat pricing — amount per seat per interval. */
+interface PerSeatPriceConfig extends PriceBase {
+    type: "per_seat";
+    /** Price amount per seat in cents */
+    amount: number;
+    /** Usage metric that tracks seat count */
+    metric: string;
+}
+/** Usage-based metered pricing — charged based on consumption. */
+interface MeteredPriceConfig extends PriceBase {
+    type: "metered";
+    /** Usage metric name */
+    metric: string;
+    /** Tiers for graduated or volume pricing */
+    tiers: PriceTier[];
+    /** How tiers are applied */
+    tierMode: "graduated" | "volume";
+}
+/** Tiered pricing without a specific metric — uses flat tiers. */
+interface TieredPriceConfig extends PriceBase {
+    type: "tiered";
+    /** Tiers for graduated or volume pricing */
+    tiers: PriceTier[];
+    /** How tiers are applied */
+    tierMode: "graduated" | "volume";
+}
+/** Union of all price config types. */
+type PriceConfig = RecurringPriceConfig | PerSeatPriceConfig | MeteredPriceConfig | TieredPriceConfig;
+/** Grandfathering strategy when a plan's price changes. */
+type GrandfatheringStrategy = "keep_price" | "migrate_at_renewal" | "migrate_immediately";
+/** A plan (product) in the billing config. */
+interface PlanConfig {
+    /** Display name for the plan */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Feature flags this plan grants (e.g., ["analytics", "api_access"]) */
+    features?: string[];
+    /** Typed entitlements: { featureKey: true | { limit: number } } */
+    entitlements?: Record<string, EntitlementValue>;
+    /** Prices for this plan */
+    prices: PriceConfig[];
+    /** Previous config key if this plan was renamed. */
+    renamedFrom?: string;
+    /** How to handle existing subscribers when prices change. Default: "keep_price". */
+    grandfathering?: GrandfatheringStrategy;
+}
+/** Feature definition in the features registry. */
+interface FeatureConfig {
+    /** Feature type: boolean (on/off) or metered (usage-based with limits) */
+    type: "boolean" | "metered";
+}
+/** Entitlement value: true for boolean features, or { limit: number } for metered features. */
+type EntitlementValue = true | {
+    limit: number;
+};
+/** A migration directive: move subscribers from one plan to another. */
+interface MigrationConfig {
+    /** Source plan config key (must exist in DB) */
+    from: string;
+    /** Target plan config key (must exist in config.plans) */
+    to: string;
+    /** Explicit price mapping: { oldPriceConfigKey: newPriceConfigKey }. If omitted, matches by (interval, currency). */
+    priceMapping?: Record<string, string>;
+}
+/** Root billing config object. */
+interface BillingConfig {
+    /** Typed features registry. When defined, entitlements are validated against it. */
+    features?: Record<string, FeatureConfig>;
+    plans: Record<string, PlanConfig>;
+    /** Migration directives: move subscribers between plans during sync. */
+    migrations?: MigrationConfig[];
+}
+/** Return type of defineBilling() — same as input but branded for type narrowing. */
+type BillingDefinition = BillingConfig;
+/** Extract literal plan keys from a billing config type. */
+type InferPlanKeys<T> = T extends {
+    plans: infer P;
+} ? keyof P & string : never;
+/** Extract literal feature keys from a billing config type. */
+type InferFeatureKeys<T> = T extends {
+    features: infer F;
+} ? keyof F & string : never;
+/** Extract only the metered feature keys from a billing config type. */
+type InferMeteredFeatures<T> = T extends {
+    features: infer F;
+} ? {
+    [K in keyof F & string]: F[K] extends {
+        type: "metered";
+    } ? K : never;
+}[keyof F & string] : never;
+/** Structured plan object: `billing.plans.pro.key`, `.name`, `.entitlements` */
+type StructuredPlan<T, K extends string> = {
+    readonly key: K;
+    readonly name: T extends {
+        plans: infer P;
+    } ? K extends keyof P ? P[K] extends {
+        name: infer N;
+    } ? N : string : string : string;
+    readonly entitlements: T extends {
+        plans: infer P;
+    } ? K extends keyof P ? P[K] extends {
+        entitlements: infer E;
+    } ? Readonly<E> : {} : {} : {};
+};
+/** Map of plan keys to their structured plan objects. */
+type StructuredPlans<T> = {
+    readonly [K in InferPlanKeys<T>]: StructuredPlan<T, K>;
+};
+/** Structured feature object: `billing.features.api_calls.key`, `.type` */
+type StructuredFeature<T, K extends string> = {
+    readonly key: K;
+    readonly type: T extends {
+        features: infer F;
+    } ? K extends keyof F ? F[K] extends {
+        type: infer FT;
+    } ? FT : string : string : string;
+};
+/** Map of feature keys to their structured feature objects. */
+type StructuredFeatures<T> = T extends {
+    features: infer F;
+} ? {
+    readonly [K in keyof F & string]: StructuredFeature<T, K>;
+} : {};
+/**
+ * Typed billing definition returned by `defineBilling()`.
+ *
+ * Carries phantom types that downstream factories use to constrain
+ * plan/feature string parameters — enabling full IDE autocomplete.
+ *
+ * Plans and features are structured objects with `.key`, `.name`, `.entitlements` (plans)
+ * and `.key`, `.type` (features) for dot-notation access.
+ */
+interface TypedBilling<T extends BillingConfig> {
+    /** The raw billing config. Access plan objects, prices, etc. via `billing._config.plans.pro`. */
+    readonly _config: T;
+    /**
+     * Phantom type carrier — never read at runtime.
+     * Use `B["_types"]["planKey"]` to extract the plan key union from a `TypedBilling`.
+     */
+    readonly _types: {
+        readonly planKey: InferPlanKeys<T>;
+        readonly featureKey: InferFeatureKeys<T>;
+        readonly meteredFeature: InferMeteredFeatures<T>;
+    };
+    /** Structured plan objects: `billing.plans.pro.key` is `"pro"`, `.name` is `"Pro"`, etc. */
+    readonly plans: StructuredPlans<T>;
+    /** Structured feature objects: `billing.features.api_calls.key` is `"api_calls"`, `.type` is `"metered"`, etc. */
+    readonly features: StructuredFeatures<T>;
+}
+/** Extract the plan key union from a `TypedBilling` instance type. Falls back to `string`. */
+type PlanKey<B> = B extends TypedBilling<infer T> ? InferPlanKeys<T> : string;
+/** Extract the feature key union from a `TypedBilling` instance type. Falls back to `string`. */
+type FeatureKey<B> = B extends TypedBilling<infer T> ? InferFeatureKeys<T> : string;
+
+declare function validateConfig(config: unknown): BillingConfig;
+/**
+ * Normalize config by converting legacy `features: string[]` to typed `entitlements`.
+ * Does not mutate the input — returns a new config.
+ */
+declare function normalizeConfig(config: BillingConfig): BillingConfig;
+
+interface ServerProduct {
+    id: string;
+    configKey: string | null;
+    name: string;
+    description: string | null;
+    features: string[];
+    entitlements?: Record<string, EntitlementValue> | null;
+    version?: number;
+    grandfathering?: string;
+    isActive: boolean;
+    managedBy: string;
+    stripeProductId: string | null;
+    previousConfigKeys: string[];
+    prices: ServerPrice[];
+}
+interface ServerPrice {
+    id: string;
+    configKey: string | null;
+    amount: number | null;
+    currency: string;
+    interval: string;
+    intervalCount: number;
+    isActive: boolean;
+    stripePriceId: string | null;
+}
+interface ServerState {
+    products: ServerProduct[];
+}
+type PlanOp = {
+    type: "create";
+    key: string;
+    plan: BillingConfig["plans"][string];
+} | {
+    type: "update";
+    key: string;
+    plan: BillingConfig["plans"][string];
+    existing: ServerProduct;
+    changes: string[];
+    versionBump?: boolean;
+    grandfathering?: GrandfatheringStrategy;
+} | {
+    type: "archive";
+    key: string;
+    existing: ServerProduct;
+    activeSubscribers: number;
+} | {
+    type: "rename";
+    key: string;
+    oldKey: string;
+    plan: BillingConfig["plans"][string];
+    existing: ServerProduct;
+    activeSubscribers: number;
+};
+type PriceOp = {
+    type: "create";
+    planKey: string;
+    price: PriceConfig;
+    configKey: string;
+} | {
+    type: "archive";
+    planKey: string;
+    existing: ServerPrice;
+    configKey: string;
+};
+interface DiffResult {
+    planOps: PlanOp[];
+    priceOps: PriceOp[];
+    hasDestructive: boolean;
+}
+declare function priceConfigKey(planKey: string, price: PriceConfig): string;
+declare function computeDiff(config: BillingConfig, server: ServerState, subscriberCounts: Record<string, number>): DiffResult;
+
+interface PullOptions {
+    includeDashboard?: boolean;
+}
+interface PullResult {
+    config: BillingConfig;
+    dashboardPlans: Array<{
+        name: string;
+        suggestedKey: string;
+    }>;
+}
+declare function slugify(name: string): string;
+declare function serverStateToBillingConfig(state: ServerState, options?: PullOptions): PullResult;
+declare function renderConfigAsTypeScript(result: PullResult): string;
+
+/**
+ * Define your billing plans. Use this in your `authgate.billing.ts` config file.
+ *
+ * Returns a `TypedBilling<T>` object that carries plan and feature keys
+ * as literal types — enabling full IDE autocomplete across hooks, helpers,
+ * and test utilities.
+ *
+ * @example
+ * ```ts
+ * export const billing = defineBilling({
+ *   features: {
+ *     api_calls: { type: "metered" },
+ *     analytics: { type: "boolean" },
+ *   },
+ *   plans: {
+ *     free: { name: "Free", prices: [...] },
+ *     pro: { name: "Pro", prices: [...] },
+ *   },
+ * });
+ *
+ * billing.plans.pro.key         // "pro" — autocomplete + literal type
+ * billing.plans.pro.name        // "Pro"
+ * billing.plans.pro.entitlements // { api_calls: { limit: 10000 }, analytics: true }
+ * billing.features.api_calls.key  // "api_calls"
+ * billing.features.api_calls.type // "metered"
+ * ```
+ */
+declare function defineBilling<const T extends BillingConfig>(config: T): TypedBilling<T>;
+
+export { type BillingConfig, type BillingDefinition, type DiffResult, type EntitlementValue, type FeatureConfig, type FeatureKey, type GrandfatheringStrategy, type InferFeatureKeys, type InferMeteredFeatures, type InferPlanKeys, type MeteredPriceConfig, type PerSeatPriceConfig, type PlanConfig, type PlanKey, type PlanOp, type PriceConfig, type PriceOp, type PriceTier, type PullOptions, type PullResult, type RecurringPriceConfig, type ServerPrice, type ServerProduct, type ServerState, type TieredPriceConfig, type TypedBilling, computeDiff, defineBilling, normalizeConfig, priceConfigKey, renderConfigAsTypeScript, serverStateToBillingConfig, slugify, validateConfig };

package/dist/index.d.ts

@@ -0,0 +1,302 @@
+/** A tier definition for tiered/graduated pricing. */
+interface PriceTier {
+    /** Upper bound of this tier (units). Use Infinity or omit for the last tier. */
+    upTo?: number | "inf";
+    /** Per-unit amount in cents for this tier. */
+    unitAmount: number;
+    /** Flat fee in cents for this tier (optional). */
+    flatAmount?: number;
+}
+/** Base price fields shared by all pricing types. */
+interface PriceBase {
+    /** ISO 4217 currency code (e.g., "usd") */
+    currency: string;
+    /** Billing interval */
+    interval: "monthly" | "yearly";
+    /** Billing interval count (default: 1). E.g., 2 + "monthly" = every 2 months */
+    intervalCount?: number;
+}
+/** Standard recurring price (flat-rate). Type is optional for backward compat. */
+interface RecurringPriceConfig extends PriceBase {
+    type?: "recurring";
+    /** Price amount in cents (e.g., 1999 = $19.99) */
+    amount: number;
+}
+/** Per-seat pricing — amount per seat per interval. */
+interface PerSeatPriceConfig extends PriceBase {
+    type: "per_seat";
+    /** Price amount per seat in cents */
+    amount: number;
+    /** Usage metric that tracks seat count */
+    metric: string;
+}
+/** Usage-based metered pricing — charged based on consumption. */
+interface MeteredPriceConfig extends PriceBase {
+    type: "metered";
+    /** Usage metric name */
+    metric: string;
+    /** Tiers for graduated or volume pricing */
+    tiers: PriceTier[];
+    /** How tiers are applied */
+    tierMode: "graduated" | "volume";
+}
+/** Tiered pricing without a specific metric — uses flat tiers. */
+interface TieredPriceConfig extends PriceBase {
+    type: "tiered";
+    /** Tiers for graduated or volume pricing */
+    tiers: PriceTier[];
+    /** How tiers are applied */
+    tierMode: "graduated" | "volume";
+}
+/** Union of all price config types. */
+type PriceConfig = RecurringPriceConfig | PerSeatPriceConfig | MeteredPriceConfig | TieredPriceConfig;
+/** Grandfathering strategy when a plan's price changes. */
+type GrandfatheringStrategy = "keep_price" | "migrate_at_renewal" | "migrate_immediately";
+/** A plan (product) in the billing config. */
+interface PlanConfig {
+    /** Display name for the plan */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Feature flags this plan grants (e.g., ["analytics", "api_access"]) */
+    features?: string[];
+    /** Typed entitlements: { featureKey: true | { limit: number } } */
+    entitlements?: Record<string, EntitlementValue>;
+    /** Prices for this plan */
+    prices: PriceConfig[];
+    /** Previous config key if this plan was renamed. */
+    renamedFrom?: string;
+    /** How to handle existing subscribers when prices change. Default: "keep_price". */
+    grandfathering?: GrandfatheringStrategy;
+}
+/** Feature definition in the features registry. */
+interface FeatureConfig {
+    /** Feature type: boolean (on/off) or metered (usage-based with limits) */
+    type: "boolean" | "metered";
+}
+/** Entitlement value: true for boolean features, or { limit: number } for metered features. */
+type EntitlementValue = true | {
+    limit: number;
+};
+/** A migration directive: move subscribers from one plan to another. */
+interface MigrationConfig {
+    /** Source plan config key (must exist in DB) */
+    from: string;
+    /** Target plan config key (must exist in config.plans) */
+    to: string;
+    /** Explicit price mapping: { oldPriceConfigKey: newPriceConfigKey }. If omitted, matches by (interval, currency). */
+    priceMapping?: Record<string, string>;
+}
+/** Root billing config object. */
+interface BillingConfig {
+    /** Typed features registry. When defined, entitlements are validated against it. */
+    features?: Record<string, FeatureConfig>;
+    plans: Record<string, PlanConfig>;
+    /** Migration directives: move subscribers between plans during sync. */
+    migrations?: MigrationConfig[];
+}
+/** Return type of defineBilling() — same as input but branded for type narrowing. */
+type BillingDefinition = BillingConfig;
+/** Extract literal plan keys from a billing config type. */
+type InferPlanKeys<T> = T extends {
+    plans: infer P;
+} ? keyof P & string : never;
+/** Extract literal feature keys from a billing config type. */
+type InferFeatureKeys<T> = T extends {
+    features: infer F;
+} ? keyof F & string : never;
+/** Extract only the metered feature keys from a billing config type. */
+type InferMeteredFeatures<T> = T extends {
+    features: infer F;
+} ? {
+    [K in keyof F & string]: F[K] extends {
+        type: "metered";
+    } ? K : never;
+}[keyof F & string] : never;
+/** Structured plan object: `billing.plans.pro.key`, `.name`, `.entitlements` */
+type StructuredPlan<T, K extends string> = {
+    readonly key: K;
+    readonly name: T extends {
+        plans: infer P;
+    } ? K extends keyof P ? P[K] extends {
+        name: infer N;
+    } ? N : string : string : string;
+    readonly entitlements: T extends {
+        plans: infer P;
+    } ? K extends keyof P ? P[K] extends {
+        entitlements: infer E;
+    } ? Readonly<E> : {} : {} : {};
+};
+/** Map of plan keys to their structured plan objects. */
+type StructuredPlans<T> = {
+    readonly [K in InferPlanKeys<T>]: StructuredPlan<T, K>;
+};
+/** Structured feature object: `billing.features.api_calls.key`, `.type` */
+type StructuredFeature<T, K extends string> = {
+    readonly key: K;
+    readonly type: T extends {
+        features: infer F;
+    } ? K extends keyof F ? F[K] extends {
+        type: infer FT;
+    } ? FT : string : string : string;
+};
+/** Map of feature keys to their structured feature objects. */
+type StructuredFeatures<T> = T extends {
+    features: infer F;
+} ? {
+    readonly [K in keyof F & string]: StructuredFeature<T, K>;
+} : {};
+/**
+ * Typed billing definition returned by `defineBilling()`.
+ *
+ * Carries phantom types that downstream factories use to constrain
+ * plan/feature string parameters — enabling full IDE autocomplete.
+ *
+ * Plans and features are structured objects with `.key`, `.name`, `.entitlements` (plans)
+ * and `.key`, `.type` (features) for dot-notation access.
+ */
+interface TypedBilling<T extends BillingConfig> {
+    /** The raw billing config. Access plan objects, prices, etc. via `billing._config.plans.pro`. */
+    readonly _config: T;
+    /**
+     * Phantom type carrier — never read at runtime.
+     * Use `B["_types"]["planKey"]` to extract the plan key union from a `TypedBilling`.
+     */
+    readonly _types: {
+        readonly planKey: InferPlanKeys<T>;
+        readonly featureKey: InferFeatureKeys<T>;
+        readonly meteredFeature: InferMeteredFeatures<T>;
+    };
+    /** Structured plan objects: `billing.plans.pro.key` is `"pro"`, `.name` is `"Pro"`, etc. */
+    readonly plans: StructuredPlans<T>;
+    /** Structured feature objects: `billing.features.api_calls.key` is `"api_calls"`, `.type` is `"metered"`, etc. */
+    readonly features: StructuredFeatures<T>;
+}
+/** Extract the plan key union from a `TypedBilling` instance type. Falls back to `string`. */
+type PlanKey<B> = B extends TypedBilling<infer T> ? InferPlanKeys<T> : string;
+/** Extract the feature key union from a `TypedBilling` instance type. Falls back to `string`. */
+type FeatureKey<B> = B extends TypedBilling<infer T> ? InferFeatureKeys<T> : string;
+
+declare function validateConfig(config: unknown): BillingConfig;
+/**
+ * Normalize config by converting legacy `features: string[]` to typed `entitlements`.
+ * Does not mutate the input — returns a new config.
+ */
+declare function normalizeConfig(config: BillingConfig): BillingConfig;
+
+interface ServerProduct {
+    id: string;
+    configKey: string | null;
+    name: string;
+    description: string | null;
+    features: string[];
+    entitlements?: Record<string, EntitlementValue> | null;
+    version?: number;
+    grandfathering?: string;
+    isActive: boolean;
+    managedBy: string;
+    stripeProductId: string | null;
+    previousConfigKeys: string[];
+    prices: ServerPrice[];
+}
+interface ServerPrice {
+    id: string;
+    configKey: string | null;
+    amount: number | null;
+    currency: string;
+    interval: string;
+    intervalCount: number;
+    isActive: boolean;
+    stripePriceId: string | null;
+}
+interface ServerState {
+    products: ServerProduct[];
+}
+type PlanOp = {
+    type: "create";
+    key: string;
+    plan: BillingConfig["plans"][string];
+} | {
+    type: "update";
+    key: string;
+    plan: BillingConfig["plans"][string];
+    existing: ServerProduct;
+    changes: string[];
+    versionBump?: boolean;
+    grandfathering?: GrandfatheringStrategy;
+} | {
+    type: "archive";
+    key: string;
+    existing: ServerProduct;
+    activeSubscribers: number;
+} | {
+    type: "rename";
+    key: string;
+    oldKey: string;
+    plan: BillingConfig["plans"][string];
+    existing: ServerProduct;
+    activeSubscribers: number;
+};
+type PriceOp = {
+    type: "create";
+    planKey: string;
+    price: PriceConfig;
+    configKey: string;
+} | {
+    type: "archive";
+    planKey: string;
+    existing: ServerPrice;
+    configKey: string;
+};
+interface DiffResult {
+    planOps: PlanOp[];
+    priceOps: PriceOp[];
+    hasDestructive: boolean;
+}
+declare function priceConfigKey(planKey: string, price: PriceConfig): string;
+declare function computeDiff(config: BillingConfig, server: ServerState, subscriberCounts: Record<string, number>): DiffResult;
+
+interface PullOptions {
+    includeDashboard?: boolean;
+}
+interface PullResult {
+    config: BillingConfig;
+    dashboardPlans: Array<{
+        name: string;
+        suggestedKey: string;
+    }>;
+}
+declare function slugify(name: string): string;
+declare function serverStateToBillingConfig(state: ServerState, options?: PullOptions): PullResult;
+declare function renderConfigAsTypeScript(result: PullResult): string;
+
+/**
+ * Define your billing plans. Use this in your `authgate.billing.ts` config file.
+ *
+ * Returns a `TypedBilling<T>` object that carries plan and feature keys
+ * as literal types — enabling full IDE autocomplete across hooks, helpers,
+ * and test utilities.
+ *
+ * @example
+ * ```ts
+ * export const billing = defineBilling({
+ *   features: {
+ *     api_calls: { type: "metered" },
+ *     analytics: { type: "boolean" },
+ *   },
+ *   plans: {
+ *     free: { name: "Free", prices: [...] },
+ *     pro: { name: "Pro", prices: [...] },
+ *   },
+ * });
+ *
+ * billing.plans.pro.key         // "pro" — autocomplete + literal type
+ * billing.plans.pro.name        // "Pro"
+ * billing.plans.pro.entitlements // { api_calls: { limit: 10000 }, analytics: true }
+ * billing.features.api_calls.key  // "api_calls"
+ * billing.features.api_calls.type // "metered"
+ * ```
+ */
+declare function defineBilling<const T extends BillingConfig>(config: T): TypedBilling<T>;
+
+export { type BillingConfig, type BillingDefinition, type DiffResult, type EntitlementValue, type FeatureConfig, type FeatureKey, type GrandfatheringStrategy, type InferFeatureKeys, type InferMeteredFeatures, type InferPlanKeys, type MeteredPriceConfig, type PerSeatPriceConfig, type PlanConfig, type PlanKey, type PlanOp, type PriceConfig, type PriceOp, type PriceTier, type PullOptions, type PullResult, type RecurringPriceConfig, type ServerPrice, type ServerProduct, type ServerState, type TieredPriceConfig, type TypedBilling, computeDiff, defineBilling, normalizeConfig, priceConfigKey, renderConfigAsTypeScript, serverStateToBillingConfig, slugify, validateConfig };

package/dist/index.mjs

@@ -0,0 +1,49 @@
+import {
+  computeDiff,
+  normalizeConfig,
+  priceConfigKey,
+  renderConfigAsTypeScript,
+  serverStateToBillingConfig,
+  slugify,
+  validateConfig
+} from "./chunk-AHCLNQ6P.mjs";
+import "./chunk-I4E63NIC.mjs";
+
+// src/index.ts
+function defineBilling(config) {
+  var _a;
+  const plans = {};
+  for (const [key, plan] of Object.entries(config.plans)) {
+    plans[key] = {
+      key,
+      name: plan.name,
+      entitlements: (_a = plan.entitlements) != null ? _a : {}
+    };
+  }
+  const features = {};
+  if (config.features) {
+    for (const [key, feature] of Object.entries(config.features)) {
+      features[key] = {
+        key,
+        type: feature.type
+      };
+    }
+  }
+  return {
+    _config: config,
+    _types: void 0,
+    // phantom — never read at runtime
+    plans,
+    features
+  };
+}
+export {
+  computeDiff,
+  defineBilling,
+  normalizeConfig,
+  priceConfigKey,
+  renderConfigAsTypeScript,
+  serverStateToBillingConfig,
+  slugify,
+  validateConfig
+};

package/dist/pull-from-stripe-GX2Y5XMC.mjs

@@ -0,0 +1,49 @@
+import "./chunk-I4E63NIC.mjs";
+
+// src/pull-from-stripe.ts
+async function fetchStripeState(stripeKey) {
+  var _a, _b, _c, _d, _e;
+  const Stripe = (await import("stripe")).default;
+  const stripe = new Stripe(stripeKey);
+  const [products, prices] = await Promise.all([
+    stripe.products.list({ active: true, limit: 100 }),
+    stripe.prices.list({ active: true, limit: 100 })
+  ]);
+  const pricesByProduct = /* @__PURE__ */ new Map();
+  for (const sp of prices.data) {
+    const productId = typeof sp.product === "string" ? sp.product : sp.product.id;
+    const mapped = {
+      id: sp.id,
+      configKey: null,
+      amount: sp.unit_amount,
+      currency: sp.currency,
+      interval: (_b = (_a = sp.recurring) == null ? void 0 : _a.interval) != null ? _b : "monthly",
+      intervalCount: (_d = (_c = sp.recurring) == null ? void 0 : _c.interval_count) != null ? _d : 1,
+      isActive: sp.active,
+      stripePriceId: sp.id
+    };
+    pricesByProduct.set(productId, [
+      ...(_e = pricesByProduct.get(productId)) != null ? _e : [],
+      mapped
+    ]);
+  }
+  const serverProducts = products.data.map((p) => {
+    var _a2;
+    return {
+      id: p.id,
+      configKey: null,
+      name: p.name,
+      description: p.description,
+      features: [],
+      isActive: p.active,
+      managedBy: "config",
+      stripeProductId: p.id,
+      previousConfigKeys: [],
+      prices: (_a2 = pricesByProduct.get(p.id)) != null ? _a2 : []
+    };
+  });
+  return { products: serverProducts };
+}
+export {
+  fetchStripeState
+};