@dbx-tools/shared-core 0.9.5 → 0.9.7

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

@@ -10,6 +10,68 @@ import { deepEqual } from "./object.ts";
 
 const DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000] as const;
 
+/** 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 async function mapConcurrent<T, R>(
+  values: readonly T[],
+  callback: (value: T, index: number) => R | PromiseLike<R>,
+  options: MapConcurrentOptions,
+): Promise<R[]> {
+  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<R>(values.length);
+  const failures: Array<{ index: number; reason: unknown }> = [];
+  let next = 0;
+  let failed = false;
+
+  const worker = async (): Promise<void> => {
+    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: number,
   delaysMs: readonly number[] = DEFAULT_RETRY_DELAYS_MS,

package/src/{error.ts → error-utils.ts}

@@ -7,7 +7,7 @@
  * @module
  */
 
-import { tokenizeWithOptions } from "./string.ts";
+import { tokenizeWithOptions } from "./string-utils.ts";
 
 /**
  * Normalize any thrown value into an `Error`. Returns `value` unchanged

package/src/execution.ts

@@ -1,6 +1,6 @@
 /** Generic helpers for AppKit-style intercepted execution. */
-import * as async from "./async.ts";
-import * as error from "./error.ts";
+import * as async from "./async-utils.ts";
+import * as error from "./error-utils.ts";
 import * as object from "./object.ts";
 
 /** Success/failure shape returned by an interceptor-backed executor. */

package/src/{function.ts → function-utils.ts}

@@ -32,7 +32,7 @@ export interface MemoizeOptions {
  * pending promise until it settles.
  *
  * @example
- * const ranges = functionModule.memoize(fetchIpRanges, { ttlMs: 24 * 60 * 60 * 1000 });
+ * const ranges = functionUtils.memoize(fetchIpRanges, { ttlMs: 24 * 60 * 60 * 1000 });
  * await ranges(); // fetches
  * await ranges(); // cached until 24h later
  */

package/src/log.ts

@@ -27,7 +27,7 @@
  * @module
  */
 
-import { memoize } from "./function.ts";
+import { memoize } from "./function-utils.ts";
 import { type NameLike, toBoolean } from "./object.ts";
 
 /** `process`-shaped view off `globalThis`, so no node types are needed. */

package/src/pattern.ts

@@ -38,7 +38,7 @@
 
 import { logger } from "./log.ts";
 import * as predicate from "./predicate.ts";
-import { parseList } from "./string.ts";
+import { parseList } from "./string-utils.ts";
 
 const log = logger("shared/pattern");
 

package/src/{string.ts → string-utils.ts}

@@ -47,6 +47,18 @@ export type IdentifierOptions = KeyOptions & {
   delimiter?: string;
 };
 
+/** Leading and trailing blank-line handling for {@link dedent}. */
+export type DedentOptions = {
+  /** Remove leading blank lines after indentation normalization. Defaults to `true`. */
+  trimStart?: boolean;
+  /**
+   * Remove trailing blank lines after indentation normalization. Defaults to `true`.
+   */
+  trimEnd?: boolean;
+  /** Remove spaces and tabs from each line end. Defaults to `true`. */
+  trimLineEnd?: boolean;
+};
+
 type ResolvedTokenizeOptions = Required<TokenizeOptions>;
 type ResolvedIdentifierOptions = Required<
   IdentifierOptions & Pick<TokenizeOptions, "lowerCase" | "capitalize">
@@ -420,7 +432,7 @@ export function toDescription(node: Description): string {
 
 function renderBlock(node: Description, pad: string): string {
   if (node == null) return "";
-  if (typeof node === "string") return prependPad(dedentSection(node), pad);
+  if (typeof node === "string") return prependPad(dedent(node), pad);
   if (Array.isArray(node)) return renderSequence(node, pad);
   const kind = listKind(node as Record<string, unknown>);
   if (kind) {
@@ -430,18 +442,17 @@ function renderBlock(node: Description, pad: string): string {
 }
 
 /**
- * Normalize a string section: right-strip every line, drop the
- * common leading-whitespace prefix shared by all non-blank lines,
- * and trim leading / trailing blank lines. Matches Python's
- * `textwrap.dedent` semantics so embedded indented template
- * literals round-trip cleanly.
+ * Right-strip every line, remove common indentation, and optionally trim
+ * leading and trailing blank lines. Whitespace-only lines normalize to empty
+ * lines, matching common dedent implementations.
  */
-function dedentSection(text: string): string {
-  if (!text) return "";
-  const lines = text.split("\n").map((line) => line.replace(/[ \t]+$/, ""));
+export function dedentLines(text: string, options: DedentOptions = {}): string[] {
+  if (!text) return [];
+  const { trimStart = true, trimEnd = true, trimLineEnd = true } = options;
+  const lines = text.split("\n").map((line) => (trimLineEnd ? line.replace(/[ \t]+$/, "") : line));
   let min = Infinity;
   for (const line of lines) {
-    if (!line) continue;
+    if (!line.trim()) continue;
     const match = /^[ \t]*/.exec(line);
     const width = match ? match[0].length : 0;
     if (width < min) min = width;
@@ -450,9 +461,18 @@ function dedentSection(text: string): string {
     min === Infinity || min === 0 ? lines : lines.map((line) => (line ? line.slice(min) : ""));
   let start = 0;
   let end = stripped.length;
-  while (start < end && !stripped[start]) start += 1;
-  while (end > start && !stripped[end - 1]) end -= 1;
-  return stripped.slice(start, end).join("\n");
+  if (trimStart) {
+    while (start < end && !stripped[start]!.trim()) start += 1;
+  }
+  if (trimEnd) {
+    while (end > start && !stripped[end - 1]!.trim()) end -= 1;
+  }
+  return stripped.slice(start, end);
+}
+
+/** Join {@link dedentLines}, trimming leading and trailing blank lines by default. */
+export function dedent(text: string, options: DedentOptions = {}): string {
+  return dedentLines(text, options).join("\n");
 }
 
 /**

package/lib/src/async.js

@@ -1,169 +0,0 @@
-/**
- * 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];
-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.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.ts\";\n\nconst DEFAULT_RETRY_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000] as const;\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"]}

package/lib/src/brand.js

@@ -1,132 +0,0 @@
-/**
- * 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";
-const nonBlankString = z.string().trim().min(1);
-const color = z.string().regex(/^#(?:[\da-f]{3}|[\da-f]{6}|[\da-f]{8})$/i, "Expected a hex color.");
-/** Package asset references used when a brand context supplies no custom artwork. */
-export const DEFAULT_BRAND_ASSETS = {
-    icon: {
-        light: "@dbx-tools/ui-branding/assets/icon-light.svg",
-        dark: "@dbx-tools/ui-branding/assets/icon-dark.svg",
-    },
-    logo: {
-        light: "@dbx-tools/ui-branding/assets/logo-light.svg",
-        dark: "@dbx-tools/ui-branding/assets/logo-dark.svg",
-    },
-    favicon: "@dbx-tools/ui-branding/assets/icon-light.svg",
-};
-/** Validates light and optional dark variants for one visual asset. */
-export const BrandAssetSetSchema = z
-    .object({
-    light: nonBlankString.describe("Asset for light surfaces."),
-    dark: nonBlankString.optional().describe("Asset for dark surfaces; light is the fallback."),
-})
-    .strict()
-    .describe("Theme-aware references to one visual asset.");
-/** Strict brand palette whose omitted colors resolve to the dbx tools defaults. */
-export const BrandColorsSchema = z
-    .object({
-    primary: color.default("#1B3139").describe("Primary action and identity color."),
-    primaryHover: color.default("#0E538B").describe("Primary hover or pressed color."),
-    accent: color.default("#00A972").describe("Secondary accent color."),
-    foreground: color.default("#1B3139").describe("Default text and mark color."),
-    background: color.default("#FFFFFF").describe("Default page background."),
-    surface: color.default("#F9F7F4").describe("Secondary surface background."),
-    muted: color.default("#618794").describe("Muted text color."),
-    border: color.default("#E4E2DD").describe("Default border color."),
-})
-    .strict()
-    .prefault({});
-/** Strict audience, tone, principle, and avoidance lists with practical defaults. */
-export const BrandVoiceSchema = z
-    .object({
-    audience: z
-        .array(nonBlankString)
-        .default(["Databricks developers", "application engineers", "AI agents"]),
-    tone: z.array(nonBlankString).default(["direct", "practical", "technical", "approachable"]),
-    principles: z
-        .array(nonBlankString)
-        .default([
-        "Lead with the useful outcome.",
-        "Prefer concrete examples and accurate technical language.",
-        "Keep product claims specific and defensible.",
-    ]),
-    avoid: z
-        .array(nonBlankString)
-        .default(["unsupported superlatives", "vague AI claims", "unnecessary jargon"]),
-})
-    .strict()
-    .prefault({});
-/**
- * Strict portable brand contract that fills identity, assets, colors,
- * typography, voice, links, and extension defaults during parsing.
- */
-export const BrandContextSchema = z
-    .object({
-    schemaVersion: z.literal("1").default("1"),
-    name: nonBlankString.default("dbx tools").describe("Canonical display name."),
-    shortName: nonBlankString.default("dbx").describe("Compact name for constrained UI."),
-    tagline: nonBlankString
-        .default("Practical tools for Databricks builders.")
-        .describe("Short product line suitable for a header or metadata."),
-    description: nonBlankString
-        .default("Companion packages for Databricks developers building apps, agents, data workflows, and reusable UI.")
-        .describe("Plain-language product description."),
-    assets: z
-        .object({
-        icon: BrandAssetSetSchema.default(DEFAULT_BRAND_ASSETS.icon),
-        logo: BrandAssetSetSchema.default(DEFAULT_BRAND_ASSETS.logo),
-        favicon: nonBlankString.default(DEFAULT_BRAND_ASSETS.favicon),
-    })
-        .strict()
-        .default(DEFAULT_BRAND_ASSETS),
-    colors: BrandColorsSchema,
-    typography: z
-        .object({
-        sans: nonBlankString.default("'DM Sans', ui-sans-serif, system-ui, sans-serif"),
-        mono: nonBlankString.default("'DM Mono', ui-monospace, SFMono-Regular, Menlo, monospace"),
-    })
-        .strict()
-        .prefault({}),
-    voice: BrandVoiceSchema,
-    links: z
-        .object({
-        website: z.string().url().optional(),
-        repository: z.string().url().optional(),
-        documentation: z.string().url().optional(),
-    })
-        .strict()
-        .default({}),
-    extensions: z
-        .record(nonBlankString, z.unknown())
-        .default({})
-        .describe("Namespaced consumer-specific values that do not belong in the portable core."),
-})
-    .strict()
-    .describe("Portable identity, visual, and voice context for UI, libraries, and LLMs.");
-/** Validate input and fill every dbx tools default. */
-export function parseBrandContext(input = {}) {
-    return BrandContextSchema.parse(input);
-}
-/** Canonical dbx tools brand context with all schema defaults resolved. */
-export const defaultBrandContext = parseBrandContext();
-/** JSON Schema representation suitable for structured-output and tool definitions. */
-export function brandContextJsonSchema() {
-    return z.toJSONSchema(BrandContextSchema);
-}
-/** Stable prompt block for an LLM that needs to write or design in this brand. */
-export function brandContextPrompt(context = defaultBrandContext) {
-    return [
-        `Use the following ${context.name} brand context for names, visual choices, and writing voice.`,
-        "Treat explicit task instructions as higher priority than this context.",
-        "",
-        JSON.stringify(context, null, 2),
-    ].join("\n");
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brand.js","sourceRoot":"","sources":["../../src/brand.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-safe brand contract, defaults, and LLM serialization helpers.\n *\n * Asset values are intentionally strings: they may be relative file paths,\n * package exports, data URLs, or network URLs depending on the consumer.\n *\n * @module\n */\nimport { z } from \"zod\";\n\nconst nonBlankString = z.string().trim().min(1);\nconst color = z.string().regex(/^#(?:[\\da-f]{3}|[\\da-f]{6}|[\\da-f]{8})$/i, \"Expected a hex color.\");\n\n/** Package asset references used when a brand context supplies no custom artwork. */\nexport const DEFAULT_BRAND_ASSETS = {\n  icon: {\n    light: \"@dbx-tools/ui-branding/assets/icon-light.svg\",\n    dark: \"@dbx-tools/ui-branding/assets/icon-dark.svg\",\n  },\n  logo: {\n    light: \"@dbx-tools/ui-branding/assets/logo-light.svg\",\n    dark: \"@dbx-tools/ui-branding/assets/logo-dark.svg\",\n  },\n  favicon: \"@dbx-tools/ui-branding/assets/icon-light.svg\",\n} as const;\n\n/** Validates light and optional dark variants for one visual asset. */\nexport const BrandAssetSetSchema = z\n  .object({\n    light: nonBlankString.describe(\"Asset for light surfaces.\"),\n    dark: nonBlankString.optional().describe(\"Asset for dark surfaces; light is the fallback.\"),\n  })\n  .strict()\n  .describe(\"Theme-aware references to one visual asset.\");\n\n/** Strict brand palette whose omitted colors resolve to the dbx tools defaults. */\nexport const BrandColorsSchema = z\n  .object({\n    primary: color.default(\"#1B3139\").describe(\"Primary action and identity color.\"),\n    primaryHover: color.default(\"#0E538B\").describe(\"Primary hover or pressed color.\"),\n    accent: color.default(\"#00A972\").describe(\"Secondary accent color.\"),\n    foreground: color.default(\"#1B3139\").describe(\"Default text and mark color.\"),\n    background: color.default(\"#FFFFFF\").describe(\"Default page background.\"),\n    surface: color.default(\"#F9F7F4\").describe(\"Secondary surface background.\"),\n    muted: color.default(\"#618794\").describe(\"Muted text color.\"),\n    border: color.default(\"#E4E2DD\").describe(\"Default border color.\"),\n  })\n  .strict()\n  .prefault({});\n\n/** Strict audience, tone, principle, and avoidance lists with practical defaults. */\nexport const BrandVoiceSchema = z\n  .object({\n    audience: z\n      .array(nonBlankString)\n      .default([\"Databricks developers\", \"application engineers\", \"AI agents\"]),\n    tone: z.array(nonBlankString).default([\"direct\", \"practical\", \"technical\", \"approachable\"]),\n    principles: z\n      .array(nonBlankString)\n      .default([\n        \"Lead with the useful outcome.\",\n        \"Prefer concrete examples and accurate technical language.\",\n        \"Keep product claims specific and defensible.\",\n      ]),\n    avoid: z\n      .array(nonBlankString)\n      .default([\"unsupported superlatives\", \"vague AI claims\", \"unnecessary jargon\"]),\n  })\n  .strict()\n  .prefault({});\n\n/**\n * Strict portable brand contract that fills identity, assets, colors,\n * typography, voice, links, and extension defaults during parsing.\n */\nexport const BrandContextSchema = z\n  .object({\n    schemaVersion: z.literal(\"1\").default(\"1\"),\n    name: nonBlankString.default(\"dbx tools\").describe(\"Canonical display name.\"),\n    shortName: nonBlankString.default(\"dbx\").describe(\"Compact name for constrained UI.\"),\n    tagline: nonBlankString\n      .default(\"Practical tools for Databricks builders.\")\n      .describe(\"Short product line suitable for a header or metadata.\"),\n    description: nonBlankString\n      .default(\n        \"Companion packages for Databricks developers building apps, agents, data workflows, and reusable UI.\",\n      )\n      .describe(\"Plain-language product description.\"),\n    assets: z\n      .object({\n        icon: BrandAssetSetSchema.default(DEFAULT_BRAND_ASSETS.icon),\n        logo: BrandAssetSetSchema.default(DEFAULT_BRAND_ASSETS.logo),\n        favicon: nonBlankString.default(DEFAULT_BRAND_ASSETS.favicon),\n      })\n      .strict()\n      .default(DEFAULT_BRAND_ASSETS),\n    colors: BrandColorsSchema,\n    typography: z\n      .object({\n        sans: nonBlankString.default(\"'DM Sans', ui-sans-serif, system-ui, sans-serif\"),\n        mono: nonBlankString.default(\"'DM Mono', ui-monospace, SFMono-Regular, Menlo, monospace\"),\n      })\n      .strict()\n      .prefault({}),\n    voice: BrandVoiceSchema,\n    links: z\n      .object({\n        website: z.string().url().optional(),\n        repository: z.string().url().optional(),\n        documentation: z.string().url().optional(),\n      })\n      .strict()\n      .default({}),\n    extensions: z\n      .record(nonBlankString, z.unknown())\n      .default({})\n      .describe(\"Namespaced consumer-specific values that do not belong in the portable core.\"),\n  })\n  .strict()\n  .describe(\"Portable identity, visual, and voice context for UI, libraries, and LLMs.\");\n\n/** Fully validated brand context after every schema default has been applied. */\nexport type BrandContext = z.output<typeof BrandContextSchema>;\n/** Input accepted by {@link BrandContextSchema}, before defaults are materialized. */\nexport type BrandContextInput = z.input<typeof BrandContextSchema>;\n/** Theme-aware light and optional dark references for one brand asset. */\nexport type BrandAssetSet = z.output<typeof BrandAssetSetSchema>;\n\n/** Validate input and fill every dbx tools default. */\nexport function parseBrandContext(input: unknown = {}): BrandContext {\n  return BrandContextSchema.parse(input);\n}\n\n/** Canonical dbx tools brand context with all schema defaults resolved. */\nexport const defaultBrandContext: BrandContext = parseBrandContext();\n\n/** JSON Schema representation suitable for structured-output and tool definitions. */\nexport function brandContextJsonSchema(): Record<string, unknown> {\n  return z.toJSONSchema(BrandContextSchema) as Record<string, unknown>;\n}\n\n/** Stable prompt block for an LLM that needs to write or design in this brand. */\nexport function brandContextPrompt(context: BrandContext = defaultBrandContext): string {\n  return [\n    `Use the following ${context.name} brand context for names, visual choices, and writing voice.`,\n    \"Treat explicit task instructions as higher priority than this context.\",\n    \"\",\n    JSON.stringify(context, null, 2),\n  ].join(\"\\n\");\n}\n"]}