@fun-xyz/fiat-contract 0.2.1

package/dist/types.d.ts

@@ -0,0 +1,486 @@
+/**
+ * fiat-contract — types
+ *
+ * The published contract between `fun-backend` (emits envelopes) and
+ * `funkit`/`connect-core` (renders them). Zero runtime logic lives here.
+ *
+ * Sources of truth (do not extend this file from anywhere else):
+ *  - Contract doc: Fiat Client Contract — Step-Driven Flow & Endpoint Schematics
+ *    https://app.notion.com/p/3b9fc3b2a002815eb270fa4c818268cc
+ *    §"The envelope" · §"Conformance package — concrete spec"
+ *    §"Proposal (2026-08-13): split InputSpec → params + inputs + expects" (ACCEPTED)
+ *  - FE doc: Fiat Frontend — State Machine & Screen Map
+ *    https://app.notion.com/p/3bbfc3b2a00281c994c2cebd17b1d6d3
+ *    §"✅ Decisions" · per-screen "State details" · §"Event bindings per flow state"
+ *
+ * Litmus rules encoded here:
+ *  - errors are fields, never states (`error?: FailureReason` on every fallible state)
+ *  - `params` = server literals · `inputs` = collected FieldSpecs · `expects` = injected surface results
+ *  - terminality comes from the table (`src/table.ts`), never from `transitions.length`
+ */
+/**
+ * JSON value. `params` carry these — opaque literals the client spreads verbatim.
+ * Named `JsonValue` rather than `Json` because this package's surface is re-exported wholesale;
+ * a bare `Json` is a generic name to put in a consumer's import scope for no benefit.
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * The harness parses the verb off the endpoint string — SUBMIT is not "POST".
+ *
+ * Defined locally on purpose: neither the TS lib nor `@types/node` publishes an HTTP-method union
+ * (`http.METHODS` is a runtime `string[]`), and the one in `fun-backend`'s `backend-utils`
+ * (`GET | PATCH | POST | PUT | DELETE`) is not exported from that package's root — and depending on
+ * the backend would invert this package's direction anyway. Deliberately two members, not five: the
+ * `/fiat/*` surface uses only these, and a wider union would let the backend emit a verb the
+ * harness has no path for.
+ */
+export type HttpVerb = 'GET' | 'POST';
+/**
+ * Endpoint strings as emitted: `"POST /fiat/session/verify"`, `"GET /fiat/orders/o_31c"`.
+ *
+ * A **bounded** union of the documented `/fiat/*` surface (contract §Endpoints), not the open
+ * `` `${HttpVerb} /fiat/${string}` `` it started as: bounded catches a typo'd endpoint family
+ * (`POST /fiat/orderz`) at compile time, and measured *cheaper* than the open pattern
+ * (77,680 vs 77,688 types across this package).
+ *
+ * On the fun-backend#3984 hazard (unbounded pattern prefixes OOM'd every build at 1.1M types):
+ * that blowup came from pattern types keying **mapped types**, where every `keyof` and indexed
+ * access re-expands across all members. This type is only ever a field value — never in `keyof`,
+ * never a `Record` key, never a mapped-type key — so assignability is a single match per member.
+ * Keep it that way: `Record<FiatEndpoint, …>` is the shape that would make this expensive.
+ *
+ * Per-order paths stay patterns because the id is runtime data (`o_31c`); TS template literals
+ * cannot express "no slash", so `GET /fiat/orders/${string}` also admits sub-paths. Precision at
+ * that level is the table's job (`allowedTransitions` + `endpointMatches`), not the type's.
+ */
+export type FiatEndpoint = 'GET /fiat/payment-methods' | 'POST /fiat/quote' | 'POST /fiat/auth' | 'POST /fiat/session' | 'POST /fiat/session/verify' | 'GET /fiat/kyc' | 'POST /fiat/kyc/form' | 'POST /fiat/kyc/document' | 'POST /fiat/instruments' | 'POST /fiat/orders' | `GET /fiat/orders/${string}` | `GET /fiat/orders/${string}/instructions` | `POST /fiat/orders/${string}/confirm-payment` | `POST /fiat/orders/${string}/reference` | `POST /fiat/orders/${string}/cancel` | `POST /fiat/orders/${string}/surface-result`;
+/**
+ * FiatProvider is metadata: it selects the embedded provider SDK for CLIENT_SURFACE steps and
+ * feeds analytics. It never drives sequencing (contract §The envelope).
+ * TODO(open-decision): the docs name only Transak as a v1 provider for the headless flow
+ * (contract §Decisions 3; Swapped-headless does not exist yet, Banxa is Tradeoff #4).
+ * `SWAPPED` added at fun-backend's request (2026-08-17) so its legacy fops payment-provider id
+ * has one shared vocabulary instead of a second fun-backend-local enum — it never appears as a
+ * `StepResponse.provider` value since Swapped's fops flow doesn't emit this envelope.
+ */
+export type FiatProvider = 'TRANSAK' | 'SWAPPED';
+/**
+ * The order status vocabulary. Monotonic ranks, no backwards moves. Terminal outcomes are
+ * OrderStatus, never FlowState kinds.
+ *
+ * **This package is the source of truth** (Charles, review 2026-08-14): `fun-backend` should
+ * reference these values for the `fiat_orders` table rather than declaring its own copy, so the
+ * enum cannot drift between the wire contract and the database.
+ *
+ * The enum mirrors the backend's real statuses as closely as possible; presentation mapping is the
+ * client's job (Jeremy, same thread) — the FE may collapse several of these into one visual state,
+ * but the contract does not pre-collapse them.
+ */
+export type OrderStatus = 'CREATING' | 'AWAITING_PAYMENT' | 'PAYMENT_VERIFYING' | 'PROCESSING' | 'PENDING_DELIVERY' | 'ON_HOLD' | 'CRYPTO_SENT' | 'SETTLED' | 'EXPIRED' | 'CANCELLED' | 'FAILED' | 'REFUNDED'
+/**
+ * A capture that never became an order — the pull-rail orphan (contract Flow A's
+ * capture-then-order topology: the component yields a `requestId`, then `createOrder` runs).
+ *
+ * Added from Charles's review (2026-08-14): it exists in the backend's status set and was missing
+ * here. Encoded as a first-class value rather than pre-mapped to `PROCESSING`, because the enum
+ * should mirror the source of truth and let the client collapse it for display.
+ *
+ * TODO(open-decision): its semantics, its position in the monotonic ranks, and its recovery are
+ * not published in either doc — `domains/fiat` has not landed in `fun-backend` yet. Treated as
+ * NON-terminal here (see `TERMINAL_ORDER_STATUSES`), which is the safe default: a client that
+ * wrongly thinks the flow is over stops polling, while one that keeps polling lets the reconciler
+ * resolve it. Confirm against the backend's rank map when it lands.
+ */
+ | 'CAPTURE_ORPHANED';
+export type FailureCategory = 'PAYMENT_DECLINED' | 'KYC_REJECTED' | 'PROVIDER_OUTAGE' | 'USER_ERROR' | 'CANCELLED' | 'EXPIRED';
+/**
+ * Recovery affordance the client renders. Contract spelling is `CONTACT_SUPPORT`
+ * (the FE doc's Screen 11 note writes `SUPPORT` as shorthand — same value).
+ */
+export type Recovery = 'REQUOTE' | 'RETRY_PAYMENT' | 'CONTACT_SUPPORT' | 'NONE';
+/** Three expiries, three recoveries (contract §The envelope, FailureReason comment). */
+export type ExpiredWhich = 'QUOTE' | 'PAYMENT_WINDOW' | 'INSTRUCTIONS';
+/**
+ * `code?` is a copy key (e.g. `BAD_CODE`), not an error code to branch on.
+ * TODO(open-decision): contract OQ7 — the failure/partial-payment enumeration is incomplete.
+ * This is the taxonomy as published; new categories land with OQ7.
+ */
+export type FailureReason = {
+    category: Exclude<FailureCategory, 'EXPIRED'>;
+    retryable: boolean;
+    recovery: Recovery;
+    code?: string;
+} | {
+    category: 'EXPIRED';
+    which: ExpiredWhich;
+    retryable: boolean;
+    recovery: Recovery;
+    code?: string;
+};
+/**
+ * Amounts are decimal strings in the docs' envelopes ("100.00") — never numbers.
+ * Named to pair with `CryptoAmount`: every use site is a `fiat:` field.
+ */
+export interface FiatAmount {
+    currency: string;
+    amount: string;
+}
+export interface CryptoAmount {
+    currency: string;
+    network: string;
+    amount: string;
+}
+/** `id` is the client's localization lookup key; `labelFallback` renders for unknown ids. */
+export interface FeeLine {
+    id: string;
+    labelFallback: string;
+    amount: string;
+}
+/**
+ * `expiresAt` is BE-stamped, not a provider passthrough (contract §Quote semantics).
+ * All v1 quotes are estimates as a global fact, not a field.
+ * `paymentMethod` is an agnostic category (`card`, `apple_pay`, `bank_transfer`, …) — the docs
+ * leave the set open, so it stays `string` rather than a fabricated enum.
+ */
+export interface Quote {
+    quoteRef: string;
+    fiat: FiatAmount;
+    crypto: CryptoAmount;
+    rate: string;
+    totalFee: string;
+    feeBreakdown: FeeLine[];
+    paymentMethod: string;
+    expiresAt: string;
+}
+/** Deferred to the credit-card iteration (FE doc port ledger) — optional wherever it appears. */
+export interface Instrument {
+    brandLabel: string;
+    last4: string;
+}
+/** Payload of `PENDING_ORDER` (contract: `OrderRef`). */
+export interface OrderRef {
+    orderId: string;
+    fiat: FiatAmount;
+    crypto: CryptoAmount;
+    method: string;
+    createdAt: string;
+    status: OrderStatus;
+}
+/**
+ * Payload of `ORDER{CREATED}` (FE doc Screens 7 · 13 · 14 · 15).
+ * `crypto` is optional because the Screen 14/15 envelopes omit it (fiat-only failure/refund views).
+ */
+export interface OrderSummary {
+    orderId: string;
+    fiat: FiatAmount;
+    crypto?: CryptoAmount;
+    method: string;
+    createdAt: string;
+    instrument?: Instrument;
+}
+/**
+ * TODO(open-decision): the element shape of `statusHistory` is not defined in either doc
+ * (FE doc Screen 7 lists the key; the FE sketch renders `<StatusTimeline history={…}/>`).
+ * Encoding the documented minimum — the status only — rather than inventing timestamps.
+ */
+export interface StatusHistoryEntry {
+    status: OrderStatus;
+}
+export interface Tx {
+    chainId: number;
+    hash: string;
+}
+export interface Refund {
+    currency: string;
+    amount: string;
+    expectedBy: string;
+}
+/**
+ * Carried as *data* in CAPTURE phases only (`PAYMENT{CAPTURE}` · `KYC{CAPTURE}`).
+ * Δ2: the CLIENT_SURFACE transition carries just `report` — single-carry, no duplication.
+ * `session` values are secrets: never log them (FE doc §Decisions, redaction).
+ */
+export type Surface = {
+    kind: 'URL_REDIRECT';
+    url: string;
+} | {
+    kind: 'URL_EMBED';
+    url: string;
+} | {
+    kind: 'PCI_COMPONENT';
+    session: string;
+} | {
+    kind: 'PAY_SHEET';
+    session: string;
+} | {
+    kind: 'ACH_COMPONENT';
+    session: string;
+};
+export interface InstructionField {
+    id: string;
+    labelFallback: string;
+    value: string;
+}
+/**
+ * Payload of `PAYMENT{INSTRUCT}` — push rails. Values are PII-adjacent: never logged.
+ * TODO(open-decision): contract OQ1 lists `QR_IMAGE` as *deliberately not pre-declared* in the
+ * v1 vocabulary while §The envelope's Instructions bullet enumerates it. Kept in the union per
+ * the envelope section (and the conformance-package spec); handshake-gate it if OQ1 lands the
+ * other way.
+ * TODO(open-decision): contract OQ7 — expired instructions have no documented recovery and no
+ * re-issue endpoint exists.
+ */
+export type Instructions = {
+    kind: 'DEEPLINK';
+    url: string;
+    /** TODO(open-decision): element shape undocumented (contract: "UPI deeplink ×4 app variants"). */
+    appVariants: string[];
+} | {
+    kind: 'QR_IMAGE';
+    url: string;
+} | {
+    kind: 'BANK_FIELDS';
+    fields: InstructionField[];
+    expiresAt?: string;
+} | {
+    kind: 'REFERENCE';
+    code: string;
+    expiresAt: string;
+};
+export interface SelectOption {
+    id: string;
+    labelFallback: string;
+}
+/** Field types inside a KYC form round. A new field TYPE is a client release (handshake-gated). */
+export type FormFieldType = 'TEXT' | 'DATE' | 'SELECT' | 'COUNTRY' | 'FILE' | 'HOSTED_LINK';
+export interface FormField {
+    id: string;
+    type: FormFieldType;
+    labelFallback: string;
+    required: boolean;
+    regex?: string;
+    /** SELECT only. */
+    options?: SelectOption[];
+    /** HOSTED_LINK only. */
+    url?: string;
+}
+/** Payload of `KYC{INPUT_REQUIRED}`. One uniform renderer walks `fields`. */
+export interface FormDescriptor {
+    formId: string;
+    fields: FormField[];
+}
+/**
+ * A `FieldSpec` describes something the **client collects**. It never carries a value.
+ * `FORM_VALUES` = "collect the values of the form already carried in `state.form`" — the
+ * transition never re-carries the descriptor (the double-carry disease Δ2 killed).
+ *
+ * Note: the contract's illustrative list reads `'TEXT' | 'NUMBER' | …`; the conformance-package
+ * spec closes the set at the seven below, so `NUMBER` is not declared here.
+ */
+export type FieldSpec = {
+    type: 'TEXT';
+    length?: number;
+    regex?: string;
+    labelFallback?: string;
+} | {
+    type: 'DATE';
+    labelFallback?: string;
+} | {
+    type: 'COUNTRY';
+    labelFallback?: string;
+} | {
+    type: 'FILE';
+    labelFallback?: string;
+} | {
+    type: 'SELECT';
+    options?: SelectOption[];
+    labelFallback?: string;
+} | {
+    type: 'HOSTED_LINK';
+    url: string;
+    labelFallback?: string;
+} | {
+    type: 'FORM_VALUES';
+};
+export type FieldSpecType = FieldSpec['type'];
+/** Server literals — spread into the body verbatim, opaque to the client. */
+export type TransitionParams = Record<string, JsonValue>;
+/** Client-collected specs — the harness renders + locally validates, then merges values in. */
+export type TransitionInputs = Record<string, FieldSpec>;
+export interface PollSpec {
+    endpoint: FiatEndpoint;
+    params?: TransitionParams;
+    intervalMs: number;
+    backoffFactor?: number;
+    maxIntervalMs?: number;
+    giveUpAfterMs?: number;
+}
+export interface ReportSpec {
+    endpoint: FiatEndpoint;
+    params?: TransitionParams;
+    /**
+     * Names the harness copies out of the surface result into the body (e.g. `["requestId"]`).
+     * Declared so conformance can assert the surface actually yields them.
+     */
+    expects?: string[];
+}
+export type TransitionMode = 'SUBMIT' | 'AWAIT' | 'CLIENT_SURFACE';
+/**
+ * Body assembly, harness-owned, one rule:
+ *   `body = {…params, …collected(inputs), …injected(expects)}`
+ * A key collision across the three sources is a contract violation (see `assertLegalEmission`),
+ * never last-write-wins.
+ *
+ * `id` keys localization; `labelFallback` renders for ids the client doesn't recognize and rides
+ * SUBMIT entries only — the user-visible ones.
+ */
+export type Transition = {
+    id: string;
+    mode: 'SUBMIT';
+    endpoint: FiatEndpoint;
+    params?: TransitionParams;
+    inputs?: TransitionInputs;
+    labelFallback?: string;
+} | {
+    id: string;
+    mode: 'AWAIT';
+    poll: PollSpec;
+} | {
+    id: string;
+    mode: 'CLIENT_SURFACE';
+    report: ReportSpec;
+};
+/**
+ * TODO(open-decision): shape owned by the auth spike (contract §Auth & ref binding, item 5).
+ * `FUN_AUTH` never renders in fomo (identity is ambient), so nothing in either doc constrains
+ * this beyond the key name. Charles's review (2026-08-14) questions whether the kind is needed at
+ * all, pending the Transak Auth Reliance answer — if reliance lands, provider-side session auth is
+ * unreachable for fomo users and this kind may go with it. Kept for now: removing a kind is
+ * cheap, adding one back costs a client release (handshake-gated).
+ */
+export type AuthChallenge = Record<string, JsonValue>;
+/**
+ * The semantic state. Three rules keep this union honest:
+ *   1. sub-states are payload discriminants, never new kinds
+ *   2. terminal outcomes are OrderStatus, never kinds
+ *   3. every fallible state carries `error?: FailureReason`
+ */
+export type FlowState = {
+    kind: 'QUOTE';
+    quote: Quote;
+    error?: FailureReason;
+} | {
+    kind: 'FUN_AUTH';
+    challenge: AuthChallenge;
+    error?: FailureReason;
+} | {
+    kind: 'SESSION_AUTH';
+    channel: 'EMAIL_OTP';
+    error?: FailureReason;
+}
+/** Dropped from v1 (no UK module coverage) — kind retained, handshake-gated. */
+ | {
+    kind: 'KYC';
+    phase: 'CAPTURE';
+    surface: Surface;
+    error?: FailureReason;
+} | {
+    kind: 'KYC';
+    phase: 'INPUT_REQUIRED';
+    form: FormDescriptor;
+    error?: FailureReason;
+} | {
+    kind: 'KYC';
+    phase: 'NO_ACTION_REQUIRED';
+    /**
+     * Note the deliberate name collision (Charles's nit, review 2026-08-14): `ON_HOLD` appears
+     * here as a KYC reason *and* in `OrderStatus`. They are different things and both names come
+     * from their own doc, so neither is renamed:
+     *   - `KYC{NO_ACTION_REQUIRED, ON_HOLD}` = FCA cooling-off, pre-order, `retryAfter` set,
+     *     empty transitions, NOT terminal.
+     *   - `OrderStatus.ON_HOLD` = post-order compliance or amount mismatch, resolves to
+     *     `PROCESSING` or `REFUNDED`.
+     * They cannot be confused in code — different types, different positions in the envelope —
+     * but they can be confused in conversation, so say which one you mean.
+     */
+    reason: 'IN_REVIEW' | 'ON_HOLD' | 'REJECTED';
+    retryAfter?: string;
+    /**
+     * Terminal REJECTED variant carries this (FE doc Screen 11: `KYC_REJECTED`,
+     * `retryable: false`, `recovery: CONTACT_SUPPORT`) and renders in place — it never routes
+     * through `ORDER{CREATED, FAILED}`.
+     * TODO(open-decision): contract OQ7 — which rejections escalate vs terminate.
+     */
+    failureReason?: FailureReason;
+    error?: FailureReason;
+}
+/**
+ * TODO(open-decision): removal proposed (contract §"Proposal: remove PENDING_ORDER").
+ * Shipped in 0.1.0 so the current shape is representable; FE Screen 12 is frozen until the
+ * decision lands. The removal targets the wizard-interstitial *kind*, not the pending-order
+ * concept (which may re-land as an out-of-wizard PENDING_ORDERS view).
+ */
+ | {
+    kind: 'PENDING_ORDER';
+    order: OrderRef;
+    error?: FailureReason;
+} | {
+    kind: 'BLOCKED';
+    /**
+     * Observed value: `REGION_UNSUPPORTED` (FE doc Screen 16). The contract types this as
+     * `string`; no enum is published, so none is invented here.
+     */
+    reason: string;
+    /** `null` renders "no comeback date" (FE doc Screen 16 emits it explicitly). */
+    retryAfter?: string | null;
+    error?: FailureReason;
+} | {
+    kind: 'PAYMENT';
+    phase: 'CAPTURE';
+    surface: Surface;
+    error?: FailureReason;
+} | {
+    kind: 'PAYMENT';
+    phase: 'INSTRUCT';
+    /**
+     * TODO(open-decision): `orderId` placement — envelope sibling (contract §Worked example,
+     * steps 4–5) vs inside state (FE doc v0, Screen 6). Both are accepted here; the FE doc's
+     * in-state placement is the current shape, `StepResponse.orderId` covers the other.
+     */
+    orderId?: string;
+    instructions: Instructions;
+    error?: FailureReason;
+} | {
+    kind: 'ORDER';
+    phase: 'AWAITING_CONFIRMATION';
+    quote: Quote;
+    error?: FailureReason;
+} | {
+    kind: 'ORDER';
+    phase: 'CREATED';
+    /** Absent in the contract's terse worked-example envelopes, present in every FE screen. */
+    order?: OrderSummary;
+    status: OrderStatus;
+    statusHistory?: StatusHistoryEntry[];
+    tx?: Tx;
+    refund?: Refund;
+    failureReason?: FailureReason;
+    error?: FailureReason;
+};
+export type FlowStateKind = FlowState['kind'];
+/**
+ * Every `/fiat/*` response. `transitions: []` = nothing the wizard can do; whether the *flow*
+ * is over is read from the table (`terminal`), never from array emptiness (ON_HOLD is the proof).
+ */
+export interface StepResponse {
+    state: FlowState;
+    provider: FiatProvider;
+    transitions: Transition[];
+    /** TODO(open-decision): `orderId` placement — see `PAYMENT{INSTRUCT}.orderId` above. */
+    orderId?: string;
+}
+/** The envelope as it appears in the docs' JSON — alias kept because both names are in use. */
+export type Envelope = StepResponse;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/types.mjs

@@ -0,0 +1,2 @@
+import "./chunk-KIQOUUEZ.mjs";
+//# sourceMappingURL=types.mjs.map

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@fun-xyz/fiat-contract",
+  "version": "0.2.1",
+  "description": "Published conformance contract for Fun's headless fiat onramp: FlowState/Transition types, zod schemas, the transition table as data, recorded fixtures, assertion helpers.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fun-xyz/fiat-contract.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.js"
+    },
+    "./table": {
+      "types": "./dist/table.d.ts",
+      "import": "./dist/table.mjs",
+      "require": "./dist/table.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "table.js",
+    "table.d.ts",
+    "types.js",
+    "types.d.ts",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "generate:fixtures": "node scripts/generate-fixture-data.mjs",
+    "typegen": "tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "build": "rm -rf dist && npm run typegen && node build.mjs",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "check": "npm run typecheck && npm run test"
+  },
+  "peerDependencies": {
+    "zod": "^3.22.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.4.3"
+  },
+  "module": "./dist/index.mjs",
+  "sideEffects": false,
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types.d.ts"
+      ],
+      "table": [
+        "./dist/table.d.ts"
+      ]
+    }
+  }
+}

package/table.d.ts

@@ -0,0 +1 @@
+export * from './dist/table';

package/table.js

@@ -0,0 +1,5 @@
+// Compat stub: resolvers that do not read `package.json#exports` (Metro before RN 0.79, where
+// `unstable_enablePackageExports` defaults to false) resolve `@fun-xyz/fiat-contract/table` to this
+// file by path instead. Verified: without it, Metro fails with "Unable to resolve module".
+// Anything that does read `exports` never sees this file — it goes straight to dist/.
+module.exports = require('./dist/table.js');

package/types.d.ts

@@ -0,0 +1 @@
+export * from './dist/types';

package/types.js

@@ -0,0 +1,3 @@
+// Compat stub — see table.js. The types entry has no runtime exports; this exists so a
+// path-based resolver does not fail on `@fun-xyz/fiat-contract/types`.
+module.exports = require('./dist/types.js');