@dbx-tools/shared-core 0.9.131 → 0.9.133

package/README.md

@@ -1,9 +1,11 @@
 # @dbx-tools/shared-core
 
-Browser-safe utility base for `@dbx-tools/*` packages.
+Use browser-safe utilities shared by `@dbx-tools/*` packages in browsers,
+workers, Node, Bun, CLIs, and schema packages. The package includes logging,
+options, networking, JSON, hashing, predicates, and other dependency-light
+foundations.
 
-These dependency-free helpers run in Node, browsers, workers, CLIs, and shared
-schema packages. Modules are exported as namespaces so call sites stay explicit:
+Import the namespaces that your code uses:
 
 ```ts
 import {
@@ -11,6 +13,8 @@ import {
   brandUtils,
   environmentUtils,
   errorUtils,
+  execution,
+  functionUtils,
   hash,
   http,
   json,
@@ -18,20 +22,23 @@ import {
   net,
   object,
   options,
+  pattern,
+  predicate,
   stringUtils,
+  token,
 } from "@dbx-tools/shared-core";
 ```
 
-Node-only helpers live in [`@dbx-tools/core`](../../node/core). AppKit and
-Databricks SDK helpers live in [`@dbx-tools/appkit`](../../node/appkit).
+Node-only helpers live in [@dbx-tools/core](../../node/core). AppKit and
+Databricks SDK helpers live in [@dbx-tools/appkit](../../node/appkit).
 
-Key features:
+Use these utilities for:
 
 - Abort-aware async utilities for polling, sleeping, and connecting cancellation
   across web and Node runtimes.
 - Error normalization for unknown thrown values, nested causes, and HTTP-ish
   status/message extraction.
-- Deterministic non-cryptographic hashes and short ids for cache keys, slugs,
+- Deterministic non-cryptographic hashes and short IDs for cache keys, slugs,
   and generated names.
 - Non-throwing JSON parsing for untrusted input, with record narrowing so parsed
   data is not cast blindly.
@@ -41,12 +48,19 @@ Key features:
   logging helpers that avoid Node-only dependencies.
 - Namespace exports that make utility call sites explicit without creating a
   grab-bag default import.
-- A Zod-backed `BrandContext` contract with dbx tools defaults, JSON Schema
+- A Zod-backed `BrandContext` contract with dbx-tools defaults, JSON Schema
   output, and prompt serialization for browser, library, and LLM consumers.
 - Shared Zod option schemas for Databricks environment names, normalized URLs,
   TCP ports, listener addresses, and schema-driven parse/serialization.
 
-## Brand Context
+## Runtime boundary
+
+This package doesn't read files, discover Databricks credentials, or call
+workspace APIs. Node-only configuration and filesystem behavior lives in
+[@dbx-tools/core](../../node/core). AppKit integration lives in
+[@dbx-tools/appkit](../../node/appkit).
+
+## Brand context
 
 ```ts
 import { brandUtils } from "@dbx-tools/shared-core";
@@ -58,11 +72,11 @@ const instructions = brandUtils.brandContextPrompt(context);
 
 `BrandContextSchema` validates identity, theme-aware assets, colors,
 typography, links, audience, and voice. Every field has a dbx tools default, so
-an empty object is a complete context. Use [`@dbx-tools/core`](../../node/core)
+an empty object is a complete context. Use [@dbx-tools/core](../../node/core)
 to discover and read YAML/JSON files, and
-[`@dbx-tools/ui/branding`](../../ui/appkit) to apply the same context to a UI.
+[@dbx-tools/ui/branding](../../ui/appkit) to apply the same context to a UI.
 
-## Async Control
+## Control asynchronous work
 
 ```ts
 for await (const status of asyncUtils.poll(fetchStatus, {
@@ -80,7 +94,7 @@ await asyncUtils.sleep(500, abortSignal);
 `asyncUtils.tieAbortSignal()` and `asyncUtils.sleep()` let route handlers connect caller
 cancellation to background work.
 
-## Error Handling
+## Handle errors
 
 ```ts
 try {
@@ -96,7 +110,7 @@ try {
 `errorUtils.errorNodes()` normalize unknown thrown values. `errorUtils.errorContext()`
 extracts HTTP-ish status/message detail from nested errors.
 
-## Hashes And Ids
+## Create hashes and IDs
 
 ```ts
 const id = hash.id(8);
@@ -107,7 +121,7 @@ const suffix = hash.fnvHashWithOptions({ length: 6 }, longName);
 These hashes are deterministic and non-cryptographic. Use them for cache keys,
 slug suffixes, and trace-stable identifiers, not secrets or signatures.
 
-## Parsing Untrusted JSON
+## Parse untrusted JSON
 
 ```ts
 const body = json.parseRecord(await readRequestText(req)) ?? {};
@@ -119,15 +133,15 @@ const settings = json.parse<Settings>(process.env.SETTINGS, DEFAULT_SETTINGS);
 
 `json.parse()` returns the fallback (or `undefined`) instead of throwing, so a
 malformed request body, env var, config file, subprocess stdout, or third-party
-response does not need its own `try`/`catch`. `json.parseRecord()` additionally
+response does not need its own `try`/`catch`. `json.parseRecord()` also
 narrows to `Record<string, unknown>`, which a bare `JSON.parse(...) as Record<...>`
 does not: it rejects a parsed `null`, array, or scalar rather than letting it
 through as an object.
 
 Reach for `JSON.parse` directly only when a throw is the correct outcome, such as
-reading a file this repo generated itself.
+reading a trusted generated file.
 
-## Strings And Descriptions
+## Normalize strings and descriptions
 
 ```ts
 const slug = stringUtils.toSlug("My Cool Project!");
@@ -144,7 +158,7 @@ const description = stringUtils.toDescription([
 ```
 
 `stringUtils.tokenize()`, `toSlug()`, and `toIdentifier()` keep package names, tool
-ids, schema ids, and generated labels consistent. `toDescription()` turns nested
+IDs, schema IDs, and generated labels consistent. `toDescription()` turns nested
 description data into prompt/tool text without hand-concatenating paragraphs.
 `dedent()` removes common indentation and surrounding blank lines from multiline
 code or configuration templates. Its `trimStart` and `trimEnd` options preserve
@@ -152,7 +166,7 @@ boundary blank lines when generated output requires them, while `trimLineEnd:
 false` preserves trailing spaces and tabs. `dedentLines()` returns the same
 normalization as a line array for file generators.
 
-Three helpers exist so call sites stop re-implementing them:
+Use the following helpers for common labels and configuration values:
 
 ```ts
 const label = stringUtils.toLabel("web_search"); // "Web Search"
@@ -167,7 +181,7 @@ field off parsed JSON. `parseList()` normalizes a config value that may arrive a
 an array or as one comma/whitespace-separated env string, de-duplicating as it
 goes.
 
-## Objects And Predicates
+## Work with objects and predicates
 
 ```ts
 if (object.isRecord(value)) {
@@ -185,7 +199,7 @@ const isRunnable = predicate
 short-circuits. `predicate.create()` returns composable predicates with `and`,
 `or`, and `negate`, used heavily by the projen engine.
 
-## Serializable Values And Stable Identities
+## Validate serializable values and stable identities
 
 ```ts
 if (object.isSerializableValue(requestBody)) {
@@ -207,11 +221,11 @@ it. Object key order does not affect the result, but types and structure do:
 `1` and `"1"` differ, and so do `["a", "bc"]` and `["ab", "c"]`. It throws on a
 cycle, a non-finite number, or a function/symbol rather than returning an
 identity two callers could disagree about. `@dbx-tools/postgres` derives both its
-advisory-lock ids and its notification channel names through it. Use
-`hash.fnvHash()` instead when a short collision-tolerant digest is enough — its
+advisory-lock IDs and its notification channel names through it. Use
+`hash.fnvHash()` instead when a short collision-tolerant digest is enough. Its
 canonicalizer is looser and folds every `Date` onto one token.
 
-## Numbers, Dates, And Durations
+## Parse numbers, dates, and durations
 
 ```ts
 object.toNumber("1,000"); //     1000
@@ -233,8 +247,8 @@ object.toDuration("-7d"); //               -604_800_000
 object.toDuration("2026-08-02"); //        ms from now until that instant
 ```
 
-All three are for values typed by HAND into env vars, CLI flags, and config
-files, so they are deliberately lenient: whitespace between amount and unit is
+These helpers parse values entered in environment variables, CLI flags, and
+configuration files. Whitespace between the amount and unit is
 optional, units are case-insensitive, and plurals and abbreviations are
 equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`). Signs make
 a duration an OFFSET, which is what lets `toDate` read `-30d` / `12 hours ago` /
@@ -244,9 +258,9 @@ a duration an OFFSET, which is what lets `toDate` read `-30d` / `12 hours ago` /
 over `Number(value)` is that `Number` invents values: `""`, `null`, `[]`, and a
 whitespace string all become `0`, so every caller has to re-check the result.
 `toNumber` returns `undefined` instead, and accepts the spellings a person
-actually types — digit-group separators, a bare fraction, a trailing point, an
-exponent, a trailing percent. `ToNumberOptions` disables the `separators` and
-`percent` leniencies for a string whose other characters carry meaning; a SQL
+actually types, including digit-group separators, a bare fraction, a trailing point, an
+exponent, and a trailing percent. `ToNumberOptions` disables the `separators` and
+`percent` leniencies for a string whose other characters carry meaning. A SQL
 cell uses that so `"1,000"` in a text column stays the string the query returned.
 
 `toDate` exists rather than `new Date(value)` because a bare epoch usually
@@ -255,17 +269,17 @@ arrives as a STRING (`date +%s`, a JSON field, a copied log line) and
 Numeric input is therefore routed to the epoch path, with values under `1e11`
 read as seconds and the rest as milliseconds. An unknown unit fails the whole
 duration parse instead of being skipped, so `1 fortnight` is `undefined` rather
-than `1`. Neither function throws - like `toBoolean` they return `undefined`, so
+than `1`. Neither function throws. Like `toBoolean`, they return `undefined`, so
 the caller decides whether a bad value is fatal, a warning, or a fallback
 (`@dbx-tools/tunnel`'s `TUNNEL_AUTH_SESSION_CUTOFF` warns and carries on).
 
-### Dates And Durations Are Inverses
+### Dates and durations are inverses
 
 Each function falls back to the other, so one field accepts both readings: a
 duration reaching `toDate` resolves against now, and a date reaching
 `toDuration` becomes the signed offset from now (`date - now`, so a past instant
-is negative). Each tries its own reading first — `toDate` runs `Date.parse`
-before the duration fallback — and recurses with the other's parser off, so a
+is negative). Each tries its own reading first. `toDate` runs `Date.parse`
+before the duration fallback and recurses with the other's parser off, so a
 value cannot bounce between them.
 
 ```ts
@@ -279,7 +293,7 @@ the current clock makes the same input mean something different on every call. A
 timeout or a poll interval must not accept a date, because it would yield a
 plausible but wrong number that also drifts.
 
-## Iterables
+## Transform iterables
 
 ```ts
 const names = object
@@ -299,7 +313,7 @@ The iterable helpers are lazy and work well for filesystem scans, package lists,
 and one-pass generated data. Use `sequence(..., { cache: true })` when a source
 must be re-read.
 
-## HTTP Headers And Cookies
+## Read HTTP headers and cookies
 
 ```ts
 const cookies = http.parseCookies(req);
@@ -314,14 +328,14 @@ http.forEachHeaderValue(req, "authorization", (value) => {
 records, and plain `{ headers }` objects. `http.createFetchError()` turns a
 failed `Response` into an error with response text attached.
 
-## Intercepted Execution
+## Run intercepted execution
 
 `execution.directExecutor()` gives plugin-backed tools a no-plugin fallback with
 the same success/failure shape as AppKit's executor. `execution.run()` merges the
 plugin timeout signal with the caller's cancellation signal and centralizes
 result unwrapping without imposing an AppKit dependency on shared code.
 
-## Network Strings, Email, And CIDR
+## Parse network strings, email addresses, and CIDR blocks
 
 ```ts
 const url = net.urlBuilder("example.com")?.withPathAppend("api", "2.0");
@@ -334,10 +348,10 @@ const internal = cidr ? net.ipInCidr("10.1.2.3", cidr) : false;
 `urlBuilder(...).pathMatches()` compares path prefixes on segment boundaries.
 IP/CIDR helpers parse IPv4 and IPv6 into a shared bigint comparison model.
 
-## Allow-List Patterns
+## Compile allowlist patterns
 
 ```ts
-// One matcher from a config array OR a delimited env stringUtils.
+// One matcher from a config array or a delimited environment string.
 const forwardable = pattern.toPatternMatcher(["x-mastra-*", "/^x-trace-/", "x-tenant"]);
 
 forwardable("x-mastra-model"); // true  (glob)
@@ -346,25 +360,25 @@ forwardable("x-tenant"); // true  (literal, whole-string)
 forwardable("x-forwarded-user"); // false
 ```
 
-Every configurable allow-list in this repo takes the same three shapes, so the
+Configurable allowlists accept 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-stringUtils. Matching is case-insensitive by default -
-what HTTP header names and email addresses both want - and `caseSensitive` opts
-out.
+or a literal compared as a whole string. Matching is case-insensitive by
+default, which suits HTTP header names and email addresses. Set `caseSensitive`
+to opt out.
 
 An invalid regex is skipped with a warning instead of throwing, so one bad
 config entry cannot stop a process from starting. No usable patterns yields a
-matcher that always returns `false`; a caller that reads "no patterns" as "permit
+matcher that always returns `false`. A caller that reads "no patterns" as "permit
 everything" must say so itself. The result is a `predicate`, so it composes with
 `.and()` / `.or()` / `.negate()`.
 
-Reach for [`@dbx-tools/path`](../../node/path)'s `toPathMatcher` instead when
+Use [@dbx-tools/path](../../node/path)'s `toPathMatcher` instead when
 matching a filesystem path or URL path, where `/` is a segment boundary and `**`
-is meaningful - that one is `minimatch`-backed. This module is deliberately
+is meaningful. That matcher uses `minimatch`. This module remains
 dependency-free so it stays usable in a browser bundle.
 
-## Token Claims
+## Read token claims
 
 ```ts
 const scopes = token.getAccessTokenScopes(req, "x-forwarded-access-token");
@@ -375,7 +389,7 @@ Token helpers decode JWT payloads without validating signatures. Use them for
 request-scoped authorization hints after the platform has already authenticated
 the request.
 
-## Memoization
+## Memoize functions
 
 ```ts
 const getRanges = functionUtils.memoize(fetchRanges, {
@@ -385,13 +399,13 @@ const getRanges = functionUtils.memoize(fetchRanges, {
 
 `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.
+SDK catalogs, and expensive computed constants.
 
 Serializing whole callbacks rather than caching one value is a Node concern
 (it needs `node:worker_threads`), so it lives in
-[`@dbx-tools/core`](../../node/core)'s `processLock` instead.
+[@dbx-tools/core](../../node/core)'s `processLock` instead.
 
-## Logging
+## Write logs
 
 ```ts
 const logger = log.logger("mastra/genie");
@@ -407,30 +421,30 @@ formatted process streams on server runtimes: debug/info use stdout and
 warn/error use stderr. It honors `LOG_LEVEL` per call, so debug statements can
 stay in production code without paying formatting cost when disabled.
 
-## Modules
+## Package exports
 
-- `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()`.
-- `stringUtils` - tokenization, slugs, identifiers, human labels, string coercion,
+- `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()`.
+- `stringUtils`: tokenization, slugs, identifiers, human labels, string coercion,
   config lists, multiline string/line dedenting, descriptions, pluralization,
   and HTML escaping.
-- `object` - record checks, number/boolean/date/duration coercion, present-only
+- `object`: record checks, number/boolean/date/duration coercion, present-only
   field spreading, deep equality, JSON-round-trip guards
   (`isSerializableValue`), canonical identity keys (`toStableKey`), shape types,
   and lazy sequence transforms + collection helpers.
-- `predicate` - composable boolean/type predicates.
-- `pattern` - literal / glob / `/regex/` allow-list matching compiled to a
+- `predicate`: composable boolean/type predicates.
+- `pattern`: literal, glob, and `/regex/` allowlist matching compiled to a
   predicate.
-- `http` - header iteration, cookie parsing, and fetch error creation.
-- `execution` - direct executor fallback, cancellation merging, and result unwrapping.
-- `net` - URL building, email parsing, path matching, IP/CIDR helpers.
-- `options` - Databricks environment/config schemas, ports, listener addresses,
+- `http`: header iteration, cookie parsing, and fetch error creation.
+- `execution`: direct executor fallback, cancellation merging, and result unwrapping.
+- `net`: URL building, email parsing, path matching, and IP/CIDR helpers.
+- `options`: Databricks environment/config schemas, ports, listener addresses,
   URL normalization, nullable map parsing, and flag/env JSON serialization.
-- `token` - JWT payload and scope readers.
-- `functionUtils` - memoization.
-- `log` - tagged leveled logging.
-- `brandUtils` - Zod schema, defaults, JSON Schema, and LLM prompt serialization.
-- `environmentUtils` - Databricks App runtime detection from App env vars or the
+- `token`: JWT payload and scope readers.
+- `functionUtils`: memoization.
+- `log`: tagged leveled logging.
+- `brandUtils`: Zod schema, defaults, JSON Schema, and LLM prompt serialization.
+- `environmentUtils`: Databricks App runtime detection from App env vars or the
   Apps container source tree.

package/index.ts

@@ -3,7 +3,7 @@
 // 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.131";
+export const PACKAGE_VERSION = "0.9.133";
 export * as asyncUtils from "./src/async-utils.ts";
 export * as bindings from "./src/bindings.ts";
 export * as brandUtils from "./src/brand-utils.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export declare const PACKAGE_VERSION = "0.9.131";
+export declare const PACKAGE_VERSION = "0.9.133";
 export * as asyncUtils from "./src/async-utils.ts";
 export * as bindings from "./src/bindings.ts";
 export * as brandUtils from "./src/brand-utils.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // 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.131";
+export const PACKAGE_VERSION = "0.9.133";
 export * as asyncUtils from "./src/async-utils.js";
 export * as bindings from "./src/bindings.js";
 export * as brandUtils from "./src/brand-utils.js";
@@ -26,4 +26,4 @@ export { DATABRICKS_APP_SOURCE_ROOT } from "./src/environment-utils.js";
 export { MAX_TCP_PORT } from "./src/net.js";
 export { DatabricksEnvironmentNamesSchema, databricksEnvironmentNames, PostgresEnvironmentNamesSchema, postgresEnvironmentNames, postgresRoleSchema, PostgresOptionsSchema, PostgresConfigOptionsSchema, tcpPortSchema, tcpPortOrZeroSchema, normalizedUrlSchema, DatabricksOptionsSchema, LakebaseOptionsSchema, TcpListenAddressSchema, UnixListenAddressSchema } from "./src/options.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/brand-utils.d.ts

@@ -86,7 +86,7 @@ export declare const BrandContextSchema: z.ZodObject<{
     links: z.ZodPrefault<z.ZodObject<{
         website: z.ZodDefault<z.ZodString>;
         repository: z.ZodOptional<z.ZodString>;
-        documentation: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
     extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;

package/lib/src/brand-utils.js

@@ -99,7 +99,7 @@ export const BrandContextSchema = z
         .object({
         website: z.string().url().default("https://dbx.tools"),
         repository: z.string().url().optional(),
-        documentation: z.string().url().optional(),
+        documentation: z.string().url().default("https://docs.dbx.tools/"),
     })
         .strict()
         .prefault({}),
@@ -129,4 +129,4 @@ export function brandContextPrompt(context = defaultBrandContext) {
         JSON.stringify(context, null, 2),
     ].join("\n");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brand-utils.js","sourceRoot":"","sources":["../../src/brand-utils.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().default(\"https://dbx.tools\"),\n        repository: z.string().url().optional(),\n        documentation: z.string().url().optional(),\n      })\n      .strict()\n      .prefault({}),\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brand-utils.js","sourceRoot":"","sources":["../../src/brand-utils.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().default(\"https://dbx.tools\"),\n        repository: z.string().url().optional(),\n        documentation: z.string().url().default(\"https://docs.dbx.tools/\"),\n      })\n      .strict()\n      .prefault({}),\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"]}

package/package.json

@@ -114,7 +114,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.131",
+  "version": "0.9.133",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [

package/src/brand-utils.ts

@@ -107,7 +107,7 @@ export const BrandContextSchema = z
       .object({
         website: z.string().url().default("https://dbx.tools"),
         repository: z.string().url().optional(),
-        documentation: z.string().url().optional(),
+        documentation: z.string().url().default("https://docs.dbx.tools/"),
       })
       .strict()
       .prefault({}),