@dbx-tools/shared-core 0.3.44 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,36 @@
+export * as async from "./src/async.js";
+export * as brand from "./src/brand.js";
+export * as error from "./src/error.js";
+export * as functionModule from "./src/function.js";
+export * as hash from "./src/hash.js";
+export * as http from "./src/http.js";
+export * as json from "./src/json.js";
+export * as log from "./src/log.js";
+export * as net from "./src/net.js";
+export * as object from "./src/object.js";
+export * as predicate from "./src/predicate.js";
+export * as string from "./src/string.js";
+export * as token from "./src/token.js";
+export { poll, tieAbortSignal, combineAbortSignals, sleep } from "./src/async.js";
+export type { PollContext, PollProducer, PollOptions } from "./src/async.js";
+export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, parseBrandContext, defaultBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.js";
+export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.js";
+export { toError, errorMessage, errorMessages, errorNodes, errorContext } from "./src/error.js";
+export type { ErrorContext } from "./src/error.js";
+export { memoize } from "./src/function.js";
+export type { MemoizeOptions } from "./src/function.js";
+export { id, fnvHash, fnvHashWithOptions, toBase32 } from "./src/hash.js";
+export { forEachHeaderValue, parseCookies, createFetchError } from "./src/http.js";
+export type { HeaderLike } from "./src/http.js";
+export { parse, parseRecord } from "./src/json.js";
+export { isLevelEnabled, logger } from "./src/log.js";
+export type { LogLevel, Logger } from "./src/log.js";
+export { urlBuilder, pathMatch, parseEmails, isEmail, parseIp, parseCidr, ipInCidr, findContainingCidr, isLoopbackHost } from "./src/net.js";
+export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.js";
+export { isOneOrMany, isCollection, isEmpty, values, isContainer, map, filter, nonNull, flatMap, flat, distinct, concat, take, group, find, findLast, findIndex, findLastIndex, some, every, forEach, at, toOneOrMany, toArray, sequence, generator, isRecord, toBoolean, deepEqual } from "./src/object.js";
+export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, DeepEqualComparator } from "./src/object.js";
+export { create } from "./src/predicate.js";
+export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.js";
+export { tokenizeWithOptions, tokenize, toIdentifierWithOptions, toIdentifier, toSlugWithOptions, toSlug, trimToNull, parseList, trimToEmpty, firstNonEmpty, escapeHtml, toUniqueSlug, toDescription, pluralize, toLabel, capitalize } from "./src/string.js";
+export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.js";
+export { getAccessTokenPayload, getAccessTokenScopes, includesAccessTokenScope } from "./src/token.js";

package/lib/index.js

@@ -0,0 +1,30 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as async from "./src/async.js";
+export * as brand from "./src/brand.js";
+export * as error from "./src/error.js";
+export * as functionModule from "./src/function.js";
+export * as hash from "./src/hash.js";
+export * as http from "./src/http.js";
+export * as json from "./src/json.js";
+export * as log from "./src/log.js";
+export * as net from "./src/net.js";
+export * as object from "./src/object.js";
+export * as predicate from "./src/predicate.js";
+export * as string from "./src/string.js";
+export * as token from "./src/token.js";
+export { poll, tieAbortSignal, combineAbortSignals, sleep } from "./src/async.js";
+export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, parseBrandContext, defaultBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.js";
+export { toError, errorMessage, errorMessages, errorNodes, errorContext } from "./src/error.js";
+export { memoize } from "./src/function.js";
+export { id, fnvHash, fnvHashWithOptions, toBase32 } from "./src/hash.js";
+export { forEachHeaderValue, parseCookies, createFetchError } from "./src/http.js";
+export { parse, parseRecord } from "./src/json.js";
+export { isLevelEnabled, logger } from "./src/log.js";
+export { urlBuilder, pathMatch, parseEmails, isEmail, parseIp, parseCidr, ipInCidr, findContainingCidr, isLoopbackHost } from "./src/net.js";
+export { isOneOrMany, isCollection, isEmpty, values, isContainer, map, filter, nonNull, flatMap, flat, distinct, concat, take, group, find, findLast, findIndex, findLastIndex, some, every, forEach, at, toOneOrMany, toArray, sequence, generator, isRecord, toBoolean, deepEqual } from "./src/object.js";
+export { create } from "./src/predicate.js";
+export { tokenizeWithOptions, tokenize, toIdentifierWithOptions, toIdentifier, toSlugWithOptions, toSlug, trimToNull, parseList, trimToEmpty, firstNonEmpty, escapeHtml, toUniqueSlug, toDescription, pluralize, toLabel, capitalize } from "./src/string.js";
+export { getAccessTokenPayload, getAccessTokenScopes, includesAccessTokenScope } from "./src/token.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/async.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Per-iteration context handed to {@link PollProducer} and the
+ * predicate on each step of a {@link poll} loop. Bundles the
+ * iteration metadata so the call signatures stay stable as `poll`
+ * grows additional fields.
+ *
+ * `signal` is owned by `poll`: it tracks the external
+ * `PollOptions.signal` (when supplied) and also fires when the
+ * consumer breaks out of the loop, so producers can forward it to
+ * any in-flight work (`fetch`, SDK calls, etc.) and have a single
+ * cancellation source tear down both the request and the loop.
+ *
+ * `attributes` is a mutable scratchpad shared across every
+ * iteration of a single `poll` run. The same object reference is
+ * passed each call so writes from one iteration are visible to the
+ * next - useful for stashing per-loop state (retry counters, start
+ * timestamps, anything you'd otherwise close over via a let).
+ * Generic `A` lets callers type the bag; defaults to
+ * `Record<string, unknown>`.
+ */
+export interface PollContext<T, A = Record<string, unknown>> {
+    /** Zero-based iteration index (`0` on the first call). */
+    attempt: number;
+    /** Value yielded on the prior iteration; `undefined` on the first. */
+    previous: T | undefined;
+    /** Cancellation handle. Always defined; forward to in-flight work. */
+    signal: AbortSignal;
+    /** Per-run mutable scratchpad shared across iterations. */
+    attributes: A;
+}
+/** One step of a {@link poll} loop. See {@link PollContext}. */
+export type PollProducer<T, A = Record<string, unknown>> = (ctx: PollContext<T, A>) => T | PromiseLike<T>;
+export interface PollOptions<T, A = Record<string, unknown>> {
+    /** Milliseconds to wait between polls. */
+    intervalMs: number;
+    /**
+     * Predicate evaluated against each yielded value: return `true` to
+     * keep it, `false` to skip it (without stopping the loop). May be
+     * sync or async - a `PromiseLike<boolean>` is awaited before the
+     * decision is made. Receives the same {@link PollContext} as the
+     * producer (same `signal`, same `attributes` bag). The special
+     * value `"distinct"` skips a value that deep-equals the previous
+     * one.
+     */
+    filter?: ((value: T, ctx: PollContext<T, A>) => boolean | PromiseLike<boolean>) | "distinct";
+    /**
+     * Predicate evaluated against each yielded value: return `true` to
+     * keep polling, `false` to stop. May be sync or async. Omit to poll
+     * forever (the consumer stops by breaking out of the loop or by
+     * aborting `signal`).
+     */
+    predicate?: (value: T, ctx: PollContext<T, A>) => boolean | PromiseLike<boolean>;
+    /**
+     * External cancellation handle. Tied into the internal signal that
+     * `poll` hands to `producer`, so aborting it tears down both the
+     * in-flight request and the inter-poll sleep.
+     */
+    signal?: AbortSignal;
+    /**
+     * Hard upper bound on the total lifetime of the poll loop, in
+     * milliseconds. When the budget elapses, `poll` aborts its internal
+     * signal so the in-flight producer and inter-poll sleep both tear
+     * down promptly, and the loop throws the `TimeoutError`
+     * `DOMException` produced by `AbortSignal.timeout(timeoutMs)`. The
+     * budget starts ticking the moment the generator is created.
+     */
+    timeoutMs?: number;
+    /**
+     * Initial value for `ctx.attributes`. Defaults to `{}`. The same
+     * object is reused across iterations, so callers can pre-populate
+     * fields (timers, retry counters, etc.) and the producer /
+     * predicate can mutate them in place.
+     */
+    attributes?: A;
+}
+/**
+ * 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 declare function poll<T, A = Record<string, unknown>>(producer: PollProducer<T, A>, options: PollOptions<T, A>): AsyncGenerator<T, void, void>;
+/**
+ * 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 declare function tieAbortSignal(child: AbortController, parent?: AbortSignal): void;
+/**
+ * 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 declare function combineAbortSignals(...signals: (AbortSignal | undefined)[]): AbortSignal | undefined;
+/**
+ * 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 declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/lib/src/async.js

@@ -0,0 +1,163 @@
+/**
+ * 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";
+/**
+ * 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))
+                        continue;
+                }
+                else if (!(await options.filter(value, ctx))) {
+                    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];
+    const combined = new AbortController();
+    for (const signal of present)
+        tieAbortSignal(combined, signal);
+    return combined.signal;
+}
+/**
+ * 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.js","sourceRoot":"","sources":["../../src/async.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\";\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\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)) continue;\n        } else if (!(await options.filter(value, ctx))) {\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  const combined = new AbortController();\n  for (const signal of present) tieAbortSignal(combined, signal);\n  return combined.signal;\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"]}

package/lib/src/brand.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Browser-safe brand contract, defaults, and LLM serialization helpers.
+ *
+ * Asset values are intentionally strings: they may be relative file paths,
+ * package exports, data URLs, or network URLs depending on the consumer.
+ *
+ * @module
+ */
+import { z } from "zod";
+export declare const DEFAULT_BRAND_ASSETS: {
+    readonly icon: {
+        readonly light: "@dbx-tools/ui-branding/assets/icon-light.svg";
+        readonly dark: "@dbx-tools/ui-branding/assets/icon-dark.svg";
+    };
+    readonly logo: {
+        readonly light: "@dbx-tools/ui-branding/assets/logo-light.svg";
+        readonly dark: "@dbx-tools/ui-branding/assets/logo-dark.svg";
+    };
+    readonly favicon: "@dbx-tools/ui-branding/assets/icon-light.svg";
+};
+export declare const BrandAssetSetSchema: z.ZodObject<{
+    light: z.ZodString;
+    dark: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const BrandColorsSchema: z.ZodPrefault<z.ZodObject<{
+    primary: z.ZodDefault<z.ZodString>;
+    primaryHover: z.ZodDefault<z.ZodString>;
+    accent: z.ZodDefault<z.ZodString>;
+    foreground: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodString>;
+    surface: z.ZodDefault<z.ZodString>;
+    muted: z.ZodDefault<z.ZodString>;
+    border: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>>;
+export declare const BrandVoiceSchema: z.ZodPrefault<z.ZodObject<{
+    audience: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tone: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    principles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    avoid: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
+export declare const BrandContextSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodLiteral<"1">>;
+    name: z.ZodDefault<z.ZodString>;
+    shortName: z.ZodDefault<z.ZodString>;
+    tagline: z.ZodDefault<z.ZodString>;
+    description: z.ZodDefault<z.ZodString>;
+    assets: z.ZodDefault<z.ZodObject<{
+        icon: z.ZodDefault<z.ZodObject<{
+            light: z.ZodString;
+            dark: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        logo: z.ZodDefault<z.ZodObject<{
+            light: z.ZodString;
+            dark: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        favicon: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    colors: z.ZodPrefault<z.ZodObject<{
+        primary: z.ZodDefault<z.ZodString>;
+        primaryHover: z.ZodDefault<z.ZodString>;
+        accent: z.ZodDefault<z.ZodString>;
+        foreground: z.ZodDefault<z.ZodString>;
+        background: z.ZodDefault<z.ZodString>;
+        surface: z.ZodDefault<z.ZodString>;
+        muted: z.ZodDefault<z.ZodString>;
+        border: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    typography: z.ZodPrefault<z.ZodObject<{
+        sans: z.ZodDefault<z.ZodString>;
+        mono: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    voice: z.ZodPrefault<z.ZodObject<{
+        audience: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        tone: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        principles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        avoid: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    links: z.ZodDefault<z.ZodObject<{
+        website: z.ZodOptional<z.ZodString>;
+        repository: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type BrandContext = z.output<typeof BrandContextSchema>;
+export type BrandContextInput = z.input<typeof BrandContextSchema>;
+export type BrandAssetSet = z.output<typeof BrandAssetSetSchema>;
+/** Validate input and fill every dbx tools default. */
+export declare function parseBrandContext(input?: unknown): BrandContext;
+export declare const defaultBrandContext: BrandContext;
+/** JSON Schema representation suitable for structured-output and tool definitions. */
+export declare function brandContextJsonSchema(): Record<string, unknown>;
+/** Stable prompt block for an LLM that needs to write or design in this brand. */
+export declare function brandContextPrompt(context?: BrandContext): string;