@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/sdk-init-Bln9rFtn.js

@@ -0,0 +1,4138 @@
+import "./_web-crypto-random-bytes-Bo-GTcRS.js";
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./libsodium-wrappers-BhbOA8dQ.js";
+import "./codecs-Dc1Krpbt.js";
+import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
+import { r as Milliseconds, s as Timestamp } from "./time.vo-tNheinXm.js";
+import { t as BigNumber } from "./bignum.vo-CEXOIew0.js";
+import { t as autoDismissFailureOnSuccess } from "./auto-dismiss-failure-on-success-s8MGDEIu.js";
+import "./retry-config-Dmgt28wM.js";
+import { t as ActivityType } from "./activity-type-GsJGWs-3.js";
+import { t as TokenId } from "./token-id.vo-Bvwhr3ZE.js";
+import { t as AuthenticationCancelledError } from "./types-CJT6XF2c.js";
+import { g as MidnightNetworkId, l as MidnightSDKTestNetworkId, x as getProofServerEndpoint, y as assertProofServerRouting } from "./const-D0CbQlo4.js";
+import { n as midnightContextActions } from "./slice-oWnc7YVD.js";
+import { c as toUnshieldedTokenType, o as hasMidnightAccount, s as isInMemoryMidnightAccount, t as convertHttpUrlToWebsocket } from "./utils-DFwzEvbv.js";
+import { t as midnightWalletsForRuntime } from "./midnight-wallet-DIsAlSn6.js";
+import { $ as makeSemaphore, $c as appendAll, $l as match$10, $o as all$2, Aa as interruptAs$1, Ac as void_$4, Al as unsafeGet$2, Au as FEATURE_FLAG_MIDNIGHT_SHIELDED_ACTIVITY_ROWS, B as flatten$6, Ba as fork, Bc as set$2, Cl as splitAt$1, Ct as runSync$1, D as dieMessage$2, Da as _await$1, Du as identity$2, Ec as sync$7, Es as catchAll$6, Eu as dual, Fa as Scope, Ga as die$7, Gc as size$8, Gl as splitAt, Go as capacity$8, Gs as deferredMake, Gt as zipRight$8, Ht as withFiberRuntime$1, Ia as addFinalizer$1, Io as update$1, Is as currentSchedulingPriority$1, J as ignoreLogged, Jl as getOrElse, Jo as offer$5, Js as deferredUnsafeMake, K as gen, Ka as fail$8, Ko as isEmpty$9, Ks as deferredSucceed, Kt as zipWith$7, L as fiberIdWith, La as addFinalizerExit, Lc as combineAll, M as exit, Mc as withFiberRuntime, Ml as unsafeLast, Mt as sync$8, N as fail$10, Nc as zipRight$6, No as make$18, Nt as tap$7, Oa as inheritAll, Oc as uninterruptible, Os as currentContext$1, Ot as scopedWith$3, Ou as pipe, P as failCause$8, Pc as SingleShotGen, Po as modify$1, Pt as tapErrorCause$4, Q as isEffect, Qa as isInterrupted, Qc as append, Qo as unbounded$8, Ra as close, Rc as get$4, Ro as Class, Rt as uninterruptible$1, S as catchAllCause$5, Sc as onInterrupt, St as runPromise$1, Tc as suspend$8, To as sequential$1, Ts as asVoid$1, Tt as scope$2, Tu as constVoid, U as forkDaemon, Ua as NoSuchElementException, Ul as fromIterable$2, Uo as EmptyMutableQueue, Us as deferredAwait, Ut as zip$4, V as forEach$2, Va as make$19, Vl as empty$4, Vt as when$2, W as forkIn, Wo as bounded$8, Ws as deferredInterruptWith, Wt as zipLeft$4, X as interruptible, Xa as interruptors, Xl as isNone, Xo as poll$4, Y as interrupt$4, Ya as interrupt$3, Yo as offerAll$4, Z as intoDeferred, Za as isDieType, Zl as isSome, Zo as pollUpTo, Zs as fiberId, _c as flatMap$7, _o as forEachParUnbounded, _s as isDone$1, _u as YieldWrap, as as isFailure, at as matchCause$2, au as right, b as cached$1, bs as succeed$11, bt as repeat$3, c as createProofServerAccess, cu as OP_COMMIT, d as EffectTypeId, ds as void_$5, du as symbol$1, el as drop$2, es as die$6, eu as none, f as _void, fl as isEmpty$8, fs as zip$5, fu as cached, g as as$5, gl as map$13, go as forEachConcurrentDiscard, gs as failCause$9, gt as race$3, gu as symbol, h as all$3, hu as random, i as MidnightSyncFailureId, it as match$11, iu as match$8, j as ensuring$5, ja as join, jc as whenEffect$2, jo as get$5, jt as suspend$9, ka as interrupt$2, kt as succeed$10, ll as fromIterable$3, ls as match$9, lu as pipeArguments, m as acquireUseRelease$1, ms as _await, mt as provideService$6, mu as hash, n as watchMidnightAccount, nl as empty$5, ns as failCause$7, nu as some$2, o as createAttestedProofServerAccess, ol as findFirst, os as isSuccess$1, ot as matchCauseEffect, ou as StreamTypeId$2, pl as isNonEmpty, ps as zipRight$7, pt as provide$2, pu as combine$2, q as ignore, qa as failureOrCause, qo as length, qs as deferredUnsafeDone, r as watchMidnightAccounts, rl as filter$3, rs as interrupt$5, rt as mapError$5, ru as left, s as createHttpProofServerTransport, ss as map$11, su as effectVariance, to as map$12, ts as fail$9, tt as map$10, u as createScopedProofServerAccess, us as succeed$9, uu as equals, v as asVoid$2, vc as interrupt$1, vl as of$2, vs as make$17, vt as raceWith$1, vu as internalCall, wc as succeed$8, wo as currentScheduler$1, wt as runtime, x as catchAll$7, xc as map$9, xl as reduce$2, y as async, yl as prepend$2, yu as hasProperty, z as flatMap$8, za as extend, zc as make$16, zl as unsafeGet$3, zt as uninterruptibleMask } from "./watch-CUEvcP-V.js";
+import { n as teeAttestationProgress$ } from "./send-proof-progress-C-ljq1x5.js";
+import { Percent, deepEquals } from "@laceio/cardano/util";
+import { EMPTY, Observable, catchError, combineLatest, concat, defaultIfEmpty, defer, distinctUntilChanged, exhaustMap, filter, firstValueFrom, forkJoin, from, groupBy, ignoreElements, map, merge, mergeMap, of, scan, shareReplay, switchMap, take, takeUntil, tap, throttleTime, throwError, throwIfEmpty, withLatestFrom, zip } from "rxjs";
+import isEqual from "lodash/isEqual.js";
+import { SerializedTransaction } from "@midnightntwrk/wallet-sdk-abstractions";
+import { DustAddress, ShieldedAddress, UnshieldedAddress } from "@midnightntwrk/wallet-sdk-address-format";
+import * as ledger from "@midnight-ntwrk/ledger-v8";
+import { PublicKey, UnshieldedWallet } from "@midnightntwrk/wallet-sdk/unshielded";
+import { SubmissionError } from "@midnightntwrk/wallet-sdk/capabilities/submission";
+import { NodeClientError, PolkadotNodeClient } from "@midnightntwrk/wallet-sdk/node-client/effect";
+import { InMemoryTransactionHistoryStorage, WalletEntrySchema, mergeWalletEntries } from "@midnightntwrk/wallet-sdk";
+import { DustWallet } from "@midnightntwrk/wallet-sdk/dust";
+import { WalletFacade } from "@midnightntwrk/wallet-sdk/facade";
+import { ShieldedWallet } from "@midnightntwrk/wallet-sdk/shielded";
+//#region ../../packages/contract/midnight-context/src/value-objects/midnight-address.vo.ts
+const MidnightShieldedAddress = (address) => address;
+const MidnightUnshieldedAddress = (address) => address;
+const MidnightDustAddress = (address) => address;
+//#endregion
+//#region ../../packages/contract/midnight-context/src/value-objects/serialised-wallet-state.vo.ts
+/**
+* Either encoding. Production only ever constructs this from the SDK's
+* verbatim JSON; the hex form comes back from storage on older profiles.
+*/
+const SerialisedWalletState = (value) => value;
+/**
+* A heuristic over the values we actually persist, not a parse: hex and JSON
+* overlap (`12345678` is both), so nothing can separate them in general. Every
+* blob written here opens with `{`; `[` is headroom for a serialiser that
+* returns a top-level array. Anything else reads as hex, and a wrong guess
+* costs a rebuild from seed, which the restore path already handles.
+*
+* First character only: matching hex across the whole payload cost ~2500ms
+* against 10k documents of 100k characters, against ~8ms here, and was
+* case-sensitive so it missed uppercase hex besides.
+*/
+const isVerbatimJson = (value) => value.startsWith("{") || value.startsWith("[");
+SerialisedWalletState.toJSON = (value) => isVerbatimJson(value) ? value : HexBytes.toUTF8(value);
+//#endregion
+//#region ../../packages/contract/midnight-context/src/midnight-accounts.ts
+/** Two account lists are the same run of accounts when their ids line up in
+* order — the identity the account stream re-emits on. */
+const sameAccounts = (accounts1, accounts2) => {
+	if (accounts1.length !== accounts2.length) return false;
+	for (let index = 0; index < accounts1.length; index++) if (accounts1[index].accountId !== accounts2[index].accountId) return false;
+	return true;
+};
+/**
+* The in-memory Midnight accounts on the active Midnight network, as a stream
+* that only re-emits when the run of account ids actually changes. Emits an
+* empty list while the wallet repo is migrating, so a consumer never acts on a
+* half-migrated repo. Nothing is emitted until a Midnight network is registered.
+*/
+const midnightAccounts$ = (state) => combineLatest([
+	state.wallets.selectActiveNetworkAccounts$,
+	state.midnightContext.selectMidnightBlockchainNetworkId$.pipe(filter(Boolean)),
+	state.wallets.selectIsWalletRepoMigrating$
+]).pipe(map(([accounts, activeNetwork, isWalletRepoMigrating]) => isWalletRepoMigrating ? [] : accounts.filter(isInMemoryMidnightAccount).filter((account) => account.blockchainNetworkId === activeNetwork)), distinctUntilChanged(sameAccounts));
+//#endregion
+//#region ../../packages/contract/midnight-context/src/register-midnight-blockchain-networks.ts
+/**
+* Registers the Midnight networks with the global network store once, the
+* first time it reports Midnight absent. Every loadout with Midnight accounts
+* needs this: `wallets.selectActiveNetworkAccounts` drops the accounts of an
+* unregistered blockchain. The registration lands a tick after this decides,
+* so it sets the networks only while Midnight still has none: a network the
+* consumer selected in between keeps precedence.
+*
+* An existing Midnight account pins the testnet selection to its own network,
+* so a profile created before the network store existed keeps syncing where
+* its account lives; otherwise the default testnet is selected.
+*/
+const registerMidnightBlockchainNetworks = (_, { network: { selectBlockchainNetworks$ }, midnightContext: { selectDefaultTestNetNetworkId$ }, wallets: { selectAll$ } }, { actions }) => selectBlockchainNetworks$.pipe(filter((blockchainNetworks) => !blockchainNetworks?.Midnight), withLatestFrom(selectDefaultTestNetNetworkId$, selectAll$.pipe(map((allWallets) => allWallets.flatMap((wallet) => wallet.accounts)))), map(([, defaultTestNetNetworkId, accounts]) => {
+	const existingMidnightAccount = accounts.find((account) => account.blockchainName === "Midnight");
+	const testnetNetworkId = existingMidnightAccount ? existingMidnightAccount.blockchainSpecific.networkId : defaultTestNetNetworkId;
+	return actions.network.registerBlockchainNetworks({
+		blockchain: "Midnight",
+		mainnet: MidnightNetworkId("mainnet"),
+		testnet: MidnightNetworkId(testnetNetworkId)
+	});
+}));
+/**
+* @since 2.0.0
+* @category fiberRefs
+*/
+const currentContext = currentContext$1;
+/**
+* @since 2.0.0
+* @category fiberRefs
+*/
+const currentSchedulingPriority = currentSchedulingPriority$1;
+/**
+* @since 2.0.0
+* @category fiberRefs
+*/
+const currentScheduler = currentScheduler$1;
+/** @internal */
+const EnqueueTypeId$1 = /* @__PURE__ */ Symbol.for("effect/QueueEnqueue");
+/** @internal */
+const DequeueTypeId$1 = /* @__PURE__ */ Symbol.for("effect/QueueDequeue");
+/** @internal */
+const QueueStrategyTypeId$1 = /* @__PURE__ */ Symbol.for("effect/QueueStrategy");
+/** @internal */
+const BackingQueueTypeId$1 = /* @__PURE__ */ Symbol.for("effect/BackingQueue");
+const queueStrategyVariance = { _A: (_) => _ };
+const backingQueueVariance = { _A: (_) => _ };
+/** @internal */
+const enqueueVariance = { _In: (_) => _ };
+/** @internal */
+const dequeueVariance = { _Out: (_) => _ };
+/** @internal */
+var QueueImpl = class extends Class {
+	queue;
+	takers;
+	shutdownHook;
+	shutdownFlag;
+	strategy;
+	[EnqueueTypeId$1] = enqueueVariance;
+	[DequeueTypeId$1] = dequeueVariance;
+	constructor(queue, takers, shutdownHook, shutdownFlag, strategy) {
+		super();
+		this.queue = queue;
+		this.takers = takers;
+		this.shutdownHook = shutdownHook;
+		this.shutdownFlag = shutdownFlag;
+		this.strategy = strategy;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	commit() {
+		return this.take;
+	}
+	capacity() {
+		return this.queue.capacity();
+	}
+	get size() {
+		return suspend$8(() => catchAll$6(this.unsafeSize(), () => interrupt$1));
+	}
+	unsafeSize() {
+		if (get$4(this.shutdownFlag)) return none();
+		return some$2(this.queue.length() - length(this.takers) + this.strategy.surplusSize());
+	}
+	get isEmpty() {
+		return map$9(this.size, (size) => size <= 0);
+	}
+	get isFull() {
+		return map$9(this.size, (size) => size >= this.capacity());
+	}
+	get shutdown() {
+		return uninterruptible(withFiberRuntime((state) => {
+			pipe(this.shutdownFlag, set$2(true));
+			return pipe(forEachConcurrentDiscard(unsafePollAll(this.takers), (d) => deferredInterruptWith(d, state.id()), false, false), zipRight$6(this.strategy.shutdown), whenEffect$2(deferredSucceed(this.shutdownHook, void 0)), asVoid$1);
+		}));
+	}
+	get isShutdown() {
+		return sync$7(() => get$4(this.shutdownFlag));
+	}
+	get awaitShutdown() {
+		return deferredAwait(this.shutdownHook);
+	}
+	isActive() {
+		return !get$4(this.shutdownFlag);
+	}
+	unsafeOffer(value) {
+		if (get$4(this.shutdownFlag)) return false;
+		let noRemaining;
+		if (this.queue.length() === 0) {
+			const taker = pipe(this.takers, poll$4(EmptyMutableQueue));
+			if (taker !== EmptyMutableQueue) {
+				unsafeCompleteDeferred$1(taker, value);
+				noRemaining = true;
+			} else noRemaining = false;
+		} else noRemaining = false;
+		if (noRemaining) return true;
+		const succeeded = this.queue.offer(value);
+		unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+		return succeeded;
+	}
+	offer(value) {
+		return suspend$8(() => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			let noRemaining;
+			if (this.queue.length() === 0) {
+				const taker = pipe(this.takers, poll$4(EmptyMutableQueue));
+				if (taker !== EmptyMutableQueue) {
+					unsafeCompleteDeferred$1(taker, value);
+					noRemaining = true;
+				} else noRemaining = false;
+			} else noRemaining = false;
+			if (noRemaining) return succeed$8(true);
+			const succeeded = this.queue.offer(value);
+			unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+			return succeeded ? succeed$8(true) : this.strategy.handleSurplus([value], this.queue, this.takers, this.shutdownFlag);
+		});
+	}
+	offerAll(iterable) {
+		return suspend$8(() => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			const values = fromIterable$2(iterable);
+			const pTakers = this.queue.length() === 0 ? fromIterable$2(unsafePollN$1(this.takers, values.length)) : empty$4;
+			const [forTakers, remaining] = pipe(values, splitAt(pTakers.length));
+			for (let i = 0; i < pTakers.length; i++) {
+				const taker = pTakers[i];
+				const item = forTakers[i];
+				unsafeCompleteDeferred$1(taker, item);
+			}
+			if (remaining.length === 0) return succeed$8(true);
+			const surplus = this.queue.offerAll(remaining);
+			unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+			return isEmpty$8(surplus) ? succeed$8(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+		});
+	}
+	get take() {
+		return withFiberRuntime((state) => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			const item = this.queue.poll(EmptyMutableQueue);
+			if (item !== EmptyMutableQueue) {
+				this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+				return succeed$8(item);
+			} else {
+				const deferred = deferredUnsafeMake(state.id());
+				return pipe(suspend$8(() => {
+					pipe(this.takers, offer$5(deferred));
+					unsafeCompleteTakers(this.strategy, this.queue, this.takers);
+					return get$4(this.shutdownFlag) ? interrupt$1 : deferredAwait(deferred);
+				}), onInterrupt(() => {
+					return sync$7(() => unsafeRemove$1(this.takers, deferred));
+				}));
+			}
+		});
+	}
+	get takeAll() {
+		return suspend$8(() => {
+			return get$4(this.shutdownFlag) ? interrupt$1 : sync$7(() => {
+				const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
+				this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+				return fromIterable$3(values);
+			});
+		});
+	}
+	takeUpTo(max) {
+		return suspend$8(() => get$4(this.shutdownFlag) ? interrupt$1 : sync$7(() => {
+			const values = this.queue.pollUpTo(max);
+			this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
+			return fromIterable$3(values);
+		}));
+	}
+	takeBetween(min, max) {
+		return suspend$8(() => takeRemainderLoop$1(this, min, max, empty$5()));
+	}
+};
+/** @internal */
+const takeRemainderLoop$1 = (self, min, max, acc) => {
+	if (max < min) return succeed$8(acc);
+	return pipe(takeUpTo$3(self, max), flatMap$7((bs) => {
+		const remaining = min - bs.length;
+		if (remaining === 1) return pipe(take$7(self), map$9((b) => pipe(acc, appendAll(bs), append(b))));
+		if (remaining > 1) return pipe(take$7(self), flatMap$7((b) => takeRemainderLoop$1(self, remaining - 1, max - bs.length - 1, pipe(acc, appendAll(bs), append(b)))));
+		return succeed$8(pipe(acc, appendAll(bs)));
+	}));
+};
+/** @internal */
+const bounded$7 = (requestedCapacity) => pipe(sync$7(() => bounded$8(requestedCapacity)), flatMap$7((queue) => make$13(backingQueueFromMutableQueue(queue), backPressureStrategy$1())));
+/** @internal */
+const unbounded$7 = () => pipe(sync$7(() => unbounded$8()), flatMap$7((queue) => make$13(backingQueueFromMutableQueue(queue), droppingStrategy$1())));
+/** @internal */
+const unsafeMake = (queue, takers, shutdownHook, shutdownFlag, strategy) => {
+	return new QueueImpl(queue, takers, shutdownHook, shutdownFlag, strategy);
+};
+/** @internal */
+const make$13 = (queue, strategy) => pipe(deferredMake(), map$9((deferred) => unsafeMake(queue, unbounded$8(), deferred, make$16(false), strategy)));
+/** @internal */
+var BackingQueueFromMutableQueue = class {
+	mutable;
+	[BackingQueueTypeId$1] = backingQueueVariance;
+	constructor(mutable) {
+		this.mutable = mutable;
+	}
+	poll(def) {
+		return poll$4(this.mutable, def);
+	}
+	pollUpTo(limit) {
+		return pollUpTo(this.mutable, limit);
+	}
+	offerAll(elements) {
+		return offerAll$4(this.mutable, elements);
+	}
+	offer(element) {
+		return offer$5(this.mutable, element);
+	}
+	capacity() {
+		return capacity$8(this.mutable);
+	}
+	length() {
+		return length(this.mutable);
+	}
+};
+/** @internal */
+const backingQueueFromMutableQueue = (mutable) => new BackingQueueFromMutableQueue(mutable);
+/** @internal */
+const size$7 = (self) => self.size;
+/** @internal */
+const shutdown$7 = (self) => self.shutdown;
+/** @internal */
+const offer$4 = /* @__PURE__ */ dual(2, (self, value) => self.offer(value));
+/** @internal */
+const take$7 = (self) => self.take;
+/** @internal */
+const takeUpTo$3 = /* @__PURE__ */ dual(2, (self, max) => self.takeUpTo(max));
+/** @internal */
+const backPressureStrategy$1 = () => new BackPressureStrategy$1();
+/** @internal */
+const droppingStrategy$1 = () => new DroppingStrategy$1();
+/** @internal */
+var BackPressureStrategy$1 = class {
+	[QueueStrategyTypeId$1] = queueStrategyVariance;
+	putters = /* @__PURE__ */ unbounded$8();
+	surplusSize() {
+		return length(this.putters);
+	}
+	onCompleteTakersWithEmptyQueue(takers) {
+		while (!isEmpty$9(this.putters) && !isEmpty$9(takers)) {
+			const taker = poll$4(takers, void 0);
+			const putter = poll$4(this.putters, void 0);
+			if (putter[2]) unsafeCompleteDeferred$1(putter[1], true);
+			unsafeCompleteDeferred$1(taker, putter[0]);
+		}
+	}
+	get shutdown() {
+		return pipe(fiberId, flatMap$7((fiberId) => pipe(sync$7(() => unsafePollAll(this.putters)), flatMap$7((putters) => forEachConcurrentDiscard(putters, ([_, deferred, isLastItem]) => isLastItem ? pipe(deferredInterruptWith(deferred, fiberId), asVoid$1) : void_$4, false, false)))));
+	}
+	handleSurplus(iterable, queue, takers, isShutdown) {
+		return withFiberRuntime((state) => {
+			const deferred = deferredUnsafeMake(state.id());
+			return pipe(suspend$8(() => {
+				this.unsafeOffer(iterable, deferred);
+				this.unsafeOnQueueEmptySpace(queue, takers);
+				unsafeCompleteTakers(this, queue, takers);
+				return get$4(isShutdown) ? interrupt$1 : deferredAwait(deferred);
+			}), onInterrupt(() => sync$7(() => this.unsafeRemove(deferred))));
+		});
+	}
+	unsafeOnQueueEmptySpace(queue, takers) {
+		let keepPolling = true;
+		while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
+			const putter = pipe(this.putters, poll$4(EmptyMutableQueue));
+			if (putter === EmptyMutableQueue) keepPolling = false;
+			else {
+				const offered = queue.offer(putter[0]);
+				if (offered && putter[2]) unsafeCompleteDeferred$1(putter[1], true);
+				else if (!offered) unsafeOfferAll$1(this.putters, pipe(unsafePollAll(this.putters), prepend$2(putter)));
+				unsafeCompleteTakers(this, queue, takers);
+			}
+		}
+	}
+	unsafeOffer(iterable, deferred) {
+		const stuff = fromIterable$2(iterable);
+		for (let i = 0; i < stuff.length; i++) {
+			const value = stuff[i];
+			if (i === stuff.length - 1) pipe(this.putters, offer$5([
+				value,
+				deferred,
+				true
+			]));
+			else pipe(this.putters, offer$5([
+				value,
+				deferred,
+				false
+			]));
+		}
+	}
+	unsafeRemove(deferred) {
+		unsafeOfferAll$1(this.putters, pipe(unsafePollAll(this.putters), filter$3(([, _]) => _ !== deferred)));
+	}
+};
+/** @internal */
+var DroppingStrategy$1 = class {
+	[QueueStrategyTypeId$1] = queueStrategyVariance;
+	surplusSize() {
+		return 0;
+	}
+	get shutdown() {
+		return void_$4;
+	}
+	onCompleteTakersWithEmptyQueue() {}
+	handleSurplus(_iterable, _queue, _takers, _isShutdown) {
+		return succeed$8(false);
+	}
+	unsafeOnQueueEmptySpace(_queue, _takers) {}
+};
+/** @internal */
+const unsafeCompleteDeferred$1 = (deferred, a) => {
+	return deferredUnsafeDone(deferred, succeed$8(a));
+};
+/** @internal */
+const unsafeOfferAll$1 = (queue, as) => {
+	return pipe(queue, offerAll$4(as));
+};
+/** @internal */
+const unsafePollAll = (queue) => {
+	return pipe(queue, pollUpTo(Number.POSITIVE_INFINITY));
+};
+/** @internal */
+const unsafePollN$1 = (queue, max) => {
+	return pipe(queue, pollUpTo(max));
+};
+/** @internal */
+const unsafeRemove$1 = (queue, a) => {
+	unsafeOfferAll$1(queue, pipe(unsafePollAll(queue), filter$3((b) => a !== b)));
+};
+/** @internal */
+const unsafeCompleteTakers = (strategy, queue, takers) => {
+	let keepPolling = true;
+	while (keepPolling && queue.length() !== 0) {
+		const taker = pipe(takers, poll$4(EmptyMutableQueue));
+		if (taker !== EmptyMutableQueue) {
+			const element = queue.poll(EmptyMutableQueue);
+			if (element !== EmptyMutableQueue) {
+				unsafeCompleteDeferred$1(taker, element);
+				strategy.unsafeOnQueueEmptySpace(queue, takers);
+			} else unsafeOfferAll$1(takers, pipe(unsafePollAll(takers), prepend$2(taker)));
+			keepPolling = true;
+		} else keepPolling = false;
+	}
+	if (keepPolling && queue.length() === 0 && !isEmpty$9(takers)) strategy.onCompleteTakersWithEmptyQueue(takers);
+};
+const addSubscribers = (subscription, pollers) => (subscribers) => {
+	if (!subscribers.has(subscription)) subscribers.set(subscription, /* @__PURE__ */ new Set());
+	subscribers.get(subscription).add(pollers);
+};
+/** @internal */
+var SubscriptionImpl = class extends Class {
+	pubsub;
+	subscribers;
+	subscription;
+	pollers;
+	shutdownHook;
+	shutdownFlag;
+	strategy;
+	replayWindow;
+	[DequeueTypeId$1] = dequeueVariance;
+	constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, replayWindow) {
+		super();
+		this.pubsub = pubsub;
+		this.subscribers = subscribers;
+		this.subscription = subscription;
+		this.pollers = pollers;
+		this.shutdownHook = shutdownHook;
+		this.shutdownFlag = shutdownFlag;
+		this.strategy = strategy;
+		this.replayWindow = replayWindow;
+	}
+	commit() {
+		return this.take;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	capacity() {
+		return this.pubsub.capacity;
+	}
+	isActive() {
+		return !get$4(this.shutdownFlag);
+	}
+	get size() {
+		return suspend$8(() => get$4(this.shutdownFlag) ? interrupt$1 : succeed$8(this.subscription.size() + this.replayWindow.remaining));
+	}
+	unsafeSize() {
+		if (get$4(this.shutdownFlag)) return none();
+		return some$2(this.subscription.size() + this.replayWindow.remaining);
+	}
+	get isFull() {
+		return suspend$8(() => get$4(this.shutdownFlag) ? interrupt$1 : succeed$8(this.subscription.size() === this.capacity()));
+	}
+	get isEmpty() {
+		return map$9(this.size, (size) => size === 0);
+	}
+	get shutdown() {
+		return uninterruptible(withFiberRuntime((state) => {
+			set$2(this.shutdownFlag, true);
+			return pipe(forEachParUnbounded(unsafePollAllQueue(this.pollers), (d) => deferredInterruptWith(d, state.id()), false), zipRight$6(sync$7(() => {
+				this.subscribers.delete(this.subscription);
+				this.subscription.unsubscribe();
+				this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
+			})), whenEffect$2(deferredSucceed(this.shutdownHook, void 0)), asVoid$1);
+		}));
+	}
+	get isShutdown() {
+		return sync$7(() => get$4(this.shutdownFlag));
+	}
+	get awaitShutdown() {
+		return deferredAwait(this.shutdownHook);
+	}
+	get take() {
+		return withFiberRuntime((state) => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			if (this.replayWindow.remaining > 0) return succeed$8(this.replayWindow.take());
+			const message = isEmpty$9(this.pollers) ? this.subscription.poll(EmptyMutableQueue) : EmptyMutableQueue;
+			if (message === EmptyMutableQueue) {
+				const deferred = deferredUnsafeMake(state.id());
+				return pipe(suspend$8(() => {
+					pipe(this.pollers, offer$5(deferred));
+					pipe(this.subscribers, addSubscribers(this.subscription, this.pollers));
+					this.strategy.unsafeCompletePollers(this.pubsub, this.subscribers, this.subscription, this.pollers);
+					return get$4(this.shutdownFlag) ? interrupt$1 : deferredAwait(deferred);
+				}), onInterrupt(() => sync$7(() => unsafeRemove(this.pollers, deferred))));
+			} else {
+				this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
+				return succeed$8(message);
+			}
+		});
+	}
+	get takeAll() {
+		return suspend$8(() => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			const as = isEmpty$9(this.pollers) ? unsafePollAllSubscription(this.subscription) : empty$5();
+			this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
+			if (this.replayWindow.remaining > 0) return succeed$8(appendAll(this.replayWindow.takeAll(), as));
+			return succeed$8(as);
+		});
+	}
+	takeUpTo(max) {
+		return suspend$8(() => {
+			if (get$4(this.shutdownFlag)) return interrupt$1;
+			let replay = void 0;
+			if (this.replayWindow.remaining >= max) return succeed$8(this.replayWindow.takeN(max));
+			else if (this.replayWindow.remaining > 0) {
+				replay = this.replayWindow.takeAll();
+				max = max - replay.length;
+			}
+			const as = isEmpty$9(this.pollers) ? unsafePollN(this.subscription, max) : empty$5();
+			this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
+			return replay ? succeed$8(appendAll(replay, as)) : succeed$8(as);
+		});
+	}
+	takeBetween(min, max) {
+		return suspend$8(() => takeRemainderLoop(this, min, max, empty$5()));
+	}
+};
+/** @internal */
+const takeRemainderLoop = (self, min, max, acc) => {
+	if (max < min) return succeed$8(acc);
+	return pipe(self.takeUpTo(max), flatMap$7((bs) => {
+		const remaining = min - bs.length;
+		if (remaining === 1) return pipe(self.take, map$9((b) => pipe(acc, appendAll(bs), append(b))));
+		if (remaining > 1) return pipe(self.take, flatMap$7((b) => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, pipe(acc, appendAll(bs), append(b)))));
+		return succeed$8(pipe(acc, appendAll(bs)));
+	}));
+};
+/** @internal */
+const unsafeOfferAll = (queue, as) => {
+	return pipe(queue, offerAll$4(as));
+};
+/** @internal */
+const unsafePollAllQueue = (queue) => {
+	return pipe(queue, pollUpTo(Number.POSITIVE_INFINITY));
+};
+/** @internal */
+const unsafePollAllSubscription = (subscription) => {
+	return subscription.pollUpTo(Number.POSITIVE_INFINITY);
+};
+/** @internal */
+const unsafePollN = (subscription, max) => {
+	return subscription.pollUpTo(max);
+};
+/** @internal */
+const unsafeRemove = (queue, value) => {
+	unsafeOfferAll(queue, pipe(unsafePollAllQueue(queue), filter$3((elem) => elem !== value)));
+};
+/**
+* Makes a new bounded `Queue`. When the capacity of the queue is reached, any
+* additional calls to `offer` will be suspended until there is more room in
+* the queue.
+*
+* **Note**: When possible use only power of 2 capacities; this will provide
+* better performance by utilising an optimised version of the underlying
+* `RingBuffer`.
+*
+* @since 2.0.0
+* @category constructors
+*/
+const bounded$4 = bounded$7;
+/**
+* Creates a new unbounded `Queue`.
+*
+* @since 2.0.0
+* @category constructors
+*/
+const unbounded$4 = unbounded$7;
+/**
+* Retrieves the size of the queue, which is equal to the number of elements
+* in the queue. This may be negative if fibers are suspended waiting for
+* elements to be added to the queue.
+*
+* @since 2.0.0
+* @category getters
+*/
+const size$4 = size$7;
+/**
+* Interrupts any fibers that are suspended on `offer` or `take`. Future calls
+* to `offer*` and `take*` will be interrupted immediately.
+*
+* @since 2.0.0
+* @category utils
+*/
+const shutdown$4 = shutdown$7;
+/**
+* Places one value in the queue.
+*
+* @since 2.0.0
+* @category utils
+*/
+const offer$3 = offer$4;
+/**
+* Takes the oldest value in the queue. If the queue is empty, this will return
+* a computation that resumes when an item has been added to the queue.
+*
+* @since 2.0.0
+* @category utils
+*/
+const take$6 = take$7;
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelChildExecutorDecision.js
+/** @internal */
+const OP_CONTINUE = "Continue";
+/** @internal */
+const OP_CLOSE = "Close";
+/** @internal */
+const OP_YIELD = "Yield";
+/** @internal */
+const ChildExecutorDecisionTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelChildExecutorDecision");
+/** @internal */
+const proto$7 = { [ChildExecutorDecisionTypeId]: ChildExecutorDecisionTypeId };
+/** @internal */
+const Continue = (_) => {
+	const op = Object.create(proto$7);
+	op._tag = OP_CONTINUE;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/continuation.js
+/** @internal */
+const OP_CONTINUATION_K = "ContinuationK";
+/** @internal */
+const OP_CONTINUATION_FINALIZER = "ContinuationFinalizer";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/channel/continuation.js
+/** @internal */
+const ContinuationTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelContinuation");
+const continuationVariance = {
+	_Env: (_) => _,
+	_InErr: (_) => _,
+	_InElem: (_) => _,
+	_InDone: (_) => _,
+	_OutErr: (_) => _,
+	_OutDone: (_) => _,
+	_OutErr2: (_) => _,
+	_OutElem: (_) => _,
+	_OutDone2: (_) => _
+};
+/** @internal */
+var ContinuationKImpl = class {
+	onSuccess;
+	onHalt;
+	_tag = OP_CONTINUATION_K;
+	[ContinuationTypeId] = continuationVariance;
+	constructor(onSuccess, onHalt) {
+		this.onSuccess = onSuccess;
+		this.onHalt = onHalt;
+	}
+	onExit(exit) {
+		return isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
+	}
+};
+/** @internal */
+var ContinuationFinalizerImpl = class {
+	finalizer;
+	_tag = OP_CONTINUATION_FINALIZER;
+	[ContinuationTypeId] = continuationVariance;
+	constructor(finalizer) {
+		this.finalizer = finalizer;
+	}
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelUpstreamPullStrategy.js
+/** @internal */
+const OP_PULL_AFTER_NEXT = "PullAfterNext";
+/** @internal */
+const OP_PULL_AFTER_ALL_ENQUEUED = "PullAfterAllEnqueued";
+/** @internal */
+const UpstreamPullStrategyTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelUpstreamPullStrategy");
+const upstreamPullStrategyVariance = { _A: (_) => _ };
+/** @internal */
+const proto$6 = { [UpstreamPullStrategyTypeId]: upstreamPullStrategyVariance };
+/** @internal */
+const PullAfterNext = (emitSeparator) => {
+	const op = Object.create(proto$6);
+	op._tag = OP_PULL_AFTER_NEXT;
+	op.emitSeparator = emitSeparator;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channel.js
+/** @internal */
+const OP_BRACKET_OUT = "BracketOut";
+/** @internal */
+const OP_BRIDGE = "Bridge";
+/** @internal */
+const OP_CONCAT_ALL = "ConcatAll";
+/** @internal */
+const OP_EMIT$3 = "Emit";
+/** @internal */
+const OP_ENSURING = "Ensuring";
+/** @internal */
+const OP_FAIL$2 = "Fail";
+/** @internal */
+const OP_FOLD = "Fold";
+/** @internal */
+const OP_FROM_EFFECT$1 = "FromEffect";
+/** @internal */
+const OP_PIPE_TO = "PipeTo";
+/** @internal */
+const OP_PROVIDE$1 = "Provide";
+/** @internal */
+const OP_READ$1 = "Read";
+/** @internal */
+const OP_SUCCEED$2 = "Succeed";
+/** @internal */
+const OP_SUCCEED_NOW = "SucceedNow";
+/** @internal */
+const OP_SUSPEND$1 = "Suspend";
+/** @internal */
+const ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
+const channelVariance = {
+	_Env: (_) => _,
+	_InErr: (_) => _,
+	_InElem: (_) => _,
+	_InDone: (_) => _,
+	_OutErr: (_) => _,
+	_OutElem: (_) => _,
+	_OutDone: (_) => _
+};
+/** @internal */
+const proto$5 = {
+	[ChannelTypeId]: channelVariance,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const isChannel = (u) => hasProperty(u, ChannelTypeId) || isEffect(u);
+/** @internal */
+const acquireReleaseOut = /* @__PURE__ */ dual(2, (self, release) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_BRACKET_OUT;
+	op.acquire = () => self;
+	op.finalizer = release;
+	return op;
+});
+/** @internal */
+const catchAllCause$2 = /* @__PURE__ */ dual(2, (self, f) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_FOLD;
+	op.channel = self;
+	op.k = new ContinuationKImpl(succeed$5, f);
+	return op;
+});
+/** @internal */
+const collectElementsReader = (builder) => readWith({
+	onInput: (outElem) => flatMap$4(sync$4(() => {
+		builder.push(outElem);
+	}), () => collectElementsReader(builder)),
+	onFailure: fail$5,
+	onDone: succeedNow
+});
+/** @internal */
+const concatAllWith = (channels, f, g) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_CONCAT_ALL;
+	op.combineInners = f;
+	op.combineAll = g;
+	op.onPull = () => PullAfterNext(none());
+	op.onEmit = () => Continue;
+	op.value = () => channels;
+	op.k = identity$2;
+	return op;
+};
+/** @internal */
+const concatMapWith = /* @__PURE__ */ dual(4, (self, f, g, h) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_CONCAT_ALL;
+	op.combineInners = g;
+	op.combineAll = h;
+	op.onPull = () => PullAfterNext(none());
+	op.onEmit = () => Continue;
+	op.value = () => self;
+	op.k = f;
+	return op;
+});
+/** @internal */
+const embedInput = /* @__PURE__ */ dual(2, (self, input) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_BRIDGE;
+	op.input = input;
+	op.channel = self;
+	return op;
+});
+/** @internal */
+const ensuringWith$2 = /* @__PURE__ */ dual(2, (self, finalizer) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_ENSURING;
+	op.channel = self;
+	op.finalizer = finalizer;
+	return op;
+});
+/** @internal */
+const fail$5 = (error) => failCause$4(fail$8(error));
+/** @internal */
+const failCause$4 = (cause) => failCauseSync$2(() => cause);
+/** @internal */
+const failCauseSync$2 = (evaluate) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_FAIL$2;
+	op.error = evaluate;
+	return op;
+};
+/** @internal */
+const flatMap$4 = /* @__PURE__ */ dual(2, (self, f) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_FOLD;
+	op.channel = self;
+	op.k = new ContinuationKImpl(f, failCause$4);
+	return op;
+});
+/** @internal */
+const fromEffect$4 = (effect) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_FROM_EFFECT$1;
+	op.effect = () => effect;
+	return op;
+};
+/** @internal */
+const pipeTo = /* @__PURE__ */ dual(2, (self, that) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_PIPE_TO;
+	op.left = () => self;
+	op.right = () => that;
+	return op;
+});
+/** @internal */
+const readWith = (options) => readWithCause({
+	onInput: options.onInput,
+	onFailure: (cause) => match$8(failureOrCause(cause), {
+		onLeft: options.onFailure,
+		onRight: failCause$4
+	}),
+	onDone: options.onDone
+});
+/** @internal */
+const readWithCause = (options) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_READ$1;
+	op.more = options.onInput;
+	op.done = new ContinuationKImpl(options.onDone, options.onFailure);
+	return op;
+};
+/** @internal */
+const succeed$5 = (value) => sync$4(() => value);
+/** @internal */
+const succeedNow = (result) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_SUCCEED_NOW;
+	op.terminal = result;
+	return op;
+};
+/** @internal */
+const suspend$5 = (evaluate) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_SUSPEND$1;
+	op.channel = evaluate;
+	return op;
+};
+const sync$4 = (evaluate) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_SUCCEED$2;
+	op.evaluate = evaluate;
+	return op;
+};
+const void_$3 = /* @__PURE__ */ succeedNow(void 0);
+/** @internal */
+const write = (out) => {
+	const op = Object.create(proto$5);
+	op._tag = OP_EMIT$3;
+	op.out = out;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelState.js
+/** @internal */
+const OP_DONE$3 = "Done";
+/** @internal */
+const OP_EMIT$2 = "Emit";
+/** @internal */
+const OP_FROM_EFFECT = "FromEffect";
+/** @internal */
+const OP_READ = "Read";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/channel/channelState.js
+/** @internal */
+const ChannelStateTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelState");
+const channelStateVariance = {
+	_E: (_) => _,
+	_R: (_) => _
+};
+/** @internal */
+const proto$4 = { [ChannelStateTypeId]: channelStateVariance };
+/** @internal */
+const Done$2 = () => {
+	const op = Object.create(proto$4);
+	op._tag = OP_DONE$3;
+	return op;
+};
+/** @internal */
+const Emit$1 = () => {
+	const op = Object.create(proto$4);
+	op._tag = OP_EMIT$2;
+	return op;
+};
+/** @internal */
+const fromEffect$3 = (effect) => {
+	const op = Object.create(proto$4);
+	op._tag = OP_FROM_EFFECT;
+	op.effect = effect;
+	return op;
+};
+/** @internal */
+const Read = (upstream, onEffect, onEmit, onDone) => {
+	const op = Object.create(proto$4);
+	op._tag = OP_READ;
+	op.upstream = upstream;
+	op.onEffect = onEffect;
+	op.onEmit = onEmit;
+	op.onDone = onDone;
+	return op;
+};
+/** @internal */
+const isFromEffect = (self) => self._tag === OP_FROM_EFFECT;
+/** @internal */
+const effect$1 = (self) => isFromEffect(self) ? self.effect : _void;
+/** @internal */
+const effectOrUndefinedIgnored = (self) => isFromEffect(self) ? ignore(self.effect) : void 0;
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/channel/subexecutor.js
+/** @internal */
+const OP_PULL_FROM_CHILD = "PullFromChild";
+/** @internal */
+const OP_PULL_FROM_UPSTREAM = "PullFromUpstream";
+/** @internal */
+const OP_DRAIN_CHILD_EXECUTORS = "DrainChildExecutors";
+/** @internal */
+const OP_EMIT$1 = "Emit";
+/**
+* Execute the `childExecutor` and on each emitted value, decide what to do by
+* `onEmit`.
+*
+* @internal
+*/
+var PullFromChild = class {
+	childExecutor;
+	parentSubexecutor;
+	onEmit;
+	_tag = OP_PULL_FROM_CHILD;
+	constructor(childExecutor, parentSubexecutor, onEmit) {
+		this.childExecutor = childExecutor;
+		this.parentSubexecutor = parentSubexecutor;
+		this.onEmit = onEmit;
+	}
+	close(exit$4) {
+		const fin1 = this.childExecutor.close(exit$4);
+		const fin2 = this.parentSubexecutor.close(exit$4);
+		if (fin1 !== void 0 && fin2 !== void 0) return zipWith$7(exit(fin1), exit(fin2), (exit1, exit2) => pipe(exit1, zipRight$7(exit2)));
+		else if (fin1 !== void 0) return fin1;
+		else if (fin2 !== void 0) return fin2;
+		else return;
+	}
+	enqueuePullFromChild(_child) {
+		return this;
+	}
+};
+/**
+* Execute `upstreamExecutor` and for each emitted element, spawn a child
+* channel and continue with processing it by `PullFromChild`.
+*
+* @internal
+*/
+var PullFromUpstream = class PullFromUpstream {
+	upstreamExecutor;
+	createChild;
+	lastDone;
+	activeChildExecutors;
+	combineChildResults;
+	combineWithChildResult;
+	onPull;
+	onEmit;
+	_tag = OP_PULL_FROM_UPSTREAM;
+	constructor(upstreamExecutor, createChild, lastDone, activeChildExecutors, combineChildResults, combineWithChildResult, onPull, onEmit) {
+		this.upstreamExecutor = upstreamExecutor;
+		this.createChild = createChild;
+		this.lastDone = lastDone;
+		this.activeChildExecutors = activeChildExecutors;
+		this.combineChildResults = combineChildResults;
+		this.combineWithChildResult = combineWithChildResult;
+		this.onPull = onPull;
+		this.onEmit = onEmit;
+	}
+	close(exit$5) {
+		const fin1 = this.upstreamExecutor.close(exit$5);
+		const result = [...this.activeChildExecutors.map((child) => child !== void 0 ? child.childExecutor.close(exit$5) : void 0), fin1].reduce((acc, next) => {
+			if (acc !== void 0 && next !== void 0) return zipWith$7(acc, exit(next), (exit1, exit2) => zipRight$7(exit1, exit2));
+			else if (acc !== void 0) return acc;
+			else if (next !== void 0) return exit(next);
+			else return;
+		}, void 0);
+		return result === void 0 ? result : result;
+	}
+	enqueuePullFromChild(child) {
+		return new PullFromUpstream(this.upstreamExecutor, this.createChild, this.lastDone, [...this.activeChildExecutors, child], this.combineChildResults, this.combineWithChildResult, this.onPull, this.onEmit);
+	}
+};
+/**
+* Transformed from `PullFromUpstream` when upstream has finished but there
+* are still active child executors.
+*
+* @internal
+*/
+var DrainChildExecutors = class DrainChildExecutors {
+	upstreamExecutor;
+	lastDone;
+	activeChildExecutors;
+	upstreamDone;
+	combineChildResults;
+	combineWithChildResult;
+	onPull;
+	_tag = OP_DRAIN_CHILD_EXECUTORS;
+	constructor(upstreamExecutor, lastDone, activeChildExecutors, upstreamDone, combineChildResults, combineWithChildResult, onPull) {
+		this.upstreamExecutor = upstreamExecutor;
+		this.lastDone = lastDone;
+		this.activeChildExecutors = activeChildExecutors;
+		this.upstreamDone = upstreamDone;
+		this.combineChildResults = combineChildResults;
+		this.combineWithChildResult = combineWithChildResult;
+		this.onPull = onPull;
+	}
+	close(exit$3) {
+		const fin1 = this.upstreamExecutor.close(exit$3);
+		const result = [...this.activeChildExecutors.map((child) => child !== void 0 ? child.childExecutor.close(exit$3) : void 0), fin1].reduce((acc, next) => {
+			if (acc !== void 0 && next !== void 0) return zipWith$7(acc, exit(next), (exit1, exit2) => zipRight$7(exit1, exit2));
+			else if (acc !== void 0) return acc;
+			else if (next !== void 0) return exit(next);
+			else return;
+		}, void 0);
+		return result === void 0 ? result : result;
+	}
+	enqueuePullFromChild(child) {
+		return new DrainChildExecutors(this.upstreamExecutor, this.lastDone, [...this.activeChildExecutors, child], this.upstreamDone, this.combineChildResults, this.combineWithChildResult, this.onPull);
+	}
+};
+/** @internal */
+var Emit = class {
+	value;
+	next;
+	_tag = OP_EMIT$1;
+	constructor(value, next) {
+		this.value = value;
+		this.next = next;
+	}
+	close(exit) {
+		const result = this.next.close(exit);
+		return result === void 0 ? result : result;
+	}
+	enqueuePullFromChild(_child) {
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelUpstreamPullRequest.js
+/** @internal */
+const OP_PULLED = "Pulled";
+/** @internal */
+const OP_NO_UPSTREAM = "NoUpstream";
+/** @internal */
+const UpstreamPullRequestTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelUpstreamPullRequest");
+const upstreamPullRequestVariance = { _A: (_) => _ };
+/** @internal */
+const proto$3 = { [UpstreamPullRequestTypeId]: upstreamPullRequestVariance };
+/** @internal */
+const Pulled = (value) => {
+	const op = Object.create(proto$3);
+	op._tag = OP_PULLED;
+	op.value = value;
+	return op;
+};
+/** @internal */
+const NoUpstream = (activeDownstreamCount) => {
+	const op = Object.create(proto$3);
+	op._tag = OP_NO_UPSTREAM;
+	op.activeDownstreamCount = activeDownstreamCount;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/channel/channelExecutor.js
+/** @internal */
+var ChannelExecutor = class ChannelExecutor {
+	_activeSubexecutor = void 0;
+	_cancelled = void 0;
+	_closeLastSubstream = void 0;
+	_currentChannel;
+	_done = void 0;
+	_doneStack = [];
+	_emitted = void 0;
+	_executeCloseLastSubstream;
+	_input = void 0;
+	_inProgressFinalizer = void 0;
+	_providedEnv;
+	constructor(initialChannel, providedEnv, executeCloseLastSubstream) {
+		this._currentChannel = initialChannel;
+		this._executeCloseLastSubstream = executeCloseLastSubstream;
+		this._providedEnv = providedEnv;
+	}
+	run() {
+		let result = void 0;
+		while (result === void 0) if (this._cancelled !== void 0) result = this.processCancellation();
+		else if (this._activeSubexecutor !== void 0) result = this.runSubexecutor();
+		else try {
+			if (this._currentChannel === void 0) result = Done$2();
+			else {
+				if (isEffect(this._currentChannel)) this._currentChannel = fromEffect$4(this._currentChannel);
+				switch (this._currentChannel._tag) {
+					case OP_BRACKET_OUT:
+						result = this.runBracketOut(this._currentChannel);
+						break;
+					case OP_BRIDGE: {
+						const bridgeInput = this._currentChannel.input;
+						this._currentChannel = this._currentChannel.channel;
+						if (this._input !== void 0) {
+							const inputExecutor = this._input;
+							this._input = void 0;
+							const drainer = () => flatMap$8(bridgeInput.awaitRead(), () => suspend$9(() => {
+								const state = inputExecutor.run();
+								switch (state._tag) {
+									case OP_DONE$3: return match$9(inputExecutor.getDone(), {
+										onFailure: (cause) => bridgeInput.error(cause),
+										onSuccess: (value) => bridgeInput.done(value)
+									});
+									case OP_EMIT$2: return flatMap$8(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
+									case OP_FROM_EFFECT: return matchCauseEffect(state.effect, {
+										onFailure: (cause) => bridgeInput.error(cause),
+										onSuccess: () => drainer()
+									});
+									case OP_READ: return readUpstream(state, () => drainer(), (cause) => bridgeInput.error(cause));
+								}
+							}));
+							result = fromEffect$3(flatMap$8(forkDaemon(interruptible(drainer())), (fiber) => sync$8(() => this.addFinalizer((exit) => flatMap$8(interrupt$2(fiber), () => suspend$9(() => {
+								const effect = this.restorePipe(exit, inputExecutor);
+								return effect !== void 0 ? effect : _void;
+							}))))));
+						}
+						break;
+					}
+					case OP_CONCAT_ALL: {
+						const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, (effect) => sync$8(() => {
+							this._closeLastSubstream = pipe(this._closeLastSubstream === void 0 ? _void : this._closeLastSubstream, zipRight$8(effect));
+						}));
+						executor._input = this._input;
+						const channel = this._currentChannel;
+						this._activeSubexecutor = new PullFromUpstream(executor, (value) => channel.k(value), void 0, [], (x, y) => channel.combineInners(x, y), (x, y) => channel.combineAll(x, y), (request) => channel.onPull(request), (value) => channel.onEmit(value));
+						this._closeLastSubstream = void 0;
+						this._currentChannel = void 0;
+						break;
+					}
+					case OP_EMIT$3:
+						this._emitted = this._currentChannel.out;
+						this._currentChannel = this._activeSubexecutor !== void 0 ? void 0 : void_$3;
+						result = Emit$1();
+						break;
+					case OP_ENSURING:
+						this.runEnsuring(this._currentChannel);
+						break;
+					case OP_FAIL$2:
+						result = this.doneHalt(this._currentChannel.error());
+						break;
+					case OP_FOLD:
+						this._doneStack.push(this._currentChannel.k);
+						this._currentChannel = this._currentChannel.channel;
+						break;
+					case OP_FROM_EFFECT$1:
+						result = fromEffect$3(matchCauseEffect(this._providedEnv === void 0 ? this._currentChannel.effect() : pipe(this._currentChannel.effect(), provide$2(this._providedEnv)), {
+							onFailure: (cause) => {
+								const state = this.doneHalt(cause);
+								return state !== void 0 && isFromEffect(state) ? state.effect : _void;
+							},
+							onSuccess: (value) => {
+								const state = this.doneSucceed(value);
+								return state !== void 0 && isFromEffect(state) ? state.effect : _void;
+							}
+						}));
+						break;
+					case OP_PIPE_TO: {
+						const previousInput = this._input;
+						const leftExec = new ChannelExecutor(this._currentChannel.left(), this._providedEnv, (effect) => this._executeCloseLastSubstream(effect));
+						leftExec._input = previousInput;
+						this._input = leftExec;
+						this.addFinalizer((exit) => {
+							const effect = this.restorePipe(exit, previousInput);
+							return effect !== void 0 ? effect : _void;
+						});
+						this._currentChannel = this._currentChannel.right();
+						break;
+					}
+					case OP_PROVIDE$1: {
+						const previousEnv = this._providedEnv;
+						this._providedEnv = this._currentChannel.context();
+						this._currentChannel = this._currentChannel.inner;
+						this.addFinalizer(() => sync$8(() => {
+							this._providedEnv = previousEnv;
+						}));
+						break;
+					}
+					case OP_READ$1: {
+						const read = this._currentChannel;
+						result = Read(this._input, identity$2, (emitted) => {
+							try {
+								this._currentChannel = read.more(emitted);
+							} catch (error) {
+								this._currentChannel = read.done.onExit(die$6(error));
+							}
+						}, (exit) => {
+							const onExit = (exit) => {
+								return read.done.onExit(exit);
+							};
+							this._currentChannel = onExit(exit);
+						});
+						break;
+					}
+					case OP_SUCCEED$2:
+						result = this.doneSucceed(this._currentChannel.evaluate());
+						break;
+					case OP_SUCCEED_NOW:
+						result = this.doneSucceed(this._currentChannel.terminal);
+						break;
+					case OP_SUSPEND$1:
+						this._currentChannel = this._currentChannel.channel();
+						break;
+				}
+			}
+		} catch (error) {
+			this._currentChannel = failCause$4(die$7(error));
+		}
+		return result;
+	}
+	getDone() {
+		return this._done;
+	}
+	getEmit() {
+		return this._emitted;
+	}
+	cancelWith(exit) {
+		this._cancelled = exit;
+	}
+	clearInProgressFinalizer() {
+		this._inProgressFinalizer = void 0;
+	}
+	storeInProgressFinalizer(finalizer) {
+		this._inProgressFinalizer = finalizer;
+	}
+	popAllFinalizers(exit) {
+		const finalizers = [];
+		let next = this._doneStack.pop();
+		while (next) {
+			if (next._tag === "ContinuationFinalizer") finalizers.push(next.finalizer);
+			next = this._doneStack.pop();
+		}
+		const effect = finalizers.length === 0 ? _void : runFinalizers(finalizers, exit);
+		this.storeInProgressFinalizer(effect);
+		return effect;
+	}
+	popNextFinalizers() {
+		const builder = [];
+		while (this._doneStack.length !== 0) {
+			const cont = this._doneStack[this._doneStack.length - 1];
+			if (cont._tag === "ContinuationK") return builder;
+			builder.push(cont);
+			this._doneStack.pop();
+		}
+		return builder;
+	}
+	restorePipe(exit, prev) {
+		const currInput = this._input;
+		this._input = prev;
+		if (currInput !== void 0) return currInput.close(exit);
+		return _void;
+	}
+	close(exit$1) {
+		let runInProgressFinalizers = void 0;
+		const finalizer = this._inProgressFinalizer;
+		if (finalizer !== void 0) runInProgressFinalizers = pipe(finalizer, ensuring$5(sync$8(() => this.clearInProgressFinalizer())));
+		let closeSelf = void 0;
+		const selfFinalizers = this.popAllFinalizers(exit$1);
+		if (selfFinalizers !== void 0) closeSelf = pipe(selfFinalizers, ensuring$5(sync$8(() => this.clearInProgressFinalizer())));
+		const closeSubexecutors = this._activeSubexecutor === void 0 ? void 0 : this._activeSubexecutor.close(exit$1);
+		if (closeSubexecutors === void 0 && runInProgressFinalizers === void 0 && closeSelf === void 0) return;
+		return pipe(exit(ifNotNull(closeSubexecutors)), zip$4(exit(ifNotNull(runInProgressFinalizers))), zip$4(exit(ifNotNull(closeSelf))), map$10(([[exit1, exit2], exit3]) => pipe(exit1, zipRight$7(exit2), zipRight$7(exit3))), uninterruptible$1, flatMap$8((exit) => suspend$9(() => exit)));
+	}
+	doneSucceed(value) {
+		if (this._doneStack.length === 0) {
+			this._done = succeed$9(value);
+			this._currentChannel = void 0;
+			return Done$2();
+		}
+		const head = this._doneStack[this._doneStack.length - 1];
+		if (head._tag === "ContinuationK") {
+			this._doneStack.pop();
+			this._currentChannel = head.onSuccess(value);
+			return;
+		}
+		const finalizers = this.popNextFinalizers();
+		if (this._doneStack.length === 0) {
+			this._doneStack = finalizers.reverse();
+			this._done = succeed$9(value);
+			this._currentChannel = void 0;
+			return Done$2();
+		}
+		const finalizerEffect = runFinalizers(finalizers.map((f) => f.finalizer), succeed$9(value));
+		this.storeInProgressFinalizer(finalizerEffect);
+		return fromEffect$3(pipe(finalizerEffect, ensuring$5(sync$8(() => this.clearInProgressFinalizer())), uninterruptible$1, flatMap$8(() => sync$8(() => this.doneSucceed(value)))));
+	}
+	doneHalt(cause) {
+		if (this._doneStack.length === 0) {
+			this._done = failCause$7(cause);
+			this._currentChannel = void 0;
+			return Done$2();
+		}
+		const head = this._doneStack[this._doneStack.length - 1];
+		if (head._tag === "ContinuationK") {
+			this._doneStack.pop();
+			try {
+				this._currentChannel = head.onHalt(cause);
+			} catch (error) {
+				this._currentChannel = failCause$4(die$7(error));
+			}
+			return;
+		}
+		const finalizers = this.popNextFinalizers();
+		if (this._doneStack.length === 0) {
+			this._doneStack = finalizers.reverse();
+			this._done = failCause$7(cause);
+			this._currentChannel = void 0;
+			return Done$2();
+		}
+		const finalizerEffect = runFinalizers(finalizers.map((f) => f.finalizer), failCause$7(cause));
+		this.storeInProgressFinalizer(finalizerEffect);
+		return fromEffect$3(pipe(finalizerEffect, ensuring$5(sync$8(() => this.clearInProgressFinalizer())), uninterruptible$1, flatMap$8(() => sync$8(() => this.doneHalt(cause)))));
+	}
+	processCancellation() {
+		this._currentChannel = void 0;
+		this._done = this._cancelled;
+		this._cancelled = void 0;
+		return Done$2();
+	}
+	runBracketOut(bracketOut) {
+		return fromEffect$3(uninterruptible$1(matchCauseEffect(this.provide(bracketOut.acquire()), {
+			onFailure: (cause) => sync$8(() => {
+				this._currentChannel = failCause$4(cause);
+			}),
+			onSuccess: (out) => sync$8(() => {
+				this.addFinalizer((exit) => this.provide(bracketOut.finalizer(out, exit)));
+				this._currentChannel = write(out);
+			})
+		})));
+	}
+	provide(effect) {
+		if (this._providedEnv === void 0) return effect;
+		return pipe(effect, provide$2(this._providedEnv));
+	}
+	runEnsuring(ensuring) {
+		this.addFinalizer(ensuring.finalizer);
+		this._currentChannel = ensuring.channel;
+	}
+	addFinalizer(f) {
+		this._doneStack.push(new ContinuationFinalizerImpl(f));
+	}
+	runSubexecutor() {
+		const subexecutor = this._activeSubexecutor;
+		switch (subexecutor._tag) {
+			case OP_PULL_FROM_CHILD: return this.pullFromChild(subexecutor.childExecutor, subexecutor.parentSubexecutor, subexecutor.onEmit, subexecutor);
+			case OP_PULL_FROM_UPSTREAM: return this.pullFromUpstream(subexecutor);
+			case OP_DRAIN_CHILD_EXECUTORS: return this.drainChildExecutors(subexecutor);
+			case OP_EMIT$1:
+				this._emitted = subexecutor.value;
+				this._activeSubexecutor = subexecutor.next;
+				return Emit$1();
+		}
+	}
+	replaceSubexecutor(nextSubExec) {
+		this._currentChannel = void 0;
+		this._activeSubexecutor = nextSubExec;
+	}
+	finishWithExit(exit) {
+		const state = match$9(exit, {
+			onFailure: (cause) => this.doneHalt(cause),
+			onSuccess: (value) => this.doneSucceed(value)
+		});
+		this._activeSubexecutor = void 0;
+		return state === void 0 ? _void : effect$1(state);
+	}
+	finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
+		this.addFinalizer(() => pipe(closeFuncs, forEach$2((closeFunc) => pipe(sync$8(() => closeFunc(subexecutorDone)), flatMap$8((closeEffect) => closeEffect !== void 0 ? closeEffect : _void)), { discard: true })));
+		const state = pipe(subexecutorDone, match$9({
+			onFailure: (cause) => this.doneHalt(cause),
+			onSuccess: (value) => this.doneSucceed(value)
+		}));
+		this._activeSubexecutor = void 0;
+		return state;
+	}
+	applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
+		switch (strategy._tag) {
+			case OP_PULL_AFTER_NEXT: {
+				const shouldPrepend = !upstreamFinished || queue.some((subexecutor) => subexecutor !== void 0);
+				return [strategy.emitSeparator, shouldPrepend ? [void 0, ...queue] : queue];
+			}
+			case OP_PULL_AFTER_ALL_ENQUEUED: {
+				const shouldEnqueue = !upstreamFinished || queue.some((subexecutor) => subexecutor !== void 0);
+				return [strategy.emitSeparator, shouldEnqueue ? [...queue, void 0] : queue];
+			}
+		}
+	}
+	pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
+		return Read(childExecutor, identity$2, (emitted) => {
+			const childExecutorDecision = onEmitted(emitted);
+			switch (childExecutorDecision._tag) {
+				case OP_CONTINUE: break;
+				case OP_CLOSE:
+					this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision.value);
+					break;
+				case OP_YIELD: {
+					const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor);
+					this.replaceSubexecutor(modifiedParent);
+					break;
+				}
+			}
+			this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
+		}, match$9({
+			onFailure: (cause) => {
+				const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
+				return state === void 0 ? void 0 : effectOrUndefinedIgnored(state);
+			},
+			onSuccess: (doneValue) => {
+				this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue);
+			}
+		}));
+	}
+	finishWithDoneValue(childExecutor, parentSubexecutor, doneValue) {
+		const subexecutor = parentSubexecutor;
+		switch (subexecutor._tag) {
+			case OP_PULL_FROM_UPSTREAM: {
+				const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== void 0 ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
+				this._closeLastSubstream = childExecutor.close(succeed$9(doneValue));
+				this.replaceSubexecutor(modifiedParent);
+				break;
+			}
+			case OP_DRAIN_CHILD_EXECUTORS: {
+				const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== void 0 ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+				this._closeLastSubstream = childExecutor.close(succeed$9(doneValue));
+				this.replaceSubexecutor(modifiedParent);
+				break;
+			}
+			default: break;
+		}
+	}
+	handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
+		return this.finishSubexecutorWithCloseEffect(failCause$7(cause), (exit) => parentSubexecutor.close(exit), (exit) => childExecutor.close(exit));
+	}
+	pullFromUpstream(subexecutor) {
+		if (subexecutor.activeChildExecutors.length === 0) return this.performPullFromUpstream(subexecutor);
+		const activeChild = subexecutor.activeChildExecutors[0];
+		const parentSubexecutor = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, subexecutor.activeChildExecutors.slice(1), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
+		if (activeChild === void 0) return this.performPullFromUpstream(parentSubexecutor);
+		this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
+	}
+	performPullFromUpstream(subexecutor) {
+		return Read(subexecutor.upstreamExecutor, (effect) => {
+			const closeLastSubstream = this._closeLastSubstream === void 0 ? _void : this._closeLastSubstream;
+			this._closeLastSubstream = void 0;
+			return pipe(this._executeCloseLastSubstream(closeLastSubstream), zipRight$8(effect));
+		}, (emitted) => {
+			if (this._closeLastSubstream !== void 0) {
+				const closeLastSubstream = this._closeLastSubstream;
+				this._closeLastSubstream = void 0;
+				return pipe(this._executeCloseLastSubstream(closeLastSubstream), map$10(() => {
+					const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
+					childExecutor._input = this._input;
+					const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
+					this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
+					if (isSome(emitSeparator)) this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
+				}));
+			}
+			const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
+			childExecutor._input = this._input;
+			const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(Pulled(emitted)));
+			this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
+			if (isSome(emitSeparator)) this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
+		}, (exit) => {
+			if (subexecutor.activeChildExecutors.some((subexecutor) => subexecutor !== void 0)) {
+				const drain = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, [void 0, ...subexecutor.activeChildExecutors], subexecutor.upstreamExecutor.getDone(), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+				if (this._closeLastSubstream !== void 0) {
+					const closeLastSubstream = this._closeLastSubstream;
+					this._closeLastSubstream = void 0;
+					return pipe(this._executeCloseLastSubstream(closeLastSubstream), map$10(() => this.replaceSubexecutor(drain)));
+				}
+				this.replaceSubexecutor(drain);
+				return;
+			}
+			const closeLastSubstream = this._closeLastSubstream;
+			const state = this.finishSubexecutorWithCloseEffect(pipe(exit, map$11((a) => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, (exit) => subexecutor.upstreamExecutor.close(exit));
+			return state === void 0 ? void 0 : effectOrUndefinedIgnored(state);
+		});
+	}
+	drainChildExecutors(subexecutor) {
+		if (subexecutor.activeChildExecutors.length === 0) {
+			const lastClose = this._closeLastSubstream;
+			if (lastClose !== void 0) this.addFinalizer(() => succeed$10(lastClose));
+			return this.finishSubexecutorWithCloseEffect(subexecutor.upstreamDone, () => lastClose, (exit) => subexecutor.upstreamExecutor.close(exit));
+		}
+		const activeChild = subexecutor.activeChildExecutors[0];
+		const rest = subexecutor.activeChildExecutors.slice(1);
+		if (activeChild === void 0) {
+			const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(true, rest, subexecutor.onPull(NoUpstream(rest.reduce((n, curr) => curr !== void 0 ? n + 1 : n, 0))));
+			this.replaceSubexecutor(new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, remainingExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull));
+			if (isSome(emitSeparator)) {
+				this._emitted = emitSeparator.value;
+				return Emit$1();
+			}
+			return;
+		}
+		const parentSubexecutor = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, rest, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
+		this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
+	}
+};
+const ifNotNull = (effect) => effect !== void 0 ? effect : _void;
+const runFinalizers = (finalizers, exit$2) => {
+	return pipe(forEach$2(finalizers, (fin) => exit(fin(exit$2))), map$10((exits) => pipe(all$2(exits), getOrElse(() => void_$5))), flatMap$8((exit) => suspend$9(() => exit)));
+};
+/**
+* @internal
+*/
+const readUpstream = (r, onSuccess, onFailure) => {
+	const readStack = [r];
+	const read = () => {
+		const current = readStack.pop();
+		if (current === void 0 || current.upstream === void 0) return dieMessage$2("Unexpected end of input for channel execution");
+		const state = current.upstream.run();
+		switch (state._tag) {
+			case OP_EMIT$2: {
+				const emitEffect = current.onEmit(current.upstream.getEmit());
+				if (readStack.length === 0) {
+					if (emitEffect === void 0) return suspend$9(onSuccess);
+					return pipe(emitEffect, matchCauseEffect({
+						onFailure,
+						onSuccess
+					}));
+				}
+				if (emitEffect === void 0) return suspend$9(() => read());
+				return pipe(emitEffect, matchCauseEffect({
+					onFailure,
+					onSuccess: () => read()
+				}));
+			}
+			case OP_DONE$3: {
+				const doneEffect = current.onDone(current.upstream.getDone());
+				if (readStack.length === 0) {
+					if (doneEffect === void 0) return suspend$9(onSuccess);
+					return pipe(doneEffect, matchCauseEffect({
+						onFailure,
+						onSuccess
+					}));
+				}
+				if (doneEffect === void 0) return suspend$9(() => read());
+				return pipe(doneEffect, matchCauseEffect({
+					onFailure,
+					onSuccess: () => read()
+				}));
+			}
+			case OP_FROM_EFFECT:
+				readStack.push(current);
+				return pipe(current.onEffect(state.effect), catchAllCause$5((cause) => suspend$9(() => {
+					const doneEffect = current.onDone(failCause$7(cause));
+					return doneEffect === void 0 ? _void : doneEffect;
+				})), matchCauseEffect({
+					onFailure,
+					onSuccess: () => read()
+				}));
+			case OP_READ:
+				readStack.push(current);
+				readStack.push(state);
+				return suspend$9(() => read());
+		}
+	};
+	return read();
+};
+/** @internal */
+const runIn = /* @__PURE__ */ dual(2, (self, scope) => {
+	const run = (channelDeferred, scopeDeferred, scope) => acquireUseRelease$1(sync$8(() => new ChannelExecutor(self, void 0, identity$2)), (exec) => suspend$9(() => runScopedInterpret(exec.run(), exec).pipe(intoDeferred(channelDeferred), zipRight$8(_await(channelDeferred)), zipLeft$4(_await(scopeDeferred)))), (exec, exit) => {
+		const finalize = exec.close(exit);
+		if (finalize === void 0) return _void;
+		return tapErrorCause$4(finalize, (cause) => addFinalizer$1(scope, failCause$8(cause)));
+	});
+	return uninterruptibleMask((restore) => all$3([
+		fork(scope, sequential$1),
+		make$17(),
+		make$17()
+	]).pipe(flatMap$8(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(forkIn(scope), flatMap$8((fiber) => scope.addFinalizer((exit) => {
+		const interruptors$1 = isFailure(exit) ? interruptors(exit.cause) : void 0;
+		return isDone$1(channelDeferred).pipe(flatMap$8((isDone) => isDone ? succeed$11(scopeDeferred, void 0).pipe(zipRight$8(_await$1(fiber)), zipRight$8(inheritAll(fiber))) : succeed$11(scopeDeferred, void 0).pipe(zipRight$8(interruptors$1 && size$8(interruptors$1) > 0 ? interruptAs$1(fiber, combineAll(interruptors$1)) : interrupt$2(fiber)), zipRight$8(inheritAll(fiber)))));
+	}).pipe(zipRight$8(restore(_await(channelDeferred)))))))));
+});
+/** @internal */
+const runScopedInterpret = (channelState, exec) => {
+	const op = channelState;
+	switch (op._tag) {
+		case OP_FROM_EFFECT: return pipe(op.effect, flatMap$8(() => runScopedInterpret(exec.run(), exec)));
+		case OP_EMIT$2: return runScopedInterpret(exec.run(), exec);
+		case OP_DONE$3: return suspend$9(() => exec.getDone());
+		case OP_READ: return readUpstream(op, () => runScopedInterpret(exec.run(), exec), failCause$8);
+	}
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelMergeDecision.js
+/** @internal */
+const OP_DONE$2 = "Done";
+/** @internal */
+const OP_AWAIT = "Await";
+/** @internal */
+const proto$2 = { [/* @__PURE__ */ Symbol.for("effect/ChannelMergeDecision")]: {
+	_R: (_) => _,
+	_E0: (_) => _,
+	_Z0: (_) => _,
+	_E: (_) => _,
+	_Z: (_) => _
+} };
+/** @internal */
+const Done$1 = (effect) => {
+	const op = Object.create(proto$2);
+	op._tag = OP_DONE$2;
+	op.effect = effect;
+	return op;
+};
+/** @internal */
+const Await$1 = (f) => {
+	const op = Object.create(proto$2);
+	op._tag = OP_AWAIT;
+	op.f = f;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelMergeState.js
+/** @internal */
+const OP_BOTH_RUNNING = "BothRunning";
+/** @internal */
+const OP_LEFT_DONE = "LeftDone";
+/** @internal */
+const OP_RIGHT_DONE = "RightDone";
+/** @internal */
+const MergeStateTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelMergeState");
+/** @internal */
+const proto$1 = { [MergeStateTypeId]: MergeStateTypeId };
+/** @internal */
+const BothRunning = (left, right) => {
+	const op = Object.create(proto$1);
+	op._tag = OP_BOTH_RUNNING;
+	op.left = left;
+	op.right = right;
+	return op;
+};
+/** @internal */
+const LeftDone = (f) => {
+	const op = Object.create(proto$1);
+	op._tag = OP_LEFT_DONE;
+	op.f = f;
+	return op;
+};
+/** @internal */
+const RightDone = (f) => {
+	const op = Object.create(proto$1);
+	op._tag = OP_RIGHT_DONE;
+	op.f = f;
+	return op;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/channelMergeStrategy.js
+/** @internal */
+const OP_BACK_PRESSURE = "BackPressure";
+/** @internal */
+const OP_BUFFER_SLIDING = "BufferSliding";
+/** @internal */
+const MergeStrategyTypeId = /* @__PURE__ */ Symbol.for("effect/ChannelMergeStrategy");
+/** @internal */
+const proto = { [MergeStrategyTypeId]: MergeStrategyTypeId };
+/** @internal */
+const BackPressure$1 = (_) => {
+	const op = Object.create(proto);
+	op._tag = OP_BACK_PRESSURE;
+	return op;
+};
+/** @internal */
+const BufferSliding = (_) => {
+	const op = Object.create(proto);
+	op._tag = OP_BUFFER_SLIDING;
+	return op;
+};
+/** @internal */
+const match$4 = /* @__PURE__ */ dual(2, (self, { onBackPressure, onBufferSliding }) => {
+	switch (self._tag) {
+		case OP_BACK_PRESSURE: return onBackPressure();
+		case OP_BUFFER_SLIDING: return onBufferSliding();
+	}
+});
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/channel/singleProducerAsyncInput.js
+/** @internal */
+const OP_STATE_EMPTY = "Empty";
+/** @internal */
+const OP_STATE_EMIT = "Emit";
+/** @internal */
+const OP_STATE_ERROR = "Error";
+/** @internal */
+const OP_STATE_DONE = "Done";
+/** @internal */
+const stateEmpty$1 = (notifyProducer) => ({
+	_tag: OP_STATE_EMPTY,
+	notifyProducer
+});
+/** @internal */
+const stateEmit = (notifyConsumers) => ({
+	_tag: OP_STATE_EMIT,
+	notifyConsumers
+});
+/** @internal */
+const stateError = (cause) => ({
+	_tag: OP_STATE_ERROR,
+	cause
+});
+/** @internal */
+const stateDone = (done) => ({
+	_tag: OP_STATE_DONE,
+	done
+});
+/** @internal */
+var SingleProducerAsyncInputImpl = class {
+	ref;
+	constructor(ref) {
+		this.ref = ref;
+	}
+	awaitRead() {
+		return flatten$6(modify$1(this.ref, (state) => state._tag === OP_STATE_EMPTY ? [_await(state.notifyProducer), state] : [_void, state]));
+	}
+	get close() {
+		return fiberIdWith((fiberId) => this.error(interrupt$3(fiberId)));
+	}
+	done(value) {
+		return flatten$6(modify$1(this.ref, (state) => {
+			switch (state._tag) {
+				case OP_STATE_EMPTY: return [_await(state.notifyProducer), state];
+				case OP_STATE_EMIT: return [forEach$2(state.notifyConsumers, (deferred) => succeed$11(deferred, left(value)), { discard: true }), stateDone(value)];
+				case OP_STATE_ERROR: return [interrupt$4, state];
+				case OP_STATE_DONE: return [interrupt$4, state];
+			}
+		}));
+	}
+	emit(element) {
+		return flatMap$8(make$17(), (deferred) => flatten$6(modify$1(this.ref, (state) => {
+			switch (state._tag) {
+				case OP_STATE_EMPTY: return [_await(state.notifyProducer), state];
+				case OP_STATE_EMIT: {
+					const notifyConsumer = state.notifyConsumers[0];
+					const notifyConsumers = state.notifyConsumers.slice(1);
+					if (notifyConsumer !== void 0) return [succeed$11(notifyConsumer, right(element)), notifyConsumers.length === 0 ? stateEmpty$1(deferred) : stateEmit(notifyConsumers)];
+					throw new Error("Bug: Channel.SingleProducerAsyncInput.emit - Queue was empty! please report an issue at https://github.com/Effect-TS/effect/issues");
+				}
+				case OP_STATE_ERROR: return [interrupt$4, state];
+				case OP_STATE_DONE: return [interrupt$4, state];
+			}
+		})));
+	}
+	error(cause) {
+		return flatten$6(modify$1(this.ref, (state) => {
+			switch (state._tag) {
+				case OP_STATE_EMPTY: return [_await(state.notifyProducer), state];
+				case OP_STATE_EMIT: return [forEach$2(state.notifyConsumers, (deferred) => failCause$9(deferred, cause), { discard: true }), stateError(cause)];
+				case OP_STATE_ERROR: return [interrupt$4, state];
+				case OP_STATE_DONE: return [interrupt$4, state];
+			}
+		}));
+	}
+	get take() {
+		return this.takeWith((cause) => failCause$7(map$12(cause, left)), (elem) => succeed$9(elem), (done) => fail$9(right(done)));
+	}
+	takeWith(onError, onElement, onDone) {
+		return flatMap$8(make$17(), (deferred) => flatten$6(modify$1(this.ref, (state) => {
+			switch (state._tag) {
+				case OP_STATE_EMPTY: return [zipRight$8(succeed$11(state.notifyProducer, void 0), matchCause$2(_await(deferred), {
+					onFailure: onError,
+					onSuccess: match$8({
+						onLeft: onDone,
+						onRight: onElement
+					})
+				})), stateEmit([deferred])];
+				case OP_STATE_EMIT: return [matchCause$2(_await(deferred), {
+					onFailure: onError,
+					onSuccess: match$8({
+						onLeft: onDone,
+						onRight: onElement
+					})
+				}), stateEmit([...state.notifyConsumers, deferred])];
+				case OP_STATE_ERROR: return [succeed$10(onError(state.cause)), state];
+				case OP_STATE_DONE: return [succeed$10(onDone(state.done)), state];
+			}
+		})));
+	}
+};
+/** @internal */
+const make$11 = () => pipe(make$17(), flatMap$8((deferred) => make$18(stateEmpty$1(deferred))), map$10((ref) => new SingleProducerAsyncInputImpl(ref)));
+/** @internal */
+const as$4 = /* @__PURE__ */ dual(2, (self, value) => map$6(self, () => value));
+/** @internal */
+const catchAll$3 = /* @__PURE__ */ dual(2, (self, f) => catchAllCause$2(self, (cause) => match$8(failureOrCause(cause), {
+	onLeft: f,
+	onRight: failCause$4
+})));
+/** @internal */
+const concatMap$1 = /* @__PURE__ */ dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
+/** @internal */
+const drain$3 = (self) => {
+	const drainer = readWithCause({
+		onInput: () => drainer,
+		onFailure: failCause$4,
+		onDone: succeed$5
+	});
+	return pipeTo(self, drainer);
+};
+/** @internal */
+const ensuring$4 = /* @__PURE__ */ dual(2, (self, finalizer) => ensuringWith$2(self, () => finalizer));
+/** @internal */
+const flatten$3 = (self) => flatMap$4(self, identity$2);
+/** @internal */
+const fromInput$2 = (input) => unwrap$2(input.takeWith(failCause$4, (elem) => flatMap$4(write(elem), () => fromInput$2(input)), succeed$5));
+/** @internal */
+const fromQueueInternal = (queue) => pipe(fromEffect$4(take$6(queue)), flatMap$4(match$8({
+	onLeft: match$9({
+		onFailure: failCause$4,
+		onSuccess: succeedNow
+	}),
+	onRight: (elem) => flatMap$4(write(elem), () => fromQueueInternal(queue))
+})));
+/** @internal */
+const identityChannel = () => readWith({
+	onInput: (input) => flatMap$4(write(input), () => identityChannel()),
+	onFailure: fail$5,
+	onDone: succeedNow
+});
+/** @internal */
+const map$6 = /* @__PURE__ */ dual(2, (self, f) => flatMap$4(self, (a) => sync$4(() => f(a))));
+/** @internal */
+const mapOut = /* @__PURE__ */ dual(2, (self, f) => {
+	const reader = readWith({
+		onInput: (outElem) => flatMap$4(write(f(outElem)), () => reader),
+		onFailure: fail$5,
+		onDone: succeedNow
+	});
+	return pipeTo(self, reader);
+});
+/** @internal */
+const mergeAll$3 = (options) => {
+	return (channels) => mergeAllWith(options)(channels, constVoid);
+};
+/** @internal */
+const mergeAllWith = ({ bufferSize = 16, concurrency, mergeStrategy = BackPressure$1() }) => (channels, f) => unwrapScopedWith$3((scope) => gen(function* () {
+	const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency;
+	const input = yield* make$11();
+	const queueReader = fromInput$2(input);
+	const queue = yield* bounded$4(bufferSize);
+	yield* addFinalizer$1(scope, shutdown$4(queue));
+	const cancelers = yield* unbounded$4();
+	yield* addFinalizer$1(scope, shutdown$4(cancelers));
+	const lastDone = yield* make$18(none());
+	const errorSignal = yield* make$17();
+	const withPermits = (yield* makeSemaphore(concurrencyN)).withPermits;
+	const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
+	function evaluatePull(pull) {
+		return pull.pipe(flatMap$8(match$8({
+			onLeft: (done) => succeed$10(some$2(done)),
+			onRight: (outElem) => as$5(offer$3(queue, succeed$10(right(outElem))), none())
+		})), repeat$3({ until: (_) => isSome(_) }), flatMap$8((outDone) => update$1(lastDone, match$10({
+			onNone: () => some$2(outDone.value),
+			onSome: (lastDone) => some$2(f(lastDone, outDone.value))
+		}))), catchAllCause$5((cause) => isInterrupted(cause) ? failCause$8(cause) : offer$3(queue, failCause$8(cause)).pipe(zipRight$8(succeed$11(errorSignal, void 0)), asVoid$2)));
+	}
+	yield* pull.pipe(matchCauseEffect({
+		onFailure: (cause) => offer$3(queue, failCause$8(cause)).pipe(zipRight$8(succeed$10(false))),
+		onSuccess: match$8({
+			onLeft: (outDone) => raceWith$1(interruptible(_await(errorSignal)), interruptible(withPermits(concurrencyN)(_void)), {
+				onSelfDone: (_, permitAcquisition) => as$5(interrupt$2(permitAcquisition), false),
+				onOtherDone: (_, failureAwait) => zipRight$8(interrupt$2(failureAwait), get$5(lastDone).pipe(flatMap$8(match$10({
+					onNone: () => offer$3(queue, succeed$10(left(outDone))),
+					onSome: (lastDone) => offer$3(queue, succeed$10(left(f(lastDone, outDone))))
+				})), as$5(false)))
+			}),
+			onRight: (channel) => match$4(mergeStrategy, {
+				onBackPressure: () => gen(function* () {
+					const latch = yield* make$17();
+					const raceEffects = scopedWith$3((scope) => toPullIn(pipeTo(queueReader, channel), scope).pipe(flatMap$8((pull) => race$3(exit(evaluatePull(pull)), exit(interruptible(_await(errorSignal))))), flatMap$8(identity$2)));
+					yield* succeed$11(latch, void 0).pipe(zipRight$8(raceEffects), withPermits(1), forkIn(scope));
+					yield* _await(latch);
+					return !(yield* isDone$1(errorSignal));
+				}),
+				onBufferSliding: () => gen(function* () {
+					const canceler = yield* make$17();
+					const latch = yield* make$17();
+					const size = yield* size$4(cancelers);
+					yield* take$6(cancelers).pipe(flatMap$8((canceler) => succeed$11(canceler, void 0)), when$2(() => size >= concurrencyN));
+					yield* offer$3(cancelers, canceler);
+					const raceEffects = scopedWith$3((scope) => toPullIn(pipeTo(queueReader, channel), scope).pipe(flatMap$8((pull) => exit(evaluatePull(pull)).pipe(race$3(exit(interruptible(_await(errorSignal)))), race$3(exit(interruptible(_await(canceler)))))), flatMap$8(identity$2)));
+					yield* succeed$11(latch, void 0).pipe(zipRight$8(raceEffects), withPermits(1), forkIn(scope));
+					yield* _await(latch);
+					return !(yield* isDone$1(errorSignal));
+				})
+			})
+		})
+	}), repeat$3({ while: (_) => _ }), forkIn(scope));
+	const consumer = pipe(take$6(queue), flatten$6, matchCause$2({
+		onFailure: failCause$4,
+		onSuccess: match$8({
+			onLeft: succeedNow,
+			onRight: (outElem) => flatMap$4(write(outElem), () => consumer)
+		})
+	}), unwrap$2);
+	return embedInput(consumer, input);
+}));
+/** @internal */
+const mergeMap$1 = /* @__PURE__ */ dual(3, (self, f, options) => mergeAll$3(options)(mapOut(self, f)));
+/** @internal */
+const mergeWith$2 = /* @__PURE__ */ dual(2, (self, options) => {
+	function merge(scope) {
+		return gen(function* () {
+			const input = yield* make$11();
+			const queueReader = fromInput$2(input);
+			const pullL = yield* toPullIn(pipeTo(queueReader, self), scope);
+			const pullR = yield* toPullIn(pipeTo(queueReader, options.other), scope);
+			function handleSide(exit, fiber, pull) {
+				return (done, both, single) => {
+					function onDecision(decision) {
+						const op = decision;
+						if (op._tag === "Done") return succeed$10(fromEffect$4(zipRight$8(interrupt$2(fiber), op.effect)));
+						return map$10(_await$1(fiber), match$9({
+							onFailure: (cause) => fromEffect$4(op.f(failCause$7(cause))),
+							onSuccess: match$8({
+								onLeft: (done) => fromEffect$4(op.f(succeed$9(done))),
+								onRight: (elem) => zipRight$5(write(elem), go(single(op.f)))
+							})
+						}));
+					}
+					return match$9(exit, {
+						onFailure: (cause) => onDecision(done(failCause$7(cause))),
+						onSuccess: match$8({
+							onLeft: (z) => onDecision(done(succeed$9(z))),
+							onRight: (elem) => succeed$10(flatMap$4(write(elem), () => flatMap$4(fromEffect$4(forkIn(interruptible(pull), scope)), (leftFiber) => go(both(leftFiber, fiber)))))
+						})
+					});
+				};
+			}
+			function go(state) {
+				switch (state._tag) {
+					case OP_BOTH_RUNNING: return unwrap$2(raceWith$1(interruptible(join(state.left)), interruptible(join(state.right)), {
+						onSelfDone: (leftExit, rf) => zipRight$8(interrupt$2(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, (f) => LeftDone(f))),
+						onOtherDone: (rightExit, lf) => zipRight$8(interrupt$2(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), (f) => RightDone(f)))
+					}));
+					case OP_LEFT_DONE: return unwrap$2(map$10(exit(pullR), match$9({
+						onFailure: (cause) => fromEffect$4(state.f(failCause$7(cause))),
+						onSuccess: match$8({
+							onLeft: (done) => fromEffect$4(state.f(succeed$9(done))),
+							onRight: (elem) => flatMap$4(write(elem), () => go(LeftDone(state.f)))
+						})
+					})));
+					case OP_RIGHT_DONE: return unwrap$2(map$10(exit(pullL), match$9({
+						onFailure: (cause) => fromEffect$4(state.f(failCause$7(cause))),
+						onSuccess: match$8({
+							onLeft: (done) => fromEffect$4(state.f(succeed$9(done))),
+							onRight: (elem) => flatMap$4(write(elem), () => go(RightDone(state.f)))
+						})
+					})));
+				}
+			}
+			return fromEffect$4(withFiberRuntime$1((parent) => {
+				const inherit = withFiberRuntime$1((state) => {
+					state.transferChildren(parent.scope());
+					return _void;
+				});
+				return zipWith$7(interruptible(pullL).pipe(ensuring$5(inherit), forkIn(scope)), interruptible(pullR).pipe(ensuring$5(inherit), forkIn(scope)), (left, right) => BothRunning(left, right));
+			})).pipe(flatMap$4(go), embedInput(input));
+		});
+	}
+	return unwrapScopedWith$3(merge);
+});
+/** @internal */
+const pipeToOrFail = /* @__PURE__ */ dual(2, (self, that) => suspend$5(() => {
+	let channelException = void 0;
+	const reader = readWith({
+		onInput: (outElem) => flatMap$4(write(outElem), () => reader),
+		onFailure: (outErr) => {
+			channelException = ChannelException(outErr);
+			return failCause$4(die$7(channelException));
+		},
+		onDone: succeedNow
+	});
+	const writer = readWithCause({
+		onInput: (outElem) => pipe(write(outElem), flatMap$4(() => writer)),
+		onFailure: (cause) => isDieType(cause) && isChannelException(cause.defect) && equals(cause.defect, channelException) ? fail$5(cause.defect.error) : failCause$4(cause),
+		onDone: succeedNow
+	});
+	return pipeTo(pipeTo(pipeTo(self, reader), that), writer);
+}));
+/** @internal */
+const repeated = (self) => flatMap$4(self, () => repeated(self));
+/** @internal */
+const run$3 = (self) => scopedWith$3((scope) => runIn(self, scope));
+/** @internal */
+const runDrain$2 = (self) => run$3(drain$3(self));
+/** @internal */
+const scoped$2 = (effect) => unwrap$2(uninterruptibleMask((restore) => map$10(make$19(), (scope) => acquireReleaseOut(tapErrorCause$4(restore(extend(effect, scope)), (cause) => close(scope, failCause$7(cause))), (_, exit) => close(scope, exit)))));
+/** @internal */
+const scopedWith$2 = (f) => unwrapScoped$2(map$10(scope$2, (scope) => flatMap$4(fromEffect$4(f(scope)), write)));
+/** @internal */
+const toPull$2 = (self) => flatMap$8(scope$2, (scope) => toPullIn(self, scope));
+/** @internal */
+const toPullIn = /* @__PURE__ */ dual(2, (self, scope) => zip$4(sync$8(() => new ChannelExecutor(self, void 0, identity$2)), runtime()).pipe(tap$7(([executor, runtime]) => addFinalizerExit(scope, (exit) => {
+	const finalizer = executor.close(exit);
+	return finalizer !== void 0 ? provide$2(finalizer, runtime) : _void;
+})), uninterruptible$1, map$10(([executor]) => suspend$9(() => interpretToPull(executor.run(), executor)))));
+/** @internal */
+const interpretToPull = (channelState, exec) => {
+	const state = channelState;
+	switch (state._tag) {
+		case OP_DONE$3: return match$9(exec.getDone(), {
+			onFailure: failCause$8,
+			onSuccess: (done) => succeed$10(left(done))
+		});
+		case OP_EMIT$2: return succeed$10(right(exec.getEmit()));
+		case OP_FROM_EFFECT: return pipe(state.effect, flatMap$8(() => interpretToPull(exec.run(), exec)));
+		case OP_READ: return readUpstream(state, () => interpretToPull(exec.run(), exec), (cause) => failCause$8(cause));
+	}
+};
+/** @internal */
+const toQueueInternal = (queue) => {
+	return readWithCause({
+		onInput: (elem) => flatMap$4(fromEffect$4(offer$3(queue, right(elem))), () => toQueueInternal(queue)),
+		onFailure: (cause) => fromEffect$4(offer$3(queue, left(failCause$7(cause)))),
+		onDone: (done) => fromEffect$4(offer$3(queue, left(succeed$9(done))))
+	});
+};
+/** @internal */
+const unwrap$2 = (channel) => flatten$3(fromEffect$4(channel));
+/** @internal */
+const unwrapScoped$2 = (self) => concatAllWith(scoped$2(self), (d, _) => d, (d, _) => d);
+/** @internal */
+const unwrapScopedWith$3 = (f) => concatAllWith(scopedWith$2(f), (d, _) => d, (d, _) => d);
+/** @internal */
+const writeAll = (...outs) => writeChunk(fromIterable$3(outs));
+/** @internal */
+const writeChunk = (outs) => writeChunkWriter(0, outs.length, outs);
+/** @internal */
+const writeChunkWriter = (idx, len, chunk) => {
+	return idx === len ? void_$3 : pipe(write(pipe(chunk, unsafeGet$2(idx))), flatMap$4(() => writeChunkWriter(idx + 1, len, chunk)));
+};
+/** @internal */
+const zip$3 = /* @__PURE__ */ dual((args) => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith$2(self, {
+	other: that,
+	onSelfDone: (exit1) => Await$1((exit2) => suspend$9(() => zip$5(exit1, exit2))),
+	onOtherDone: (exit2) => Await$1((exit1) => suspend$9(() => zip$5(exit1, exit2)))
+}) : flatMap$4(self, (a) => map$6(that, (b) => [a, b])));
+/** @internal */
+const zipRight$5 = /* @__PURE__ */ dual((args) => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$6(zip$3(self, that, { concurrent: true }), (tuple) => tuple[1]) : flatMap$4(self, () => that));
+/** @internal */
+const ChannelExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Channel/ChannelException");
+/** @internal */
+const ChannelException = (error) => ({
+	_tag: "ChannelException",
+	[ChannelExceptionTypeId]: ChannelExceptionTypeId,
+	error
+});
+/** @internal */
+const isChannelException = (u) => hasProperty(u, ChannelExceptionTypeId);
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/sink.js
+/** @internal */
+const SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
+const sinkVariance = {
+	_A: (_) => _,
+	_In: (_) => _,
+	_L: (_) => _,
+	_E: (_) => _,
+	_R: (_) => _
+};
+/** @internal */
+var SinkImpl = class {
+	channel;
+	[SinkTypeId] = sinkVariance;
+	constructor(channel) {
+		this.channel = channel;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const suspend$4 = (evaluate) => new SinkImpl(suspend$5(() => toChannel$2(evaluate())));
+/** @internal */
+const collectAllLoop = (acc) => readWithCause({
+	onInput: (chunk) => collectAllLoop(pipe(acc, appendAll(chunk))),
+	onFailure: failCause$4,
+	onDone: () => succeed$5(acc)
+});
+/** @internal */
+const collectAllNLoop = (n, acc) => readWithCause({
+	onInput: (chunk) => {
+		const [collected, leftovers] = splitAt$1(chunk, n);
+		if (collected.length < n) return collectAllNLoop(n - collected.length, appendAll(acc, collected));
+		if (isEmpty$8(leftovers)) return succeed$5(appendAll(acc, collected));
+		return flatMap$4(write(leftovers), () => succeed$5(appendAll(acc, collected)));
+	},
+	onFailure: failCause$4,
+	onDone: () => succeed$5(acc)
+});
+/** @internal */
+const fold = (s, contFn, f) => suspend$4(() => new SinkImpl(foldReader(s, contFn, f)));
+/** @internal */
+const foldReader = (s, contFn, f) => {
+	if (!contFn(s)) return succeedNow(s);
+	return readWith({
+		onInput: (input) => {
+			const [nextS, leftovers] = foldChunkSplit(s, input, contFn, f, 0, input.length);
+			if (isNonEmpty(leftovers)) return pipe(write(leftovers), as$4(nextS));
+			return foldReader(nextS, contFn, f);
+		},
+		onFailure: fail$5,
+		onDone: () => succeedNow(s)
+	});
+};
+/** @internal */
+const foldChunkSplit = (s, chunk, contFn, f, index, length) => {
+	if (index === length) return [s, empty$5()];
+	const s1 = f(s, pipe(chunk, unsafeGet$2(index)));
+	if (contFn(s1)) return foldChunkSplit(s1, chunk, contFn, f, index + 1, length);
+	return [s1, pipe(chunk, drop$2(index + 1))];
+};
+/** @internal */
+const foldChunksReader = (s, contFn, f) => {
+	if (!contFn(s)) return succeedNow(s);
+	return readWith({
+		onInput: (input) => foldChunksReader(f(s, input), contFn, f),
+		onFailure: fail$5,
+		onDone: () => succeedNow(s)
+	});
+};
+/** @internal */
+const foldEffectReader = (s, contFn, f) => {
+	if (!contFn(s)) return succeedNow(s);
+	return readWith({
+		onInput: (input) => pipe(fromEffect$4(foldChunkSplitEffect(s, input, contFn, f)), flatMap$4(([nextS, leftovers]) => pipe(leftovers, match$10({
+			onNone: () => foldEffectReader(nextS, contFn, f),
+			onSome: (leftover) => pipe(write(leftover), as$4(nextS))
+		})))),
+		onFailure: fail$5,
+		onDone: () => succeedNow(s)
+	});
+};
+/** @internal */
+const foldChunkSplitEffect = (s, chunk, contFn, f) => foldChunkSplitEffectInternal(s, chunk, 0, chunk.length, contFn, f);
+/** @internal */
+const foldChunkSplitEffectInternal = (s, chunk, index, length, contFn, f) => {
+	if (index === length) return succeed$10([s, none()]);
+	return pipe(f(s, pipe(chunk, unsafeGet$2(index))), flatMap$8((s1) => contFn(s1) ? foldChunkSplitEffectInternal(s1, chunk, index + 1, length, contFn, f) : succeed$10([s1, some$2(pipe(chunk, drop$2(index + 1)))])));
+};
+/** @internal */
+const forEachWhileReader = (f, input, index, length, cont) => {
+	if (index === length) return cont;
+	return pipe(fromEffect$4(f(pipe(input, unsafeGet$2(index)))), flatMap$4((bool) => bool ? forEachWhileReader(f, input, index + 1, length, cont) : write(pipe(input, drop$2(index)))), catchAll$3((error) => pipe(write(pipe(input, drop$2(index))), zipRight$5(fail$5(error)))));
+};
+/** @internal */
+const fromEffect$2 = (effect) => new SinkImpl(fromEffect$4(effect));
+/** @internal */
+const head = () => fold(none(), isNone, (option, input) => match$10(option, {
+	onNone: () => some$2(input),
+	onSome: () => option
+}));
+/** @internal */
+const toChannel$2 = (self) => isEffect(self) ? toChannel$2(fromEffect$2(self)) : self.channel;
+/**
+* @since 2.0.0
+* @category constructors
+*/
+const Done = Done$1;
+/**
+* @since 2.0.0
+* @category constructors
+*/
+const Await = Await$1;
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/opCodes/streamHaltStrategy.js
+/** @internal */
+const OP_LEFT = "Left";
+/** @internal */
+const OP_RIGHT = "Right";
+/** @internal */
+const OP_BOTH = "Both";
+/** @internal */
+const OP_EITHER = "Either";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stream/haltStrategy.js
+/** @internal */
+const Left$1 = { _tag: OP_LEFT };
+/** @internal */
+const Right$1 = { _tag: OP_RIGHT };
+/** @internal */
+const Both$1 = { _tag: OP_BOTH };
+/** @internal */
+const Either$1 = { _tag: OP_EITHER };
+/** @internal */
+const fromInput$1 = (input) => {
+	switch (input) {
+		case "left": return Left$1;
+		case "right": return Right$1;
+		case "both": return Both$1;
+		case "either": return Either$1;
+		default: return input;
+	}
+};
+/**
+* @since 2.0.0
+* @category constructors
+*/
+const Both = Both$1;
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/versioned.js
+/** @internal */
+var Versioned = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+/** @internal */
+const commit = (self) => {
+	self.ref.versioned = new Versioned(self.newValue);
+};
+/** @internal */
+const isInvalid = (self) => {
+	return self.ref.versioned !== self.expected;
+};
+/** @internal */
+const isChanged = (self) => {
+	return self.isChanged;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/journal.js
+/** @internal */
+const JournalAnalysisInvalid = "Invalid";
+/** @internal */
+const JournalAnalysisReadWrite = "ReadWrite";
+/** @internal */
+const JournalAnalysisReadOnly = "ReadOnly";
+/** @internal */
+const commitJournal = (journal) => {
+	for (const entry of journal) commit(entry[1]);
+};
+/**
+* Analyzes the journal, determining whether it is valid and whether it is
+* read only in a single pass. Note that information on whether the
+* journal is read only will only be accurate if the journal is valid, due
+* to short-circuiting that occurs on an invalid journal.
+*
+* @internal
+*/
+const analyzeJournal = (journal) => {
+	let val = JournalAnalysisReadOnly;
+	for (const [, entry] of journal) {
+		val = isInvalid(entry) ? JournalAnalysisInvalid : isChanged(entry) ? JournalAnalysisReadWrite : val;
+		if (val === "Invalid") return val;
+	}
+	return val;
+};
+/** @internal */
+const collectTodos = (journal) => {
+	const allTodos = /* @__PURE__ */ new Map();
+	for (const [, entry] of journal) {
+		for (const todo of entry.ref.todos) allTodos.set(todo[0], todo[1]);
+		entry.ref.todos = /* @__PURE__ */ new Map();
+	}
+	return allTodos;
+};
+/** @internal */
+const execTodos = (todos) => {
+	const todosSorted = Array.from(todos.entries()).sort((x, y) => x[0] - y[0]);
+	for (const [_, todo] of todosSorted) todo();
+};
+/** @internal */
+const addTodo = (txnId, journal, todoEffect) => {
+	let added = false;
+	for (const [, entry] of journal) if (!entry.ref.todos.has(txnId)) {
+		entry.ref.todos.set(txnId, todoEffect);
+		added = true;
+	}
+	return added;
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/opCodes/stm.js
+/** @internal */
+const OP_WITH_STM_RUNTIME = "WithSTMRuntime";
+/** @internal */
+const OP_ON_FAILURE = "OnFailure";
+/** @internal */
+const OP_ON_RETRY = "OnRetry";
+/** @internal */
+const OP_ON_SUCCESS = "OnSuccess";
+/** @internal */
+const OP_PROVIDE = "Provide";
+/** @internal */
+const OP_SYNC = "Sync";
+/** @internal */
+const OP_SUCCEED$1 = "Succeed";
+/** @internal */
+const OP_RETRY$1 = "Retry";
+/** @internal */
+const OP_FAIL$1 = "Fail";
+/** @internal */
+const OP_INTERRUPT$1 = "Interrupt";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/opCodes/tExit.js
+/** @internal */
+const OP_FAIL = "Fail";
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+/** @internal */
+const OP_SUCCEED = "Succeed";
+/** @internal */
+const OP_RETRY = "Retry";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/opCodes/tryCommit.js
+/** @internal */
+const OP_DONE$1 = "Done";
+/** @internal */
+const OP_SUSPEND = "Suspend";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/opCodes/stmState.js
+/** @internal */
+const OP_DONE = "Done";
+/** @internal */
+const OP_INTERRUPTED = "Interrupted";
+/** @internal */
+const OP_RUNNING = "Running";
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/stmState.js
+/** @internal */
+const STMStateSymbolKey = "effect/STM/State";
+/** @internal */
+const STMStateTypeId = /* @__PURE__ */ Symbol.for(STMStateSymbolKey);
+/** @internal */
+const isSTMState = (u) => hasProperty(u, STMStateTypeId);
+/** @internal */
+const isRunning = (self) => {
+	return self._tag === OP_RUNNING;
+};
+/** @internal */
+const isDone = (self) => {
+	return self._tag === OP_DONE;
+};
+/** @internal */
+const done$2 = (exit) => {
+	return {
+		[STMStateTypeId]: STMStateTypeId,
+		_tag: OP_DONE,
+		exit,
+		[symbol]() {
+			return pipe(hash(STMStateSymbolKey), combine$2(hash(OP_DONE)), combine$2(hash(exit)), cached(this));
+		},
+		[symbol$1](that) {
+			return isSTMState(that) && that._tag === "Done" && equals(exit, that.exit);
+		}
+	};
+};
+const interruptedHash = /* @__PURE__ */ pipe(/* @__PURE__ */ hash(STMStateSymbolKey), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash(OP_INTERRUPTED)), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash("interrupted")));
+/** @internal */
+const interrupted = {
+	[STMStateTypeId]: STMStateTypeId,
+	_tag: OP_INTERRUPTED,
+	[symbol]() {
+		return interruptedHash;
+	},
+	[symbol$1](that) {
+		return isSTMState(that) && that._tag === "Interrupted";
+	}
+};
+const runningHash = /* @__PURE__ */ pipe(/* @__PURE__ */ hash(STMStateSymbolKey), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash(OP_RUNNING)), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash("running")));
+/** @internal */
+const running = {
+	[STMStateTypeId]: STMStateTypeId,
+	_tag: OP_RUNNING,
+	[symbol]() {
+		return runningHash;
+	},
+	[symbol$1](that) {
+		return isSTMState(that) && that._tag === "Running";
+	}
+};
+/** @internal */
+const fromTExit = (tExit) => {
+	switch (tExit._tag) {
+		case OP_FAIL: return done$2(fail$9(tExit.error));
+		case "Die": return done$2(die$6(tExit.defect));
+		case OP_INTERRUPT: return done$2(interrupt$5(tExit.fiberId));
+		case OP_SUCCEED: return done$2(succeed$9(tExit.value));
+		case OP_RETRY: throw new Error("BUG: STM.STMState.fromTExit - please report an issue at https://github.com/Effect-TS/effect/issues");
+	}
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/tExit.js
+/** @internal */
+const TExitSymbolKey = "effect/TExit";
+/** @internal */
+const TExitTypeId = /* @__PURE__ */ Symbol.for(TExitSymbolKey);
+const variance = {
+	_A: (_) => _,
+	_E: (_) => _
+};
+/** @internal */
+const isExit = (u) => hasProperty(u, TExitTypeId);
+/** @internal */
+const isSuccess = (self) => {
+	return self._tag === OP_SUCCEED;
+};
+/** @internal */
+const isRetry = (self) => {
+	return self._tag === OP_RETRY;
+};
+/** @internal */
+const fail$3 = (error) => ({
+	[TExitTypeId]: variance,
+	_tag: OP_FAIL,
+	error,
+	[symbol]() {
+		return pipe(hash(TExitSymbolKey), combine$2(hash(OP_FAIL)), combine$2(hash(error)), cached(this));
+	},
+	[symbol$1](that) {
+		return isExit(that) && that._tag === "Fail" && equals(error, that.error);
+	}
+});
+/** @internal */
+const die$3 = (defect) => ({
+	[TExitTypeId]: variance,
+	_tag: "Die",
+	defect,
+	[symbol]() {
+		return pipe(hash(TExitSymbolKey), combine$2(hash("Die")), combine$2(hash(defect)), cached(this));
+	},
+	[symbol$1](that) {
+		return isExit(that) && that._tag === "Die" && equals(defect, that.defect);
+	}
+});
+/** @internal */
+const interrupt = (fiberId) => ({
+	[TExitTypeId]: variance,
+	_tag: OP_INTERRUPT,
+	fiberId,
+	[symbol]() {
+		return pipe(hash(TExitSymbolKey), combine$2(hash(OP_INTERRUPT)), combine$2(hash(fiberId)), cached(this));
+	},
+	[symbol$1](that) {
+		return isExit(that) && that._tag === "Interrupt" && equals(fiberId, that.fiberId);
+	}
+});
+/** @internal */
+const succeed$3 = (value) => ({
+	[TExitTypeId]: variance,
+	_tag: OP_SUCCEED,
+	value,
+	[symbol]() {
+		return pipe(hash(TExitSymbolKey), combine$2(hash(OP_SUCCEED)), combine$2(hash(value)), cached(this));
+	},
+	[symbol$1](that) {
+		return isExit(that) && that._tag === "Succeed" && equals(value, that.value);
+	}
+});
+const retryHash = /* @__PURE__ */ pipe(/* @__PURE__ */ hash(TExitSymbolKey), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash(OP_RETRY)), /* @__PURE__ */ combine$2(/* @__PURE__ */ hash("retry")));
+/** @internal */
+const retry$3 = {
+	[TExitTypeId]: variance,
+	_tag: OP_RETRY,
+	[symbol]() {
+		return retryHash;
+	},
+	[symbol$1](that) {
+		return isExit(that) && isRetry(that);
+	}
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/tryCommit.js
+/** @internal */
+const done$1 = (exit) => {
+	return {
+		_tag: OP_DONE$1,
+		exit
+	};
+};
+/** @internal */
+const suspend$3 = (journal) => {
+	return {
+		_tag: OP_SUSPEND,
+		journal
+	};
+};
+//#endregion
+//#region ../../node_modules/effect/dist/esm/internal/stm/txnId.js
+/** @internal */
+const txnCounter = { ref: 0 };
+/** @internal */
+const make$6 = () => {
+	const newId = txnCounter.ref + 1;
+	txnCounter.ref = newId;
+	return newId;
+};
+/** @internal */
+const STMTypeId = /* @__PURE__ */ Symbol.for("effect/STM");
+const stmVariance = {
+	_R: (_) => _,
+	_E: (_) => _,
+	_A: (_) => _
+};
+/** @internal */
+var STMPrimitive = class {
+	effect_instruction_i0;
+	_op = OP_COMMIT;
+	effect_instruction_i1 = void 0;
+	effect_instruction_i2 = void 0;
+	[EffectTypeId];
+	[StreamTypeId$2];
+	[SinkTypeId];
+	[ChannelTypeId];
+	get [STMTypeId]() {
+		return stmVariance;
+	}
+	constructor(effect_instruction_i0) {
+		this.effect_instruction_i0 = effect_instruction_i0;
+		this[EffectTypeId] = effectVariance;
+		this[StreamTypeId$2] = stmVariance;
+		this[SinkTypeId] = stmVariance;
+		this[ChannelTypeId] = stmVariance;
+	}
+	[symbol$1](that) {
+		return this === that;
+	}
+	[symbol]() {
+		return cached(this, random(this));
+	}
+	[Symbol.iterator]() {
+		return new SingleShotGen(new YieldWrap(this));
+	}
+	commit() {
+		return unsafeAtomically(this, constVoid, constVoid);
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const unsafeAtomically = (self, onDone, onInterrupt) => withFiberRuntime((state) => {
+	const fiberId = state.id();
+	const env = state.getFiberRef(currentContext);
+	const scheduler = state.getFiberRef(currentScheduler);
+	const priority = state.getFiberRef(currentSchedulingPriority);
+	const commitResult = tryCommitSync(fiberId, self, env, scheduler, priority);
+	switch (commitResult._tag) {
+		case OP_DONE$1:
+			onDone(commitResult.exit);
+			return commitResult.exit;
+		case OP_SUSPEND: {
+			const txnId = make$6();
+			const state = { value: running };
+			const effect = async((k) => tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k));
+			return uninterruptibleMask((restore) => pipe(restore(effect), catchAllCause$5((cause) => {
+				let currentState = state.value;
+				if (isRunning(currentState)) state.value = interrupted;
+				currentState = state.value;
+				if (isDone(currentState)) {
+					onDone(currentState.exit);
+					return currentState.exit;
+				}
+				onInterrupt();
+				return failCause$8(cause);
+			})));
+		}
+	}
+});
+/** @internal */
+const tryCommit = (fiberId, stm, state, env, scheduler, priority) => {
+	const journal = /* @__PURE__ */ new Map();
+	const tExit = new STMDriver(stm, journal, fiberId, env).run();
+	const analysis = analyzeJournal(journal);
+	if (analysis === "ReadWrite") commitJournal(journal);
+	else if (analysis === "Invalid") throw new Error("BUG: STM.TryCommit.tryCommit - please report an issue at https://github.com/Effect-TS/effect/issues");
+	switch (tExit._tag) {
+		case OP_SUCCEED:
+			state.value = fromTExit(tExit);
+			return completeTodos(succeed$9(tExit.value), journal, scheduler, priority);
+		case OP_FAIL:
+			state.value = fromTExit(tExit);
+			return completeTodos(failCause$7(fail$8(tExit.error)), journal, scheduler, priority);
+		case "Die":
+			state.value = fromTExit(tExit);
+			return completeTodos(failCause$7(die$7(tExit.defect)), journal, scheduler, priority);
+		case OP_INTERRUPT:
+			state.value = fromTExit(tExit);
+			return completeTodos(failCause$7(interrupt$3(fiberId)), journal, scheduler, priority);
+		case OP_RETRY: return suspend$3(journal);
+	}
+};
+/** @internal */
+const tryCommitSync = (fiberId, stm, env, scheduler, priority) => {
+	const journal = /* @__PURE__ */ new Map();
+	const tExit = new STMDriver(stm, journal, fiberId, env).run();
+	const analysis = analyzeJournal(journal);
+	if (analysis === "ReadWrite" && isSuccess(tExit)) commitJournal(journal);
+	else if (analysis === "Invalid") throw new Error("BUG: STM.TryCommit.tryCommitSync - please report an issue at https://github.com/Effect-TS/effect/issues");
+	switch (tExit._tag) {
+		case OP_SUCCEED: return completeTodos(succeed$9(tExit.value), journal, scheduler, priority);
+		case OP_FAIL: return completeTodos(failCause$7(fail$8(tExit.error)), journal, scheduler, priority);
+		case "Die": return completeTodos(failCause$7(die$7(tExit.defect)), journal, scheduler, priority);
+		case OP_INTERRUPT: return completeTodos(failCause$7(interrupt$3(fiberId)), journal, scheduler, priority);
+		case OP_RETRY: return suspend$3(journal);
+	}
+};
+/** @internal */
+const tryCommitAsync = (fiberId, self, txnId, state, context, scheduler, priority, k) => {
+	if (isRunning(state.value)) {
+		const result = tryCommit(fiberId, self, state, context, scheduler, priority);
+		switch (result._tag) {
+			case OP_DONE$1:
+				completeTryCommit(result.exit, k);
+				break;
+			case OP_SUSPEND:
+				addTodo(txnId, result.journal, () => tryCommitAsync(fiberId, self, txnId, state, context, scheduler, priority, k));
+				break;
+		}
+	}
+};
+/** @internal */
+const completeTodos = (exit, journal, scheduler, priority) => {
+	const todos = collectTodos(journal);
+	if (todos.size > 0) scheduler.scheduleTask(() => execTodos(todos), priority);
+	return done$1(exit);
+};
+/** @internal */
+const completeTryCommit = (exit, k) => {
+	k(exit);
+};
+/** @internal */
+var STMDriver = class {
+	self;
+	journal;
+	fiberId;
+	contStack = [];
+	env;
+	constructor(self, journal, fiberId, r0) {
+		this.self = self;
+		this.journal = journal;
+		this.fiberId = fiberId;
+		this.env = r0;
+	}
+	getEnv() {
+		return this.env;
+	}
+	pushStack(cont) {
+		this.contStack.push(cont);
+	}
+	popStack() {
+		return this.contStack.pop();
+	}
+	nextSuccess() {
+		let current = this.popStack();
+		while (current !== void 0 && current.effect_instruction_i0 !== "OnSuccess") current = this.popStack();
+		return current;
+	}
+	nextFailure() {
+		let current = this.popStack();
+		while (current !== void 0 && current.effect_instruction_i0 !== "OnFailure") current = this.popStack();
+		return current;
+	}
+	nextRetry() {
+		let current = this.popStack();
+		while (current !== void 0 && current.effect_instruction_i0 !== "OnRetry") current = this.popStack();
+		return current;
+	}
+	run() {
+		let curr = this.self;
+		let exit = void 0;
+		while (exit === void 0 && curr !== void 0) try {
+			const current = curr;
+			if (current) switch (current._op) {
+				case "Tag":
+					curr = effect((_, __, env) => unsafeGet$3(env, current));
+					break;
+				case "Left":
+					curr = fail$2(current.left);
+					break;
+				case "None":
+					curr = fail$2(new NoSuchElementException());
+					break;
+				case "Right":
+					curr = succeed$2(current.right);
+					break;
+				case "Some":
+					curr = succeed$2(current.value);
+					break;
+				case "Commit":
+					switch (current.effect_instruction_i0) {
+						case "Die":
+							exit = die$3(internalCall(() => current.effect_instruction_i1()));
+							break;
+						case OP_FAIL$1: {
+							const cont = this.nextFailure();
+							if (cont === void 0) exit = fail$3(internalCall(() => current.effect_instruction_i1()));
+							else curr = internalCall(() => cont.effect_instruction_i2(internalCall(() => current.effect_instruction_i1())));
+							break;
+						}
+						case OP_RETRY$1: {
+							const cont = this.nextRetry();
+							if (cont === void 0) exit = retry$3;
+							else curr = internalCall(() => cont.effect_instruction_i2());
+							break;
+						}
+						case OP_INTERRUPT$1:
+							exit = interrupt(this.fiberId);
+							break;
+						case OP_WITH_STM_RUNTIME:
+							curr = internalCall(() => current.effect_instruction_i1(this));
+							break;
+						case OP_ON_SUCCESS:
+						case OP_ON_FAILURE:
+						case OP_ON_RETRY:
+							this.pushStack(current);
+							curr = current.effect_instruction_i1;
+							break;
+						case OP_PROVIDE: {
+							const env = this.env;
+							this.env = internalCall(() => current.effect_instruction_i2(env));
+							curr = pipe(current.effect_instruction_i1, ensuring$2(sync$2(() => this.env = env)));
+							break;
+						}
+						case OP_SUCCEED$1: {
+							const value = current.effect_instruction_i1;
+							const cont = this.nextSuccess();
+							if (cont === void 0) exit = succeed$3(value);
+							else curr = internalCall(() => cont.effect_instruction_i2(value));
+							break;
+						}
+						case OP_SYNC: {
+							const value = internalCall(() => current.effect_instruction_i1());
+							const cont = this.nextSuccess();
+							if (cont === void 0) exit = succeed$3(value);
+							else curr = internalCall(() => cont.effect_instruction_i2(value));
+							break;
+						}
+					}
+					break;
+			}
+		} catch (e) {
+			curr = die$2(e);
+		}
+		return exit;
+	}
+};
+/** @internal */
+const catchAll$2 = /* @__PURE__ */ dual(2, (self, f) => {
+	const stm = new STMPrimitive(OP_ON_FAILURE);
+	stm.effect_instruction_i1 = self;
+	stm.effect_instruction_i2 = f;
+	return stm;
+});
+/** @internal */
+const die$2 = (defect) => dieSync$2(() => defect);
+/** @internal */
+const dieSync$2 = (evaluate) => {
+	const stm = new STMPrimitive("Die");
+	stm.effect_instruction_i1 = evaluate;
+	return stm;
+};
+/** @internal */
+const effect = (f) => withSTMRuntime((_) => succeed$2(f(_.journal, _.fiberId, _.getEnv())));
+/** @internal */
+const ensuring$2 = /* @__PURE__ */ dual(2, (self, finalizer) => matchSTM(self, {
+	onFailure: (e) => zipRight$2(finalizer, fail$2(e)),
+	onSuccess: (a) => zipRight$2(finalizer, succeed$2(a))
+}));
+/** @internal */
+const fail$2 = (error) => failSync$2(() => error);
+/** @internal */
+const failSync$2 = (evaluate) => {
+	const stm = new STMPrimitive(OP_FAIL$1);
+	stm.effect_instruction_i1 = evaluate;
+	return stm;
+};
+/** @internal */
+const flatMap$2 = /* @__PURE__ */ dual(2, (self, f) => {
+	const stm = new STMPrimitive(OP_ON_SUCCESS);
+	stm.effect_instruction_i1 = self;
+	stm.effect_instruction_i2 = f;
+	return stm;
+});
+/** @internal */
+const matchSTM = /* @__PURE__ */ dual(2, (self, { onFailure, onSuccess }) => pipe(self, map$3(right), catchAll$2((e) => pipe(onFailure(e), map$3(left))), flatMap$2((either) => {
+	switch (either._tag) {
+		case "Left": return succeed$2(either.left);
+		case "Right": return onSuccess(either.right);
+	}
+})));
+/** @internal */
+const withSTMRuntime = (f) => {
+	const stm = new STMPrimitive(OP_WITH_STM_RUNTIME);
+	stm.effect_instruction_i1 = f;
+	return stm;
+};
+/** @internal */
+const map$3 = /* @__PURE__ */ dual(2, (self, f) => pipe(self, flatMap$2((a) => sync$2(() => f(a)))));
+/** @internal */
+const succeed$2 = (value) => {
+	const stm = new STMPrimitive(OP_SUCCEED$1);
+	stm.effect_instruction_i1 = value;
+	return stm;
+};
+/** @internal */
+const sync$2 = (evaluate) => {
+	const stm = new STMPrimitive(OP_SYNC);
+	stm.effect_instruction_i1 = evaluate;
+	return stm;
+};
+/** @internal */
+const zipRight$2 = /* @__PURE__ */ dual(2, (self, that) => pipe(self, flatMap$2(() => that)));
+const seekLoop = (self, predicate) => flatMap$2(self.take, (a) => predicate(a) ? succeed$2(a) : seekLoop(self, predicate));
+/** @internal */
+const OP_HANDOFF_STATE_EMPTY = "Empty";
+/** @internal */
+const OP_HANDOFF_STATE_FULL = "Full";
+/** @internal */
+const handoffStateEmpty = (notifyConsumer) => ({
+	_tag: OP_HANDOFF_STATE_EMPTY,
+	notifyConsumer
+});
+/** @internal */
+const handoffStateFull = (value, notifyProducer) => ({
+	_tag: OP_HANDOFF_STATE_FULL,
+	value,
+	notifyProducer
+});
+/** @internal */
+const handoffStateMatch = (onEmpty, onFull) => {
+	return (self) => {
+		switch (self._tag) {
+			case OP_HANDOFF_STATE_EMPTY: return onEmpty(self.notifyConsumer);
+			case OP_HANDOFF_STATE_FULL: return onFull(self.value, self.notifyProducer);
+		}
+	};
+};
+/** @internal */
+const offer = /* @__PURE__ */ dual(2, (self, value) => {
+	return flatMap$8(make$17(), (deferred) => flatten$6(modify$1(self.ref, (state) => pipe(state, handoffStateMatch((notifyConsumer) => [zipRight$8(succeed$11(notifyConsumer, void 0), _await(deferred)), handoffStateFull(value, deferred)], (_, notifyProducer) => [flatMap$8(_await(notifyProducer), () => pipe(self, offer(value))), state])))));
+});
+/** @internal */
+const take$3 = (self) => flatMap$8(make$17(), (deferred) => flatten$6(modify$1(self.ref, (state) => pipe(state, handoffStateMatch((notifyConsumer) => [flatMap$8(_await(notifyConsumer), () => take$3(self)), state], (value, notifyProducer) => [as$5(succeed$11(notifyProducer, void 0), value), handoffStateEmpty(deferred)])))));
+/** @internal */
+const StreamTypeId$1 = /* @__PURE__ */ Symbol.for("effect/Stream");
+/** @internal */
+const streamVariance = {
+	_R: (_) => _,
+	_E: (_) => _,
+	_A: (_) => _
+};
+/** @internal */
+var StreamImpl = class {
+	channel;
+	[StreamTypeId$1] = streamVariance;
+	constructor(channel) {
+		this.channel = channel;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const isStream = (u) => hasProperty(u, StreamTypeId$1) || isEffect(u);
+/** @internal */
+const concat$2 = /* @__PURE__ */ dual(2, (self, that) => new StreamImpl(pipe(toChannel$1(self), zipRight$5(toChannel$1(that)))));
+/** @internal */
+const empty$1 = /* @__PURE__ */ new StreamImpl(void_$3);
+/** @internal */
+const find$1 = /* @__PURE__ */ dual(2, (self, predicate) => {
+	const loop = readWith({
+		onInput: (input) => match$10(findFirst(input, predicate), {
+			onNone: () => loop,
+			onSome: (n) => write(of$2(n))
+		}),
+		onFailure: fail$5,
+		onDone: () => void_$3
+	});
+	return new StreamImpl(pipe(toChannel$1(self), pipeTo(loop)));
+});
+/** @internal */
+const flatMap$1 = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, f, options) => {
+	const bufferSize = options?.bufferSize ?? 16;
+	if (options?.switch) return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), (n) => flatMapParSwitchBuffer(self, n, bufferSize, f));
+	return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap$1(toChannel$1(self), (as) => pipe(as, map$13((a) => toChannel$1(f(a))), reduce$2(void_$3, (left, right) => pipe(left, zipRight$5(right)))))), (_) => new StreamImpl(pipe(toChannel$1(self), concatMap$1(writeChunk), mergeMap$1((out) => toChannel$1(f(out)), options))));
+});
+/** @internal */
+const matchConcurrency = (concurrency, sequential, bounded) => {
+	switch (concurrency) {
+		case void 0: return sequential();
+		case "unbounded": return bounded(Number.MAX_SAFE_INTEGER);
+		default: return concurrency > 1 ? bounded(concurrency) : sequential();
+	}
+};
+const flatMapParSwitchBuffer = /* @__PURE__ */ dual(4, (self, n, bufferSize, f) => new StreamImpl(pipe(toChannel$1(self), concatMap$1(writeChunk), mergeMap$1((out) => toChannel$1(f(out)), {
+	concurrency: n,
+	mergeStrategy: BufferSliding(),
+	bufferSize
+}))));
+/** @internal */
+const flatten$1 = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => flatMap$1(self, identity$2, options));
+/** @internal */
+const toChannel$1 = (stream) => {
+	if ("channel" in stream) return stream.channel;
+	else if (isEffect(stream)) return toChannel$1(fromEffect$1(stream));
+	else throw new TypeError(`Expected a Stream.`);
+};
+/** @internal */
+const fromChunk$1 = (chunk) => new StreamImpl(isEmpty$8(chunk) ? void_$3 : write(chunk));
+/** @internal */
+const fromEffect$1 = (effect) => pipe(effect, mapError$5(some$2), fromEffectOption$1);
+/** @internal */
+const fromEffectOption$1 = (effect) => new StreamImpl(unwrap$2(match$11(effect, {
+	onFailure: match$10({
+		onNone: () => void_$3,
+		onSome: fail$5
+	}),
+	onSuccess: (a) => write(of$2(a))
+})));
+/** @internal */
+const fromPull$1 = (effect) => pipe(effect, map$10(repeatEffectChunkOption$1), unwrapScoped$1);
+/** @internal */
+const map$2 = /* @__PURE__ */ dual(2, (self, f) => new StreamImpl(pipe(toChannel$1(self), mapOut(map$13(f)))));
+/** @internal */
+const mapEffectSequential = /* @__PURE__ */ dual(2, (self, f) => {
+	const loop = (iterator) => {
+		const next = iterator.next();
+		if (next.done) return readWithCause({
+			onInput: (elem) => loop(elem[Symbol.iterator]()),
+			onFailure: failCause$4,
+			onDone: succeed$5
+		});
+		else {
+			const value = next.value;
+			return unwrap$2(map$10(f(value), (a2) => flatMap$4(write(of$2(a2)), () => loop(iterator))));
+		}
+	};
+	return new StreamImpl(pipe(toChannel$1(self), pipeTo(suspend$5(() => loop(empty$5()[Symbol.iterator]())))));
+});
+/** @internal */
+const mergeEither$1 = /* @__PURE__ */ dual(2, (self, that) => mergeWith$1(self, that, {
+	onSelf: left,
+	onOther: right
+}));
+/** @internal */
+const mergeWith$1 = /* @__PURE__ */ dual(3, (self, other, options) => {
+	const strategy = options.haltStrategy ? fromInput$1(options.haltStrategy) : Both;
+	const handler = (terminate) => (exit) => terminate || !isSuccess$1(exit) ? Done(suspend$9(() => exit)) : Await((exit) => suspend$9(() => exit));
+	return new StreamImpl(mergeWith$2(toChannel$1(map$2(self, options.onSelf)), {
+		other: toChannel$1(map$2(other, options.onOther)),
+		onSelfDone: handler(strategy._tag === "Either" || strategy._tag === "Left"),
+		onOtherDone: handler(strategy._tag === "Either" || strategy._tag === "Right")
+	}));
+});
+/** @internal */
+const rechunkProcess = (rechunker, target) => readWithCause({
+	onInput: (chunk) => {
+		if (chunk.length === target && rechunker.isEmpty()) return flatMap$4(write(chunk), () => rechunkProcess(rechunker, target));
+		if (chunk.length > 0) {
+			const chunks = [];
+			let result = void 0;
+			let index = 0;
+			while (index < chunk.length) {
+				while (index < chunk.length && result === void 0) {
+					result = rechunker.write(pipe(chunk, unsafeGet$2(index)));
+					index = index + 1;
+				}
+				if (result !== void 0) {
+					chunks.push(result);
+					result = void 0;
+				}
+			}
+			return flatMap$4(writeAll(...chunks), () => rechunkProcess(rechunker, target));
+		}
+		return suspend$5(() => rechunkProcess(rechunker, target));
+	},
+	onFailure: (cause) => zipRight$5(rechunker.emitIfNotEmpty(), failCause$4(cause)),
+	onDone: () => rechunker.emitIfNotEmpty()
+});
+/** @internal */
+const repeatEffectChunkOption$1 = (effect) => unfoldChunkEffect$1(effect, (effect) => pipe(map$10(effect, (chunk) => some$2([chunk, effect])), catchAll$7(match$10({
+	onNone: () => succeed$10(none()),
+	onSome: fail$10
+}))));
+/** @internal */
+const repeatEffectOption$1 = (effect) => repeatEffectChunkOption$1(pipe(effect, map$10(of$2)));
+/** @internal */
+const run$1 = /* @__PURE__ */ dual(2, (self, sink) => toChannel$1(self).pipe(pipeToOrFail(toChannel$2(sink)), runDrain$2));
+/** @internal */
+const runHead$1 = (self) => run$1(self, head());
+/** @internal */
+const scoped$1 = (effect) => new StreamImpl(ensuring$4(scoped$2(pipe(effect, map$10(of$2))), _void));
+/** @internal */
+const suspend$1 = (stream) => new StreamImpl(suspend$5(() => toChannel$1(stream())));
+/** @internal */
+const tap$2 = /* @__PURE__ */ dual(2, (self, f) => mapEffectSequential(self, (a) => as$5(f(a), a)));
+/** @internal */
+const toPull$1 = (self) => map$10(toPull$2(toChannel$1(self)), (pull) => pipe(pull, mapError$5(some$2), flatMap$8(match$8({
+	onLeft: () => fail$10(none()),
+	onRight: succeed$10
+}))));
+/** @internal */
+const unfoldChunkEffect$1 = (s, f) => suspend$1(() => {
+	const loop = (s) => unwrap$2(map$10(f(s), match$10({
+		onNone: () => void_$3,
+		onSome: ([chunk, s]) => flatMap$4(write(chunk), () => loop(s))
+	})));
+	return new StreamImpl(loop(s));
+});
+/** @internal */
+const unwrapScoped$1 = (effect) => flatten$1(scoped$1(effect));
+const zipLatestAll$1 = (...streams) => {
+	if (streams.length === 0) return empty$1;
+	else if (streams.length === 1) return map$2(streams[0], (x) => [x]);
+	const [head, ...tail] = streams;
+	return zipLatestWith$1(head, zipLatestAll$1(...tail), (first, second) => [first, ...second]);
+};
+/** @internal */
+const zipLatestWith$1 = /* @__PURE__ */ dual(3, (left, right, f) => {
+	const pullNonEmpty = (pull) => pipe(pull, flatMap$8((chunk) => isEmpty$8(chunk) ? pullNonEmpty(pull) : succeed$10(chunk)));
+	return pipe(toPull$1(left), map$10(pullNonEmpty), zip$4(pipe(toPull$1(right), map$10(pullNonEmpty))), flatMap$8(([left, right]) => pipe(fromEffectOption$1(raceWith$1(left, right, {
+		onSelfDone: (leftDone, rightFiber) => pipe(suspend$9(() => leftDone), zipWith$7(join(rightFiber), (l, r) => [
+			l,
+			r,
+			true
+		])),
+		onOtherDone: (rightDone, leftFiber) => pipe(suspend$9(() => rightDone), zipWith$7(join(leftFiber), (l, r) => [
+			r,
+			l,
+			false
+		]))
+	})), flatMap$1(([l, r, leftFirst]) => pipe(fromEffect$1(make$18([unsafeLast(l), unsafeLast(r)])), flatMap$1((latest) => pipe(fromChunk$1(leftFirst ? pipe(r, map$13((a2) => f(unsafeLast(l), a2))) : pipe(l, map$13((a) => f(a, unsafeLast(r))))), concat$2(pipe(repeatEffectOption$1(left), mergeEither$1(repeatEffectOption$1(right)), mapEffectSequential(match$8({
+		onLeft: (leftChunk) => modify$1(latest, ([_, rightLatest]) => [pipe(leftChunk, map$13((a) => f(a, rightLatest))), [unsafeLast(leftChunk), rightLatest]]),
+		onRight: (rightChunk) => modify$1(latest, ([leftLatest, _]) => [pipe(rightChunk, map$13((a2) => f(leftLatest, a2))), [leftLatest, unsafeLast(rightChunk)]])
+	})), flatMap$1(fromChunk$1))))))), toPull$1)), fromPull$1);
+});
+/**
+* Finds the first element emitted by this stream that satisfies the provided
+* predicate.
+*
+* @since 2.0.0
+* @category elements
+*/
+const find = find$1;
+/**
+* Runs the stream to completion and yields the first value emitted by it,
+* discarding the rest of the elements.
+*
+* @since 2.0.0
+* @category destructors
+*/
+const runHead = runHead$1;
+/**
+* Adds an effect to consumption of every element of the stream.
+*
+* @example
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const stream = Stream.make(1, 2, 3).pipe(
+*   Stream.tap((n) => Console.log(`before mapping: ${n}`)),
+*   Stream.map((n) => n * 2),
+*   Stream.tap((n) => Console.log(`after mapping: ${n}`))
+* )
+*
+* Effect.runPromise(Stream.runCollect(stream)).then(console.log)
+* // before mapping: 1
+* // after mapping: 2
+* // before mapping: 2
+* // after mapping: 4
+* // before mapping: 3
+* // after mapping: 6
+* // { _id: 'Chunk', values: [ 2, 4, 6 ] }
+* ```
+*
+* @since 2.0.0
+* @category sequencing
+*/
+const tap$1 = tap$2;
+//#endregion
+//#region ../../packages/lib/vendor/src/midnight-facade-reservations.ts
+const NO_BALANCING_TRANSACTION = "No balancing transaction was created. Please check your transaction.";
+const releasingOnFailure = async (build) => {
+	const releases = [];
+	const reserve = (transaction, holder) => {
+		if (transaction) releases.push(async () => holder.revertTransaction(transaction));
+		return transaction;
+	};
+	try {
+		return await build(reserve);
+	} catch (error) {
+		await Promise.allSettled(releases.map(async (release) => release()));
+		throw error;
+	}
+};
+const merge$1 = (first, second) => first && second ? first.merge(second) : first ?? second;
+const kindsToBalance = (tokenKindsToBalance = "all") => {
+	const kinds = tokenKindsToBalance === "all" ? [
+		"shielded",
+		"unshielded",
+		"dust"
+	] : tokenKindsToBalance;
+	return {
+		dust: kinds.includes("dust"),
+		shielded: kinds.includes("shielded"),
+		unshielded: kinds.includes("unshielded")
+	};
+};
+/**
+* The wallet SDK's multi-step builds over `facade`, releasing the coins the
+* completed steps reserved when a later step fails. The wallet SDK keeps
+* them, and its caller gets an error with no recipe to release. Each build
+* takes the same steps over the same sub-wallets as its `WalletFacade`
+* namesake and returns the same recipe.
+*/
+const withReservationRelease = (facade) => ({
+	balanceFinalizedTransaction: async (transaction, { shieldedSecretKeys, dustSecretKey }, { ttl, tokenKindsToBalance }) => releasingOnFailure(async (reserve) => {
+		const balance = kindsToBalance(tokenKindsToBalance);
+		const unshieldedBalancing = balance.unshielded ? reserve(await facade.unshielded.balanceFinalizedTransaction(transaction), facade.unshielded) : void 0;
+		const tokenBalancing = merge$1(balance.shielded ? reserve(await facade.shielded.balanceTransaction(shieldedSecretKeys, transaction), facade.shielded) : void 0, unshieldedBalancing);
+		const balancingTransaction = merge$1(tokenBalancing, balance.dust ? await facade.dust.balanceTransactions(dustSecretKey, tokenBalancing ? [transaction, tokenBalancing] : [transaction], ttl) : void 0);
+		if (!balancingTransaction) throw new Error(NO_BALANCING_TRANSACTION);
+		return {
+			type: "FINALIZED_TRANSACTION",
+			originalTransaction: transaction,
+			balancingTransaction
+		};
+	}),
+	balanceUnboundTransaction: async (transaction, { shieldedSecretKeys, dustSecretKey }, { ttl, tokenKindsToBalance }) => releasingOnFailure(async (reserve) => {
+		const balance = kindsToBalance(tokenKindsToBalance);
+		const shieldedBalancing = balance.shielded ? reserve(await facade.shielded.balanceTransaction(shieldedSecretKeys, transaction), facade.shielded) : void 0;
+		const balancedUnshielded = balance.unshielded ? await facade.unshielded.balanceUnboundTransaction(transaction) : void 0;
+		const baseTransaction = balancedUnshielded ?? transaction;
+		const balancingTransaction = merge$1(shieldedBalancing, balance.dust ? await facade.dust.balanceTransactions(dustSecretKey, shieldedBalancing ? [baseTransaction, shieldedBalancing] : [baseTransaction], ttl) : void 0);
+		if (!balancingTransaction && !balancedUnshielded) throw new Error(NO_BALANCING_TRANSACTION);
+		return {
+			type: "UNBOUND_TRANSACTION",
+			baseTransaction,
+			balancingTransaction: balancingTransaction ?? void 0
+		};
+	}),
+	transferTransaction: async (outputs, { shieldedSecretKeys, dustSecretKey }, { ttl, payFees = true }) => releasingOnFailure(async (reserve) => {
+		const shieldedOutputs = outputs.flatMap((output) => output.type === "shielded" ? output.outputs : []);
+		const unshieldedOutputs = outputs.flatMap((output) => output.type === "unshielded" ? output.outputs : []);
+		if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) throw new Error("At least one shielded or unshielded output is required.");
+		const transfer = merge$1(shieldedOutputs.length > 0 ? reserve(await facade.shielded.transferTransaction(shieldedSecretKeys, shieldedOutputs), facade.shielded) : void 0, unshieldedOutputs.length > 0 ? reserve(await facade.unshielded.transferTransaction(unshieldedOutputs, ttl), facade.unshielded) : void 0);
+		if (!transfer) throw new Error("Unexpected transaction state.");
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: merge$1(transfer, payFees ? await facade.dust.balanceTransactions(dustSecretKey, [transfer], ttl) : void 0) ?? transfer
+		};
+	}),
+	initSwap: async ({ desiredInputs, desiredOutputs }, { shieldedSecretKeys, dustSecretKey }, { ttl, payFees = false }) => releasingOnFailure(async (reserve) => {
+		const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
+		const shieldedOutputs = desiredOutputs.flatMap((output) => output.type === "shielded" ? output.outputs : []);
+		const unshieldedOutputs = desiredOutputs.flatMap((output) => output.type === "unshielded" ? output.outputs : []);
+		const hasShieldedPart = !!shieldedInputs && Object.keys(shieldedInputs).length > 0 || shieldedOutputs.length > 0;
+		const hasUnshieldedPart = !!unshieldedInputs && Object.keys(unshieldedInputs).length > 0 || unshieldedOutputs.length > 0;
+		if (!hasShieldedPart && !hasUnshieldedPart) throw new Error("At least one shielded or unshielded swap is required.");
+		const swap = merge$1(hasShieldedPart && shieldedInputs !== void 0 ? reserve(await facade.shielded.initSwap(shieldedSecretKeys, shieldedInputs, shieldedOutputs), facade.shielded) : void 0, hasUnshieldedPart && unshieldedInputs !== void 0 ? reserve(await facade.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl), facade.unshielded) : void 0);
+		if (!swap) throw new Error("Unexpected transaction state.");
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: merge$1(swap, payFees ? await facade.dust.balanceTransactions(dustSecretKey, [swap], ttl) : void 0) ?? swap
+		};
+	})
+});
+//#endregion
+//#region ../../packages/lib/vendor/src/midnight-submission-service.ts
+const observers = /* @__PURE__ */ new WeakMap();
+const awaitDisconnection = (client) => async((resume) => {
+	if (!client.api.isConnected) {
+		resume(_void);
+		return;
+	}
+	const disconnected = () => {
+		resume(_void);
+	};
+	client.api.once("disconnected", disconnected);
+	return sync$8(() => client.api.off("disconnected", disconnected));
+});
+/** Preserve facade submission/rollback semantics while observing its single stream. */
+const createProgressSubmissionService = ({ relayURL }) => {
+	const scope = runSync$1(make$19());
+	const submissions = runSync$1(makeSemaphore(1));
+	const connection = PolkadotNodeClient.make({ nodeURL: relayURL }).pipe(provideService$6(Scope, scope), tap$7(awaitDisconnection), cached$1, runSync$1);
+	const submit = async (tx, waitFor = "InBlock") => {
+		const serialized = SerializedTransaction.from(tx);
+		return connection.pipe(flatMap$8((client) => client.sendMidnightTransaction(serialized).pipe(tap$1((event) => sync$8(() => observers.get(tx)?.(event._tag))), find((event) => event._tag === waitFor), runHead, flatMap$8(match$10({
+			onSome: succeed$10,
+			onNone: () => fail$10(new NodeClientError.TransactionProgressError({
+				message: "Transaction did not reach desired stage",
+				txData: serialized,
+				desiredStage: waitFor
+			}))
+		})), ensuring$5(awaitDisconnection(client)))), submissions.withPermits(1), mapError$5((cause) => new SubmissionError({
+			message: "Transaction submission error",
+			cause
+		})), runPromise$1);
+	};
+	return {
+		submitTransaction: submit,
+		close: async () => close(scope, void_$5).pipe(ignoreLogged, runPromise$1)
+	};
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/compute-sync-ratio.ts
+const computeConnectedSyncRatio = (applied, highest, isConnected) => isConnected && applied === 0n && highest === 0n ? Percent(1) : computeSyncRatio(applied, highest);
+const computeSyncRatio = (applied, highest) => {
+	if (highest === 0n) {
+		if (applied === 0n) return Percent(0);
+		const ratio = 1 - 1 / (1 + Number(applied) / 1e3);
+		return Percent(Math.min(.99, ratio));
+	}
+	return Percent(Math.min(1, Number(applied) / Number(highest)));
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/dependencies.ts
+/**
+* Wraps keyManager.keys$ with recovery for AuthenticationCancelledError.
+* If the user cancels the auth prompt, waits for keys to become available
+* from another source (e.g., an unlock triggered by a different flow)
+* and retries.
+*/
+const keysWithAuthCancelledRecovery$ = (keyManager) => keyManager.keys$.pipe(take(1), catchError((error) => {
+	if (!(error instanceof AuthenticationCancelledError)) return throwError(() => error);
+	return keyManager.areKeysAvailable$.pipe(filter((available) => available), take(1), switchMap(() => keyManager.keys$.pipe(take(1))));
+}));
+const STATE_SERIALISATION_THROTTLE_TIME = Milliseconds(5e3);
+const DEFAULT_BATCH_UPDATES = {
+	size: 12,
+	spacing: 4
+};
+/**
+* Restore accepts the legacy `unshieldedTxHistory` key so profiles written
+* before the persisted key was renamed load without a resync; the next persist
+* rewrites the doc under `txHistory`, migrating it lazily.
+*/
+const readPersistedTxHistory = (serializedState) => serializedState.txHistory ?? serializedState.unshieldedTxHistory;
+/**
+* djb2 over the serialized states. The previous-persist comparator must not
+* RETAIN the inputs: keeping the raw serialized strings would pin ~10MB per
+* synced wallet in service worker memory between persist cycles.
+*/
+const fingerprintOf = (parts) => {
+	let hash = 5381;
+	for (const part of parts) for (let index = 0; index < part.length; index += 1) {
+		hash = hash * 33 ^ part.charCodeAt(index);
+		hash |= 0;
+	}
+	return `${hash}:${parts.map((part) => part.length).join(":")}`;
+};
+const getAccountWalletInstance = async ({ account, config, getTemenosLedgerIndexerUrl, store, keyManager }, logger, { createAttestedProver, createLocalProofServerAccess, batchUpdates = DEFAULT_BATCH_UPDATES }) => {
+	const walletState = await firstValueFrom(store.get(String(account.accountId)).pipe(defaultIfEmpty(void 0)));
+	const indexerClientConnection = {
+		indexerHttpUrl: config.indexerAddress,
+		indexerWsUrl: convertHttpUrlToWebsocket(config.indexerAddress),
+		keepAlive: 15e3
+	};
+	const { networkId } = account.blockchainSpecific;
+	const proofServerUrl = getProofServerEndpoint(config.proofServer);
+	if (!proofServerUrl && config.proofServer.kind !== "in-process") throw new Error(`Cannot start Midnight wallet: proof server mode "${config.proofServer.kind}" has no HTTP endpoint`);
+	assertProofServerRouting(config.proofServer, !!createAttestedProver, !!createLocalProofServerAccess);
+	const createAccess = (onProgress) => config.proofServer.kind === "in-process" && createLocalProofServerAccess ? createLocalProofServerAccess(onProgress) : config.proofServer.kind === "tee-delegated" && createAttestedProver ? createAttestedProofServerAccess(createAttestedProver({
+		networkId,
+		proofServerApiUrl: config.proofServer.url,
+		getLedgerIndexerUrl: async () => {
+			if (!getTemenosLedgerIndexerUrl) throw new Error("Temenos attestation requires a ledger indexer resolver");
+			return getTemenosLedgerIndexerUrl();
+		}
+	}), onProgress) : createProofServerAccess(createHttpProofServerTransport(proofServerUrl));
+	const proofServer = createScopedProofServerAccess(createAccess);
+	const { finalizeRecipe } = proofServer;
+	const configuration = {
+		costParameters: {
+			additionalFeeOverhead: 300000000000000n,
+			feeBlocksMargin: 5
+		},
+		networkId,
+		batchUpdates,
+		indexerClientConnection,
+		relayURL: new URL(convertHttpUrlToWebsocket(config.nodeAddress)),
+		txHistoryStorage: new InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries)
+	};
+	if (walletState) {
+		const { dust, shielded, unshielded } = walletState.serializedState;
+		let restoredTxHistoryStorage;
+		try {
+			restoredTxHistoryStorage = InMemoryTransactionHistoryStorage.restore(SerialisedWalletState.toJSON(readPersistedTxHistory(walletState.serializedState)), WalletEntrySchema, mergeWalletEntries);
+		} catch (error) {
+			logger.warn(`Discarding unreadable persisted Midnight wallet state for account ${account.accountId}; rebuilding from seed`, error instanceof Error ? error.message : String(error));
+			await firstValueFrom(store.removeWhere((state) => state.accountId === account.accountId).pipe(defaultIfEmpty(void 0), catchError((wipeError) => {
+				logger.error(`Failed to discard unreadable Midnight wallet state for account ${account.accountId}`, wipeError);
+				return of(void 0);
+			})));
+		}
+		if (restoredTxHistoryStorage) {
+			configuration.txHistoryStorage = restoredTxHistoryStorage;
+			return {
+				walletFacade: await WalletFacade.init({
+					configuration,
+					provingService: () => proofServer.provingService,
+					submissionService: createProgressSubmissionService,
+					shielded: (config) => ShieldedWallet(config).restore(SerialisedWalletState.toJSON(shielded)),
+					unshielded: (config) => UnshieldedWallet(config).restore(SerialisedWalletState.toJSON(unshielded)),
+					dust: (config) => DustWallet(config).restore(SerialisedWalletState.toJSON(dust))
+				}),
+				txHistoryStorage: restoredTxHistoryStorage,
+				proofCircuitProvider: proofServer.circuits,
+				finalizeRecipe
+			};
+		}
+	}
+	const { walletKeys: { dustKeyBuffer, zswapKeyBuffer }, unshieldedKeystore } = await firstValueFrom(keysWithAuthCancelledRecovery$(keyManager));
+	const dustParameters = ledger.LedgerParameters.initialParameters().dust;
+	const txHistoryStorage = new InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries);
+	configuration.txHistoryStorage = txHistoryStorage;
+	return {
+		walletFacade: await WalletFacade.init({
+			configuration,
+			provingService: () => proofServer.provingService,
+			submissionService: createProgressSubmissionService,
+			shielded: (config) => ShieldedWallet(config).startWithSeed(zswapKeyBuffer),
+			unshielded: (config) => UnshieldedWallet(config).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore)),
+			dust: (config) => DustWallet(config).startWithSeed(dustKeyBuffer, dustParameters)
+		}),
+		txHistoryStorage,
+		proofCircuitProvider: proofServer.circuits,
+		finalizeRecipe
+	};
+};
+/**
+* Creates an observable MidnightWallet from wallet instances.
+*
+* The nightVerifyingKey is obtained from the wallet state, which works
+* for both restored and new wallets.
+*/
+const createAccountObservableMidnightWallet = ({ account, keyManager, walletFacade, haltPersistence, proofCircuitProvider, finalizeRecipe }) => {
+	const { networkId } = account.blockchainSpecific;
+	const state$ = walletFacade.state().pipe(shareReplay({
+		bufferSize: 1,
+		refCount: true
+	}));
+	const releasing = withReservationRelease(walletFacade);
+	return state$.pipe(take(1), map((initialState) => {
+		const nightVerifyingKey = initialState.unshielded.capabilities.keys.getPublicKey(initialState.unshielded.state);
+		return {
+			accountId: account.accountId,
+			areKeysAvailable$: keyManager.areKeysAvailable$,
+			networkId,
+			nightVerifyingKey,
+			proofCircuitProvider,
+			walletId: account.walletId,
+			address$: state$.pipe(map(({ dust, shielded, unshielded }) => ({
+				dust: MidnightDustAddress(DustAddress.codec.encode(networkId, dust.capabilities.keys.getAddress(dust.state)).asString()),
+				shielded: MidnightShieldedAddress(ShieldedAddress.codec.encode(networkId, shielded.address).asString()),
+				unshielded: MidnightUnshieldedAddress(UnshieldedAddress.codec.encode(networkId, unshielded.address).asString())
+			})), distinctUntilChanged(deepEquals)),
+			coinsByTokenType$: state$.pipe(map(({ shielded, unshielded }) => {
+				const shieldedCoins = {};
+				const unshieldedCoins = {};
+				for (const { coin } of shielded.totalCoins) {
+					const previousCoinsList = shieldedCoins[coin.type] || [];
+					shieldedCoins[coin.type] = previousCoinsList.concat({
+						status: "mt_index" in coin ? "available" : "pending",
+						value: BigNumber(coin.value)
+					});
+				}
+				const parseUnshieldedCoins = (status, coins) => {
+					for (const { meta, utxo } of coins) {
+						const tokenType = toUnshieldedTokenType(utxo.type, networkId);
+						unshieldedCoins[tokenType] = (unshieldedCoins[tokenType] || []).concat({
+							status,
+							value: BigNumber(utxo.value),
+							registeredForDustGeneration: meta.registeredForDustGeneration,
+							ownerAddress: utxo.owner
+						});
+					}
+				};
+				parseUnshieldedCoins("pending", unshielded.pendingCoins);
+				parseUnshieldedCoins("available", unshielded.availableCoins);
+				return {
+					shielded: shieldedCoins,
+					unshielded: unshieldedCoins
+				};
+			}), distinctUntilChanged(deepEquals)),
+			syncProgress$: state$.pipe(map(({ dust, shielded, unshielded }) => ({
+				dust: computeConnectedSyncRatio(dust.state.progress.appliedIndex, dust.state.progress.highestRelevantWalletIndex, dust.state.progress.isConnected),
+				shielded: computeConnectedSyncRatio(shielded.state.progress.appliedIndex, shielded.state.progress.highestRelevantWalletIndex, shielded.state.progress.isConnected),
+				unshielded: computeConnectedSyncRatio(unshielded.state.progress.appliedId, unshielded.state.progress.highestTransactionId, unshielded.state.progress.isConnected),
+				isStrictlyComplete: {
+					dust: dust.state.progress.isStrictlyComplete(),
+					shielded: shielded.state.progress.isStrictlyComplete(),
+					unshielded: unshielded.state.progress.isStrictlyComplete()
+				}
+			})), distinctUntilChanged(deepEquals)),
+			transactionHistory$: state$.pipe(throttleTime(500, void 0, {
+				leading: true,
+				trailing: true
+			}), switchMap(() => from(walletFacade.getAllFromTxHistory())), distinctUntilChanged(deepEquals)),
+			balanceFinalizedTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.balanceFinalizedTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			balanceUnboundTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.balanceUnboundTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			balanceUnprovenTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(walletFacade.balanceUnprovenTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			calculateTransactionFee: (tx) => from(walletFacade.calculateTransactionFee(tx)),
+			estimateTransactionFee: (tx, options) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey } }) => from(walletFacade.estimateTransactionFee(tx, dustSecretKey, options)))),
+			deregisterFromDustGeneration: (nightUtxos) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.deregisterFromDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data))))),
+			getTransactionHistoryEntryByHash: (hash) => from(walletFacade.queryTxHistoryByHash(hash)),
+			finalizeRecipe: (recipe, onProgress) => defer(async () => finalizeRecipe(walletFacade, recipe, onProgress)),
+			finalizeTransaction: (recipe) => from(walletFacade.finalizeTransaction(recipe)),
+			registerNightUtxosForDustGeneration: (nightUtxos, dustAddress) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.registerNightUtxosForDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data), dustAddress)))),
+			revert: (recipe) => from(walletFacade.revert(recipe)),
+			state: () => state$,
+			stop: () => {
+				haltPersistence();
+				return from(walletFacade.stop());
+			},
+			signUnprovenTransaction: (tx) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.signUnprovenTransaction(tx, (data) => unshieldedKeystore.signData(data))))),
+			signRecipe: (recipe) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.signRecipe(recipe, (data) => unshieldedKeystore.signData(data))))),
+			signData: (data) => keyManager.keys$.pipe(take(1), map(({ unshieldedKeystore }) => ({
+				signature: unshieldedKeystore.signData(data),
+				verifyingKey: unshieldedKeystore.getPublicKey()
+			}))),
+			submitTransaction: (tx) => from(walletFacade.submitTransaction(tx)),
+			transferTransaction: (outputs, { ttl, payFees }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.transferTransaction(outputs, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				payFees
+			})))),
+			initSwap: (desiredInputs, desiredOutputs, { ttl, payFees }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.initSwap({
+				desiredInputs,
+				desiredOutputs
+			}, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				payFees
+			}))))
+		};
+	}));
+};
+/**
+* Creates and manages the lifecycle of Midnight SDK wallet instances.
+*
+* Lifecycle:
+* - Creates all 3 wallets (Unshielded, Shielded, Dust) via getAccountWalletInstance
+* - Starts UnshieldedWallet immediately (no keys needed)
+* - Starts ShieldedWallet and DustWallet once account keys become available
+*   (one auth prompt; sync then runs for the wallet's lifetime, surviving
+*   the key manager's idle zeroization — see the start step below)
+* - DustWallet is never stopped once started
+*   (SDK limitation: stop() closes Effect runtime, breaking calculateFee)
+* - On unsubscribe: stops all wallets and clears the sync key copy
+*/
+const createAndManageWallets = (props, { logger }, options) => {
+	const { keyManager, account, store } = props;
+	return new Observable((subscriber) => {
+		let walletFacade = null;
+		let syncSecretKeys = null;
+		let syncDustSecretKey = null;
+		let syncStartSubscription = null;
+		let persistSubscription = null;
+		let isDestroyed = false;
+		let isPersistenceHalted = false;
+		const init = async () => {
+			const { walletFacade: facade, txHistoryStorage, proofCircuitProvider, finalizeRecipe } = await getAccountWalletInstance(props, logger, options);
+			if (isDestroyed) {
+				facade.stop();
+				return;
+			}
+			walletFacade = facade;
+			await walletFacade.unshielded.start();
+			syncStartSubscription = keysWithAuthCancelledRecovery$(keyManager).pipe(switchMap((keys) => {
+				if (!walletFacade) return from(Promise.resolve());
+				syncSecretKeys = ledger.ZswapSecretKeys.fromSeed(keys.walletKeys.zswapKeyBuffer);
+				syncDustSecretKey = ledger.DustSecretKey.fromSeed(keys.walletKeys.dustKeyBuffer);
+				const facade = walletFacade;
+				const syncKeys = syncSecretKeys;
+				const dustSyncKey = syncDustSecretKey;
+				return from((async () => {
+					const failures = [];
+					try {
+						await facade.shielded.start(syncKeys);
+					} catch (error) {
+						logger.error(`Midnight shielded wallet failed to start for account ${account.accountId}:`, error);
+						failures.push(error);
+					}
+					try {
+						await facade.dust.start(dustSyncKey);
+					} catch (error) {
+						logger.error(`Midnight dust wallet failed to start for account ${account.accountId}:`, error);
+						failures.push(error);
+					}
+					if (failures.length > 0) throw failures[0];
+				})());
+			})).subscribe({ error: (error) => {
+				logger.error(`Wallet sync start error for account ${account.accountId}:`, error);
+				subscriber.error(error);
+			} });
+			let lastPersistedFingerprint;
+			const persistOnce = async () => {
+				const [dust, shielded, unshielded, txHistory] = (await firstValueFrom(zip(from(walletFacade.dust.serializeState()), from(walletFacade.shielded.serializeState()), from(walletFacade.unshielded.serializeState()), from(txHistoryStorage.serialize())))).map(SerialisedWalletState);
+				const fingerprint = fingerprintOf([
+					dust,
+					shielded,
+					unshielded,
+					txHistory
+				]);
+				if (fingerprint === lastPersistedFingerprint) return;
+				if (isPersistenceHalted || isDestroyed) return;
+				await firstValueFrom(store.upsert({
+					serializedState: {
+						dust,
+						shielded,
+						unshielded,
+						txHistory
+					},
+					accountId: account.accountId,
+					walletId: account.walletId,
+					networkId: account.blockchainSpecific.networkId
+				}).pipe(defaultIfEmpty(void 0)));
+				lastPersistedFingerprint = fingerprint;
+			};
+			persistSubscription = walletFacade.state().pipe(throttleTime(STATE_SERIALISATION_THROTTLE_TIME, void 0, {
+				leading: true,
+				trailing: true
+			}), exhaustMap(() => from(persistOnce()).pipe(catchError((error) => {
+				logger.error(`Failed to persist wallet state for account ${account.accountId}:`, error);
+				return of(void 0);
+			})))).subscribe();
+			subscriber.next({
+				walletFacade,
+				haltPersistence: () => {
+					isPersistenceHalted = true;
+				},
+				proofCircuitProvider,
+				finalizeRecipe
+			});
+		};
+		init().catch((error) => {
+			subscriber.error(error);
+		});
+		return () => {
+			isDestroyed = true;
+			syncStartSubscription?.unsubscribe();
+			persistSubscription?.unsubscribe();
+			if (walletFacade) walletFacade.stop().catch(() => void 0).finally(() => {
+				syncSecretKeys?.clear();
+				syncDustSecretKey?.clear();
+			});
+		};
+	});
+};
+/**
+* Starts a Midnight account wallet with full lifecycle management.
+*
+* Creates SDK wallets, manages their start/stop lifecycle, and converts
+* to the MidnightWallet interface used by the rest of the application.
+*/
+const createStartMidnightAccountWallet = (dependencies, options) => (props) => createAndManageWallets(props, dependencies, options).pipe(switchMap(({ walletFacade, haltPersistence, proofCircuitProvider, finalizeRecipe }) => createAccountObservableMidnightWallet({
+	account: props.account,
+	keyManager: props.keyManager,
+	walletFacade,
+	haltPersistence,
+	proofCircuitProvider,
+	finalizeRecipe
+})));
+/**
+* The engine's side-effect dependencies. The attested prover is the
+* loadout's: the app proves through the bundled Temenos deployment, which a
+* headless loadout does not ship.
+*/
+const createMidnightSideEffectDependencies = (options = {}) => ({ runtime }, dependencies) => {
+	const midnightWallets$ = midnightWalletsForRuntime(runtime);
+	return {
+		midnightWallets$,
+		wasmProofActivities$: EMPTY,
+		dismissWasmProofActivity: () => void 0,
+		teeAttestationProgress$,
+		getMidnightWalletByAccountId: (accountId) => midnightWallets$.pipe(take(1), map((wallets) => wallets[accountId]), switchMap((wallet) => wallet ? of(wallet) : throwError(() => /* @__PURE__ */ new Error(`Could not load midnight wallet for account ${accountId}`)))),
+		stopAllMidnightWallets: () => {
+			const walletsArray = Object.values(midnightWallets$.value);
+			midnightWallets$.next({});
+			if (walletsArray.length === 0) return of(void 0);
+			return forkJoin(walletsArray.map((wallet) => wallet.stop())).pipe(map(() => void 0));
+		},
+		stopMidnightWallet: (accountId) => {
+			const wallet = midnightWallets$.value[accountId];
+			if (!wallet) return of(void 0);
+			const { [accountId]: _, ...remaining } = midnightWallets$.value;
+			midnightWallets$.next(remaining);
+			return wallet.stop().pipe(map(() => void 0));
+		},
+		startMidnightAccountWallet: createStartMidnightAccountWallet(dependencies, options)
+	};
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/utils/activities.ts
+const toBigInt = (v) => typeof v === "bigint" ? v : BigInt(v);
+const buildTokenBalanceChangesFromUtxos = (createdUtxos, spentUtxos, networkId) => {
+	const changesByToken = /* @__PURE__ */ new Map();
+	for (const u of createdUtxos) {
+		const tokenId = TokenId(toUnshieldedTokenType(u.tokenType, networkId));
+		const existing = changesByToken.get(tokenId);
+		const value = toBigInt(u.value);
+		changesByToken.set(tokenId, {
+			tokenId,
+			amount: existing ? existing.amount + value : value
+		});
+	}
+	for (const u of spentUtxos) {
+		const tokenId = TokenId(toUnshieldedTokenType(u.tokenType, networkId));
+		const existing = changesByToken.get(tokenId);
+		const value = toBigInt(u.value);
+		changesByToken.set(tokenId, {
+			tokenId,
+			amount: existing ? existing.amount - value : -value
+		});
+	}
+	return [...changesByToken.values()].filter(({ amount }) => amount !== 0n).map(({ tokenId, amount }) => ({
+		tokenId,
+		amount: BigNumber(amount)
+	}));
+};
+const getAddressFromUtxos = (createdUtxos, spentUtxos) => {
+	return (createdUtxos[0] ?? spentUtxos[0])?.owner ?? "";
+};
+/**
+* Whether the wallet took part in an unshielded movement in this transaction —
+* the gate for surfacing it as an activity. True for unshielded and mixed sends,
+* and for dust designation (which rotates night UTxOs into the unshielded
+* section). False for shielded-only entries: their values are encrypted and
+* unreadable, and the fee-dust they spend never lands in the unshielded section,
+* so surfacing them would only produce an empty/unknown row.
+*/
+const entryHasUnshieldedActivity = (entry) => (entry.unshielded?.createdUtxos.length ?? 0) > 0 || (entry.unshielded?.spentUtxos.length ?? 0) > 0;
+const mapStatusToActivityType = (status, tokenBalanceChanges) => {
+	switch (status) {
+		case "SUCCESS":
+		case "PARTIAL_SUCCESS": return !tokenBalanceChanges?.length || tokenBalanceChanges.some(({ amount }) => BigInt(amount) > 0n) ? ActivityType.Receive : ActivityType.Send;
+		case "FAILURE": return ActivityType.Failed;
+	}
+};
+/**
+* Resolves the activity type and displayed token amounts for a transaction's
+* unshielded section. A transaction that moved unshielded value but nets to zero
+* is a self-transfer — a plain self-send, or a dust designation, which rotates
+* NIGHT back to the owner — so it is surfaced as {@link ActivityType.Self}.
+* No amount is shown: no value left the wallet, and the intended amount is not
+* recoverable (a self output is indistinguishable from change). Failures keep
+* their Failed type regardless.
+*/
+const deriveUnshieldedActivity = ({ status, createdUtxos, spentUtxos, networkId }) => {
+	const netChanges = buildTokenBalanceChangesFromUtxos(createdUtxos, spentUtxos, networkId);
+	if (status !== "FAILURE" && netChanges.length === 0 && (createdUtxos.length > 0 || spentUtxos.length > 0)) return {
+		type: ActivityType.Self,
+		tokenBalanceChanges: []
+	};
+	return {
+		type: mapStatusToActivityType(status, netChanges),
+		tokenBalanceChanges: netChanges
+	};
+};
+const formatFee = (fees) => fees === null || fees === void 0 ? "0" : String(fees);
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/activities.ts
+const mapTxHistoryEntryToActivity = ({ accountId, txHistoryEntry, networkId }) => {
+	const { hash, timestamp, status } = txHistoryEntry;
+	const { type, tokenBalanceChanges } = deriveUnshieldedActivity({
+		status,
+		createdUtxos: txHistoryEntry.unshielded?.createdUtxos ?? [],
+		spentUtxos: txHistoryEntry.unshielded?.spentUtxos ?? [],
+		networkId
+	});
+	return {
+		accountId,
+		activityId: hash,
+		type,
+		timestamp: Timestamp(timestamp?.getTime() ?? 0),
+		tokenBalanceChanges
+	};
+};
+const mapTxHistoryEntryToActivityDetail = ({ accountId, txHistoryEntry, networkId }) => {
+	const createdUtxos = txHistoryEntry.unshielded?.createdUtxos ?? [];
+	const spentUtxos = txHistoryEntry.unshielded?.spentUtxos ?? [];
+	const activity = mapTxHistoryEntryToActivity({
+		accountId,
+		txHistoryEntry,
+		networkId
+	});
+	const address = getAddressFromUtxos(createdUtxos, spentUtxos);
+	return {
+		...activity,
+		address,
+		fee: formatFee(txHistoryEntry.fees)
+	};
+};
+/**
+* Whether confirmed rows with no unshielded section are shown. They carry no
+* readable value or date, so they render as amount-less "unknown" / 1970 rows;
+* hiding them is the default and the flag restores the earlier behaviour while
+* the product decision is open.
+*/
+const showShieldedOnlyRows$ = (stateObservables) => stateObservables.features.selectLoadedFeatures$.pipe(map((loaded) => loaded.featureFlags.some((flag) => flag.key === FEATURE_FLAG_MIDNIGHT_SHIELDED_ACTIVITY_ROWS)), distinctUntilChanged());
+const updateActivities = (_, stateObservables, { actions, midnightWallets$ }) => midnightWallets$.pipe(scan((accumulator, wallets) => ({
+	current: wallets,
+	added: Object.values(wallets).filter((w) => !(w.accountId in accumulator.current))
+}), {
+	current: {},
+	added: []
+}), mergeMap(({ added }) => added), mergeMap((wallet) => combineLatest([wallet.transactionHistory$, showShieldedOnlyRows$(stateObservables)]).pipe(map(([transactionHistory, showShieldedOnlyRows]) => ({
+	activities: transactionHistory.filter((entry) => showShieldedOnlyRows || entryHasUnshieldedActivity(entry)).map((txHistoryEntry) => mapTxHistoryEntryToActivity({
+		accountId: wallet.accountId,
+		txHistoryEntry,
+		networkId: wallet.networkId
+	})),
+	suppressedActivityIds: showShieldedOnlyRows ? [] : transactionHistory.filter((entry) => !entryHasUnshieldedActivity(entry)).map((entry) => entry.hash)
+})), mergeMap(({ activities, suppressedActivityIds }) => [
+	actions.activities.upsertActivities({
+		accountId: wallet.accountId,
+		activities
+	}),
+	...suppressedActivityIds.length > 0 ? [actions.activities.removeActivities({
+		accountId: wallet.accountId,
+		activityIds: suppressedActivityIds
+	})] : [],
+	actions.activities.setHasLoadedOldestEntry({
+		accountId: wallet.accountId,
+		hasLoadedOldestEntry: true
+	}),
+	actions.activities.setDesiredLoadedActivitiesCount({
+		accountId: wallet.accountId,
+		desiredLoadedActivitiesCount: activities.length
+	})
+]), takeUntil(midnightWallets$.pipe(filter((wallets) => !(wallet.accountId in wallets)))))));
+const loadActivityDetails = ({ activities: { loadActivityDetails$ } }, _, { actions, getMidnightWalletByAccountId, logger }) => loadActivityDetails$.pipe(filter(({ payload: { blockchainName } }) => blockchainName === "Midnight"), map((action) => action.payload.activity), switchMap(({ activityId, accountId }) => getMidnightWalletByAccountId(accountId).pipe(switchMap((wallet) => wallet.getTransactionHistoryEntryByHash(activityId).pipe(map((txHistoryEntry) => {
+	if (!txHistoryEntry) return actions.activities.setActivityDetails({ activityDetails: void 0 });
+	return actions.activities.setActivityDetails({ activityDetails: mapTxHistoryEntryToActivityDetail({
+		accountId: wallet.accountId,
+		txHistoryEntry,
+		networkId: wallet.networkId
+	}) });
+}), catchError((error) => {
+	logger.error("Failed to load Midnight activity details", error);
+	return EMPTY;
+}))), catchError(() => EMPTY))));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/proof-activities.ts
+const watchProofActivities = (_actions, _state, { actions, wasmProofActivities$ }) => wasmProofActivities$.pipe(map((activities) => actions.midnightContext.proofActivitiesUpdated(activities)));
+const dismissProofActivity = ({ midnightContext: { proofActivityDismissRequested$ } }, _state, { dismissWasmProofActivity }) => proofActivityDismissRequested$.pipe(tap(({ payload }) => {
+	dismissWasmProofActivity(payload);
+}), ignoreElements());
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/proof-server-kill-switch.ts
+/** Persist the fallback when a selected provider is disabled or no longer
+* belongs to the source-controlled catalogue. Notify once per affected batch. */
+const migrateUnavailableProofServerSelection = (_, { midnightContext: { selectUnavailableProofServerNetworks$, selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => selectUnavailableProofServerNetworks$.pipe(distinctUntilChanged(isEqual), filter((networkIds) => networkIds.length > 0), withLatestFrom(selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$), mergeMap(([networkIds, networksConfig, featureFlagsOverrides]) => from([...networkIds.map((networkId) => actions.midnightContext.setUserNetworkConfigOverride({
+	networkId,
+	config: networksConfig[networkId],
+	featureFlagsOverrides: featureFlagsOverrides[networkId] ?? {}
+})), actions.ui.showToast({
+	text: "midnight.proof-server.unavailable",
+	color: "neutral",
+	duration: 8,
+	leftIcon: {
+		name: "AlertTriangle",
+		size: 20
+	}
+})])));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/resync.ts
+const withMidnightAccounts = (makeSideEffect) => (actionObservables, stateObservables, dependencies) => makeSideEffect(midnightAccounts$(stateObservables))(actionObservables, stateObservables, dependencies);
+const requestResyncWallet = withMidnightAccounts((midnightAccount$) => ({ midnightSync: { requestResync$ } }, _, { actions }) => merge(requestResync$.pipe(withLatestFrom(midnightAccount$), switchMap(([_, accounts]) => {
+	return from([...accounts.map(({ accountId }) => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: Timestamp(Date.now())
+		}
+	})), actions.midnightSync.resync()]);
+}))));
+const createClearWalletStateOnResync = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightSync: { resync$ } }, _, { actions, stopAllMidnightWallets, logger }) => resync$.pipe(withLatestFrom(midnightAccounts$), switchMap(([_, midnightAccounts]) => stopAllMidnightWallets().pipe(catchError((error) => {
+	logger.error("Midnight resync: stop failed", error);
+	return of(void 0);
+}), switchMap(() => store.clear().pipe(defaultIfEmpty(void 0), catchError((error) => {
+	logger.error("Midnight resync: state wipe failed", error);
+	return of(void 0);
+}))), switchMap(() => [...midnightAccounts.flatMap(({ accountId }) => [
+	actions.addresses.resetAddresses({ accountId }),
+	actions.tokens.resetAccountTokens({ accountId }),
+	actions.activities.resetActivities({ accountId }),
+	actions.midnightContext.resetAccountDust({ accountId })
+]), actions.midnightSync.restartWalletWatch()])))));
+/**
+* Side-effect that triggers a Midnight wallet resync whenever the config change
+* is made with a feature flag override and the wallet is unlocked.
+*/
+const resyncWalletOnConfigChangeFromFeatureFlags = withMidnightAccounts((midnightAccounts$) => (_, { appLock: { isUnlocked$ }, midnightContext: { selectCurrentNetwork$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => {
+	return selectNetworksConfigFeatureFlagsOverrides$.pipe(withLatestFrom(isUnlocked$), filter(([_, isUnlocked]) => isUnlocked), switchMap(() => selectCurrentNetwork$.pipe(take(1))), map(({ config }) => config), distinctUntilChanged(deepEquals)).pipe(withLatestFrom(midnightAccounts$), switchMap(([_, midnightAccounts]) => from([...midnightAccounts.map(({ accountId }) => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: Timestamp(Date.now())
+		}
+	})), actions.midnightSync.resync()])));
+});
+const createDeleteWalletSideEffect = (storage) => ({ wallets: { removeWallet$ } }, { wallets: { selectAll$ } }, { stopMidnightWallet, actions, logger }) => removeWallet$.pipe(withLatestFrom(selectAll$.pipe(map((wallets) => wallets.filter(hasMidnightAccount)))), switchMap(([{ payload }, midnightWallets]) => {
+	const walletId = typeof payload === "string" ? payload : payload.walletId;
+	const targetWallet = midnightWallets.find((w) => w.walletId === walletId);
+	if (!targetWallet) return EMPTY;
+	const allMidnightAccounts = targetWallet.accounts.filter(isInMemoryMidnightAccount);
+	return (allMidnightAccounts.length > 0 ? forkJoin(allMidnightAccounts.map(({ accountId }) => stopMidnightWallet(accountId))) : of([])).pipe(switchMap(() => storage.removeWhere((wallet) => wallet.walletId === walletId).pipe(defaultIfEmpty(void 0), catchError((error) => {
+		logger.error("Midnight delete wallet: state wipe failed", error);
+		return of(void 0);
+	}))), mergeMap(() => allMidnightAccounts.flatMap(({ accountId }) => [
+		actions.addresses.resetAddresses({ accountId }),
+		actions.tokens.resetAccountTokens({ accountId }),
+		actions.activities.resetActivities({ accountId })
+	])));
+}));
+/**
+* Stops one Midnight account's wallet, wipes that account's persisted SDK
+* state, then emits the actions that clear every redux cache the wiped state
+* fed. Scoped to a single account, unlike `createClearWalletStateOnResync`,
+* which wipes the whole chain.
+*
+* A step that errors or completes without emitting is handed to
+* `onStepFailure`: return an observable that emits to carry on with the next
+* step, or one that errors to abort the reset with that error.
+*/
+const stopAndWipeAccountState$ = ({ accountId, actions, store, stop$, onStepFailure }) => stop$.pipe(take(1), throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")), catchError((error) => onStepFailure("stop", error)), switchMap(() => store.removeWhere((wallet) => wallet?.accountId === accountId).pipe(throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account storage wipe did not acknowledge completion")), catchError((error) => onStepFailure("wipe", error)))), mergeMap(() => [
+	actions.addresses.resetAddresses({ accountId }),
+	actions.tokens.resetAccountTokens({ accountId }),
+	actions.activities.resetActivities({ accountId }),
+	actions.midnightContext.resetAccountDust({ accountId }),
+	actions.sync.resetAccountSyncStatus({ accountId })
+]));
+/**
+* The extension's per-account "reset sync state": stops and wipes the account,
+* then reloads the app so every engine restarts from empty state. Stop and wipe
+* failures are logged and the reset carries on, because the reload is what
+* recovers the account.
+*
+* The reload is emitted LAST, after the storage write settles: sequencing it
+* inside this chain (rather than firing it from a separate UI tap) is what stops
+* a hard reload from preempting the wipe and leaving the old SDK document to
+* restore from.
+*/
+const createResetSyncStateSideEffect = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightContext: { resetSyncState$ } }, _, { actions, stopMidnightWallet, logger }) => resetSyncState$.pipe(withLatestFrom(midnightAccounts$), switchMap(([{ payload }, midnightAccounts]) => {
+	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
+	if (!account) return EMPTY;
+	const { accountId } = account;
+	return concat(stopAndWipeAccountState$({
+		accountId,
+		actions,
+		store,
+		stop$: stopMidnightWallet(accountId),
+		onStepFailure: (step, error) => {
+			logger.error(`Midnight reset sync state: ${step} failed`, error);
+			return of(void 0);
+		}
+	}), of(actions.app.reloadApplication()));
+})));
+/**
+* The headless per-account "reset sync state": stops and wipes the account,
+* then restarts that account's watcher in place, since a headless runtime has
+* no application to reload. The account's sync operation reads Pending while
+* the reset runs and Failed if a stop or wipe fails, so the caller can observe
+* the outcome and retry.
+*/
+const createHeadlessResetSyncStateSideEffect = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightContext: { resetSyncState$ } }, _, { actions, stopMidnightWallet, logger }) => resetSyncState$.pipe(withLatestFrom(midnightAccounts$), groupBy(([{ payload }]) => payload.accountId), mergeMap((requests$) => requests$.pipe(exhaustMap(([{ payload }, midnightAccounts]) => {
+	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
+	if (!account) return EMPTY;
+	const { accountId } = account;
+	const pendingOperation = () => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: Timestamp(Date.now())
+		}
+	});
+	const stop$ = merge(of(void 0), requests$).pipe(switchMap(() => defer(() => stopMidnightWallet(accountId)).pipe(throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")))));
+	return concat(of(pendingOperation()), stopAndWipeAccountState$({
+		accountId,
+		actions,
+		store,
+		stop$,
+		onStepFailure: (step, error) => {
+			logger.error(`Midnight reset sync state: ${step} failed`, error);
+			return throwError(() => error);
+		}
+	}), defer(() => of(pendingOperation(), actions.midnightSync.restartAccountWatch({ accountId })))).pipe(catchError((error) => {
+		logger.error("Midnight account resync failed", error);
+		const failedAt = Timestamp(Date.now());
+		return of(actions.sync.addSyncOperation({
+			accountId,
+			operation: {
+				operationId: `${accountId}-midnight-sync`,
+				status: "Failed",
+				description: "sync.operation.midnight-resync",
+				error: "sync.error.midnight-sync-failed",
+				startedAt: failedAt,
+				failedAt
+			}
+		}));
+	}));
+})))));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/sync-failure.ts
+/**
+* Dismiss a Midnight account's sync failure once its own sync recovers.
+*
+* The `completeSyncOperation` for `${accountId}-midnight-sync` is the
+* "recovered" signal, whichever route got there — transparent retry, the
+* failure's tap-to-retry `restartWalletWatch`, or the resubscription `whileActive`
+* performs on unlock.
+*
+* Keyed per-account, so no lookup is needed: a completion for a sibling Midnight
+* account (or a Cardano/Bitcoin one) maps to a different, non-existent
+* MidnightSyncFailureId and no-ops, leaving a still-broken account's failure in
+* place until its OWN sync completes.
+*/
+const autoDismissMidnightSyncFailureOnSyncSuccess = ({ sync: { completeSyncOperation$ } }, { failures: { selectFailureById$ } }) => completeSyncOperation$.pipe(map(({ payload }) => MidnightSyncFailureId(payload.accountId)), autoDismissFailureOnSuccess(selectFailureById$));
+/**
+* On resume, clear the sync failure for every Midnight account.
+*
+* Complements the per-account recovery dismissal above by clearing a stale error
+* immediately, rather than leaving it on screen for the length of the first sync
+* after unlock. No restart is dispatched: `watchMidnightAccounts` ends its pipe
+* with `whileActive`, so resuming already resubscribes every account watcher.
+* Accounts with no failure are a no-op.
+*/
+const autoDismissMidnightSyncFailureOnResume = (_, { wallets: { selectAll$ }, failures: { selectFailureById$ } }, { walletResumed$ }) => walletResumed$.pipe(withLatestFrom(selectAll$), mergeMap(([, wallets]) => from(wallets.flatMap((wallet) => wallet.accounts).filter(isInMemoryMidnightAccount).map((account) => MidnightSyncFailureId(account.accountId)))), autoDismissFailureOnSuccess(selectFailureById$));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/tee-attestation-progress.ts
+/**
+* Forwards attested-proving progress from the dependency-level stream into
+* redux, where the send-flow checklist UI reads it. Pure mapping — the
+* events originate inside the proving service (ADR 19).
+*/
+const watchTeeAttestationProgress = (_actionObservables, _stateObservables, { actions, teeAttestationProgress$ }) => teeAttestationProgress$.pipe(map((event) => event.type === "begin" ? actions.midnightContext.teeAttestationProgressStarted(event) : actions.midnightContext.teeAttestationProgressUpdated(event)));
+/**
+* Clears the previous run's checklist as soon as a new Midnight transaction
+* starts building, so a redone send never opens the
+* processing screen with stale step results. The attested proving service's
+* `reset` then rebuilds the pending checklist when verification actually
+* begins. The signer owns confirmation resets. Submit must not clear the
+* completed checklist while the transaction is being submitted.
+*/
+const clearTeeAttestationProgressOnNewTx = ({ txExecutor: { txPhaseRequested$ } }, _stateObservables, { actions }) => txPhaseRequested$.pipe(filter(({ payload: { config } }) => config.params.blockchainName === "Midnight" && config.type === "buildTx"), map(() => actions.midnightContext.teeAttestationProgressCleared()));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/index.ts
+/**
+* The engine's side effects plus the ones a loadout adds over the same
+* persisted wallet-state storage. The engine set reads only the contracts
+* the engine itself depends on; a loadout decides what else it can run.
+*/
+const createInitializeSideEffects = (loadoutSideEffects) => () => [(actionObservables, stateObservables, dependencies) => {
+	const midnightStateStorage = dependencies.createCollectionStorage({
+		collectionId: "midnightWalletState",
+		computeDocId: (wallet) => String(wallet.accountId)
+	});
+	return merge(...[
+		updateActivities,
+		loadActivityDetails,
+		createDeleteWalletSideEffect(midnightStateStorage),
+		createClearWalletStateOnResync(midnightStateStorage),
+		requestResyncWallet,
+		autoDismissMidnightSyncFailureOnResume,
+		autoDismissMidnightSyncFailureOnSyncSuccess,
+		watchMidnightAccounts(midnightStateStorage, watchMidnightAccount),
+		...loadoutSideEffects(midnightStateStorage)
+	].map((sideEffect) => sideEffect(actionObservables, stateObservables, dependencies)));
+}];
+createInitializeSideEffects((storage) => [
+	createResetSyncStateSideEffect(storage),
+	resyncWalletOnConfigChangeFromFeatureFlags,
+	migrateUnavailableProofServerSelection,
+	watchProofActivities,
+	dismissProofActivity,
+	watchTeeAttestationProgress,
+	clearTeeAttestationProgressOnNewTx
+]);
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/network-config.ts
+/**
+* Applies a loadout's supported networks and default proof servers right
+* after the first action the store handles, which redux-persist dispatches
+* while the store is created. Both therefore hold before the store is handed
+* out and before any side effect starts: a side effect would land a tick
+* later, and a network selected in between would be checked against the
+* contract's full list.
+*/
+const createApplyNetworkDefaultsMiddleware = ({ supportedNetworkIds, defaultProofServers }) => {
+	const { setDefaultProofServers, setSupportedNetworksIds } = midnightContextActions.midnightContext;
+	return (store) => (next) => {
+		let pending = [...supportedNetworkIds ? [setSupportedNetworksIds(supportedNetworkIds)] : [], ...defaultProofServers ? [setDefaultProofServers(defaultProofServers)] : []];
+		return (action) => {
+			const result = next(action);
+			const defaults = pending;
+			pending = [];
+			for (const defaultAction of defaults) store.dispatch(defaultAction);
+			return result;
+		};
+	};
+};
+/**
+* Applies a loadout's endpoint choices as user overrides on startup, so they
+* take precedence over the contract defaults and the feature-flag values
+* without a settings UI to enter them through.
+*/
+const createApplyNetworkConfigOverrides = (overrides) => (_, { midnightContext: { selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => zip(selectNetworksConfig$.pipe(take(1)), selectNetworksConfigFeatureFlagsOverrides$.pipe(take(1))).pipe(mergeMap(([networksConfig, featureFlagsOverrides]) => Object.entries(overrides).map(([networkId, override]) => actions.midnightContext.setUserNetworkConfigOverride({
+	networkId,
+	config: {
+		...networksConfig[networkId],
+		...override
+	},
+	featureFlagsOverrides: featureFlagsOverrides[networkId]
+}))));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/sdk-init.ts
+const assertDefaultTestnetConfigured = (config) => {
+	const networkId = config?.defaultMidnightTestnetNetworkId;
+	if (!networkId || !MidnightSDKTestNetworkId.includes(networkId)) throw new Error(`createLaceWallet needs config.defaultMidnightTestnetNetworkId, the Midnight testnet a wallet starts on: one of ${MidnightSDKTestNetworkId.join(", ")}; got ${String(networkId)}`);
+};
+const createSdkStoreInit = ({ auth, batchUpdates, createAttestedProver, networks = {}, supportedNetworkIds, defaultProofServers }) => {
+	const initializeSideEffects = createInitializeSideEffects((storage) => [
+		registerMidnightBlockchainNetworks,
+		createApplyNetworkConfigOverrides(networks),
+		createHeadlessResetSyncStateSideEffect(storage)
+	]);
+	const initializeDependencies = createMidnightSideEffectDependencies({
+		batchUpdates,
+		createAttestedProver
+	});
+	return (props, dependencies) => {
+		assertDefaultTestnetConfigured(props.runtime.config);
+		return {
+			middleware: [createApplyNetworkDefaultsMiddleware({
+				supportedNetworkIds,
+				defaultProofServers
+			})],
+			sideEffects: initializeSideEffects(props, dependencies),
+			sideEffectDependencies: {
+				...initializeDependencies(props, dependencies),
+				...auth
+			}
+		};
+	};
+};
+//#endregion
+export { createSdkStoreInit };