@openreceive/http 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,411 @@
+import { OpenReceive, PaymentCheck } from '@openreceive/node';
+export { Checkout, CreateCheckoutAmount, OpenReceive, PaymentCheck, SwapCheckout } from '@openreceive/node';
+import { H as Host, R as ReconcilableAttempt, S as SqlAdapter } from './adapter-surface-BtXnvW2q.js';
+export { A as AttemptStatus, a as Authorize, b as AuthorizeAction, c as AuthorizeContext, d as AuthorizeResource, C as CheckoutCreatedHook, e as CheckoutCreatedInput, f as CreateHostDbOptions, g as CreateHostOptions, h as CreateHostRepositoryOptions, i as CreateHttpHandlerOptions, j as CreateStackOptions, k as HostError, l as HttpError, m as HttpHandler, I as IpRateLimitConfig, N as NotificationListener, n as NotificationWorker, O as OPENRECEIVE_ATTEMPT_EXPIRY_GRACE_SECONDS, o as OPENRECEIVE_RECONCILE_BATCH_SIZE, P as PaymentInsert, p as PaymentRecord, q as PaymentRepository, r as PaymentSettlement, s as PaymentSettlementHook, t as RateLimit, u as ReconciliationTransition, v as ResolveCheckoutContext, w as ResolveCheckoutHook, x as ResolvedHostCheckout, y as ServiceErrorShape, z as SettlementEvent, B as SettlementEventHook, D as SettlementRecord, E as SqlClient, F as SqlDatabase, G as SqlPaymentRepository, J as SqlPaymentsOptions, K as SqlQuery, L as Stack, M as StackStorage, Q as StackWallet, T as createHost, U as createHttpHandler, V as createIpRateLimit, W as createProxyRateLimitingConfig, X as createRequestId, Y as createSqlPayments, Z as createStack, _ as errorResponse, $ as hostError, a0 as isServiceErrorShape, a1 as isStackOptions, a2 as jsonResponse, a3 as mapHostRouteError, a4 as paymentsSchemaSql, a5 as resolveClientIp, a6 as startNotificationListener, a7 as startNotificationWorker } from './adapter-surface-BtXnvW2q.js';
+export { OPENRECEIVE_PAYMENTS_SCHEMA_VERSION } from '@openreceive/core';
+
+/** The pieces of a framework request the bridge needs, framework-agnostic. */
+interface NodeRequestParts {
+    readonly method: string;
+    readonly headers: Readonly<Record<string, string | string[] | undefined>>;
+    /** Request path (may include the query string). */
+    readonly url: string;
+    /** Scheme reported by the framework (respecting its trust-proxy setting). */
+    readonly protocol?: string;
+    /** Body already parsed by the framework's body parser, when present. */
+    readonly parsedBody?: unknown;
+}
+/** Convert a parsed framework request into the Web Request the handler speaks. */
+declare function webRequest(parts: NodeRequestParts): Request;
+/**
+ * True when the adapter should hand this request to the OpenReceive handler
+ * instead of the surrounding app. A root mount (`prefix: "/"`) claims only the
+ * library's own paths.
+ */
+declare function isUnderPrefix(pathname: string, prefix: string): boolean;
+
+/** Wire shape of the OpenAPI `PrepareCheckoutRequest` schema (snake_case JSON body). */
+type WirePrepareCheckoutRequest = {
+    readonly reference: string;
+};
+/** Wire shape of the OpenAPI `PrepareCheckoutResponse` schema (snake_case JSON body). */
+type WirePrepareCheckoutResponse = {
+    readonly reference: string;
+    readonly amount_msats: number;
+    readonly fiat_quote?: null | WireFiatQuote;
+    readonly payment_methods: readonly WirePaymentMethod[];
+};
+/** Wire shape of the OpenAPI `CreateCheckoutRequest` schema (snake_case JSON body). */
+type WireCreateCheckoutRequest = {
+    readonly reference: string;
+    readonly memo?: string;
+    readonly metadata?: Record<string, unknown>;
+};
+/** Wire shape of the OpenAPI `Checkout` schema (snake_case JSON body). */
+type WireCheckout = {
+    readonly reference: string;
+    readonly payment_hash: string;
+    readonly bolt11: string;
+    readonly amount_msats: number;
+    readonly created_at: number;
+    readonly expires_at: number;
+    readonly fiat_quote?: null | WireFiatQuote;
+};
+/** Wire shape of the OpenAPI `CreateCheckoutResponse` schema (snake_case JSON body). */
+type WireCreateCheckoutResponse = {
+    readonly checkout: WireCheckout;
+};
+/** Wire shape of the OpenAPI `PaymentCheckRequest` schema (snake_case JSON body). */
+type WirePaymentCheckRequest = {
+    readonly reference: string;
+    readonly payment_hash: string;
+};
+/** Wire shape of the OpenAPI `PaymentStatus` schema (snake_case JSON body). */
+type WirePaymentStatus = "pending" | "settled" | "expired" | "failed" | "not_found";
+/** Wire shape of the OpenAPI `PaymentMethod` schema (snake_case JSON body). */
+type WirePaymentMethod = {
+    readonly pay_in_asset: string;
+    readonly label: string;
+    readonly network_label: string;
+    readonly provider: string;
+    readonly available: boolean;
+    readonly unavailable_reason?: string;
+    readonly unavailable_message?: string;
+    readonly pay_amount?: string;
+    readonly minimum_pay_amount?: string;
+    readonly maximum_pay_amount?: string;
+    readonly minimum_invoice_amount_msats?: number;
+    readonly maximum_invoice_amount_msats?: number;
+};
+/** Wire shape of the OpenAPI `FiatQuote` schema (snake_case JSON body). */
+type WireFiatQuote = {
+    readonly fiat: {
+        readonly currency: string;
+        readonly value: string;
+    };
+    readonly btc_fiat_price: string;
+    readonly amount_sats: number;
+    readonly amount_msats: number;
+    readonly source: "static_mock" | "primary" | "fallback";
+    readonly as_of: number;
+    readonly expires_at: number;
+};
+/** Wire shape of the OpenAPI `PaymentDetails` schema (snake_case JSON body). */
+type WirePaymentDetails = {
+    readonly transaction?: {
+        readonly payment_hash?: string;
+        readonly state?: string;
+        readonly transaction_state?: string;
+        readonly amount_msats?: number;
+        readonly fees_paid_msats?: number;
+        readonly created_at?: number;
+        readonly settled_at?: number;
+        readonly expires_at?: number;
+    };
+    readonly observed_at: number;
+    readonly paid_at_source?: "settled_at" | "observed_at";
+};
+/** Wire shape of the OpenAPI `PaymentCheck` schema (snake_case JSON body). */
+type WirePaymentCheck = {
+    readonly payment_hash: string;
+    readonly status: WirePaymentStatus;
+    readonly paid_at?: number;
+    readonly details?: WirePaymentDetails;
+    readonly payment_methods: readonly WirePaymentMethod[];
+};
+/** Wire shape of the OpenAPI `SwapQuoteRequest` schema (snake_case JSON body). */
+type WireSwapQuoteRequest = {
+    readonly reference: string;
+    readonly pay_in_asset: string;
+};
+/** Wire shape of the OpenAPI `CreateSwapRequest` schema (snake_case JSON body). */
+type WireCreateSwapRequest = {
+    readonly reference: string;
+    readonly pay_in_asset: string;
+    readonly memo?: string;
+    readonly metadata?: Record<string, unknown>;
+};
+/** Wire shape of the OpenAPI `SwapPayInAsset` schema (snake_case JSON body). */
+type WireSwapPayInAsset = "SOL_SOL" | "USDT_TRON" | "USDT_SOL" | "USDC_SOL" | "ETH_ETH" | "USDT_ETH" | "USDC_ETH";
+/** Wire shape of the OpenAPI `SwapProviderState` schema (snake_case JSON body). */
+type WireSwapProviderState = "creating_provider_order" | "awaiting_deposit" | "confirming" | "exchanging" | "paying_invoice" | "completed" | "expired" | "refund_required" | "refund_pending" | "refunded" | "attention" | "failed";
+/** Wire shape of the OpenAPI `SwapFee` schema (snake_case JSON body). */
+type WireSwapFee = {
+    readonly currency: string;
+    readonly pay_in_fiat: string;
+    readonly payout_fiat: string;
+};
+/** Wire shape of the OpenAPI `SwapQuote` schema (snake_case JSON body). */
+type WireSwapQuote = {
+    readonly provider: string;
+    readonly pay_asset: WireSwapPayInAsset;
+    readonly available: boolean;
+    readonly pay_amount?: string;
+    readonly minimum_pay_amount?: string;
+    readonly maximum_pay_amount?: string;
+    readonly minimum_invoice_amount_msats?: number;
+    readonly maximum_invoice_amount_msats?: number;
+    readonly unavailable_reason?: string;
+    readonly unavailable_message?: string;
+};
+/** Wire shape of the OpenAPI `Swap` schema (snake_case JSON body). */
+type WireSwap = {
+    readonly payment_hash: string;
+    readonly reference: string;
+    readonly provider: string;
+    readonly pay_in_asset: WireSwapPayInAsset;
+    readonly deposit_address: string;
+    readonly deposit_memo?: string;
+    readonly deposit_amount: string;
+    readonly provider_state: WireSwapProviderState;
+    readonly provider_expires_at: number;
+    readonly deposit_tx_id?: string;
+    readonly payout_tx_id?: string;
+    readonly refund_tx_id?: string;
+    readonly refund_reason?: string;
+    readonly refund_amount?: string;
+    readonly attention?: boolean;
+    readonly attention_reason?: string;
+    readonly deposit_received_amount?: string;
+    readonly emergency_repeat?: boolean;
+    readonly provider_order_id?: string;
+    readonly fee?: WireSwapFee;
+};
+/** Wire shape of the OpenAPI `SwapCheckout` schema (snake_case JSON body). */
+type WireSwapCheckout = {
+    readonly payment_hash: string;
+    readonly reference: string;
+    readonly provider: string;
+    readonly pay_in_asset: WireSwapPayInAsset;
+    readonly deposit_address: string;
+    readonly deposit_memo?: string;
+    readonly deposit_amount: string;
+    readonly provider_state: WireSwapProviderState;
+    readonly provider_expires_at: number;
+    readonly deposit_tx_id?: string;
+    readonly payout_tx_id?: string;
+    readonly refund_tx_id?: string;
+    readonly refund_reason?: string;
+    readonly refund_amount?: string;
+    readonly attention?: boolean;
+    readonly attention_reason?: string;
+    readonly deposit_received_amount?: string;
+    readonly emergency_repeat?: boolean;
+    readonly provider_order_id?: string;
+    readonly fee?: WireSwapFee;
+} & {
+    readonly checkout: WireCheckout;
+};
+/** Wire shape of the OpenAPI `CreateSwapResponse` schema (snake_case JSON body). */
+type WireCreateSwapResponse = {
+    readonly swap: WireSwapCheckout;
+};
+/** Wire shape of the OpenAPI `RatesResponse` schema (snake_case JSON body). */
+type WireRatesResponse = {
+    readonly bitcoin: Record<string, string>;
+};
+/** Wire shape of the OpenAPI `Error` schema (snake_case JSON body). */
+type WireError = {
+    readonly code: "NOT_IMPLEMENTED" | "RESTRICTED" | "UNAUTHORIZED" | "FORBIDDEN" | "RATE_LIMITED" | "QUOTA_EXCEEDED" | "INTERNAL" | "UNSUPPORTED_ENCRYPTION" | "OTHER" | "NOT_FOUND" | "TIMEOUT" | "INVALID_REQUEST" | "WALLET_UNAVAILABLE" | "INVOICE_EXPIRED" | "UNSUPPORTED_METHOD" | "CONFLICT";
+    readonly message: string;
+    readonly request_id?: string;
+    readonly retryable?: boolean;
+    readonly details?: Record<string, unknown>;
+};
+/** Wire shape of the `POST /swaps/refunds` request body (snake_case JSON body). */
+type WireRefundSwapRequest = {
+    readonly reference: string;
+    readonly payment_hash: string;
+    readonly refund_address: string;
+};
+
+interface Reconciler {
+    stop(): void;
+    readonly done: Promise<void>;
+}
+/**
+ * One bounded reconciliation pass: scan the wallet for every pending attempt,
+ * deliver settlements at least once, and persist terminal transitions so closed
+ * attempts leave the scan set. Attempt closure requires a successful wallet
+ * scan at or after expiry plus grace — a local clock alone never closes a row,
+ * because a payment could have settled while the application was offline.
+ *
+ * A walk cut short by its page cap decides nothing: the core scan omits the
+ * hashes it could not reach, so those attempts get no transition this pass and
+ * stay pending instead of being closed on an unproven `not_found`.
+ *
+ * Returns the per-hash `PaymentCheck` results of the pass so callers (notably
+ * `payments/check`) can serve a requested hash straight from the pass instead
+ * of adding a second per-invoice wallet walk. Results are keyed by hash and
+ * may cover fewer hashes than were scanned.
+ */
+declare function reconcileHostPayments(input: {
+    readonly service: OpenReceive;
+    readonly host: Host;
+    readonly overlapSeconds?: number;
+    readonly maxPages?: number;
+    readonly clock?: () => number;
+    /**
+     * The pending attempts to scan, when the caller already listed them. The
+     * opportunistic gate does — it sizes the gate interval from the same batch —
+     * so passing it here saves a second identical read on every winning pass,
+     * which is the request path.
+     */
+    readonly attempts?: readonly ReconcilableAttempt[];
+}): Promise<readonly PaymentCheck[]>;
+/**
+ * Poll and reconcile only the pending attempts in the ledger. Every pass goes
+ * through the durable `claimReconcileGate`, so N worker instances — and the
+ * request-path opportunistic reconcile — collapse to one real wallet scan per
+ * gate interval instead of each running its own.
+ */
+declare function startReconciler(input: {
+    readonly service: OpenReceive;
+    readonly host: Host;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+    readonly overlapSeconds?: number;
+    readonly clock?: () => number;
+    /**
+     * Observes per-pass failures (wallet, repository, or callback errors). The
+     * reconciler always retries from the ledger on the next pass; without this
+     * hook failures are reported once per distinct message via console.warn so a
+     * permanently failing reconciler is never silent.
+     */
+    readonly onError?: (error: unknown) => void;
+}): Promise<Reconciler>;
+
+/**
+ * Floor for the durable reconcile-gate interval: at most one real wallet scan
+ * per two seconds across EVERY worker sharing the host database. This gate is
+ * the NWC rate limit for settlement scans — open tabs polling `payments/check`
+ * (~3s) all share the one global pass instead of fanning out wallet walks.
+ */
+declare const OPENRECEIVE_MIN_RECONCILE_INTERVAL_SECONDS: 2;
+/**
+ * Wall-clock bound on an awaited request-path pass: a slow wallet must not
+ * hang user-facing requests. A timed-out pass counts as a failed scan; the
+ * gate stays claimed so the next interval retries without a stampede.
+ */
+declare const OPENRECEIVE_RECONCILE_SCAN_TIMEOUT_MS: 9000;
+/** Page cap per wallet-history walk on the awaited request path. */
+declare const OPENRECEIVE_RECONCILE_SCAN_MAX_PAGES: 50;
+type OpportunisticReconcileResult = {
+    readonly reason: "ran";
+    readonly checks: readonly PaymentCheck[];
+} | {
+    readonly reason: "no_pending" | "gate_busy" | "scan_failed";
+};
+interface MaybeReconcilePaymentsOptions {
+    readonly service: OpenReceive;
+    readonly host: Host;
+    /** Gate interval floor. Default (and minimum) 2 seconds. */
+    readonly minIntervalSeconds?: number;
+    readonly overlapSeconds?: number;
+    readonly scanTimeoutMs?: number;
+    readonly maxPages?: number;
+    readonly clock?: () => number;
+    /** Observes failed scans. Default: console.warn — a failure never propagates. */
+    readonly onError?: (error: unknown) => void;
+}
+/**
+ * The gate interval for the current pending set: the configured floor,
+ * stretched by invoice age (2s while any pending invoice is under 2 minutes
+ * old, 6s under 5 minutes, else 12s).
+ */
+declare function reconcileIntervalSeconds(attempts: readonly ReconcilableAttempt[], now: number, minIntervalSeconds?: number): number;
+/**
+ * Opportunistic settlement discovery, piggybacked on any later OpenReceive
+ * call: skip without a wallet call when nothing is pending, try the durable
+ * `openreceive_meta` gate (`gate_busy` means another worker just scanned —
+ * skip the wallet), otherwise AWAIT one bounded `reconcileHostPayments`
+ * pass (serverless-safe) and return its per-hash results.
+ *
+ * Never throws: a failed or timed-out scan is reported (default console.warn)
+ * and returns `scan_failed` — the caller's own request must not fail because a
+ * settlement sweep did. The gate's `claimed_at` is left in place on failure so
+ * a broken wallet cannot stampede; the next interval retries.
+ *
+ * The HTTP handler calls this on every mounted payment route by default
+ * (`opportunisticReconcile`; unauthenticated `GET /rates` is excluded so
+ * crawlers and health checks cannot consume the scan budget); it is exported
+ * so hosts can also drive it from their own routes or middleware (host-only
+ * routes never auto-run it).
+ */
+declare function maybeReconcilePayments(input: MaybeReconcilePaymentsOptions): Promise<OpportunisticReconcileResult>;
+
+type SqlDialect = SqlAdapter["dialect"];
+/** The raw-query slice of a Knex instance or transaction. */
+interface KnexExecutorLike {
+    raw(sql: string, bindings: readonly unknown[]): Promise<unknown>;
+}
+/** Structural view of a Knex instance. */
+interface KnexLike extends KnexExecutorLike {
+    transaction<T>(run: (trx: KnexExecutorLike) => Promise<T>): Promise<T>;
+}
+/**
+ * Wrap a Knex instance. Knex hands the SQL and bindings to the driver
+ * verbatim (`?` is already the sqlite placeholder, and `$n` postgres SQL
+ * contains no `?` for Knex to rewrite); only the RESULT shape differs per
+ * driver. The sqlite3 driver resolves the rows array itself; pg wraps them in
+ * `{ rows }` — reaching into `result[0]` would return the first ROW on
+ * sqlite, which breaks every repository read.
+ */
+declare function knexDb(knex: KnexLike, dialect: SqlDialect): SqlAdapter;
+/** The raw-query slice of a PrismaClient or interactive-transaction client. */
+interface PrismaExecutorLike {
+    $queryRawUnsafe(sql: string, ...params: unknown[]): Promise<unknown>;
+    $executeRawUnsafe(sql: string, ...params: unknown[]): Promise<unknown>;
+}
+/** Structural view of a PrismaClient. */
+interface PrismaLike extends PrismaExecutorLike {
+    $transaction<T>(run: (tx: PrismaExecutorLike) => Promise<T>): Promise<T>;
+}
+/**
+ * Wrap a PrismaClient. Match `dialect` to the Prisma datasource provider.
+ * Prisma splits raw SQL across two calls — `$queryRawUnsafe` resolves rows,
+ * `$executeRawUnsafe` resolves an affected-row count — so statements are
+ * routed by whether they return rows.
+ */
+declare function prismaDb(prisma: PrismaLike, dialect: SqlDialect): SqlAdapter;
+/** The raw-query slice of a TypeORM DataSource or transaction EntityManager. */
+interface TypeOrmExecutorLike {
+    query(sql: string, params?: unknown[]): Promise<unknown>;
+}
+/** Structural view of a TypeORM DataSource. */
+interface TypeOrmLike extends TypeOrmExecutorLike {
+    transaction<T>(run: (manager: TypeOrmExecutorLike) => Promise<T>): Promise<T>;
+}
+/**
+ * Wrap a TypeORM DataSource. `query` passes the SQL through verbatim and
+ * already resolves rows on both drivers. The transaction callback must run
+ * through the transaction's own EntityManager — falling back to the
+ * DataSource would execute settlement statements outside the transaction.
+ */
+declare function typeOrmDb(dataSource: TypeOrmLike, dialect: SqlDialect): SqlAdapter;
+/** The raw-query slice of a Sequelize instance or a managed Transaction. */
+interface SequelizeExecutorLike {
+    query(sql: string, options?: {
+        readonly bind?: readonly unknown[];
+        readonly transaction?: unknown;
+    }): Promise<unknown>;
+}
+/** Structural view of a Sequelize instance. */
+interface SequelizeLike extends SequelizeExecutorLike {
+    transaction<T>(run: (transaction: unknown) => Promise<T>): Promise<T>;
+}
+/**
+ * Wrap a Sequelize instance.
+ *
+ * Sequelize takes bind parameters under `bind` (not positional arguments) and
+ * carries the transaction on the SAME instance via an options key rather than
+ * a separate executor object — so the transaction callback threads the
+ * managed transaction back into every statement. Without that, settlement
+ * statements would run outside the transaction on the instance's own pool.
+ *
+ * `sequelize.query` resolves `[rows, metadata]` for a SELECT and metadata
+ * alone for a write, so a non-array result reads as no rows.
+ */
+declare function sequelizeDb(sequelize: SequelizeLike, dialect: SqlDialect): SqlAdapter;
+
+export { Host, type KnexLike, type MaybeReconcilePaymentsOptions, type NodeRequestParts, OPENRECEIVE_MIN_RECONCILE_INTERVAL_SECONDS, OPENRECEIVE_RECONCILE_SCAN_MAX_PAGES, OPENRECEIVE_RECONCILE_SCAN_TIMEOUT_MS, type OpportunisticReconcileResult, type PrismaLike, ReconcilableAttempt, type Reconciler, type SequelizeLike, SqlAdapter, type SqlDialect, type TypeOrmLike, type WireCheckout, type WireCreateCheckoutRequest, type WireCreateCheckoutResponse, type WireCreateSwapRequest, type WireCreateSwapResponse, type WireError, type WireFiatQuote, type WirePaymentCheck, type WirePaymentCheckRequest, type WirePaymentDetails, type WirePaymentMethod, type WirePaymentStatus, type WirePrepareCheckoutRequest, type WirePrepareCheckoutResponse, type WireRatesResponse, type WireRefundSwapRequest, type WireSwap, type WireSwapCheckout, type WireSwapFee, type WireSwapPayInAsset, type WireSwapProviderState, type WireSwapQuote, type WireSwapQuoteRequest, isUnderPrefix, knexDb, maybeReconcilePayments, prismaDb, reconcileHostPayments, reconcileIntervalSeconds, sequelizeDb, startReconciler, typeOrmDb, webRequest };

package/dist/index.js

@@ -0,0 +1,74 @@
+import {
+  HostError,
+  HttpError,
+  OPENRECEIVE_ATTEMPT_EXPIRY_GRACE_SECONDS,
+  OPENRECEIVE_MIN_RECONCILE_INTERVAL_SECONDS,
+  OPENRECEIVE_PAYMENTS_SCHEMA_VERSION,
+  OPENRECEIVE_RECONCILE_BATCH_SIZE,
+  OPENRECEIVE_RECONCILE_SCAN_MAX_PAGES,
+  OPENRECEIVE_RECONCILE_SCAN_TIMEOUT_MS,
+  createHost,
+  createHttpHandler,
+  createIpRateLimit,
+  createProxyRateLimitingConfig,
+  createRequestId,
+  createSqlPayments,
+  createStack,
+  errorResponse,
+  hostError,
+  isServiceErrorShape,
+  isStackOptions,
+  isUnderPrefix,
+  jsonResponse,
+  knexDb,
+  mapHostRouteError,
+  maybeReconcilePayments,
+  paymentsSchemaSql,
+  prismaDb,
+  reconcileHostPayments,
+  reconcileIntervalSeconds,
+  resolveClientIp,
+  sequelizeDb,
+  startNotificationListener,
+  startNotificationWorker,
+  startReconciler,
+  typeOrmDb,
+  webRequest
+} from "./chunk-5S24YV7E.js";
+export {
+  HostError,
+  HttpError,
+  OPENRECEIVE_ATTEMPT_EXPIRY_GRACE_SECONDS,
+  OPENRECEIVE_MIN_RECONCILE_INTERVAL_SECONDS,
+  OPENRECEIVE_PAYMENTS_SCHEMA_VERSION,
+  OPENRECEIVE_RECONCILE_BATCH_SIZE,
+  OPENRECEIVE_RECONCILE_SCAN_MAX_PAGES,
+  OPENRECEIVE_RECONCILE_SCAN_TIMEOUT_MS,
+  createHost,
+  createHttpHandler,
+  createIpRateLimit,
+  createProxyRateLimitingConfig,
+  createRequestId,
+  createSqlPayments,
+  createStack,
+  errorResponse,
+  hostError,
+  isServiceErrorShape,
+  isStackOptions,
+  isUnderPrefix,
+  jsonResponse,
+  knexDb,
+  mapHostRouteError,
+  maybeReconcilePayments,
+  paymentsSchemaSql,
+  prismaDb,
+  reconcileHostPayments,
+  reconcileIntervalSeconds,
+  resolveClientIp,
+  sequelizeDb,
+  startNotificationListener,
+  startNotificationWorker,
+  startReconciler,
+  typeOrmDb,
+  webRequest
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@openreceive/http",
+  "version": "0.2.1",
+  "description": "Framework-neutral (Web Request/Response) HTTP handler for OpenReceive checkout that builds on @openreceive/node and requires its Node runtime: request routing, host integration, and payment-attempt persistence.",
+  "keywords": [
+    "bitcoin",
+    "lightning",
+    "payments",
+    "nwc",
+    "bolt11",
+    "openreceive",
+    "checkout",
+    "http"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@openreceive/core": "0.2.1",
+    "@openreceive/node": "0.2.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./adapter-surface": {
+      "types": "./dist/adapter-surface.d.ts",
+      "import": "./dist/adapter-surface.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/adapter-surface.ts --format esm --dts --clean --target es2022 --out-dir dist",
+    "prepack": "npm run build"
+  },
+  "license": "MIT",
+  "author": "OpenReceive <info@openreceive.org>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openreceive/openreceive.git",
+    "directory": "packages/js/http"
+  },
+  "bugs": {
+    "url": "https://github.com/openreceive/openreceive/issues"
+  },
+  "homepage": "https://openreceive.org",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}