@voltro/plugin-billing 0.1.0

package/dist/rpc.d.ts

@@ -0,0 +1,81 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+/**
+ * A billing failure. `transient: true` marks failures the service retries
+ * (network blip talking to the provider); non-transient failures (a 4xx
+ * from the provider, a misconfigured plan) are surfaced immediately. The
+ * `billingPlugin` registers this via `errorSchemas` so it decodes TYPED on
+ * the client rather than crossing as an untyped defect.
+ */
+declare class BillingError extends BillingError_base {
+}
+
+declare const BillingError_base: Schema.TaggedErrorClass<BillingError, "BillingError", {
+    readonly _tag: Schema.tag<"BillingError">;
+} & {
+    /** Where the failure originated — provider name or an internal stage. */
+    source: typeof Schema.String;
+    message: typeof Schema.String;
+    /** Retryable? The service retries `transient` failures on a Schedule. */
+    transient: typeof Schema.Boolean;
+}>;
+
+/** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
+ *  emitted into the generated client group. Kept in lockstep with the exports. */
+export declare const billingRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const changePlanDescriptor: ActionProcedureDescriptor<"billing.changePlan", Schema.Struct<{
+    plan: typeof Schema.String;
+}>, Schema.Struct<{
+    plan: typeof Schema.String;
+    quantity: typeof Schema.Number;
+    /** Integer minor-unit settlement: > 0 charge, < 0 credit, 0 at boundary. */
+    prorationMinor: typeof Schema.Number;
+    currency: typeof Schema.String;
+}>, typeof BillingError>;
+
+export declare const changeSeatsDescriptor: ActionProcedureDescriptor<"billing.changeSeats", Schema.Struct<{
+    quantity: typeof Schema.Number;
+}>, Schema.Struct<{
+    plan: typeof Schema.String;
+    quantity: typeof Schema.Number;
+    /** Integer minor-unit settlement: > 0 charge, < 0 credit, 0 at boundary. */
+    prorationMinor: typeof Schema.Number;
+    currency: typeof Schema.String;
+}>, typeof BillingError>;
+
+export declare const portalUrlDescriptor: ActionProcedureDescriptor<"billing.portalUrl", Schema.Struct<{
+    returnUrl: typeof Schema.String;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+}>, typeof BillingError>;
+
+export declare const reportUsageDescriptor: ActionProcedureDescriptor<"billing.reportUsage", Schema.Struct<{
+    key: typeof Schema.String;
+    quantity: typeof Schema.Number;
+}>, Schema.Struct<{
+    ok: typeof Schema.Boolean;
+}>, typeof BillingError>;
+
+export declare const startCheckoutDescriptor: ActionProcedureDescriptor<"billing.startCheckout", Schema.Struct<{
+    plan: typeof Schema.String;
+    successUrl: typeof Schema.String;
+    cancelUrl: typeof Schema.String;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+}>, typeof BillingError>;
+
+export declare const subscriptionDescriptor: QueryProcedureDescriptor<"billing.subscription", Schema.Struct<{}>, Schema.Struct<{
+    subscription: Schema.NullOr<Schema.Struct<{
+        plan: typeof Schema.String;
+        status: typeof Schema.String;
+        quantity: typeof Schema.Number;
+        currentPeriodEnd: Schema.NullOr<typeof Schema.String>;
+        cancelAt: Schema.NullOr<typeof Schema.String>;
+    }>>;
+}>, typeof BillingError>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,104 @@
+import { BillingError as e } from "./types.js";
+import { Schema as t } from "effect";
+import { defineAction as n, defineQuery as r } from "@voltro/protocol";
+//#region src/rpc.ts
+var i = n({
+	name: "billing.startCheckout",
+	input: t.Struct({
+		plan: t.String,
+		successUrl: t.String,
+		cancelUrl: t.String
+	}),
+	output: t.Struct({ url: t.String }),
+	error: e
+}), a = n({
+	name: "billing.portalUrl",
+	input: t.Struct({ returnUrl: t.String }),
+	output: t.Struct({ url: t.String }),
+	error: e
+}), o = r({
+	name: "billing.subscription",
+	input: t.Struct({}),
+	output: t.Struct({ subscription: t.NullOr(t.Struct({
+		plan: t.String,
+		status: t.String,
+		quantity: t.Number,
+		currentPeriodEnd: t.NullOr(t.String),
+		cancelAt: t.NullOr(t.String)
+	})) }),
+	error: e
+}), s = n({
+	name: "billing.reportUsage",
+	input: t.Struct({
+		key: t.String,
+		quantity: t.Number
+	}),
+	output: t.Struct({ ok: t.Boolean }),
+	error: e
+}), c = t.Struct({
+	plan: t.String,
+	quantity: t.Number,
+	prorationMinor: t.Number,
+	currency: t.String
+}), l = n({
+	name: "billing.changePlan",
+	input: t.Struct({ plan: t.String }),
+	output: c,
+	error: e
+}), u = n({
+	name: "billing.changeSeats",
+	input: t.Struct({ quantity: t.Number }),
+	output: c,
+	error: e
+}), d = [
+	{
+		tag: "billing.startCheckout",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "startCheckoutDescriptor"
+		}
+	},
+	{
+		tag: "billing.portalUrl",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "portalUrlDescriptor"
+		}
+	},
+	{
+		tag: "billing.subscription",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "subscriptionDescriptor"
+		}
+	},
+	{
+		tag: "billing.reportUsage",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "reportUsageDescriptor"
+		}
+	},
+	{
+		tag: "billing.changePlan",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "changePlanDescriptor"
+		}
+	},
+	{
+		tag: "billing.changeSeats",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-billing/rpc",
+			name: "changeSeatsDescriptor"
+		}
+	}
+];
+//#endregion
+export { d as billingRpcClientImports, l as changePlanDescriptor, u as changeSeatsDescriptor, a as portalUrlDescriptor, s as reportUsageDescriptor, i as startCheckoutDescriptor, o as subscriptionDescriptor };

package/dist/types.d.ts

@@ -0,0 +1,316 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+
+/**
+ * A billing failure. `transient: true` marks failures the service retries
+ * (network blip talking to the provider); non-transient failures (a 4xx
+ * from the provider, a misconfigured plan) are surfaced immediately. The
+ * `billingPlugin` registers this via `errorSchemas` so it decodes TYPED on
+ * the client rather than crossing as an untyped defect.
+ */
+export declare class BillingError extends BillingError_base {
+}
+
+declare const BillingError_base: Schema.TaggedErrorClass<BillingError, "BillingError", {
+    readonly _tag: Schema.tag<"BillingError">;
+} & {
+    /** Where the failure originated — provider name or an internal stage. */
+    source: typeof Schema.String;
+    message: typeof Schema.String;
+    /** Retryable? The service retries `transient` failures on a Schedule. */
+    transient: typeof Schema.Boolean;
+}>;
+
+/**
+ * The normalized event union a `BillingProvider.normalizeEvent` produces
+ * from a verified, decoded provider webhook payload. `BillingService`
+ * applies these to the DB rows — switching provider swaps the adapter;
+ * the service + rows + entitlement engine are unchanged.
+ */
+export declare type BillingEvent = {
+    readonly _tag: 'subscriptionUpserted';
+    readonly tenantId: string;
+    readonly providerSubscriptionId: string;
+    readonly plan: PlanId;
+    readonly status: SubscriptionStatus;
+    /** Seat quantity from the provider event; defaults to 1 when absent. */
+    readonly quantity?: number;
+    readonly currentPeriodStart?: Date | null;
+    readonly currentPeriodEnd: Date | null;
+    readonly cancelAt: Date | null;
+} | {
+    readonly _tag: 'subscriptionCanceled';
+    readonly tenantId: string;
+    readonly providerSubscriptionId: string;
+} | {
+    readonly _tag: 'invoicePaid';
+    readonly tenantId: string;
+    readonly providerInvoiceId: string;
+    readonly amountMinor: number;
+    readonly currency: string;
+} | {
+    readonly _tag: 'invoicePaymentFailed';
+    readonly tenantId: string;
+    readonly providerInvoiceId: string;
+    readonly amountMinor: number;
+    readonly currency: string;
+} | {
+    readonly _tag: 'customerLinked';
+    readonly tenantId: string;
+    readonly providerCustomerId: string;
+};
+
+/** The event tag union — handy for `onEvent` keys. */
+export declare type BillingEventTag = BillingEvent['_tag'];
+
+/**
+ * Dumb adapter over a billing provider. Holds NO policy — checkout/portal
+ * URL minting, usage push, and pure payload→event mapping only. The
+ * `BillingService` wraps it with the entitlement engine, the DB rows, and
+ * transient retry.
+ *
+ * `normalizeEvent` receives a payload whose signature was ALREADY verified
+ * by @voltro/plugin-webhooks' mounter — this is pure mapping, never a
+ * second signature check.
+ */
+export declare interface BillingProvider {
+    readonly name: string;
+    /** Whether the provider supports server-pushed metered usage. Stripe
+     *  does (subscription-item usage records); a flat-plan provider may not.
+     *  When false, `BillingService.reportUsage` records locally but never
+     *  calls `provider.reportUsage`. */
+    readonly supportsMeteredUsage: boolean;
+    readonly createCheckoutSession: (input: CheckoutInput) => Effect.Effect<{
+        url: string;
+    }, BillingError>;
+    readonly createPortalSession: (input: PortalInput) => Effect.Effect<{
+        url: string;
+    }, BillingError>;
+    readonly reportUsage: (input: UsagePush) => Effect.Effect<void, BillingError>;
+    /** Map a verified, decoded webhook payload to a `BillingEvent`, or
+     *  `null` for an event type this provider doesn't model (handler
+     *  no-ops, still 200). */
+    readonly normalizeEvent: (raw: unknown) => Effect.Effect<BillingEvent | null, BillingError>;
+}
+
+/** The billing service Tag — `const billing = yield* BillingService`. */
+export declare class BillingService extends BillingService_base {
+}
+
+declare const BillingService_base: Context.TagClass<BillingService, "@voltro/plugin-billing/BillingService", BillingServiceShape>;
+
+export declare interface BillingServiceShape {
+    /** Read the tenant's subscription row; null when none exists. */
+    readonly subscription: (tenantId: string) => Effect.Effect<Subscription | null, BillingError>;
+    /** Resolve the tenant's plan id; defaults to `'free'` when no row. */
+    readonly plan: (tenantId: string) => Effect.Effect<PlanId, BillingError>;
+    /** Pure read — would `cost` units of `key` be allowed? No mutation. */
+    readonly checkEntitlement: (tenantId: string, key: string, cost: number) => Effect.Effect<EntitlementDecision, BillingError>;
+    /** Check + decrement, atomically. Fails `EntitlementExceeded` over-limit. */
+    readonly consumeEntitlement: (tenantId: string, key: string, cost: number) => Effect.Effect<void, BillingError | EntitlementExceeded>;
+    /** Record metered usage locally; flushed to the provider in batches. */
+    readonly reportUsage: (tenantId: string, key: string, qty: number) => Effect.Effect<void, BillingError>;
+    /** Flush all pending local usage counters to the provider. */
+    readonly flushUsage: () => Effect.Effect<void, BillingError>;
+    /** Mint a provider-hosted checkout URL for `plan`. */
+    readonly startCheckout: (input: {
+        readonly tenantId: string;
+        readonly plan: PlanId;
+        readonly successUrl: string;
+        readonly cancelUrl: string;
+    }) => Effect.Effect<{
+        url: string;
+    }, BillingError>;
+    /** Mint a provider-hosted billing-portal URL. */
+    readonly portalUrl: (tenantId: string, returnUrl: string) => Effect.Effect<{
+        url: string;
+    }, BillingError>;
+    /** Apply a normalized provider event to the DB rows (idempotent upsert). */
+    readonly applyEvent: (event: BillingEvent) => Effect.Effect<void, BillingError>;
+    /**
+     * Change the tenant's plan mid-cycle. Computes a TIME-BASED prorated
+     * settlement on the amount difference for the unused remainder of the
+     * current period (positive = charge on upgrade, negative = credit on
+     * downgrade), persists the new plan, and returns the settlement. A same-plan
+     * call is a no-op with a zero delta. Fails `BillingError` when the tenant has
+     * no subscription or the target plan is unknown.
+     */
+    readonly changePlan: (tenantId: string, newPlan: PlanId, changeAt?: Date) => Effect.Effect<SubscriptionChange, BillingError>;
+    /**
+     * Set the tenant's seat quantity mid-cycle. Prorates the amount delta
+     * (`unitAmountMinor × Δquantity`) over the unused remainder of the period,
+     * persists the new quantity, and returns the settlement. `quantity` must be a
+     * positive integer. Fails `BillingError` on no subscription / bad quantity.
+     */
+    readonly changeSeats: (tenantId: string, quantity: number, changeAt?: Date) => Effect.Effect<SubscriptionChange, BillingError>;
+    /**
+     * Record a failed payment: schedule the first dunning retry (per the
+     * configured schedule) and transition the subscription `active → pastDue`.
+     * Idempotent — a replayed failure for a subscription already in dunning does
+     * not re-arm or double-schedule.
+     */
+    readonly recordPaymentFailure: (tenantId: string, at?: Date) => Effect.Effect<DunningState | null, BillingError>;
+    /**
+     * Record a recovered payment: clear any open dunning and transition the
+     * subscription back to `active`. Idempotent / a no-op when not in dunning.
+     */
+    readonly recordPaymentSuccess: (tenantId: string, at?: Date) => Effect.Effect<void, BillingError>;
+    /**
+     * Advance every due dunning entry: subscriptions whose next retry is due move
+     * to the next offset in the schedule; those that have exhausted the schedule
+     * transition `pastDue → canceled`. Idempotent per due-time (a claim gate
+     * makes a re-run over the same window a no-op). Driven by the self-scheduled
+     * interval, or call it from your own `*.cron.tsx`.
+     */
+    readonly runDunningCycle: (now?: Date) => Effect.Effect<DunningCycleResult, BillingError>;
+}
+
+export declare interface CheckoutInput {
+    readonly tenantId: string;
+    /** Provider price id to subscribe to. */
+    readonly priceId: string;
+    readonly successUrl: string;
+    readonly cancelUrl: string;
+    /** Optional existing provider customer id to attach the checkout to. */
+    readonly providerCustomerId?: string;
+}
+
+/** The free/fallback plan id every app implicitly has. */
+export declare const DEFAULT_PLAN: PlanId;
+
+/** What one `runDunningCycle` did. */
+export declare interface DunningCycleResult {
+    /** Subscriptions advanced to the next retry offset. */
+    readonly retried: number;
+    /** Subscriptions that exhausted the schedule and were canceled. */
+    readonly canceled: number;
+}
+
+/** A tenant's live dunning record — a failed payment being retried. */
+export declare interface DunningState {
+    readonly tenantId: string;
+    readonly providerSubscriptionId: string;
+    /** 0-based index into the configured retry-offset schedule. */
+    readonly attempt: number;
+    /** When the current retry is due. */
+    readonly nextRetryAt: Date;
+    /** When dunning was first opened (the original failure). */
+    readonly startedAt: Date;
+}
+
+/** The result of a pure (non-mutating) entitlement check. */
+export declare interface EntitlementDecision {
+    /** Whether the call would be allowed. */
+    readonly allowed: boolean;
+    /** The entitlement key checked. */
+    readonly entitlement: string;
+    /** The static limit for the caller's plan (`Infinity` for `'unlimited'`). */
+    readonly limit: number;
+    /** How much is already used in the current window. */
+    readonly used: number;
+    /** The cost the call would charge. */
+    readonly cost: number;
+}
+
+/**
+ * Raised when a caller has exhausted an entitlement (quota). Distinct from
+ * the scope/permission `Forbidden` / `ScopeError` — those gate "may you
+ * call this proc"; this gates "do you have quota left". Both axes compose.
+ * `billingPlugin` registers it via `errorSchemas` so callers can
+ * pattern-match on `_tag === 'EntitlementExceeded'`.
+ */
+export declare class EntitlementExceeded extends EntitlementExceeded_base {
+}
+
+declare const EntitlementExceeded_base: Schema.TaggedErrorClass<EntitlementExceeded, "EntitlementExceeded", {
+    readonly _tag: Schema.tag<"EntitlementExceeded">;
+} & {
+    /** The entitlement key that was exhausted (`'aiCalls'`). */
+    entitlement: typeof Schema.String;
+    /** The static limit for the caller's plan. */
+    limit: typeof Schema.Number;
+    /** How much was already used in the current window. */
+    used: typeof Schema.Number;
+    /** The cost the rejected call would have charged. */
+    cost: typeof Schema.Number;
+}>;
+
+/** An entitlement limit: a finite quota or the unbounded `'unlimited'`. */
+export declare type EntitlementLimit = number | 'unlimited';
+
+/** A monetary amount: integer minor units + ISO-4217 currency. */
+export declare interface Money {
+    /** Integer minor units (cents). Never a float. */
+    readonly amountMinor: number;
+    /** ISO-4217 currency code, lowercased (`'usd'`, `'eur'`). */
+    readonly currency: string;
+}
+
+/** One plan/tier: its entitlement limits + (for paid plans) a provider price id. */
+export declare interface PlanConfig {
+    /** Provider price id (Stripe `price_…`). Absent for free/zero-cost plans. */
+    readonly priceId?: string;
+    /** Per-entitlement-key limits. Values are `number | 'unlimited'`. */
+    readonly entitlements: Readonly<Record<string, EntitlementLimit>>;
+    /** The plan's per-period price in INTEGER minor units (cents) — the unit
+     *  amount for ONE seat. Multiplied by the subscription's seat `quantity` to
+     *  get the billed amount, and drives mid-cycle proration. Absent for free
+     *  plans (treated as 0). Never a float. */
+    readonly unitAmountMinor?: number;
+    /** ISO-4217 currency for `unitAmountMinor`, lowercased (`'usd'`). Defaults
+     *  to `'usd'` when a `unitAmountMinor` is set without one. */
+    readonly currency?: string;
+}
+
+/** Plan id (the key in `billingPlugin({ plans })`). */
+export declare type PlanId = string;
+
+export declare interface PortalInput {
+    readonly tenantId: string;
+    /** Provider customer id whose billing portal to open. */
+    readonly providerCustomerId: string;
+    readonly returnUrl: string;
+}
+
+/** A tenant's subscription row, normalized across providers. */
+export declare interface Subscription {
+    readonly tenantId: string;
+    readonly provider: string;
+    readonly providerSubscriptionId: string;
+    readonly plan: PlanId;
+    readonly status: SubscriptionStatus;
+    /** Per-seat quantity — the billed amount is `plan.unitAmountMinor × quantity`.
+     *  Defaults to 1 for a single-seat subscription. */
+    readonly quantity: number;
+    /** Start of the current paid period; null for plans without a period.
+     *  Anchors mid-cycle proration (the "used" side of the period). */
+    readonly currentPeriodStart: Date | null;
+    /** When the current paid period ends; null for plans without a period. */
+    readonly currentPeriodEnd: Date | null;
+    /** When the subscription is scheduled to cancel; null if not scheduled. */
+    readonly cancelAt: Date | null;
+}
+
+/** The outcome of a mid-cycle plan/seat change — the prorated settlement. */
+export declare interface SubscriptionChange {
+    readonly tenantId: string;
+    readonly plan: PlanId;
+    readonly quantity: number;
+    /** Integer minor-unit settlement: > 0 charge, < 0 credit, 0 at boundary. */
+    readonly prorationMinor: number;
+    readonly currency: string;
+}
+
+export declare type SubscriptionStatus = 'active' | 'trialing' | 'pastDue' | 'canceled' | 'incomplete';
+
+export declare interface UsagePush {
+    readonly tenantId: string;
+    readonly entitlementKey: string;
+    /** Aggregate quantity to report for the current period. */
+    readonly quantity: number;
+    /** End of the period the usage falls in (provider timestamp anchor). */
+    readonly periodEnd?: Date;
+}
+
+export { }

package/dist/types.js

@@ -0,0 +1,14 @@
+import { Context as e, Schema as t } from "effect";
+//#region src/types.ts
+var n = class extends t.TaggedError()("BillingError", {
+	source: t.String,
+	message: t.String,
+	transient: t.Boolean
+}) {}, r = class extends t.TaggedError()("EntitlementExceeded", {
+	entitlement: t.String,
+	limit: t.Number,
+	used: t.Number,
+	cost: t.Number
+}) {}, i = "free", a = class extends e.Tag("@voltro/plugin-billing/BillingService")() {};
+//#endregion
+export { n as BillingError, a as BillingService, i as DEFAULT_PLAN, r as EntitlementExceeded };

package/dist/web/index.d.ts

@@ -0,0 +1,41 @@
+/** The plan id + redirect URLs a checkout needs. */
+export declare interface StartCheckoutInput {
+    readonly plan: string;
+    readonly successUrl: string;
+    readonly cancelUrl: string;
+}
+
+/**
+ * The caller injects the rpc binding — the generated client's
+ * `billing.startCheckout` action. Kept as a plain function type so the web
+ * subpath has zero dependency on the rpc client package; the app wires its
+ * generated binding in.
+ */
+export declare type StartCheckoutRpc = (input: StartCheckoutInput) => Promise<{
+    readonly url: string;
+}>;
+
+/**
+ * React hook that drives provider-hosted checkout. Pass the generated
+ * `billing.startCheckout` rpc binding; the hook tracks pending/error and
+ * performs the redirect on success.
+ *
+ * ```tsx
+ * const { startCheckout, pending } = useStartCheckout(rpc.billing.startCheckout)
+ * <button disabled={pending} onClick={() => startCheckout({
+ *   plan: 'pro', successUrl: location.href, cancelUrl: location.href,
+ * })}>Upgrade</button>
+ * ```
+ */
+export declare const useStartCheckout: (rpc: StartCheckoutRpc) => UseStartCheckoutResult;
+
+export declare interface UseStartCheckoutResult {
+    /** Kick off checkout: calls the rpc, then redirects to the provider URL. */
+    readonly startCheckout: (input: StartCheckoutInput) => Promise<void>;
+    /** True while the rpc is in flight. */
+    readonly pending: boolean;
+    /** The last error, or null. */
+    readonly error: Error | null;
+}
+
+export { }

package/dist/web/index.js

@@ -0,0 +1,22 @@
+import { useCallback as e, useState as t } from "react";
+//#region src/web/index.ts
+var n = () => globalThis.window, r = (r) => {
+	let [i, a] = t(!1), [o, s] = t(null);
+	return {
+		startCheckout: e(async (e) => {
+			a(!0), s(null);
+			try {
+				let { url: t } = await r(e);
+				n()?.location.assign(t);
+			} catch (e) {
+				throw s(e instanceof Error ? e : Error(String(e))), e;
+			} finally {
+				a(!1);
+			}
+		}, [r]),
+		pending: i,
+		error: o
+	};
+};
+//#endregion
+export { r as useStartCheckout };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@voltro/plugin-billing",
+  "version": "0.1.0",
+  "description": "Billing — subscriptions, plans, entitlements + usage metering on top of a pluggable BillingProvider (Stripe + mock). Ships billingPlugin() (provider-event webhook via @voltro/plugin-webhooks, the entitlement interceptor, typed BillingError + EntitlementExceeded errors, the _voltro_billing_* tables), the BillingService Context.Tag, the requireEntitlement() in-handler guard, and a browser-safe useStartCheckout() hook. Money is integer minor units end-to-end.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./web": {
+      "types": "./dist/web/index.d.ts",
+      "import": "./dist/web/index.js",
+      "default": "./dist/web/index.js"
+    },
+    "./errors": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/database": "0.1.0",
+    "@voltro/env": "0.1.0",
+    "@voltro/logger": "0.1.0",
+    "@voltro/plugin-webhooks": "0.1.0",
+    "@voltro/protocol": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4",
+    "react": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}