@fire-spark/core 0.0.3 → 0.1.1

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createAttemptReference, createPaymentError, currencyDecimals, defaultReversalFor, isPaymentError, memoryPaymentStorage, missingDeviceFields, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
 import advancedFormat from "dayjs/plugin/advancedFormat.js";
 import isBetween from "dayjs/plugin/isBetween.js";
 import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
@@ -1966,6 +1967,105 @@ const buildCustomerSnapshot = (source) => {
 	} };
 };
 //#endregion
+//#region src/logs/limits.ts
+/** Mirrors the API limits so oversized logs are trimmed, not rejected. */
+const LOG_LIMITS = {
+	message: 2e3,
+	detail: 2e3,
+	alias: 64,
+	status: 64,
+	contextId: 128,
+	errorName: 128,
+	stack: 8e3,
+	cause: 2e3,
+	batch: 50,
+	keepaliveBytes: 6e4
+};
+const truncate = (value, max) => {
+	if (value.length <= max) return value;
+	return `${value.slice(0, max - 1)}…`;
+};
+//#endregion
+//#region src/logs/context.ts
+const emptyContext = () => {
+	return {
+		channel_id: null,
+		fulfillment_id: null,
+		store_id: null,
+		brand_id: null,
+		device_id: null
+	};
+};
+let context = emptyContext();
+let posDevice = null;
+const cleanId = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return trimmed.slice(0, LOG_LIMITS.contextId);
+};
+const SCOPE_KEYS = [
+	"channel_id",
+	"fulfillment_id",
+	"store_id",
+	"brand_id"
+];
+/** Only keys present in `scope` change; `null` clears one. */
+const captureLogScope = (scope) => {
+	if (!scope) return;
+	const next = { ...context };
+	for (const key of SCOPE_KEYS) {
+		if (scope[key] === void 0) continue;
+		next[key] = cleanId(scope[key]);
+	}
+	context = next;
+};
+const captureLogDevice = (device_id) => {
+	const id = cleanId(device_id);
+	if (id) context = {
+		...context,
+		device_id: id
+	};
+};
+/** `{ device: { uid }, scope }` as returned by kiosk link and POS pair. */
+const captureLogDeviceConfig = (config) => {
+	if (!config || typeof config !== "object") return;
+	const value = config;
+	captureLogDevice(value.device?.uid);
+	captureLogScope(value.scope);
+};
+/** POS calls carry device credentials; logs reuse them for the POS route. */
+const capturePosLogDevice = (input, options) => {
+	if (!input || typeof input !== "object") return;
+	const value = input;
+	const device_uid = cleanId(value.device_uid);
+	const { device_secret } = value;
+	if (!device_uid || typeof device_secret !== "string") return;
+	if (!device_secret) return;
+	posDevice = {
+		device_uid,
+		device_secret,
+		http: {
+			baseUrl: options?.baseUrl,
+			fetchImpl: options?.fetchImpl
+		}
+	};
+	captureLogDevice(device_uid);
+};
+const clearLogDevice = () => {
+	posDevice = null;
+	context = {
+		...context,
+		device_id: null
+	};
+};
+const getLogContext = () => {
+	return { ...context };
+};
+const getPosLogDevice = () => {
+	return posDevice;
+};
+//#endregion
 //#region src/services/http.ts
 var StorefrontHttpError = class extends Error {
 	status;
@@ -2083,6 +2183,7 @@ const preferencesQuery = (scope) => {
 	return query ? `${path}?${query}` : path;
 };
 const getPreferences = (scope = {}, options) => {
+	captureLogScope(scope);
 	return storefrontJson(...[
 		preferencesQuery(scope),
 		{},
@@ -2171,7 +2272,7 @@ const kioskFetch = async (path, init, options) => {
 	};
 	return fetchImpl(kioskUrl(path, options), req);
 };
-const readError = async (response) => {
+const readError$1 = async (response) => {
 	const text = await response.text();
 	try {
 		return JSON.parse(text);
@@ -2199,10 +2300,12 @@ const getKioskConfig = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
-	return (await response.json()).data;
+	const json = await response.json();
+	captureLogDeviceConfig(json.data);
+	return json.data;
 };
 const postKioskHeartbeat = async (input, options) => {
 	const path = "/api/storefront/v1/kiosk/devices/me";
@@ -2212,9 +2315,10 @@ const postKioskHeartbeat = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return await response.json();
 };
 const postKioskHealthSamples = async (input, options) => {
@@ -2225,9 +2329,10 @@ const postKioskHealthSamples = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return await response.json();
 };
 const patchKioskOverrides = async (input, options) => {
@@ -2238,7 +2343,7 @@ const patchKioskOverrides = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
 	return (await response.json()).data;
@@ -2251,9 +2356,10 @@ const unlinkKioskSelf = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	clearLogDevice();
 	return (await response.json()).data;
 };
 /** 403 wrong or expired code, 429 too many tries for the current code. */
@@ -2265,7 +2371,7 @@ const verifyKioskAdminCode = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
 	return (await response.json()).data;
@@ -2284,9 +2390,10 @@ const fetchKioskRealtimeToken = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return (await response.json()).data;
 };
 //#endregion
@@ -2304,9 +2411,11 @@ const menuQuery = (scope, stream) => {
 	return `/api/storefront/v1/menus${query ? `?${query}` : ""}`;
 };
 const listMenus = (scope = {}, options) => {
+	captureLogScope(scope);
 	return storefrontJson(menuQuery(scope), {}, options);
 };
 const listMenusStream = (scope = {}, options = {}) => {
+	captureLogScope(scope);
 	const { category_limit, product_limit, ...http } = options;
 	return storefrontNdjson(menuQuery(scope, {
 		streaming: true,
@@ -2372,6 +2481,18 @@ const placeOrder = (id, body = {}, options) => {
 		options
 	]);
 };
+/** Records (or updates by `metadata.attempt_reference`) one payment intent. */
+const recordOrderPayment = (id, body, options) => {
+	const init = {
+		method: "POST",
+		body: JSON.stringify(body)
+	};
+	return storefrontJson(...[
+		`${orderPath(id)}/payments`,
+		init,
+		options
+	]);
+};
 const getOrderFulfillment = (id, options) => {
 	return storefrontJson(...[
 		`${orderPath(id)}/fulfillment`,
@@ -2450,6 +2571,229 @@ const listPayments = (input, options) => {
 	for (const [key, value] of Object.entries(input)) if (value) params.set(key, value);
 	return storefrontJson(`/api/storefront/v1/payments?${params.toString()}`, {}, options);
 };
+/** Server half of an adapter (`POST /payments/:id/operations/:operation`). */
+const callPaymentOperation = (paymentId, operation, body, options) => {
+	return storefrontJson(`/api/storefront/v1/payments/${encodeURIComponent(paymentId)}/operations/${encodeURIComponent(operation)}`, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+/** Reports a failed terminal operation (`payment.terminal_failed`). */
+const reportTerminalFailure = (paymentId, body, options) => {
+	return storefrontJson(`/api/storefront/v1/payments/${encodeURIComponent(paymentId)}/terminal-failures`, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+//#endregion
+//#region src/i18n/pos.ts
+const enUS = {
+	DEVICE_NOT_LINKED: "This register is not linked.",
+	DEVICE_NOT_ACTIVE: "This register is not active.",
+	PAIRING_CODE_INVALID: "That pairing code is not valid.",
+	RELINK_CODE_INVALID: "That re-link code is not valid.",
+	RELINK_CODE_EXPIRED: "That re-link code has expired.",
+	PIN_INVALID: "The PIN is incorrect.",
+	PIN_LOCKED: "This PIN is locked. Try again later.",
+	OPERATOR_NOT_ASSIGNED: "This operator is not assigned to this store.",
+	AUTHORIZER_NOT_ALLOWED: "This person cannot authorize this action.",
+	SESSION_ALREADY_OPEN: "A cash session is already open on this register.",
+	SESSION_NOT_OPEN: "Open a cash session first.",
+	BREAKDOWN_MISMATCH: "The cash breakdown does not match the amount.",
+	DIFFERENCE_NEEDS_AUTH: "The difference needs a manager PIN.",
+	KIOSK_ORDER_NOT_SETTLEABLE: "This kiosk order cannot be settled here.",
+	PAYMENT_NOT_AVAILABLE: "This payment method is not available on this register."
+};
+const posErrorMessages = {
+	en: enUS,
+	"en-US": enUS,
+	es: {
+		DEVICE_NOT_LINKED: "Esta caja no está vinculada.",
+		DEVICE_NOT_ACTIVE: "Esta caja no está activa.",
+		PAIRING_CODE_INVALID: "Ese código de vinculación no es válido.",
+		RELINK_CODE_INVALID: "Ese código de revinculación no es válido.",
+		RELINK_CODE_EXPIRED: "Ese código de revinculación expiró.",
+		PIN_INVALID: "El PIN es incorrecto.",
+		PIN_LOCKED: "Este PIN está bloqueado. Inténtalo más tarde.",
+		OPERATOR_NOT_ASSIGNED: "Este operador no está asignado a esta tienda.",
+		AUTHORIZER_NOT_ALLOWED: "Esta persona no puede autorizar esta acción.",
+		SESSION_ALREADY_OPEN: "Ya hay una sesión de caja abierta aquí.",
+		SESSION_NOT_OPEN: "Abre una sesión de caja primero.",
+		BREAKDOWN_MISMATCH: "El desglose de efectivo no coincide con el monto.",
+		DIFFERENCE_NEEDS_AUTH: "La diferencia necesita el PIN de un supervisor.",
+		KIOSK_ORDER_NOT_SETTLEABLE: "Este pedido de kiosco no se puede cobrar aquí.",
+		PAYMENT_NOT_AVAILABLE: "Este método de pago no está disponible en esta caja."
+	},
+	"pt-BR": {
+		DEVICE_NOT_LINKED: "Este caixa não está vinculado.",
+		DEVICE_NOT_ACTIVE: "Este caixa não está ativo.",
+		PAIRING_CODE_INVALID: "Esse código de vinculação não é válido.",
+		RELINK_CODE_INVALID: "Esse código de revinculação não é válido.",
+		RELINK_CODE_EXPIRED: "Esse código de revinculação expirou.",
+		PIN_INVALID: "O PIN está incorreto.",
+		PIN_LOCKED: "Este PIN está bloqueado. Tente novamente mais tarde.",
+		OPERATOR_NOT_ASSIGNED: "Este operador não está cadastrado nesta loja.",
+		AUTHORIZER_NOT_ALLOWED: "Esta pessoa não pode autorizar esta ação.",
+		SESSION_ALREADY_OPEN: "Já existe uma sessão de caixa aberta aqui.",
+		SESSION_NOT_OPEN: "Abra uma sessão de caixa primeiro.",
+		BREAKDOWN_MISMATCH: "A composição do dinheiro não confere com o valor.",
+		DIFFERENCE_NEEDS_AUTH: "A diferença precisa do PIN de um supervisor.",
+		KIOSK_ORDER_NOT_SETTLEABLE: "Este pedido do totem não pode ser cobrado aqui.",
+		PAYMENT_NOT_AVAILABLE: "Esta forma de pagamento não está disponível neste caixa."
+	}
+};
+const posErrorMessage = (code, locale = "en-US") => {
+	if (!code) return void 0;
+	return (posErrorMessages[locale] ?? posErrorMessages["en-US"])[code];
+};
+//#endregion
+//#region src/services/pos.ts
+const posUrl = (path, options) => {
+	const override = options?.baseUrl;
+	const base = override ? resolveBaseUrl(override) : resolveBaseUrl();
+	if (!path.startsWith("/")) return `${base}/${path}`;
+	return `${base}${path}`;
+};
+const posFetch = async (path, init, options) => {
+	const fetchImpl = options?.fetchImpl ?? fetch;
+	const headers = new Headers(init.headers);
+	if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+	const signal = options?.signal ?? init.signal;
+	const req = {
+		...init,
+		headers,
+		signal
+	};
+	return fetchImpl(posUrl(path, options), req);
+};
+const readError = async (response) => {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { error: text || response.statusText };
+	}
+};
+const validationDetails = (details) => {
+	if (!details || typeof details !== "object") return null;
+	const record = details;
+	if (!Array.isArray(record.issues) || !record.lines) return null;
+	return {
+		issues: record.issues,
+		lines: record.lines
+	};
+};
+/** A sale the menu rejects comes back as a 422 with issues, like checkout. */
+const throwPosError = (body, status) => {
+	const details = status === 422 ? validationDetails(body.details) : null;
+	if (details) throw new OrderValidationError(details.issues, details.lines);
+	throw new StorefrontHttpError(body.error ?? "Request failed", status, body.code);
+};
+const postJson = async (path, input, options) => {
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await posFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwPosError(body, response.status);
+	}
+	capturePosLogDevice(input, options);
+	return await response.json();
+};
+/** Pairing answers with the device config; the secret came from the app. */
+const captureLinkedDevice = (data, device_secret, options) => {
+	captureLogDeviceConfig(data);
+	const device = data?.device;
+	capturePosLogDevice({
+		device_uid: device?.uid,
+		device_secret
+	}, options);
+};
+const isPosDeviceNotLinked = (error) => {
+	if (!(error instanceof StorefrontHttpError)) return false;
+	if (error.code === "DEVICE_NOT_LINKED") return true;
+	if (error.status !== 404) return false;
+	return error.message.includes("DEVICE_NOT_LINKED");
+};
+const isPosUnauthorized = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 401;
+};
+const isPosPinLocked = (error) => {
+	return error instanceof StorefrontHttpError && error.code === "PIN_LOCKED";
+};
+const localizePosError = (error, locale = "en-US") => {
+	if (!(error instanceof StorefrontHttpError)) return void 0;
+	return posErrorMessage(error.code, locale);
+};
+const pairPosDevice = async (input, options) => {
+	const json = await postJson("/api/storefront/v1/pos/devices/pair", input, options);
+	captureLinkedDevice(json.data, input.device_secret, options);
+	return json.data;
+};
+const relinkPosDevice = async (input, options) => {
+	const json = await postJson("/api/storefront/v1/pos/devices/relink", input, options);
+	captureLinkedDevice(json.data, input.device_secret, options);
+	return json.data;
+};
+const postPosHeartbeat = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me", input, options);
+};
+const postPosHealthSamples = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me/health", input, options);
+};
+const postPosDeviceLogs = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me/logs", input, options);
+};
+const listPosOperators = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/operators", input, options)).data;
+};
+const verifyPosOperator = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/operators/verify", input, options)).data;
+};
+const listPosAuthorizers = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/authorizers", input, options)).data;
+};
+const verifyPosAuthorizer = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/auth/verify", input, options)).data;
+};
+const openPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/open", input, options)).data;
+};
+const countPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/count", input, options)).data;
+};
+const withdrawPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/withdraw", input, options)).data;
+};
+const drawerPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/drawer", input, options)).data;
+};
+const closePosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/close", input, options)).data;
+};
+const shiftEndPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/shift-end", input, options)).data;
+};
+/** The device's open caja and its events, or `{ session: null }`. */
+const getPosCurrentSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/current", input, options)).data;
+};
+const listPosKioskOrders = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/kiosk-orders", input, options)).data;
+};
+/** Safe to retry with the same `client_id`; the server dedupes the settle. */
+const settlePosKioskOrder = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/kiosk-orders/settle", input, options)).data;
+};
+const getPosCatalog = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/catalog", input, options)).data;
+};
+/** Safe to retry with the same `client_id`; the server dedupes the sale. */
+const createPosOrder = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/orders", input, options)).data;
+};
 //#endregion
 //#region src/services/stores.ts
 const storesPath = (suffix) => {
@@ -2512,10 +2856,15 @@ const services = {
 		reorder: reorderOrder,
 		validate: validateOrder,
 		place: placeOrder,
+		recordPayment: recordOrderPayment,
 		getFulfillment: getOrderFulfillment,
 		listFulfillments: listOrderFulfillments
 	},
-	payments: { list: listPayments },
+	payments: {
+		list: listPayments,
+		operation: callPaymentOperation,
+		terminalFailure: reportTerminalFailure
+	},
 	stores: {
 		list: listStores,
 		nearby: listNearbyStores,
@@ -2533,6 +2882,32 @@ const services = {
 		isAdminCodeLocked: isKioskAdminCodeLocked,
 		isDeviceNotLinked,
 		isKioskUnauthorized
+	},
+	pos: {
+		pair: pairPosDevice,
+		relink: relinkPosDevice,
+		heartbeat: postPosHeartbeat,
+		postHealthSamples: postPosHealthSamples,
+		postLogs: postPosDeviceLogs,
+		listOperators: listPosOperators,
+		verifyOperator: verifyPosOperator,
+		listAuthorizers: listPosAuthorizers,
+		verifyAuthorizer: verifyPosAuthorizer,
+		openSession: openPosSession,
+		countSession: countPosSession,
+		withdraw: withdrawPosSession,
+		drawer: drawerPosSession,
+		closeSession: closePosSession,
+		shiftEnd: shiftEndPosSession,
+		currentSession: getPosCurrentSession,
+		listKioskOrders: listPosKioskOrders,
+		settleKioskOrder: settlePosKioskOrder,
+		getCatalog: getPosCatalog,
+		createOrder: createPosOrder,
+		isDeviceNotLinked: isPosDeviceNotLinked,
+		isUnauthorized: isPosUnauthorized,
+		isPinLocked: isPosPinLocked,
+		localizeError: localizePosError
 	}
 };
 const DISALLOWED = /[^A-Za-z0-9]/g;
@@ -2614,7 +2989,7 @@ const genOrderId = (storeId) => {
 };
 //#endregion
 //#region src/order/retry.ts
-const defaultSleep = (ms) => {
+const defaultSleep$1 = (ms) => {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
 	});
@@ -2623,7 +2998,7 @@ const defaultSleep = (ms) => {
 const withExponentialRetry = async (run, options = {}) => {
 	const extraAttempts = options.extraAttempts ?? 3;
 	const baseDelayMs = options.baseDelayMs ?? 100;
-	const sleep = options.sleep ?? defaultSleep;
+	const sleep = options.sleep ?? defaultSleep$1;
 	let lastError;
 	for (let attempt = 0; attempt <= extraAttempts; attempt += 1) try {
 		return await run();
@@ -2966,6 +3341,14 @@ const subtractLine = (lines, lineUid, quantity = 1) => {
 		return scaleLineQuantity(line, nextQty);
 	});
 };
+/** Rescale one line's money to `quantity`; zero or less drops its subtree. */
+const setLineQuantity = (lines, lineUid, quantity) => {
+	if (quantity <= 0) return removeSubtree(lines, lineUid);
+	return lines.map((line) => {
+		if (line.uid !== lineUid) return line;
+		return scaleLineQuantity(line, quantity);
+	});
+};
 /** Drop a root subtree, then add the replacement tree (may merge by fingerprint). */
 const replaceLine = (lines, lineUid, next) => {
 	return addLines(removeSubtree(lines, lineUid), next);
@@ -2974,6 +3357,767 @@ const emptyLines = () => {
 	return [];
 };
 //#endregion
+//#region src/order/payments/orchestrator.ts
+const AMBIGUOUS_QUERIES = 3;
+const defaultSleep = (ms, signal) => {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
+		});
+	});
+};
+const defaultClock = {
+	now: () => Date.now(),
+	sleep: defaultSleep
+};
+var TimeoutSignal = class extends Error {};
+/**
+* Provider deadline that pauses while the customer is answering `ctx.ui`;
+* user waits run on `interaction_timeout_ms` instead.
+*/
+const createDeadline = (timeoutMs, onExpire) => {
+	let remaining = timeoutMs;
+	let startedAt = 0;
+	let timer = null;
+	let paused = 0;
+	const run = () => {
+		startedAt = Date.now();
+		timer = setTimeout(onExpire, Math.max(remaining, 0));
+	};
+	const stop = () => {
+		if (!timer) return;
+		clearTimeout(timer);
+		timer = null;
+		remaining -= Date.now() - startedAt;
+	};
+	return {
+		start: run,
+		pause: () => {
+			if (paused === 0) stop();
+			paused += 1;
+		},
+		resume: () => {
+			paused -= 1;
+			if (paused === 0) run();
+		},
+		clear: stop
+	};
+};
+const withUserTimeout = (promise, ms) => {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(new PaymentUserTimeout());
+		}, ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+};
+var PaymentUserTimeout = class extends Error {};
+const timedUI = (ui, deadline, interactionMs) => {
+	const wrap = (call) => {
+		deadline.pause();
+		return withUserTimeout(call(), interactionMs).finally(() => deadline.resume());
+	};
+	return {
+		message: (input) => ui.message(input),
+		action: (input) => ui.action(input),
+		select: (input) => {
+			return wrap(() => ui.select(input));
+		},
+		input: (input) => wrap(() => ui.input(input)),
+		confirm: (input) => wrap(() => ui.confirm(input))
+	};
+};
+/** Runs one adapter call with the provider timeout and the user clock. */
+const runTimed = async (ctx, call) => {
+	const controller = new AbortController();
+	const parent = ctx.signal;
+	const abort = () => controller.abort();
+	parent.addEventListener("abort", abort);
+	let expire = () => void 0;
+	const expired = new Promise((_, reject) => {
+		expire = () => {
+			controller.abort();
+			reject(new TimeoutSignal());
+		};
+	});
+	const deadline = createDeadline(ctx.policy.timeout_ms, () => expire());
+	const interaction = ctx.policy.interaction_timeout_ms;
+	const ui = timedUI(ctx.ui, deadline, interaction);
+	const scoped = {
+		...ctx,
+		ui,
+		signal: controller.signal
+	};
+	deadline.start();
+	try {
+		return await Promise.race([call(scoped), expired]);
+	} finally {
+		deadline.clear();
+		parent.removeEventListener("abort", abort);
+	}
+};
+const failed = (ctx, error, extra = {}) => {
+	const metadata = {
+		attempt_reference: ctx.attemptReference,
+		error,
+		...extra
+	};
+	return {
+		status: "FAILED",
+		amount: ctx.amount.value,
+		metadata,
+		error
+	};
+};
+const errorOf = (ctx, error, startedAt, clock) => {
+	const elapsed_ms = clock.now() - startedAt;
+	const attempt = ctx.attempt;
+	if (isPaymentError(error)) return {
+		...error.error,
+		attempt,
+		elapsed_ms
+	};
+	let code = "UNKNOWN";
+	if (error instanceof TimeoutSignal) code = "TIMEOUT";
+	if (error instanceof PaymentUserTimeout) code = "USER_TIMEOUT";
+	const extra = {
+		attempt,
+		elapsed_ms,
+		provider_message: error instanceof Error ? error.message : null
+	};
+	return createPaymentError(code, extra);
+};
+/** `start` that timed out after leaving the device is ambiguous. */
+const startError = (error) => {
+	if (error.code !== "TIMEOUT") return error;
+	return createPaymentError("AMBIGUOUS", {
+		attempt: error.attempt,
+		elapsed_ms: error.elapsed_ms
+	});
+};
+const isFinal = (result) => result.status !== "PENDING";
+const callOperation = async (ctx, operation, result, clock) => {
+	const startedAt = clock.now();
+	try {
+		return await runTimed(ctx, (scoped) => operation(scoped, result));
+	} catch (error) {
+		return failed(ctx, errorOf(ctx, error, startedAt, clock));
+	}
+};
+/** Query up to 3 times, cancel once, else FAILED + needs_review. */
+const resolveAmbiguous = async (adapter, ctx, pending, clock) => {
+	if (adapter.query) for (let i = 0; i < AMBIGUOUS_QUERIES; i += 1) {
+		await clock.sleep(ctx.policy.poll_interval_ms, ctx.signal);
+		const next = await callOperation(ctx, adapter.query, pending, clock);
+		if (next.status === "PAID") return next;
+		const definitive = next.error?.code !== "TIMEOUT" && !next.error?.retryable;
+		if (next.status === "FAILED" && definitive && next.error?.code !== "AMBIGUOUS") return next;
+	}
+	if (adapter.cancel) {
+		const cancelled = await callOperation(ctx, adapter.cancel, pending, clock);
+		if (cancelled.status === "CANCELLED") return cancelled;
+	}
+	const error = createPaymentError("AMBIGUOUS", { attempt: ctx.attempt });
+	return failed(ctx, error, { needs_review: true });
+};
+/** PENDING with an action: poll until paid, rejected or the QR expires. */
+const pollPending = async (adapter, ctx, pending, clock, options) => {
+	if (pending.metadata.confirm_after_inject) return pending;
+	if (!adapter.query) return pending;
+	const expiresAt = clock.now() + ctx.policy.qr_ttl_ms;
+	let current = pending;
+	while (clock.now() < expiresAt) {
+		if (ctx.signal.aborted) break;
+		await clock.sleep(ctx.policy.poll_interval_ms, ctx.signal);
+		if (ctx.signal.aborted) break;
+		const next = await callOperation(ctx, adapter.query, current, clock);
+		if (next.status === "FAILED" && next.error?.retryable) continue;
+		if (isFinal(next)) return next;
+		current = next;
+		await options.onProgress?.(current);
+	}
+	if (adapter.cancel) await callOperation(ctx, adapter.cancel, current, clock);
+	const code = ctx.signal.aborted ? "CANCELLED_BY_USER" : "WALLET_EXPIRED";
+	return failed(ctx, createPaymentError(code, { attempt: ctx.attempt }));
+};
+const runStart = async (adapter, ctx, clock) => {
+	const startedAt = clock.now();
+	try {
+		return await runTimed(ctx, (scoped) => adapter.start(scoped));
+	} catch (error) {
+		const raw = errorOf(ctx, error, startedAt, clock);
+		return failed(ctx, startError(raw));
+	}
+};
+const toTerminalContext = (ctx) => {
+	const b1 = {
+		paymentId: ctx.paymentId,
+		attempt: ctx.attempt
+	};
+	const b2 = { attemptReference: ctx.attemptReference };
+	const b3 = {
+		environment: ctx.environment,
+		config: ctx.config
+	};
+	const b4 = {
+		deviceSettings: ctx.deviceSettings,
+		policy: ctx.policy
+	};
+	const b5 = {
+		ui: ctx.ui,
+		storage: ctx.storage,
+		server: ctx.server
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...b5,
+		signal: ctx.signal
+	};
+};
+const closeBatch = async (adapter, ctx) => {
+	const close = adapter.terminal?.closeBatch;
+	if (!close) return false;
+	const done = await close(toTerminalContext(ctx)).catch(() => null);
+	return Boolean(done?.ok);
+};
+/**
+* One payment attempt with the policy of section 7: timeout, retries on
+* retryable errors (same `attempt_reference`), batch close and retry,
+* polling for actions and resolution of ambiguous results.
+*/
+const runPaymentAttempt = async (adapter, ctx, options = {}) => {
+	const clock = options.clock ?? defaultClock;
+	return withTerminalLock(ctx.paymentId, async () => {
+		let batchClosed = false;
+		let attempt = 1;
+		while (true) {
+			const current = {
+				...ctx,
+				attempt
+			};
+			const result = await runStart(adapter, current, clock);
+			const code = result.error?.code;
+			if (code === "BATCH_CLOSE_REQUIRED" && !batchClosed) {
+				batchClosed = true;
+				if (await closeBatch(adapter, current)) continue;
+			}
+			if (code === "AMBIGUOUS") {
+				await options.onProgress?.({
+					...result,
+					status: "PENDING"
+				});
+				return resolveAmbiguous(adapter, current, result, clock);
+			}
+			const canRetry = attempt < ctx.policy.max_attempts;
+			if (result.status === "FAILED" && result.error?.retryable && canRetry) {
+				attempt += 1;
+				continue;
+			}
+			if (result.status !== "PENDING") return result;
+			await options.onProgress?.(result);
+			return pollPending(adapter, current, result, clock, options);
+		}
+	});
+};
+/** Undo a charge after a failed injection or an incomplete split payment. */
+const reversePayment = async (adapter, ctx, result, options = {}) => {
+	const clock = options.clock ?? defaultClock;
+	const now = options.now ?? new Date(clock.now());
+	let kind = (adapter.reversalFor ?? defaultReversalFor)(result, now);
+	const operation = kind === "cancel" ? adapter.cancel : adapter.refund;
+	if (kind !== "manual" && !operation) kind = "manual";
+	if (kind === "manual" || !operation) {
+		const error = createPaymentError("MANUAL_REVERSAL_REQUIRED");
+		const m1 = {
+			...result.metadata,
+			error,
+			needs_review: true
+		};
+		return {
+			kind: "manual",
+			result: {
+				...result,
+				metadata: m1,
+				error
+			}
+		};
+	}
+	const run = () => callOperation(ctx, operation, result, clock);
+	const next = await withTerminalLock(ctx.paymentId, run);
+	return {
+		kind,
+		result: next
+	};
+};
+//#endregion
+//#region src/order/payments/session.ts
+const noopUI = {
+	message: () => void 0,
+	action: () => void 0,
+	select: () => Promise.reject(/* @__PURE__ */ new Error("Payment UI not configured")),
+	input: () => Promise.reject(/* @__PURE__ */ new Error("Payment UI not configured")),
+	confirm: () => Promise.resolve(false)
+};
+const adapterKey = (provider, method) => {
+	return `${provider}:${method}`;
+};
+const record = (value) => {
+	if (!value || typeof value !== "object") return {};
+	return value;
+};
+/** PAID plus PENDING with `confirm_after_inject`, in the order currency. */
+const coveredAmount = (intents) => {
+	return intents.reduce((sum, intent) => {
+		const confirm = record(intent.metadata).confirm_after_inject === true;
+		const pendingConfirm = intent.status === "PENDING" && confirm;
+		if (intent.status !== "PAID" && !pendingConfirm) return sum;
+		return sum + intent.totals.total;
+	}, 0);
+};
+const remainingAmount = (order) => {
+	const decimals = currencyDecimals(order.totals.currency);
+	const left = order.totals.total - coveredAmount(order.payment_intents);
+	return Math.max(roundTo(left, decimals), 0);
+};
+const isPlaced = (order) => order.status !== "OPEN";
+/** Orchestrator failures carry the charge-currency amount, not the order's. */
+const withOrderAmount = (result, amount) => {
+	if (result.status !== "FAILED") return result;
+	return {
+		...result,
+		amount
+	};
+};
+const toFailure = (error) => {
+	const message = error instanceof Error ? error.message : "Terminal failed";
+	return {
+		ok: false,
+		message,
+		error: createPaymentError("UNKNOWN", { provider_message: message })
+	};
+};
+/**
+* Payment state of one order: adapters, device settings and the attempt
+* orchestration. The app only provides adapters, UI and storage.
+*/
+var PaymentSession = class {
+	deps;
+	adapters = /* @__PURE__ */ new Map();
+	payments = /* @__PURE__ */ new Map();
+	ui = noopUI;
+	storage = memoryPaymentStorage();
+	options = {};
+	constructor(deps) {
+		this.deps = deps;
+	}
+	setAdapters(adapters) {
+		this.adapters.clear();
+		for (const adapter of adapters) this.adapters.set(adapterKey(adapter.provider, adapter.method), adapter);
+	}
+	setUI(ui) {
+		this.ui = ui;
+	}
+	setStorage(storage) {
+		this.storage = storage;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		captureLogDevice(options.deviceId);
+	}
+	adapterFor(payment) {
+		const key = adapterKey(payment.provider.provider_id, payment.method.method);
+		return this.adapters.get(key) ?? null;
+	}
+	/** Device fields still missing for a payment on this device. */
+	missingFields(payment) {
+		const adapter = this.adapterFor(payment);
+		if (!adapter) return [];
+		const fromCatalog = record(payment.method.config).device_fields;
+		const fields = adapter.deviceFields ?? fromCatalog;
+		const settings = this.options.deviceSettings?.[payment.id];
+		return missingDeviceFields(Array.isArray(fields) ? fields : [], settings);
+	}
+	/**
+	* Merchant payments with an installed adapter (provider + method) that
+	* are fully configured on this device.
+	*/
+	available(payments) {
+		return payments.filter((payment) => {
+			if (!this.adapterFor(payment)) return false;
+			this.payments.set(payment.id, payment);
+			return this.missingFields(payment).length === 0;
+		});
+	}
+	remaining() {
+		return remainingAmount(this.deps.getOrder());
+	}
+	server(payment, attempt) {
+		const order_id = this.deps.getOrder().id;
+		const http = this.deps.http;
+		return { call: (operation, input) => {
+			const body = {
+				order_id,
+				attempt_reference: attempt,
+				input
+			};
+			const op = services.payments.operation;
+			return op(payment.id, operation, body, http);
+		} };
+	}
+	async chargeAmount(payment, value, server) {
+		const config = record(payment.config);
+		const orderCurrency = this.deps.getOrder().totals.currency;
+		const chargeCurrency = config.charge_currency;
+		if (!chargeCurrency || chargeCurrency === orderCurrency) return toChargeAmount({
+			value,
+			orderCurrency
+		});
+		const exchange = record(config.exchange_rate);
+		let rate = typeof exchange.rate === "number" ? exchange.rate : null;
+		if (exchange.source === "provider") {
+			const input = {
+				from: orderCurrency,
+				to: chargeCurrency
+			};
+			rate = (await server.call("exchange_rate", input)).rate;
+		}
+		return toChargeAmount({
+			value,
+			orderCurrency,
+			chargeCurrency,
+			rate
+		});
+	}
+	async buildContext(payment, amount, attemptReference, signal) {
+		const order = this.deps.getOrder();
+		const server = this.server(payment, attemptReference);
+		const conversion = await this.chargeAmount(payment, amount, server);
+		const config = record(payment.config);
+		const methodConfig = record(payment.method.config);
+		const share = order.totals.total > 0 ? amount / order.totals.total : 1;
+		const decimals = currencyDecimals(order.totals.currency);
+		const taxes = taxBreakdown(order.lines, {
+			share,
+			decimals
+		});
+		const info = order.customer.customer_info;
+		const customer = {
+			document: info.document_number ?? null,
+			documentType: info.document_type ?? null,
+			phone: info.phone ?? null
+		};
+		const environment = resolveProviderEnvironment({
+			isProduction: this.options.isProduction ?? false,
+			paymentConfig: config
+		});
+		const policy = resolvePaymentPolicy({
+			methodConfig,
+			paymentConfig: config
+		});
+		const prefix = `payments:${payment.id}`;
+		const storage = scopedPaymentStorage(this.storage, prefix);
+		const deviceSettings = this.options.deviceSettings?.[payment.id] ?? {};
+		const totals = order.totals;
+		const o1 = {
+			id: order.id,
+			currency: totals.currency,
+			totals
+		};
+		const b1 = {
+			paymentId: payment.id,
+			order: o1,
+			customer
+		};
+		const b2 = {
+			amount: conversion.amount,
+			taxes,
+			attemptReference
+		};
+		const b3 = {
+			collectAt: this.collectAt(payment),
+			attempt: 1
+		};
+		const b4 = {
+			environment,
+			config,
+			deviceSettings,
+			policy
+		};
+		const b5 = {
+			ui: this.ui,
+			storage,
+			server,
+			signal
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	}
+	collectAt(payment) {
+		if (payment.method.method === "CASH") return this.options.cashCollectAt ?? "DOOR";
+		return this.options.collectAt ?? "DEVICE";
+	}
+	toIntent(payment, result, placedAt) {
+		const totals = {
+			...this.deps.getOrder().totals,
+			total: result.amount
+		};
+		const resolved_at = result.status !== "PENDING" && result.status !== "IDLE" ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+		const message = result.error?.message;
+		const b1 = {
+			payment_id: payment.id,
+			method: payment.method.method
+		};
+		const b2 = { provider: payment.provider.provider_id };
+		const b3 = {
+			collect_at: this.collectAt(payment),
+			status: result.status
+		};
+		const b4 = {
+			totals,
+			placed_at: placedAt,
+			resolved_at
+		};
+		const b5 = {
+			metadata: { ...result.metadata },
+			error_message: message
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	}
+	async recordResult(payment, result, placedAt) {
+		const order = this.deps.getOrder();
+		const intent = this.toIntent(payment, result, placedAt);
+		const http = this.deps.http;
+		const p1 = [
+			order.id,
+			{ intent },
+			http
+		];
+		const next = await services.orders.recordPayment(...p1);
+		this.deps.applyOrder(next);
+	}
+	/**
+	* Charges `payment`: places the order with a PENDING intent if needed,
+	* runs the adapter with the merchant policy and records every result.
+	*/
+	async pay(payment, options = {}) {
+		const adapter = this.adapterFor(payment);
+		if (!adapter) {
+			const id = payment.id;
+			throw new Error(`No payment adapter installed for payment ${id}`);
+		}
+		this.payments.set(payment.id, payment);
+		const missing = this.missingFields(payment);
+		if (missing.length > 0) {
+			const keys = missing.map((field) => field.key).join(", ");
+			const id = payment.id;
+			throw new Error(`Payment ${id} is missing device fields: ${keys}`);
+		}
+		const remaining = this.remaining();
+		const amount = Math.min(options.amount ?? remaining, remaining);
+		if (amount <= 0) throw new Error("Order is already covered");
+		const attemptReference = createAttemptReference();
+		const placedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const pending = {
+			status: payment.method.method === "CASH" ? "IDLE" : "PENDING",
+			amount: isPlaced(this.deps.getOrder()) ? amount : remaining,
+			metadata: { attempt_reference: attemptReference }
+		};
+		const order = this.deps.getOrder();
+		if (!isPlaced(order)) {
+			const intent = this.toIntent(payment, pending, placedAt);
+			const p1 = {
+				id: payment.id,
+				intents: [intent]
+			};
+			await this.deps.placeOrder({ payment: p1 });
+		} else await this.recordResult(payment, pending, placedAt);
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		options.signal?.addEventListener("abort", abort);
+		try {
+			const a1 = [
+				payment,
+				amount,
+				attemptReference,
+				controller.signal
+			];
+			const ctx = await this.buildContext(...a1);
+			const onProgress = async (progress) => {
+				await options.onProgress?.(progress);
+				if (progress.status !== "PENDING") return;
+				await this.recordResult(payment, progress, placedAt);
+			};
+			const attempt = await runPaymentAttempt(adapter, ctx, {
+				...this.deps.runOptions,
+				onProgress
+			});
+			const result = withOrderAmount(attempt, amount);
+			if (result.status !== "IDLE") await this.recordResult(payment, result, placedAt);
+			return result;
+		} finally {
+			options.signal?.removeEventListener("abort", abort);
+		}
+	}
+	intentResult(intent) {
+		const metadata = record(intent.metadata);
+		const error = metadata.error;
+		return {
+			status: intent.status,
+			amount: intent.totals.total,
+			metadata,
+			...error ? { error } : {}
+		};
+	}
+	async contextFor(intent) {
+		const payment = intent.payment_id ? this.payments.get(intent.payment_id) : null;
+		if (!payment) return null;
+		const adapter = this.adapterFor(payment);
+		if (!adapter) return null;
+		const result = this.intentResult(intent);
+		const reference = result.metadata.attempt_reference;
+		if (!reference) return null;
+		const signal = new AbortController().signal;
+		const a1 = [
+			payment,
+			intent.totals.total,
+			reference,
+			signal
+		];
+		return {
+			payment,
+			adapter,
+			result,
+			ctx: await this.buildContext(...a1),
+			placedAt: intent.placed_at
+		};
+	}
+	/** After the order is injected: confirm PENDING `confirm_after_inject`. */
+	async confirmAfterInject() {
+		const intents = this.deps.getOrder().payment_intents;
+		const results = [];
+		for (const intent of intents) {
+			const metadata = record(intent.metadata);
+			if (intent.status !== "PENDING") continue;
+			if (metadata.confirm_after_inject !== true) continue;
+			const found = await this.contextFor(intent);
+			const confirm = found?.adapter.confirm;
+			if (!found || !confirm) continue;
+			const { payment, result, ctx, placedAt } = found;
+			const confirmed = await confirm(ctx, result).catch((error) => {
+				const err = createPaymentError("UNKNOWN", { provider_message: error instanceof Error ? error.message : null });
+				const m1 = {
+					...result.metadata,
+					error: err
+				};
+				return {
+					...result,
+					status: "FAILED",
+					metadata: m1,
+					error: err
+				};
+			});
+			const next = {
+				...confirmed,
+				metadata: { ...confirmed.metadata }
+			};
+			delete next.metadata.confirm_after_inject;
+			await this.recordResult(payment, next, placedAt);
+			results.push(next);
+		}
+		return results;
+	}
+	/**
+	* Undo charges of this order (injection failed or split payment
+	* abandoned): cancel, refund or flag for manual reversal.
+	*/
+	async reverseAll() {
+		const intents = this.deps.getOrder().payment_intents;
+		const outcomes = [];
+		for (const intent of intents) {
+			const confirm = record(intent.metadata).confirm_after_inject === true;
+			if (!(intent.status === "PAID" || confirm) || intent.status === "IDLE") continue;
+			const found = await this.contextFor(intent);
+			if (!found) continue;
+			const { payment, adapter, result, ctx, placedAt } = found;
+			const outcome = await reversePayment(adapter, ctx, result);
+			const reversed = withOrderAmount(outcome.result, intent.totals.total);
+			await this.recordResult(payment, reversed, placedAt);
+			outcomes.push(outcome);
+		}
+		return outcomes;
+	}
+	/** Runs a terminal operation (init, test, closeBatch, status, extra). */
+	async runTerminal(payment, key) {
+		const terminal = this.adapterFor(payment)?.terminal;
+		if (!terminal) return {
+			ok: false,
+			message: "No terminal operations"
+		};
+		const base = {
+			init: terminal.init,
+			test: terminal.test
+		};
+		const more = {
+			closeBatch: terminal.closeBatch,
+			status: terminal.status
+		};
+		const named = {
+			...base,
+			...more
+		};
+		const extra = terminal.extra?.find((item) => item.key === key)?.run;
+		const operation = named[key] ?? extra;
+		if (!operation) return {
+			ok: false,
+			message: `Unknown operation ${key}`
+		};
+		const signal = new AbortController().signal;
+		const reference = createAttemptReference();
+		const result = await operation(toTerminalContext(await this.buildContext(payment, 0, reference, signal))).catch(toFailure);
+		if (!result.ok) await this.reportTerminal(payment, key, result);
+		return result;
+	}
+	async reportTerminal(payment, operation, result) {
+		const fallback = createPaymentError("UNKNOWN");
+		const error = result.error ?? {
+			...fallback,
+			message: result.message ?? fallback.message
+		};
+		const body = {
+			operation,
+			device_id: this.options.deviceId ?? null,
+			error
+		};
+		const report = services.payments.terminalFailure;
+		await report(payment.id, body, this.deps.http).catch(() => void 0);
+	}
+};
+//#endregion
 //#region src/schedule/schedule.ts
 const DAY_OF_WEEK = [
 	"sunday",
@@ -3643,9 +4787,11 @@ var Order = class Order {
 	externalNotify;
 	http;
 	flush;
+	payments;
 	constructor(config, notify) {
 		this.draft = cloneOrder(config.order);
 		this.synced = cloneOrder(config.order);
+		this.rememberLogScope();
 		this.persisted = config.persisted;
 		this.http = config.http;
 		this.externalNotify = notify;
@@ -3669,6 +4815,16 @@ var Order = class Order {
 			fresh: config.fresh ?? false,
 			sleep: config.sleep
 		});
+		this.payments = new PaymentSession({
+			getOrder: () => this.draft,
+			placeOrder: (input) => this.placeOrder(input),
+			applyOrder: (next) => {
+				this.draft = cloneOrder(next);
+				this.synced = cloneOrder(next);
+				this.notify();
+			},
+			http: this.http
+		});
 	}
 	/**
 	* Opens a cart session: reuses an existing OPEN order for the scope, or a
@@ -3881,6 +5037,12 @@ var Order = class Order {
 		});
 		this.commitLines({ lines });
 	}
+	rememberLogScope() {
+		captureLogScope({
+			...this.draft,
+			brand_id: this.draft.brand_id ?? null
+		});
+	}
 	setScope(scope) {
 		if (this.deleted) return;
 		this.draft = {
@@ -3890,6 +5052,7 @@ var Order = class Order {
 			fulfillment_id: scope.fulfillment_id ?? this.draft.fulfillment_id,
 			brand_id: scope.brand_id === void 0 ? this.draft.brand_id : optionalBrandId(scope.brand_id)
 		};
+		this.rememberLogScope();
 		this.scheduleAfterMutate();
 	}
 	/** Shallow-merges into order metadata; `null` values are kept as-is. */
@@ -4004,6 +5167,50 @@ var Order = class Order {
 		this.synced = cloneOrder(next);
 		this.notify();
 	}
+	/** Installed `@fire-spark/payments-*` adapters (provider + method). */
+	setPaymentAdapters(adapters) {
+		this.payments.setAdapters(adapters);
+	}
+	/** Template modal/sheet the adapters use to talk to the customer. */
+	setPaymentUI(ui) {
+		this.payments.setUI(ui);
+	}
+	/** Persistent device storage (terminal keys, last batch close). */
+	setPaymentStorage(storage) {
+		this.payments.setStorage(storage);
+	}
+	/** Environment, collect point and this device's `payment_settings`. */
+	setPaymentOptions(options) {
+		this.payments.setOptions(options);
+	}
+	/** Merchant payments with an adapter installed and configured here. */
+	getPaymentOptions(payments) {
+		return this.payments.available(payments);
+	}
+	/** Device fields still missing for `payment` on this device. */
+	getMissingPaymentFields(payment) {
+		return this.payments.missingFields(payment);
+	}
+	/** Order total minus PAID (and confirm-after-inject) intents. */
+	getRemainingAmount() {
+		return this.payments.remaining();
+	}
+	/** Places the order if needed and charges `payment` (all or part). */
+	pay(payment, options) {
+		return this.payments.pay(payment, options);
+	}
+	/** Confirms intents that waited for the order injection. */
+	confirmPaymentsAfterInject() {
+		return this.payments.confirmAfterInject();
+	}
+	/** Cancels or refunds every charge of this order (or flags it manual). */
+	reversePayments() {
+		return this.payments.reverseAll();
+	}
+	/** Terminal admin operation (init, test, closeBatch, status, extra). */
+	runPaymentTerminal(payment, key) {
+		return this.payments.runTerminal(payment, key);
+	}
 	/** Applies lines/redeem, replaying redemption steps and totals. */
 	commitLines(patch) {
 		const lines = patch.lines ?? this.draft.lines;
@@ -4822,6 +6029,201 @@ const collectOrderLineDiffs = (input) => {
 	return diffs;
 };
 //#endregion
+//#region src/logs/serializeError.ts
+const UNKNOWN_MESSAGE = "Unknown error";
+const MAX_CAUSE_DEPTH = 3;
+const safeStringify = (value) => {
+	try {
+		const json = JSON.stringify(value);
+		return json === void 0 ? String(value) : json;
+	} catch {
+		return String(value);
+	}
+};
+const messageOf = (value) => {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object" && "message" in value) {
+		const message = value.message;
+		if (typeof message === "string") return message;
+	}
+	if (value === void 0) return "";
+	return safeStringify(value);
+};
+/** `TypeError: boom ← caused by: Error: socket closed` style chain. */
+const describeCause = (cause, depth = 0) => {
+	if (cause instanceof Error) {
+		const head = `${cause.name}: ${cause.message}`;
+		const inner = cause.cause;
+		if (inner === void 0 || depth >= MAX_CAUSE_DEPTH) return head;
+		return `${head} ← caused by: ${describeCause(inner, depth + 1)}`;
+	}
+	return messageOf(cause);
+};
+const nameOf = (value) => {
+	if (value instanceof Error) return value.name;
+	if (value && typeof value === "object" && "name" in value) {
+		const name = value.name;
+		if (typeof name === "string") return name;
+	}
+	return null;
+};
+const stackOf = (value) => {
+	if (value && typeof value === "object" && "stack" in value) {
+		const stack = value.stack;
+		if (typeof stack === "string" && stack) return stack;
+	}
+	return null;
+};
+const causeOf = (value) => {
+	if (!value || typeof value !== "object" || !("cause" in value)) return null;
+	const cause = value.cause;
+	if (cause === void 0 || cause === null) return null;
+	return describeCause(cause) || null;
+};
+/** Accepts anything a `catch` can receive. */
+const serializeError = (value) => {
+	const message = truncate(messageOf(value).trim() || UNKNOWN_MESSAGE, LOG_LIMITS.message);
+	const name = nameOf(value);
+	const stack = stackOf(value);
+	const cause = causeOf(value);
+	const e1 = { name: name ? truncate(name, LOG_LIMITS.errorName) : null };
+	const e2 = { stack: stack ? truncate(stack, LOG_LIMITS.stack) : null };
+	const e3 = { cause: cause ? truncate(cause, LOG_LIMITS.cause) : null };
+	return {
+		message,
+		error: {
+			...e1,
+			...e2,
+			...e3
+		}
+	};
+};
+//#endregion
+//#region src/logs/log.ts
+const LOGS_PATH = "/api/storefront/v1/logs";
+const POS_LOGS_PATH = "/api/storefront/v1/pos/logs";
+const FLUSH_DELAY_MS = 500;
+let queue = [];
+let timer = null;
+const optionalText = (value, max) => {
+	const trimmed = value?.trim();
+	if (!trimmed) return null;
+	return truncate(trimmed, max);
+};
+const buildEntry = (level, message, options, error) => {
+	const text = typeof message === "string" ? message.trim() : "";
+	if (!text) return null;
+	const b1 = {
+		level,
+		message: truncate(text, LOG_LIMITS.message)
+	};
+	const b2 = { alias: optionalText(options.alias, LOG_LIMITS.alias) };
+	const b3 = { detail: optionalText(options.detail, LOG_LIMITS.detail) };
+	const b4 = { status: optionalText(options.status, LOG_LIMITS.status) };
+	const b5 = {
+		error: error ?? null,
+		occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...getLogContext(),
+		...b5
+	};
+};
+const isAuthConfigured = () => {
+	try {
+		getBaseUrl();
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Browsers cap keepalive bodies at 64 KB; bigger batches send normally. */
+const postInit = (body) => {
+	return {
+		method: "POST",
+		body,
+		keepalive: body.length < LOG_LIMITS.keepaliveBytes
+	};
+};
+const sendPos = async (device, logs) => {
+	const fetchImpl = device.http.fetchImpl ?? fetch;
+	const url = `${resolveBaseUrl(device.http.baseUrl)}${POS_LOGS_PATH}`;
+	const { device_uid, device_secret } = device;
+	const body = JSON.stringify({
+		device_uid,
+		device_secret,
+		logs
+	});
+	const headers = { "Content-Type": "application/json" };
+	return (await fetchImpl(url, {
+		...postInit(body),
+		headers
+	})).ok;
+};
+const sendBatch = async (logs) => {
+	try {
+		const device = getPosLogDevice();
+		if (device) return await sendPos(device, logs);
+		if (!isAuthConfigured()) return false;
+		await storefrontJson(LOGS_PATH, postInit(JSON.stringify({ logs })));
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Sends queued logs now; resolves once every batch has been attempted. */
+const flushLogs = async () => {
+	if (timer) clearTimeout(timer);
+	timer = null;
+	const pending = queue;
+	queue = [];
+	const jobs = [];
+	for (let i = 0; i < pending.length; i += LOG_LIMITS.batch) {
+		const chunk = pending.slice(i, i + LOG_LIMITS.batch);
+		const entries = chunk.map((item) => item.entry);
+		const job = sendBatch(entries).then((sent) => {
+			for (const item of chunk) item.resolve(sent);
+		});
+		jobs.push(job);
+	}
+	await Promise.all(jobs);
+};
+const enqueue = (entry) => {
+	return new Promise((resolve) => {
+		queue.push({
+			entry,
+			resolve
+		});
+		if (queue.length >= LOG_LIMITS.batch) {
+			flushLogs();
+			return;
+		}
+		if (!timer) timer = setTimeout(() => void flushLogs(), FLUSH_DELAY_MS);
+	});
+};
+/**
+* Reports a log to the merchant dashboard with the SDK's current context
+* (channel, fulfillment, store, brand, device). Never throws; resolves to
+* `false` when the log could not be delivered.
+*/
+const log = (level, message, options = {}) => {
+	const entry = buildEntry(level, message, options);
+	if (!entry) return Promise.resolve(false);
+	return enqueue(entry);
+};
+/** `log("error", …)` with message, name, stack and cause read from `error`. */
+const logError = (error, options = {}) => {
+	const { message, error: info } = serializeError(error);
+	const entry = buildEntry("error", message, options, info);
+	if (!entry) return Promise.resolve(false);
+	return enqueue(entry);
+};
+//#endregion
 //#region src/rules/assert.ts
 const assert = (value, message) => {
 	if (value) return;
@@ -4935,7 +6337,8 @@ const MULTI_CUSTOM_TYPES = [
 	"Fulfillments",
 	"Stores",
 	"Channels",
-	"Brands"
+	"Brands",
+	"Payments"
 ];
 const isMultiCustomType = (type) => {
 	return MULTI_CUSTOM_TYPES.includes(type);
@@ -5821,6 +7224,10 @@ var RulesEngine = class {
 		throw new Error(msg);
 	};
 	assertCustom = (condition) => {
+		if (condition.type === "Payment" || condition.type === "Payments") {
+			const payment = this.getDependency("payment", condition.type);
+			return matchCustom(condition, payment.id);
+		}
 		const order = this.getDependency("order", condition.type);
 		return assertCustom(condition, order);
 	};
@@ -6112,4 +7519,316 @@ const paymentMatchesClientConditions = (conditions, order, options) => {
 	return Boolean(engine.matchOrConditions(groups).match);
 };
 //#endregion
-export { DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, collectOrderLineDiffs, computeStartingPrice, countCartProducts, createSession, currentNodes, defaultConditionError, flattenMenuCategories, fromOrderLines, genId, genOrderId, getScheduleWindow, indexMenu, isCheckoutFieldFilled, isDeviceNotLinked, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isStorefrontNotFound, isVariantBase, listMenusStream, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, resolveCheckout, services, storefrontJson, toOrderLines, validateOrderAgainstMenu, visitedStates };
+//#region src/card/card.ts
+const DEFAULT_GAPS = [
+	4,
+	8,
+	12,
+	16
+];
+const spec = (s) => s;
+/** Detection order matters: narrower prefixes first. */
+const CARD_BRANDS = [
+	spec({
+		brand: "amex",
+		label: "American Express",
+		pattern: /^3[47]/,
+		lengths: [15],
+		gaps: [4, 10],
+		cvcLengths: [4]
+	}),
+	spec({
+		brand: "diners",
+		label: "Diners Club",
+		pattern: /^3(?:0[0-59]|[689])/,
+		lengths: [
+			14,
+			16,
+			19
+		],
+		gaps: [4, 10],
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "jcb",
+		label: "JCB",
+		pattern: /^35(?:2[89]|[3-8])/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "visa",
+		label: "Visa",
+		pattern: /^4/,
+		lengths: [
+			13,
+			16,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "mastercard",
+		label: "Mastercard",
+		pattern: /^(?:5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)/,
+		lengths: [16],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "discover",
+		label: "Discover",
+		pattern: /^(?:6011|64[4-9]|65)/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "unionpay",
+		label: "UnionPay",
+		pattern: /^62/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	})
+];
+const UNKNOWN_SPEC = {
+	brand: "unknown",
+	label: "",
+	pattern: /^$/,
+	lengths: [
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19
+	],
+	gaps: DEFAULT_GAPS,
+	cvcLengths: [3, 4]
+};
+const last = (values) => values[values.length - 1] ?? 0;
+const cardDigits = (value) => value.replace(/\D/g, "");
+/** Mod-10 checksum. Expects digits only (non-digits are ignored). */
+const luhnCheck = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return false;
+	let sum = 0;
+	for (let i = 0; i < digits.length; i++) {
+		let digit = Number(digits[digits.length - 1 - i]);
+		if (i % 2 === 1) {
+			digit *= 2;
+			if (digit > 9) digit -= 9;
+		}
+		sum += digit;
+	}
+	return sum % 10 === 0;
+};
+const cardBrandSpec = (brand) => {
+	return CARD_BRANDS.find((item) => item.brand === brand) ?? UNKNOWN_SPEC;
+};
+/** Brand from the typed prefix; `unknown` until the prefix is unambiguous. */
+const detectCardBrand = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return "unknown";
+	return CARD_BRANDS.find((item) => item.pattern.test(digits))?.brand ?? "unknown";
+};
+const toPaymentCardBrand = (brand) => {
+	if (brand === "jcb" || brand === "unionpay" || brand === "unknown") return "other";
+	return brand;
+};
+const cardNumberMaxLength = (brand) => {
+	return last(cardBrandSpec(brand).lengths);
+};
+/** Space positions for a PAN of `length` digits (Diners 14 → 4-6-4). */
+const cardNumberGaps = (brand, length) => {
+	if (brand === "diners" && length > 14) return DEFAULT_GAPS;
+	return cardBrandSpec(brand).gaps;
+};
+/** Digits only, capped to the brand max length, grouped with spaces. */
+const formatCardNumber = (value) => {
+	const raw = cardDigits(value);
+	const brand = detectCardBrand(raw);
+	const digits = raw.slice(0, cardNumberMaxLength(brand));
+	const gaps = cardNumberGaps(brand, digits.length);
+	let out = "";
+	for (let i = 0; i < digits.length; i++) {
+		if (i > 0 && gaps.includes(i)) out += " ";
+		out += digits[i];
+	}
+	return out;
+};
+/** Caret index in `formatted` right after its `digitCount`-th digit. */
+const caretAfterDigits = (formatted, digitCount) => {
+	if (digitCount <= 0) return 0;
+	let seen = 0;
+	for (let i = 0; i < formatted.length; i++) {
+		if (/\d/.test(formatted[i] ?? "")) seen += 1;
+		if (seen === digitCount) return i + 1;
+	}
+	return formatted.length;
+};
+const validateCardNumber = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return "required";
+	const { lengths } = cardBrandSpec(detectCardBrand(digits));
+	if (digits.length < (lengths[0] ?? 0)) return "incomplete";
+	if (!lengths.includes(digits.length)) return "incomplete";
+	if (!luhnCheck(digits)) return "invalid";
+	return null;
+};
+/** Ready to move focus on: a valid length for the brand that passes Luhn. */
+const isCardNumberComplete = (value) => {
+	const digits = cardDigits(value);
+	const brand = detectCardBrand(digits);
+	if (brand === "unknown") return digits.length === cardNumberMaxLength(brand) && luhnCheck(digits);
+	return validateCardNumber(digits) === null;
+};
+/** Full-length PAN that fails Luhn — safe to flag while the user types. */
+const isCardNumberDefinitelyInvalid = (value) => {
+	const digits = cardDigits(value);
+	const max = cardNumberMaxLength(detectCardBrand(digits));
+	return digits.length === max && !luhnCheck(digits);
+};
+const SEPARATED_EXPIRY = /^(\d{1,2})\s*[/\-.\s]\s*(\d*)$/;
+const shortYear = (year) => {
+	if (year.length >= 4) return year.slice(2, 4);
+	return year.slice(0, 2);
+};
+const joinExpiry = (month, year) => {
+	if (!year) return month;
+	return `${month}/${year}`;
+};
+/**
+* `MM/YY` as the user types or pastes: `4` → `04`, `13` → `01/3`,
+* `12/2030` → `12/30`. The slash only appears once a year digit exists so
+* backspace never gets stuck.
+*/
+const formatExpiry = (value) => {
+	const raw = value.trim();
+	const separated = SEPARATED_EXPIRY.exec(raw);
+	if (separated) {
+		const [, monthPart = "", yearPart = ""] = separated;
+		const month = monthPart.length === 1 && monthPart !== "0" ? `0${monthPart}` : monthPart;
+		return joinExpiry(month, shortYear(yearPart));
+	}
+	const all = cardDigits(raw);
+	const digits = all.length === 6 ? `${all.slice(0, 2)}${all.slice(4)}` : all;
+	const first = digits[0];
+	if (!first) return "";
+	if (Number(first) > 1) return joinExpiry(`0${first}`, digits.slice(1, 3));
+	if (digits.length === 1) return digits;
+	const month = digits.slice(0, 2);
+	if (Number(month) > 12) return joinExpiry(`0${first}`, digits.slice(1, 3));
+	return joinExpiry(month, digits.slice(2, 4));
+};
+const parseExpiry = (value) => {
+	const match = /^(\d{2})\/(\d{2})$/.exec(value.trim());
+	if (!match) return null;
+	return {
+		month: Number(match[1]),
+		year: 2e3 + Number(match[2])
+	};
+};
+const isExpiryComplete = (value) => {
+	return /^\d{2}\/\d{2}$/.test(value.trim());
+};
+const MAX_EXPIRY_YEARS = 20;
+const validateExpiry = (value, now = /* @__PURE__ */ new Date()) => {
+	if (!value.trim()) return "required";
+	const parsed = parseExpiry(value);
+	if (!parsed) return "incomplete";
+	const { month, year } = parsed;
+	if (month < 1 || month > 12) return "invalid_month";
+	const currentYear = now.getFullYear();
+	const currentMonth = now.getMonth() + 1;
+	if (year < currentYear) return "expired";
+	if (year === currentYear && month < currentMonth) return "expired";
+	if (year > currentYear + MAX_EXPIRY_YEARS) return "too_far";
+	return null;
+};
+const cvcMaxLength = (brand) => {
+	return last(cardBrandSpec(brand).cvcLengths);
+};
+const formatCvc = (value, brand) => {
+	return cardDigits(value).slice(0, cvcMaxLength(brand));
+};
+const validateCvc = (value, brand) => {
+	const digits = cardDigits(value);
+	if (!digits) return "required";
+	if (!cardBrandSpec(brand).cvcLengths.includes(digits.length)) return "incomplete";
+	return null;
+};
+const isCvcComplete = (value, brand) => {
+	return cardDigits(value).length === cvcMaxLength(brand);
+};
+const CARDHOLDER_CHARS = /^[\p{L}\p{M}][\p{L}\p{M}'’. -]*$/u;
+const CARDHOLDER_MAX = 100;
+const normalizeCardholderName = (value) => {
+	return value.trim().replace(/\s+/g, " ");
+};
+const validateCardholderName = (value) => {
+	const name = normalizeCardholderName(value);
+	if (!name) return "required";
+	if (!CARDHOLDER_CHARS.test(name)) return "invalid_chars";
+	if (name.replace(/[^\p{L}]/gu, "").length < 2) return "too_short";
+	if (name.length > CARDHOLDER_MAX) return "too_long";
+	return null;
+};
+const previewLength = (brand) => {
+	if (brand === "amex") return 15;
+	if (brand === "diners") return 14;
+	return 16;
+};
+/**
+* Digit slots for a card preview, grouped like the formatted number. Middle
+* digits are masked as `•`; first and last groups stay readable.
+*/
+const cardPreviewGroups = (value) => {
+	const raw = cardDigits(value);
+	const brand = detectCardBrand(raw);
+	const digits = raw.slice(0, cardNumberMaxLength(brand));
+	const total = Math.max(previewLength(brand), digits.length);
+	const gaps = cardNumberGaps(brand, total);
+	const groups = [];
+	let group = [];
+	for (let i = 0; i < total; i++) {
+		if (i > 0 && gaps.includes(i)) {
+			groups.push(group);
+			group = [];
+		}
+		const digit = digits[i];
+		const masked = i >= 4 && i < total - 4;
+		if (digit === void 0) group.push({
+			char: "",
+			filled: false
+		});
+		else group.push({
+			char: masked ? "•" : digit,
+			filled: true
+		});
+	}
+	groups.push(group);
+	return groups;
+};
+//#endregion
+export { CARD_BRANDS, DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, serializeError, services, setLineQuantity, storefrontJson, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, visitedStates };