@fabricorg/platform 1.10.0 → 1.10.1

package/dist/adapters/index.js

@@ -1,3 +1,683 @@
-export { AdapterCircuitBreakerRegistry, AdapterCircuitOpenError, AdapterRegistry, InMemoryAdapterCircuitBreaker, MissingAdapterRegistrationError, assertAdapterCircuitBreakerConfig, assertAdapterOutcomeConsistency, classifyAdapterOutcome, classifyCircuitBreakerOutcome, executeWithAdapterRetry, getRetryDelayMs, isAdapterCircuitOpenError, resolveAdapterRetryPolicy, scopedAdapterCircuitBreakerKey, shouldRetryAdapterOutcome } from '../chunk-Q4Q4JPR3.js';
-//# sourceMappingURL=index.js.map
+//#region adapters/circuit-breaker.ts
+/**
+* Map an {@link AdapterOutcomeKind} to how it counts toward a circuit breaker.
+*
+* | Outcome kind        | Counts as |
+* |---------------------|-----------|
+* | `success`           | `success` |
+* | `transient_failure` | `failure` |
+* | `timeout`           | `failure` |
+* | `ambiguous`         | `failure` |
+* | `permanent_failure` | `ignored` |
+*
+* `ambiguous` counts as a failure: the dependency did not give a definite
+* answer, which is a health signal even though the Host routes the invocation
+* to reconciliation. `permanent_failure` (validation or rejection) is the
+* dependency working correctly and saying no, so it does not trip the breaker.
+* `executeWithAdapterRetry` classifies a thrown error with the caller's
+* `classifyThrownError` (default `transient_failure`) and maps that kind here,
+* so an unclassified thrown error counts as a failure.
+*/
+function classifyCircuitBreakerOutcome(kind) {
+	switch (kind) {
+		case "success": return "success";
+		case "permanent_failure": return "ignored";
+		case "transient_failure":
+		case "timeout":
+		case "ambiguous": return "failure";
+		default: return "failure";
+	}
+}
+const MANUAL_OVERRIDES = ["force_open", "force_closed"];
+/**
+* Validate a circuit-breaker config. Throws a `RangeError` naming the first
+* invalid field: `mode` must be `monitor` or `enforce`; `failureThreshold` and
+* `minimumSamples` positive integers; `windowMs` and `probeLeaseMs` positive
+* finite numbers; `cooldownMs` a non-negative finite number; `manualOverride`
+* `force_open` or `force_closed` when present.
+*/
+function assertAdapterCircuitBreakerConfig(config) {
+	if (!config || typeof config !== "object") throw new RangeError("Adapter circuit breaker config must be an object.");
+	if (config.mode !== "monitor" && config.mode !== "enforce") throw new RangeError(`Adapter circuit breaker mode must be "monitor" or "enforce"; got ${JSON.stringify(config.mode)}.`);
+	if (!Number.isInteger(config.failureThreshold) || config.failureThreshold < 1) throw new RangeError(`Adapter circuit breaker failureThreshold must be a positive integer; got ${String(config.failureThreshold)}.`);
+	if (typeof config.windowMs !== "number" || !Number.isFinite(config.windowMs) || config.windowMs <= 0) throw new RangeError(`Adapter circuit breaker windowMs must be a positive number of milliseconds; got ${String(config.windowMs)}.`);
+	if (typeof config.cooldownMs !== "number" || !Number.isFinite(config.cooldownMs) || config.cooldownMs < 0) throw new RangeError(`Adapter circuit breaker cooldownMs must be a non-negative number of milliseconds; got ${String(config.cooldownMs)}.`);
+	if (config.minimumSamples !== void 0 && (!Number.isInteger(config.minimumSamples) || config.minimumSamples < 1)) throw new RangeError(`Adapter circuit breaker minimumSamples must be a positive integer; got ${String(config.minimumSamples)}.`);
+	if (config.probeLeaseMs !== void 0 && (typeof config.probeLeaseMs !== "number" || !Number.isFinite(config.probeLeaseMs) || config.probeLeaseMs <= 0)) throw new RangeError(`Adapter circuit breaker probeLeaseMs must be a positive number of milliseconds; got ${String(config.probeLeaseMs)}.`);
+	if (config.manualOverride !== void 0 && !MANUAL_OVERRIDES.includes(config.manualOverride)) throw new RangeError(`Adapter circuit breaker manualOverride must be "force_open" or "force_closed"; got ${JSON.stringify(config.manualOverride)}.`);
+}
+/**
+* Dependency-free, in-process circuit breaker for one adapter operation.
+*
+* State lives in this instance only: it is not shared between processes,
+* hosts, or replicas, and it is lost on restart. Each replica trips on the
+* failures it observes itself.
+*
+* Tripping rule (parity with the .NET `InMemoryAdapterCircuitBreaker`): after
+* a failure is recorded while `closed`, let `N` be the outcomes recorded within
+* the last `windowMs` and `M = minimumSamples ?? failureThreshold`. The breaker
+* opens when `N >= M` and either
+* 1. the most recent `failureThreshold` outcomes in the window are all
+*    failures, or
+* 2. the failure ratio in the window is at least `failureThreshold / M`.
+*
+* With `minimumSamples` omitted this reads "`failureThreshold` consecutive
+* failures". With `minimumSamples: 20, failureThreshold: 10` it also opens at
+* a 50% failure rate over at least 20 calls.
+*
+* After `cooldownMs` the breaker turns `half_open` and admits one probe. A
+* probe success closes it and clears the window; a probe failure reopens it
+* and restarts the cooldown. At most one probe is outstanding at a time: it
+* holds a lease of `probeLeaseMs` (default `max(cooldownMs, windowMs)`, never
+* derived from the cooldown alone, so `cooldownMs: 0` still admits one probe).
+* A probe that has not recorded when its lease expires is considered lost and
+* the next call becomes the probe.
+*
+* Epochs: the breaker keeps a generation counter that advances on every state
+* change (including one committed by an elapsed cooldown), every manual
+* override change, and every probe grant. Each admission carries the
+* generation it was granted in. `record` first commits any elapsed cooldown,
+* then compares generations. An outcome from an earlier epoch is stale: it is
+* dropped entirely. It changes no state, does not resolve or free the probe
+* slot, and is not added to the rolling window, so it cannot contribute to a
+* later trip either. Because a probe grant starts a new epoch, the outstanding
+* probe is the only `probe: true` admission of the current epoch, which is how
+* a replaced probe's late outcome is told apart. An outcome recorded without an
+* admission, or with one that has no `generation`, is treated as current: it is
+* sampled, can trip a closed breaker and resolves an outstanding probe.
+*
+* Telemetry is buffered and delivered after each operation commits. An
+* elapsed cooldown is committed, and its `cooldown_elapsed` event delivered,
+* as a step of its own before `acquire`, `record`, `getState` or
+* `setManualOverride` continues, so a callback reacting to it (for example by
+* forcing the breaker open) governs the call that observed it. Every other
+* event is delivered once the method's decision or record is final, and a
+* callback never revokes an admission that is already committed. Two cases
+* follow from that: a breaker call made from inside a callback queues its own
+* `cooldown_elapsed` behind the current delivery and decides first; and with
+* `cooldownMs: 0`, a cooldown that falls due again during the decision (because
+* a callback reopened the breaker) is committed and admitted before its event
+* is delivered.
+*
+* `monitor` mode runs the same state machine and reports the same telemetry
+* but admits every call; calls enforce mode would have refused are reported
+* as `would_reject`.
+*
+* A manual override pins the reported state (`force_open` → `open`,
+* `force_closed` → `closed`) and suspends automatic transitions while set;
+* outcomes of calls admitted under the override are still recorded. Like an
+* automatic open, `force_open` blocks only in `enforce` mode. Clearing the
+* override returns the breaker to `closed` with its window intact.
+*/
+var InMemoryAdapterCircuitBreaker = class {
+	key;
+	mode;
+	config;
+	now;
+	onEvent;
+	probeLeaseMs;
+	samples = [];
+	state = "closed";
+	openedAt = 0;
+	probeIssuedAt;
+	/** Advances on every state change, manual override change and probe grant. */
+	generation = 0;
+	manualOverride;
+	/** Telemetry waiting for the current operation to commit. */
+	outbox = [];
+	operationDepth = 0;
+	flushing = false;
+	constructor(options) {
+		assertAdapterCircuitBreakerConfig(options.config);
+		this.key = options.key;
+		this.config = { ...options.config };
+		this.mode = options.config.mode;
+		this.now = options.now ?? Date.now;
+		this.onEvent = options.onEvent;
+		this.manualOverride = options.config.manualOverride;
+		this.probeLeaseMs = options.config.probeLeaseMs ?? Math.max(options.config.cooldownMs, options.config.windowMs);
+	}
+	getState() {
+		this.settle(this.now());
+		return this.reportedState();
+	}
+	getManualOverride() {
+		return this.manualOverride;
+	}
+	/**
+	* Set (`force_open` / `force_closed`) or clear (`undefined`) the manual
+	* override. Clearing returns the breaker to `closed` with its window intact.
+	*/
+	setManualOverride(override) {
+		if (override !== void 0 && !MANUAL_OVERRIDES.includes(override)) throw new RangeError(`Adapter circuit breaker manualOverride must be "force_open" or "force_closed"; got ${JSON.stringify(override)}.`);
+		const now = this.now();
+		this.settle(now);
+		if (override === this.manualOverride) return;
+		this.operation(() => {
+			const from = this.reportedState();
+			this.manualOverride = override;
+			this.generation++;
+			if (override === void 0) {
+				this.state = "closed";
+				this.releaseProbe();
+			}
+			this.emit({
+				type: "state_change",
+				key: this.key,
+				mode: this.mode,
+				at: now,
+				from,
+				to: this.reportedState(),
+				reason: override === void 0 ? "manual_override_cleared" : "manual_override",
+				...override ? { manualOverride: override } : {}
+			});
+		});
+	}
+	check() {
+		return this.decide(false, this.now());
+	}
+	acquire() {
+		const now = this.now();
+		this.settle(now);
+		return this.operation(() => this.decide(true, now));
+	}
+	record(outcome, admission) {
+		const now = this.now();
+		this.settle(now);
+		this.operation(() => this.applyOutcome(outcome, admission, now));
+	}
+	applyOutcome(outcome, admission, now) {
+		const generation = admission?.generation;
+		if (generation !== void 0 && generation !== this.generation) return;
+		const resolvesProbe = this.state === "half_open" && this.probeIssuedAt !== void 0 && (generation === void 0 || admission?.probe === true);
+		if (outcome === "ignored") {
+			if (resolvesProbe) this.releaseProbe();
+			return;
+		}
+		this.prune(now);
+		this.samples.push({
+			at: now,
+			failure: outcome === "failure"
+		});
+		if (this.manualOverride) return;
+		if (resolvesProbe) {
+			this.releaseProbe();
+			if (outcome === "success") {
+				this.samples = [];
+				this.transition("closed", "probe_succeeded", now);
+			} else {
+				this.openedAt = now;
+				this.transition("open", "probe_failed", now);
+			}
+			return;
+		}
+		if (this.state === "closed" && outcome === "failure" && this.shouldTrip()) {
+			this.openedAt = now;
+			this.transition("open", "failure_threshold", now);
+		}
+	}
+	/**
+	* `take` is false for {@link check}: a pure preview that sees an elapsed
+	* cooldown without committing it, takes no probe and emits nothing.
+	*/
+	decide(take, now) {
+		if (this.manualOverride === "force_closed") return {
+			allowed: true,
+			state: "closed",
+			probe: false,
+			manualOverride: "force_closed",
+			generation: this.generation
+		};
+		if (this.manualOverride === "force_open") return this.refuse(take, {
+			state: "open",
+			manualOverride: "force_open"
+		});
+		const cooldownElapsed = this.state === "open" && now - this.openedAt >= this.config.cooldownMs;
+		if (take) this.advance(now);
+		const state = !take && cooldownElapsed ? "half_open" : this.state;
+		if (state === "closed") return {
+			allowed: true,
+			state: "closed",
+			probe: false,
+			generation: this.generation
+		};
+		if (state === "open") return this.refuse(take, {
+			state: "open",
+			retryAfterMs: Math.max(0, this.openedAt + this.config.cooldownMs - now)
+		});
+		if (!(!take && cooldownElapsed || this.probeIssuedAt === void 0 || now - this.probeIssuedAt >= this.probeLeaseMs)) return this.refuse(take, { state: "half_open" });
+		if (!take) return {
+			allowed: true,
+			state: "half_open",
+			probe: true,
+			generation: this.generation
+		};
+		this.probeIssuedAt = now;
+		this.generation++;
+		return {
+			allowed: true,
+			state: "half_open",
+			probe: true,
+			generation: this.generation
+		};
+	}
+	refuse(take, detail) {
+		const enforce = this.mode === "enforce";
+		if (take) this.emit({
+			type: enforce ? "rejected" : "would_reject",
+			key: this.key,
+			mode: this.mode,
+			at: this.now(),
+			...detail
+		});
+		const generation = this.generation;
+		return enforce ? {
+			allowed: false,
+			probe: false,
+			...detail,
+			generation
+		} : {
+			allowed: true,
+			probe: false,
+			wouldReject: true,
+			...detail,
+			generation
+		};
+	}
+	releaseProbe() {
+		this.probeIssuedAt = void 0;
+	}
+	/** Apply the time-based open → half_open transition. */
+	advance(now) {
+		if (this.state === "open" && now - this.openedAt >= this.config.cooldownMs) {
+			this.releaseProbe();
+			this.transition("half_open", "cooldown_elapsed", now);
+		}
+	}
+	shouldTrip() {
+		const minimumSamples = this.config.minimumSamples ?? this.config.failureThreshold;
+		const total = this.samples.length;
+		if (total < minimumSamples) return false;
+		let consecutive = 0;
+		for (let index = total - 1; index >= 0 && this.samples[index].failure; index--) consecutive++;
+		if (consecutive >= this.config.failureThreshold) return true;
+		return this.samples.reduce((count, sample) => count + (sample.failure ? 1 : 0), 0) / total >= this.config.failureThreshold / minimumSamples;
+	}
+	prune(now) {
+		const cutoff = now - this.config.windowMs;
+		let drop = 0;
+		while (drop < this.samples.length && this.samples[drop].at < cutoff) drop++;
+		if (drop > 0) this.samples.splice(0, drop);
+	}
+	transition(to, reason, at) {
+		const from = this.state;
+		if (from === to) return;
+		this.state = to;
+		this.generation++;
+		this.emit({
+			type: "state_change",
+			key: this.key,
+			mode: this.mode,
+			at,
+			from,
+			to,
+			reason
+		});
+	}
+	reportedState() {
+		if (this.manualOverride) return this.manualOverride === "force_open" ? "open" : "closed";
+		return this.state;
+	}
+	/**
+	* Commit an elapsed cooldown as an operation of its own, delivering its
+	* event before the caller's operation reads state.
+	*/
+	settle(now) {
+		if (this.manualOverride) return;
+		this.operation(() => this.advance(now));
+	}
+	/**
+	* Run `step` to completion, then deliver the telemetry it produced. The
+	* return value is fixed before any listener runs.
+	*/
+	operation(step) {
+		this.operationDepth++;
+		try {
+			return step();
+		} finally {
+			this.operationDepth--;
+			if (this.operationDepth === 0) this.flush();
+		}
+	}
+	emit(event) {
+		if (this.onEvent) this.outbox.push(event);
+	}
+	/**
+	* Deliver buffered events in order. A listener that calls back into the
+	* breaker queues its own events; this loop delivers them after it returns
+	* instead of recursing.
+	*/
+	flush() {
+		if (this.flushing) return;
+		this.flushing = true;
+		try {
+			for (let event = this.outbox.shift(); event; event = this.outbox.shift()) this.deliver(event);
+		} finally {
+			this.flushing = false;
+		}
+	}
+	deliver(event) {
+		const listener = this.onEvent;
+		if (!listener) return;
+		try {
+			const result = listener(event);
+			if (result && typeof result.then === "function") result.then(void 0, () => void 0);
+		} catch {}
+	}
+};
+/**
+* Key by tenant, optional space, vendor, and adapter operation. Components are
+* URI-encoded to distinguish embedded delimiters; ordinary adapter identifiers
+* remain readable as the trailing `adapterType:operation`.
+*
+* Missing scope uses a separate `unscoped` namespace (still split by vendor)
+* rather than rejecting the call. Calls without scope share that
+* namespace; callers must supply scope for tenant isolation. Missing space or
+* vendor is distinct from an empty string. `vendor` is required by the public
+* adapter type, but its absence is tolerated for JavaScript callers.
+* Keys appear in errors and telemetry: use non-secret identifiers.
+*/
+function scopedAdapterCircuitBreakerKey(adapter, scope) {
+	return [
+		scope === void 0 ? "unscoped" : `tenant=${encodeURIComponent(scope.tenantId)}`,
+		scope?.spaceId === void 0 ? "space" : `space=${encodeURIComponent(scope.spaceId)}`,
+		adapter.vendor === void 0 ? "vendor" : `vendor=${encodeURIComponent(adapter.vendor)}`,
+		encodeURIComponent(adapter.adapterType),
+		encodeURIComponent(adapter.operation)
+	].join(":");
+}
+/**
+* Lazily creates one {@link InMemoryAdapterCircuitBreaker} per
+* key, from that adapter's own `circuitBreaker` config. The default key is
+* `adapterType:operation`, shared across tenants and vendors; override it with
+* {@link AdapterCircuitBreakerRegistryOptions.key} to isolate invocation scopes.
+* Adapters without a config get no breaker. The first config seen for a key
+* wins; later conflicting configs reuse the existing breaker without throwing.
+* Share a key only between adapters intended to use the same configuration.
+*/
+var AdapterCircuitBreakerRegistry = class {
+	options;
+	breakers = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.options = options;
+	}
+	forAdapter(adapter, scope) {
+		if (!adapter.circuitBreaker) return void 0;
+		const key = this.options.key?.(adapter, scope) ?? `${adapter.adapterType}:${adapter.operation}`;
+		let breaker = this.breakers.get(key);
+		if (!breaker) {
+			breaker = new InMemoryAdapterCircuitBreaker({
+				key,
+				config: adapter.circuitBreaker,
+				...this.options.now ? { now: this.options.now } : {},
+				...this.options.onEvent ? { onEvent: this.options.onEvent } : {}
+			});
+			this.breakers.set(key, breaker);
+		}
+		return breaker;
+	}
+	/** Looks up the default `adapterType:operation` key without creating a breaker. */
+	get(adapterType, operation) {
+		return this.getByKey(`${adapterType}:${operation}`);
+	}
+	/** Looks up an exact key, including a custom key, without creating a breaker. */
+	getByKey(key) {
+		return this.breakers.get(key);
+	}
+};
+/**
+* Thrown by `executeWithAdapterRetry` when an `enforce`-mode breaker refuses
+* an attempt. The refused attempt never reached `execute`, so no external
+* effect happened for it.
+*/
+var AdapterCircuitOpenError = class extends Error {
+	name = "AdapterCircuitOpenError";
+	code = "ADAPTER_CIRCUIT_OPEN";
+	reason = "circuit_open";
+	adapterKey;
+	state;
+	/** The attempt number that was refused (1 = refused before any call). */
+	attempt;
+	retryAfterMs;
+	manualOverride;
+	/** Error of the previous attempt, when the breaker opened mid-retry. */
+	lastError;
+	constructor(input) {
+		const after = input.retryAfterMs !== void 0 ? `; retry after ${input.retryAfterMs} ms` : "";
+		super(`Adapter circuit is ${input.state === "half_open" ? "half-open with its probe in flight" : "open"} for ${input.adapterKey}; the call was not attempted${after}.`);
+		this.adapterKey = input.adapterKey;
+		this.state = input.state;
+		this.attempt = input.attempt;
+		if (input.retryAfterMs !== void 0) this.retryAfterMs = input.retryAfterMs;
+		if (input.manualOverride !== void 0) this.manualOverride = input.manualOverride;
+		if (input.lastError !== void 0) this.lastError = input.lastError;
+	}
+};
+/**
+* Recognise an {@link AdapterCircuitOpenError}, including one constructed by a
+* second copy of this package (for example an ESM and a CommonJS build loaded
+* side by side), where `instanceof` fails.
+*/
+function isAdapterCircuitOpenError(error) {
+	if (error instanceof AdapterCircuitOpenError) return true;
+	return typeof error === "object" && error !== null && error.name === "AdapterCircuitOpenError" && error.code === "ADAPTER_CIRCUIT_OPEN";
+}
+//#endregion
+//#region adapters/index.ts
+function adapterKey(adapterType, operation) {
+	return `${adapterType}:${operation}`;
+}
+var MissingAdapterRegistrationError = class extends Error {
+	constructor(adapterType, operation) {
+		super(`No adapter registered for adapterType "${adapterType}" and operation "${operation}"`);
+		this.name = "MissingAdapterRegistrationError";
+	}
+};
+var AdapterRegistry = class {
+	adapters = /* @__PURE__ */ new Map();
+	register(adapter) {
+		const key = adapterKey(adapter.adapterType, adapter.operation);
+		if (this.adapters.has(key)) throw new Error(`Adapter already registered for adapterType "${adapter.adapterType}" and operation "${adapter.operation}"`);
+		this.adapters.set(key, adapter);
+	}
+	resolve(adapterType, operation) {
+		return this.adapters.get(adapterKey(adapterType, operation));
+	}
+	require(adapterType, operation) {
+		const adapter = this.resolve(adapterType, operation);
+		if (!adapter) throw new MissingAdapterRegistrationError(adapterType, operation);
+		return adapter;
+	}
+};
+const DEFAULT_RETRY_POLICY = {
+	idempotent: true,
+	maxAttempts: 3,
+	initialDelayMs: 100,
+	backoffMultiplier: 2,
+	maxDelayMs: 1e3
+};
+const NO_RETRY_POLICY = {
+	idempotent: false,
+	maxAttempts: 1,
+	initialDelayMs: 0,
+	backoffMultiplier: 1,
+	maxDelayMs: 0
+};
+function resolveAdapterRetryPolicy(policy, defaultIdempotent) {
+	if (!(policy?.idempotent ?? defaultIdempotent)) return NO_RETRY_POLICY;
+	return {
+		idempotent: true,
+		maxAttempts: Math.max(1, Math.min(policy?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts, 5)),
+		initialDelayMs: Math.max(0, policy?.initialDelayMs ?? DEFAULT_RETRY_POLICY.initialDelayMs),
+		backoffMultiplier: Math.max(1, policy?.backoffMultiplier ?? DEFAULT_RETRY_POLICY.backoffMultiplier),
+		maxDelayMs: Math.max(0, policy?.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs)
+	};
+}
+function getRetryDelayMs(attempt, policy) {
+	const exponentialDelay = policy.initialDelayMs * policy.backoffMultiplier ** Math.max(0, attempt - 1);
+	return Math.min(exponentialDelay, policy.maxDelayMs);
+}
+/**
+* Classify an {@link AdapterExecutionResult} into an {@link AdapterOutcomeKind}.
+* When `outcome` is explicitly set, it is returned directly, after rejecting a
+* contradictory result where `success` is true but the outcome is non-success.
+* Otherwise a successful result maps to `success` and a failed result maps to
+* `transient_failure` (the historical default).
+*/
+function classifyAdapterOutcome(result) {
+	if (result.outcome) {
+		assertAdapterOutcomeConsistency(result);
+		return result.outcome;
+	}
+	return result.success ? "success" : "transient_failure";
+}
+/**
+* Determine whether an outcome kind is retryable. Only `transient_failure`
+* is retryable, and only when the adapter policy is idempotent. Permanent
+* failures, timeouts, and ambiguous outcomes are never retried.
+*/
+function shouldRetryAdapterOutcome(kind, idempotent) {
+	return kind === "transient_failure" && idempotent;
+}
+/**
+* Reject a contradictory adapter result where `success` is true but the
+* explicit `outcome` is a non-success kind. A successful result claiming an
+* ambiguous, permanent, timeout, or transient outcome is a programming
+* error — the adapter cannot have both succeeded and require reconciliation.
+*/
+function assertAdapterOutcomeConsistency(result) {
+	if (result.success && result.outcome && result.outcome !== "success") throw new Error(`Adapter returned success=true with contradictory outcome "${result.outcome}"; a successful result must not declare a non-success outcome.`);
+}
+/**
+* Record an outcome on the breaker. A breaker that throws must not turn a
+* call that already ran (and may have had its external effect) into a failure.
+*/
+function recordCircuitOutcome(breaker, outcome, admission) {
+	if (!breaker) return;
+	try {
+		breaker.record(outcome, admission);
+	} catch {}
+}
+function circuitOpenError(breaker, admission, attempt, lastError) {
+	return new AdapterCircuitOpenError({
+		adapterKey: breaker.key,
+		state: admission.state,
+		attempt,
+		...admission.retryAfterMs !== void 0 ? { retryAfterMs: admission.retryAfterMs } : {},
+		...admission.manualOverride !== void 0 ? { manualOverride: admission.manualOverride } : {},
+		...lastError !== void 0 ? { lastError } : {}
+	});
+}
+async function executeWithAdapterRetry(options) {
+	const policy = resolveAdapterRetryPolicy(options.policy, options.defaultIdempotent);
+	const sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+	const breaker = options.circuitBreaker;
+	let lastError;
+	for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+		let admission;
+		let executed = false;
+		let recorded = false;
+		const record = (outcome) => {
+			if (!executed || recorded) return;
+			recorded = true;
+			recordCircuitOutcome(breaker, outcome, admission);
+		};
+		let refusal;
+		/**
+		* Classify an error thrown by `prepareAttempt`, `execute` or a later
+		* step of this attempt. Returns "retry" after sleeping, "rethrow", or the
+		* breaker admission that refuses the retry.
+		*/
+		async function handleThrown(error) {
+			lastError = error instanceof Error ? error.message : String(error);
+			const thrownOutcome = options.classifyThrownError ? options.classifyThrownError(error) : "transient_failure";
+			record(classifyCircuitBreakerOutcome(thrownOutcome));
+			let willRetry = shouldRetryAdapterOutcome(thrownOutcome, policy.idempotent) && attempt < policy.maxAttempts;
+			const blocked = willRetry ? refusedRetry(breaker) : void 0;
+			if (blocked) willRetry = false;
+			const nextDelayMs = willRetry ? getRetryDelayMs(attempt, policy) : void 0;
+			await options.onAttempt?.({
+				attempt,
+				error: lastError,
+				willRetry,
+				nextDelayMs
+			});
+			if (blocked) return blocked;
+			if (!willRetry) return "rethrow";
+			await sleep(nextDelayMs ?? 0);
+			return "retry";
+		}
+		try {
+			if (options.prepareAttempt) await options.prepareAttempt(attempt, policy.maxAttempts);
+		} catch (error) {
+			const decision = await handleThrown(error);
+			if (decision === "rethrow") throw error;
+			if (decision === "retry") continue;
+			refusal = decision;
+		}
+		if (!refusal) {
+			if (breaker) {
+				admission = breaker.acquire();
+				if (!admission.allowed) throw circuitOpenError(breaker, admission, attempt, lastError);
+			}
+			try {
+				executed = true;
+				const result = await options.execute(attempt, policy.maxAttempts);
+				if (options.isSuccessful(result)) {
+					record("success");
+					await options.onAttempt?.({
+						attempt,
+						result,
+						willRetry: false
+					});
+					return result;
+				}
+				lastError = options.getError(result) ?? "Adapter returned unsuccessful result";
+				const outcome = options.classifyOutcome ? options.classifyOutcome(result) : "transient_failure";
+				record(classifyCircuitBreakerOutcome(outcome));
+				let willRetry = shouldRetryAdapterOutcome(outcome, policy.idempotent) && attempt < policy.maxAttempts;
+				refusal = willRetry ? refusedRetry(breaker) : void 0;
+				if (refusal) willRetry = false;
+				const nextDelayMs = willRetry ? getRetryDelayMs(attempt, policy) : void 0;
+				await options.onAttempt?.({
+					attempt,
+					result,
+					error: lastError,
+					willRetry,
+					nextDelayMs
+				});
+				if (!willRetry && !refusal) return result;
+				if (!refusal) await sleep(nextDelayMs ?? 0);
+			} catch (error) {
+				const decision = await handleThrown(error);
+				if (decision === "rethrow") throw error;
+				refusal = decision === "retry" ? void 0 : decision;
+			}
+		}
+		if (refusal && breaker) throw circuitOpenError(breaker, refusal, attempt + 1, lastError);
+	}
+	throw new Error(lastError ?? "Adapter retry exhausted");
+}
+/**
+* Preview whether an `enforce`-mode breaker would refuse the next attempt.
+* Returns the refusing admission, or undefined when the retry may proceed.
+*/
+function refusedRetry(breaker) {
+	if (!breaker) return void 0;
+	const preview = breaker.check();
+	return preview.allowed ? void 0 : preview;
+}
+//#endregion
+export { AdapterCircuitBreakerRegistry, AdapterCircuitOpenError, AdapterRegistry, InMemoryAdapterCircuitBreaker, MissingAdapterRegistrationError, assertAdapterCircuitBreakerConfig, assertAdapterOutcomeConsistency, classifyAdapterOutcome, classifyCircuitBreakerOutcome, executeWithAdapterRetry, getRetryDelayMs, isAdapterCircuitOpenError, resolveAdapterRetryPolicy, scopedAdapterCircuitBreakerKey, shouldRetryAdapterOutcome };
+
 //# sourceMappingURL=index.js.map