@absolutejs/billing 0.6.0 → 0.8.0

package/dist/ledger.js

@@ -73,13 +73,13 @@ var creditGate = (input) => {
 };
 var isGrantableCredits = (credits) => Number.isFinite(credits) && credits > 0;
 export {
-  isPeriodLapsed,
-  isGrantableCredits,
-  creditsFor,
-  creditGate,
+  createUsageLedger,
   creditBalanceFrom,
-  createUsageLedger
+  creditGate,
+  creditsFor,
+  isGrantableCredits,
+  isPeriodLapsed
 };
 
-//# debugId=C0A752957B46E2F564756E2164756E21
+//# debugId=CB2DC54F3ACBA03564756E2164756E21
 //# sourceMappingURL=ledger.js.map

package/dist/ledger.js.map

@@ -5,6 +5,6 @@
     "// The layer between a meter and an invoice: every metered event gets priced,\n// converted to the customer's credit unit, written to an append-only ledger,\n// debited against a balance, and folded into a daily rollup that a spend cap\n// can read. Every app billing a metered API rebuilds this, and each one\n// rediscovers the same three traps:\n//\n//   - Money in floats. Summing float ledger rows drifts; one real deployment\n//     lost 2 cents across 25,740 rows before anyone noticed. Amounts here are\n//     integer sub-units (see Plan.denomination) and are only ever added.\n//   - The debit and the ledger row diverging. If the row is written but the\n//     balance is not debited, a customer gets free usage; the reverse\n//     over-charges. They must land together, so the store commits them as one\n//     unit — this module never splits them.\n//   - The rollup being treated as truth. It is a derived index, rebuildable\n//     from the ledger, so a rollup failure must never fail the charge.\n//\n// Storage stays the host's business (Postgres, ClickHouse, anything). This\n// owns the policy and the arithmetic, which is the part that is identical\n// everywhere — and the part that is worth getting wrong only once.\n\n/** One priced, metered event, ready to persist. */\nexport type LedgerEntry = {\n  /** Charge in integer sub-units of the plan's denomination (see\n   *  `Plan.denomination`) — never a float. */\n  amount: number;\n  /** What the customer is billed in the product's own unit. */\n  credits: number;\n  /** Product-level grouping (\"chat\", \"voice\"), not the vendor's. */\n  feature?: string | null;\n  model?: string;\n  /** \"llm\" | \"tts\" | \"embedding\" | whatever the product meters. */\n  operation: string;\n  provider: string;\n  /** Idempotency handle for at-least-once callers. */\n  requestId?: string;\n  /** Null for system/background work with nobody to bill. */\n  tenant?: string | null;\n};\n\nexport type LedgerCommit = {\n  /** Append the row AND debit `entry.credits` from the tenant's balance in a\n   *  single atomic unit. Called with tenant null for unattributed work, where\n   *  there is nothing to debit. */\n  commit: (entry: LedgerEntry) => Promise<void>;\n  /** Fold the entry into a derived daily aggregate. Best-effort by contract:\n   *  this module swallows its failures. */\n  rollup?: (entry: LedgerEntry) => Promise<void>;\n  /** Total sub-units charged since `since`, for the spend cap. */\n  spentSince?: (since: Date) => Promise<number>;\n};\n\nexport type UsageLedgerOptions = {\n  /** Sub-units per credit. A peg of 1_000 with micros means 1 credit =\n   *  $0.001. Required for credit conversion; omit to bill in raw amounts. */\n  creditPegSubUnits?: number;\n  /** Reported when a rollup fails. The charge already succeeded. */\n  onRollupError?: (error: unknown, entry: LedgerEntry) => void;\n  store: LedgerCommit;\n};\n\n/**\n * Credits for a charge. Ceiling, not rounding: a product that sells credits\n * must never hand out a fraction it cannot deduct, and rounding down means\n * the smallest calls are free — which is how a \"cheap\" endpoint becomes an\n * unmetered one.\n */\nexport const creditsFor = (amount: number, pegSubUnits: number) => {\n  if (pegSubUnits <= 0) return 0;\n\n  return Math.ceil(amount / pegSubUnits);\n};\n\nexport type UsageLedger = {\n  /** Price-agnostic: hand it an amount already in sub-units. Returns what was\n   *  written, including the credits it derived. */\n  record: (\n    entry: Omit<LedgerEntry, \"credits\"> & { credits?: number },\n  ) => Promise<LedgerEntry>;\n  /** True once spend since `since` reaches `capSubUnits`. Fails OPEN — a\n   *  broken cap must not take down paid features, and the per-provider\n   *  budgets are still in front. */\n  overCap: (capSubUnits: number, since: Date) => Promise<boolean>;\n};\n\nexport const createUsageLedger = (options: UsageLedgerOptions): UsageLedger => {\n  const { creditPegSubUnits, onRollupError, store } = options;\n\n  return {\n    overCap: async (capSubUnits, since) => {\n      if (!store.spentSince) return false;\n      try {\n        return (await store.spentSince(since)) >= capSubUnits;\n      } catch {\n        return false;\n      }\n    },\n    record: async (input) => {\n      const credits =\n        input.credits ??\n        (creditPegSubUnits === undefined\n          ? 0\n          : creditsFor(input.amount, creditPegSubUnits));\n      const entry: LedgerEntry = { ...input, credits };\n      // The charge is the thing that must not be lost; it is awaited and its\n      // failure propagates to the caller.\n      await store.commit(entry);\n      // The rollup is a derived index — rebuildable from the ledger — so its\n      // failure is reported, never raised.\n      if (store.rollup) {\n        await store.rollup(entry).catch((error: unknown) => {\n          onRollupError?.(error, entry);\n        });\n      }\n\n      return entry;\n    },\n  };\n};\n\n// -----------------------------------------------------------------------------\n// Credit balances\n// -----------------------------------------------------------------------------\n\n// A credit-based product needs the same four decisions no matter what it\n// sells: what the customer may spend, whether the period has rolled, whether\n// this call is allowed, and whether a grant is real. The lookups behind them\n// (subscriptions, comps, plan tables) are the host's; the arithmetic is not,\n// and it is the part where an off-by-one hands out free usage.\n\nexport type CreditBalanceInput = {\n  /** Granted credits that SURVIVE a period reset (referrals, goodwill). */\n  bonusCredits: number;\n  consumed: number;\n  /** Credits the plan grants for the current period. */\n  periodAllowance: number;\n  periodEnd?: Date | null;\n};\n\nexport type CreditBalance = {\n  /** periodAllowance + bonusCredits — the spendable ceiling this period. */\n  allowance: number;\n  bonusCredits: number;\n  consumed: number;\n  periodAllowance: number;\n  periodEnd: Date | null;\n  /** Never negative: an over-spend reads as zero left, not a debt. */\n  remaining: number;\n};\n\n/** Derive the spendable view of a stored balance row. */\nexport const creditBalanceFrom = (row: CreditBalanceInput): CreditBalance => {\n  const allowance = row.periodAllowance + row.bonusCredits;\n\n  return {\n    allowance,\n    bonusCredits: row.bonusCredits,\n    consumed: row.consumed,\n    periodAllowance: row.periodAllowance,\n    periodEnd: row.periodEnd ?? null,\n    remaining: Math.max(0, allowance - row.consumed),\n  };\n};\n\n/** Whether the billing window has closed and the allowance should re-snapshot.\n *  A null end date means \"no window\" — an unbounded balance never lapses. */\nexport const isPeriodLapsed = (\n  periodEnd: Date | null | undefined,\n  now = new Date(),\n) =>\n  periodEnd !== null &&\n  periodEnd !== undefined &&\n  periodEnd.getTime() <= now.getTime();\n\n/**\n * How hard the gate bites. `off` skips the balance read entirely, `warn`\n * always allows but reports `low` so the UI can say so, `block` refuses once\n * the remaining balance cannot cover the estimate.\n */\nexport type CreditEnforcementMode = \"block\" | \"off\" | \"warn\";\n\nexport type CreditGate = {\n  allowance: number;\n  allowed: boolean;\n  /** True when the balance cannot cover the estimate, in ANY mode — the\n   *  signal a product surfaces before it starts refusing work. */\n  low: boolean;\n  mode: CreditEnforcementMode;\n  remaining: number;\n};\n\nexport type CreditGateInput = {\n  allowance: number;\n  estimatedCredits?: number;\n  mode: CreditEnforcementMode;\n  remaining: number;\n};\n\n/** Decide whether a metered call proceeds. Pure — the caller does the reads. */\nexport const creditGate = (input: CreditGateInput): CreditGate => {\n  const { allowance, estimatedCredits = 1, mode, remaining } = input;\n  if (mode === \"off\") {\n    return { allowance: 0, allowed: true, low: false, mode, remaining: 0 };\n  }\n  const sufficient = remaining >= estimatedCredits;\n\n  return {\n    allowance,\n    allowed: mode === \"block\" ? sufficient : true,\n    low: !sufficient,\n    mode,\n    remaining,\n  };\n};\n\n/** Whether a bonus grant is worth writing — guards against NaN and negatives\n *  quietly corrupting a balance. */\nexport const isGrantableCredits = (credits: number) =>\n  Number.isFinite(credits) && credits > 0;\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;AAkEO,IAAM,aAAa,CAAC,QAAgB,gBAAwB;AAAA,EACjE,IAAI,eAAe;AAAA,IAAG,OAAO;AAAA,EAE7B,OAAO,KAAK,KAAK,SAAS,WAAW;AAAA;AAehC,IAAM,oBAAoB,CAAC,YAA6C;AAAA,EAC7E,QAAQ,mBAAmB,eAAe,UAAU;AAAA,EAEpD,OAAO;AAAA,IACL,SAAS,OAAO,aAAa,UAAU;AAAA,MACrC,IAAI,CAAC,MAAM;AAAA,QAAY,OAAO;AAAA,MAC9B,IAAI;AAAA,QACF,OAAQ,MAAM,MAAM,WAAW,KAAK,KAAM;AAAA,QAC1C,MAAM;AAAA,QACN,OAAO;AAAA;AAAA;AAAA,IAGX,QAAQ,OAAO,UAAU;AAAA,MACvB,MAAM,UACJ,MAAM,YACL,sBAAsB,YACnB,IACA,WAAW,MAAM,QAAQ,iBAAiB;AAAA,MAChD,MAAM,QAAqB,KAAK,OAAO,QAAQ;AAAA,MAG/C,MAAM,MAAM,OAAO,KAAK;AAAA,MAGxB,IAAI,MAAM,QAAQ;AAAA,QAChB,MAAM,MAAM,OAAO,KAAK,EAAE,MAAM,CAAC,UAAmB;AAAA,UAClD,gBAAgB,OAAO,KAAK;AAAA,SAC7B;AAAA,MACH;AAAA,MAEA,OAAO;AAAA;AAAA,EAEX;AAAA;AAkCK,IAAM,oBAAoB,CAAC,QAA2C;AAAA,EAC3E,MAAM,YAAY,IAAI,kBAAkB,IAAI;AAAA,EAE5C,OAAO;AAAA,IACL;AAAA,IACA,cAAc,IAAI;AAAA,IAClB,UAAU,IAAI;AAAA,IACd,iBAAiB,IAAI;AAAA,IACrB,WAAW,IAAI,aAAa;AAAA,IAC5B,WAAW,KAAK,IAAI,GAAG,YAAY,IAAI,QAAQ;AAAA,EACjD;AAAA;AAKK,IAAM,iBAAiB,CAC5B,WACA,MAAM,IAAI,SAEV,cAAc,QACd,cAAc,aACd,UAAU,QAAQ,KAAK,IAAI,QAAQ;AA2B9B,IAAM,aAAa,CAAC,UAAuC;AAAA,EAChE,QAAQ,WAAW,mBAAmB,GAAG,MAAM,cAAc;AAAA,EAC7D,IAAI,SAAS,OAAO;AAAA,IAClB,OAAO,EAAE,WAAW,GAAG,SAAS,MAAM,KAAK,OAAO,MAAM,WAAW,EAAE;AAAA,EACvE;AAAA,EACA,MAAM,aAAa,aAAa;AAAA,EAEhC,OAAO;AAAA,IACL;AAAA,IACA,SAAS,SAAS,UAAU,aAAa;AAAA,IACzC,KAAK,CAAC;AAAA,IACN;AAAA,IACA;AAAA,EACF;AAAA;AAKK,IAAM,qBAAqB,CAAC,YACjC,OAAO,SAAS,OAAO,KAAK,UAAU;",
-  "debugId": "C0A752957B46E2F564756E2164756E21",
+  "debugId": "CB2DC54F3ACBA03564756E2164756E21",
   "names": []
 }

package/dist/manifest.js

@@ -588,22 +588,22 @@ var TypeSystemPolicy;
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
 __export(exports_value, {
-  IsUndefined: () => IsUndefined2,
-  IsUint8Array: () => IsUint8Array,
-  IsSymbol: () => IsSymbol,
-  IsString: () => IsString,
-  IsRegExp: () => IsRegExp,
-  IsObject: () => IsObject2,
-  IsNumber: () => IsNumber2,
-  IsNull: () => IsNull,
-  IsIterator: () => IsIterator,
-  IsFunction: () => IsFunction,
-  IsDate: () => IsDate,
-  IsBoolean: () => IsBoolean,
-  IsBigInt: () => IsBigInt,
-  IsAsyncIterator: () => IsAsyncIterator,
+  HasPropertyKey: () => HasPropertyKey,
   IsArray: () => IsArray2,
-  HasPropertyKey: () => HasPropertyKey
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber2,
+  IsObject: () => IsObject2,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUint8Array: () => IsUint8Array,
+  IsUndefined: () => IsUndefined2
 });
 function HasPropertyKey(value, key) {
   return key in value;
@@ -1208,7 +1208,7 @@ function Literal(value, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
-function Boolean(options) {
+function Boolean2(options) {
   return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
 }
 
@@ -1230,7 +1230,7 @@ function String2(options) {
 // node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
 function* FromUnion(syntax) {
   const trim = syntax.trim().replace(/"|'/g, "");
-  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
+  return trim === "boolean" ? yield Boolean2() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
     const literals = trim.split("|").map((literal) => Literal(literal.trim()));
     return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
   })();
@@ -1622,57 +1622,57 @@ function Unknown(options) {
 // node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 var exports_type = {};
 __export(exports_type, {
-  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError,
-  IsVoid: () => IsVoid2,
-  IsUnsafe: () => IsUnsafe2,
-  IsUnknown: () => IsUnknown2,
-  IsUnionLiteral: () => IsUnionLiteral,
-  IsUnion: () => IsUnion2,
-  IsUndefined: () => IsUndefined4,
-  IsUint8Array: () => IsUint8Array3,
-  IsTuple: () => IsTuple2,
-  IsTransform: () => IsTransform2,
-  IsThis: () => IsThis2,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsSymbol: () => IsSymbol3,
-  IsString: () => IsString3,
-  IsSchema: () => IsSchema2,
-  IsRegExp: () => IsRegExp3,
-  IsRef: () => IsRef2,
-  IsRecursive: () => IsRecursive,
-  IsRecord: () => IsRecord2,
-  IsReadonly: () => IsReadonly2,
-  IsProperties: () => IsProperties,
-  IsPromise: () => IsPromise2,
-  IsOptional: () => IsOptional2,
-  IsObject: () => IsObject4,
-  IsNumber: () => IsNumber4,
-  IsNull: () => IsNull3,
-  IsNot: () => IsNot2,
-  IsNever: () => IsNever2,
-  IsMappedResult: () => IsMappedResult2,
-  IsMappedKey: () => IsMappedKey2,
-  IsLiteralValue: () => IsLiteralValue2,
-  IsLiteralString: () => IsLiteralString,
-  IsLiteralNumber: () => IsLiteralNumber,
-  IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteral: () => IsLiteral2,
-  IsKindOf: () => IsKindOf2,
-  IsKind: () => IsKind2,
-  IsIterator: () => IsIterator3,
-  IsIntersect: () => IsIntersect2,
-  IsInteger: () => IsInteger2,
-  IsImport: () => IsImport,
-  IsFunction: () => IsFunction3,
-  IsDate: () => IsDate3,
-  IsConstructor: () => IsConstructor2,
-  IsComputed: () => IsComputed2,
-  IsBoolean: () => IsBoolean3,
-  IsBigInt: () => IsBigInt3,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsArray: () => IsArray4,
+  IsAny: () => IsAny2,
   IsArgument: () => IsArgument2,
-  IsAny: () => IsAny2
+  IsArray: () => IsArray4,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsBigInt: () => IsBigInt3,
+  IsBoolean: () => IsBoolean3,
+  IsComputed: () => IsComputed2,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate3,
+  IsFunction: () => IsFunction3,
+  IsImport: () => IsImport,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator3,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull3,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise2,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol3,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array3,
+  IsUndefined: () => IsUndefined4,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
 });
 class TypeGuardUnknownTypeError extends TypeBoxError {
 }
@@ -3023,68 +3023,68 @@ function Void(options) {
 // node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
 var exports_type2 = {};
 __export(exports_type2, {
-  Void: () => Void,
-  Uppercase: () => Uppercase,
-  Unsafe: () => Unsafe,
-  Unknown: () => Unknown,
-  Union: () => Union,
-  Undefined: () => Undefined,
-  Uncapitalize: () => Uncapitalize,
-  Uint8Array: () => Uint8Array2,
-  Tuple: () => Tuple,
-  Transform: () => Transform,
-  TemplateLiteral: () => TemplateLiteral,
-  Symbol: () => Symbol2,
-  String: () => String2,
-  ReturnType: () => ReturnType,
-  Rest: () => Rest,
-  Required: () => Required,
-  RegExp: () => RegExp2,
-  Ref: () => Ref,
-  Recursive: () => Recursive,
-  Record: () => Record,
-  ReadonlyOptional: () => ReadonlyOptional,
-  Readonly: () => Readonly,
-  Promise: () => Promise2,
-  Pick: () => Pick,
-  Partial: () => Partial,
-  Parameters: () => Parameters,
-  Optional: () => Optional,
-  Omit: () => Omit,
-  Object: () => Object2,
-  Number: () => Number2,
-  Null: () => Null,
-  Not: () => Not,
-  Never: () => Never,
-  Module: () => Module,
-  Mapped: () => Mapped,
-  Lowercase: () => Lowercase,
-  Literal: () => Literal,
-  KeyOf: () => KeyOf,
-  Iterator: () => Iterator,
-  Intersect: () => Intersect,
-  Integer: () => Integer,
-  Instantiate: () => Instantiate,
-  InstanceType: () => InstanceType,
-  Index: () => Index,
-  Function: () => Function,
-  Extract: () => Extract,
-  Extends: () => Extends,
-  Exclude: () => Exclude,
-  Enum: () => Enum,
-  Date: () => Date2,
-  ConstructorParameters: () => ConstructorParameters,
-  Constructor: () => Constructor,
-  Const: () => Const,
-  Composite: () => Composite,
-  Capitalize: () => Capitalize,
-  Boolean: () => Boolean,
-  BigInt: () => BigInt,
-  Awaited: () => Awaited,
-  AsyncIterator: () => AsyncIterator,
-  Array: () => Array2,
+  Any: () => Any,
   Argument: () => Argument,
-  Any: () => Any
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean2,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
 });
 
 // node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
@@ -3252,6 +3252,79 @@ var serializedTool = Type.Object({
   input: jsonSchemaObject,
   kind: Type.Union([Type.Literal("runtime"), Type.Literal("workspace")])
 });
+var productId = Type.String({ pattern: "^[a-z][a-z0-9_-]{0,63}$" });
+var productCopy = {
+  description: Type.String({ minLength: 1 }),
+  id: productId,
+  title: Type.String({ minLength: 1 })
+};
+var productOperation = Type.Union([
+  Type.Literal("aggregate"),
+  Type.Literal("create"),
+  Type.Literal("delete"),
+  Type.Literal("detail"),
+  Type.Literal("list"),
+  Type.Literal("update")
+]);
+var productProjection = Type.Object({
+  blocks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    category: Type.String({ minLength: 1 }),
+    componentExport: Type.String({ minLength: 1 }),
+    frameworks: Type.Optional(Type.Array(Type.Union(clientFrameworks.map((framework) => Type.Literal(framework))))),
+    props: jsonSchemaObject
+  }))),
+  connections: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    envKeys: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    kind: Type.Union([
+      Type.Literal("none"),
+      Type.Literal("oauth"),
+      Type.Literal("secret")
+    ]),
+    setupTool: Type.Optional(Type.String({ pattern: TOOL_NAME_PATTERN.source })),
+    testTool: Type.Optional(Type.String({ pattern: TOOL_NAME_PATTERN.source }))
+  }))),
+  dataSources: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    operations: Type.Array(productOperation, { minItems: 1 }),
+    schema: jsonSchemaObject,
+    tools: Type.Optional(Type.Partial(Type.Object({
+      aggregate: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      create: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      delete: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      detail: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      list: Type.String({ pattern: TOOL_NAME_PATTERN.source }),
+      update: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+    })))
+  }))),
+  events: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    schema: jsonSchemaObject,
+    source: Type.Union([
+      Type.Literal("data"),
+      Type.Literal("package"),
+      Type.Literal("ui"),
+      Type.Literal("webhook")
+    ])
+  }))),
+  healthChecks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    tool: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+  }))),
+  releaseChecks: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    healthCheckIds: Type.Optional(Type.Array(productId)),
+    severity: Type.Union([
+      Type.Literal("blocking"),
+      Type.Literal("warning")
+    ])
+  }))),
+  workflowActions: Type.Optional(Type.Array(Type.Object({
+    ...productCopy,
+    tool: Type.String({ pattern: TOOL_NAME_PATTERN.source })
+  })))
+});
 var manifestSchema = Type.Object({
   contract: Type.Union([Type.Literal(1), Type.Literal(2)]),
   discovery: Type.Optional(Type.Object({
@@ -3277,6 +3350,14 @@ var manifestSchema = Type.Object({
     tagline: Type.String({ minLength: 1 })
   }),
   implements: Type.Optional(Type.Array(adapterImplementation)),
+  integration: Type.Optional(Type.Object({
+    description: Type.Optional(Type.String({ minLength: 1 })),
+    mode: Type.Union([
+      Type.Literal("adapter"),
+      Type.Literal("code-first"),
+      Type.Literal("recipe")
+    ])
+  })),
   lifecycle: Type.Optional(Type.Array(lifecycleStep)),
   presets: Type.Optional(Type.Array(Type.Object({
     description: Type.Optional(Type.String()),
@@ -3284,6 +3365,7 @@ var manifestSchema = Type.Object({
     title: Type.String(),
     values: Type.Record(Type.String(), Type.Unknown())
   }))),
+  product: Type.Optional(productProjection),
   requires: Type.Optional(manifestRequirements),
   settings: jsonSchemaObject,
   slots: Type.Optional(Type.Record(Type.String(), adapterSlot)),
@@ -3455,5 +3537,5 @@ export {
   manifest
 };
 
-//# debugId=FB56701BA9401D2A64756E2164756E21
+//# debugId=2A4F7A6A88D9528264756E2164756E21
 //# sourceMappingURL=manifest.js.map