@athrio/loom 0.0.9 → 0.0.10

package/dist/Cache-Dv3Qogvb.js

@@ -0,0 +1,1048 @@
+#!/usr/bin/env node
+import { r as __exportAll } from "./rolldown-runtime-YU9U6SYh.js";
+import { Ao as make$1, Bd as succeedNone, Cm as isExit, Dh as dual, Do as get$1, Ef as merge, Jd as updateContext, Ju as ClockRef, Md as onExit, Mo as set$1, No as size$1, Np as failVoid, Op as map$1, Qp as isSome, Rp as succeed$1, Tp as filterMap, Ud as sync, Vd as succeedSome, Yd as void_, Zp as isNone, _u as makeUnsafe, cf as infinity, du as _await, fd as exitIsFailure, id as catchCause, jd as map, jo as remove, ld as contextWith, lf as isFinite, pd as exitIsSuccess, pf as toMillis, pu as doneUnsafe, rd as asSome, sf as fromInputUnsafe, uf as isZero, wm as withFiber, wo as clear, xm as exitSucceed, ym as PipeInspectableProto, zd as succeed } from "./SqlClient-BHo_uVyk.js";
+//#region ../../node_modules/effect/dist/Cache.js
+/**
+* Caches values loaded by an Effect lookup function.
+*
+* A cache stores successful and failed lookup results, shares an in-progress
+* lookup when multiple callers request the same missing key, and limits entries
+* by capacity and optional time-to-live rules. This module includes helpers for
+* reading, setting, refreshing, invalidating, and inspecting cache contents.
+*
+* @since 4.0.0
+*/
+var Cache_exports = /* @__PURE__ */ __exportAll({
+	entries: () => entries,
+	get: () => get,
+	getOption: () => getOption,
+	getSuccess: () => getSuccess,
+	has: () => has,
+	invalidate: () => invalidate,
+	invalidateAll: () => invalidateAll,
+	invalidateWhen: () => invalidateWhen,
+	keys: () => keys,
+	make: () => make,
+	makeWith: () => makeWith,
+	refresh: () => refresh,
+	set: () => set,
+	size: () => size,
+	values: () => values
+});
+var TypeId = "~effect/Cache";
+/**
+* Creates a cache with dynamic time-to-live based on the result and key.
+*
+* **When to use**
+*
+* Use when you need different cache entry lifetimes based on the lookup result
+* or key characteristics.
+*
+* **Details**
+*
+* The timeToLive function receives both the exit result and the key, allowing
+* for flexible TTL policies based on success/failure state and key characteristics.
+*
+* **Example** (Configuring dynamic time to live)
+*
+* ```ts
+* import { Cache, Effect, Exit } from "effect"
+*
+* // Cache with TTL based on computed value
+* const userCache = Effect.gen(function*() {
+*   const cache = yield* Cache.makeWith(
+*     (id: number) => Effect.succeed({ id, active: id % 2 === 0 }),
+*     {
+*       capacity: 1000,
+*       timeToLive(exit) {
+*         if (Exit.isSuccess(exit)) {
+*           const user = exit.value
+*           return user.active ? "1 hour" : "5 minutes"
+*         }
+*         return "30 seconds"
+*       }
+*     }
+*   )
+*
+*   return cache
+* })
+* ```
+*
+* @see {@link make} for a simpler cache constructor with a fixed time-to-live for all entries
+* @category constructors
+* @since 2.0.0
+*/
+var makeWith = (lookup, options) => contextWith((context) => {
+	const self = Object.create(Proto);
+	self.lookup = (key) => updateContext(lookup(key), (input) => merge(context, input));
+	self.map = make$1();
+	self.capacity = options.capacity;
+	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
+	return succeed(self);
+});
+/**
+* Creates a cache with a fixed time-to-live for all entries.
+*
+* **Details**
+*
+* This is the basic cache constructor where all entries share the same TTL.
+* The lookup function will be called when a key is not found or has expired.
+*
+* **Example** (Creating a basic cache)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Basic cache with string keys
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number>({
+*     capacity: 100,
+*     lookup: (key) => Effect.succeed(key.length)
+*   })
+*
+*   const result1 = yield* Cache.get(cache, "hello")
+*   const result2 = yield* Cache.get(cache, "world")
+*   console.log({ result1, result2 }) // { result1: 5, result2: 5 }
+* })
+* ```
+*
+* **Example** (Creating a cache with TTL)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const users = new Map([
+*     [123, { name: "Ada", email: "ada@example.com" }],
+*     [456, { name: "Grace", email: "grace@example.com" }]
+*   ])
+*
+*   const cache = yield* Cache.make<
+*     number,
+*     { name: string; email: string },
+*     string
+*   >({
+*     capacity: 500,
+*     lookup: (userId) =>
+*       Effect.suspend(() => {
+*         const user = users.get(userId)
+*         return user === undefined
+*           ? Effect.fail(`User ${userId} not found`)
+*           : Effect.succeed(user)
+*       }),
+*     timeToLive: "15 minutes"
+*   })
+*
+*   const user1 = yield* Cache.get(cache, 123)
+*   console.log(user1) // { name: "Ada", email: "ada@example.com" }
+*
+*   const user2 = yield* Cache.get(cache, 123)
+*   console.log(user2) // { name: "Ada", email: "ada@example.com" }
+* })
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+var make = (options) => makeWith(options.lookup, {
+	...options,
+	timeToLive: options.timeToLive ? () => options.timeToLive : defaultTimeToLive
+});
+var Proto = {
+	...PipeInspectableProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "Cache",
+			capacity: this.capacity,
+			map: this.map
+		};
+	}
+};
+var defaultTimeToLive = (_, _key) => infinity;
+/**
+* Retrieves the value for a key, invoking the lookup function on a cache miss
+* or expired entry.
+*
+* **Details**
+*
+* Concurrent `get` calls for the same missing key share the same pending
+* lookup. The cache stores the lookup `Exit`, so failed lookups are cached and
+* will fail again until the entry expires, is invalidated, or is refreshed.
+*
+* **Example** (Getting cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Cache miss - triggers lookup function
+*   const result1 = yield* Cache.get(cache, "hello")
+*   console.log(result1) // 5
+*
+*   // Cache hit - returns cached value without lookup
+*   const result2 = yield* Cache.get(cache, "hello")
+*   console.log(result2) // 5 (from cache)
+*
+*   return { result1, result2 }
+* })
+* ```
+*
+* **Example** (Handling lookup failures)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Error handling when lookup fails
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number, string>({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       key === "error"
+*         ? Effect.fail("Lookup failed")
+*         : Effect.succeed(key.length)
+*   })
+*
+*   // Successful lookup
+*   const success = yield* Cache.get(cache, "hello")
+*   console.log(success) // 5
+*
+*   // Failed lookup - returns error
+*   const failure = yield* Effect.exit(Cache.get(cache, "error"))
+*   console.log(failure) // Exit.fail("Lookup failed")
+* })
+* ```
+*
+* **Example** (Sharing concurrent lookups)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Concurrent access - multiple gets of same key only invoke lookup once
+* const program = Effect.gen(function*() {
+*   let lookupCount = 0
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   // Multiple concurrent gets
+*   const results = yield* Effect.all([
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello")
+*   ], { concurrency: "unbounded" })
+*
+*   console.log(results) // [5, 5, 5]
+*   console.log(lookupCount) // 1 (lookup called only once)
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var get = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const oentry = get$1(self.map, key);
+	if (isSome(oentry) && !hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		set$1(self.map, key, oentry.value);
+		return _await(oentry.value.deferred);
+	}
+	const deferred = makeUnsafe();
+	const entry = {
+		expiresAt: void 0,
+		deferred
+	};
+	set$1(self.map, key, entry);
+	if (Number.isFinite(self.capacity)) checkCapacity(self);
+	return onExit(self.lookup(key), (exit) => {
+		doneUnsafe(deferred, exit);
+		const ttl = self.timeToLive(exit, key);
+		if (isFinite(ttl)) entry.expiresAt = fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl);
+		else if (isZero(ttl)) remove(self.map, key);
+		return void_;
+	});
+}));
+var hasExpired = (entry, fiber) => {
+	if (entry.expiresAt === void 0) return false;
+	return fiber.getRef(ClockRef).currentTimeMillisUnsafe() >= entry.expiresAt;
+};
+var checkCapacity = (self) => {
+	let diff = size$1(self.map) - self.capacity;
+	if (diff <= 0) return;
+	for (const [key] of self.map) {
+		remove(self.map, key);
+		diff--;
+		if (diff === 0) return;
+	}
+};
+/**
+* Reads an existing cache entry without invoking the lookup function.
+*
+* **Details**
+*
+* Returns `Option.none()` when the key is missing or expired, and `Option.some`
+* when a cached lookup has succeeded. If the entry is still pending, waits for
+* it to complete. If the cached or pending lookup fails, this effect fails with
+* the same error.
+*
+* **Example** (Reading cached values without lookup)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // No value in cache yet - returns None without lookup
+*   const empty = yield* Cache.getOption(cache, "hello")
+*   console.log(empty) // Option.none()
+*
+*   // Populate cache using get
+*   yield* Cache.get(cache, "hello")
+*
+*   // Now getOption returns the cached value
+*   const cached = yield* Cache.getOption(cache, "hello")
+*   console.log(cached) // Option.some(5)
+*
+*   return { empty, cached }
+* })
+* ```
+*
+* **Example** (Skipping expired entries)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // Expired entries return None
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Add value to cache
+*   yield* Cache.get(cache, "hello")
+*
+*   // Value exists before expiration
+*   const beforeExpiry = yield* Cache.getOption(cache, "hello")
+*   console.log(beforeExpiry) // Option.some(5)
+*
+*   // Simulate time passing
+*   yield* TestClock.adjust("2 hours")
+*
+*   // Value expired - returns None
+*   const afterExpiry = yield* Cache.getOption(cache, "hello")
+*   console.log(afterExpiry) // Option.none()
+* })
+* ```
+*
+* **Example** (Waiting for pending lookups)
+*
+* ```ts
+* import { Cache, Deferred, Effect, Fiber } from "effect"
+*
+* // Waits for ongoing computation to complete
+* const program = Effect.gen(function*() {
+*   const deferred = yield* Deferred.make<void>()
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (_key: string) => Deferred.await(deferred).pipe(Effect.as(42))
+*   })
+*
+*   // Start lookup in background
+*   const getFiber = yield* Effect.forkChild(Cache.get(cache, "key"))
+*
+*   // getOption waits for ongoing computation
+*   const optionFiber = yield* Effect.forkChild(Cache.getOption(cache, "key"))
+*
+*   // Complete the computation
+*   yield* Deferred.succeed(deferred, void 0)
+*
+*   const result = yield* Fiber.join(optionFiber)
+*   console.log(result) // Option.some(42)
+*
+*   const value = yield* Fiber.join(getFiber)
+*   console.log(value) // 42
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var getOption = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const entry = getImpl(self, key, fiber);
+	return entry ? asSome(_await(entry.deferred)) : succeedNone;
+}));
+var getImpl = (self, key, fiber, isRead = true) => {
+	const oentry = get$1(self.map, key);
+	if (isNone(oentry)) return;
+	else if (hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		return;
+	} else if (isRead) {
+		remove(self.map, key);
+		set$1(self.map, key, oentry.value);
+	}
+	return oentry.value;
+};
+/**
+* Retrieves the value associated with the specified key from the cache, only if
+* it contains a resolved successful value.
+*
+* **Details**
+*
+* This checks only an existing non-expired entry. It returns `Option.some` when
+* the entry has already resolved successfully, and `Option.none` for missing,
+* expired, failed, or still-pending entries.
+*
+* @see {@link get} for triggering or awaiting the cache lookup
+* @see {@link getOption} for reading an existing entry as an optional effect
+*
+* @category combinators
+* @since 4.0.0
+*/
+var getSuccess = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const exit = getImpl(self, key, fiber)?.deferred.effect;
+	if (exit && exitIsSuccess(exit)) return succeedSome(exit.value);
+	return succeedNone;
+}));
+/**
+* Sets the value associated with the specified key in the cache. This will
+* overwrite any existing value for that key, skipping the lookup function.
+*
+* **Example** (Setting values directly)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Set a value directly without invoking lookup
+*   yield* Cache.set(cache, "hello", 42)
+*   const result = yield* Cache.get(cache, "hello")
+*   console.log(result) // 42 (not 5 from lookup)
+* })
+* ```
+*
+* **Example** (Overwriting cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Overwriting existing cached values
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // First get populates via lookup
+*   const original = yield* Cache.get(cache, "test") // 4
+*
+*   // Set overwrites the cached value
+*   yield* Cache.set(cache, "test", 999)
+*   const updated = yield* Cache.get(cache, "test") // 999
+*
+*   console.log({ original, updated })
+* })
+* ```
+*
+* **Example** (Applying TTL to set values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // TTL behavior with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Set value with TTL applied
+*   yield* Cache.set(cache, "temporary", 123)
+*   console.log(yield* Cache.has(cache, "temporary")) // true
+*
+*   // Advance time past TTL
+*   yield* TestClock.adjust("2 hours")
+*   console.log(yield* Cache.has(cache, "temporary")) // false
+* })
+* ```
+*
+* **Example** (Enforcing capacity when setting values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Capacity enforcement with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 2,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Fill cache to capacity
+*   yield* Cache.set(cache, "a", 1)
+*   yield* Cache.set(cache, "b", 2)
+*   console.log(yield* Cache.size(cache)) // 2
+*
+*   // Adding another entry evicts oldest
+*   yield* Cache.set(cache, "c", 3)
+*   console.log(yield* Cache.size(cache)) // 2
+*   console.log(yield* Cache.has(cache, "a")) // false (evicted)
+*   console.log(yield* Cache.has(cache, "c")) // true
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var set = /*#__PURE__*/ dual(3, (self, key, value) => withFiber((fiber) => {
+	const exit = exitSucceed(value);
+	const deferred = makeUnsafe();
+	doneUnsafe(deferred, exit);
+	const ttl = self.timeToLive(exit, key);
+	if (isZero(ttl)) {
+		remove(self.map, key);
+		return void_;
+	}
+	set$1(self.map, key, {
+		deferred,
+		expiresAt: isFinite(ttl) ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl) : void 0
+	});
+	checkCapacity(self);
+	return void_;
+}));
+/**
+* Checks whether the cache contains an entry for the specified key.
+*
+* **Details**
+*
+* This checks for an existing non-expired entry without invoking the cache
+* lookup function. Expired entries are treated as absent.
+*
+* **Example** (Checking for cached keys)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Check non-existent key
+*   console.log(yield* Cache.has(cache, "missing")) // false
+*
+*   // Add entry and check existence
+*   yield* Cache.get(cache, "hello")
+*   console.log(yield* Cache.has(cache, "hello")) // true
+* })
+* ```
+*
+* **Example** (Checking TTL expiration)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // TTL expiration behavior
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Add entry with TTL
+*   yield* Cache.get(cache, "expires")
+*   console.log(yield* Cache.has(cache, "expires")) // true
+*
+*   // Still valid before expiration
+*   yield* TestClock.adjust("30 minutes")
+*   console.log(yield* Cache.has(cache, "expires")) // true
+*
+*   // Expired after TTL
+*   yield* TestClock.adjust("31 minutes")
+*   console.log(yield* Cache.has(cache, "expires")) // false
+* })
+* ```
+*
+* **Example** (Checking multiple keys)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Checking multiple keys efficiently
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Populate some entries
+*   yield* Cache.set(cache, "apple", 5)
+*   yield* Cache.set(cache, "banana", 6)
+*
+*   // Check multiple keys
+*   const keys = ["apple", "banana", "cherry", "date"]
+*   for (const key of keys) {
+*     const exists = yield* Cache.has(cache, key)
+*     console.log(`${key}: ${exists}`)
+*   }
+*   // Output:
+*   // apple: true
+*   // banana: true
+*   // cherry: false
+*   // date: false
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var has = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	return succeed(getImpl(self, key, fiber, false) !== void 0);
+}));
+/**
+* Invalidates the entry associated with the specified key in the cache.
+*
+* **Example** (Invalidating cached entries)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add a value to the cache
+*   yield* Cache.get(cache, "hello")
+*   console.log(yield* Cache.has(cache, "hello")) // true
+*
+*   // Invalidate the entry
+*   yield* Cache.invalidate(cache, "hello")
+*   console.log(yield* Cache.has(cache, "hello")) // false
+*
+*   // Invalidating non-existent keys doesn't error
+*   yield* Cache.invalidate(cache, "nonexistent")
+*
+*   // Get after invalidation will invoke lookup again
+*   let lookupCount = 0
+*   const cache2 = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   yield* Cache.get(cache2, "test") // lookupCount = 1
+*   yield* Cache.invalidate(cache2, "test")
+*   yield* Cache.get(cache2, "test") // lookupCount = 2 (lookup called again)
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var invalidate = /*#__PURE__*/ dual(2, (self, key) => sync(() => {
+	remove(self.map, key);
+}));
+/**
+* Invalidates the entry associated with the specified key in the cache when the
+* predicate returns true for the cached value.
+*
+* **Example** (Invalidating entries conditionally)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add values to the cache
+*   yield* Cache.get(cache, "hello") // value = 5
+*   yield* Cache.get(cache, "hi") // value = 2
+*
+*   // Invalidate when value equals 5
+*   const invalidated1 = yield* Cache.invalidateWhen(
+*     cache,
+*     "hello",
+*     (value) => value === 5
+*   )
+*   console.log(invalidated1) // true
+*   console.log(yield* Cache.has(cache, "hello")) // false
+*
+*   // Don't invalidate when predicate doesn't match
+*   const invalidated2 = yield* Cache.invalidateWhen(
+*     cache,
+*     "hi",
+*     (value) => value === 5
+*   )
+*   console.log(invalidated2) // false
+*   console.log(yield* Cache.has(cache, "hi")) // true (still present)
+*
+*   // Returns false for non-existent keys
+*   const invalidated3 = yield* Cache.invalidateWhen(
+*     cache,
+*     "nonexistent",
+*     () => true
+*   )
+*   console.log(invalidated3) // false
+*
+*   // Returns false for failed cached values
+*   const cacheWithErrors = yield* Cache.make<string, number, string>({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       key === "fail" ? Effect.fail("error") : Effect.succeed(key.length)
+*   })
+*
+*   yield* Effect.exit(Cache.get(cacheWithErrors, "fail"))
+*   const invalidated4 = yield* Cache.invalidateWhen(
+*     cacheWithErrors,
+*     "fail",
+*     () => true
+*   )
+*   console.log(invalidated4) // false (can't invalidate failed values)
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var invalidateWhen = /*#__PURE__*/ dual(3, (self, key, f) => withFiber((fiber) => {
+	const oentry = getImpl(self, key, fiber, false);
+	if (oentry === void 0) return succeed(false);
+	return _await(oentry.deferred).pipe(map((value) => {
+		if (f(value)) {
+			remove(self.map, key);
+			return true;
+		}
+		return false;
+	}), catchCause(() => succeed(false)));
+}));
+/**
+* Forces a refresh of the value associated with the specified key in the cache.
+*
+* **Details**
+*
+* It will always invoke the lookup function to construct a new value,
+* overwriting any existing value for that key.
+*
+* **Example** (Refreshing cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Force refresh of existing cached values
+* const program = Effect.gen(function*() {
+*   let counter = 0
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.sync(() => `${key}-${++counter}`)
+*   })
+*
+*   // Initial cache population
+*   const value1 = yield* Cache.get(cache, "user")
+*   console.log(value1) // "user-1"
+*
+*   // Get from cache (no lookup)
+*   const value2 = yield* Cache.get(cache, "user")
+*   console.log(value2) // "user-1" (same value)
+*
+*   // Force refresh - always calls lookup
+*   const refreshed = yield* Cache.refresh(cache, "user")
+*   console.log(refreshed) // "user-2" (new value)
+*
+*   // Subsequent gets return refreshed value
+*   const value3 = yield* Cache.get(cache, "user")
+*   console.log(value3) // "user-2"
+* })
+* ```
+*
+* **Example** (Resetting TTL on refresh)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // Refresh resets TTL (Time To Live)
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   yield* Cache.get(cache, "test")
+*   yield* TestClock.adjust("45 minutes")
+*
+*   // Entry would normally expire in 15 minutes
+*   console.log(yield* Cache.has(cache, "test")) // true
+*
+*   // Refresh resets the TTL to full 1 hour
+*   yield* Cache.refresh(cache, "test")
+*   yield* TestClock.adjust("30 minutes")
+*
+*   // Still valid because TTL was reset
+*   console.log(yield* Cache.has(cache, "test")) // true
+* })
+* ```
+*
+* **Example** (Refreshing missing keys)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Refresh non-existent keys
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(`value-for-${key}`)
+*   })
+*
+*   // Refresh non-existent key creates new entry
+*   const result = yield* Cache.refresh(cache, "newKey")
+*   console.log(result) // "value-for-newKey"
+*
+*   // Verify it's now cached
+*   console.log(yield* Cache.has(cache, "newKey")) // true
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var refresh = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const deferred = makeUnsafe();
+	const entry = {
+		expiresAt: void 0,
+		deferred
+	};
+	const existing = getImpl(self, key, fiber, false) !== void 0;
+	if (!existing) {
+		set$1(self.map, key, entry);
+		checkCapacity(self);
+	}
+	return onExit(self.lookup(key), (exit) => {
+		doneUnsafe(deferred, exit);
+		const ttl = self.timeToLive(exit, key);
+		if (isZero(ttl)) {
+			remove(self.map, key);
+			return void_;
+		}
+		entry.expiresAt = isFinite(ttl) ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl) : void 0;
+		if (existing) set$1(self.map, key, entry);
+		return void_;
+	});
+}));
+/**
+* Invalidates all entries in the cache.
+*
+* **Example** (Invalidating all entries)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Clear all cached entries at once
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Populate cache with multiple entries
+*   yield* Cache.get(cache, "apple")
+*   yield* Cache.get(cache, "banana")
+*   yield* Cache.get(cache, "cherry")
+*
+*   console.log(yield* Cache.size(cache)) // 3
+*   console.log(yield* Cache.has(cache, "apple")) // true
+*
+*   // Clear all entries
+*   yield* Cache.invalidateAll(cache)
+*
+*   // Verify cache is empty
+*   console.log(yield* Cache.size(cache)) // 0
+*   console.log(yield* Cache.has(cache, "apple")) // false
+*   console.log(yield* Cache.has(cache, "banana")) // false
+*   console.log(yield* Cache.has(cache, "cherry")) // false
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var invalidateAll = (self) => sync(() => {
+	clear(self.map);
+});
+/**
+* Retrieves the approximate number of entries in the cache.
+*
+* **Details**
+*
+* Note that expired entries are counted until they are accessed and removed.
+* The size reflects the current number of entries stored, not the number
+* of valid entries.
+*
+* **Example** (Reading cache size)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Empty cache has size 0
+*   const emptySize = yield* Cache.size(cache)
+*   console.log(emptySize) // 0
+*
+*   // Add entries and check size
+*   yield* Cache.get(cache, "hello")
+*   yield* Cache.get(cache, "world")
+*   const sizeAfterAdding = yield* Cache.size(cache)
+*   console.log(sizeAfterAdding) // 2
+*
+*   // Size decreases after invalidation
+*   yield* Cache.invalidate(cache, "hello")
+*   const sizeAfterInvalidation = yield* Cache.size(cache)
+*   console.log(sizeAfterInvalidation) // 1
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var size = (self) => sync(() => size$1(self.map));
+/**
+* Retrieves all active keys from the cache, automatically filtering out expired entries.
+*
+* **Example** (Reading active keys)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Basic key enumeration
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add some entries to the cache
+*   yield* Cache.get(cache, "hello")
+*   yield* Cache.get(cache, "world")
+*   yield* Cache.get(cache, "cache")
+*
+*   // Retrieve all active keys
+*   const keys = yield* Cache.keys(cache)
+*
+*   console.log(Array.from(keys).sort()) // ["cache", "hello", "world"]
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var keys = (self) => withFiber((fiber) => {
+	const now = fiber.getRef(ClockRef).currentTimeMillisUnsafe();
+	return succeed(filterMap(self.map, ([key, entry]) => {
+		if (entry.expiresAt === void 0 || entry.expiresAt > now) return succeed$1(key);
+		remove(self.map, key);
+		return failVoid;
+	}));
+});
+/**
+* Retrieves all successfully cached values from the cache, excluding failed
+* lookups and expired entries.
+*
+* **Example** (Reading all cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add some values to the cache
+*   yield* Cache.get(cache, "a")
+*   yield* Cache.get(cache, "ab")
+*   yield* Cache.get(cache, "abc")
+*
+*   // Retrieve all cached values
+*   const values = yield* Cache.values(cache)
+*   const valuesArray = Array.from(values).sort()
+*
+*   console.log(valuesArray) // [1, 2, 3]
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var values = (self) => map(entries(self), map$1(([, value]) => value));
+/**
+* Retrieves all key-value pairs from the cache as an iterable. This function
+* only returns entries with successfully resolved values, filtering out any
+* failed lookups or expired entries.
+*
+* **Gotchas**
+*
+* Expired entries are removed from the cache while `entries` filters them out.
+*
+* @see {@link keys} for retrieving only cached keys
+* @see {@link values} for retrieving only cached values
+*
+* @category combinators
+* @since 4.0.0
+*/
+var entries = (self) => withFiber((fiber) => {
+	const now = fiber.getRef(ClockRef).currentTimeMillisUnsafe();
+	return succeed(filterMap(self.map, ([key, entry]) => {
+		if (entry.expiresAt === void 0 || entry.expiresAt > now) {
+			const exit = entry.deferred.effect;
+			return !isExit(exit) || exitIsFailure(exit) ? failVoid : succeed$1([key, exit.value]);
+		}
+		remove(self.map, key);
+		return failVoid;
+	}));
+});
+//#endregion
+export { makeWith as i, get as n, make as r, Cache_exports as t };
+
+//# sourceMappingURL=Cache-Dv3Qogvb.js.map