@cmmd-center/forge 0.10.13 → 0.10.16

package/dist/{Path-CHDjKLrB.cjs → Path-Be7zSwar.cjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const require_Schema = require("./Schema-Cf_uEUQU.cjs");
+const require_Schema = require("./Schema-dLi7Qssy.cjs");
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/Brand.js
 /**
 * This function returns a `Constructor` that **does not apply any runtime
@@ -26,7 +26,7 @@ function nominal() {
 /**
 * @since 4.0.0
 */
-const TypeId$11 = "~effect/platform/PlatformError";
+const TypeId$12 = "~effect/platform/PlatformError";
 /**
 * @since 4.0.0
 * @category Models
@@ -66,7 +66,7 @@ var PlatformError = class extends require_Schema.TaggedError("PlatformError") {
 	/**
 	* @since 4.0.0
 	*/
-	[TypeId$11] = TypeId$11;
+	[TypeId$12] = TypeId$12;
 	get message() {
 		return this.reason.message;
 	}
@@ -234,7 +234,7 @@ const runIn = require_Schema.fiberRunIn;
 * @category constructors
 * @since 3.8.0
 */
-const makeUnsafe$1 = require_Schema.makeLatchUnsafe;
+const makeUnsafe$2 = require_Schema.makeLatchUnsafe;
 /**
 * Creates a new Latch.
 *
@@ -270,7 +270,7 @@ const makeUnsafe$1 = require_Schema.makeLatchUnsafe;
 * @category constructors
 * @since 3.8.0
 */
-const make$10 = require_Schema.makeLatch;
+const make$11 = require_Schema.makeLatch;
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/MutableList.js
 /**
@@ -371,7 +371,7 @@ const Empty = /* @__PURE__ */ Symbol.for("effect/MutableList/Empty");
 * @since 4.0.0
 * @category constructors
 */
-const make$9 = () => ({
+const make$10 = () => ({
 	head: void 0,
 	tail: void 0,
 	length: 0
@@ -582,7 +582,7 @@ const appendAllUnsafe = (self, messages, mutable = false) => {
 * @since 4.0.0
 * @category mutations
 */
-const clear = (self) => {
+const clear$1 = (self) => {
 	self.head = self.tail = void 0;
 	self.length = 0;
 };
@@ -632,7 +632,7 @@ const takeN = (self, n) => {
 	n = Math.min(n, self.length);
 	if (n === self.length && self.head?.offset === 0 && !self.head.next) {
 		const array = self.head.array;
-		clear(self);
+		clear$1(self);
 		return array;
 	}
 	const array = new Array(n);
@@ -646,13 +646,13 @@ const takeN = (self, n) => {
 			if (index === n) {
 				self.head = chunk;
 				self.length -= n;
-				if (self.length === 0) clear(self);
+				if (self.length === 0) clear$1(self);
 				return array;
 			}
 		}
 		chunk = chunk.next;
 	}
-	clear(self);
+	clear$1(self);
 	return array;
 };
 /**
@@ -752,7 +752,7 @@ const take$1 = (self) => {
 	self.head.offset++;
 	self.length--;
 	if (self.head.offset === self.head.array.length) if (self.head.next) self.head = self.head.next;
-	else clear(self);
+	else clear$1(self);
 	return message;
 };
 /**
@@ -856,9 +856,9 @@ const filter$1 = (self, f) => {
 const remove$1 = (self, value) => filter$1(self, (v) => v !== value);
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/MutableRef.js
-const TypeId$10 = "~effect/MutableRef";
+const TypeId$11 = "~effect/MutableRef";
 const MutableRefProto = {
-	[TypeId$10]: TypeId$10,
+	[TypeId$11]: TypeId$11,
 	...require_Schema.PipeInspectableProto,
 	toJSON() {
 		return {
@@ -891,7 +891,7 @@ const MutableRefProto = {
 * @since 2.0.0
 * @category constructors
 */
-const make$8 = (value) => {
+const make$9 = (value) => {
 	const ref = Object.create(MutableRefProto);
 	ref.current = value;
 	return ref;
@@ -970,7 +970,7 @@ const set$1 = /* @__PURE__ */ require_Schema.dual(2, (self, value) => {
 *
 * @since 2.0.0
 */
-const TypeId$9 = "~effect/PubSub";
+const TypeId$10 = "~effect/PubSub";
 const SubscriptionTypeId = "~effect/PubSub/Subscription";
 /**
 * Creates a PubSub with a custom atomic implementation and strategy.
@@ -995,7 +995,7 @@ const SubscriptionTypeId = "~effect/PubSub/Subscription";
 * @since 4.0.0
 * @category constructors
 */
-const make$7 = (options) => require_Schema.sync(() => makePubSubUnsafe(options.atomicPubSub(), /* @__PURE__ */ new Map(), require_Schema.makeUnsafe$1(), makeUnsafe$1(false), make$8(false), options.strategy()));
+const make$8 = (options) => require_Schema.sync(() => makePubSubUnsafe(options.atomicPubSub(), /* @__PURE__ */ new Map(), require_Schema.makeUnsafe$1(), makeUnsafe$2(false), make$9(false), options.strategy()));
 /**
 * Creates an unbounded `PubSub`.
 *
@@ -1029,7 +1029,7 @@ const make$7 = (options) => require_Schema.sync(() => makePubSubUnsafe(options.a
 * @since 2.0.0
 * @category constructors
 */
-const unbounded$1 = (options) => make$7({
+const unbounded$1 = (options) => make$8({
 	atomicPubSub: () => makeAtomicUnbounded(options),
 	strategy: () => new DroppingStrategy()
 });
@@ -1245,7 +1245,7 @@ const removeSubscribers = (subscribers, subscription, pollers) => {
 	set.delete(pollers);
 	if (set.size === 0) subscribers.delete(subscription);
 };
-const makeSubscriptionUnsafe = (pubsub, subscribers, strategy) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make$9(), makeUnsafe$1(false), make$8(false), strategy, pubsub.replayWindow());
+const makeSubscriptionUnsafe = (pubsub, subscribers, strategy) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make$10(), makeUnsafe$2(false), make$9(false), strategy, pubsub.replayWindow());
 var UnboundedPubSub = class {
 	publisherHead = {
 		value: AbsentValue,
@@ -1411,7 +1411,7 @@ var SubscriptionImpl = class {
 	}
 };
 var PubSubImpl = class {
-	[TypeId$9] = { _A: require_Schema.identity };
+	[TypeId$10] = { _A: require_Schema.identity };
 	pubsub;
 	subscribers;
 	scope;
@@ -1591,7 +1591,7 @@ const emptyReplayWindow = {
 /**
 * @since 3.8.0
 */
-const TypeId$8 = "~effect/Queue";
+const TypeId$9 = "~effect/Queue";
 const EnqueueTypeId = "~effect/Queue/Enqueue";
 const DequeueTypeId = "~effect/Queue/Dequeue";
 const variance$1 = {
@@ -1599,7 +1599,7 @@ const variance$1 = {
 	_E: require_Schema.identity
 };
 const QueueProto = {
-	[TypeId$8]: variance$1,
+	[TypeId$9]: variance$1,
 	[EnqueueTypeId]: variance$1,
 	[DequeueTypeId]: variance$1,
 	...require_Schema.PipeInspectableProto,
@@ -1651,12 +1651,12 @@ const QueueProto = {
 * })
 * ```
 */
-const make$6 = (options) => require_Schema.withFiber$1((fiber) => {
+const make$7 = (options) => require_Schema.withFiber$1((fiber) => {
 	const self = Object.create(QueueProto);
 	self.dispatcher = fiber.currentDispatcher;
 	self.capacity = options?.capacity ?? Number.POSITIVE_INFINITY;
 	self.strategy = options?.strategy ?? "suspend";
-	self.messages = make$9();
+	self.messages = make$10();
 	self.scheduleRunning = false;
 	self.state = {
 		_tag: "Open",
@@ -1691,7 +1691,7 @@ const make$6 = (options) => require_Schema.withFiber$1((fiber) => {
 * @since 2.0.0
 * @category Constructors
 */
-const bounded = (capacity) => make$6({ capacity });
+const bounded = (capacity) => make$7({ capacity });
 /**
 * Creates a bounded queue with sliding strategy. When the queue reaches capacity,
 * new elements are added and the oldest elements are dropped.
@@ -1722,7 +1722,7 @@ const bounded = (capacity) => make$6({ capacity });
 * @since 2.0.0
 * @category Constructors
 */
-const sliding = (capacity) => make$6({
+const sliding = (capacity) => make$7({
 	capacity,
 	strategy: "sliding"
 });
@@ -1758,7 +1758,7 @@ const sliding = (capacity) => make$6({
 * @since 2.0.0
 * @category Constructors
 */
-const unbounded = () => make$6();
+const unbounded = () => make$7();
 /**
 * Add a message to the queue. Returns `false` if the queue is done.
 *
@@ -2100,7 +2100,7 @@ const endUnsafe = (self) => failCauseUnsafe(self, require_Schema.causeFail(requi
 */
 const shutdown = (self) => require_Schema.sync$2(() => {
 	if (self.state._tag === "Done") return true;
-	clear(self.messages);
+	clear$1(self.messages);
 	const offers = self.state.offers;
 	finalize(self, self.state._tag === "Open" ? exitInterrupt : self.state.exit);
 	if (offers.size > 0) {
@@ -2485,7 +2485,7 @@ const finalize = (self, exit) => {
 * @since 2.0.0
 * @category constructors
 */
-const makeUnsafe = (permits) => new SemaphoreImpl(permits);
+const makeUnsafe$1 = (permits) => new SemaphoreImpl(permits);
 var SemaphoreImpl = class {
 	waiters = /* @__PURE__ */ new Set();
 	taken = 0;
@@ -2593,7 +2593,7 @@ var SemaphoreImpl = class {
 * @since 2.0.0
 * @category constructors
 */
-const make$5 = (permits) => require_Schema.sync$2(() => new SemaphoreImpl(permits));
+const make$6 = (permits) => require_Schema.sync$2(() => new SemaphoreImpl(permits));
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/Channel.js
 /**
@@ -2658,7 +2658,7 @@ const make$5 = (permits) => require_Schema.sync$2(() => new SemaphoreImpl(permit
 * @since 4.0.0
 * @category Type Identifiers
 */
-const TypeId$7 = "~effect/Channel";
+const TypeId$8 = "~effect/Channel";
 /**
 * Tests if a value is a `Channel`.
 *
@@ -2674,9 +2674,9 @@ const TypeId$7 = "~effect/Channel";
 * @category guards
 * @since 3.5.4
 */
-const isChannel = (u) => require_Schema.hasProperty(u, TypeId$7);
+const isChannel = (u) => require_Schema.hasProperty(u, TypeId$8);
 const ChannelProto = {
-	[TypeId$7]: {
+	[TypeId$8]: {
 		_Env: require_Schema.identity,
 		_InErr: require_Schema.identity,
 		_InElem: require_Schema.identity,
@@ -2791,7 +2791,7 @@ const toTransform = (channel) => channel.transform;
 * @since 2.0.0
 */
 const DefaultChunkSize$1 = 4096;
-const asyncQueue = (scope, f, options) => make$6({
+const asyncQueue = (scope, f, options) => make$7({
 	capacity: options?.bufferSize,
 	strategy: options?.strategy
 }).pipe(require_Schema.tap((queue) => require_Schema.addFinalizer$1(scope, shutdown(queue))), require_Schema.tap((queue) => require_Schema.forkIn(require_Schema.provide$2(f(queue), scope), scope)));
@@ -3482,7 +3482,7 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(require_S
 	const runFork = require_Schema.runForkWith(yield* require_Schema.context());
 	const trackFiber = runIn(forkedScope);
 	if (options.unordered) {
-		const semaphore = makeUnsafe(concurrencyN);
+		const semaphore = makeUnsafe$1(concurrencyN);
 		const release = require_Schema.constant(semaphore.release(1));
 		const handle = require_Schema.matchCauseEffect({
 			onFailure: (cause) => require_Schema.flatMap(failCause$2(queue, cause), release),
@@ -3851,8 +3851,8 @@ const orDie$1 = (self) => catch_(self, die$1);
 */
 const mergeAll = /* @__PURE__ */ require_Schema.dual(2, (channels, { bufferSize = 16, concurrency, switch: switch_ = false }) => fromTransformBracket(require_Schema.fnUntraced(function* (upstream, scope, forkedScope) {
 	const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);
-	const semaphore = switch_ ? void 0 : makeUnsafe(concurrencyN);
-	const doneLatch = yield* make$10(true);
+	const semaphore = switch_ ? void 0 : makeUnsafe$1(concurrencyN);
+	const doneLatch = yield* make$11(true);
 	const fibers = /* @__PURE__ */ new Set();
 	const queue = yield* bounded(bufferSize);
 	yield* require_Schema.addFinalizer$1(forkedScope, shutdown(queue));
@@ -4276,14 +4276,14 @@ const runFold$1 = /* @__PURE__ */ require_Schema.dual(3, (self, initial, f) => r
 const toPullScoped = (self, scope) => toTransform(self)(require_Schema.done$1(), scope);
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/internal/stream.js
-const TypeId$6 = "~effect/Stream";
+const TypeId$7 = "~effect/Stream";
 const streamVariance = {
 	_R: require_Schema.identity,
 	_E: require_Schema.identity,
 	_A: require_Schema.identity
 };
 const StreamProto = {
-	[TypeId$6]: streamVariance,
+	[TypeId$7]: streamVariance,
 	pipe() {
 		return require_Schema.pipeArguments(this, arguments);
 	}
@@ -4296,7 +4296,7 @@ const fromChannel$2 = (channel) => {
 };
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/Sink.js
-const TypeId$5 = "~effect/Sink";
+const TypeId$6 = "~effect/Sink";
 const endVoid = /* @__PURE__ */ require_Schema.succeed([void 0]);
 const sinkVariance = {
 	_A: require_Schema.identity,
@@ -4306,7 +4306,7 @@ const sinkVariance = {
 	_R: require_Schema.identity
 };
 const SinkProto = {
-	[TypeId$5]: sinkVariance,
+	[TypeId$6]: sinkVariance,
 	pipe() {
 		return require_Schema.pipeArguments(this, arguments);
 	}
@@ -4328,7 +4328,7 @@ const SinkProto = {
 * @since 2.0.0
 * @category guards
 */
-const isSink = (u) => require_Schema.hasProperty(u, TypeId$5);
+const isSink = (u) => require_Schema.hasProperty(u, TypeId$6);
 /**
 * Creates a sink from a `Channel`.
 *
@@ -4468,9 +4468,9 @@ const forEachArray = (f) => fromTransform((upstream) => upstream.pipe(require_Sc
 const unwrap$1 = (effect) => fromChannel$1(unwrap$2(require_Schema.map(effect, toChannel$1)));
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/MutableHashMap.js
-const TypeId$4 = "~effect/collections/MutableHashMap";
+const TypeId$5 = "~effect/collections/MutableHashMap";
 const MutableHashMapProto = {
-	[TypeId$4]: TypeId$4,
+	[TypeId$5]: TypeId$5,
 	[Symbol.iterator]() {
 		return this.backing[Symbol.iterator]();
 	},
@@ -4535,7 +4535,7 @@ const empty$1 = () => {
 * @since 2.0.0
 * @category constructors
 */
-const make$4 = (...entries) => fromIterable$1(entries);
+const make$5 = (...entries) => fromIterable$1(entries);
 /**
 * Creates a MutableHashMap from an iterable collection of key-value pairs.
 *
@@ -4587,7 +4587,7 @@ const fromIterable$1 = (entries) => {
 * @since 2.0.0
 * @category elements
 */
-const get$2 = /* @__PURE__ */ require_Schema.dual(2, (self, key) => {
+const get$3 = /* @__PURE__ */ require_Schema.dual(2, (self, key) => {
 	if (self.backing.has(key)) return require_Schema.some(self.backing.get(key));
 	else if (isSimpleKey(key)) return require_Schema.none();
 	const refKey = referentialKeysCache.get(self);
@@ -4608,6 +4608,27 @@ const getFromBucket = (self, bucket, key) => {
 	return require_Schema.none();
 };
 /**
+* Checks if the MutableHashMap contains the specified key.
+*
+* @example
+* ```ts
+* import * as MutableHashMap from "effect/MutableHashMap"
+*
+* const map = MutableHashMap.make(["key1", 42], ["key2", 100])
+*
+* console.log(MutableHashMap.has(map, "key1")) // true
+* console.log(MutableHashMap.has(map, "key3")) // false
+*
+* // Pipe-able version
+* const hasKey = MutableHashMap.has("key1")
+* console.log(hasKey(map)) // true
+* ```
+*
+* @since 2.0.0
+* @category elements
+*/
+const has = /* @__PURE__ */ require_Schema.dual(2, (self, key) => require_Schema.isSome(get$3(self, key)));
+/**
 * Sets a key-value pair in the MutableHashMap, mutating the map in place.
 * If the key already exists, its value is updated.
 *
@@ -4723,6 +4744,41 @@ const remove = /* @__PURE__ */ require_Schema.dual(2, (self, key_) => {
 	return self;
 });
 /**
+* Removes all key-value pairs from the MutableHashMap, mutating the map in place.
+* The map becomes empty after this operation.
+*
+* @example
+* ```ts
+* import * as MutableHashMap from "effect/MutableHashMap"
+*
+* const map = MutableHashMap.make(
+*   ["key1", 42],
+*   ["key2", 100],
+*   ["key3", 200]
+* )
+*
+* console.log(MutableHashMap.size(map)) // 3
+*
+* // Clear all entries
+* MutableHashMap.clear(map)
+*
+* console.log(MutableHashMap.size(map)) // 0
+* console.log(MutableHashMap.has(map, "key1")) // false
+*
+* // Can still add new entries after clearing
+* MutableHashMap.set(map, "new", 999)
+* console.log(MutableHashMap.size(map)) // 1
+* ```
+*
+* @since 2.0.0
+* @category mutations
+*/
+const clear = (self) => {
+	self.backing.clear();
+	self.buckets.clear();
+	return self;
+};
+/**
 * Returns the number of key-value pairs in the MutableHashMap.
 *
 * @example
@@ -4748,6 +4804,165 @@ const remove = /* @__PURE__ */ require_Schema.dual(2, (self, key_) => {
 */
 const size = (self) => self.backing.size;
 //#endregion
+//#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/RcMap.js
+/**
+* @since 3.5.0
+*/
+const TypeId$4 = "~effect/RcMap";
+const makeUnsafe = (options) => ({
+	[TypeId$4]: TypeId$4,
+	lookup: options.lookup,
+	context: options.context,
+	scope: options.scope,
+	idleTimeToLive: options.idleTimeToLive,
+	capacity: options.capacity,
+	state: {
+		_tag: "Open",
+		map: empty$1()
+	},
+	pipe() {
+		return require_Schema.pipeArguments(this, arguments);
+	}
+});
+/**
+* An `RcMap` can contain multiple reference counted resources that can be indexed
+* by a key. The resources are lazily acquired on the first call to `get` and
+* released when the last reference is released.
+*
+* Complex keys can extend `Equal` and `Hash` to allow lookups by value.
+*
+* **Options**
+*
+* - `capacity`: The maximum number of resources that can be held in the map.
+* - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
+*
+* @since 3.5.0
+* @category models
+* @example
+* ```ts
+* import { Effect, RcMap } from "effect"
+*
+* Effect.gen(function*() {
+*   const map = yield* RcMap.make({
+*     lookup: (key: string) =>
+*       Effect.acquireRelease(
+*         Effect.succeed(`acquired ${key}`),
+*         () => Effect.log(`releasing ${key}`)
+*       )
+*   })
+*
+*   // Get "foo" from the map twice, which will only acquire it once.
+*   // It will then be released once the scope closes.
+*   yield* RcMap.get(map, "foo").pipe(
+*     Effect.andThen(RcMap.get(map, "foo")),
+*     Effect.scoped
+*   )
+* })
+* ```
+*/
+const make$4 = (options) => require_Schema.withFiber((fiber) => {
+	const context = fiber.context;
+	const scope = require_Schema.get(context, require_Schema.Scope);
+	const self = makeUnsafe({
+		lookup: options.lookup,
+		context,
+		scope,
+		idleTimeToLive: typeof options.idleTimeToLive === "function" ? require_Schema.flow(options.idleTimeToLive, require_Schema.fromInputUnsafe) : require_Schema.constant(require_Schema.fromInputUnsafe(options.idleTimeToLive ?? require_Schema.zero)),
+		capacity: Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
+	});
+	return require_Schema.as(require_Schema.addFinalizerExit(scope, () => {
+		if (self.state._tag === "Closed") return require_Schema.void_;
+		const map = self.state.map;
+		self.state = { _tag: "Closed" };
+		return require_Schema.forEach(map, ([, entry]) => require_Schema.exit(require_Schema.close(entry.scope, require_Schema.void_$1))).pipe(require_Schema.tap(() => require_Schema.sync(() => {
+			clear(map);
+		})));
+	}), self);
+});
+/**
+* Retrieves a value from the RcMap by key. If the resource doesn't exist, it will be
+* acquired using the lookup function. The resource is reference counted and will be
+* released when the scope closes.
+*
+* @since 3.5.0
+* @category combinators
+* @example
+* ```ts
+* import { Effect, RcMap } from "effect"
+*
+* Effect.gen(function*() {
+*   const map = yield* RcMap.make({
+*     lookup: (key: string) =>
+*       Effect.acquireRelease(
+*         Effect.succeed(`Resource: ${key}`),
+*         () => Effect.log(`Released ${key}`)
+*       )
+*   })
+*
+*   // Get a resource - it will be acquired on first access
+*   const resource = yield* RcMap.get(map, "database")
+*   console.log(resource) // "Resource: database"
+* }).pipe(Effect.scoped)
+* ```
+*/
+const get$2 = /* @__PURE__ */ require_Schema.dual(2, (self, key) => require_Schema.uninterruptibleMask((restore) => {
+	if (self.state._tag === "Closed") return require_Schema.interrupt;
+	const state = self.state;
+	const parent = getCurrent();
+	const o = get$3(state.map, key);
+	let entry;
+	if (o._tag === "Some") {
+		entry = o.value;
+		entry.refCount++;
+	} else if (Number.isFinite(self.capacity) && size(self.state.map) >= self.capacity) return require_Schema.fail(new require_Schema.ExceededCapacityError(`RcMap attempted to exceed capacity of ${self.capacity}`));
+	else {
+		entry = {
+			deferred: require_Schema.makeUnsafe$2(),
+			scope: require_Schema.makeUnsafe$1(),
+			idleTimeToLive: self.idleTimeToLive(key),
+			finalizer: void 0,
+			fiber: void 0,
+			expiresAt: 0,
+			refCount: 1
+		};
+		entry.finalizer = release(self, key, entry);
+		set(state.map, key, entry);
+		const context = new Map(self.context.mapUnsafe);
+		parent.context.mapUnsafe.forEach((value, key) => {
+			context.set(key, value);
+		});
+		context.set(require_Schema.Scope.key, entry.scope);
+		self.lookup(key).pipe(require_Schema.runForkWith(require_Schema.makeUnsafe$3(context)), runIn(entry.scope)).addObserver((exit) => require_Schema.doneUnsafe(entry.deferred, exit));
+	}
+	const scope = require_Schema.getUnsafe(parent.context, require_Schema.Scope);
+	return require_Schema.addFinalizer$1(scope, entry.finalizer).pipe(require_Schema.andThen(restore(require_Schema._await(entry.deferred))));
+}));
+const release = (self, key, entry) => require_Schema.withFiber((fiber) => {
+	entry.refCount--;
+	if (entry.refCount > 0) return require_Schema.void_;
+	else if (self.state._tag === "Closed" || !has(self.state.map, key) || require_Schema.isZero(entry.idleTimeToLive)) {
+		if (self.state._tag === "Open") remove(self.state.map, key);
+		return require_Schema.close(entry.scope, require_Schema.void_$1);
+	} else if (!require_Schema.isFinite$1(entry.idleTimeToLive)) return require_Schema.void_;
+	const clock = fiber.getRef(require_Schema.Clock);
+	entry.expiresAt = clock.currentTimeMillisUnsafe() + require_Schema.toMillis(entry.idleTimeToLive);
+	if (entry.fiber) return require_Schema.void_;
+	entry.fiber = require_Schema.interruptibleMask(function loop(restore) {
+		const now = clock.currentTimeMillisUnsafe();
+		const remaining = entry.expiresAt - now;
+		if (remaining <= 0) {
+			if (self.state._tag === "Closed" || entry.refCount > 0) return require_Schema.void_;
+			remove(self.state.map, key);
+			return restore(require_Schema.close(entry.scope, require_Schema.void_$1));
+		}
+		return require_Schema.flatMap(clock.sleep(require_Schema.millis(remaining)), () => loop(restore));
+	}).pipe(require_Schema.ensuring(require_Schema.sync(() => {
+		entry.fiber = void 0;
+	})), require_Schema.runForkWith(fiber.context), runIn(self.scope));
+	return require_Schema.void_;
+});
+require_Schema.uninterruptible;
+//#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/internal/rcRef.js
 const TypeId$3 = "~effect/RcRef";
 const stateEmpty = { _tag: "Empty" };
@@ -4762,7 +4977,7 @@ var RcRefImpl = class {
 		return require_Schema.pipeArguments(this, arguments);
 	}
 	state = stateEmpty;
-	semaphore = /* @__PURE__ */ makeUnsafe(1);
+	semaphore = /* @__PURE__ */ makeUnsafe$1(1);
 	acquire;
 	context;
 	scope;
@@ -5908,9 +6123,9 @@ const debounce = /* @__PURE__ */ require_Schema.dual(2, (self, duration) => tran
 	let lastArr;
 	let cause;
 	let emitAtMs = Infinity;
-	const pullLatch = makeUnsafe$1();
-	const emitLatch = makeUnsafe$1();
-	const endLatch = makeUnsafe$1();
+	const pullLatch = makeUnsafe$2();
+	const emitLatch = makeUnsafe$2();
+	const endLatch = makeUnsafe$2();
 	yield* pull.pipe(pullLatch.whenOpen, require_Schema.flatMap((arr) => {
 		emitLatch.openUnsafe();
 		lastArr = arr;
@@ -6408,7 +6623,7 @@ const mkUint8Array = (self) => runFold$1(self.channel, () => new Uint8Array(0),
 const toReadableStreamWith = /* @__PURE__ */ require_Schema.dual((args) => isStream(args[0]), (self, context, options) => {
 	let currentResolve = void 0;
 	let fiber = void 0;
-	const latch = makeUnsafe$1(false);
+	const latch = makeUnsafe$2(false);
 	return new ReadableStream({
 		start(controller) {
 			fiber = require_Schema.runFork(require_Schema.provideContext(runForEachArray(self, (chunk) => latch.whenOpen(require_Schema.sync(() => {
@@ -7434,6 +7649,12 @@ Object.defineProperty(exports, "get$1", {
 		return get$2;
 	}
 });
+Object.defineProperty(exports, "get$2", {
+	enumerable: true,
+	get: function() {
+		return get$3;
+	}
+});
 Object.defineProperty(exports, "getCurrent", {
 	enumerable: true,
 	get: function() {
@@ -7503,19 +7724,25 @@ Object.defineProperty(exports, "make$5", {
 Object.defineProperty(exports, "make$6", {
 	enumerable: true,
 	get: function() {
-		return make$8;
+		return make$7;
+	}
+});
+Object.defineProperty(exports, "make$7", {
+	enumerable: true,
+	get: function() {
+		return make$9;
 	}
 });
 Object.defineProperty(exports, "makeUnsafe", {
 	enumerable: true,
 	get: function() {
-		return makeUnsafe;
+		return makeUnsafe$1;
 	}
 });
 Object.defineProperty(exports, "makeUnsafe$1", {
 	enumerable: true,
 	get: function() {
-		return makeUnsafe$1;
+		return makeUnsafe$2;
 	}
 });
 Object.defineProperty(exports, "map", {
@@ -7819,4 +8046,4 @@ Object.defineProperty(exports, "unwrap", {
 	}
 });
 
-//# sourceMappingURL=Path-CHDjKLrB.cjs.map
+//# sourceMappingURL=Path-Be7zSwar.cjs.map