@versori/run 0.2.29 → 0.3.0-veta.1

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.d.ts

@@ -0,0 +1,111 @@
+/**
+ * A cache suitable for use with {@linkcode memoize}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export type MemoizationCache<K, V> = {
+    has: (key: K) => boolean;
+    get: (key: K) => V | undefined;
+    set: (key: K, val: V) => unknown;
+    delete: (key: K) => unknown;
+};
+/**
+ * The result of a memoized function, as stored in its cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export type MemoizationCacheResult<T> = {
+    kind: "ok";
+    value: T;
+} | {
+    kind: "error";
+    error: unknown;
+} | (T extends Promise<unknown> ? {
+    kind: "promise";
+    value: T;
+} : never);
+/**
+ * Options for {@linkcode memoize}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ */
+export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>>> = {
+    /**
+     * Provide a custom cache for getting previous results. By default, a new
+     * {@linkcode Map} object is instantiated upon memoization and used as a cache, with no
+     * limit on the number of results to be cached.
+     *
+     * Alternatively, you can supply a {@linkcode LruCache} with a specified max
+     * size to limit memory usage.
+     */
+    cache?: Cache;
+    /**
+     * Function to get a unique cache key from the function's arguments. By
+     * default, a composite key is created from all the arguments plus the `this`
+     * value, using reference equality to check for equivalence.
+     *
+     * @example
+     * ```ts
+     * import { memoize } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const fn = memoize(({ value }: { cacheKey: number; value: number }) => {
+     *   return value;
+     * }, { getKey: ({ cacheKey }) => cacheKey });
+     *
+     * assertEquals(fn({ cacheKey: 1, value: 2 }), 2);
+     * assertEquals(fn({ cacheKey: 1, value: 99 }), 2);
+     * assertEquals(fn({ cacheKey: 2, value: 99 }), 99);
+     * ```
+     */
+    getKey?: (this: ThisParameterType<Fn>, ...args: Parameters<Fn>) => Key;
+    /**
+     * Callback to determine if an error or other thrown value is cacheable.
+     *
+     * @default {() => false}
+     *
+     * @param err The thrown error or other value.
+     * @returns `true` if the error is cacheable, `false` otherwise.
+     */
+    errorIsCacheable?: (err: unknown) => boolean;
+};
+/**
+ * Cache the results of a function based on its arguments.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ * @param fn The function to memoize
+ * @param options Options for memoization
+ *
+ * @returns The memoized function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { memoize } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * > [!NOTE]
+ * > * By default, memoization is on the basis of all arguments passed to the
+ * >   function, with equality determined by reference. This means that, for
+ * >   example, passing a memoized function as `arr.map(func)` will not use the
+ * >   cached results, as the index is implicitly passed as an argument. To
+ * >   avoid this, you can pass a custom `getKey` option or use the memoized
+ * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
+ */
+export declare function memoize<Fn extends (...args: never[]) => unknown, Key = string, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>> = Map<Key, MemoizationCacheResult<ReturnType<Fn>>>>(fn: Fn, options?: MemoizeOptions<Fn, Key, Cache>): Fn;
+//# sourceMappingURL=memoize.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/memoize.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI;IACnC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACzB,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAChC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,KAAK,CAAC,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACxB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,EACH,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,IACzE;IACF;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC;IACvE;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,OAAO,CACrB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,GAAG,MAAM,EACZ,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,GACzE,GAAG,CACD,GAAG,EACH,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CACvC,EAEH,EAAE,EAAE,EAAE,EACN,OAAO,CAAC,EAAE,cAAc,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GACvC,EAAE,CA+DJ"}

package/script/deps/jsr.io/@std/cache/0.2.0/memoize.js

@@ -0,0 +1,85 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = memoize;
+const _serialize_arg_list_js_1 = require("./_serialize_arg_list.js");
+/**
+ * Cache the results of a function based on its arguments.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ * @param fn The function to memoize
+ * @param options Options for memoization
+ *
+ * @returns The memoized function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { memoize } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * > [!NOTE]
+ * > * By default, memoization is on the basis of all arguments passed to the
+ * >   function, with equality determined by reference. This means that, for
+ * >   example, passing a memoized function as `arr.map(func)` will not use the
+ * >   cached results, as the index is implicitly passed as an argument. To
+ * >   avoid this, you can pass a custom `getKey` option or use the memoized
+ * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
+ */
+function memoize(fn, options) {
+    const cache = options?.cache ?? new Map();
+    const getKey = options?.getKey ??
+        (0, _serialize_arg_list_js_1._serializeArgList)(cache);
+    const errorIsCacheable = options?.errorIsCacheable ?? (() => false);
+    const memoized = function (...args) {
+        const key = getKey.apply(this, args);
+        if (cache.has(key)) {
+            const result = cache.get(key);
+            switch (result.kind) {
+                case "ok":
+                case "promise":
+                    return result.value;
+                case "error":
+                    throw result.error;
+            }
+        }
+        try {
+            let value = fn.apply(this, args);
+            if (value instanceof Promise) {
+                value = value.catch((reason) => {
+                    if (!errorIsCacheable(reason)) {
+                        cache.delete(key);
+                    }
+                    throw reason;
+                });
+                cache.set(key, { kind: "promise", value });
+            }
+            else {
+                cache.set(key, { kind: "ok", value });
+            }
+            return value;
+        }
+        catch (e) {
+            if (errorIsCacheable(e)) {
+                cache.set(key, { kind: "error", error: e });
+            }
+            throw e;
+        }
+    };
+    return Object.defineProperties(memoized, {
+        length: { value: fn.length },
+        name: { value: fn.name },
+    });
+}

package/script/deps/jsr.io/@std/cache/0.2.0/mod.d.ts

@@ -0,0 +1,24 @@
+/**
+ * In-memory cache utilities, such as memoization and caches with different
+ * expiration policies.
+ *
+ * ```ts
+ * import { memoize, LruCache, type MemoizationCacheResult } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const cache = new LruCache<string, MemoizationCacheResult<bigint>>(1000);
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * }, { cache });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * @module
+ */
+export * from "./lru_cache.js";
+export * from "./memoize.js";
+export * from "./ttl_cache.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/script/deps/jsr.io/@std/cache/0.2.0/mod.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * In-memory cache utilities, such as memoization and caches with different
+ * expiration policies.
+ *
+ * ```ts
+ * import { memoize, LruCache, type MemoizationCacheResult } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const cache = new LruCache<string, MemoizationCacheResult<bigint>>(1000);
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * }, { cache });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * @module
+ */
+__exportStar(require("./lru_cache.js"), exports);
+__exportStar(require("./memoize.js"), exports);
+__exportStar(require("./ttl_cache.js"), exports);

package/script/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts

@@ -0,0 +1,129 @@
+import type { MemoizationCache } from "./memoize.js";
+/**
+ * Time-to-live cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Automatically removes entries after the configured amount of time elapses.
+ *
+ * @typeParam K The type of the cache keys.
+ * @typeParam V The type of the cache values.
+ *
+ * @example Usage
+ * ```ts
+ * import { TtlCache } from "@std/cache/ttl-cache";
+ * import { assertEquals } from "@std/assert/equals";
+ * import { delay } from "@std/async/delay";
+ *
+ * const cache = new TtlCache<string, number>(1000);
+ *
+ * cache.set("a", 1);
+ * assertEquals(cache.size, 1);
+ * await delay(2000);
+ * assertEquals(cache.size, 0);
+ * ```
+ */
+export declare class TtlCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param defaultTtl The default time-to-live in milliseconds. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     */
+    constructor(defaultTtl: number);
+    /**
+     * Set a value in the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The cache key
+     * @param value The value to set
+     * @param ttl A custom time-to-live. If supplied, overrides the cache's
+     * default TTL for this entry. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     * @returns `this` for chaining.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { delay } from "@std/async/delay";
+     *
+     * const cache = new TtlCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assertEquals(cache.get("a"), 1);
+     *
+     * await delay(200);
+     * assertEquals(cache.get("a"), undefined);
+     * ```
+     */
+    set(key: K, value: V, ttl?: number): this;
+    /**
+     * Deletes the value associated with the given key.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to delete.
+     * @returns `true` if the key was deleted, `false` otherwise.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.delete("a");
+     * assertEquals(cache.has("a"), false);
+     * ```
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear(): void;
+    /**
+     * Automatically clears all remaining timeouts once the cache goes out of
+     * scope if the cache is declared with `using`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * let c: TtlCache<string, number>;
+     * {
+     *  using cache = new TtlCache<string, number>(1000);
+     *  cache.set("a", 1);
+     *  c = cache;
+     * }
+     * assertEquals(c.size, 0);
+     * ```
+     */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=ttl_cache.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl_cache.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/ttl_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IAIjC;;;;;;;;OAQG;gBACS,UAAU,EAAE,MAAM;IAK9B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAyB,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;OAmBG;IACM,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAMhC;;;;;;;;;;;;;;;;;OAiBG;IACM,KAAK,IAAI,IAAI;IAQtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB"}

package/script/deps/jsr.io/@std/cache/0.2.0/ttl_cache.js

@@ -0,0 +1,166 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TtlCache_defaultTtl, _TtlCache_timeouts;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtlCache = void 0;
+/**
+ * Time-to-live cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Automatically removes entries after the configured amount of time elapses.
+ *
+ * @typeParam K The type of the cache keys.
+ * @typeParam V The type of the cache values.
+ *
+ * @example Usage
+ * ```ts
+ * import { TtlCache } from "@std/cache/ttl-cache";
+ * import { assertEquals } from "@std/assert/equals";
+ * import { delay } from "@std/async/delay";
+ *
+ * const cache = new TtlCache<string, number>(1000);
+ *
+ * cache.set("a", 1);
+ * assertEquals(cache.size, 1);
+ * await delay(2000);
+ * assertEquals(cache.size, 0);
+ * ```
+ */
+class TtlCache extends Map {
+    /**
+     * Constructs a new instance.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param defaultTtl The default time-to-live in milliseconds. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     */
+    constructor(defaultTtl) {
+        super();
+        _TtlCache_defaultTtl.set(this, void 0);
+        _TtlCache_timeouts.set(this, new Map());
+        __classPrivateFieldSet(this, _TtlCache_defaultTtl, defaultTtl, "f");
+    }
+    /**
+     * Set a value in the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The cache key
+     * @param value The value to set
+     * @param ttl A custom time-to-live. If supplied, overrides the cache's
+     * default TTL for this entry. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     * @returns `this` for chaining.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { delay } from "@std/async/delay";
+     *
+     * const cache = new TtlCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assertEquals(cache.get("a"), 1);
+     *
+     * await delay(200);
+     * assertEquals(cache.get("a"), undefined);
+     * ```
+     */
+    set(key, value, ttl = __classPrivateFieldGet(this, _TtlCache_defaultTtl, "f")) {
+        clearTimeout(__classPrivateFieldGet(this, _TtlCache_timeouts, "f").get(key));
+        super.set(key, value);
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").set(key, setTimeout(() => this.delete(key), ttl));
+        return this;
+    }
+    /**
+     * Deletes the value associated with the given key.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to delete.
+     * @returns `true` if the key was deleted, `false` otherwise.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.delete("a");
+     * assertEquals(cache.has("a"), false);
+     * ```
+     */
+    delete(key) {
+        clearTimeout(__classPrivateFieldGet(this, _TtlCache_timeouts, "f").get(key));
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").delete(key);
+        return super.delete(key);
+    }
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear() {
+        for (const timeout of __classPrivateFieldGet(this, _TtlCache_timeouts, "f").values()) {
+            clearTimeout(timeout);
+        }
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").clear();
+        super.clear();
+    }
+    /**
+     * Automatically clears all remaining timeouts once the cache goes out of
+     * scope if the cache is declared with `using`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * let c: TtlCache<string, number>;
+     * {
+     *  using cache = new TtlCache<string, number>(1000);
+     *  cache.set("a", 1);
+     *  c = cache;
+     * }
+     * assertEquals(c.size, 0);
+     * ```
+     */
+    [(_TtlCache_defaultTtl = new WeakMap(), _TtlCache_timeouts = new WeakMap(), Symbol.dispose)]() {
+        this.clear();
+    }
+}
+exports.TtlCache = TtlCache;

package/script/src/connection/DirectConnectionFactory.d.ts

@@ -0,0 +1,29 @@
+import { Client } from '@connectrpc/connect';
+import { RequestHandler } from 'express';
+import { Logger } from '../observability/mod.js';
+import { credentialv1alpha1, tokensv1, oauth1v1 } from '../services/credentials/mod.js';
+import { Connection } from '../services/platform/mod.js';
+import { HttpClientFactory } from './internal/HttpClientFactory.js';
+import { ConnectionFactory, FetchLike } from './types.js';
+/**
+ * DirectConnectionFactory is used by actual {@link FetchFactory} and {@link ExpressHandlers} implementations to build a
+ * fetchers and handlers for a given connection.
+ *
+ * This should be used by the internal runtime to construct either a static or dynamic {@link ConnectionFactory} (or
+ * some other implementation that implements {@link ConnectionFactory}), which can be used to build a {@link FetchLike}
+ * or {@link RequestHandler} for a given {@link Context}.
+ */
+export declare class DirectConnectionFactory implements ConnectionFactory {
+    private readonly httpClientFactory;
+    private readonly credentials;
+    private readonly tokens;
+    private readonly oauth1;
+    private readonly logger;
+    private readonly outboundConnectionFactory;
+    private readonly expressInboundConnectionFactory;
+    constructor(httpClientFactory: HttpClientFactory, credentials: Client<typeof credentialv1alpha1.CredentialService>, tokens: Client<typeof tokensv1.TokenService>, oauth1: Client<typeof oauth1v1.AuthorizationService>, logger: Logger);
+    fetcher(cnx: Connection): Promise<FetchLike>;
+    handler(cnx: Connection): Promise<RequestHandler>;
+    static fromEnv(logger: Logger): DirectConnectionFactory;
+}
+//# sourceMappingURL=DirectConnectionFactory.d.ts.map

package/script/src/connection/DirectConnectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectConnectionFactory.d.ts","sourceRoot":"","sources":["../../../src/src/connection/DirectConnectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGpE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG1D;;;;;;;GAOG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;IAKzD,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAR3B,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IACtE,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAA2B;gBAGtD,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,MAAM,CAAC,OAAO,kBAAkB,CAAC,iBAAiB,CAAC,EAChE,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,EAC5C,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,oBAAoB,CAAC,EACpD,MAAM,EAAE,MAAM;IAkBnC,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAI5C,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC;IAIjD,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB;CAqB1D"}