@vibesdotdev/account 0.0.0-stage → 1.0.0-rc.2

package/dist/billing/contracts.d.ts

@@ -0,0 +1,199 @@
+export declare const billingAccountServiceContracts: {
+    getOverview: {
+        method: "GET";
+        href: "/api/account/billing";
+        parseInput: (input: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+        };
+        parseOutput: (output: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+            plan: {
+                planKey: string;
+                planName: string;
+                status: "active" | "incomplete" | "paused" | "trialing" | "past_due" | "canceled";
+                interval: "custom" | "month" | "year" | "one-time";
+                isTrial: boolean;
+                seatsIncluded?: number | undefined;
+                trialEndsAt?: string | undefined;
+                currentPeriodStart?: string | undefined;
+                currentPeriodEnd?: string | undefined;
+                renewsAt?: string | undefined;
+                cancelAt?: string | undefined;
+            } | null;
+            entitlements: {
+                key: string;
+                label: string;
+                source: "manual" | "addon" | "plan" | "promotion";
+                enabled: boolean;
+                limit?: number | null | undefined;
+                unit?: string | undefined;
+                description?: string | undefined;
+            }[];
+            usageHighlights: {
+                feature: string;
+                category: string;
+                label: string;
+                unit: string;
+                consumedQuantity: number;
+                includedQuantity?: number | null | undefined;
+                overageQuantity?: number | undefined;
+                windowStart?: string | undefined;
+                windowEnd?: string | undefined;
+                resetsAt?: string | undefined;
+            }[];
+            recentInvoices: {
+                id: string;
+                status: "void" | "draft" | "open" | "past_due" | "paid" | "uncollectible";
+                currency: string;
+                totalInMinorUnits: number;
+                number?: string | undefined;
+                subtotalInMinorUnits?: number | undefined;
+                amountDueInMinorUnits?: number | undefined;
+                amountPaidInMinorUnits?: number | undefined;
+                issuedAt?: string | undefined;
+                dueAt?: string | undefined;
+                paidAt?: string | undefined;
+                hostedInvoiceUrl?: string | undefined;
+                pdfUrl?: string | undefined;
+            }[];
+            creditBalance?: {
+                scope: "user" | "organization" | "project";
+                scopeId: string;
+                available: number;
+                pending?: number | undefined;
+                unit?: string | undefined;
+                asOf?: string | undefined;
+            } | null | undefined;
+            defaultPaymentMethod?: {
+                id: string;
+                isDefault: boolean;
+                status: "unavailable" | "active" | "expired" | "requires_action";
+                brand?: string | undefined;
+                last4?: string | undefined;
+                expMonth?: number | undefined;
+                expYear?: number | undefined;
+                funding?: "unknown" | "credit" | "debit" | "prepaid" | undefined;
+            } | null | undefined;
+        };
+    };
+    listPaymentMethods: {
+        method: "GET";
+        href: "/api/account/billing/payment-methods";
+        parseInput: (input: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+        };
+        parseOutput: (output: unknown) => {
+            items: {
+                id: string;
+                isDefault: boolean;
+                status: "unavailable" | "active" | "expired" | "requires_action";
+                brand?: string | undefined;
+                last4?: string | undefined;
+                expMonth?: number | undefined;
+                expYear?: number | undefined;
+                funding?: "unknown" | "credit" | "debit" | "prepaid" | undefined;
+            }[];
+        };
+    };
+    listInvoices: {
+        method: "GET";
+        href: "/api/account/billing/invoices";
+        parseInput: (input: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+            limit: number;
+            status?: ("void" | "draft" | "open" | "past_due" | "paid" | "uncollectible")[] | undefined;
+            cursor?: string | undefined;
+        };
+        parseOutput: (output: unknown) => {
+            items: {
+                id: string;
+                status: "void" | "draft" | "open" | "past_due" | "paid" | "uncollectible";
+                currency: string;
+                totalInMinorUnits: number;
+                number?: string | undefined;
+                subtotalInMinorUnits?: number | undefined;
+                amountDueInMinorUnits?: number | undefined;
+                amountPaidInMinorUnits?: number | undefined;
+                issuedAt?: string | undefined;
+                dueAt?: string | undefined;
+                paidAt?: string | undefined;
+                hostedInvoiceUrl?: string | undefined;
+                pdfUrl?: string | undefined;
+            }[];
+            hasMore: boolean;
+            nextCursor?: string | undefined;
+        };
+    };
+    getUsageSummary: {
+        method: "GET";
+        href: "/api/account/billing/usage";
+        parseInput: (input: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+            window: "custom" | "current" | "previous" | "rolling_30d" | "rolling_12m";
+            startAt?: string | undefined;
+            endAt?: string | undefined;
+        };
+        parseOutput: (output: unknown) => {
+            feature: string;
+            category: string;
+            label: string;
+            unit: string;
+            consumedQuantity: number;
+            includedQuantity?: number | null | undefined;
+            overageQuantity?: number | undefined;
+            windowStart?: string | undefined;
+            windowEnd?: string | undefined;
+            resetsAt?: string | undefined;
+        }[];
+    };
+    createPortalSession: {
+        method: "POST";
+        href: "/api/account/billing/portal-session";
+        parseInput: (input: unknown) => {
+            scope: {
+                kind: "organization" | "account";
+                accountId?: string | undefined;
+                organizationId?: string | undefined;
+                organizationSlug?: string | undefined;
+                label?: string | undefined;
+            };
+            flow: "manage-subscription" | "update-payment-method" | "download-invoices";
+            returnPath?: string | undefined;
+        };
+        parseOutput: (output: unknown) => {
+            url: string;
+            expiresAt?: string | undefined;
+        };
+    };
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/billing/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../src/billing/contracts.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,8BAA8B;;;;4BAIrB,OAAO;;;;;;;;;8BACL,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAKT,OAAO;;;;;;;;;8BACL,OAAO;;;;;;;;;;;;;;;;4BAKT,OAAO;;;;;;;;;;;;8BACL,OAAO;;;;;;;;;;;;;;;;;;;;;;;4BAKT,OAAO;;;;;;;;;;;;8BACL,OAAO;;;;;;;;;;;;;;;;4BAKT,OAAO;;;;;;;;;;;8BACL,OAAO;;;;;CAE0C,CAAC"}

package/dist/billing/contracts.js

@@ -0,0 +1,37 @@
+import { billingAccountOverviewSchema, billingInvoiceCollectionSchema, billingPaymentMethodCollectionSchema } from "./schemas/core/account.js";
+import { billingAccountScopedRequestSchema, billingInvoiceListRequestSchema, billingPortalSessionRequestSchema, billingPortalSessionSchema, billingUsageSummaryRequestSchema } from "./schemas/core/requests.js";
+import { billingUsageMetricSummarySchema } from "./schemas/core/usage.js";
+import { accountBillingApiRoutes } from "./schemas/navigation.js";
+export const billingAccountServiceContracts = {
+    getOverview: {
+        method: 'GET',
+        href: accountBillingApiRoutes.overview,
+        parseInput: (input) => billingAccountScopedRequestSchema.parse(input),
+        parseOutput: (output) => billingAccountOverviewSchema.parse(output)
+    },
+    listPaymentMethods: {
+        method: 'GET',
+        href: accountBillingApiRoutes.paymentMethods,
+        parseInput: (input) => billingAccountScopedRequestSchema.parse(input),
+        parseOutput: (output) => billingPaymentMethodCollectionSchema.parse(output)
+    },
+    listInvoices: {
+        method: 'GET',
+        href: accountBillingApiRoutes.invoices,
+        parseInput: (input) => billingInvoiceListRequestSchema.parse(input),
+        parseOutput: (output) => billingInvoiceCollectionSchema.parse(output)
+    },
+    getUsageSummary: {
+        method: 'GET',
+        href: accountBillingApiRoutes.usage,
+        parseInput: (input) => billingUsageSummaryRequestSchema.parse(input),
+        parseOutput: (output) => billingUsageMetricSummarySchema.array().parse(output)
+    },
+    createPortalSession: {
+        method: 'POST',
+        href: accountBillingApiRoutes.portalSession,
+        parseInput: (input) => billingPortalSessionRequestSchema.parse(input),
+        parseOutput: (output) => billingPortalSessionSchema.parse(output)
+    }
+};
+//# sourceMappingURL=contracts.js.map

package/dist/billing/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/billing/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,4BAA4B,EAC5B,8BAA8B,EAC9B,oCAAoC,EACpC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,iCAAiC,EACjC,+BAA+B,EAC/B,iCAAiC,EACjC,0BAA0B,EAC1B,gCAAgC,EAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC7C,WAAW,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,uBAAuB,CAAC,QAAQ;QACtC,UAAU,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,iCAAiC,CAAC,KAAK,CAAC,KAAK,CAAC;QAC9E,WAAW,EAAE,CAAC,MAAe,EAAE,EAAE,CAAC,4BAA4B,CAAC,KAAK,CAAC,MAAM,CAAC;KAC5E;IACD,kBAAkB,EAAE;QACnB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,uBAAuB,CAAC,cAAc;QAC5C,UAAU,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,iCAAiC,CAAC,KAAK,CAAC,KAAK,CAAC;QAC9E,WAAW,EAAE,CAAC,MAAe,EAAE,EAAE,CAAC,oCAAoC,CAAC,KAAK,CAAC,MAAM,CAAC;KACpF;IACD,YAAY,EAAE;QACb,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,uBAAuB,CAAC,QAAQ;QACtC,UAAU,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,+BAA+B,CAAC,KAAK,CAAC,KAAK,CAAC;QAC5E,WAAW,EAAE,CAAC,MAAe,EAAE,EAAE,CAAC,8BAA8B,CAAC,KAAK,CAAC,MAAM,CAAC;KAC9E;IACD,eAAe,EAAE;QAChB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,uBAAuB,CAAC,KAAK;QACnC,UAAU,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,gCAAgC,CAAC,KAAK,CAAC,KAAK,CAAC;QAC7E,WAAW,EAAE,CAAC,MAAe,EAAE,EAAE,CAAC,+BAA+B,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC;KACvF;IACD,mBAAmB,EAAE;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,uBAAuB,CAAC,aAAa;QAC3C,UAAU,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,iCAAiC,CAAC,KAAK,CAAC,KAAK,CAAC;QAC9E,WAAW,EAAE,CAAC,MAAe,EAAE,EAAE,CAAC,0BAA0B,CAAC,KAAK,CAAC,MAAM,CAAC;KAC1E;CACuE,CAAC"}

package/dist/billing/definitions/features.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Canonical billing feature catalog managed in code.
+ *
+ * Feature slugs are kebab-case across boolean gates, numeric limits, and usage quotas.
+ *
+ * `stripeMeterEventName` (optional) maps a usage-type feature to its Stripe
+ * Billing Meter. When set, every successful `recordRatedUsageEvent` for that
+ * feature emits to Stripe so usage-based / overage plans can invoice the
+ * metered portion. Convention: snake_case, no `monthly` suffix (Stripe meters
+ * are inherently periodic via the price's `aggregate_usage` window).
+ *
+ * Slugs left without a meter name are either:
+ *   - boolean gates / numeric limits (not metered usage)
+ *   - usage signals that need per-user attribution work before they can flow
+ *     to Stripe (storage, bandwidth, sandbox uptime — see follow-up tasks).
+ */
+export declare const MANAGED_BILLING_FEATURES: readonly [{
+    readonly slug: "workbench";
+    readonly type: "boolean";
+    readonly name: "Workbench";
+    readonly category: "ai";
+}, {
+    readonly slug: "benchmarks";
+    readonly type: "boolean";
+    readonly name: "Benchmarks";
+    readonly category: "ai";
+}, {
+    readonly slug: "ai-agents";
+    readonly type: "boolean";
+    readonly name: "AI Agents";
+    readonly category: "ai";
+}, {
+    readonly slug: "knowledge-bases";
+    readonly type: "boolean";
+    readonly name: "Knowledge Bases";
+    readonly category: "knowledge";
+}, {
+    readonly slug: "knowledge-extraction";
+    readonly type: "boolean";
+    readonly name: "Knowledge Extraction";
+    readonly category: "knowledge";
+}, {
+    readonly slug: "knowledge-cloud-delivery";
+    readonly type: "boolean";
+    readonly name: "Knowledge Cloud Delivery";
+    readonly category: "knowledge";
+}, {
+    readonly slug: "manual-ingest";
+    readonly type: "boolean";
+    readonly name: "Manual Ingest";
+    readonly category: "ingest";
+}, {
+    readonly slug: "model-70b-access";
+    readonly type: "boolean";
+    readonly name: "70B Model Access";
+    readonly category: "ai";
+}, {
+    readonly slug: "web-crawl-pages-monthly";
+    readonly type: "numeric";
+    readonly name: "Web Crawl Pages (Monthly)";
+    readonly category: "ingest";
+    readonly stripeMeterEventName: "web_crawl_pages";
+}, {
+    readonly slug: "ai-audio-generations";
+    readonly type: "usage";
+    readonly name: "AI Audio Generations";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_audio_generations";
+}, {
+    readonly slug: "ai-image-generations";
+    readonly type: "usage";
+    readonly name: "AI Image Generations";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_image_generations";
+}, {
+    readonly slug: "knowledge-queries";
+    readonly type: "usage";
+    readonly name: "Knowledge Queries";
+    readonly category: "knowledge";
+    readonly stripeMeterEventName: "knowledge_queries";
+}, {
+    readonly slug: "ai-benchmark-execute";
+    readonly type: "usage";
+    readonly name: "AI Benchmark Executions";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_benchmark_executions";
+}, {
+    readonly slug: "ai-text-tokens";
+    readonly type: "usage";
+    readonly name: "AI Text Tokens";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_text_tokens";
+}, {
+    readonly slug: "ai-agent-runs";
+    readonly type: "usage";
+    readonly name: "AI Agent Runs";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_agent_runs";
+}, {
+    readonly slug: "ai-agent-callback";
+    readonly type: "usage";
+    readonly name: "AI Agent Callbacks";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_agent_callbacks";
+}, {
+    readonly slug: "ai-knowledge-extract";
+    readonly type: "usage";
+    readonly name: "AI Knowledge Extraction";
+    readonly category: "knowledge";
+    readonly stripeMeterEventName: "ai_knowledge_extractions";
+}, {
+    readonly slug: "ai-ocr-pages";
+    readonly type: "usage";
+    readonly name: "AI OCR Pages";
+    readonly category: "ai";
+    readonly stripeMeterEventName: "ai_ocr_pages";
+}, {
+    readonly slug: "build-mode-access";
+    readonly type: "boolean";
+    readonly name: "Build Mode";
+    readonly category: "ai";
+}, {
+    readonly slug: "sandbox-uptime-minutes";
+    readonly type: "usage";
+    readonly name: "Sandbox Uptime (Minutes)";
+    readonly category: "infrastructure";
+}, {
+    readonly slug: "code-execution-seconds";
+    readonly type: "usage";
+    readonly name: "Code Execution (Seconds)";
+    readonly category: "infrastructure";
+    readonly stripeMeterEventName: "code_execution_seconds";
+}, {
+    readonly slug: "platform-overhead-seconds";
+    readonly type: "usage";
+    readonly name: "Platform Overhead (Seconds)";
+    readonly category: "infrastructure";
+}, {
+    readonly slug: "storage-capacity-gb";
+    readonly type: "numeric";
+    readonly name: "Storage Capacity (GB)";
+    readonly category: "infrastructure";
+}, {
+    readonly slug: "storage-monthly-gb";
+    readonly type: "usage";
+    readonly name: "Storage (GB-Month)";
+    readonly category: "infrastructure";
+    readonly stripeMeterEventName: "storage_monthly_gb";
+}, {
+    readonly slug: "bandwidth-egress-gb";
+    readonly type: "usage";
+    readonly name: "Bandwidth Egress (GB)";
+    readonly category: "infrastructure";
+}, {
+    readonly slug: "private-repos";
+    readonly type: "numeric";
+    readonly name: "Private Repositories";
+    readonly category: "forge";
+}, {
+    readonly slug: "private-packages";
+    readonly type: "numeric";
+    readonly name: "Private Registry Packages";
+    readonly category: "forge";
+}, {
+    readonly slug: "registry-storage-gb";
+    readonly type: "usage";
+    readonly name: "Registry Storage (GB)";
+    readonly category: "forge";
+}, {
+    readonly slug: "repo-storage-mb";
+    readonly type: "usage";
+    readonly name: "Repository Storage (MB)";
+    readonly category: "forge";
+}, {
+    readonly slug: "collaborator-seats";
+    readonly type: "numeric";
+    readonly name: "Collaborator Seats";
+    readonly category: "forge";
+}, {
+    readonly slug: "fleet-restricted-workload";
+    readonly type: "boolean";
+    readonly name: "Restricted-workload fleet hosts";
+    readonly category: "infrastructure";
+}, {
+    readonly slug: "omniframe-play-vip";
+    readonly type: "boolean";
+    readonly name: "Omniframe Play VIP";
+    readonly category: "omniframe-play";
+}, {
+    readonly slug: "omniframe-play-ad-free";
+    readonly type: "boolean";
+    readonly name: "Omniframe Play ad-free";
+    readonly category: "omniframe-play";
+}];
+//# sourceMappingURL=features.d.ts.map

package/dist/billing/definitions/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../src/billing/definitions/features.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiO3B,CAAC"}

package/dist/billing/definitions/features.js

@@ -0,0 +1,243 @@
+/**
+ * Canonical billing feature catalog managed in code.
+ *
+ * Feature slugs are kebab-case across boolean gates, numeric limits, and usage quotas.
+ *
+ * `stripeMeterEventName` (optional) maps a usage-type feature to its Stripe
+ * Billing Meter. When set, every successful `recordRatedUsageEvent` for that
+ * feature emits to Stripe so usage-based / overage plans can invoice the
+ * metered portion. Convention: snake_case, no `monthly` suffix (Stripe meters
+ * are inherently periodic via the price's `aggregate_usage` window).
+ *
+ * Slugs left without a meter name are either:
+ *   - boolean gates / numeric limits (not metered usage)
+ *   - usage signals that need per-user attribution work before they can flow
+ *     to Stripe (storage, bandwidth, sandbox uptime — see follow-up tasks).
+ */
+export const MANAGED_BILLING_FEATURES = [
+    { slug: 'workbench', type: 'boolean', name: 'Workbench', category: 'ai' },
+    { slug: 'benchmarks', type: 'boolean', name: 'Benchmarks', category: 'ai' },
+    { slug: 'ai-agents', type: 'boolean', name: 'AI Agents', category: 'ai' },
+    {
+        slug: 'knowledge-bases',
+        type: 'boolean',
+        name: 'Knowledge Bases',
+        category: 'knowledge'
+    },
+    {
+        slug: 'knowledge-extraction',
+        type: 'boolean',
+        name: 'Knowledge Extraction',
+        category: 'knowledge'
+    },
+    {
+        // Paid-only boolean gate: local knowledge items are pushed to the
+        // knowledge service automatically only when this is on.
+        slug: 'knowledge-cloud-delivery',
+        type: 'boolean',
+        name: 'Knowledge Cloud Delivery',
+        category: 'knowledge'
+    },
+    {
+        slug: 'manual-ingest',
+        type: 'boolean',
+        name: 'Manual Ingest',
+        category: 'ingest'
+    },
+    {
+        slug: 'model-70b-access',
+        type: 'boolean',
+        name: '70B Model Access',
+        category: 'ai'
+    },
+    {
+        slug: 'web-crawl-pages-monthly',
+        type: 'numeric',
+        name: 'Web Crawl Pages (Monthly)',
+        category: 'ingest',
+        stripeMeterEventName: 'web_crawl_pages'
+    },
+    {
+        slug: 'ai-audio-generations',
+        type: 'usage',
+        name: 'AI Audio Generations',
+        category: 'ai',
+        stripeMeterEventName: 'ai_audio_generations'
+    },
+    {
+        slug: 'ai-image-generations',
+        type: 'usage',
+        name: 'AI Image Generations',
+        category: 'ai',
+        stripeMeterEventName: 'ai_image_generations'
+    },
+    {
+        slug: 'knowledge-queries',
+        type: 'usage',
+        name: 'Knowledge Queries',
+        category: 'knowledge',
+        stripeMeterEventName: 'knowledge_queries'
+    },
+    {
+        slug: 'ai-benchmark-execute',
+        type: 'usage',
+        name: 'AI Benchmark Executions',
+        category: 'ai',
+        stripeMeterEventName: 'ai_benchmark_executions'
+    },
+    {
+        slug: 'ai-text-tokens',
+        type: 'usage',
+        name: 'AI Text Tokens',
+        category: 'ai',
+        stripeMeterEventName: 'ai_text_tokens'
+    },
+    {
+        slug: 'ai-agent-runs',
+        type: 'usage',
+        name: 'AI Agent Runs',
+        category: 'ai',
+        stripeMeterEventName: 'ai_agent_runs'
+    },
+    {
+        slug: 'ai-agent-callback',
+        type: 'usage',
+        name: 'AI Agent Callbacks',
+        category: 'ai',
+        stripeMeterEventName: 'ai_agent_callbacks'
+    },
+    {
+        slug: 'ai-knowledge-extract',
+        type: 'usage',
+        name: 'AI Knowledge Extraction',
+        category: 'knowledge',
+        stripeMeterEventName: 'ai_knowledge_extractions'
+    },
+    {
+        slug: 'ai-ocr-pages',
+        type: 'usage',
+        name: 'AI OCR Pages',
+        category: 'ai',
+        stripeMeterEventName: 'ai_ocr_pages'
+    },
+    {
+        slug: 'build-mode-access',
+        type: 'boolean',
+        name: 'Build Mode',
+        category: 'ai'
+    },
+    {
+        slug: 'sandbox-uptime-minutes',
+        type: 'usage',
+        name: 'Sandbox Uptime (Minutes)',
+        category: 'infrastructure'
+        // stripeMeterEventName intentionally unset — emission blocked on
+        // per-user sandbox attribution (no sampler exists yet).
+    },
+    {
+        slug: 'code-execution-seconds',
+        type: 'usage',
+        name: 'Code Execution (Seconds)',
+        category: 'infrastructure',
+        stripeMeterEventName: 'code_execution_seconds'
+    },
+    {
+        slug: 'platform-overhead-seconds',
+        type: 'usage',
+        name: 'Platform Overhead (Seconds)',
+        category: 'infrastructure'
+        // stripeMeterEventName intentionally unset — internal-visibility signal
+        // for worker time that ran with no billing subject in job metadata.
+    },
+    {
+        slug: 'storage-capacity-gb',
+        type: 'numeric',
+        name: 'Storage Capacity (GB)',
+        category: 'infrastructure'
+        // INSTANTANEOUS capacity entitlement — the ADMISSION gate for storage
+        // writes: allowed iff currentStoredGB + requestedGB <= limit for the
+        // billing subject (user, or org when the asset is org-owned). Platform
+        // supplies the raw current-stored fact; account owns the plan limit.
+        // This is deliberately distinct from `storage-monthly-gb` below, which
+        // is the RATING meter — reusing one numeric for both admission and
+        // rating was the split-authority disease this pair closes.
+    },
+    {
+        slug: 'storage-monthly-gb',
+        type: 'usage',
+        name: 'Storage (GB-Month)',
+        category: 'infrastructure',
+        // RATING ONLY — never an admission predicate. Admission is
+        // `storage-capacity-gb` above.
+        // Emitted by the daily `billing.storage-sample` job (see
+        // apps/account-web/src/server/billing/worker/jobs/storage-sample.ts).
+        // The sampler aggregates R2 bytes by the `org/{id}/...` / `user/{id}/...`
+        // key-prefix convention and emits one rated-usage event per
+        // (bucket, owner) per day at `currentGB / daysInMonth`. The Stripe
+        // meter (provisioned by feature-sync) sums these into a per-period
+        // GB-month total.
+        stripeMeterEventName: 'storage_monthly_gb'
+    },
+    {
+        slug: 'bandwidth-egress-gb',
+        type: 'usage',
+        name: 'Bandwidth Egress (GB)',
+        category: 'infrastructure'
+        // stripeMeterEventName intentionally unset — emission blocked on
+        // per-zone egress attribution (needs Cloudflare Analytics integration).
+    },
+    {
+        slug: 'private-repos',
+        type: 'numeric',
+        name: 'Private Repositories',
+        category: 'forge'
+    },
+    {
+        slug: 'private-packages',
+        type: 'numeric',
+        name: 'Private Registry Packages',
+        category: 'forge'
+    },
+    {
+        slug: 'registry-storage-gb',
+        type: 'usage',
+        name: 'Registry Storage (GB)',
+        category: 'forge'
+        // stripeMeterEventName intentionally unset — emission blocked on
+        // per-owner R2 storage attribution for private packages (needs a
+        // registry storage sampler analogous to billing.storage-sample).
+    },
+    {
+        slug: 'repo-storage-mb',
+        type: 'usage',
+        name: 'Repository Storage (MB)',
+        category: 'forge'
+        // stripeMeterEventName intentionally unset — emission blocked on
+        // per-owner git repo storage attribution (needs a repo storage sampler).
+    },
+    {
+        slug: 'collaborator-seats',
+        type: 'numeric',
+        name: 'Collaborator Seats',
+        category: 'forge'
+    },
+    {
+        slug: 'fleet-restricted-workload',
+        type: 'boolean',
+        name: 'Restricted-workload fleet hosts',
+        category: 'infrastructure'
+    },
+    {
+        slug: 'omniframe-play-vip',
+        type: 'boolean',
+        name: 'Omniframe Play VIP',
+        category: 'omniframe-play'
+    },
+    {
+        slug: 'omniframe-play-ad-free',
+        type: 'boolean',
+        name: 'Omniframe Play ad-free',
+        category: 'omniframe-play'
+    }
+];
+//# sourceMappingURL=features.js.map