@dbx-tools/shared-core 0.9.5 → 0.9.6

package/README.md

@@ -8,16 +8,16 @@ namespaces so call sites stay explicit:
 
 ```ts
 import {
-  async,
-  brand,
-  error,
+  asyncUtils,
+  brandUtils,
+  errorUtils,
   hash,
   http,
   json,
   log,
   net,
   object,
-  string,
+  stringUtils,
 } from "@dbx-tools/shared-core";
 ```
 
@@ -46,11 +46,11 @@ Key features:
 ## Brand Context
 
 ```ts
-import { brand } from "@dbx-tools/shared-core";
+import { brandUtils } from "@dbx-tools/shared-core";
 
-const context = brand.parseBrandContext({ name: "Acme Data" });
-const jsonSchema = brand.brandContextJsonSchema();
-const instructions = brand.brandContextPrompt(context);
+const context = brandUtils.parseBrandContext({ name: "Acme Data" });
+const jsonSchema = brandUtils.brandContextJsonSchema();
+const instructions = brandUtils.brandContextPrompt(context);
 ```
 
 `BrandContextSchema` validates identity, theme-aware assets, colors,
@@ -62,7 +62,7 @@ to discover and read YAML/JSON files, and
 ## Async Control
 
 ```ts
-for await (const status of async.poll(fetchStatus, {
+for await (const status of asyncUtils.poll(fetchStatus, {
   intervalMs: 250,
   timeoutMs: 30_000,
   predicate: (s) => s !== "READY",
@@ -70,11 +70,11 @@ for await (const status of async.poll(fetchStatus, {
   render(status);
 }
 
-await async.sleep(500, abortSignal);
+await asyncUtils.sleep(500, abortSignal);
 ```
 
-`async.poll()` is useful for Databricks APIs that expose long-running state.
-`async.tieAbortSignal()` and `async.sleep()` let route handlers connect caller
+`asyncUtils.poll()` is useful for Databricks APIs that expose long-running state.
+`asyncUtils.tieAbortSignal()` and `asyncUtils.sleep()` let route handlers connect caller
 cancellation to background work.
 
 ## Error Handling
@@ -83,14 +83,14 @@ cancellation to background work.
 try {
   await run();
 } catch (err) {
-  logger.warn("run failed", { error: error.errorMessage(err) });
-  const ctx = error.errorContext(err);
+  logger.warn("run failed", { error: errorUtils.errorMessage(err) });
+  const ctx = errorUtils.errorContext(err);
   return Response.json({ message: ctx.message }, { status: ctx.status ?? 500 });
 }
 ```
 
-`error.toError()`, `error.errorMessage()`, `error.errorMessages()`, and
-`error.errorNodes()` normalize unknown thrown values. `error.errorContext()`
+`errorUtils.toError()`, `errorUtils.errorMessage()`, `errorUtils.errorMessages()`, and
+`errorUtils.errorNodes()` normalize unknown thrown values. `errorUtils.errorContext()`
 extracts HTTP-ish status/message detail from nested errors.
 
 ## Hashes And Ids
@@ -127,26 +127,26 @@ reading a file this repo generated itself.
 ## Strings And Descriptions
 
 ```ts
-const slug = string.toSlug("My Cool Project!");
-const id = string.toIdentifierWithOptions({ delimiter: "_" }, "Model Name");
-const unique = string.toUniqueSlug("Send Email", { fallbackPrefix: "tool" });
-const description = string.toDescription([
+const slug = stringUtils.toSlug("My Cool Project!");
+const id = stringUtils.toIdentifierWithOptions({ delimiter: "_" }, "Model Name");
+const unique = stringUtils.toUniqueSlug("Send Email", { fallbackPrefix: "tool" });
+const description = stringUtils.toDescription([
   "Answer with SQL first.",
   { "When data is missing": "Say what is missing." },
 ]);
 ```
 
-`string.tokenize()`, `toSlug()`, and `toIdentifier()` keep package names, tool
+`stringUtils.tokenize()`, `toSlug()`, and `toIdentifier()` keep package names, tool
 ids, schema ids, and generated labels consistent. `toDescription()` turns nested
 description data into prompt/tool text without hand-concatenating paragraphs.
 
 Three helpers exist so call sites stop re-implementing them:
 
 ```ts
-const label = string.toLabel("web_search"); // "Web Search"
-const name = string.capitalize(segment); // no charAt(0).toUpperCase() idiom
-const host = string.trimToEmpty(parsed.host); // unknown JSON field -> string
-const allowed = string.parseList(process.env.ALLOWED_URLS);
+const label = stringUtils.toLabel("web_search"); // "Web Search"
+const name = stringUtils.capitalize(segment); // no charAt(0).toUpperCase() idiom
+const host = stringUtils.trimToEmpty(parsed.host); // unknown JSON field -> string
+const allowed = stringUtils.parseList(process.env.ALLOWED_URLS);
 ```
 
 `toLabel()` and `capitalize()` are the humanizers for identifiers and path
@@ -325,7 +325,7 @@ parse IPv4 and IPv6 into a shared bigint comparison model.
 ## Allow-List Patterns
 
 ```ts
-// One matcher from a config array OR a delimited env string.
+// One matcher from a config array OR a delimited env stringUtils.
 const forwardable = pattern.toPatternMatcher(["x-mastra-*", "/^x-trace-/", "x-tenant"]);
 
 forwardable("x-mastra-model"); // true  (glob)
@@ -337,7 +337,7 @@ forwardable("x-forwarded-user"); // false
 Every configurable allow-list in this repo takes the same three shapes, so the
 compilation lives here once: a `/regex/` literal (with optional flags), a
 shell-style glob (`*`, `?`, anchored at both ends, all other characters escaped),
-or a literal compared whole-string. Matching is case-insensitive by default -
+or a literal compared whole-stringUtils. Matching is case-insensitive by default -
 what HTTP header names and email addresses both want - and `caseSensitive` opts
 out.
 
@@ -366,12 +366,12 @@ the request.
 ## Memoization
 
 ```ts
-const getRanges = functionModule.memoize(fetchRanges, {
+const getRanges = functionUtils.memoize(fetchRanges, {
   ttlMs: 24 * 60 * 60 * 1000,
 });
 ```
 
-`functionModule.memoize()` caches sync or async factories, evicts rejected
+`functionUtils.memoize()` caches sync or async factories, evicts rejected
 promises, and supports TTL-based refresh. It is useful for public metadata feeds,
 SDK catalogues, and expensive computed constants.
 
@@ -397,11 +397,11 @@ when disabled.
 
 ## Modules
 
-- `async` - polling, sleep, and abort-signal wiring.
-- `error` - unknown-error normalization and HTTP-ish error context.
+- `asyncUtils` - polling, sleep, and abort-signal wiring.
+- `errorUtils` - unknown-error normalization and HTTP-ish error context.
 - `hash` - ids, FNV hashes, and base32 encoding.
 - `json` - non-throwing `parse()` and record-narrowing `parseRecord()`.
-- `string` - tokenization, slugs, identifiers, human labels, string coercion,
+- `stringUtils` - tokenization, slugs, identifiers, human labels, string coercion,
   config lists, descriptions, pluralization, and HTML escaping.
 - `object` - record checks, number/boolean/date/duration coercion, present-only
   field spreading, deep equality, JSON-round-trip guards
@@ -414,6 +414,6 @@ when disabled.
 - `execution` - direct executor fallback, cancellation merging, and result unwrapping.
 - `net` - URL building, email parsing, path matching, IP/CIDR helpers.
 - `token` - JWT payload and scope readers.
-- `functionModule` - memoization.
+- `functionUtils` - memoization.
 - `log` - tagged leveled logging.
-- `brand` - Zod schema, defaults, JSON Schema, and LLM prompt serialization.
+- `brandUtils` - Zod schema, defaults, JSON Schema, and LLM prompt serialization.

package/index.ts

@@ -3,12 +3,12 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export const PACKAGE_VERSION = "0.9.5";
-export * as async from "./src/async.ts";
-export * as brand from "./src/brand.ts";
-export * as error from "./src/error.ts";
+export const PACKAGE_VERSION = "0.9.6";
+export * as asyncUtils from "./src/async-utils.ts";
+export * as brandUtils from "./src/brand-utils.ts";
+export * as errorUtils from "./src/error-utils.ts";
 export * as execution from "./src/execution.ts";
-export * as functionModule from "./src/function.ts";
+export * as functionUtils from "./src/function-utils.ts";
 export * as hash from "./src/hash.ts";
 export * as http from "./src/http.ts";
 export * as json from "./src/json.ts";
@@ -17,19 +17,19 @@ export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
 export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
-export * as string from "./src/string.ts";
+export * as stringUtils from "./src/string-utils.ts";
 export * as token from "./src/token.ts";
-export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
-export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
-export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
-export type { ErrorContext } from "./src/error.ts";
+export type { ConcurrentErrorMode, MapConcurrentOptions, PollContext, PollProducer, PollOptions } from "./src/async-utils.ts";
+export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand-utils.ts";
+export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand-utils.ts";
+export type { ErrorContext } from "./src/error-utils.ts";
 export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
-export type { MemoizeOptions } from "./src/function.ts";
+export type { MemoizeOptions } from "./src/function-utils.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
-export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";
+export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string-utils.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.ts";

package/lib/index.d.ts

@@ -1,10 +1,10 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export declare const PACKAGE_VERSION = "0.9.5";
-export * as async from "./src/async.ts";
-export * as brand from "./src/brand.ts";
-export * as error from "./src/error.ts";
+export declare const PACKAGE_VERSION = "0.9.6";
+export * as asyncUtils from "./src/async-utils.ts";
+export * as brandUtils from "./src/brand-utils.ts";
+export * as errorUtils from "./src/error-utils.ts";
 export * as execution from "./src/execution.ts";
-export * as functionModule from "./src/function.ts";
+export * as functionUtils from "./src/function-utils.ts";
 export * as hash from "./src/hash.ts";
 export * as http from "./src/http.ts";
 export * as json from "./src/json.ts";
@@ -13,19 +13,19 @@ export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
 export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
-export * as string from "./src/string.ts";
+export * as stringUtils from "./src/string-utils.ts";
 export * as token from "./src/token.ts";
-export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
-export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
-export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
-export type { ErrorContext } from "./src/error.ts";
+export type { ConcurrentErrorMode, MapConcurrentOptions, PollContext, PollProducer, PollOptions } from "./src/async-utils.ts";
+export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand-utils.ts";
+export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand-utils.ts";
+export type { ErrorContext } from "./src/error-utils.ts";
 export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
-export type { MemoizeOptions } from "./src/function.ts";
+export type { MemoizeOptions } from "./src/function-utils.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
-export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";
+export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string-utils.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.ts";

package/lib/index.js

@@ -2,12 +2,12 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export const PACKAGE_VERSION = "0.9.5";
-export * as async from "./src/async.js";
-export * as brand from "./src/brand.js";
-export * as error from "./src/error.js";
+export const PACKAGE_VERSION = "0.9.6";
+export * as asyncUtils from "./src/async-utils.js";
+export * as brandUtils from "./src/brand-utils.js";
+export * as errorUtils from "./src/error-utils.js";
 export * as execution from "./src/execution.js";
-export * as functionModule from "./src/function.js";
+export * as functionUtils from "./src/function-utils.js";
 export * as hash from "./src/hash.js";
 export * as http from "./src/http.js";
 export * as json from "./src/json.js";
@@ -16,8 +16,8 @@ export * as net from "./src/net.js";
 export * as object from "./src/object.js";
 export * as pattern from "./src/pattern.js";
 export * as predicate from "./src/predicate.js";
-export * as string from "./src/string.js";
+export * as stringUtils from "./src/string-utils.js";
 export * as token from "./src/token.js";
-export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.js";
+export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand-utils.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/{async.d.ts → async-utils.d.ts}

@@ -1,3 +1,23 @@
+/** Controls how {@link mapConcurrent} reacts when a worker rejects. */
+export type ConcurrentErrorMode = "fail-fast" | "settle";
+/** Bounded-worker settings for {@link mapConcurrent}. */
+export interface MapConcurrentOptions {
+    /** Maximum number of callbacks running at once. */
+    concurrency: number;
+    /**
+     * `"fail-fast"` stops claiming new work after the first rejection.
+     * `"settle"` attempts every value and throws an `AggregateError` afterward.
+     */
+    errorMode?: ConcurrentErrorMode;
+}
+/**
+ * Map values through a bounded worker pool while preserving input order.
+ *
+ * Active callbacks are always allowed to settle. In fail-fast mode no new
+ * callback starts after the first observed rejection. Settle mode attempts
+ * every value and reports all failures in input order through `AggregateError`.
+ */
+export declare function mapConcurrent<T, R>(values: readonly T[], callback: (value: T, index: number) => R | PromiseLike<R>, options: MapConcurrentOptions): Promise<R[]>;
 export declare function boundedRetryDelay(attempt: number, delaysMs?: readonly number[]): number;
 /**
  * Per-iteration context handed to {@link PollProducer} and the

package/lib/src/async-utils.js

@@ -0,0 +1,208 @@
+/**
+ * Cancellation-aware async primitives: an abortable {@link sleep}, an
+ * {@link AbortController} linker ({@link tieAbortSignal}), and a periodic
+ * {@link poll} generator. Dependency-free; `poll`'s `"distinct"` filter
+ * uses the local {@link deepEqual}.
+ *
+ * @module
+ */
+import { deepEqual } from "./object.js";
+const DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000];
+/**
+ * Map values through a bounded worker pool while preserving input order.
+ *
+ * Active callbacks are always allowed to settle. In fail-fast mode no new
+ * callback starts after the first observed rejection. Settle mode attempts
+ * every value and reports all failures in input order through `AggregateError`.
+ */
+export async function mapConcurrent(values, callback, options) {
+    const { concurrency, errorMode = "fail-fast" } = options;
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
+        throw new RangeError(`concurrency must be a positive integer, got ${String(concurrency)}`);
+    }
+    if (values.length === 0)
+        return [];
+    const results = new Array(values.length);
+    const failures = [];
+    let next = 0;
+    let failed = false;
+    const worker = async () => {
+        while (next < values.length && !(failed && errorMode === "fail-fast")) {
+            const index = next++;
+            try {
+                results[index] = await callback(values[index], index);
+            }
+            catch (reason) {
+                failures.push({ index, reason });
+                failed = true;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+    if (failures.length === 0)
+        return results;
+    failures.sort((left, right) => left.index - right.index);
+    if (errorMode === "settle") {
+        throw new AggregateError(failures.map(({ reason }) => reason), `${failures.length} concurrent operation${failures.length === 1 ? "" : "s"} failed`);
+    }
+    throw failures[0].reason;
+}
+export function boundedRetryDelay(attempt, delaysMs = DEFAULT_RETRY_DELAYS_MS) {
+    if (!delaysMs.length)
+        return 0;
+    return delaysMs[Math.min(Math.max(0, attempt), delaysMs.length - 1)];
+}
+/**
+ * Async iterable that drives a periodic poll. Each iteration:
+ *
+ *   1. Builds a {@link PollContext} (`attempt`, `previous`, `signal`,
+ *      shared `attributes`) and calls `producer(ctx)`; yields the
+ *      resolved value (subject to `filter`).
+ *   2. Evaluates `options.predicate(value, ctx)`; stops when it
+ *      returns (or resolves to) `false`.
+ *   3. Sleeps `options.intervalMs` before the next attempt.
+ *
+ * The first call runs immediately (no leading sleep) so the consumer
+ * sees a value without waiting an interval. Errors thrown by
+ * `producer` propagate through the generator.
+ *
+ * `poll` always creates an internal `AbortController` and exposes
+ * `internal.signal` as `ctx.signal`, so producers can rely on a
+ * defined signal without a nullish check. The external
+ * `options.signal` is tied in, and a `try/finally` aborts the
+ * internal signal when the consumer breaks out of the `for await`
+ * (or the loop throws), so any producer work still holding the
+ * signal sees the cancellation too.
+ *
+ * @example
+ * for await (const msg of poll(
+ *   async ({ signal }) =>
+ *     client.genie.getMessage({ ... }, { abortSignal: signal }),
+ *   {
+ *     intervalMs: 250,
+ *     predicate: (m) => !TERMINAL_STATUSES.has(m.status),
+ *     signal: controller.signal,
+ *   },
+ * )) {
+ *   render(msg);
+ * }
+ */
+export async function* poll(producer, options) {
+    const { intervalMs, predicate, signal, attributes, timeoutMs } = options;
+    const controller = new AbortController();
+    if (signal)
+        tieAbortSignal(controller, signal);
+    if (timeoutMs !== undefined) {
+        tieAbortSignal(controller, AbortSignal.timeout(timeoutMs));
+    }
+    // Single shared attributes object so writes from one iteration are
+    // visible on the next. `{} as A` is safe because either the caller
+    // supplied `attributes` (typed) or `A` defaulted to the unknown
+    // record shape (in which case `{}` satisfies it).
+    const sharedAttributes = attributes ?? {};
+    try {
+        let previous;
+        for (let attempt = 0;; attempt++) {
+            controller.signal.throwIfAborted();
+            const ctx = {
+                attempt,
+                previous,
+                signal: controller.signal,
+                attributes: sharedAttributes,
+            };
+            const value = await producer(ctx);
+            if (options.filter) {
+                if (options.filter === "distinct") {
+                    if (deepEqual(previous, value)) {
+                        await sleep(intervalMs, controller.signal);
+                        continue;
+                    }
+                }
+                else if (!(await options.filter(value, ctx))) {
+                    await sleep(intervalMs, controller.signal);
+                    continue;
+                }
+            }
+            yield value;
+            if (predicate && !(await predicate(value, ctx)))
+                return;
+            await sleep(intervalMs, controller.signal);
+            previous = value;
+        }
+    }
+    finally {
+        controller.abort();
+    }
+}
+/**
+ * Tie a child `AbortController` to a parent signal. The child aborts
+ * whenever the parent aborts; aborting the child does not affect the
+ * parent (so a fetch-level cancel doesn't tear down the main poll loop).
+ */
+export function tieAbortSignal(child, parent) {
+    if (!parent) {
+        return;
+    }
+    else if (parent.aborted) {
+        child.abort(parent.reason);
+        return;
+    }
+    parent.addEventListener("abort", () => child.abort(parent.reason), {
+        once: true,
+    });
+}
+/**
+ * Combine several optional cancellation sources into one signal that aborts
+ * as soon as any of them does.
+ *
+ * The usual caller is an operation that has to honor more than one source at
+ * once - a caller's own signal (a closed connection, an agent run being
+ * cancelled) plus one derived from a timeout - where the awaited I/O accepts
+ * only a single signal. Absent sources are ignored, and a lone signal is
+ * returned as-is so the common path allocates nothing. Returns `undefined`
+ * only when every input is absent, which callers can pass straight through
+ * to an optional `signal` parameter.
+ *
+ * Aborting an input aborts the result (carrying that input's `reason`);
+ * nothing propagates back the other way.
+ *
+ * @example
+ * await fetch(url, { signal: combineAbortSignals(req.signal, timeout.signal) });
+ */
+export function combineAbortSignals(...signals) {
+    const present = signals.filter((signal) => signal !== undefined);
+    if (present.length <= 1)
+        return present[0];
+    return AbortSignal.any(present);
+}
+/**
+ * Promisified `setTimeout` that wakes up early (and rejects with
+ * `signal.reason`) when `signal` aborts mid-wait. Short-circuits to a
+ * rejected promise when the signal is already aborted on entry, so the
+ * abort path is consistent regardless of whether the wait actually
+ * started.
+ *
+ * Use as the building block for any "wait, but cancel cleanly" pattern -
+ * inter-poll backoff, pacing loops, retry timers, long-poll budgets - so
+ * cancellation always rejects with the caller's `signal.reason` rather
+ * than silently resolving after the timer expires.
+ *
+ * @example
+ * await sleep(250, req.signal);
+ */
+export function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-utils.js","sourceRoot":"","sources":["../../src/async-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cancellation-aware async primitives: an abortable {@link sleep}, an\n * {@link AbortController} linker ({@link tieAbortSignal}), and a periodic\n * {@link poll} generator. Dependency-free; `poll`'s `\"distinct\"` filter\n * uses the local {@link deepEqual}.\n *\n * @module\n */\nimport { deepEqual } from \"./object.ts\";\n\nconst DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000] as const;\n\n/** Controls how {@link mapConcurrent} reacts when a worker rejects. */\nexport type ConcurrentErrorMode = \"fail-fast\" | \"settle\";\n\n/** Bounded-worker settings for {@link mapConcurrent}. */\nexport interface MapConcurrentOptions {\n  /** Maximum number of callbacks running at once. */\n  concurrency: number;\n  /**\n   * `\"fail-fast\"` stops claiming new work after the first rejection.\n   * `\"settle\"` attempts every value and throws an `AggregateError` afterward.\n   */\n  errorMode?: ConcurrentErrorMode;\n}\n\n/**\n * Map values through a bounded worker pool while preserving input order.\n *\n * Active callbacks are always allowed to settle. In fail-fast mode no new\n * callback starts after the first observed rejection. Settle mode attempts\n * every value and reports all failures in input order through `AggregateError`.\n */\nexport async function mapConcurrent<T, R>(\n  values: readonly T[],\n  callback: (value: T, index: number) => R | PromiseLike<R>,\n  options: MapConcurrentOptions,\n): Promise<R[]> {\n  const { concurrency, errorMode = \"fail-fast\" } = options;\n  if (!Number.isSafeInteger(concurrency) || concurrency < 1) {\n    throw new RangeError(`concurrency must be a positive integer, got ${String(concurrency)}`);\n  }\n  if (values.length === 0) return [];\n\n  const results = new Array<R>(values.length);\n  const failures: Array<{ index: number; reason: unknown }> = [];\n  let next = 0;\n  let failed = false;\n\n  const worker = async (): Promise<void> => {\n    while (next < values.length && !(failed && errorMode === \"fail-fast\")) {\n      const index = next++;\n      try {\n        results[index] = await callback(values[index]!, index);\n      } catch (reason) {\n        failures.push({ index, reason });\n        failed = true;\n      }\n    }\n  };\n\n  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));\n  if (failures.length === 0) return results;\n\n  failures.sort((left, right) => left.index - right.index);\n  if (errorMode === \"settle\") {\n    throw new AggregateError(\n      failures.map(({ reason }) => reason),\n      `${failures.length} concurrent operation${failures.length === 1 ? \"\" : \"s\"} failed`,\n    );\n  }\n  throw failures[0]!.reason;\n}\n\nexport function boundedRetryDelay(\n  attempt: number,\n  delaysMs: readonly number[] = DEFAULT_RETRY_DELAYS_MS,\n): number {\n  if (!delaysMs.length) return 0;\n  return delaysMs[Math.min(Math.max(0, attempt), delaysMs.length - 1)]!;\n}\n\n/**\n * Per-iteration context handed to {@link PollProducer} and the\n * predicate on each step of a {@link poll} loop. Bundles the\n * iteration metadata so the call signatures stay stable as `poll`\n * grows additional fields.\n *\n * `signal` is owned by `poll`: it tracks the external\n * `PollOptions.signal` (when supplied) and also fires when the\n * consumer breaks out of the loop, so producers can forward it to\n * any in-flight work (`fetch`, SDK calls, etc.) and have a single\n * cancellation source tear down both the request and the loop.\n *\n * `attributes` is a mutable scratchpad shared across every\n * iteration of a single `poll` run. The same object reference is\n * passed each call so writes from one iteration are visible to the\n * next - useful for stashing per-loop state (retry counters, start\n * timestamps, anything you'd otherwise close over via a let).\n * Generic `A` lets callers type the bag; defaults to\n * `Record<string, unknown>`.\n */\nexport interface PollContext<T, A = Record<string, unknown>> {\n  /** Zero-based iteration index (`0` on the first call). */\n  attempt: number;\n  /** Value yielded on the prior iteration; `undefined` on the first. */\n  previous: T | undefined;\n  /** Cancellation handle. Always defined; forward to in-flight work. */\n  signal: AbortSignal;\n  /** Per-run mutable scratchpad shared across iterations. */\n  attributes: A;\n}\n\n/** One step of a {@link poll} loop. See {@link PollContext}. */\nexport type PollProducer<T, A = Record<string, unknown>> = (\n  ctx: PollContext<T, A>,\n) => T | PromiseLike<T>;\n\n/**\n * Controls poll cadence, filtering, termination, cancellation, timeout, and\n * the mutable per-run attributes exposed through {@link PollContext}.\n */\nexport interface PollOptions<T, A = Record<string, unknown>> {\n  /** Milliseconds to wait between polls. */\n  intervalMs: number;\n  /**\n   * Predicate evaluated against each yielded value: return `true` to\n   * keep it, `false` to skip it (without stopping the loop). May be\n   * sync or async - a `PromiseLike<boolean>` is awaited before the\n   * decision is made. Receives the same {@link PollContext} as the\n   * producer (same `signal`, same `attributes` bag). The special\n   * value `\"distinct\"` skips a value that deep-equals the previous\n   * one.\n   */\n  filter?: ((value: T, ctx: PollContext<T, A>) => boolean | PromiseLike<boolean>) | \"distinct\";\n  /**\n   * Predicate evaluated against each yielded value: return `true` to\n   * keep polling, `false` to stop. May be sync or async. Omit to poll\n   * forever (the consumer stops by breaking out of the loop or by\n   * aborting `signal`).\n   */\n  predicate?: (value: T, ctx: PollContext<T, A>) => boolean | PromiseLike<boolean>;\n  /**\n   * External cancellation handle. Tied into the internal signal that\n   * `poll` hands to `producer`, so aborting it tears down both the\n   * in-flight request and the inter-poll sleep.\n   */\n  signal?: AbortSignal;\n  /**\n   * Hard upper bound on the total lifetime of the poll loop, in\n   * milliseconds. When the budget elapses, `poll` aborts its internal\n   * signal so the in-flight producer and inter-poll sleep both tear\n   * down promptly, and the loop throws the `TimeoutError`\n   * `DOMException` produced by `AbortSignal.timeout(timeoutMs)`. The\n   * budget starts ticking the moment the generator is created.\n   */\n  timeoutMs?: number;\n  /**\n   * Initial value for `ctx.attributes`. Defaults to `{}`. The same\n   * object is reused across iterations, so callers can pre-populate\n   * fields (timers, retry counters, etc.) and the producer /\n   * predicate can mutate them in place.\n   */\n  attributes?: A;\n}\n\n/**\n * Async iterable that drives a periodic poll. Each iteration:\n *\n *   1. Builds a {@link PollContext} (`attempt`, `previous`, `signal`,\n *      shared `attributes`) and calls `producer(ctx)`; yields the\n *      resolved value (subject to `filter`).\n *   2. Evaluates `options.predicate(value, ctx)`; stops when it\n *      returns (or resolves to) `false`.\n *   3. Sleeps `options.intervalMs` before the next attempt.\n *\n * The first call runs immediately (no leading sleep) so the consumer\n * sees a value without waiting an interval. Errors thrown by\n * `producer` propagate through the generator.\n *\n * `poll` always creates an internal `AbortController` and exposes\n * `internal.signal` as `ctx.signal`, so producers can rely on a\n * defined signal without a nullish check. The external\n * `options.signal` is tied in, and a `try/finally` aborts the\n * internal signal when the consumer breaks out of the `for await`\n * (or the loop throws), so any producer work still holding the\n * signal sees the cancellation too.\n *\n * @example\n * for await (const msg of poll(\n *   async ({ signal }) =>\n *     client.genie.getMessage({ ... }, { abortSignal: signal }),\n *   {\n *     intervalMs: 250,\n *     predicate: (m) => !TERMINAL_STATUSES.has(m.status),\n *     signal: controller.signal,\n *   },\n * )) {\n *   render(msg);\n * }\n */\nexport async function* poll<T, A = Record<string, unknown>>(\n  producer: PollProducer<T, A>,\n  options: PollOptions<T, A>,\n): AsyncGenerator<T, void, void> {\n  const { intervalMs, predicate, signal, attributes, timeoutMs } = options;\n  const controller = new AbortController();\n  if (signal) tieAbortSignal(controller, signal);\n  if (timeoutMs !== undefined) {\n    tieAbortSignal(controller, AbortSignal.timeout(timeoutMs));\n  }\n  // Single shared attributes object so writes from one iteration are\n  // visible on the next. `{} as A` is safe because either the caller\n  // supplied `attributes` (typed) or `A` defaulted to the unknown\n  // record shape (in which case `{}` satisfies it).\n  const sharedAttributes = attributes ?? ({} as A);\n  try {\n    let previous: T | undefined;\n    for (let attempt = 0; ; attempt++) {\n      controller.signal.throwIfAborted();\n      const ctx: PollContext<T, A> = {\n        attempt,\n        previous,\n        signal: controller.signal,\n        attributes: sharedAttributes,\n      };\n      const value = await producer(ctx);\n      if (options.filter) {\n        if (options.filter === \"distinct\") {\n          if (deepEqual(previous, value)) {\n            await sleep(intervalMs, controller.signal);\n            continue;\n          }\n        } else if (!(await options.filter(value, ctx))) {\n          await sleep(intervalMs, controller.signal);\n          continue;\n        }\n      }\n      yield value;\n      if (predicate && !(await predicate(value, ctx))) return;\n      await sleep(intervalMs, controller.signal);\n      previous = value;\n    }\n  } finally {\n    controller.abort();\n  }\n}\n\n/**\n * Tie a child `AbortController` to a parent signal. The child aborts\n * whenever the parent aborts; aborting the child does not affect the\n * parent (so a fetch-level cancel doesn't tear down the main poll loop).\n */\nexport function tieAbortSignal(child: AbortController, parent?: AbortSignal): void {\n  if (!parent) {\n    return;\n  } else if (parent.aborted) {\n    child.abort(parent.reason);\n    return;\n  }\n  parent.addEventListener(\"abort\", () => child.abort(parent.reason), {\n    once: true,\n  });\n}\n\n/**\n * Combine several optional cancellation sources into one signal that aborts\n * as soon as any of them does.\n *\n * The usual caller is an operation that has to honor more than one source at\n * once - a caller's own signal (a closed connection, an agent run being\n * cancelled) plus one derived from a timeout - where the awaited I/O accepts\n * only a single signal. Absent sources are ignored, and a lone signal is\n * returned as-is so the common path allocates nothing. Returns `undefined`\n * only when every input is absent, which callers can pass straight through\n * to an optional `signal` parameter.\n *\n * Aborting an input aborts the result (carrying that input's `reason`);\n * nothing propagates back the other way.\n *\n * @example\n * await fetch(url, { signal: combineAbortSignals(req.signal, timeout.signal) });\n */\nexport function combineAbortSignals(\n  ...signals: (AbortSignal | undefined)[]\n): AbortSignal | undefined {\n  const present = signals.filter((signal): signal is AbortSignal => signal !== undefined);\n  if (present.length <= 1) return present[0];\n  return AbortSignal.any(present);\n}\n\n/**\n * Promisified `setTimeout` that wakes up early (and rejects with\n * `signal.reason`) when `signal` aborts mid-wait. Short-circuits to a\n * rejected promise when the signal is already aborted on entry, so the\n * abort path is consistent regardless of whether the wait actually\n * started.\n *\n * Use as the building block for any \"wait, but cancel cleanly\" pattern -\n * inter-poll backoff, pacing loops, retry timers, long-poll budgets - so\n * cancellation always rejects with the caller's `signal.reason` rather\n * than silently resolving after the timer expires.\n *\n * @example\n * await sleep(250, req.signal);\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  if (signal?.aborted) return Promise.reject(signal.reason);\n  return new Promise((resolve, reject) => {\n    const onAbort = (): void => {\n      clearTimeout(timer);\n      reject(signal!.reason);\n    };\n    const timer = setTimeout(() => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n"]}