@vibedout/commerce 0.0.0-stage → 0.2.4

package/dist/types-BUyLunnB.d.mts

@@ -0,0 +1,503 @@
+//#region ../money/src/index.d.ts
+/**
+ * `@vibedout/money`: one money type, and the conversions around it done once.
+ *
+ * An amount is an integer count of minor units (centavos, cents) plus an uppercase ISO 4217 currency.
+ * No float ever crosses a package's API: a provider that speaks decimals ("185.20", `62.5`) is converted
+ * at its HTTP boundary with {@link toMinor}, and shown to people with {@link formatMoney}.
+ *
+ * This file imports nothing, so it can be copied into a project as it is. It needs only `Intl`
+ * (for {@link formatMoney}), which every runtime provides.
+ */
+interface Money {
+  /** Whole minor units, never a float. */
+  amountMinor: number;
+  /** Uppercase ISO 4217, for example `"MXN"`. */
+  currency: string;
+}
+//#endregion
+//#region src/types.d.ts
+/** The platform's two languages. `es-MX` is the default. */
+type CommerceLocale = "es-MX" | "en";
+/**
+ * What a port needs from the request it runs in. The same shape as the event bus's `SubscriberContext` with a clock, so a test can fix the
+ * time and a hold expires when the test says.
+ */
+interface PortContext<Env = unknown> {
+  env: Env;
+  db: D1Database;
+  /** Milliseconds since the epoch. Use this and not `Date.now()`, so expiry is testable. */
+  now: number;
+  /** The language of the strings a port returns (titles, rate names). Default `es-MX`. */
+  locale?: CommerceLocale;
+  /** The signed-in person, when there is one. A guest is `null` or left out. */
+  userId?: string | null;
+}
+declare const LINE_AVAILABILITIES: readonly ["available", "sold_out", "not_orderable", "not_found"];
+/**
+ * - `available`: can be bought now, in the quantity asked up to `maxQuantity`.
+ * - `sold_out`: a real item with no stock now ("agotado hoy"). It keeps its title and price so a cart can still show it.
+ * - `not_orderable`: a real item that is not for sale (hidden, draft, ordering switched off).
+ * - `not_found`: the `ref` is not (or no longer) sold. `title` may be the ref and the price is 0; it is never charged.
+ */
+type LineAvailability = (typeof LINE_AVAILABILITIES)[number];
+declare const FULFILMENTS: readonly ["ship", "pickup", "digital", "service", "none"];
+/** What happens after payment, so a cart knows whether it needs an address (`ship`) and a receipt knows what it sold. */
+type Fulfilment = (typeof FULFILMENTS)[number];
+/** A value that survives `JSON.stringify` and back unchanged. */
+type SnapshotValue = string | number | boolean | null | readonly SnapshotValue[] | {
+  readonly [key: string]: SnapshotValue;
+};
+/** What is frozen into the order line (a variant's name, its sku, an image id, the chosen options). At most 2 KiB as JSON. */
+interface LineSnapshot {
+  readonly [key: string]: SnapshotValue;
+}
+/** What the browser says: which thing and how many. Never a price. */
+interface LineAsk {
+  /** The source's own id for the thing (`var_1`, a sku, a service id). Opaque to everyone but the source. */
+  ref: string;
+  /** A whole number of at least 1. */
+  quantity: number;
+  /** Choices the buyer made (`{ size: "m" }`), for a source that has them. Strings only. */
+  options?: Readonly<Record<string, string>>;
+}
+/** The ids inventory knows an item by. The owner of the thing says it in two strings and never imports inventory. */
+interface StockSubject {
+  /** `catalog.variant`, `menu.item`, `shop.sku`. */
+  subjectType: string;
+  subjectId: string;
+}
+/** What a line source answers for one {@link LineAsk}: the server's price and everything that depends on the thing. */
+interface ResolvedLine {
+  /** The ask's `ref`, echoed. */
+  ref: string;
+  /** What the buyer sees and what the receipt keeps, in the context's language. */
+  title: string;
+  /** The ask's quantity, echoed. A source never changes it; `maxQuantity` says what is allowed. */
+  quantity: number;
+  /** The price of one, in minor units. 0 is allowed (a free item). */
+  unitAmountMinor: number;
+  /** Uppercase ISO 4217. */
+  currency: string;
+  availability: LineAvailability;
+  /** The most of this line one order may take: the stock left, or a per-order cap. At least 1 when given. */
+  maxQuantity?: number;
+  /** The SAT product and service key (ClaveProdServ) for the invoice. */
+  taxCode?: string;
+  /** Whether `unitAmountMinor` already includes tax (Mexican shelf prices do). */
+  taxIncluded: boolean;
+  fulfilment: Fulfilment;
+  /** Present when inventory should hold this line. */
+  stock?: StockSubject;
+  /** What to freeze into the order line. */
+  snapshot: LineSnapshot;
+}
+/**
+ * Prices what a buyer asks for. A feature registers one under a dotted key in `block.json` (`worker-ports`, port `line-source`, key
+ * `catalog.variant`); a checkout or a payment finds it by that key. The result has **one line per ask, in the order asked**, even for a
+ * ref that does not exist (`availability: "not_found"`); it never throws for a bad ref and never trusts a price from the ask.
+ *
+ * A source whose things have a capacity of their own, which inventory does not count (a booking slot and its seats, a class and its places),
+ * also holds them: `hold`, `commit` and `release`, optional (0.2.0) and always the three together. They follow the stock port's rules, by
+ * the ask instead of a stock subject: a hold is every ask or none and idempotent by `holdId` (a later `expiresAt` extends it, never
+ * shortens it; a hold that is over answers `hold_closed`), the last place goes to one buyer, the clock is `ctx.now`, the places come back by
+ * themselves at `expiresAt`, a payment that arrives after that still commits and says `late` (and `oversold` when the place went to someone
+ * else meanwhile), and a committed hold cannot be released. While a hold lasts, `resolve` counts its places as taken (`maxQuantity`, and
+ * `sold_out` at none). A checkout holds such a source's asks with the order's id, beside the stock port's hold, and commits or releases
+ * both. `runLineHoldConformance` in `@vibedout/commerce/testing` is the suite such a source passes.
+ */
+interface LineSource {
+  resolve(ctx: PortContext, asks: readonly LineAsk[]): Promise<readonly ResolvedLine[]>;
+  /** Optional (0.2.0), with `commit` and `release`: takes the places the asks name until `expiresAt`. */
+  hold?(ctx: PortContext, request: LineHoldRequest): Promise<LineHoldResult>;
+  /** Optional (0.2.0): the payment succeeded, the places are sold. A late commit still commits. */
+  commit?(ctx: PortContext, holdId: string): Promise<LineSettleResult>;
+  /** Optional (0.2.0): the payment failed for good, was cancelled or expired: the places go back. */
+  release?(ctx: PortContext, holdId: string): Promise<LineSettleResult>;
+}
+/** One line of a cart, which names the line source that sells it: a cart holds things of several features. */
+interface CartAsk extends LineAsk {
+  /** The key the source is registered under (`catalog.variant`, `booking.service`). */
+  source: string;
+}
+/** What `resolveCart` answers for a {@link CartAsk}: its source's line, and the key of that source. */
+interface CartLine extends ResolvedLine {
+  source: string;
+}
+/**
+ * The line source registered under a key, or nothing. With the pattern pack's registry:
+ * `(key) => { const found = linePort<LineSource>(key); return found.ok ? found.port : undefined; }`.
+ */
+type FindLineSource = (key: string) => LineSource | undefined;
+/** A line source that holds its own places: `hold`, `commit` and `release` are there (`holdsCapacity` tells). */
+type HoldingLineSource = LineSource & Required<Pick<LineSource, "hold" | "commit" | "release">>;
+declare const STOCK_TRACKINGS: readonly ["none", "toggle", "count"];
+/** `none`: always available. `toggle`: in or out by hand ("agotado hoy"). `count`: numbers, a ledger and holds. */
+type StockTracking = (typeof STOCK_TRACKINGS)[number];
+interface StockLevel {
+  subject: StockSubject;
+  tracking: StockTracking;
+  /** Whether one more can be taken now. */
+  inStock: boolean;
+  /** Units that can still be held. `null` when there is no number (`none`, and `toggle` while in); 0 for a `toggle` that is out. Never negative. */
+  available: number | null;
+  /** For `toggle` while out: when it comes back (milliseconds), or `null` for "until someone changes it". */
+  outUntil?: number | null;
+}
+interface HoldLine {
+  subject: StockSubject;
+  /** A whole number of at least 1. */
+  quantity: number;
+}
+interface HoldRequest {
+  /**
+   * The checkout's own id for this hold (the order id). The same id asked again with the same lines is the same hold: it holds nothing twice,
+   * and a later `expiresAt` extends it (a voucher's date is known only after the payment starts) but never shortens it. The hold the answer
+   * carries has the `expiresAt` that applies. An id whose hold is over answers `hold_closed`.
+   */
+  holdId: string;
+  /** Every line or none: a hold that cannot take all of them takes nothing. Two lines of one subject are held as their sum. */
+  lines: readonly HoldLine[];
+  /**
+   * Milliseconds since the epoch, after `ctx.now` and at most {@link MAX_HOLD_MS} after it (anything else is `invalid_request`: a time in the
+   * wrong unit would hold stock for years). The units go back by themselves at this time.
+   */
+  expiresAt: number;
+}
+/** The longest a hold may last: 14 days, more than the longest voucher a payment method gives. */
+declare const MAX_HOLD_MS: number;
+declare const HOLD_STATUSES: readonly ["held", "committed", "released", "expired"];
+type HoldStatus = (typeof HOLD_STATUSES)[number];
+/** A hold of the stock port, by stock subject; with `LineAsk` lines, a hold of a line source (`LineHold`). */
+interface Hold<Line = HoldLine> {
+  holdId: string;
+  status: HoldStatus;
+  /** Milliseconds since the epoch. */
+  expiresAt: number;
+  lines: readonly Line[];
+  /**
+   * When the committed units left (`fulfil`), in milliseconds since the epoch. Absent while they have not; the status stays `committed`,
+   * because fulfilling moves the units on hand, not whether they are sold.
+   */
+  fulfilledAt?: number;
+}
+interface ShortLine {
+  subject: StockSubject;
+  requested: number;
+  /** What could have been held. */
+  available: number;
+}
+type HoldResult<Line = HoldLine, Short = ShortLine> = {
+  ok: true;
+  hold: Hold<Line>;
+} | {
+  ok: false;
+  code: "insufficient_stock";
+  short: readonly Short[];
+} |
+/** The `holdId` exists with other lines. */
+{
+  ok: false;
+  code: "hold_conflict";
+} |
+/** The `holdId` is a hold that is over (committed, released or expired): a new attempt takes a new id. */
+{
+  ok: false;
+  code: "hold_closed";
+  status: Exclude<HoldStatus, "held">;
+} | {
+  ok: false;
+  code: "invalid_request";
+  message: string;
+};
+type SettleResult<Line = HoldLine> = {
+  ok: true;
+  hold: Hold<Line>;
+  /** False when the hold was already in the state asked for (the call is idempotent). */
+  changed: boolean;
+  /** Commit only: the hold had expired or been released before the payment arrived. The units were taken anyway: the money is in. */
+  late?: boolean;
+  /** Commit only: taking them put the stock below zero, for an item that does not allow overselling. A person should look at the order. */
+  oversold?: boolean;
+} | {
+  ok: false;
+  code: "unknown_hold";
+} |
+/** `release` of a hold that was already committed, `fulfil` of one that is not committed, or `uncommit` of one that is still held or was fulfilled. */
+{
+  ok: false;
+  code: "invalid_state";
+  status: HoldStatus;
+};
+/**
+ * Stock, provided by the `inventory` feature (one per project). Holds are atomic and idempotent by `holdId`, the last unit goes to exactly
+ * one of two buyers, and every decision about time (a hold that is over, a toggle that comes back) uses `ctx.now`, never the database's clock.
+ * `runStockConformance` in `@vibedout/commerce/testing` is the suite a provider must pass.
+ */
+interface StockPort {
+  availability(ctx: PortContext, subjects: readonly StockSubject[]): Promise<readonly StockLevel[]>;
+  /** Takes the units off the shelf until `expiresAt`. */
+  hold(ctx: PortContext, request: HoldRequest): Promise<HoldResult>;
+  /** The payment succeeded: the units are sold. A late commit still commits. */
+  commit(ctx: PortContext, holdId: string): Promise<SettleResult>;
+  /** The payment failed, was cancelled or expired: the units go back. */
+  release(ctx: PortContext, holdId: string): Promise<SettleResult>;
+  /**
+   * Optional (0.1.1): the units of a committed hold left the shelf (shipped, handed over, delivered). They stop being counted twice, as sold
+   * and as on hand: both go down by the hold's lines, so what can be bought does not move. Once per hold: a second call answers
+   * `changed: false`. A hold that is not committed is `invalid_state` with its status, and nothing moves. A checkout calls it when it
+   * fulfils an order; a provider that does not track units on hand may leave it out (`runStockConformance` then takes `skipFulfil`).
+   */
+  fulfil?(ctx: PortContext, holdId: string): Promise<SettleResult>;
+  /**
+   * Optional (0.2.1): the sale was undone before the units left the shelf (the order was refunded in full and never fulfilled), so a committed
+   * hold gives its units back: they can be bought again, `on hand` does not move, and the hold ends as `released`. Once per hold: a second
+   * call answers `changed: false`, as does a hold that is already over. A hold that is still `held` (not paid) is `invalid_state` with its
+   * status, because that is what `release` is for; a hold that was fulfilled is `invalid_state` `committed`, because its units left. The id
+   * stays closed to a new hold, and a payment that still arrived for it would commit it again as a late one: a caller uncommits an order
+   * that cannot be paid any more. A provider that does not count units may leave it out (`runStockConformance` then takes `skipUncommit`).
+   */
+  uncommit?(ctx: PortContext, holdId: string): Promise<SettleResult>;
+}
+/** What a line source that holds its own places takes: the asks it priced (`ref`, `quantity`, `options`), by the checkout's hold id. */
+interface LineHoldRequest {
+  /** The checkout's id for this hold (the order id), as in the stock port's {@link HoldRequest}. */
+  holdId: string;
+  /** Every ask or none. Two asks for the same ref with the same options are held as their sum. */
+  lines: readonly LineAsk[];
+  /** Milliseconds since the epoch, after `ctx.now` and at most {@link MAX_HOLD_MS} after it; anything else is `invalid_request`. */
+  expiresAt: number;
+}
+/** An ask a line source could not hold in full: what was asked and how many places there were. A ref the source does not know has 0. */
+interface ShortAsk {
+  ref: string;
+  requested: number;
+  available: number;
+}
+type LineHold = Hold<LineAsk>;
+type LineHoldResult = HoldResult<LineAsk, ShortAsk>;
+type LineSettleResult = SettleResult<LineAsk>;
+declare const PAYMENT_METHODS: readonly ["card", "oxxo", "spei"];
+type PaymentMethod = (typeof PAYMENT_METHODS)[number];
+/** One thing paid for, as the provider's page lists it. */
+interface PaymentLine {
+  ref?: string;
+  title: string;
+  quantity: number;
+  unitAmountMinor: number;
+  currency: string;
+  taxCode?: string;
+}
+declare const ADJUSTMENT_KINDS: readonly ["shipping", "tax", "discount"];
+type AdjustmentKind = (typeof ADJUSTMENT_KINDS)[number];
+/** How much of a discount came off one line: `index` is the position of the line in the list the discount is about. */
+interface LineDiscountPart {
+  index: number;
+  amountMinor: number;
+}
+/** A charge on top of the lines (`shipping`, `tax`) or a reduction (`discount`). `amountMinor` is never negative: the kind says the sign. */
+interface PaymentAdjustment {
+  kind: AdjustmentKind;
+  title: string;
+  amountMinor: number;
+  currency: string;
+  /**
+   * Optional (0.2.4), `discount` only: which of the request's `lines` it came off (`index` is the position in `StartPaymentInput.lines`), so
+   * the provider's page shows each line discounted by what the invoice states for it. The amounts add up to `amountMinor` and no line gives
+   * more than it costs ({@link checkLineDiscounts}). A discount that leaves it out is spread over what the other discounts left of the lines
+   * (the payments feature's own rule). `paymentRequestFrom` fills it in from `Totals.discounts`.
+   */
+  lines?: readonly LineDiscountPart[];
+}
+interface StartPaymentInput {
+  /** The order's id, set by the server. The provider's idempotency key derives from it: the same reference is the same payment. */
+  reference: string;
+  lines: readonly PaymentLine[];
+  adjustments?: readonly PaymentAdjustment[];
+  /**
+   * What is charged: the lines plus `shipping` and `tax`, minus `discount`. Must be greater than zero (a free order calls no provider). The
+   * discounts together are at most the lines: they are taken off the items, never off the shipping or the tax.
+   */
+  totalMinor: number;
+  currency: string;
+  /** Who pays. Both optional: a guest gives an email at most. */
+  payer?: {
+    userId?: string;
+    email?: string;
+  };
+  methods?: readonly PaymentMethod[];
+  successUrl: string;
+  cancelUrl: string;
+  /** Milliseconds since the epoch; the provider's page stops accepting payment then. */
+  expiresAt?: number;
+  metadata?: Readonly<Record<string, string>>;
+}
+type StartPaymentResult = {
+  ok: true;
+  paymentId: string;
+  redirectUrl: string;
+  expiresAt?: number;
+} | {
+  ok: false;
+  code: "invalid_request" | "not_configured" | "provider_error";
+  message: string;
+  /** Whether the same call may be tried again. */
+  retryable?: boolean;
+};
+/** Why a payment could not be cancelled. */
+type CancelPaymentFailure =
+/** No payment was started for this reference. */
+"unknown_payment" |
+/** It was paid (or refunded, or disputed): refund it instead. */
+"already_paid" |
+/** The provider cannot stop it now. `message` says why. */
+"not_cancellable" | "not_configured" | "provider_error";
+type CancelPaymentResult =
+/** The payment takes no money from now on. `changed` is false when it already could not (cancelled, expired, failed for good). */
+{
+  ok: true;
+  changed: boolean;
+} | {
+  ok: false;
+  code: CancelPaymentFailure;
+  message: string;
+  retryable?: boolean;
+};
+/**
+ * Money moves here, provided by the `payments` feature (one per project). `runPaymentsConformance` in `@vibedout/commerce/testing` is the
+ * suite a provider passes.
+ */
+interface PaymentsPort {
+  start(ctx: PortContext, input: StartPaymentInput): Promise<StartPaymentResult>;
+  /**
+   * Optional (0.2.0): the order behind `reference` will not be paid (staff cancelled it, or its time ran out), so the provider's page stops
+   * taking money and a voucher stops being payable. Once per payment: a second call answers `changed: false`, and starting the reference
+   * again is refused. A payment already on its way (a payer who pressed "pay" at the same moment, a voucher being paid at the counter) can
+   * still arrive as `payment.succeeded`: the caller handles it as the late payment it is. A caller checks the method is there
+   * (`payments.cancel?.(...)`); without it the page stays payable until its `expiresAt`.
+   */
+  cancel?(ctx: PortContext, reference: string): Promise<CancelPaymentResult>;
+}
+/** Where something goes. Country is ISO 3166-1 alpha-2 (`MX`); the rest is the little a rate or a tax needs. */
+interface Destination {
+  country: string;
+  region?: string;
+  postalCode?: string;
+}
+interface TaxInput {
+  currency: string;
+  /** The chargeable lines. */
+  lines: readonly ResolvedLine[];
+  /** What the discounts take off the subtotal, so a tax is worked on what is paid. */
+  discountMinor: number;
+  /**
+   * Optional (0.2.2): what the discounts took off each line, in the order of `lines` (see `lineDiscountsFrom`), adding up to `discountMinor`. A
+   * discount that applies to one line only lowers the tax of that line only, which matters when the lines are taxed at different rates. Without
+   * it a provider spreads `discountMinor` over the lines in proportion to their totals (`spreadDiscount`).
+   */
+  lineDiscountsMinor?: readonly number[];
+  shippingMinor: number;
+  destination?: Destination;
+}
+interface TaxBreakdown {
+  /** `IVA`, `IEPS`. */
+  code: string;
+  title: string;
+  /** Basis points: 16% is 1600. */
+  rateBp?: number;
+  amountMinor: number;
+  /** True when the amount is already inside the line prices (`taxIncluded`), so it is not added to the total. */
+  included: boolean;
+}
+interface TaxResult {
+  /** The currency of every amount here: it must be the order's. */
+  currency: string;
+  /** What the order adds on top of the lines. */
+  addedMinor: number;
+  /** The tax already inside the prices, for the invoice. It does not change the total. */
+  includedMinor: number;
+  /** When present, the amounts that are not `included` add up to `addedMinor` and those that are to `includedMinor`. */
+  breakdown?: readonly TaxBreakdown[];
+}
+/** Provided by a tax feature (`tax-mx`): at most one per project. Optional for checkout: without it the order adds no tax. */
+interface TaxPort {
+  compute(ctx: PortContext, input: TaxInput): Promise<TaxResult>;
+}
+interface ShippingRatesInput {
+  currency: string;
+  lines: readonly ResolvedLine[];
+  subtotalMinor: number;
+  destination: Destination;
+}
+interface ShippingRate {
+  /** Stable for a quote: the buyer sends the id back and the server quotes again before it charges, so the amount is never the browser's. */
+  id: string;
+  title: string;
+  amountMinor: number;
+  currency: string;
+  carrier?: string;
+  estimatedDays?: {
+    min: number;
+    max: number;
+  };
+}
+/** Provided by a shipping feature: at most one per project. Optional for checkout. */
+interface ShippingRatesPort {
+  quote(ctx: PortContext, input: ShippingRatesInput): Promise<readonly ShippingRate[]>;
+}
+interface DiscountInput {
+  currency: string;
+  lines: readonly ResolvedLine[];
+  subtotalMinor: number;
+  /** Codes the buyer typed. */
+  codes: readonly string[];
+  userId?: string | null;
+}
+interface AppliedDiscount {
+  code?: string;
+  title: string;
+  amountMinor: number;
+  /** Must be the order's currency. */
+  currency: string;
+  /**
+   * Optional (0.2.2): which lines it came off, so a tax and an invoice can state each line's discount. `index` is the line's position in
+   * `DiscountInput.lines`; the amounts add up to `amountMinor` and no line gives more than its total. A discount of the whole order leaves it out
+   * (`attributeDiscounts`, 0.2.4, spreads it over what the others left of the lines).
+   */
+  lines?: readonly LineDiscountPart[];
+}
+declare const DISCOUNT_REJECTIONS: readonly ["unknown", "expired", "not_applicable", "used_up", "minimum_not_met"];
+type DiscountRejection = (typeof DISCOUNT_REJECTIONS)[number];
+interface DiscountResult {
+  applied: readonly AppliedDiscount[];
+  rejected: readonly {
+    code: string;
+    reason: DiscountRejection;
+  }[];
+}
+/** Provided by a pricing feature: at most one per project. Optional for checkout. */
+interface DiscountPort {
+  apply(ctx: PortContext, input: DiscountInput): Promise<DiscountResult>;
+}
+/**
+ * The port names and what each provides. `line-source` is registered under many keys, every other port once. The names are the engine's
+ * `WORKER_PORTS` (`worker-ports` in `block.json`) and the pattern pack's `PORT_NAMES`; a test in the engine keeps the three equal.
+ *
+ * ```ts
+ * export const fxStock: PortProviders["stock"] = { availability, hold, commit, release };
+ * ```
+ *
+ * The engine checks each provider of the generated `registerPorts` call against its entry here (`satisfies PortProviders["stock"]`) when
+ * the project lists this package.
+ */
+interface PortProviders {
+  "line-source": LineSource;
+  stock: StockPort;
+  payments: PaymentsPort;
+  tax: TaxPort;
+  "shipping-rates": ShippingRatesPort;
+  discount: DiscountPort;
+}
+type PortName = keyof PortProviders;
+//#endregion
+export { StartPaymentInput as $, LineHoldRequest as A, PaymentsPort as B, HoldStatus as C, LineAvailability as D, LineAsk as E, MAX_HOLD_MS as F, STOCK_TRACKINGS as G, PortName as H, PAYMENT_METHODS as I, ShippingRatesInput as J, SettleResult as K, PaymentAdjustment as L, LineSettleResult as M, LineSnapshot as N, LineDiscountPart as O, LineSource as P, SnapshotValue as Q, PaymentLine as R, HoldResult as S, LINE_AVAILABILITIES as T, PortProviders as U, PortContext as V, ResolvedLine as W, ShortAsk as X, ShippingRatesPort as Y, ShortLine as Z, Fulfilment as _, CancelPaymentResult as a, TaxBreakdown as at, HoldLine as b, CommerceLocale as c, TaxResult as ct, DiscountInput as d, StartPaymentResult as et, DiscountPort as f, FindLineSource as g, FULFILMENTS as h, CancelPaymentFailure as i, StockTracking as it, LineHoldResult as j, LineHold as k, DISCOUNT_REJECTIONS as l, Money as lt, DiscountResult as m, AdjustmentKind as n, StockPort as nt, CartAsk as o, TaxInput as ot, DiscountRejection as p, ShippingRate as q, AppliedDiscount as r, StockSubject as rt, CartLine as s, TaxPort as st, ADJUSTMENT_KINDS as t, StockLevel as tt, Destination as u, HOLD_STATUSES as v, HoldingLineSource as w, HoldRequest as x, Hold as y, PaymentMethod as z };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { $ as StartPaymentInput, A as LineHoldRequest, B as PaymentsPort, C as HoldStatus, D as LineAvailability, E as LineAsk, F as MAX_HOLD_MS, G as STOCK_TRACKINGS, H as PortName, I as PAYMENT_METHODS, J as ShippingRatesInput, K as SettleResult, L as PaymentAdjustment, M as LineSettleResult, N as LineSnapshot, O as LineDiscountPart, P as LineSource, Q as SnapshotValue, R as PaymentLine, S as HoldResult, T as LINE_AVAILABILITIES, U as PortProviders, V as PortContext, W as ResolvedLine, X as ShortAsk, Y as ShippingRatesPort, Z as ShortLine, _ as Fulfilment, a as CancelPaymentResult, at as TaxBreakdown, b as HoldLine, c as CommerceLocale, ct as TaxResult, d as DiscountInput, et as StartPaymentResult, f as DiscountPort, g as FindLineSource, h as FULFILMENTS, i as CancelPaymentFailure, it as StockTracking, j as LineHoldResult, k as LineHold, l as DISCOUNT_REJECTIONS, lt as Money, m as DiscountResult, n as AdjustmentKind, nt as StockPort, o as CartAsk, ot as TaxInput, p as DiscountRejection, q as ShippingRate, r as AppliedDiscount, rt as StockSubject, s as CartLine, st as TaxPort, t as ADJUSTMENT_KINDS, tt as StockLevel, u as Destination, v as HOLD_STATUSES, w as HoldingLineSource, x as HoldRequest, y as Hold, z as PaymentMethod } from "./types-BUyLunnB.mjs";
+export { ADJUSTMENT_KINDS, AdjustmentKind, AppliedDiscount, CancelPaymentFailure, CancelPaymentResult, CartAsk, CartLine, CommerceLocale, DISCOUNT_REJECTIONS, Destination, DiscountInput, DiscountPort, DiscountRejection, DiscountResult, FULFILMENTS, FindLineSource, Fulfilment, HOLD_STATUSES, Hold, HoldLine, HoldRequest, HoldResult, HoldStatus, HoldingLineSource, LINE_AVAILABILITIES, LineAsk, LineAvailability, LineDiscountPart, LineHold, LineHoldRequest, LineHoldResult, LineSettleResult, LineSnapshot, LineSource, MAX_HOLD_MS, type Money, PAYMENT_METHODS, PaymentAdjustment, PaymentLine, PaymentMethod, PaymentsPort, PortContext, PortName, PortProviders, ResolvedLine, STOCK_TRACKINGS, SettleResult, ShippingRate, ShippingRatesInput, ShippingRatesPort, ShortAsk, ShortLine, SnapshotValue, StartPaymentInput, StartPaymentResult, StockLevel, StockPort, StockSubject, StockTracking, TaxBreakdown, TaxInput, TaxPort, TaxResult };

package/dist/types.mjs

@@ -0,0 +1,46 @@
+//#region src/types.ts
+const LINE_AVAILABILITIES = [
+	"available",
+	"sold_out",
+	"not_orderable",
+	"not_found"
+];
+const FULFILMENTS = [
+	"ship",
+	"pickup",
+	"digital",
+	"service",
+	"none"
+];
+const STOCK_TRACKINGS = [
+	"none",
+	"toggle",
+	"count"
+];
+/** The longest a hold may last: 14 days, more than the longest voucher a payment method gives. */
+const MAX_HOLD_MS = 12096e5;
+const HOLD_STATUSES = [
+	"held",
+	"committed",
+	"released",
+	"expired"
+];
+const PAYMENT_METHODS = [
+	"card",
+	"oxxo",
+	"spei"
+];
+const ADJUSTMENT_KINDS = [
+	"shipping",
+	"tax",
+	"discount"
+];
+const DISCOUNT_REJECTIONS = [
+	"unknown",
+	"expired",
+	"not_applicable",
+	"used_up",
+	"minimum_not_met"
+];
+//#endregion
+export { ADJUSTMENT_KINDS, DISCOUNT_REJECTIONS, FULFILMENTS, HOLD_STATUSES, LINE_AVAILABILITIES, MAX_HOLD_MS, PAYMENT_METHODS, STOCK_TRACKINGS };

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "@vibedout/commerce",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.4",
+  "private": false,
+  "type": "module",
+  "description": "The contracts a store is built from on Cloudflare Workers, as types and pure functions: line sources that price what a buyer asks for on the server (ResolvedLine in integer minor units with its availability, maximum quantity and a snapshot) and may hold places of their own, the stock port (hold with an expiry, commit, release, fulfil, uncommit), the payments port (start, cancel), and the tax, shipping-rates and discount ports; checks for buyer input and for what a source returns; a cart priced across sources; totals in minor units that refuse a mixed currency; a discount split over lines to the centavo; and test helpers (a line-source harness, an in-memory stock and slots, a fake payments port, and the suites a stock, a holding source and a payments provider pass). No floats, no runtime dependencies.",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./discounts": {
+      "types": "./dist/discounts.d.mts",
+      "default": "./dist/discounts.mjs"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.mts",
+      "default": "./dist/errors.mjs"
+    },
+    "./lines": {
+      "types": "./dist/lines.d.mts",
+      "default": "./dist/lines.mjs"
+    },
+    "./money": {
+      "types": "./dist/money.d.mts",
+      "default": "./dist/money.mjs"
+    },
+    "./payments": {
+      "types": "./dist/payments.d.mts",
+      "default": "./dist/payments.mjs"
+    },
+    "./ports": {
+      "types": "./dist/ports.d.mts",
+      "default": "./dist/ports.mjs"
+    },
+    "./snapshot": {
+      "types": "./dist/snapshot.d.mts",
+      "default": "./dist/snapshot.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
+    },
+    "./totals": {
+      "types": "./dist/totals.d.mts",
+      "default": "./dist/totals.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.mts",
+      "default": "./dist/types.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260702.1",
+    "@types/node": "24.13.3",
+    "tsdown": "^0.22.14",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.0",
+    "@vibedout/money": "0.1.0"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibedoutapps/vibedout-platform.git",
+    "directory": "packages/commerce"
+  },
+  "keywords": [
+    "commerce",
+    "checkout",
+    "cart",
+    "inventory",
+    "stock",
+    "minor-units",
+    "cloudflare",
+    "workers"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown",
+    "test": "vitest run"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts"
 }