@pipeline-builder/api-core 3.4.100 → 3.4.102

package/lib/testing/tier-mock.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared tier fixture for the per-package `@pipeline-builder/api-core` test
+ * mocks (each suite's `test/helpers/mock-api-core.ts`).
+ *
+ * WHY A SEPARATE MODULE: every service mocks `@pipeline-builder/api-core` via
+ * `jest.unstable_mockModule('@pipeline-builder/api-core', …)`. That intercepts the
+ * *package* specifier only — this file is imported through the DEEP built path
+ * `@pipeline-builder/api-core/lib/testing/tier-mock.js`, a different specifier the
+ * mock does NOT intercept, so a mock can pull real, complete tier data without
+ * self-referencing its own mock. api-core has no `exports` map, so the subpath
+ * resolves; both sides are ESM so there's no interop wrinkle.
+ *
+ * WHAT IT BUYS: the tier NAME LIST is sourced from the real `VALID_TIERS`, so
+ * adding a tier in `quota-tiers.ts` flows into every mock automatically — no more
+ * "add a tier → hand-edit N mocks, discover the misses one gate round at a time"
+ * (which is exactly how the `unlimited` tier broke pipeline-core/api-server/platform).
+ * `mockQuotaTiers()` builds a COMPLETE `QUOTA_TIERS` (an entry for every tier) from
+ * caller-supplied per-tier limits, defaulting any unspecified tier to uncapped — so
+ * a new tier can never leave a `QUOTA_TIERS[tier].limits` undefined at mock load.
+ */
+import { type FeatureFlag } from '../types/feature-flags.js';
+import { type QuotaTier, type QuotaTierLimits } from '../types/quota-tiers.js';
+/** The real, complete tier-name list — the single source mocks derive from. */
+export declare const MOCK_TIER_NAMES: readonly QuotaTier[];
+/** Mirrors api-core's `isValidTier`, driven by the shared name list. */
+export declare const mockIsValidTier: (t: string) => boolean;
+type TierPreset = {
+    label: string;
+    limits: QuotaTierLimits;
+};
+/**
+ * Build a COMPLETE `QUOTA_TIERS` map (one entry per real tier) for a mock.
+ * Pass the per-tier limit overrides a suite actually asserts on; every other
+ * dimension (and every unspecified tier) falls back to uncapped, so the map is
+ * always exhaustive over `VALID_TIERS` — the property that keeps a newly-added
+ * tier from crashing mock load.
+ */
+export declare function mockQuotaTiers(limitsByTier?: Partial<Record<QuotaTier, Partial<QuotaTierLimits>>>): Record<QuotaTier, TierPreset>;
+/**
+ * Build a COMPLETE `TIER_FEATURES` map. Defaults every tier to all feature flags
+ * (the common mock stance); pass overrides for suites that assert a narrower set.
+ */
+export declare function mockTierFeatures(featuresByTier?: Partial<Record<QuotaTier, readonly FeatureFlag[]>>): Record<QuotaTier, readonly FeatureFlag[]>;
+export {};

package/lib/testing/tier-mock.js

@@ -0,0 +1,63 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared tier fixture for the per-package `@pipeline-builder/api-core` test
+ * mocks (each suite's `test/helpers/mock-api-core.ts`).
+ *
+ * WHY A SEPARATE MODULE: every service mocks `@pipeline-builder/api-core` via
+ * `jest.unstable_mockModule('@pipeline-builder/api-core', …)`. That intercepts the
+ * *package* specifier only — this file is imported through the DEEP built path
+ * `@pipeline-builder/api-core/lib/testing/tier-mock.js`, a different specifier the
+ * mock does NOT intercept, so a mock can pull real, complete tier data without
+ * self-referencing its own mock. api-core has no `exports` map, so the subpath
+ * resolves; both sides are ESM so there's no interop wrinkle.
+ *
+ * WHAT IT BUYS: the tier NAME LIST is sourced from the real `VALID_TIERS`, so
+ * adding a tier in `quota-tiers.ts` flows into every mock automatically — no more
+ * "add a tier → hand-edit N mocks, discover the misses one gate round at a time"
+ * (which is exactly how the `unlimited` tier broke pipeline-core/api-server/platform).
+ * `mockQuotaTiers()` builds a COMPLETE `QUOTA_TIERS` (an entry for every tier) from
+ * caller-supplied per-tier limits, defaulting any unspecified tier to uncapped — so
+ * a new tier can never leave a `QUOTA_TIERS[tier].limits` undefined at mock load.
+ */
+import { ALL_FEATURE_FLAGS } from '../types/feature-flags.js';
+import { VALID_TIERS } from '../types/quota-tiers.js';
+/** The real, complete tier-name list — the single source mocks derive from. */
+export const MOCK_TIER_NAMES = VALID_TIERS;
+/** Mirrors api-core's `isValidTier`, driven by the shared name list. */
+export const mockIsValidTier = (t) => MOCK_TIER_NAMES.includes(t);
+/** Every quota dimension uncapped — the default for tiers a caller doesn't specify. */
+const uncappedLimits = () => ({
+    seats: -1,
+    plugins: -1,
+    pipelines: -1,
+    apiCalls: -1,
+    aiCalls: -1,
+    storageBytes: -1,
+    dashboards: -1,
+    alertRules: -1,
+    alertDestinations: -1,
+    idpConfigs: -1,
+});
+const titleCase = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+/**
+ * Build a COMPLETE `QUOTA_TIERS` map (one entry per real tier) for a mock.
+ * Pass the per-tier limit overrides a suite actually asserts on; every other
+ * dimension (and every unspecified tier) falls back to uncapped, so the map is
+ * always exhaustive over `VALID_TIERS` — the property that keeps a newly-added
+ * tier from crashing mock load.
+ */
+export function mockQuotaTiers(limitsByTier = {}) {
+    return Object.fromEntries(MOCK_TIER_NAMES.map((t) => [
+        t,
+        { label: titleCase(t), limits: { ...uncappedLimits(), ...(limitsByTier[t] ?? {}) } },
+    ]));
+}
+/**
+ * Build a COMPLETE `TIER_FEATURES` map. Defaults every tier to all feature flags
+ * (the common mock stance); pass overrides for suites that assert a narrower set.
+ */
+export function mockTierFeatures(featuresByTier = {}) {
+    return Object.fromEntries(MOCK_TIER_NAMES.map((t) => [t, featuresByTier[t] ?? [...ALL_FEATURE_FLAGS]]));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/feature-flags.js

@@ -26,6 +26,8 @@ export const TIER_FEATURES = {
     // tier (see billing-config `advanced_reporting`). Enterprise unlocks all.
     team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],
     enterprise: [...ALL_FEATURE_FLAGS],
+    // Unlimited includes every feature / add-on bundle (billing-disabled default).
+    unlimited: [...ALL_FEATURE_FLAGS],
 };
 // Feature metadata (for display)
 /** Human-readable metadata for each feature flag. */
@@ -112,4 +114,4 @@ export function resolveUserFeatures(tier, opts) {
     // Return in canonical order
     return ALL_FEATURE_FLAGS.filter(f => features.has(f));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/types/feature-flags.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// Feature flag identifiers\n\n/** Canonical feature flag identifiers. */\nexport type FeatureFlag =\n  // `priority_support` and `custom_integrations` are ENTERPRISE-EXCLUSIVE\n  // marketing/entitlement flags: granted only by the enterprise tier (no add-on\n  // bundle sells them to a lower tier — intentional, they anchor the Enterprise\n  // plan) and not currently `requireFeature`-gated on any route (they surface in\n  // plan marketing + the entitlement set; enforcement is a future hook). This is\n  // by design, not dead code — do not \"fix\" by wiring a bundle without a pricing\n  // decision. Contrast `audit_log`/`sso`/`advanced_reporting`, which ARE sold as\n  // add-on bundles and gated (see billing-config `loadBundles` + `requireFeature`).\n  | 'priority_support'\n  | 'custom_integrations'\n  | 'ai_generation'\n  | 'bulk_operations'\n  | 'audit_log'\n  | 'sso'\n  // DORA / advanced delivery analytics (paid tiers only).\n  | 'advanced_reporting'\n  // Per-team usage breakdown across the org→team subtree. INCLUDED in Enterprise;\n  // sold as an add-on bundle to Pro/Team (see billing-config `team_usage_analytics`).\n  | 'team_usage_analytics';\n\n/** All valid feature flags (order determines display order). */\nexport const ALL_FEATURE_FLAGS: readonly FeatureFlag[] = [\n  'priority_support',\n  'ai_generation',\n  'bulk_operations',\n  'custom_integrations',\n  'audit_log',\n  'sso',\n  'advanced_reporting',\n  'team_usage_analytics',\n];\n\n/** Check whether a string is a valid FeatureFlag. */\nexport function isValidFeatureFlag(value: string): value is FeatureFlag {\n  return (ALL_FEATURE_FLAGS as readonly string[]).includes(value);\n}\n\n// Tier-to-feature mapping\n\n/** Features enabled by default for each tier. */\nexport const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]> = {\n  developer: [],\n  pro: ['priority_support', 'ai_generation', 'bulk_operations'],\n  // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED\n  // in Team, not an add-on). advanced_reporting (DORA) is NOT a Team tier feature —\n  // it's INCLUDED only in Enterprise and sold as an add-on bundle to every other\n  // tier (see billing-config `advanced_reporting`). Enterprise unlocks all.\n  team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],\n  enterprise: [...ALL_FEATURE_FLAGS],\n};\n\n// Feature metadata (for display)\n\n/** Human-readable metadata for each feature flag. */\nexport const FEATURE_METADATA: Record<FeatureFlag, { label: string; description: string }> = {\n  priority_support: {\n    label: 'Priority Support',\n    description: 'Faster response times and dedicated support channels',\n  },\n  ai_generation: {\n    label: 'AI Generation',\n    description: 'AI-powered pipeline and plugin generation',\n  },\n  bulk_operations: {\n    label: 'Bulk Operations',\n    description: 'Batch create, update, and delete for pipelines and plugins',\n  },\n  custom_integrations: {\n    label: 'Custom Integrations',\n    description: 'Connect to external services and custom webhook endpoints',\n  },\n  audit_log: {\n    label: 'Audit Log',\n    description: 'Detailed audit trail of all user and system actions',\n  },\n  sso: {\n    label: 'SSO / IdP',\n    description: 'Single sign-on and external identity-provider configurations',\n  },\n  advanced_reporting: {\n    label: 'Advanced Reporting',\n    description: 'DORA / advanced delivery analytics',\n  },\n  team_usage_analytics: {\n    label: 'Team Usage Analytics',\n    description: 'Per-team usage breakdown across the org → team subtree',\n  },\n};\n\n// Resolution logic\n\n/**\n * Resolve a user's effective feature set.\n *\n * 1. Sysadmins (isSuperAdmin) always get ALL features.\n * 2. Start with the tier's default features.\n * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.\n * 4. Invalid override keys are silently ignored.\n *\n * @param tier - The organization's quota tier\n * @param opts - Resolution options:\n *   - `overrides`: per-user overrides (key = feature flag, value = enabled)\n *   - `isSuperAdmin`: whether the user has the global super-admin flag\n *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on\n *     bundles). A NAMED field so it can never be silently dropped by a caller\n *     that omits a trailing positional arg.\n * @returns Sorted array of enabled feature flags\n */\nexport function resolveUserFeatures(\n  tier: QuotaTier,\n  opts?: {\n    overrides?: Record<string, boolean> | null;\n    isSuperAdmin?: boolean;\n    accountFeatures?: readonly string[] | null;\n  },\n): FeatureFlag[] {\n  const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};\n\n  // Sysadmins get everything regardless of tier.\n  if (isSuperAdmin) return [...ALL_FEATURE_FLAGS];\n\n  // Start with tier defaults\n  const features = new Set<FeatureFlag>(TIER_FEATURES[tier] ?? []);\n\n  // Account-level entitlements (purchased feature bundles — audit_log/sso).\n  // Applied before per-user overrides so an explicit user override still wins.\n  if (accountFeatures) {\n    for (const key of accountFeatures) {\n      if (isValidFeatureFlag(key)) features.add(key);\n    }\n  }\n\n  // Apply per-user overrides\n  if (featureOverrides) {\n    for (const [key, enabled] of Object.entries(featureOverrides)) {\n      if (!isValidFeatureFlag(key)) continue;\n      if (enabled) {\n        features.add(key);\n      } else {\n        features.delete(key);\n      }\n    }\n  }\n\n  // Return in canonical order\n  return ALL_FEATURE_FLAGS.filter(f => features.has(f));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/types/feature-flags.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA4BtC,gEAAgE;AAChE,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD,kBAAkB;IAClB,eAAe;IACf,iBAAiB;IACjB,qBAAqB;IACrB,WAAW;IACX,KAAK;IACL,oBAAoB;IACpB,sBAAsB;CACvB,CAAC;AAEF,qDAAqD;AACrD,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAQ,iBAAuC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC;AAED,0BAA0B;AAE1B,iDAAiD;AACjD,MAAM,CAAC,MAAM,aAAa,GAA8C;IACtE,SAAS,EAAE,EAAE;IACb,GAAG,EAAE,CAAC,kBAAkB,EAAE,eAAe,EAAE,iBAAiB,CAAC;IAC7D,8EAA8E;IAC9E,kFAAkF;IAClF,+EAA+E;IAC/E,0EAA0E;IAC1E,IAAI,EAAE,CAAC,kBAAkB,EAAE,eAAe,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,CAAC;IAClF,UAAU,EAAE,CAAC,GAAG,iBAAiB,CAAC;IAClC,+EAA+E;IAC/E,SAAS,EAAE,CAAC,GAAG,iBAAiB,CAAC;CAClC,CAAC;AAEF,iCAAiC;AAEjC,qDAAqD;AACrD,MAAM,CAAC,MAAM,gBAAgB,GAAgE;IAC3F,gBAAgB,EAAE;QAChB,KAAK,EAAE,kBAAkB;QACzB,WAAW,EAAE,sDAAsD;KACpE;IACD,aAAa,EAAE;QACb,KAAK,EAAE,eAAe;QACtB,WAAW,EAAE,2CAA2C;KACzD;IACD,eAAe,EAAE;QACf,KAAK,EAAE,iBAAiB;QACxB,WAAW,EAAE,4DAA4D;KAC1E;IACD,mBAAmB,EAAE;QACnB,KAAK,EAAE,qBAAqB;QAC5B,WAAW,EAAE,2DAA2D;KACzE;IACD,SAAS,EAAE;QACT,KAAK,EAAE,WAAW;QAClB,WAAW,EAAE,qDAAqD;KACnE;IACD,GAAG,EAAE;QACH,KAAK,EAAE,WAAW;QAClB,WAAW,EAAE,8DAA8D;KAC5E;IACD,kBAAkB,EAAE;QAClB,KAAK,EAAE,oBAAoB;QAC3B,WAAW,EAAE,oCAAoC;KAClD;IACD,oBAAoB,EAAE;QACpB,KAAK,EAAE,sBAAsB;QAC7B,WAAW,EAAE,wDAAwD;KACtE;CACF,CAAC;AAEF,mBAAmB;AAEnB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAe,EACf,IAIC;IAED,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;IAElF,+CAA+C;IAC/C,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,iBAAiB,CAAC,CAAC;IAEhD,2BAA2B;IAC3B,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAc,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAEjE,0EAA0E;IAC1E,6EAA6E;IAC7E,IAAI,eAAe,EAAE,CAAC;QACpB,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YAClC,IAAI,kBAAkB,CAAC,GAAG,CAAC;gBAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED,2BAA2B;IAC3B,IAAI,gBAAgB,EAAE,CAAC;QACrB,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC9D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC;gBAAE,SAAS;YACvC,IAAI,OAAO,EAAE,CAAC;gBACZ,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAED,4BAA4B;IAC5B,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// Feature flag identifiers\n\n/** Canonical feature flag identifiers. */\nexport type FeatureFlag =\n  // `priority_support` and `custom_integrations` are ENTERPRISE-EXCLUSIVE\n  // marketing/entitlement flags: granted only by the enterprise tier (no add-on\n  // bundle sells them to a lower tier — intentional, they anchor the Enterprise\n  // plan) and not currently `requireFeature`-gated on any route (they surface in\n  // plan marketing + the entitlement set; enforcement is a future hook). This is\n  // by design, not dead code — do not \"fix\" by wiring a bundle without a pricing\n  // decision. Contrast `audit_log`/`sso`/`advanced_reporting`, which ARE sold as\n  // add-on bundles and gated (see billing-config `loadBundles` + `requireFeature`).\n  | 'priority_support'\n  | 'custom_integrations'\n  | 'ai_generation'\n  | 'bulk_operations'\n  | 'audit_log'\n  | 'sso'\n  // DORA / advanced delivery analytics (paid tiers only).\n  | 'advanced_reporting'\n  // Per-team usage breakdown across the org→team subtree. INCLUDED in Enterprise;\n  // sold as an add-on bundle to Pro/Team (see billing-config `team_usage_analytics`).\n  | 'team_usage_analytics';\n\n/** All valid feature flags (order determines display order). */\nexport const ALL_FEATURE_FLAGS: readonly FeatureFlag[] = [\n  'priority_support',\n  'ai_generation',\n  'bulk_operations',\n  'custom_integrations',\n  'audit_log',\n  'sso',\n  'advanced_reporting',\n  'team_usage_analytics',\n];\n\n/** Check whether a string is a valid FeatureFlag. */\nexport function isValidFeatureFlag(value: string): value is FeatureFlag {\n  return (ALL_FEATURE_FLAGS as readonly string[]).includes(value);\n}\n\n// Tier-to-feature mapping\n\n/** Features enabled by default for each tier. */\nexport const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]> = {\n  developer: [],\n  pro: ['priority_support', 'ai_generation', 'bulk_operations'],\n  // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED\n  // in Team, not an add-on). advanced_reporting (DORA) is NOT a Team tier feature —\n  // it's INCLUDED only in Enterprise and sold as an add-on bundle to every other\n  // tier (see billing-config `advanced_reporting`). Enterprise unlocks all.\n  team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],\n  enterprise: [...ALL_FEATURE_FLAGS],\n  // Unlimited includes every feature / add-on bundle (billing-disabled default).\n  unlimited: [...ALL_FEATURE_FLAGS],\n};\n\n// Feature metadata (for display)\n\n/** Human-readable metadata for each feature flag. */\nexport const FEATURE_METADATA: Record<FeatureFlag, { label: string; description: string }> = {\n  priority_support: {\n    label: 'Priority Support',\n    description: 'Faster response times and dedicated support channels',\n  },\n  ai_generation: {\n    label: 'AI Generation',\n    description: 'AI-powered pipeline and plugin generation',\n  },\n  bulk_operations: {\n    label: 'Bulk Operations',\n    description: 'Batch create, update, and delete for pipelines and plugins',\n  },\n  custom_integrations: {\n    label: 'Custom Integrations',\n    description: 'Connect to external services and custom webhook endpoints',\n  },\n  audit_log: {\n    label: 'Audit Log',\n    description: 'Detailed audit trail of all user and system actions',\n  },\n  sso: {\n    label: 'SSO / IdP',\n    description: 'Single sign-on and external identity-provider configurations',\n  },\n  advanced_reporting: {\n    label: 'Advanced Reporting',\n    description: 'DORA / advanced delivery analytics',\n  },\n  team_usage_analytics: {\n    label: 'Team Usage Analytics',\n    description: 'Per-team usage breakdown across the org → team subtree',\n  },\n};\n\n// Resolution logic\n\n/**\n * Resolve a user's effective feature set.\n *\n * 1. Sysadmins (isSuperAdmin) always get ALL features.\n * 2. Start with the tier's default features.\n * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.\n * 4. Invalid override keys are silently ignored.\n *\n * @param tier - The organization's quota tier\n * @param opts - Resolution options:\n *   - `overrides`: per-user overrides (key = feature flag, value = enabled)\n *   - `isSuperAdmin`: whether the user has the global super-admin flag\n *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on\n *     bundles). A NAMED field so it can never be silently dropped by a caller\n *     that omits a trailing positional arg.\n * @returns Sorted array of enabled feature flags\n */\nexport function resolveUserFeatures(\n  tier: QuotaTier,\n  opts?: {\n    overrides?: Record<string, boolean> | null;\n    isSuperAdmin?: boolean;\n    accountFeatures?: readonly string[] | null;\n  },\n): FeatureFlag[] {\n  const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};\n\n  // Sysadmins get everything regardless of tier.\n  if (isSuperAdmin) return [...ALL_FEATURE_FLAGS];\n\n  // Start with tier defaults\n  const features = new Set<FeatureFlag>(TIER_FEATURES[tier] ?? []);\n\n  // Account-level entitlements (purchased feature bundles — audit_log/sso).\n  // Applied before per-user overrides so an explicit user override still wins.\n  if (accountFeatures) {\n    for (const key of accountFeatures) {\n      if (isValidFeatureFlag(key)) features.add(key);\n    }\n  }\n\n  // Apply per-user overrides\n  if (featureOverrides) {\n    for (const [key, enabled] of Object.entries(featureOverrides)) {\n      if (!isValidFeatureFlag(key)) continue;\n      if (enabled) {\n        features.add(key);\n      } else {\n        features.delete(key);\n      }\n    }\n  }\n\n  // Return in canonical order\n  return ALL_FEATURE_FLAGS.filter(f => features.has(f));\n}\n"]}

package/lib/types/quota-tiers.d.ts

@@ -1,5 +1,10 @@
-/** Available quota tier identifiers. */
-export type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise';
+/** Available quota tier identifiers.
+ *
+ * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes
+ * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no
+ * metering/enforcement surface exists, so nothing is capped), and it is NEVER
+ * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */
+export type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';
 /** Limit values for each quota type within a tier. */
 export interface QuotaTierLimits {
     plugins: number;
@@ -32,12 +37,22 @@ export interface QuotaTierPreset {
     limits: QuotaTierLimits;
 }
 export declare const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset>;
-/** All valid tier names. */
+/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*
+ *  tier — `unlimited` is a valid value even though it's never offered for sale. */
 export declare const VALID_TIERS: readonly QuotaTier[];
+/** The standard, billing-selectable tiers — the ones offered as purchasable plans
+ *  and shown in tier pickers. Derived as "every valid tier except `unlimited`",
+ *  which is the billing-DISABLED default and is never displayed/selectable when
+ *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */
+export declare const STANDARD_TIERS: readonly QuotaTier[];
+/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,
+ *  opt-out default-on — mirrors the billing/platform configs). With billing OFF
+ *  there's no metering/enforcement surface, so the default tier is `unlimited`. */
+export declare function isBillingEnabled(): boolean;
 /**
- * Default tier assigned to new organizations. Overridable via the
- * `DEFAULT_QUOTA_TIER` env var (one of developer|pro|team|enterprise);
- * an invalid/unset value falls back to 'developer'.
+ * Default tier assigned to new organizations.
+ * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).
+ * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.
  */
 export declare const DEFAULT_TIER: QuotaTier;
 /** Check whether a string is a valid QuotaTier. */

package/lib/types/quota-tiers.js

@@ -78,6 +78,20 @@ const DEFAULT_TIER_LIMITS = {
         idpConfigs: -1,
         seats: 25,
     },
+    // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled
+    // (no enforcement surface) — never shown/selectable when billing is enabled.
+    unlimited: {
+        plugins: -1,
+        pipelines: -1,
+        apiCalls: -1,
+        aiCalls: -1,
+        storageBytes: -1,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: -1,
+        seats: -1,
+    },
 };
 /** Read an integer env var, falling back to the code default. `-1` = unlimited. */
 function envInt(name, fallback) {
@@ -120,17 +134,32 @@ export const QUOTA_TIERS = {
     pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },
     team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },
     enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },
+    unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },
 };
-/** All valid tier names. */
+/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*
+ *  tier — `unlimited` is a valid value even though it's never offered for sale. */
 export const VALID_TIERS = Object.keys(QUOTA_TIERS);
+/** The standard, billing-selectable tiers — the ones offered as purchasable plans
+ *  and shown in tier pickers. Derived as "every valid tier except `unlimited`",
+ *  which is the billing-DISABLED default and is never displayed/selectable when
+ *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */
+export const STANDARD_TIERS = VALID_TIERS.filter((t) => t !== 'unlimited');
+/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,
+ *  opt-out default-on — mirrors the billing/platform configs). With billing OFF
+ *  there's no metering/enforcement surface, so the default tier is `unlimited`. */
+export function isBillingEnabled() {
+    return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';
+}
 /**
- * Default tier assigned to new organizations. Overridable via the
- * `DEFAULT_QUOTA_TIER` env var (one of developer|pro|team|enterprise);
- * an invalid/unset value falls back to 'developer'.
+ * Default tier assigned to new organizations.
+ * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).
+ * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.
  */
-export const DEFAULT_TIER = isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '')
-    ? process.env.DEFAULT_QUOTA_TIER
-    : 'developer';
+export const DEFAULT_TIER = !isBillingEnabled()
+    ? 'unlimited'
+    : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'
+        ? process.env.DEFAULT_QUOTA_TIER
+        : 'developer');
 /** Check whether a string is a valid QuotaTier. */
 export function isValidTier(value) {
     // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype
@@ -143,4 +172,4 @@ export function isValidTier(value) {
 export function getTierLimits(tier) {
     return isValidTier(tier) ? QUOTA_TIERS[tier].limits : QUOTA_TIERS.developer.limits;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/** Available quota tier identifiers. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, apiCalls CAPPED (was unlimited — a DoS/abuse hole\n  // on a shared resource); aiCalls small (each has ~$0.01-0.10 external cost).\n  developer: {\n    plugins: 25,\n    pipelines: 5,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    seats: 1,\n  },\n  // Pro = one power user, individual pricing.\n  pro: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 500_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    seats: 1,\n  },\n  // Team = collaboration tier; the seat limit (10) is the real differentiator\n  // over Pro. Limits sit between Pro and Enterprise.\n  team: {\n    plugins: 100,\n    pipelines: 200,\n    apiCalls: 2_000_000,\n    aiCalls: 5_000,\n    storageBytes: 150 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 10,\n  },\n  // Enterprise: org-wide, high seat cap. FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped high so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 250,\n    pipelines: 200,\n    apiCalls: 10_000_000,\n    aiCalls: 15_000,\n    storageBytes: 500 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 25,\n  },\n};\n\n/** Read an integer env var, falling back to the code default. `-1` = unlimited. */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const n = parseInt(raw, 10);\n  return Number.isNaN(n) ? fallback : n;\n}\n\n/** Read a string env var, falling back to the code default. */\nfunction envStr(name: string, fallback: string): string {\n  const raw = process.env[name];\n  return raw === undefined || raw === '' ? fallback : raw;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n};\n\n/** All valid tier names. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/**\n * Default tier assigned to new organizations. Overridable via the\n * `DEFAULT_QUOTA_TIER` env var (one of developer|pro|team|enterprise);\n * an invalid/unset value falls back to 'developer'.\n */\nexport const DEFAULT_TIER: QuotaTier =\n  isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '')\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer';\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, apiCalls CAPPED (was unlimited — a DoS/abuse hole\n  // on a shared resource); aiCalls small (each has ~$0.01-0.10 external cost).\n  developer: {\n    plugins: 25,\n    pipelines: 5,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    seats: 1,\n  },\n  // Pro = one power user, individual pricing.\n  pro: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 500_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    seats: 1,\n  },\n  // Team = collaboration tier; the seat limit (10) is the real differentiator\n  // over Pro. Limits sit between Pro and Enterprise.\n  team: {\n    plugins: 100,\n    pipelines: 200,\n    apiCalls: 2_000_000,\n    aiCalls: 5_000,\n    storageBytes: 150 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 10,\n  },\n  // Enterprise: org-wide, high seat cap. FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped high so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 250,\n    pipelines: 200,\n    apiCalls: 10_000_000,\n    aiCalls: 15_000,\n    storageBytes: 500 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 25,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    aiCalls: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: -1,\n  },\n};\n\n/** Read an integer env var, falling back to the code default. `-1` = unlimited. */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const n = parseInt(raw, 10);\n  return Number.isNaN(n) ? fallback : n;\n}\n\n/** Read a string env var, falling back to the code default. */\nfunction envStr(name: string, fallback: string): string {\n  const raw = process.env[name];\n  return raw === undefined || raw === '' ? fallback : raw;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n"]}

package/package.json

@@ -87,7 +87,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.100",
+  "version": "3.4.102",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },