@stewardhq/sdk 0.3.0 → 0.6.0

package/dist/index.js

@@ -1,12 +1,640 @@
-import { $ as CurrencySchema, A as EMAIL_LOCALES, B as NotificationEmailsSchema, C as BillingProfileKindSchema, D as SubscriptionSummarySchema, E as SubscriptionStatusSchema, F as EmailSettingsPatchSchema, G as emailTemplateOf, H as billingPageUrl, I as EmailSettingsSchema, J as uniqueEmails, K as emailTemplateSettings, L as EmailTemplateSchema, M as EMAIL_TEMPLATE_BY_EVENT, N as EmailExtraTextSchema, O as BILLING_PATH_PLACEHOLDERS, P as EmailSenderSchema, Q as CodeSchema, R as EmailTemplateSettingsSchema, S as AccountUpsertInputSchema, T as EntitlementSnapshotSchema, U as emailLocaleOf, V as applyEmailSettingsPatch, W as emailRecipients, X as ActorRefSchema, Y as API_VERSION, Z as AmountMinorSchema, _ as AccountProfileStateSchema, a as EVENT_TYPES, at as ErrorResponseSchema, b as AccountStateSchema, c as PING_EVENT_TYPE, ct as IntervalSchema, d as ACCOUNT_INCLUDES, et as DateTimeSchema, f as AccessStateSchema, g as AccountOpenCheckoutSchema, h as AccountLocaleSchema, i as EVENT_DETAIL_SCHEMAS, it as ErrorCategorySchema, j as EMAIL_TEMPLATES, k as BillingPathSchema, l as PingSchema, lt as MetadataSchema, m as AccountDunningStateSchema, n as ApiVersionSchema, nt as EntitlementValueSchema, o as EventIdSchema, ot as ExternalRefSchema, p as AccountDeleteResponseSchema, q as isEmailRelevant, r as BillingEventSchema, rt as EntitlementsSchema, s as LEGACY_EVENT_TYPES, st as IdSchema, t as AnyBillingEventSchema, tt as ERROR_CATEGORIES, u as isEventType, v as AccountScheduledChangeSchema, w as BillingProfileSchema, x as AccountSubscriptionStateSchema, y as AccountSchema, z as MAX_NOTIFICATION_EMAILS } from "./_chunks/events.js";
-import { $ as InvoiceVoidResponseSchema, $t as PriceSchema, A as WebhookSecretSchema, At as checkoutRedirectUrl, B as errorCodeSpec, Bt as TtlMinutesSchema, C as WEBHOOK_SECRET_PREFIX, Ct as CheckoutSessionCreateInputSchema, D as WebhookEndpointSchema, Dt as ConsentSchema, E as WebhookEndpointRotateInputSchema, Et as CheckoutStatusSchema, F as PlanSetModeSchema, Ft as ProductSettingsPatchSchema, G as CheckoutSessionResponseSchema, Gt as AccountsRefreshResultSchema, H as AccountDetailSchema, Ht as applySettingsPatch, I as PlanSetResponseSchema, It as ProductSettingsSchema, J as HEADER_API_VERSION, Jt as CatalogSyncResultSchema, K as GrantCreateResponseSchema, Kt as CatalogSchema, L as PlanSetWarningSchema, Lt as ReturnOriginSchema, M as webhookEndpointUrlProblem, Mt as BrandingSchema, N as PLAN_SET_MODES, Nt as DEFAULT_CHECKOUT_TTL_MINUTES, O as WebhookEndpointStatusSchema, Ot as MAX_CHECKOUT_CONSENT_DOCS, P as PlanSetInputSchema, Pt as DEFAULT_PORTAL_TTL_MINUTES, Q as InvoiceIssueResponseSchema, Qt as PriceDefSchema, R as ResyncResultSchema, Rt as SETTINGS_LOCALES, S as WEBHOOK_ENDPOINT_STATUSES, St as CheckoutPrefillSchema, T as WebhookEndpointListSchema, Tt as CheckoutSessionSchema, U as AccountUpsertResponseSchema, Ut as isReturnUrlAllowed, V as isKnownErrorCode, Vt as WebUrlSchema, W as CancelSubscriptionResponseSchema, Wt as returnOriginsOf, X as HEADER_REQUEST_ID, Xt as FeatureTypeSchema, Y as HEADER_IDEMPOTENCY_KEY, Yt as FeatureDefSchema, Z as HEADER_SDK, Zt as PlanDefSchema, _ as emailReadinessOf, _t as PORTAL_SESSION_ERRORS, a as DOCTOR_SEVERITIES, at as InvoiceVoidInputSchema, b as DEFAULT_ENDPOINT_EVENT_TYPES, bt as CHECKOUT_ERRORS, c as DoctorEndpointSchema, ct as ManualInvoiceLineInputSchema, d as DoctorReportSchema, dt as CancelSubscriptionInputSchema, et as ManualInvoiceResponseSchema, f as DoctorSettingsSchema, ft as GrantCreateInputSchema, g as buildDoctorReport, gt as SubscriptionSchema, h as DoctorWarningSchema, ht as StatsSchema, i as DOCTOR_REQUIRED_LEGAL_LINKS, it as InvoiceStatusSchema, j as generateWebhookSecret, jt as BrandingPatchSchema, k as WebhookLastDeliverySchema, kt as ProviderPayloadSchema, l as DoctorHostedSchema, lt as manualInvoiceTotals, m as DoctorUnsellablePriceSchema, mt as PaymentSchema, n as DOCTOR_PROVIDER_ENVIRONMENTS, nt as InvoiceLineSchema, o as DoctorCatalogSchema, ot as MANUAL_INVOICE_MAX_AMOUNT_MINOR, p as DoctorSeveritySchema, pt as GrantSchema, q as HEADER_ACTOR_REF, qt as CatalogSyncInputSchema, r as DOCTOR_REQUIRED_BRANDING, rt as InvoiceSchema, s as DoctorEmailsSchema, st as ManualInvoiceInputSchema, t as DOCTOR_PENDING_BACKLOG_MS, tt as InvoiceIssueInputSchema, u as DoctorProviderSchema, ut as splitInclusiveTax, v as endpointDiagnosisOf, vt as PortalSessionCreateInputSchema, w as WebhookEndpointCreateInputSchema, wt as CheckoutSessionCreatedSchema, x as EventTypeSchema, xt as CheckoutConsentInputSchema, y as hostedReadinessOf, yt as PortalSessionSchema, z as ERROR_CODES, zt as SettingsLocaleSchema } from "./_chunks/src.js";
-import { a as isGrantActive, i as LIVE_SUBSCRIPTION_STATUSES, n as isValidTckn, o as isLiveSubscriptionStatus, r as isValidVkn, s as resolveEntitlements, t as isE164 } from "./_chunks/validators.js";
-import { t as createSteward } from "./_chunks/steward.js";
+import { $ as emailLocaleOf, $t as MeteredPriceSchema, A as SubscriptionStatusSchema, An as hasControlCharacters, At as METER_FILTER_MAX_CONDITIONS, B as EmailSenderSchema, Bn as EntitlementsSchema, Bt as MeterCreditEntryKindSchema, C as AccountSchema, Cn as EventNameSchema, Ct as DEFAULT_METER_LOW_AT, D as BillingProfileKindSchema, Dn as IngestEventSchema, Dt as METER_AGGREGATION_KINDS, E as AccountUpsertInputSchema, En as INGEST_REJECT_CODES, Et as MAX_METER_UNITS, F as EMAIL_LOCALES, Fn as CodeSchema, Ft as MeterAggregationSchema, G as InvoicePaymentDueEmailSchema, Gn as INVOICE_PAYMENT_STATUSES, Gt as MeterLabelSchema, H as EmailSettingsSchema, Hn as ErrorResponseSchema, Ht as MeterCreditPropertiesSchema, I as EMAIL_PAYLOAD_SCHEMAS, In as CurrencySchema, It as MeterChargeLineSchema, J as NotificationEmailsSchema, Jn as InvoiceBillingReasonSchema, Jt as MeterPeriodSchema, K as MAX_NOTIFICATION_EMAILS, Kn as IdSchema, Kt as MeterLowAtSchema, L as EMAIL_TEMPLATES, Ln as DateTimeSchema, Lt as MeterChargeListSchema, M as BILLING_PATH_PLACEHOLDERS, Mn as API_VERSION, Mt as METER_FILTER_OPERATORS, N as BankTransferInstructionsEmailSchema, Nn as ActorRefSchema, Nt as METER_PERIOD_STATUSES, O as BillingProfileSchema, On as IngestRejectCodeSchema, Ot as METER_CHARGE_STATUSES, P as BillingPathSchema, Pn as AmountMinorSchema, Pt as METER_STANDINGS, Q as billingPageUrl, Qt as MeteredPriceDefSchema, R as EMAIL_TEMPLATE_BY_EVENT, Rn as ERROR_CATEGORIES, Rt as MeterChargeSchema, S as AccountScheduledChangeSchema, Sn as EventMetadataValueSchema, St as CreditGrantInputSchema, T as AccountSubscriptionStateSchema, Tn as EventsIngestResultSchema, Tt as MAX_METERED_PRICE_PER_UNITS, U as EmailTemplateSchema, Un as ExternalRefSchema, Ut as MeterDefSchema, V as EmailSettingsPatchSchema, Vn as ErrorCategorySchema, Vt as MeterCreditEntrySchema, W as EmailTemplateSettingsSchema, Wn as INVOICE_BILLING_REASONS, Wt as MeterFilterSchema, X as PriceChangeNoticeMeteredRateSchema, Xn as MetadataSchema, Xt as MeterStandingSchema, Y as PriceChangeNoticeEmailSchema, Yn as InvoicePaymentStatusSchema, Yt as MeterPeriodStatusSchema, Z as applyEmailSettingsPatch, Zt as MeterUnitsSchema, _ as AccountMeterStateSchema, _n as EVENT_TIMESTAMP_MAX_AGE_DAYS, _t as isFeatureFlagBenefit, a as EVENT_TYPES, an as fromMicroUnits, at as uniqueEmails, b as AccountOpenInvoiceSchema, bn as EventMetadataKeySchema, bt as AccountMetersSchema, c as LEGACY_EVENT_TYPES, cn as parseMicroUnits, ct as BenefitDefSchema, d as isEventType, dn as EVENTS_INGEST_MAX_BYTES, dt as BenefitTypeSchema, en as canonicalMeterFilter, et as emailRecipients, f as ACCOUNT_INCLUDES, fn as EVENTS_INGEST_MAX_EVENTS, ft as CatalogBenefitSchema, g as AccountLocaleSchema, gn as EVENT_NAME_MAX_LENGTH, gt as featureValueMatchesType, h as AccountDunningStateSchema, hn as EVENT_METADATA_STRING_MAX_LENGTH, ht as MeterCreditBenefitDefSchema, i as EVENT_DETAIL_SCHEMAS, in as UNIT_DECIMALS, it as liveSubscriptionOf, j as SubscriptionSummarySchema, jn as isEventTimestampInRange, jt as METER_FILTER_MAX_DEPTH, k as EntitlementSnapshotSchema, kn as IngestRejectionSchema, kt as METER_CREDIT_ENTRY_KINDS, l as PING_EVENT_TYPE, ln as plainDecimalOf, lt as BenefitDescriptionSchema, m as AccountDeleteResponseSchema, mn as EVENT_METADATA_MAX_PAIRS, mt as FeatureFlagPropertiesSchema, n as ApiVersionSchema, nn as InvalidUnitValueError, nt as emailTemplateSettings, o as EventIdSchema, on as isMicroPrecise, ot as AccountBenefitSchema, p as AccessStateSchema, pn as EVENT_METADATA_KEY_MAX_LENGTH, pt as FeatureFlagBenefitDefSchema, q as NoticedMeteredRateSchema, qn as IntervalSchema, qt as MeterPeriodListSchema, r as BillingEventSchema, rn as MICRO_UNITS_PER_UNIT, rt as isEmailRelevant, s as FULL_STATE_EVENT_TYPES, sn as microToDecimalString, st as BENEFIT_TYPES, t as AnyBillingEventSchema, tn as meterFilterClauseOf, tt as emailTemplateOf, u as PingSchema, un as toMicroUnits, ut as BenefitSourceSchema, v as AccountMetersStateSchema, vn as EVENT_TIMESTAMP_MAX_SKEW_MINUTES, vt as isMeterCreditBenefit, w as AccountStateSchema, wn as EventsIngestInputSchema, wt as DecimalUnitsStringSchema, x as AccountProfileStateSchema, xn as EventMetadataSchema, xt as CatalogMeterSchema, y as AccountOpenCheckoutSchema, yn as EventExternalIdSchema, yt as AccountMeterSchema, z as EmailExtraTextSchema, zn as EntitlementValueSchema, zt as MeterChargeStatusSchema } from "./_chunks/events.js";
+import { $ as rolloverOf, $n as MAX_CATALOG_BENEFITS, $t as CheckoutSessionCreatedSchema, A as WebhookEndpointRotateInputSchema, An as MeteringSettingsPatchSchema, At as InvoiceWaiveInputSchema, B as PlanSetResponseSchema, Bn as applySettingsPatch, Bt as PaymentSchema, C as hostedReadinessOf, Cn as DEFAULT_PORTAL_TTL_MINUTES, Ct as InvoiceIssueInputSchema, D as WEBHOOK_SECRET_PREFIX, Dn as LateGraceMinutesSchema, Dt as InvoiceSchema, E as WEBHOOK_ENDPOINT_STATUSES, En as EventsSettingsSchema, Et as InvoicePaymentSessionSchema, F as generateWebhookSecret, Fn as ReturnOriginSchema, Ft as splitInclusiveTax, G as contributionOf, Gn as returnOriginsOf, Gt as PortalSessionCreateInputSchema, H as ResyncResultSchema, Hn as eventsSettingsOf, Ht as SubscriptionChangeInputSchema, I as webhookEndpointUrlProblem, In as SETTINGS_LOCALES, It as CancelSubscriptionInputSchema, J as meterCreditsOf, Jn as CatalogSchema, Jt as BankTransferRecordedSchema, K as matchesFilter, Kn as AccountsRefreshResultSchema, Kt as PortalSessionSchema, L as PLAN_SET_MODES, Ln as SettingsLocaleSchema, Lt as GrantCreateInputSchema, M as WebhookEndpointStatusSchema, Mn as PaymentDueDaysSchema, Mt as ManualInvoiceInputSchema, N as WebhookLastDeliverySchema, Nn as ProductSettingsPatchSchema, Nt as ManualInvoiceLineInputSchema, O as WebhookEndpointCreateInputSchema, On as METER_CHARGE_MODES, Ot as InvoiceStatusSchema, P as WebhookSecretSchema, Pn as ProductSettingsSchema, Pt as manualInvoiceTotals, Q as rateOverage, Qn as FeatureTypeSchema, Qt as CheckoutSessionCreateInputSchema, R as PlanSetInputSchema, Rn as TtlMinutesSchema, Rt as GrantSchema, S as endpointDiagnosisOf, Sn as DEFAULT_PAYMENT_DUE_DAYS, St as UncancelSubscriptionResponseSchema, T as EventTypeSchema, Tn as EventsSettingsPatchSchema, Tt as InvoicePaymentSessionCreateInputSchema, U as addUtcMonths, Un as isReturnUrlAllowed, Ut as SubscriptionSchema, V as PlanSetWarningSchema, Vn as billingSettingsOf, Vt as StatsSchema, W as consumptionOf, Wn as meteringSettingsOf, Wt as PORTAL_SESSION_ERRORS, X as overageOf, Xn as CatalogSyncResultSchema, Xt as CheckoutConsentInputSchema, Y as overageCapReached, Yn as CatalogSyncInputSchema, Yt as CHECKOUT_ERRORS, Z as periodBoundsOf, Zn as FeatureDefSchema, Zt as CheckoutPrefillSchema, _ as DoctorSeveritySchema, _n as DEFAULT_CHECKOUT_TTL_MINUTES, _t as InvoiceVoidResponseSchema, a as DOCTOR_ROLLUP_LAG_WARN_SECONDS, an as PAYMENT_METHODS, ar as PriceDefSchema, at as AccountUpsertResponseSchema, b as buildDoctorReport, bn as DEFAULT_METER_CHARGE_MODE, bt as MeResponseSchema, c as DoctorCatalogSchema, cn as checkoutRedirectUrl, ct as CheckoutSessionResponseSchema, d as DoctorEventsSchema, dn as BankTransferSettingsSchema, dt as HEADER_ACTOR_REF, en as CheckoutSessionSchema, er as MAX_CATALOG_METERED_PRICES, et as standingOf, f as DoctorHostedSchema, fn as BillingSettingsPatchSchema, ft as HEADER_API_VERSION, g as DoctorSettingsSchema, gn as DEFAULT_BANK_TRANSFER_PAYMENT_DAYS, gt as InvoiceIssueResponseSchema, h as DoctorReportSchema, hn as BrandingSchema, ht as HEADER_SDK, i as DOCTOR_REQUIRED_LEGAL_LINKS, in as MAX_CHECKOUT_CONSENT_DOCS, ir as PlanDefSchema, it as AccountDetailSchema, j as WebhookEndpointSchema, jn as MeteringSettingsSchema, jt as MANUAL_INVOICE_MAX_AMOUNT_MINOR, k as WebhookEndpointListSchema, kn as MeterChargeModeSchema, kt as InvoiceVoidInputSchema, l as DoctorEmailsSchema, ln as BankTransferPaymentDaysSchema, lt as CreditGrantResponseSchema, m as DoctorProviderSchema, mn as BrandingPatchSchema, mt as HEADER_REQUEST_ID, n as DOCTOR_PROVIDER_ENVIRONMENTS, nn as ConsentSchema, nr as MAX_PLAN_BENEFITS, nt as errorCodeSpec, o as DOCTOR_SEVERITIES, on as PaymentMethodSchema, or as PriceSchema, ot as CancelSubscriptionResponseSchema, p as DoctorOverageSchema, pn as BillingSettingsSchema, pt as HEADER_IDEMPOTENCY_KEY, q as meterChargeTotals, qn as CatalogPlanSchema, qt as BankTransferRecordInputSchema, r as DOCTOR_REQUIRED_BRANDING, rn as INDIVIDUAL_IDENTITY_PLACEHOLDER, rr as METERED_PRICE_TAX_MISMATCH, rt as isKnownErrorCode, s as DoctorBillingSchema, sn as ProviderPayloadSchema, st as ChangeSubscriptionResponseSchema, t as DOCTOR_PENDING_BACKLOG_MS, tn as CheckoutStatusSchema, tr as MAX_CATALOG_METERS, tt as ERROR_CODES, u as DoctorEndpointSchema, un as BankTransferSettingsPatchSchema, ut as GrantCreateResponseSchema, v as DoctorUnsellablePriceSchema, vn as DEFAULT_EVENT_RETENTION_DAYS, vt as InvoiceWaiveResponseSchema, w as DEFAULT_ENDPOINT_EVENT_TYPES, wn as EventRetentionDaysSchema, wt as InvoiceLineSchema, x as emailReadinessOf, xn as DEFAULT_MIN_INVOICE_MINOR, xt as STEWARD_CAPABILITIES, y as DoctorWarningSchema, yn as DEFAULT_LATE_GRACE_MINUTES, yt as ManualInvoiceResponseSchema, z as PlanSetModeSchema, zn as WebUrlSchema, zt as MAX_GRANT_BENEFITS } from "./_chunks/src.js";
+import { a as LIVE_SUBSCRIPTION_STATUSES, c as isLiveSubscriptionStatus, i as FEATURE_FLAG_BENEFIT_TYPE, l as resolveBenefits, n as isValidTckn, o as OVERRIDE_BENEFIT_SOURCE, r as isValidVkn, s as isGrantActive, t as isE164, u as resolveEntitlements } from "./_chunks/validators.js";
 import { a as StewardNetworkError, i as StewardError, n as StewardConfigError, r as StewardContractError, t as StewardApiError } from "./_chunks/errors.js";
+//#region ../contract/src/client.ts
+/**
+* `Retry-After` başlığını milisaniyeye çevirir: saniye (tam sayı) ya da HTTP
+* tarihi. Geçmiş tarih 0; okunamayan değer null.
+*/
+function parseRetryAfter(value, now = Date.now()) {
+	if (value === null || value === void 0) return null;
+	const trimmed = value.trim();
+	if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+	if (!/^[A-Za-z]/.test(trimmed)) return null;
+	const at = Date.parse(trimmed);
+	return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+const SDK_HEADER_VALUE = /^[\x21-\x7e][\x20-\x7e]{0,199}$/;
+function createBillingClient(options) {
+	const baseUrl = options.baseUrl.replace(/\/$/, "");
+	const doFetch = options.fetch ?? fetch;
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	if (options.sdk !== void 0 && !SDK_HEADER_VALUE.test(options.sdk)) throw new Error("sdk: yazdırılabilir ASCII, en çok 200 karakter");
+	function meta(res) {
+		const out = {};
+		const requestId = res.headers.get(HEADER_REQUEST_ID);
+		if (requestId) out.requestId = requestId;
+		if (res.status === 429 || res.status === 503) {
+			const retryAfterMs = parseRetryAfter(res.headers.get("retry-after"));
+			if (retryAfterMs !== null) out.retryAfterMs = retryAfterMs;
+		}
+		return out;
+	}
+	async function send(method, path, body, call, extraHeaders) {
+		const headers = {
+			authorization: `Bearer ${options.apiKey}`,
+			accept: "application/json",
+			[HEADER_API_VERSION]: API_VERSION,
+			...extraHeaders
+		};
+		if (options.sdk !== void 0) headers[HEADER_SDK] = options.sdk;
+		if (method !== "GET") headers[HEADER_IDEMPOTENCY_KEY] = call?.idempotencyKey ?? globalThis.crypto.randomUUID();
+		if (call?.actorRef) headers[HEADER_ACTOR_REF] = call.actorRef;
+		if (body !== void 0) headers["content-type"] = "application/json";
+		try {
+			return { res: await doFetch(`${baseUrl}${path}`, {
+				method,
+				headers,
+				...body !== void 0 ? { body: JSON.stringify(body) } : {},
+				signal: AbortSignal.timeout(timeoutMs)
+			}) };
+		} catch (error) {
+			return {
+				ok: false,
+				status: 0,
+				error: error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError") ? "timeout" : "network_error"
+			};
+		}
+	}
+	async function failure(res) {
+		const json = await res.json().catch(() => null);
+		const parsed = ErrorResponseSchema.safeParse(json);
+		const { requestId, retryAfterMs } = meta(res);
+		const common = {
+			...requestId !== void 0 ? { requestId } : {},
+			...retryAfterMs !== void 0 ? { retryAfterMs } : {}
+		};
+		if (parsed.success) {
+			const { error, message, category, retryable } = parsed.data;
+			const bodyRequestId = requestId === void 0 ? parsed.data.requestId : void 0;
+			return {
+				ok: false,
+				status: res.status,
+				error,
+				...message !== void 0 ? { message } : {},
+				...category !== void 0 ? { category } : {},
+				...retryable !== void 0 ? { retryable } : {},
+				...bodyRequestId !== void 0 ? { requestId: bodyRequestId } : {},
+				...common
+			};
+		}
+		return {
+			ok: false,
+			status: res.status,
+			error: `http_${res.status}`,
+			...common
+		};
+	}
+	function success(res, data) {
+		const { requestId } = meta(res);
+		return {
+			ok: true,
+			status: res.status,
+			data,
+			...requestId !== void 0 ? { requestId } : {}
+		};
+	}
+	function invalid(res) {
+		const { requestId } = meta(res);
+		return {
+			ok: false,
+			status: res.status,
+			error: "invalid_response",
+			...requestId !== void 0 ? { requestId } : {}
+		};
+	}
+	async function call(schema, method, path, body, opts) {
+		const sent = await send(method, path, body, opts);
+		if (!("res" in sent)) return sent;
+		const { res } = sent;
+		if (!res.ok) return failure(res);
+		const json = await res.json().catch(() => void 0);
+		const parsed = schema.safeParse(json);
+		if (!parsed.success) return invalid(res);
+		return success(res, parsed.data);
+	}
+	async function empty(method, path, opts) {
+		const sent = await send(method, path, void 0, opts);
+		if (!("res" in sent)) return sent;
+		const { res } = sent;
+		if (!res.ok) return failure(res);
+		return success(res, null);
+	}
+	/** GET with `If-None-Match` (the previous response's `etag`): 304 → `{notModified: true}`. */
+	async function conditional(schema, path, etag) {
+		const sent = await send("GET", path, void 0, void 0, etag !== void 0 ? { "if-none-match": etag } : void 0);
+		if (!("res" in sent)) return sent;
+		const { res } = sent;
+		const responseEtag = res.headers.get("etag");
+		if (res.status === 304) {
+			const current = responseEtag ?? etag;
+			return current === void 0 ? invalid(res) : success(res, {
+				notModified: true,
+				etag: current
+			});
+		}
+		if (!res.ok) return failure(res);
+		const parsed = schema.safeParse(await res.json().catch(() => void 0));
+		if (!parsed.success) return invalid(res);
+		return success(res, {
+			notModified: false,
+			etag: responseEtag,
+			body: parsed.data
+		});
+	}
+	const ref = (value) => encodeURIComponent(value);
+	return {
+		getCatalog: () => call(CatalogSchema, "GET", "/v1/catalog"),
+		syncCatalog: (input, opts) => call(CatalogSyncResultSchema, "PUT", "/v1/admin/catalog", input, opts),
+		upsertAccount: (accountRef, input, opts) => call(AccountUpsertResponseSchema, "PUT", `/v1/accounts/${ref(accountRef)}`, input, opts),
+		getAccount: (accountRef, include = []) => call(AccountDetailSchema, "GET", `/v1/accounts/${ref(accountRef)}${include.length ? `?include=${include.join(",")}` : ""}`),
+		/**
+		* Hesap durumu (`AccountState`). ETag = `"<version>"`; önceki yanıtın
+		* `etag`'i verilirse ve durum değişmediyse 304 → `{notModified: true}`.
+		*/
+		getAccountState: async (accountRef, opts = {}) => {
+			const result = await conditional(AccountStateSchema, `/v1/accounts/${ref(accountRef)}/state`, opts.etag);
+			if (!result.ok) return result;
+			const read = result.data;
+			return {
+				...result,
+				data: read.notModified ? read : {
+					notModified: false,
+					etag: read.etag,
+					state: read.body
+				}
+			};
+		},
+		/** Atomic plan (K6): active plan grants → one plan grant (`planCode: null` removes it); `mode` is accepted and ignored (M35: no rank), `warnings` is always empty. */
+		setPlan: (accountRef, input, opts) => call(PlanSetResponseSchema, "PUT", `/v1/accounts/${ref(accountRef)}/plan`, input, opts),
+		/** Saklı durumu `account.state_changed` (`cause: "resync"`) olarak yeniden yayınlar; version değişmez (202). */
+		resync: (accountRef, opts) => call(ResyncResultSchema, "POST", `/v1/accounts/${ref(accountRef)}/resync`, void 0, opts),
+		/** KVKK anonimleştirme (F4e): `{ref, deletedAt}`; silinmişse 410 `account_deleted`, canlı abonelikte 409 `subscription_active`. */
+		deleteAccount: (accountRef, opts) => call(AccountDeleteResponseSchema, "DELETE", `/v1/accounts/${ref(accountRef)}`, void 0, opts),
+		createCheckoutSession: (accountRef, input, opts) => call(CheckoutSessionCreatedSchema, "POST", `/v1/accounts/${ref(accountRef)}/checkout-sessions`, input, opts),
+		getCheckoutSession: (id) => call(CheckoutSessionResponseSchema, "GET", `/v1/checkout-sessions/${ref(id)}`),
+		createPortalSession: (accountRef, input = {}, opts) => call(PortalSessionSchema, "POST", `/v1/accounts/${ref(accountRef)}/portal-sessions`, input, opts),
+		cancelSubscription: (id, input, opts) => call(CancelSubscriptionResponseSchema, "POST", `/v1/subscriptions/${ref(id)}/cancel`, input, opts),
+		/**
+		* Billing core (MF9): schedules a plan/interval/price change for the next period (errors:
+		* `SubscriptionChangeInputSchema`: 409 `already_subscribed`, 422 `plan_not_found`,
+		* `plan_not_sellable`, `subscription_change_invalid`).
+		*/
+		changeSubscription: (id, input, opts) => call(ChangeSubscriptionResponseSchema, "POST", `/v1/subscriptions/${ref(id)}/change`, input, opts),
+		/**
+		* Billing core (MF9): takes back a cancellation scheduled for the period end; no body. 409
+		* `cancel_not_scheduled` (none scheduled) or `already_canceled` (ended, or its period is over).
+		*/
+		uncancelSubscription: (id, opts) => call(UncancelSubscriptionResponseSchema, "POST", `/v1/subscriptions/${ref(id)}/uncancel`, void 0, opts),
+		createGrant: (accountRef, input, opts) => call(GrantCreateResponseSchema, "POST", `/v1/accounts/${ref(accountRef)}/grants`, input, opts),
+		revokeGrant: (id, opts) => empty("DELETE", `/v1/grants/${ref(id)}`, opts),
+		getStats: () => call(StatsSchema, "GET", "/v1/stats"),
+		doctor: () => call(DoctorReportSchema, "GET", "/v1/doctor"),
+		issueInvoice: (id, input, opts) => call(InvoiceIssueResponseSchema, "POST", `/v1/invoices/${ref(id)}/issue`, input, opts),
+		/** Manuel taslak fatura (F4f): profil gerekir (422 `billing_profile_required`); `issueInvoice` ile kesilir. */
+		createManualInvoice: (accountRef, input, opts) => call(ManualInvoiceResponseSchema, "POST", `/v1/accounts/${ref(accountRef)}/invoices`, input, opts),
+		/** Yalnızca manuel fatura (409 `invoice_has_payment` / `invoice_not_voidable`); `invoice.voided`. */
+		voidInvoice: (id, input, opts) => call(InvoiceVoidResponseSchema, "POST", `/v1/invoices/${ref(id)}/void`, input, opts),
+		/**
+		* Billing core: opens steward's hosted pay page for an unpaid invoice → `{id, url, expiresAt}`;
+		* redirect the customer to `url` (409 `invoice_not_payable`). Opening changes no state.
+		*/
+		createInvoicePaymentSession: (id, input = {}, opts) => call(InvoicePaymentSessionSchema, "POST", `/v1/invoices/${ref(id)}/payment-sessions`, input, opts),
+		/** Billing core: forgives an unpaid invoice (409 `invoice_not_waivable`). */
+		waiveInvoice: (id, input, opts) => call(InvoiceWaiveResponseSchema, "POST", `/v1/invoices/${ref(id)}/waive`, input, opts),
+		/**
+		* `POST /v1/events/ingest`: 1–1 000 events → `{inserted, duplicates, rejected[]}`. Pass the SAME
+		* `idempotencyKey` on every retry of a batch (a new batch composition needs a new key);
+		* `externalId` dedups each event for good. 422 `batch_too_large`; 503 `events_backlog` (retry after `retryAfterMs`).
+		*/
+		ingestEvents: (input, opts) => call(EventsIngestResultSchema, "POST", "/v1/events/ingest", input, opts),
+		/**
+		* `GET /v1/accounts/:ref/meters` (open period per meter). ETag = the account's meter sequence;
+		* with the previous `etag` an unchanged read is 304 → `{notModified: true}`.
+		*/
+		getAccountMeters: async (accountRef, opts = {}) => {
+			const result = await conditional(AccountMetersSchema, `/v1/accounts/${ref(accountRef)}/meters`, opts.etag);
+			if (!result.ok) return result;
+			const read = result.data;
+			return {
+				...result,
+				data: read.notModified ? read : {
+					notModified: false,
+					etag: read.etag,
+					meters: read.body
+				}
+			};
+		},
+		/** `GET /v1/accounts/:ref/meters/periods?limit=`: closed meter periods, newest first. */
+		listMeterPeriods: (accountRef, opts = {}) => call(MeterPeriodListSchema, "GET", `/v1/accounts/${ref(accountRef)}/meters/periods${opts.limit !== void 0 ? `?limit=${encodeURIComponent(String(opts.limit))}` : ""}`),
+		/** `POST /v1/accounts/:ref/credits`: one-off credit for a meter's open period (422 `meter_not_found`). */
+		grantCredits: (accountRef, input, opts) => call(CreditGrantResponseSchema, "POST", `/v1/accounts/${ref(accountRef)}/credits`, input, opts),
+		/** `GET /v1/accounts/:ref/meter-charges`: overage pricing records (also `dry_run` ones), newest first. */
+		listMeterCharges: (accountRef) => call(MeterChargeListSchema, "GET", `/v1/accounts/${ref(accountRef)}/meter-charges`),
+		getInvoiceDocument: async (id) => {
+			const sent = await send("GET", `/v1/invoices/${ref(id)}/document`, void 0, void 0);
+			if (!("res" in sent)) return sent;
+			const { res } = sent;
+			if (!res.ok) return failure(res);
+			return success(res, {
+				contentType: res.headers.get("content-type") ?? "application/octet-stream",
+				bytes: new Uint8Array(await res.arrayBuffer())
+			});
+		},
+		getSettings: () => call(ProductSettingsSchema, "GET", "/v1/admin/settings"),
+		updateSettings: (patch, opts) => call(ProductSettingsSchema, "PATCH", "/v1/admin/settings", patch, opts),
+		listWebhookEndpoints: () => call(WebhookEndpointListSchema, "GET", "/v1/admin/webhook-endpoints"),
+		createWebhookEndpoint: (input, opts) => call(WebhookEndpointSchema, "POST", "/v1/admin/webhook-endpoints", input, opts),
+		rotateWebhookEndpointSecret: (id, input, opts) => call(WebhookEndpointSchema, "POST", `/v1/admin/webhook-endpoints/${ref(id)}/rotate`, input, opts),
+		deactivateWebhookEndpoint: (id, opts) => call(WebhookEndpointSchema, "POST", `/v1/admin/webhook-endpoints/${ref(id)}/deactivate`, void 0, opts)
+	};
+}
+//#endregion
+//#region src/retry.ts
+const RETRY_CLASSES = [
+	"network",
+	"5xx",
+	"429"
+];
+const BASE_DELAY_MS = 250;
+function retryPolicy(options = {}) {
+	const attempts = options.attempts ?? 2;
+	const maxDelayMs = options.maxDelayMs ?? 5e3;
+	const on = options.on ?? RETRY_CLASSES;
+	const problems = [];
+	if (!Number.isInteger(attempts) || attempts < 0) problems.push(`retries.attempts negatif olmayan tam sayı olmalı: ${attempts}`);
+	if (!Number.isFinite(maxDelayMs) || maxDelayMs < 0) problems.push(`retries.maxDelayMs negatif olmayan sayı olmalı: ${maxDelayMs}`);
+	for (const value of on) if (!RETRY_CLASSES.includes(value)) problems.push(`retries.on bilinmeyen sınıf: ${String(value)} (${RETRY_CLASSES.join(", ")})`);
+	if (problems.length > 0) throw new StewardConfigError({ message: `createSteward: ${problems.join("; ")}` });
+	return {
+		attempts,
+		on: new Set(on),
+		maxDelayMs,
+		sleep: options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+		random: options.random ?? Math.random
+	};
+}
+/** Başarısız sonucun tekrar sınıfı; hiçbirine girmiyorsa null (4xx, sözleşme hatası). */
+function retryClassOf(failure) {
+	if (failure.status === 0) return "network";
+	if (failure.status === 429) return "429";
+	if (failure.status >= 500) return "5xx";
+	return null;
+}
+function shouldRetry(request, failure, policy) {
+	if (request.method !== "GET" && request.idempotencyKey === void 0) return false;
+	const kind = retryClassOf(failure);
+	if (kind === null || !policy.on.has(kind)) return false;
+	if (kind === "network") return true;
+	return (failure.retryable ?? errorCodeSpec(failure.error)?.retryable) !== false;
+}
+/** `retry`. tekrardan (1'den başlar) önceki bekleme, ms. */
+function retryDelayMs(retry, failure, policy) {
+	if (failure.retryAfterMs !== void 0) return Math.min(failure.retryAfterMs, policy.maxDelayMs);
+	const ceiling = Math.min(policy.maxDelayMs, BASE_DELAY_MS * 2 ** (retry - 1));
+	return Math.round(ceiling / 2 + policy.random() * ceiling / 2);
+}
+/** `send`'i politika izin verdikçe tekrarlar; son sonucu (başarılı ya da değil) döner. */
+async function withRetries(request, policy, send) {
+	let result = await send();
+	for (let retry = 1; retry <= policy.attempts && !result.ok && shouldRetry(request, result, policy); retry++) {
+		await policy.sleep(retryDelayMs(retry, result, policy));
+		result = await send();
+	}
+	return result;
+}
+//#endregion
+//#region src/steward.ts
+const SDK_HEADER = `@stewardhq/sdk/0.6.0`;
+const defaultEnv = () => globalThis.process?.env ?? {};
+function isHttpUrl(value) {
+	try {
+		const { protocol } = new URL(value);
+		return protocol === "http:" || protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/** Nesne ağacındaki her metodu, istek göndermeden `error(yol)` ile reddeden eşiyle değiştirir. */
+function rejectAll(api, error, prefix = "") {
+	return Object.fromEntries(Object.entries(api).map(([name, value]) => {
+		const path = `${prefix}${name}`;
+		if (typeof value === "function") return [name, () => Promise.reject(error(path))];
+		return [name, typeof value === "object" && value !== null ? rejectAll(value, error, `${path}.`) : value];
+	}));
+}
+function createSteward(options = {}) {
+	const env = options.env ?? defaultEnv();
+	const setting = (value, name) => {
+		const text = (value ?? env[name])?.trim();
+		return text === void 0 || text === "" ? void 0 : text;
+	};
+	const baseUrl = setting(options.baseUrl, "STEWARD_URL");
+	const apiKey = setting(options.apiKey, "STEWARD_API_KEY");
+	const adminBaseUrl = setting(options.adminBaseUrl, "STEWARD_ADMIN_URL");
+	const adminApiKey = setting(options.adminApiKey, "STEWARD_ADMIN_API_KEY");
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	const adminOnly = baseUrl === void 0 && apiKey === void 0 && adminBaseUrl !== void 0 && adminApiKey !== void 0;
+	const problems = [];
+	if (!adminOnly) {
+		if (baseUrl === void 0) problems.push("STEWARD_URL (baseUrl) tanımlı değil");
+		else if (!isHttpUrl(baseUrl)) problems.push("STEWARD_URL (baseUrl) geçerli bir http(s) adresi değil");
+		if (apiKey === void 0) problems.push("STEWARD_API_KEY (apiKey) tanımlı değil");
+	}
+	if (adminBaseUrl !== void 0 && !isHttpUrl(adminBaseUrl)) problems.push("STEWARD_ADMIN_URL (adminBaseUrl) geçerli bir http(s) adresi değil");
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) problems.push(`timeoutMs pozitif sayı olmalı: ${timeoutMs}`);
+	if (options.actorRef !== void 0 && !ActorRefSchema.safeParse(options.actorRef).success) problems.push("actorRef biçimi geçersiz (tür[:kimlik], ör. system, user:42)");
+	if (problems.length > 0) {
+		const hint = baseUrl === void 0 && apiKey === void 0 ? " (yalnızca admin.* için STEWARD_ADMIN_URL + STEWARD_ADMIN_API_KEY yeter)" : "";
+		throw new StewardConfigError({ message: `createSteward: ${problems.join("; ")}${hint}` });
+	}
+	const policy = retryPolicy(options.retries);
+	const doFetch = options.fetch ?? fetch;
+	const clientOptions = (target) => ({
+		...target,
+		timeoutMs,
+		sdk: SDK_HEADER,
+		...options.fetch !== void 0 ? { fetch: options.fetch } : {}
+	});
+	const adminTarget = adminBaseUrl !== void 0 && adminApiKey !== void 0 ? {
+		baseUrl: adminBaseUrl.replace(/\/$/, ""),
+		apiKey: adminApiKey
+	} : null;
+	const adminClient = adminTarget === null ? null : createBillingClient(clientOptions(adminTarget));
+	const productTarget = baseUrl !== void 0 && apiKey !== void 0 ? {
+		baseUrl: baseUrl.replace(/\/$/, ""),
+		apiKey
+	} : null;
+	const missingProduct = (name) => new StewardConfigError({ message: `steward.${name}: STEWARD_URL (baseUrl) ve STEWARD_API_KEY (apiKey) tanımlı değil; istemci yalnızca admin.* için yapılandırıldı` });
+	const raw = createBillingClient(clientOptions(productTarget ?? {
+		baseUrl: "http://steward.invalid",
+		apiKey: "-"
+	}));
+	const eitherTarget = productTarget ?? adminTarget;
+	const eitherClient = productTarget !== null ? raw : adminClient;
+	function requireAdmin() {
+		if (adminClient !== null && adminTarget !== null) return {
+			client: adminClient,
+			target: adminTarget
+		};
+		const missing = [...adminBaseUrl === void 0 ? ["STEWARD_ADMIN_URL (adminBaseUrl)"] : [], ...adminApiKey === void 0 ? ["STEWARD_ADMIN_API_KEY (adminApiKey)"] : []];
+		throw new StewardConfigError({ message: `steward.admin: ${missing.join(" ve ")} tanımlı değil` });
+	}
+	async function send(target, method, path, call, extraHeaders = {}) {
+		const headers = {
+			authorization: `Bearer ${target.apiKey}`,
+			accept: "application/json",
+			[HEADER_API_VERSION]: API_VERSION,
+			[HEADER_SDK]: SDK_HEADER,
+			...extraHeaders
+		};
+		if (call.idempotencyKey !== void 0) headers[HEADER_IDEMPOTENCY_KEY] = call.idempotencyKey;
+		if (call.actorRef !== void 0) headers[HEADER_ACTOR_REF] = call.actorRef;
+		try {
+			return { res: await doFetch(`${target.baseUrl}${path}`, {
+				method,
+				headers,
+				signal: AbortSignal.timeout(timeoutMs)
+			}) };
+		} catch (error) {
+			const name = typeof error === "object" && error !== null ? error.name : void 0;
+			return {
+				ok: false,
+				status: 0,
+				error: name === "TimeoutError" || name === "AbortError" ? "timeout" : "network_error"
+			};
+		}
+	}
+	function meta(res) {
+		const requestId = res.headers.get(HEADER_REQUEST_ID);
+		const retryAfterMs = res.status === 429 || res.status === 503 ? parseRetryAfter(res.headers.get("retry-after")) : null;
+		return {
+			...requestId ? { requestId } : {},
+			...retryAfterMs !== null ? { retryAfterMs } : {}
+		};
+	}
+	async function failureOf(res) {
+		const parsed = ErrorResponseSchema.safeParse(await res.json().catch(() => null));
+		const { requestId, retryAfterMs } = meta(res);
+		const common = { ...retryAfterMs !== void 0 ? { retryAfterMs } : {} };
+		if (!parsed.success) return {
+			ok: false,
+			status: res.status,
+			error: `http_${res.status}`,
+			...requestId !== void 0 ? { requestId } : {},
+			...common
+		};
+		const { error, message, category, retryable } = parsed.data;
+		const id = requestId ?? parsed.data.requestId;
+		return {
+			ok: false,
+			status: res.status,
+			error,
+			...message !== void 0 ? { message } : {},
+			...category !== void 0 ? { category } : {},
+			...retryable !== void 0 ? { retryable } : {},
+			...id !== void 0 ? { requestId: id } : {},
+			...common
+		};
+	}
+	function success(res, data) {
+		const { requestId } = meta(res);
+		return {
+			ok: true,
+			status: res.status,
+			data,
+			...requestId !== void 0 ? { requestId } : {}
+		};
+	}
+	function invalid(res) {
+		const { requestId } = meta(res);
+		return {
+			ok: false,
+			status: res.status,
+			error: "invalid_response",
+			...requestId !== void 0 ? { requestId } : {}
+		};
+	}
+	async function sendParsed(target, method, path, schema, call) {
+		const sent = await send(target, method, path, call);
+		if (!("res" in sent)) return sent;
+		if (!sent.res.ok) return failureOf(sent.res);
+		const parsed = schema.safeParse(await sent.res.json().catch(() => void 0));
+		return parsed.success ? success(sent.res, parsed.data) : invalid(sent.res);
+	}
+	async function readCatalog(etag) {
+		const sent = await send(productTarget, "GET", "/v1/catalog", {}, etag !== void 0 ? { "if-none-match": etag } : {});
+		if (!("res" in sent)) return sent;
+		const { res } = sent;
+		const responseEtag = res.headers.get("etag");
+		if (res.status === 304) {
+			const current = responseEtag ?? etag;
+			return current === void 0 ? invalid(res) : success(res, {
+				notModified: true,
+				etag: current
+			});
+		}
+		if (!res.ok) return failureOf(res);
+		const parsed = CatalogSchema.safeParse(await res.json().catch(() => void 0));
+		return parsed.success ? success(res, {
+			notModified: false,
+			etag: responseEtag,
+			catalog: parsed.data
+		}) : invalid(res);
+	}
+	function toError(failure) {
+		const context = {
+			...failure.requestId !== void 0 ? { requestId: failure.requestId } : {},
+			...failure.retryAfterMs !== void 0 ? { retryAfterMs: failure.retryAfterMs } : {}
+		};
+		if (failure.status === 0) return new StewardNetworkError({
+			code: failure.error === "timeout" ? "timeout" : "network_error",
+			...context
+		});
+		if (failure.error === "invalid_response") return new StewardContractError({
+			httpStatus: failure.status,
+			...context
+		});
+		return new StewardApiError({
+			code: failure.error,
+			httpStatus: failure.status,
+			...failure.message !== void 0 ? { message: failure.message } : {},
+			...failure.category !== void 0 ? { category: failure.category } : {},
+			...failure.retryable !== void 0 ? { retryable: failure.retryable } : {},
+			...context
+		});
+	}
+	async function run(method, call, attempt) {
+		let effective = {};
+		if (method !== "GET") {
+			const actorRef = call?.actorRef ?? options.actorRef;
+			if (actorRef === void 0) throw new StewardConfigError({
+				code: "actor_ref_required",
+				message: "actorRef yok: createSteward({ actorRef }) ya da çağrıda { actorRef } verin (tür[:kimlik], ör. user:42, system)"
+			});
+			if (!ActorRefSchema.safeParse(actorRef).success) throw new StewardConfigError({
+				code: "invalid_actor_ref",
+				message: "actorRef biçimi geçersiz (tür[:kimlik], ör. user:42, system)"
+			});
+			effective = {
+				idempotencyKey: call?.idempotencyKey ?? globalThis.crypto.randomUUID(),
+				actorRef
+			};
+		}
+		const result = await withRetries({
+			method,
+			...effective.idempotencyKey !== void 0 ? { idempotencyKey: effective.idempotencyKey } : {}
+		}, policy, () => attempt(effective));
+		if (result.ok) return result.data;
+		throw toError(result);
+	}
+	const read = (attempt) => run("GET", void 0, attempt);
+	const productApi = {
+		accounts: {
+			upsert: (ref, input, call) => run("PUT", call, (c) => raw.upsertAccount(ref, input, c)),
+			get: (ref, opts = {}) => read(() => raw.getAccount(ref, opts.include)),
+			state: async (ref) => {
+				const result = await read(() => raw.getAccountState(ref));
+				if (result.notModified) throw new StewardContractError({ httpStatus: 304 });
+				return result.state;
+			},
+			readState: (ref, opts = {}) => read(() => raw.getAccountState(ref, opts.etag !== void 0 ? { etag: opts.etag } : {})),
+			setPlan: (ref, input, call) => run("PUT", call, (c) => raw.setPlan(ref, input, c)),
+			resync: (ref, call) => run("POST", call, (c) => raw.resync(ref, c)),
+			delete: (ref, call) => run("DELETE", call, (c) => raw.deleteAccount(ref, c))
+		},
+		checkoutSessions: {
+			create: (ref, input, call) => run("POST", call, (c) => raw.createCheckoutSession(ref, input, c)),
+			get: (id) => read(() => raw.getCheckoutSession(id))
+		},
+		portalSessions: { create: (ref, input = {}, call) => run("POST", call, (c) => raw.createPortalSession(ref, input, c)) },
+		subscriptions: {
+			cancel: (id, input, call) => run("POST", call, (c) => raw.cancelSubscription(id, input, c)),
+			change: (id, input, call) => run("POST", call, (c) => raw.changeSubscription(id, input, c)),
+			uncancel: (id, call) => run("POST", call, (c) => raw.uncancelSubscription(id, c))
+		},
+		grants: {
+			create: (ref, input, call) => run("POST", call, (c) => raw.createGrant(ref, input, c)),
+			revoke: async (id, call) => {
+				await run("DELETE", call, (c) => raw.revokeGrant(id, c));
+			}
+		},
+		invoices: {
+			issue: (id, input, call) => run("POST", call, (c) => raw.issueInvoice(id, input, c)),
+			document: (id) => read(() => raw.getInvoiceDocument(id)),
+			createManual: (ref, input, call) => run("POST", call, (c) => raw.createManualInvoice(ref, input, c)),
+			void: (id, input, call) => run("POST", call, (c) => raw.voidInvoice(id, input, c)),
+			createPaymentSession: (id, input = {}, call) => run("POST", call, (c) => raw.createInvoicePaymentSession(id, input, c)),
+			waive: (id, input, call) => run("POST", call, (c) => raw.waiveInvoice(id, input, c))
+		},
+		catalog: {
+			get: () => read(() => raw.getCatalog()),
+			read: (opts = {}) => read(() => readCatalog(opts.etag))
+		},
+		events: { ingest: (input, call) => run("POST", call, (c) => raw.ingestEvents(input, c)) },
+		meters: {
+			get: async (ref) => {
+				const result = await read(() => raw.getAccountMeters(ref));
+				if (result.notModified) throw new StewardContractError({ httpStatus: 304 });
+				return result.meters;
+			},
+			read: (ref, opts = {}) => read(() => raw.getAccountMeters(ref, opts.etag !== void 0 ? { etag: opts.etag } : {})),
+			periods: (ref, opts = {}) => read(() => raw.listMeterPeriods(ref, opts.limit !== void 0 ? { limit: opts.limit } : {}))
+		},
+		credits: { grant: (ref, input, call) => run("POST", call, (c) => raw.grantCredits(ref, input, c)) },
+		meterCharges: { list: (ref) => read(() => raw.listMeterCharges(ref)) },
+		stats: () => read(() => raw.getStats())
+	};
+	return {
+		...productTarget !== null ? productApi : rejectAll(productApi, missingProduct),
+		me: () => read(() => sendParsed(eitherTarget, "GET", "/v1/me", MeResponseSchema, {})),
+		doctor: () => read(() => eitherClient.doctor()),
+		admin: {
+			catalog: { sync: async (input, call) => {
+				const { client } = requireAdmin();
+				return run("PUT", call, (c) => client.syncCatalog(input, c));
+			} },
+			accounts: { refresh: async (call) => {
+				const { target } = requireAdmin();
+				return run("POST", call, (c) => sendParsed(target, "POST", "/v1/admin/accounts/refresh", AccountsRefreshResultSchema, c));
+			} },
+			settings: {
+				get: async () => {
+					const { client } = requireAdmin();
+					return read(() => client.getSettings());
+				},
+				update: async (patch, call) => {
+					const { client } = requireAdmin();
+					return run("PATCH", call, (c) => client.updateSettings(patch, c));
+				}
+			},
+			endpoints: {
+				list: async () => {
+					const { client } = requireAdmin();
+					return read(() => client.listWebhookEndpoints());
+				},
+				create: async (input, call) => {
+					const { client } = requireAdmin();
+					return run("POST", call, (c) => client.createWebhookEndpoint(input, c));
+				},
+				rotate: async (id, input, call) => {
+					const { client } = requireAdmin();
+					return run("POST", call, (c) => client.rotateWebhookEndpointSecret(id, input, c));
+				},
+				deactivate: async (id, call) => {
+					const { client } = requireAdmin();
+					return run("POST", call, (c) => client.deactivateWebhookEndpoint(id, c));
+				}
+			}
+		}
+	};
+}
+//#endregion
 //#region src/state-cache.ts
 const MANY_CONCURRENCY = 8;
-const FAILURE_BACKOFF_MS = 5e3;
-function fieldsOf$1(error) {
+const FAILURE_BACKOFF_MS$1 = 5e3;
+function fieldsOf$3(error) {
 	const { code, httpStatus, requestId } = typeof error === "object" && error !== null ? error : {};
 	return {
 		code: typeof code === "string" ? code : null,
@@ -14,7 +642,7 @@ function fieldsOf$1(error) {
 		requestId: typeof requestId === "string" ? requestId : null
 	};
 }
-function isOutage({ code, httpStatus }) {
+function isOutage$1({ code, httpStatus }) {
 	if (httpStatus === 0) return code === "network_error" || code === "timeout";
 	return httpStatus !== null && (httpStatus >= 500 || httpStatus === 429);
 }
@@ -34,7 +662,7 @@ function stateCache(steward, options = {}) {
 	const { catalog, fallback, onFallback } = options;
 	const logger = options.logger ?? console;
 	const now = options.now ?? Date.now;
-	const backoffMs = Math.min(ttlMs, FAILURE_BACKOFF_MS);
+	const backoffMs = Math.min(ttlMs, FAILURE_BACKOFF_MS$1);
 	const entries = /* @__PURE__ */ new Map();
 	const flights = /* @__PURE__ */ new Map();
 	let seq = 0;
@@ -67,7 +695,7 @@ function stateCache(steward, options = {}) {
 	/** Kesintide: bayat değer → fallback → asıl hata. WARN her başarısız istekte ve bayattan fallback'e geçişte bir kez. */
 	async function degrade(ref, failure) {
 		const { error } = failure;
-		const { code, requestId } = fieldsOf$1(error);
+		const { code, requestId } = fieldsOf$3(error);
 		const entry = entries.get(ref);
 		const t = now();
 		if (entry?.state && t < entry.fetchedAt + ttlMs + staleIfErrorMs) {
@@ -148,7 +776,7 @@ function stateCache(steward, options = {}) {
 		try {
 			read = await steward.accounts.readState(ref, known?.state && known.etag !== null ? { etag: known.etag } : {});
 		} catch (error) {
-			const fields = fieldsOf$1(error);
+			const fields = fieldsOf$3(error);
 			if (isNotFound(fields)) {
 				if (missing === "throw") {
 					entries.delete(ref);
@@ -170,7 +798,7 @@ function stateCache(steward, options = {}) {
 				});
 				return missingFallback(ref, failure);
 			}
-			if (!isOutage(fields)) throw error;
+			if (!isOutage$1(fields)) throw error;
 			const current = entries.get(ref);
 			const failure = {
 				error,
@@ -263,6 +891,10 @@ function stateCache(steward, options = {}) {
 			if (current?.state && account.version < current.state.version) return;
 			const etag = current?.state?.version === account.version ? current.etag : null;
 			put(account.ref, confirmed(account, etag, now()));
+		},
+		peek(ref) {
+			const entry = entries.get(ref);
+			return entry?.state && now() < entry.fetchedAt + ttlMs + staleIfErrorMs ? entry.state : null;
 		}
 	};
 }
@@ -286,7 +918,7 @@ const BY_CATEGORY = {
 	unavailable: 503
 };
 const isCategory = (value) => typeof value === "string" && ERROR_CATEGORIES.includes(value);
-function fieldsOf(err) {
+function fieldsOf$2(err) {
 	if (typeof err !== "object" || err === null) return null;
 	const { code, category, retryable, requestId, retryAfterMs } = err;
 	if (typeof code !== "string") return null;
@@ -304,7 +936,7 @@ function fieldsOf(err) {
 const retryAfter = (fields) => fields.retryAfterMs === void 0 ? {} : { "Retry-After": String(Math.max(1, Math.ceil(fields.retryAfterMs / 1e3))) };
 function httpStatusFor(err, options = {}) {
 	const logger = options.logger ?? console;
-	const fields = fieldsOf(err);
+	const fields = fieldsOf$2(err);
 	if (!fields) return {
 		status: 500,
 		headers: {}
@@ -356,6 +988,46 @@ function httpStatusFor(err, options = {}) {
 	};
 }
 //#endregion
+//#region src/meter-catalog.ts
+function meterCatalogFacts(input) {
+	const meters = new Map(Object.entries(input.meters));
+	const credits = /* @__PURE__ */ new Map();
+	const creditsOf = (plan) => {
+		const known = credits.get(plan);
+		if (known !== void 0) return known;
+		const { benefits } = resolveBenefits({
+			catalog: input,
+			subscriptions: plan === input.defaultPlanCode ? [] : [{
+				planCode: plan,
+				status: "active"
+			}]
+		});
+		const granted = meterCreditsOf(benefits, { defaultPlanCode: input.defaultPlanCode });
+		const out = new Map([...granted].map(([meter, credit]) => [meter, credit.unitsMicro]));
+		credits.set(plan, out);
+		return out;
+	};
+	const billableOf = (plan, meter) => plan !== input.defaultPlanCode && input.meteredPrices.some((price) => price.planCode === plan && price.meter === meter);
+	const stateBlockOf = (plan) => {
+		const planCredits = creditsOf(plan);
+		return Object.fromEntries([...meters.keys()].map((code) => {
+			const credit = planCredits.get(code);
+			return [code, {
+				includedUnits: credit === void 0 ? null : fromMicroUnits(credit),
+				billable: billableOf(plan, code),
+				standing: "ok"
+			}];
+		}));
+	};
+	return {
+		defaultPlan: input.defaultPlanCode,
+		meters,
+		creditsOf,
+		billableOf,
+		stateBlockOf
+	};
+}
+//#endregion
 //#region src/catalog.ts
 const feature = (type, options) => options?.description === void 0 ? { type } : {
 	type,
@@ -367,6 +1039,75 @@ const limit = (options) => feature("limit", options);
 const flag = (options) => feature("boolean", options);
 /** Serbest metin ayarı. */
 const text = (options) => feature("string", options);
+/**
+* A `feature_flag` benefit: feature key → value it grants, e.g. `featureFlag({ sso: true })`.
+* Keys are catalog features and values follow the feature's type (checked by `defineCatalog`).
+*/
+function featureFlag(properties, options) {
+	const copy = { ...properties };
+	const description = options?.description;
+	return description === void 0 ? {
+		type: "feature_flag",
+		properties: copy
+	} : {
+		type: "feature_flag",
+		properties: copy,
+		description: { ...description }
+	};
+}
+/**
+* A `meter_credit` benefit (metering phase 2, M5): `meterCredit("ai_tokens", { units: 50_000 })`,
+* optionally `rollover: { capUnits }`. The meter must be a catalog meter (checked by `defineCatalog`);
+* units may be decimals with at most 6 places.
+*/
+function meterCredit(meter, options) {
+	const given = isRecord(options) ? options : {};
+	const rollover = given.rollover;
+	const properties = {
+		meter,
+		units: given.units,
+		...rollover !== void 0 ? { rolloverCapUnits: isRecord(rollover) ? rollover.capUnits : null } : {}
+	};
+	const description = given.description;
+	return description === void 0 ? {
+		type: "meter_credit",
+		properties
+	} : {
+		type: "meter_credit",
+		properties,
+		description: copyOf(description)
+	};
+}
+/**
+* Aggregations (M4): `count()` events, `sum(key)` / `max(key)` of the finite, non-negative number
+* at `metadata.<key>` (decimals allowed), `unique(key)` distinct values at `metadata.<key>`.
+*/
+const count = () => ({ kind: "count" });
+const sum = (key) => ({
+	kind: "sum",
+	key
+});
+const max = (key) => ({
+	kind: "max",
+	key
+});
+const unique = (key) => ({
+	kind: "unique",
+	key
+});
+function meter(options) {
+	const given = isRecord(options) ? options : {};
+	const spec = {
+		aggregation: copyDeep(given.aggregate),
+		label: copyDeep(given.label)
+	};
+	if (given.event !== void 0) spec.event = given.event;
+	if (given.filter !== void 0) spec.filter = copyDeep(given.filter);
+	if (given.unitLabel !== void 0) spec.unitLabel = copyDeep(given.unitLabel);
+	if (given.displayPer !== void 0) spec.displayPer = given.displayPer;
+	if (given.lowAt !== void 0) spec.lowAt = given.lowAt;
+	return spec;
+}
 function matches(type, value) {
 	switch (type) {
 		case "limit": return value === null || typeof value === "number" && Number.isInteger(value) && value >= 0;
@@ -379,9 +1120,35 @@ const EXPECTED = {
 	boolean: "boolean",
 	string: "string"
 };
+const EXPECTED_EN = {
+	limit: "non-negative integer or null",
+	boolean: "boolean",
+	string: "string"
+};
 const show = (value) => value === void 0 ? "yok" : JSON.stringify(value);
+const showValue = (value) => value === void 0 ? "nothing" : JSON.stringify(value);
 const has = (object, key) => Object.hasOwn(object, key);
 const isObject = (value) => typeof value === "object" && value !== null;
+const isRecord = (value) => isObject(value) && !Array.isArray(value);
+const copyOf = (value) => Array.isArray(value) ? [...value] : isObject(value) ? { ...value } : value;
+/** Deep copy of plain JSON-like data (arrays and objects); other values as they are. */
+const copyDeep = (value) => Array.isArray(value) ? value.map(copyDeep) : isObject(value) ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, copyDeep(v)])) : value;
+/** Deep freeze of data made by `copyDeep`. */
+const freezeDeep = (value) => {
+	if (isObject(value)) {
+		for (const inner of Object.values(value)) freezeDeep(inner);
+		Object.freeze(value);
+	}
+	return value;
+};
+const benefitCopy = ({ type, properties, description }) => description === void 0 ? {
+	type,
+	properties: { ...properties }
+} : {
+	type,
+	properties: { ...properties },
+	description: copyOf(description)
+};
 function invalid(problems) {
 	return new StewardConfigError({
 		code: "invalid_catalog",
@@ -402,7 +1169,39 @@ function defineCatalog(definition) {
 	if (!isObject(input.features)) problems.push("features: nesne bekleniyor");
 	if (!isObject(input.plans)) problems.push("plans: nesne bekleniyor");
 	if (!Array.isArray(input.prices)) problems.push("prices: dizi bekleniyor");
+	if (input.benefits !== void 0 && !isRecord(input.benefits)) problems.push("benefits: object expected");
+	if (input.meters !== void 0 && !isRecord(input.meters)) problems.push("meters: object expected");
+	if (input.meteredPrices !== void 0 && !Array.isArray(input.meteredPrices)) problems.push("meteredPrices: array expected");
 	if (problems.length > 0) throw invalid(problems);
+	const meters = /* @__PURE__ */ new Map();
+	for (const [code, spec] of Object.entries(input.meters ?? {})) {
+		if (!isRecord(spec) || !isRecord(spec.aggregation) || typeof spec.aggregation.kind !== "string") {
+			problems.push(`meters.${code}: meter({ aggregate: count() | sum(key) | max(key) | unique(key), … }) expected`);
+			continue;
+		}
+		meters.set(code, copyDeep(spec));
+	}
+	const benefitCodes = new Set(Object.keys(input.benefits ?? {}));
+	const benefits = /* @__PURE__ */ new Map();
+	for (const [code, spec] of Object.entries(input.benefits ?? {})) {
+		if (!isRecord(spec) || spec.type !== "feature_flag" && spec.type !== "meter_credit" || !isRecord(spec.properties)) {
+			problems.push(`benefits.${code}: featureFlag() or meterCredit() expected`);
+			continue;
+		}
+		if (spec.type === "meter_credit") {
+			const meterCode = spec.properties.meter;
+			if (typeof meterCode !== "string" || !meters.has(meterCode)) problems.push(`benefits.${code}.properties.meter: undefined meter ${showValue(meterCode)}`);
+		} else for (const [key, value] of Object.entries(spec.properties)) {
+			const feature = features.get(key);
+			if (feature === void 0) problems.push(`benefits.${code}.properties.${key}: undefined feature`);
+			else if (!matches(feature.type, value)) problems.push(`benefits.${code}.properties.${key}: ${EXPECTED_EN[feature.type]} expected, got ${showValue(value)}`);
+		}
+		benefits.set(code, benefitCopy({
+			type: spec.type,
+			properties: spec.properties,
+			...spec.description !== void 0 ? { description: spec.description } : {}
+		}));
+	}
 	const plans = /* @__PURE__ */ new Map();
 	for (const [code, plan] of Object.entries(input.plans)) {
 		const given = isObject(plan) && isObject(plan.entitlements) ? plan.entitlements : {};
@@ -413,13 +1212,25 @@ function defineCatalog(definition) {
 			entitlements[key] = given[key];
 		}
 		for (const key of Object.keys(given).filter((k) => !features.has(k))) problems.push(`plans.${code}.entitlements.${key}: tanımsız feature`);
-		const { name, rank, sellable } = isObject(plan) ? plan : {};
-		plans.set(code, {
+		const { name, rank, sellable, benefits: listed } = isObject(plan) ? plan : {};
+		const runtime = {
 			name,
-			rank,
 			sellable,
 			entitlements
-		});
+		};
+		if (rank !== void 0) runtime.rank = rank;
+		if (listed !== void 0) {
+			if (Array.isArray(listed)) {
+				const seen = /* @__PURE__ */ new Set();
+				for (const [i, benefit] of listed.entries()) {
+					if (typeof benefit !== "string" || !benefitCodes.has(benefit)) problems.push(`plans.${code}.benefits.${i}: undefined benefit ${showValue(benefit)}`);
+					else if (seen.has(benefit)) problems.push(`plans.${code}.benefits.${i}: duplicate benefit ${benefit}`);
+					seen.add(benefit);
+				}
+				runtime.benefits = [...listed];
+			} else problems.push(`plans.${code}.benefits: array of benefit codes expected`);
+		}
+		plans.set(code, runtime);
 	}
 	if (typeof input.defaultPlan !== "string" || !plans.has(input.defaultPlan)) problems.push(`defaultPlan: ${show(input.defaultPlan)} planlarda yok`);
 	const prices = input.prices.map((price, i) => {
@@ -427,6 +1238,12 @@ function defineCatalog(definition) {
 		if (typeof copy.plan !== "string" || !plans.has(copy.plan)) problems.push(`prices.${i}.plan: ${show(copy.plan)} planlarda yok`);
 		return copy;
 	});
+	const meteredPrices = (input.meteredPrices ?? []).map((price, i) => {
+		const copy = { ...isObject(price) ? price : {} };
+		if (typeof copy.plan !== "string" || !plans.has(copy.plan)) problems.push(`meteredPrices.${i}.plan: undefined plan ${showValue(copy.plan)}`);
+		if (typeof copy.meter !== "string" || !meters.has(copy.meter)) problems.push(`meteredPrices.${i}.meter: undefined meter ${showValue(copy.meter)}`);
+		return copy;
+	});
 	if (problems.length > 0) throw invalid(problems);
 	const toSyncInput = () => ({
 		defaultPlanCode: input.defaultPlan,
@@ -434,15 +1251,24 @@ function defineCatalog(definition) {
 			key,
 			...spec
 		})),
-		plans: [...plans].map(([code, plan]) => ({
+		plans: [...plans].map(([code, { name, rank, sellable, entitlements, benefits: listed }]) => ({
 			code,
-			...plan,
-			entitlements: { ...plan.entitlements }
+			name,
+			rank: rank === void 0 ? 0 : rank,
+			sellable,
+			entitlements: { ...entitlements },
+			...listed !== void 0 && listed.length > 0 ? { benefits: [...listed] } : {}
 		})),
 		prices: prices.map(({ plan, ...rest }) => ({
 			planCode: plan,
 			...rest
-		}))
+		})),
+		...benefits.size > 0 ? { benefits: Object.fromEntries([...benefits].map(([code, benefit]) => [code, benefitCopy(benefit)])) } : {},
+		...meters.size > 0 ? { meters: Object.fromEntries([...meters].map(([code, spec]) => [code, copyDeep(spec)])) } : {},
+		...meteredPrices.length > 0 ? { meteredPrices: meteredPrices.map(({ plan, ...rest }) => ({
+			planCode: plan,
+			...rest
+		})) } : {}
 	});
 	const parsed = CatalogSyncInputSchema.safeParse(toSyncInput());
 	if (!parsed.success) {
@@ -461,7 +1287,14 @@ function defineCatalog(definition) {
 	}
 	const defaultPlan = input.defaultPlan;
 	const isPlan = (code) => typeof code === "string" && plans.has(code);
-	const planEntitlements = (code) => plans.get(code).entitlements;
+	const resolved = new Map([...plans.keys()].map((code) => [code, Object.freeze(resolveEntitlements({
+		catalog: parsed.data,
+		subscription: code === defaultPlan ? null : {
+			planCode: code,
+			status: "active"
+		}
+	}).entitlements)]));
+	const planEntitlements = (code) => resolved.get(code);
 	const entitlementsOf = (plan) => {
 		if (!isPlan(plan)) throw new StewardConfigError({
 			code: "unknown_plan",
@@ -483,6 +1316,16 @@ function defineCatalog(definition) {
 		if (fellBack.length > 0) options.onFallback?.(fellBack);
 		return result;
 	};
+	const facts = meters.size > 0 ? meterCatalogFacts(parsed.data) : null;
+	const metersBlocks = /* @__PURE__ */ new Map();
+	const metersBlockOf = (plan) => {
+		let block = metersBlocks.get(plan);
+		if (block === void 0) {
+			block = facts.stateBlockOf(plan);
+			metersBlocks.set(plan, block);
+		}
+		return Object.fromEntries(Object.entries(block).map(([code, meterState]) => [code, { ...meterState }]));
+	};
 	const stateOf = (ref, plan = defaultPlan, options = {}) => ({
 		ref,
 		displayName: options.displayName ?? ref,
@@ -497,19 +1340,32 @@ function defineCatalog(definition) {
 		profile: {
 			present: false,
 			kind: null
-		}
+		},
+		...facts !== null ? { meters: metersBlockOf(plan) } : {}
 	});
 	const frozen = (value) => Object.freeze(value);
+	const frozenBenefit = ({ properties, description, ...rest }) => frozen({
+		...rest,
+		properties: frozen({ ...properties }),
+		...isObject(description) ? { description: frozen({ ...description }) } : {}
+	});
 	return frozen({
 		defaultPlan,
 		features: frozen(Object.fromEntries([...features].map(([key, spec]) => [key, frozen({ ...spec })]))),
-		plans: frozen(Object.fromEntries([...plans].map(([code, plan]) => [code, frozen({
+		plans: frozen(Object.fromEntries([...plans].map(([code, { benefits: listed, ...plan }]) => [code, frozen({
 			...plan,
-			entitlements: frozen({ ...plan.entitlements })
+			entitlements: frozen({ ...plan.entitlements }),
+			...listed !== void 0 ? { benefits: frozen([...listed]) } : {}
 		})]))),
 		prices: frozen(prices.map((price) => frozen({ ...price }))),
+		benefits: frozen(Object.fromEntries([...benefits].map(([code, benefit]) => [code, frozenBenefit(benefit)]))),
+		meters: frozen(Object.fromEntries([...meters].map(([code, spec]) => [code, freezeDeep(copyDeep(spec))]))),
+		meteredPrices: frozen(meteredPrices.map((price) => frozen({ ...price }))),
 		$plan: void 0,
 		$entitlements: void 0,
+		$benefit: void 0,
+		$meter: void 0,
+		$event: void 0,
 		toSyncInput,
 		entitlementsOf,
 		resolve,
@@ -518,4 +1374,781 @@ function defineCatalog(definition) {
 	});
 }
 //#endregion
-export { ACCOUNT_INCLUDES, API_VERSION, AccessStateSchema, AccountDeleteResponseSchema, AccountDetailSchema, AccountDunningStateSchema, AccountLocaleSchema, AccountOpenCheckoutSchema, AccountProfileStateSchema, AccountScheduledChangeSchema, AccountSchema, AccountStateSchema, AccountSubscriptionStateSchema, AccountUpsertInputSchema, AccountUpsertResponseSchema, AccountsRefreshResultSchema, ActorRefSchema, AmountMinorSchema, AnyBillingEventSchema, ApiVersionSchema, BILLING_PATH_PLACEHOLDERS, BillingEventSchema, BillingPathSchema, BillingProfileKindSchema, BillingProfileSchema, BrandingPatchSchema, BrandingSchema, CHECKOUT_ERRORS, CancelSubscriptionInputSchema, CancelSubscriptionResponseSchema, CatalogSchema, CatalogSyncInputSchema, CatalogSyncResultSchema, CheckoutConsentInputSchema, CheckoutPrefillSchema, CheckoutSessionCreateInputSchema, CheckoutSessionCreatedSchema, CheckoutSessionResponseSchema, CheckoutSessionSchema, CheckoutStatusSchema, CodeSchema, ConsentSchema, CurrencySchema, DEFAULT_CHECKOUT_TTL_MINUTES, DEFAULT_ENDPOINT_EVENT_TYPES, DEFAULT_PORTAL_TTL_MINUTES, DOCTOR_PENDING_BACKLOG_MS, DOCTOR_PROVIDER_ENVIRONMENTS, DOCTOR_REQUIRED_BRANDING, DOCTOR_REQUIRED_LEGAL_LINKS, DOCTOR_SEVERITIES, DateTimeSchema, DoctorCatalogSchema, DoctorEmailsSchema, DoctorEndpointSchema, DoctorHostedSchema, DoctorProviderSchema, DoctorReportSchema, DoctorSettingsSchema, DoctorSeveritySchema, DoctorUnsellablePriceSchema, DoctorWarningSchema, EMAIL_LOCALES, EMAIL_TEMPLATES, EMAIL_TEMPLATE_BY_EVENT, ERROR_CATEGORIES, ERROR_CODES, EVENT_DETAIL_SCHEMAS, EVENT_TYPES, EmailExtraTextSchema, EmailSenderSchema, EmailSettingsPatchSchema, EmailSettingsSchema, EmailTemplateSchema, EmailTemplateSettingsSchema, EntitlementSnapshotSchema, EntitlementValueSchema, EntitlementsSchema, ErrorCategorySchema, ErrorResponseSchema, EventIdSchema, EventTypeSchema, ExternalRefSchema, FeatureDefSchema, FeatureTypeSchema, GrantCreateInputSchema, GrantCreateResponseSchema, GrantSchema, HEADER_ACTOR_REF, HEADER_API_VERSION, HEADER_IDEMPOTENCY_KEY, HEADER_REQUEST_ID, HEADER_SDK, IdSchema, IntervalSchema, InvoiceIssueInputSchema, InvoiceIssueResponseSchema, InvoiceLineSchema, InvoiceSchema, InvoiceStatusSchema, InvoiceVoidInputSchema, InvoiceVoidResponseSchema, LEGACY_EVENT_TYPES, LIVE_SUBSCRIPTION_STATUSES, MANUAL_INVOICE_MAX_AMOUNT_MINOR, MAX_CHECKOUT_CONSENT_DOCS, MAX_NOTIFICATION_EMAILS, ManualInvoiceInputSchema, ManualInvoiceLineInputSchema, ManualInvoiceResponseSchema, MetadataSchema, NotificationEmailsSchema, PING_EVENT_TYPE, PLAN_SET_MODES, PORTAL_SESSION_ERRORS, PaymentSchema, PingSchema, PlanDefSchema, PlanSetInputSchema, PlanSetModeSchema, PlanSetResponseSchema, PlanSetWarningSchema, PortalSessionCreateInputSchema, PortalSessionSchema, PriceDefSchema, PriceSchema, ProductSettingsPatchSchema, ProductSettingsSchema, ProviderPayloadSchema, ResyncResultSchema, ReturnOriginSchema, SETTINGS_LOCALES, SettingsLocaleSchema, StatsSchema, StewardApiError, StewardConfigError, StewardContractError, StewardError, StewardNetworkError, SubscriptionSchema, SubscriptionStatusSchema, SubscriptionSummarySchema, TtlMinutesSchema, WEBHOOK_ENDPOINT_STATUSES, WEBHOOK_SECRET_PREFIX, WebUrlSchema, WebhookEndpointCreateInputSchema, WebhookEndpointListSchema, WebhookEndpointRotateInputSchema, WebhookEndpointSchema, WebhookEndpointStatusSchema, WebhookLastDeliverySchema, WebhookSecretSchema, applyEmailSettingsPatch, applySettingsPatch, billingPageUrl, buildDoctorReport, checkoutRedirectUrl, createSteward, defineCatalog, emailLocaleOf, emailReadinessOf, emailRecipients, emailTemplateOf, emailTemplateSettings, endpointDiagnosisOf, errorCodeSpec, flag, generateWebhookSecret, hostedReadinessOf, httpStatusFor, isE164, isEmailRelevant, isEventType, isGrantActive, isKnownErrorCode, isLiveSubscriptionStatus, isReturnUrlAllowed, isValidTckn, isValidVkn, limit, manualInvoiceTotals, resolveEntitlements, returnOriginsOf, splitInclusiveTax, stateCache, text, uniqueEmails, webhookEndpointUrlProblem };
+//#region src/events.ts
+/** How long an acknowledged event stays pending: the meter rollup lags behind ingestion (≤ 10 s target). */
+const EVENTS_RECENT_MS = 6e4;
+const MAX_BACKOFF_MS = 3e4;
+const BASE_BACKOFF_MS = 1e3;
+const WARN_EVERY_MS = 1e4;
+/** Room for `{"events":[` … `]}` and separators within the ingest body limit. */
+const BATCH_BYTES = EVENTS_INGEST_MAX_BYTES - 1024;
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const describeError = (error) => error instanceof Error ? error.message : String(error);
+function fieldsOf$1(error) {
+	const { code, retryable, retryAfterMs } = isPlainObject(error) || error instanceof Error ? error : {};
+	return {
+		code: typeof code === "string" ? code : null,
+		retryable: typeof retryable === "boolean" ? retryable : null,
+		retryAfterMs: typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) ? retryAfterMs : null
+	};
+}
+function isTransient(error) {
+	const { code, retryable } = fieldsOf$1(error);
+	return retryable === true || code === "invalid_response";
+}
+function utf8Length(text) {
+	let bytes = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c < 128) bytes += 1;
+		else if (c < 2048) bytes += 2;
+		else if (c >= 55296 && c <= 56319) {
+			bytes += 4;
+			i++;
+		} else bytes += 3;
+	}
+	return bytes;
+}
+function positive(name, value, problems, { integer = false, max = Number.POSITIVE_INFINITY } = {}) {
+	if (!(Number.isFinite(value) && value > 0 && value <= max && (!integer || Number.isInteger(value)))) problems.push(`${name} must be a positive ${integer ? "integer" : "number"}${Number.isFinite(max) ? ` ≤ ${max}` : ""}: ${String(value)}`);
+}
+/** Events tracker (M16); see the comment above. */
+function Events(options) {
+	const flushIntervalMs = options.flushIntervalMs ?? 2e3;
+	const maxBatch = options.maxBatch ?? 500;
+	const maxQueue = options.maxQueue ?? 1e4;
+	const autoFlush = options.autoFlush ?? true;
+	const problems = [];
+	if (typeof options.steward?.events?.ingest !== "function") problems.push("steward.events.ingest is required (createSteward())");
+	positive("flushIntervalMs", flushIntervalMs, problems);
+	positive("maxBatch", maxBatch, problems, {
+		integer: true,
+		max: EVENTS_INGEST_MAX_EVENTS
+	});
+	positive("maxQueue", maxQueue, problems, { integer: true });
+	if (typeof autoFlush !== "boolean") problems.push("autoFlush must be a boolean");
+	if (options.actorRef !== void 0 && !ActorRefSchema.safeParse(options.actorRef).success) problems.push("actorRef format is invalid (kind[:id], e.g. service:api)");
+	if (problems.length > 0) throw new StewardConfigError({ message: `Events: ${problems.join("; ")}` });
+	const { steward, actorRef, onRejected, onDrop } = options;
+	const logger = options.logger ?? console;
+	const now = options.now ?? Date.now;
+	const random = options.random ?? Math.random;
+	/** Waiting events, oldest first. */
+	let queue = [];
+	/** The first `size` queued events were sent with `key` before (a failed batch): the next attempt sends exactly them with it. */
+	let head = null;
+	/** Acknowledged events kept pending for `EVENTS_RECENT_MS`, oldest first. */
+	let recent = [];
+	const byRef = /* @__PURE__ */ new Map();
+	let failures = 0;
+	let retryAt = 0;
+	let timer = null;
+	let chain = Promise.resolve();
+	let runs = 0;
+	let dropWarnedAt = Number.NEGATIVE_INFINITY;
+	let droppedSinceWarn = 0;
+	const index = (entry) => {
+		const ref = entry.event.accountRef;
+		let set = byRef.get(ref);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			byRef.set(ref, set);
+		}
+		set.add(entry);
+	};
+	const unindex = (entry) => {
+		const ref = entry.event.accountRef;
+		const set = byRef.get(ref);
+		if (set === void 0) return;
+		set.delete(entry);
+		if (set.size === 0) byRef.delete(ref);
+	};
+	function hook(name, run) {
+		try {
+			run();
+		} catch (error) {
+			logger.warn(`Events ${name} threw`, { error: describeError(error) });
+		}
+	}
+	function drop(events, info) {
+		if (onDrop !== void 0) hook("onDrop", () => onDrop(events, info));
+	}
+	function pruneRecent() {
+		const oldest = now() - EVENTS_RECENT_MS;
+		let cut = 0;
+		while (cut < recent.length && (recent[cut].ackedAt < oldest || recent.length - cut > maxQueue)) cut++;
+		if (cut === 0) return;
+		for (const entry of recent.slice(0, cut)) unindex(entry);
+		recent = recent.slice(cut);
+	}
+	/** Queue over `maxQueue`: the oldest events go to `onDrop`. A shortened failed batch gets a new key (its composition changed). */
+	function enforceLimit() {
+		const excess = queue.length - maxQueue;
+		if (excess <= 0) return;
+		const dropped = queue.splice(0, excess);
+		for (const entry of dropped) unindex(entry);
+		if (head !== null) {
+			const size = head.size - Math.min(excess, head.size);
+			head = size > 0 ? {
+				key: globalThis.crypto.randomUUID(),
+				size
+			} : null;
+		}
+		droppedSinceWarn += dropped.length;
+		const t = now();
+		if (t - dropWarnedAt >= WARN_EVERY_MS) {
+			logger.warn("Events queue full; the oldest events were dropped (onDrop)", {
+				dropped: droppedSinceWarn,
+				maxQueue
+			});
+			dropWarnedAt = t;
+			droppedSinceWarn = 0;
+		}
+		drop(dropped.map((entry) => entry.event), { reason: "queue_full" });
+	}
+	function takeBatch() {
+		let size = 0;
+		let key;
+		if (head !== null) {
+			size = Math.min(head.size, queue.length);
+			key = head.key;
+		} else {
+			let bytes = 0;
+			while (size < queue.length && size < maxBatch && (size === 0 || bytes + queue[size].bytes + 1 <= BATCH_BYTES)) {
+				bytes += queue[size].bytes + 1;
+				size++;
+			}
+			key = globalThis.crypto.randomUUID();
+		}
+		head = null;
+		const entries = queue.splice(0, size);
+		for (const entry of entries) entry.state = "sending";
+		return {
+			key,
+			entries
+		};
+	}
+	function acknowledge(batch, result) {
+		const rejectedAt = /* @__PURE__ */ new Map();
+		for (const rejection of result.rejected) if (rejection.index >= 0 && rejection.index < batch.entries.length) rejectedAt.set(rejection.index, rejection);
+		const ackedAt = now();
+		const rejected = [];
+		batch.entries.forEach((entry, i) => {
+			const rejection = rejectedAt.get(i);
+			if (rejection !== void 0) {
+				unindex(entry);
+				rejected.push({
+					...rejection,
+					event: entry.event
+				});
+				return;
+			}
+			entry.state = "acked";
+			entry.ackedAt = ackedAt;
+			recent.push(entry);
+		});
+		pruneRecent();
+		if (rejected.length > 0) {
+			const codes = [...new Set(rejected.map((r) => r.code))];
+			logger.warn("steward rejected events (not retried; onRejected)", {
+				rejected: rejected.length,
+				codes
+			});
+			if (onRejected !== void 0) hook("onRejected", () => onRejected(rejected));
+		}
+	}
+	function backoffMs(retryAfterMs) {
+		const ceiling = Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** Math.min(failures - 1, 16));
+		const jittered = Math.round(ceiling / 2 + random() * ceiling / 2);
+		return Math.min(MAX_BACKOFF_MS, Math.max(jittered, retryAfterMs ?? 0));
+	}
+	/** Sends one batch; `false` when sending should pause (transient failure). */
+	async function send(batch) {
+		try {
+			const result = await steward.events.ingest({ events: batch.entries.map((entry) => entry.event) }, {
+				idempotencyKey: batch.key,
+				...actorRef !== void 0 ? { actorRef } : {}
+			});
+			failures = 0;
+			retryAt = 0;
+			acknowledge(batch, result);
+			return true;
+		} catch (error) {
+			const { code, retryAfterMs } = fieldsOf$1(error);
+			if (isTransient(error)) {
+				for (const entry of batch.entries) entry.state = "queued";
+				queue = [...batch.entries, ...queue];
+				head = {
+					key: batch.key,
+					size: batch.entries.length
+				};
+				failures += 1;
+				const delay = backoffMs(retryAfterMs);
+				retryAt = now() + delay;
+				logger.warn("steward event ingest failed; the batch stays queued", {
+					code,
+					events: batch.entries.length,
+					queued: queue.length,
+					retryInMs: delay
+				});
+				enforceLimit();
+				return false;
+			}
+			for (const entry of batch.entries) unindex(entry);
+			logger.warn("steward event ingest failed permanently; the batch was dropped (onDrop)", {
+				code,
+				events: batch.entries.length
+			});
+			drop(batch.entries.map((entry) => entry.event), {
+				reason: "request_failed",
+				message: code ?? describeError(error),
+				error
+			});
+			return true;
+		}
+	}
+	async function drain(force) {
+		while (queue.length > 0) {
+			if (!force && now() < retryAt) return;
+			if (!await send(takeBatch())) return;
+		}
+	}
+	function arm(delay) {
+		if (!autoFlush || timer !== null || queue.length === 0) return;
+		timer = setTimeout(() => {
+			timer = null;
+			schedule(false);
+		}, Math.max(0, delay));
+		timer.unref?.();
+	}
+	function rearm() {
+		if (queue.length === 0) return;
+		const t = now();
+		arm(retryAt > t ? retryAt - t : flushIntervalMs);
+	}
+	function schedule(force) {
+		runs += 1;
+		const run = chain.then(() => drain(force)).catch((error) => logger.warn("Events flush failed", { error: describeError(error) })).finally(() => {
+			runs -= 1;
+			rearm();
+		});
+		chain = run;
+		return run;
+	}
+	function normalizedTimestamp(timestamp) {
+		if (timestamp === void 0) return new Date(now()).toISOString();
+		if (!(timestamp instanceof Date)) return timestamp;
+		return Number.isNaN(timestamp.getTime()) ? "Invalid Date" : timestamp.toISOString();
+	}
+	function eventOf(ref, name, metadata, externalId, timestamp) {
+		return {
+			accountRef: ref,
+			name,
+			externalId: externalId === void 0 ? globalThis.crypto.randomUUID() : externalId,
+			timestamp: normalizedTimestamp(timestamp),
+			...metadata !== void 0 ? { metadata: isPlainObject(metadata) ? { ...metadata } : metadata } : {}
+		};
+	}
+	function issuesOf(error) {
+		return error.issues.map((issue) => `${issue.path.map(String).join(".") || "(event)"}: ${issue.message}`).join("; ");
+	}
+	return {
+		track(ref, name, metadata, trackOptions) {
+			let event = null;
+			try {
+				const given = isPlainObject(trackOptions) ? trackOptions : {};
+				event = eventOf(ref, name, metadata, given.externalId, given.timestamp);
+				const parsed = IngestEventSchema.safeParse(event);
+				if (!parsed.success) {
+					const message = issuesOf(parsed.error);
+					logger.warn("Events.track: invalid event dropped (onDrop)", {
+						name: typeof name === "string" ? name.slice(0, 128) : null,
+						problems: message
+					});
+					drop([event], {
+						reason: "invalid_event",
+						message
+					});
+					return;
+				}
+				const entry = {
+					event: parsed.data,
+					bytes: utf8Length(JSON.stringify(parsed.data)),
+					state: "queued",
+					ackedAt: null
+				};
+				queue.push(entry);
+				index(entry);
+				enforceLimit();
+				if (!autoFlush) return;
+				if (queue.length >= maxBatch && runs === 0 && now() >= retryAt) schedule(false);
+				else arm(flushIntervalMs);
+			} catch (error) {
+				logger.warn("Events.track: event dropped", { error: describeError(error) });
+				if (event !== null) drop([event], {
+					reason: "invalid_event",
+					message: describeError(error)
+				});
+			}
+		},
+		flush() {
+			if (timer !== null) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			return schedule(true);
+		},
+		async ingest(events, ingestOptions = {}) {
+			let input;
+			try {
+				input = { events: (Array.isArray(events) ? events : []).map((e) => eventOf(e.accountRef, e.name, e.metadata, e.externalId, e.timestamp)) };
+			} catch (error) {
+				throw new StewardConfigError({
+					code: "invalid_events",
+					message: `Events.ingest: ${describeError(error)}`,
+					cause: error
+				});
+			}
+			const parsed = EventsIngestInputSchema.safeParse(input);
+			if (!parsed.success) throw new StewardConfigError({
+				code: "invalid_events",
+				message: `Events.ingest: ${issuesOf(parsed.error)}`
+			});
+			const entries = parsed.data.events.map((event) => ({
+				event,
+				bytes: 0,
+				state: "sending",
+				ackedAt: null
+			}));
+			for (const entry of entries) index(entry);
+			try {
+				const result = await steward.events.ingest(parsed.data, {
+					idempotencyKey: ingestOptions.idempotencyKey ?? globalThis.crypto.randomUUID(),
+					...actorRef !== void 0 ? { actorRef } : {}
+				});
+				const rejected = new Set(result.rejected.map((r) => r.index));
+				const ackedAt = now();
+				entries.forEach((entry, i) => {
+					if (rejected.has(i)) {
+						unindex(entry);
+						return;
+					}
+					entry.state = "acked";
+					entry.ackedAt = ackedAt;
+					recent.push(entry);
+				});
+				pruneRecent();
+				return result;
+			} catch (error) {
+				for (const entry of entries) unindex(entry);
+				throw error;
+			}
+		},
+		pending(ref) {
+			pruneRecent();
+			const set = byRef.get(ref);
+			if (set === void 0) return [];
+			return [...set].map((entry) => ({
+				event: entry.event,
+				ackedAt: entry.state === "acked" ? entry.ackedAt : null
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/meters.ts
+const FAILURE_BACKOFF_MS = 5e3;
+const STANDING_ORDER = {
+	ok: 0,
+	low: 1,
+	exhausted: 2
+};
+const worse = (a, b) => STANDING_ORDER[b] > STANDING_ORDER[a] ? b : a;
+const micro = (value) => typeof value === "number" ? parseMicroUnits(value) ?? 0n : 0n;
+const isStanding = (value) => typeof value === "string" && Object.hasOwn(STANDING_ORDER, value);
+function fieldsOf(error) {
+	const { code, httpStatus } = typeof error === "object" && error !== null ? error : {};
+	return {
+		code: typeof code === "string" ? code : null,
+		httpStatus: typeof httpStatus === "number" ? httpStatus : null
+	};
+}
+function isOutage(error) {
+	const { code, httpStatus } = fieldsOf(error);
+	if (httpStatus === 0) return code === "network_error" || code === "timeout";
+	return httpStatus !== null && (httpStatus >= 500 || httpStatus === 429);
+}
+/** Rollup lag of a read (`asOf − rolledUpThrough`, steward's clock), ms; unknown → the whole recent window. */
+function rollupLagMs(body) {
+	const lag = Date.parse(body.asOf) - Date.parse(body.rolledUpThrough);
+	return Number.isFinite(lag) ? Math.min(Math.max(lag, 0), EVENTS_RECENT_MS) : EVENTS_RECENT_MS;
+}
+/** Units the pending events add to a meter whose period consumption is `consumed` (micro units). */
+function pendingMicroOf(def, events, cutoff, consumed) {
+	let total = 0n;
+	let largest = 0n;
+	const distinct = /* @__PURE__ */ new Set();
+	for (const { event, ackedAt } of events) {
+		if (ackedAt !== null && ackedAt < cutoff) continue;
+		if (!matchesFilter(event, def.filter)) continue;
+		const c = contributionOf(event, def.aggregation);
+		switch (c.kind) {
+			case "count":
+				total += MICRO_UNITS_PER_UNIT;
+				break;
+			case "sum":
+				total += c.micro;
+				break;
+			case "max":
+				if (c.micro > largest) largest = c.micro;
+				break;
+			case "unique": distinct.add(c.value);
+		}
+	}
+	switch (def.aggregation.kind) {
+		case "max": return largest > consumed ? largest - consumed : 0n;
+		case "unique": return BigInt(distinct.size) * MICRO_UNITS_PER_UNIT;
+		default: return total;
+	}
+}
+/** Meter reader and gate (M13, M15, M16); see the comment above. */
+function Meters(options) {
+	const ttlMs = options.ttlMs ?? 1e4;
+	const staleIfErrorMs = options.staleIfErrorMs ?? 6e5;
+	const maxEntries = options.maxEntries ?? 1e4;
+	const policy = options.onUnavailable ?? "allow";
+	const problems = [];
+	if (typeof options.steward?.meters?.read !== "function") problems.push("steward.meters.read is required (createSteward())");
+	if (typeof options.catalog?.toSyncInput !== "function") problems.push("catalog is required (defineCatalog())");
+	if (!(Number.isFinite(ttlMs) && ttlMs >= 0)) problems.push(`ttlMs must be a non-negative number: ${ttlMs}`);
+	if (!(Number.isFinite(staleIfErrorMs) && staleIfErrorMs >= 0)) problems.push(`staleIfErrorMs must be a non-negative number: ${staleIfErrorMs}`);
+	if (!(Number.isInteger(maxEntries) && maxEntries >= 1)) problems.push(`maxEntries must be a positive integer: ${maxEntries}`);
+	if (policy !== "allow" && policy !== "deny" && typeof policy !== "function") problems.push(`onUnavailable must be "allow", "deny" or a function: ${String(policy)}`);
+	if (options.events !== void 0 && typeof options.events.pending !== "function") problems.push("events must be an Events() (pending)");
+	if (options.cache !== void 0 && typeof options.cache.peek !== "function") problems.push("cache must be a stateCache() (peek)");
+	if (problems.length > 0) throw new StewardConfigError({ message: `Meters: ${problems.join("; ")}` });
+	const parsed = CatalogSyncInputSchema.safeParse(options.catalog.toSyncInput());
+	if (!parsed.success) throw new StewardConfigError({
+		code: "invalid_catalog",
+		message: "Meters: the catalog is not valid (defineCatalog)"
+	});
+	const facts = meterCatalogFacts(parsed.data);
+	if (facts.meters.size === 0) throw new StewardConfigError({ message: "Meters: the catalog defines no meters" });
+	const defaultCredits = facts.creditsOf(facts.defaultPlan);
+	const { steward, cache, events, onFallback } = options;
+	const logger = options.logger ?? console;
+	const now = options.now ?? Date.now;
+	const backoffMs = Math.min(ttlMs, FAILURE_BACKOFF_MS);
+	const entries = /* @__PURE__ */ new Map();
+	const flights = /* @__PURE__ */ new Map();
+	const warnedMissing = /* @__PURE__ */ new Set();
+	function put(ref, entry) {
+		entries.delete(ref);
+		entries.set(ref, entry);
+		for (const oldest of entries.keys()) {
+			if (entries.size <= maxEntries) break;
+			entries.delete(oldest);
+		}
+	}
+	function degrade(ref, entry, failure) {
+		const t = now();
+		if (entry.body !== null && t < entry.confirmedAt + ttlMs + staleIfErrorMs) {
+			if (failure.warned !== "stale") {
+				const { code } = fieldsOf(failure.error);
+				logger.warn("steward meters unreadable; using the stale value", {
+					ref,
+					code,
+					ageMs: t - entry.confirmedAt
+				});
+				failure.warned = "stale";
+			}
+			return {
+				kind: "value",
+				body: entry.body,
+				bodyAt: entry.bodyAt,
+				source: "stale"
+			};
+		}
+		return {
+			kind: "fallback",
+			error: failure.error
+		};
+	}
+	async function load(ref, flight) {
+		const known = entries.get(ref);
+		let read;
+		try {
+			read = await steward.meters.read(ref, known?.body && known.etag !== null ? { etag: known.etag } : {});
+		} catch (error) {
+			if (!isOutage(error)) throw error;
+			const failure = {
+				error,
+				until: now() + backoffMs,
+				warned: null
+			};
+			const current = entries.get(ref) ?? {
+				body: null,
+				etag: null,
+				bodyAt: Number.NEGATIVE_INFINITY,
+				confirmedAt: Number.NEGATIVE_INFINITY,
+				expiresAt: Number.NEGATIVE_INFINITY,
+				failure: null
+			};
+			current.failure = failure;
+			put(ref, current);
+			return degrade(ref, current, failure);
+		}
+		const t = now();
+		let body;
+		let bodyAt;
+		if (!read.notModified) {
+			body = read.meters;
+			bodyAt = t;
+		} else if (known?.body) {
+			body = known.body;
+			bodyAt = known.bodyAt;
+		} else throw new StewardContractError({ httpStatus: 304 });
+		put(ref, {
+			body,
+			etag: read.etag,
+			bodyAt,
+			confirmedAt: t,
+			expiresAt: flight.invalidated ? Number.NEGATIVE_INFINITY : t + ttlMs,
+			failure: null
+		});
+		return {
+			kind: "value",
+			body,
+			bodyAt,
+			source: "live"
+		};
+	}
+	function join(ref) {
+		const running = flights.get(ref);
+		if (running) return running.promise;
+		const control = { invalidated: false };
+		const promise = load(ref, control).finally(() => {
+			if (flights.get(ref)?.promise === promise) flights.delete(ref);
+		});
+		flights.set(ref, Object.assign(control, { promise }));
+		return promise;
+	}
+	async function snapshot(ref, fresh) {
+		const entry = entries.get(ref);
+		if (entry) put(ref, entry);
+		if (entry && !fresh) {
+			const t = now();
+			if (entry.body !== null && t < entry.expiresAt) return {
+				kind: "value",
+				body: entry.body,
+				bodyAt: entry.bodyAt,
+				source: "cached"
+			};
+			if (entry.failure && t < entry.failure.until) return degrade(ref, entry, entry.failure);
+		}
+		return join(ref);
+	}
+	/** Steward's meter plus the pending units. `def` absent: a meter this catalog does not define (no pending units). */
+	function computed(meter, def, pending, cutoff, source) {
+		const credited = micro(meter.creditedUnits);
+		const consumedBefore = micro(meter.consumedUnits);
+		const pendingMicro = def === void 0 ? 0n : pendingMicroOf(def, pending, cutoff, consumedBefore);
+		const consumed = consumedBefore + pendingMicro;
+		const balance = credited - consumed;
+		const standing = def === void 0 || pendingMicro === 0n ? meter.standing : worse(meter.standing, standingOf({
+			creditedMicro: credited,
+			consumedMicro: consumed,
+			lowAt: def.lowAt
+		}));
+		return {
+			balanceMicro: balance,
+			value: {
+				periodStart: meter.periodStart,
+				periodEnd: meter.periodEnd,
+				includedUnits: meter.includedUnits,
+				consumedUnits: fromMicroUnits(consumed),
+				creditedUnits: fromMicroUnits(credited),
+				balance: fromMicroUnits(balance),
+				overageUnits: fromMicroUnits(balance < 0n ? -balance : 0n),
+				pendingUnits: fromMicroUnits(pendingMicro),
+				standing,
+				billable: meter.billable,
+				amountDueMinor: meter.amountDueMinor,
+				currency: meter.currency,
+				capReached: meter.billable && meter.capReached === true,
+				source
+			}
+		};
+	}
+	/** Fallback value: the account's coarse facts from `cache` if it holds them, else the default plan's credit; zero consumption. */
+	function fallbackOf(ref, code, pending) {
+		const def = facts.meters.get(code);
+		const coarse = cache?.peek(ref)?.meters?.[code];
+		const includedMicro = coarse !== void 0 ? coarse.includedUnits === null ? null : micro(coarse.includedUnits) : defaultCredits.get(code) ?? null;
+		const credited = includedMicro ?? 0n;
+		const consumed = pendingMicroOf(def, pending, Number.NEGATIVE_INFINITY, 0n);
+		const balance = credited - consumed;
+		const standing = worse(isStanding(coarse?.standing) ? coarse.standing : "ok", standingOf({
+			creditedMicro: credited,
+			consumedMicro: consumed,
+			lowAt: def.lowAt
+		}));
+		return {
+			balanceMicro: balance,
+			value: {
+				periodStart: null,
+				periodEnd: null,
+				includedUnits: includedMicro === null ? null : fromMicroUnits(includedMicro),
+				consumedUnits: fromMicroUnits(consumed),
+				creditedUnits: fromMicroUnits(credited),
+				balance: fromMicroUnits(balance),
+				overageUnits: fromMicroUnits(balance < 0n ? -balance : 0n),
+				pendingUnits: fromMicroUnits(consumed),
+				standing,
+				billable: coarse?.billable === true,
+				amountDueMinor: null,
+				currency: null,
+				capReached: false,
+				source: "fallback"
+			}
+		};
+	}
+	function fellBack(event) {
+		if (onFallback === void 0) return;
+		try {
+			onFallback(event);
+		} catch (error) {
+			logger.warn("Meters onFallback threw", {
+				ref: event.ref,
+				error: String(error)
+			});
+		}
+	}
+	function warnUnavailable(ref, snap) {
+		const failure = entries.get(ref)?.failure;
+		if (failure && failure.error === snap.error) {
+			if (failure.warned === "fallback") return;
+			failure.warned = "fallback";
+		}
+		const { code } = fieldsOf(snap.error);
+		logger.warn("steward meters unreadable, no stale value; using the catalog fallback", {
+			ref,
+			code
+		});
+	}
+	/** One meter of a snapshot; a catalog meter steward does not report gets the catalog value. */
+	function meterOf(ref, code, snap, pending) {
+		const def = facts.meters.get(code);
+		const reported = Object.hasOwn(snap.body.meters, code) ? snap.body.meters[code] : void 0;
+		if (reported !== void 0) return computed(reported, def, pending, snap.bodyAt - rollupLagMs(snap.body), snap.source);
+		if (!warnedMissing.has(code)) {
+			warnedMissing.add(code);
+			logger.warn("steward does not report a catalog meter (catalog not pushed?); using the catalog value", { meter: code });
+		}
+		fellBack({
+			ref,
+			meter: code,
+			reason: "meter_not_found"
+		});
+		return fallbackOf(ref, code, pending);
+	}
+	function requireMeter(name, meter) {
+		if (typeof meter !== "string" || !facts.meters.has(meter)) throw new StewardConfigError({
+			code: "unknown_meter",
+			message: `Meters.${name}: not a catalog meter: ${JSON.stringify(meter)}`
+		});
+	}
+	const pendingOf = (ref) => events?.pending(ref) ?? [];
+	return {
+		async get(ref, readOptions = {}) {
+			const snap = await snapshot(ref, readOptions.fresh === true);
+			const pending = pendingOf(ref);
+			const out = {};
+			if (snap.kind === "fallback") {
+				warnUnavailable(ref, snap);
+				fellBack({
+					ref,
+					meter: null,
+					reason: fieldsOf(snap.error).code ?? "unknown"
+				});
+				for (const code of facts.meters.keys()) out[code] = fallbackOf(ref, code, pending).value;
+				return out;
+			}
+			for (const code of facts.meters.keys()) out[code] = meterOf(ref, code, snap, pending).value;
+			for (const [code, meter] of Object.entries(snap.body.meters)) if (!Object.hasOwn(out, code)) out[code] = computed(meter, void 0, pending, 0, snap.source).value;
+			return out;
+		},
+		async balance(ref, meter, readOptions = {}) {
+			requireMeter("balance", meter);
+			const snap = await snapshot(ref, readOptions.fresh === true);
+			const pending = pendingOf(ref);
+			if (snap.kind === "value") return meterOf(ref, meter, snap, pending).value;
+			warnUnavailable(ref, snap);
+			fellBack({
+				ref,
+				meter,
+				reason: fieldsOf(snap.error).code ?? "unknown"
+			});
+			return fallbackOf(ref, meter, pending).value;
+		},
+		async check(ref, meter, checkOptions = {}) {
+			requireMeter("check", meter);
+			const units = checkOptions.units ?? 1;
+			const unitsMicro = typeof units === "number" ? parseMicroUnits(units) : null;
+			if (unitsMicro === null) throw new StewardConfigError({
+				code: "invalid_units",
+				message: `Meters.check: units must be a finite, non-negative number: ${String(units)}`
+			});
+			const snap = await snapshot(ref, checkOptions.fresh === true);
+			const pending = pendingOf(ref);
+			const result = ({ value, balanceMicro }, allowed) => ({
+				allowed: allowed ?? (value.billable ? !value.capReached : value.includedUnits === null || balanceMicro >= unitsMicro),
+				balance: value.balance,
+				standing: value.standing,
+				billable: value.billable,
+				source: value.source
+			});
+			if (snap.kind === "value") return result(meterOf(ref, meter, snap, pending));
+			warnUnavailable(ref, snap);
+			const fallback = fallbackOf(ref, meter, pending);
+			let allowed;
+			if (typeof policy === "function") try {
+				allowed = policy({
+					ref,
+					meter,
+					units,
+					balance: fallback.value,
+					error: snap.error
+				}) === true;
+			} catch (error) {
+				logger.warn("Meters onUnavailable threw; the steward error is thrown", {
+					ref,
+					meter,
+					error: String(error)
+				});
+				throw snap.error;
+			}
+			else allowed = policy === "allow";
+			fellBack({
+				ref,
+				meter,
+				reason: fieldsOf(snap.error).code ?? "unknown"
+			});
+			return result(fallback, allowed);
+		},
+		invalidate(ref) {
+			const flight = flights.get(ref);
+			if (flight) {
+				flight.invalidated = true;
+				flights.delete(ref);
+			}
+			const entry = entries.get(ref);
+			if (entry) Object.assign(entry, {
+				expiresAt: Number.NEGATIVE_INFINITY,
+				failure: null
+			});
+		}
+	};
+}
+//#endregion
+export { ACCOUNT_INCLUDES, API_VERSION, AccessStateSchema, AccountBenefitSchema, AccountDeleteResponseSchema, AccountDetailSchema, AccountDunningStateSchema, AccountLocaleSchema, AccountMeterSchema, AccountMeterStateSchema, AccountMetersSchema, AccountMetersStateSchema, AccountOpenCheckoutSchema, AccountOpenInvoiceSchema, AccountProfileStateSchema, AccountScheduledChangeSchema, AccountSchema, AccountStateSchema, AccountSubscriptionStateSchema, AccountUpsertInputSchema, AccountUpsertResponseSchema, AccountsRefreshResultSchema, ActorRefSchema, AmountMinorSchema, AnyBillingEventSchema, ApiVersionSchema, BENEFIT_TYPES, BILLING_PATH_PLACEHOLDERS, BankTransferInstructionsEmailSchema, BankTransferPaymentDaysSchema, BankTransferRecordInputSchema, BankTransferRecordedSchema, BankTransferSettingsPatchSchema, BankTransferSettingsSchema, BenefitDefSchema, BenefitDescriptionSchema, BenefitSourceSchema, BenefitTypeSchema, BillingEventSchema, BillingPathSchema, BillingProfileKindSchema, BillingProfileSchema, BillingSettingsPatchSchema, BillingSettingsSchema, BrandingPatchSchema, BrandingSchema, CHECKOUT_ERRORS, CancelSubscriptionInputSchema, CancelSubscriptionResponseSchema, CatalogBenefitSchema, CatalogMeterSchema, CatalogPlanSchema, CatalogSchema, CatalogSyncInputSchema, CatalogSyncResultSchema, ChangeSubscriptionResponseSchema, CheckoutConsentInputSchema, CheckoutPrefillSchema, CheckoutSessionCreateInputSchema, CheckoutSessionCreatedSchema, CheckoutSessionResponseSchema, CheckoutSessionSchema, CheckoutStatusSchema, CodeSchema, ConsentSchema, CreditGrantInputSchema, CreditGrantResponseSchema, CurrencySchema, DEFAULT_BANK_TRANSFER_PAYMENT_DAYS, DEFAULT_CHECKOUT_TTL_MINUTES, DEFAULT_ENDPOINT_EVENT_TYPES, DEFAULT_EVENT_RETENTION_DAYS, DEFAULT_LATE_GRACE_MINUTES, DEFAULT_METER_CHARGE_MODE, DEFAULT_METER_LOW_AT, DEFAULT_MIN_INVOICE_MINOR, DEFAULT_PAYMENT_DUE_DAYS, DEFAULT_PORTAL_TTL_MINUTES, DOCTOR_PENDING_BACKLOG_MS, DOCTOR_PROVIDER_ENVIRONMENTS, DOCTOR_REQUIRED_BRANDING, DOCTOR_REQUIRED_LEGAL_LINKS, DOCTOR_ROLLUP_LAG_WARN_SECONDS, DOCTOR_SEVERITIES, DateTimeSchema, DecimalUnitsStringSchema, DoctorBillingSchema, DoctorCatalogSchema, DoctorEmailsSchema, DoctorEndpointSchema, DoctorEventsSchema, DoctorHostedSchema, DoctorOverageSchema, DoctorProviderSchema, DoctorReportSchema, DoctorSettingsSchema, DoctorSeveritySchema, DoctorUnsellablePriceSchema, DoctorWarningSchema, EMAIL_LOCALES, EMAIL_PAYLOAD_SCHEMAS, EMAIL_TEMPLATES, EMAIL_TEMPLATE_BY_EVENT, ERROR_CATEGORIES, ERROR_CODES, EVENTS_INGEST_MAX_BYTES, EVENTS_INGEST_MAX_EVENTS, EVENTS_RECENT_MS, EVENT_DETAIL_SCHEMAS, EVENT_METADATA_KEY_MAX_LENGTH, EVENT_METADATA_MAX_PAIRS, EVENT_METADATA_STRING_MAX_LENGTH, EVENT_NAME_MAX_LENGTH, EVENT_TIMESTAMP_MAX_AGE_DAYS, EVENT_TIMESTAMP_MAX_SKEW_MINUTES, EVENT_TYPES, EmailExtraTextSchema, EmailSenderSchema, EmailSettingsPatchSchema, EmailSettingsSchema, EmailTemplateSchema, EmailTemplateSettingsSchema, EntitlementSnapshotSchema, EntitlementValueSchema, EntitlementsSchema, ErrorCategorySchema, ErrorResponseSchema, EventExternalIdSchema, EventIdSchema, EventMetadataKeySchema, EventMetadataSchema, EventMetadataValueSchema, EventNameSchema, EventRetentionDaysSchema, EventTypeSchema, Events, EventsIngestInputSchema, EventsIngestResultSchema, EventsSettingsPatchSchema, EventsSettingsSchema, ExternalRefSchema, FEATURE_FLAG_BENEFIT_TYPE, FULL_STATE_EVENT_TYPES, FeatureDefSchema, FeatureFlagBenefitDefSchema, FeatureFlagPropertiesSchema, FeatureTypeSchema, GrantCreateInputSchema, GrantCreateResponseSchema, GrantSchema, HEADER_ACTOR_REF, HEADER_API_VERSION, HEADER_IDEMPOTENCY_KEY, HEADER_REQUEST_ID, HEADER_SDK, INDIVIDUAL_IDENTITY_PLACEHOLDER, INGEST_REJECT_CODES, INVOICE_BILLING_REASONS, INVOICE_PAYMENT_STATUSES, IdSchema, IngestEventSchema, IngestRejectCodeSchema, IngestRejectionSchema, IntervalSchema, InvalidUnitValueError, InvoiceBillingReasonSchema, InvoiceIssueInputSchema, InvoiceIssueResponseSchema, InvoiceLineSchema, InvoicePaymentDueEmailSchema, InvoicePaymentSessionCreateInputSchema, InvoicePaymentSessionSchema, InvoicePaymentStatusSchema, InvoiceSchema, InvoiceStatusSchema, InvoiceVoidInputSchema, InvoiceVoidResponseSchema, InvoiceWaiveInputSchema, InvoiceWaiveResponseSchema, LEGACY_EVENT_TYPES, LIVE_SUBSCRIPTION_STATUSES, LateGraceMinutesSchema, MANUAL_INVOICE_MAX_AMOUNT_MINOR, MAX_CATALOG_BENEFITS, MAX_CATALOG_METERED_PRICES, MAX_CATALOG_METERS, MAX_CHECKOUT_CONSENT_DOCS, MAX_GRANT_BENEFITS, MAX_METERED_PRICE_PER_UNITS, MAX_METER_UNITS, MAX_NOTIFICATION_EMAILS, MAX_PLAN_BENEFITS, METERED_PRICE_TAX_MISMATCH, METER_AGGREGATION_KINDS, METER_CHARGE_MODES, METER_CHARGE_STATUSES, METER_CREDIT_ENTRY_KINDS, METER_FILTER_MAX_CONDITIONS, METER_FILTER_MAX_DEPTH, METER_FILTER_OPERATORS, METER_PERIOD_STATUSES, METER_STANDINGS, MICRO_UNITS_PER_UNIT, ManualInvoiceInputSchema, ManualInvoiceLineInputSchema, ManualInvoiceResponseSchema, MeResponseSchema, MetadataSchema, MeterAggregationSchema, MeterChargeLineSchema, MeterChargeListSchema, MeterChargeModeSchema, MeterChargeSchema, MeterChargeStatusSchema, MeterCreditBenefitDefSchema, MeterCreditEntryKindSchema, MeterCreditEntrySchema, MeterCreditPropertiesSchema, MeterDefSchema, MeterFilterSchema, MeterLabelSchema, MeterLowAtSchema, MeterPeriodListSchema, MeterPeriodSchema, MeterPeriodStatusSchema, MeterStandingSchema, MeterUnitsSchema, MeteredPriceDefSchema, MeteredPriceSchema, MeteringSettingsPatchSchema, MeteringSettingsSchema, Meters, NoticedMeteredRateSchema, NotificationEmailsSchema, OVERRIDE_BENEFIT_SOURCE, PAYMENT_METHODS, PING_EVENT_TYPE, PLAN_SET_MODES, PORTAL_SESSION_ERRORS, PaymentDueDaysSchema, PaymentMethodSchema, PaymentSchema, PingSchema, PlanDefSchema, PlanSetInputSchema, PlanSetModeSchema, PlanSetResponseSchema, PlanSetWarningSchema, PortalSessionCreateInputSchema, PortalSessionSchema, PriceChangeNoticeEmailSchema, PriceChangeNoticeMeteredRateSchema, PriceDefSchema, PriceSchema, ProductSettingsPatchSchema, ProductSettingsSchema, ProviderPayloadSchema, ResyncResultSchema, ReturnOriginSchema, SETTINGS_LOCALES, STEWARD_CAPABILITIES, SettingsLocaleSchema, StatsSchema, StewardApiError, StewardConfigError, StewardContractError, StewardError, StewardNetworkError, SubscriptionChangeInputSchema, SubscriptionSchema, SubscriptionStatusSchema, SubscriptionSummarySchema, TtlMinutesSchema, UNIT_DECIMALS, UncancelSubscriptionResponseSchema, WEBHOOK_ENDPOINT_STATUSES, WEBHOOK_SECRET_PREFIX, WebUrlSchema, WebhookEndpointCreateInputSchema, WebhookEndpointListSchema, WebhookEndpointRotateInputSchema, WebhookEndpointSchema, WebhookEndpointStatusSchema, WebhookLastDeliverySchema, WebhookSecretSchema, addUtcMonths, applyEmailSettingsPatch, applySettingsPatch, billingPageUrl, billingSettingsOf, buildDoctorReport, canonicalMeterFilter, checkoutRedirectUrl, consumptionOf, contributionOf, count, createSteward, defineCatalog, emailLocaleOf, emailReadinessOf, emailRecipients, emailTemplateOf, emailTemplateSettings, endpointDiagnosisOf, errorCodeSpec, eventsSettingsOf, featureFlag, featureValueMatchesType, flag, fromMicroUnits, generateWebhookSecret, hasControlCharacters, hostedReadinessOf, httpStatusFor, isE164, isEmailRelevant, isEventTimestampInRange, isEventType, isFeatureFlagBenefit, isGrantActive, isKnownErrorCode, isLiveSubscriptionStatus, isMeterCreditBenefit, isMicroPrecise, isReturnUrlAllowed, isValidTckn, isValidVkn, limit, liveSubscriptionOf, manualInvoiceTotals, matchesFilter, max, meter, meterChargeTotals, meterCredit, meterCreditsOf, meterFilterClauseOf, meteringSettingsOf, microToDecimalString, overageCapReached, overageOf, parseMicroUnits, periodBoundsOf, plainDecimalOf, rateOverage, resolveBenefits, resolveEntitlements, returnOriginsOf, rolloverOf, splitInclusiveTax, standingOf, stateCache, sum, text, toMicroUnits, unique, uniqueEmails, webhookEndpointUrlProblem };