@dbx-tools/shared-core 0.9.5 → 0.9.6

package/lib/src/string-utils.js

@@ -0,0 +1,513 @@
+/**
+ * Browser-safe string toolkit: tokenization, identifier / slug
+ * generation (with hash-suffix collision resistance), HTML escaping,
+ * header-value trimming, and a nested description-tree renderer for
+ * long-form LLM prompt / tool-description text. Depends only on the
+ * local {@link fnvHashWithOptions} for deterministic hash suffixes.
+ *
+ * @module
+ */
+import { fnvHashWithOptions } from "./hash.js";
+// A leading `v`/`V` immediately followed by digits (a version marker like
+// `v2`) is kept as ONE token instead of splitting into `v` + `2`; it leads the
+// alternation so it wins over the generic letter / digit runs. Everything else
+// is the usual camelCase word / number / all-caps-acronym split.
+const TOKENIZE_CAMEL_CASE_REGEXP = /[vV][0-9]+|[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;
+const TOKENIZE_NON_ALPHANUMERIC_REGEXP = /[a-zA-Z0-9]+/g;
+const TOKENIZE_OVERRIDES = [
+    (token, options) => {
+        if (!options.capitalize)
+            return token;
+        const lower = token.toLowerCase();
+        if (lower === "ai")
+            return "AI";
+        if (lower === "fs")
+            return "FS";
+        return token;
+    },
+    // Version marker `v2` -> `V2` when capitalizing (the leading `v` uppercases,
+    // the digits stay), so it reads as one unit rather than "V 2".
+    (token, options) => {
+        if (options.capitalize && /^v[0-9]+$/.test(token)) {
+            return `V${token.slice(1)}`;
+        }
+        return token;
+    },
+];
+const URI_REGEXP = /^([a-zA-Z][a-zA-Z0-9+.-]*)?:\/\/([^\s/?#][^\s]*)?$/;
+const EMAIL_REGEXP = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+)@([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+)$/;
+const TOKENIZE_DEFAULTS = {
+    distinct: false,
+    lowerCase: false,
+    capitalize: false,
+    omitUriScheme: false,
+    omitEmailDomain: false,
+    camelCase: true,
+};
+const IDENTIFIER_DEFAULTS = {
+    ...TOKENIZE_DEFAULTS,
+    lowerCase: true,
+    maxLength: Infinity,
+    truncateStrategy: "hash",
+    truncateHashLength: 6,
+    delimiter: "-",
+};
+export function* tokenizeWithOptions(options, ...values) {
+    const opts = { ...TOKENIZE_DEFAULTS, ...options };
+    const seen = opts.distinct ? new Set() : undefined;
+    const regexp = opts.camelCase ? TOKENIZE_CAMEL_CASE_REGEXP : TOKENIZE_NON_ALPHANUMERIC_REGEXP;
+    for (const value of values) {
+        if (value == null)
+            continue;
+        let stringValue = typeof value === "string" ? value : String(value);
+        if (!stringValue)
+            continue;
+        if (opts.omitUriScheme) {
+            const match = stringValue.match(URI_REGEXP);
+            if (match)
+                stringValue = match[2] ?? "";
+        }
+        if (opts.omitEmailDomain) {
+            const match = stringValue.match(EMAIL_REGEXP);
+            if (match)
+                stringValue = match[1] ?? "";
+        }
+        if (!stringValue)
+            continue;
+        for (const tokenMatch of stringValue.matchAll(regexp)) {
+            let token = tokenMatch[0];
+            if (opts.lowerCase)
+                token = token.toLowerCase();
+            if (opts.capitalize)
+                token = capitalize(token);
+            if (!token)
+                continue;
+            for (const override of TOKENIZE_OVERRIDES) {
+                token = override(token, opts);
+                if (!token)
+                    break;
+            }
+            if (!token || seen?.has(token))
+                continue;
+            seen?.add(token);
+            yield token;
+        }
+    }
+}
+export function* tokenize(...values) {
+    yield* tokenizeWithOptions({}, ...values);
+}
+/**
+ * Join tokenized values with `delimiter`. When the next token would push the
+ * result over `maxLength`: `trim` stops adding; `empty` returns `""`; `hash`
+ * appends a digest of accepted tokens plus the overflow token if the result
+ * still fits, otherwise `""`.
+ */
+export function toIdentifierWithOptions(options, ...values) {
+    const opts = {
+        ...IDENTIFIER_DEFAULTS,
+        ...options,
+        lowerCase: true,
+    };
+    const tokens = [];
+    let currentLength = 0;
+    for (const token of tokenizeWithOptions(opts, ...values)) {
+        const sepLength = tokens.length > 0 ? opts.delimiter.length : 0;
+        const nextLength = currentLength + sepLength + token.length;
+        if (nextLength > opts.maxLength) {
+            if (opts.truncateStrategy === "empty")
+                return "";
+            if (opts.truncateStrategy === "trim")
+                break;
+            const hash = digestTokens(opts.truncateHashLength, tokens, token);
+            if (currentLength + sepLength + hash.length <= opts.maxLength) {
+                return tokens.length > 0 ? tokens.join(opts.delimiter) + opts.delimiter + hash : hash;
+            }
+            return "";
+        }
+        tokens.push(token);
+        currentLength = nextLength;
+    }
+    return tokens.join(opts.delimiter);
+}
+export function toIdentifier(...values) {
+    return toIdentifierWithOptions({}, ...values);
+}
+/**
+ * Slugified identifier: same rules as {@link toIdentifierWithOptions} with the
+ * delimiter forced to `-`. Accepts {@link KeyOptions} so callers cannot
+ * override the delimiter.
+ */
+export function toSlugWithOptions(options, ...values) {
+    return toIdentifierWithOptions({ ...options, delimiter: "-" }, ...values);
+}
+export function toSlug(...values) {
+    return toSlugWithOptions({}, ...values);
+}
+/**
+ * Trim `value` and return `null` for non-strings, `undefined`, or
+ * strings that are empty after trimming. Lets call sites collapse the
+ * common
+ *
+ * ```ts
+ * typeof v === "string" && v.trim() ? v.trim() : null
+ * ```
+ *
+ * dance into a single helper. Useful for HTTP header / query / form
+ * extractors where downstream code wants `string | null` to drive a
+ * cheap `??` / `if (x)` cascade.
+ */
+export function trimToNull(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+// Config lists arrive either already split (an array) or as one env-var string
+// with entries separated by commas and/or whitespace.
+const LIST_SEPARATOR_REGEXP = /[\s,]+/;
+/**
+ * Normalize a config list that may arrive as an array or as a single
+ * comma/whitespace-separated string: split, apply `transform`, drop empties,
+ * and de-duplicate (first occurrence wins).
+ *
+ * This is the shape every allow-list / fallback-order setting in this repo
+ * takes, because the same value can come from typed config (`string[]`) or from
+ * an environment variable (`"a, b c"`). Pass `transform` to normalize entries
+ * as they are read; it defaults to trimming.
+ *
+ * @example
+ * parseList("docs.example.com, *.databricks.com");
+ * parseList(process.env.MODEL_FALLBACKS);
+ * parseList(raw, normalizeUrlPattern);
+ */
+export function parseList(raw, transform = (entry) => entry.trim()) {
+    const entries = typeof raw === "string" ? raw.split(LIST_SEPARATOR_REGEXP) : Array.isArray(raw) ? raw : [];
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        const normalized = transform(entry);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * {@link trimToNull} with an empty-string miss instead of `null`, for callers
+ * that build a string unconditionally and treat "absent" as "".
+ *
+ * Reading loosely-typed JSON is the motivating case: a field that should be a
+ * string may be missing or the wrong type, and the caller wants `""` rather
+ * than a null check at every access.
+ *
+ * @example
+ * const title = trimToEmpty(record.title); // always a string
+ */
+export function trimToEmpty(value) {
+    return trimToNull(value) ?? "";
+}
+/**
+ * Trim the first usable string out of `value`. Returns `null` when
+ * `value` is `undefined`, `null`, an empty string, or an array whose
+ * first string member is empty. Mirrors how Express / Node header
+ * accessors expose single vs. repeated headers - the first
+ * non-empty entry wins, everything else is ignored.
+ */
+export function firstNonEmpty(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const trimmed = trimToNull(item);
+            if (trimmed)
+                return trimmed;
+        }
+        return null;
+    }
+    return trimToNull(value);
+}
+/**
+ * Escape the five characters significant in HTML text and
+ * double-quoted attribute values (`&`, `<`, `>`, `"`, `'`) so an
+ * untrusted string can be interpolated into markup without breaking
+ * out of its context. `&` is replaced first so ampersands introduced
+ * by the later replacements aren't double-escaped.
+ */
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+/**
+ * Slugify `value` (using the standard {@link toIdentifierWithOptions}
+ * tokenizer + delimiter rules) and **always** suffix a short
+ * deterministic hash. Use when you need a stable, slugified id that
+ * is guaranteed to be unique across descriptions sharing the same
+ * leading tokens (tool ids, cache keys, etc.).
+ *
+ * Behaviour differs from `toIdentifierWithOptions({ maxLength,
+ * truncateStrategy: "hash" })`: that helper only appends a hash when
+ * the slug *overflows* `maxLength`. This helper appends a hash
+ * unconditionally so the result is collision-resistant even for
+ * short inputs. The hash is computed over the raw `value` so two
+ * descriptions producing the same slug still get different ids.
+ *
+ * @param value - Source string (typically a tool/agent description).
+ * @param options.delimiter - Token separator (default `"_"`).
+ * @param options.slugMaxLength - Cap on the slug portion (the part
+ *   before the hash). Default 32.
+ * @param options.hashLength - Length of the suffix produced by
+ *   {@link fnvHashWithOptions} (Crockford-style base-32 alphabet, max 7
+ *   chars). Default 6.
+ * @param options.fallbackPrefix - Prefix used when the slug is empty
+ *   (e.g. punctuation-only input). Default `"id"`.
+ */
+export function toUniqueSlug(value, options = {}) {
+    const delimiter = options.delimiter ?? "_";
+    const slugMaxLength = options.slugMaxLength ?? 32;
+    const hashLength = options.hashLength ?? 6;
+    const fallbackPrefix = options.fallbackPrefix ?? "id";
+    const slug = toIdentifierWithOptions({ delimiter, maxLength: slugMaxLength, truncateStrategy: "trim" }, value);
+    const suffix = fnvHashWithOptions({ length: hashLength }, value);
+    return slug ? `${slug}${delimiter}${suffix}` : `${fallbackPrefix}${delimiter}${suffix}`;
+}
+function digestTokens(length, parts, extra) {
+    let combined = "";
+    for (const part of parts)
+        combined += part + "\0";
+    if (extra !== undefined)
+        combined += extra + "\0";
+    return fnvHashWithOptions({ length }, combined);
+}
+const LIST_KEYS = ["bullets", "numbered"];
+/**
+ * Format a nested description tree as a Markdown-ish string suitable
+ * for an LLM system prompt, Zod `.describe()` block, Mastra tool
+ * description, or any other long-form text destination.
+ *
+ * Every string section is dedented (common leading whitespace stripped),
+ * right-trimmed line by line, and freed of leading / trailing blank
+ * lines, so callers can write multi-line template literals indented
+ * naturally in source without leaking that indentation into the
+ * consumer-facing output. Plain-string inputs flow through unchanged
+ * apart from the same normalization pass, so a single multi-line
+ * template literal works directly:
+ *
+ * ```ts
+ * toDescription(`
+ *   Ask the Genie space "${alias}" a question.
+ *   Pass the answer through as-is.
+ * `);
+ * // Ask the Genie space "default" a question.
+ * // Pass the answer through as-is.
+ *
+ * toDescription([
+ *   `
+ *     Ask the Genie space a question.
+ *     Phrase it from the user's perspective.
+ *   `,
+ *   { bullets: [
+ *     ["Pass the answer through as-is", { numbered: ["item", "item"] }],
+ *   ]},
+ *   { Instructions: "Reply with the SQL only." },
+ * ]);
+ * // Ask the Genie space a question.
+ * // Phrase it from the user's perspective.
+ * // - Pass the answer through as-is
+ * //   1. item
+ * //   2. item
+ * //
+ * // Instructions:
+ * //
+ * // Reply with the SQL only.
+ * ```
+ *
+ * See {@link Description} for the node grammar.
+ */
+export function toDescription(node) {
+    return renderBlock(node, "")
+        .replace(/[ \t]+$/gm, "")
+        .replace(/\n+$/, "");
+}
+function renderBlock(node, pad) {
+    if (node == null)
+        return "";
+    if (typeof node === "string")
+        return prependPad(dedentSection(node), pad);
+    if (Array.isArray(node))
+        return renderSequence(node, pad);
+    const kind = listKind(node);
+    if (kind) {
+        return renderList(node[kind], pad, kind);
+    }
+    return renderMap(node, pad);
+}
+/**
+ * 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.
+ */
+function dedentSection(text) {
+    if (!text)
+        return "";
+    const lines = text.split("\n").map((line) => line.replace(/[ \t]+$/, ""));
+    let min = Infinity;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        const match = /^[ \t]*/.exec(line);
+        const width = match ? match[0].length : 0;
+        if (width < min)
+            min = width;
+    }
+    const stripped = 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");
+}
+/**
+ * An object is treated as a typed list only when it has exactly one
+ * own key, that key is `bullets` or `numbered`, and the value is an
+ * array. Everything else is a headers map - so callers wanting a
+ * single header literally named `bullets` or `numbered` can use a
+ * multi-key map or rename.
+ */
+function listKind(node) {
+    const keys = Object.keys(node);
+    if (keys.length !== 1)
+        return null;
+    const key = keys[0];
+    if (LIST_KEYS.includes(key) && Array.isArray(node[key])) {
+        return key;
+    }
+    return null;
+}
+function prependPad(text, pad) {
+    if (!text)
+        return "";
+    if (!pad)
+        return text;
+    return text
+        .split("\n")
+        .map((line) => (line ? pad + line : ""))
+        .join("\n");
+}
+function renderSequence(items, pad) {
+    const rendered = [];
+    for (const item of items) {
+        const text = renderBlock(item, pad);
+        if (!text)
+            continue;
+        rendered.push({ text, node: item });
+    }
+    if (rendered.length === 0)
+        return "";
+    let out = rendered[0].text;
+    for (let i = 1; i < rendered.length; i += 1) {
+        const sep = needsBlankLineBetween(rendered[i - 1].node, rendered[i].node) ? "\n\n" : "\n";
+        out += sep + rendered[i].text;
+    }
+    return out;
+}
+/**
+ * Maps always create their own section boundary (a `Header:` line plus
+ * a blank line before the body), so anything touching a map gets a
+ * blank-line break. Plain text adjacent to a typed list flushes
+ * together in either direction: text-before-list reads as a lead-in,
+ * text-after-list as a trailing summary. Two text paragraphs and two
+ * adjacent lists both get a blank-line break for legibility.
+ */
+function needsBlankLineBetween(prev, curr) {
+    if (isMap(prev) || isMap(curr))
+        return true;
+    const prevIsText = typeof prev === "string";
+    const currIsText = typeof curr === "string";
+    if (prevIsText !== currIsText)
+        return false;
+    return true;
+}
+/**
+ * A node is a headers map when it is a non-array, non-list object.
+ * `bullets` / `numbered` single-key objects are the only structured
+ * objects that aren't maps.
+ */
+function isMap(node) {
+    if (node == null)
+        return false;
+    if (typeof node === "string")
+        return false;
+    if (Array.isArray(node))
+        return false;
+    return listKind(node) === null;
+}
+function renderList(items, pad, kind) {
+    if (items.length === 0)
+        return "";
+    if (items.length === 1 && typeof items[0] === "string") {
+        return prependPad(items[0], pad);
+    }
+    const lines = [];
+    for (let i = 0; i < items.length; i += 1) {
+        const item = items[i];
+        const marker = kind === "bullets" ? "- " : `${i + 1}. `;
+        const body = renderBlock(item, "");
+        const bodyLines = body.split("\n");
+        lines.push(`${pad}${marker}${bodyLines[0] ?? ""}`);
+        const continuation = pad + " ".repeat(marker.length);
+        for (const line of bodyLines.slice(1)) {
+            lines.push(line ? `${continuation}${line}` : "");
+        }
+    }
+    return lines.join("\n");
+}
+function renderMap(node, pad) {
+    const parts = [];
+    for (const [header, value] of Object.entries(node)) {
+        const body = renderBlock(value, pad);
+        if (!body && !header.trim())
+            continue;
+        const headerLine = header.trim() ? `${pad}${header}:` : "";
+        parts.push(body ? `${headerLine}\n\n${body}` : headerLine);
+    }
+    return parts.join("\n\n");
+}
+/**
+ * Format a count with its noun, pluralizing (naive `+s`) unless the count is 1:
+ * `pluralize(1, "barrel")` -> `"1 barrel"`, `pluralize(3, "barrel")` ->
+ * `"3 barrels"`. Collapses the `${n} noun${n === 1 ? "" : "s"}` idiom.
+ */
+export function pluralize(count, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+/**
+ * Title-case a snake / kebab / camel identifier into a human-readable label:
+ * tokenize (lowercased, capitalized), then join with spaces. Falls back to
+ * the raw `value` when it yields no tokens (e.g. punctuation-only input).
+ * `bge_large_en` -> `"Bge Large En"`, `promptId` -> `"Prompt Id"`.
+ *
+ * The single source of truth for the "humanize a column / field name" idiom -
+ * reused by the chat data-grid headers and the export renderer. Extra
+ * {@link TokenizeOptions} (e.g. `camelCase: false`) merge over the defaults.
+ */
+export function toLabel(value, options) {
+    const tokens = [...tokenizeWithOptions({ lowerCase: true, capitalize: true, ...options }, value)];
+    return tokens.length > 0 ? tokens.join(" ") : value;
+}
+/**
+ * Upper-case the first character of `value`, leaving the rest untouched.
+ * `"working"` -> `"Working"`. Collapses the
+ * `s.charAt(0).toUpperCase() + s.slice(1)` idiom.
+ */
+export function capitalize(value) {
+    return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string-utils.js","sourceRoot":"","sources":["../../src/string-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-safe string toolkit: tokenization, identifier / slug\n * generation (with hash-suffix collision resistance), HTML escaping,\n * header-value trimming, and a nested description-tree renderer for\n * long-form LLM prompt / tool-description text. Depends only on the\n * local {@link fnvHashWithOptions} for deterministic hash suffixes.\n *\n * @module\n */\nimport { fnvHashWithOptions } from \"./hash.ts\";\n\n/**\n * Options controlling {@link tokenizeWithOptions}. All default off except\n * `camelCase`.\n *\n * - `distinct` - drop duplicate tokens (first occurrence wins).\n * - `lowerCase` - lowercase every token.\n * - `capitalize` - upper-case each token's first letter (then\n *   {@link TOKENIZE_OVERRIDES} fix up `ai` -> `AI`, `fs` -> `FS`, and\n *   `v2` -> `V2`).\n * - `omitUriScheme` - strip a leading `scheme://` before tokenizing.\n * - `omitEmailDomain` - keep only the local part of an email.\n * - `camelCase` - split on camelCase boundaries / digit runs / acronyms\n *   (default `true`); when `false`, split only on non-alphanumerics.\n */\nexport type TokenizeOptions = {\n  distinct?: boolean;\n  lowerCase?: boolean;\n  capitalize?: boolean;\n  omitUriScheme?: boolean;\n  omitEmailDomain?: boolean;\n  camelCase?: boolean;\n};\n\n/**\n * Tokenization and overflow controls for lowercase keys and slugs. The default\n * length is unlimited; overflow uses a six-character hash unless overridden.\n */\nexport type KeyOptions = Omit<TokenizeOptions, \"lowerCase\" | \"capitalize\"> & {\n  maxLength?: number;\n  truncateStrategy?: \"hash\" | \"trim\" | \"empty\";\n  truncateHashLength?: number;\n};\n\n/** {@link KeyOptions} plus the token delimiter used by identifier generation. */\nexport type IdentifierOptions = KeyOptions & {\n  delimiter?: string;\n};\n\ntype ResolvedTokenizeOptions = Required<TokenizeOptions>;\ntype ResolvedIdentifierOptions = Required<\n  IdentifierOptions & Pick<TokenizeOptions, \"lowerCase\" | \"capitalize\">\n>;\n\n// A leading `v`/`V` immediately followed by digits (a version marker like\n// `v2`) is kept as ONE token instead of splitting into `v` + `2`; it leads the\n// alternation so it wins over the generic letter / digit runs. Everything else\n// is the usual camelCase word / number / all-caps-acronym split.\nconst TOKENIZE_CAMEL_CASE_REGEXP = /[vV][0-9]+|[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g;\nconst TOKENIZE_NON_ALPHANUMERIC_REGEXP = /[a-zA-Z0-9]+/g;\nconst TOKENIZE_OVERRIDES: ((token: string, options: TokenizeOptions) => string)[] = [\n  (token, options) => {\n    if (!options.capitalize) return token;\n    const lower = token.toLowerCase();\n    if (lower === \"ai\") return \"AI\";\n    if (lower === \"fs\") return \"FS\";\n    return token;\n  },\n  // Version marker `v2` -> `V2` when capitalizing (the leading `v` uppercases,\n  // the digits stay), so it reads as one unit rather than \"V 2\".\n  (token, options) => {\n    if (options.capitalize && /^v[0-9]+$/.test(token)) {\n      return `V${token.slice(1)}`;\n    }\n    return token;\n  },\n];\nconst URI_REGEXP = /^([a-zA-Z][a-zA-Z0-9+.-]*)?:\\/\\/([^\\s/?#][^\\s]*)?$/;\nconst EMAIL_REGEXP = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+)@([a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)+)$/;\n\nconst TOKENIZE_DEFAULTS: ResolvedTokenizeOptions = {\n  distinct: false,\n  lowerCase: false,\n  capitalize: false,\n  omitUriScheme: false,\n  omitEmailDomain: false,\n  camelCase: true,\n};\n\nconst IDENTIFIER_DEFAULTS: ResolvedIdentifierOptions = {\n  ...TOKENIZE_DEFAULTS,\n  lowerCase: true,\n  maxLength: Infinity,\n  truncateStrategy: \"hash\",\n  truncateHashLength: 6,\n  delimiter: \"-\",\n};\n\nexport function* tokenizeWithOptions(\n  options: TokenizeOptions,\n  ...values: unknown[]\n): Generator<string> {\n  const opts: ResolvedTokenizeOptions = { ...TOKENIZE_DEFAULTS, ...options };\n  const seen = opts.distinct ? new Set<string>() : undefined;\n  const regexp = opts.camelCase ? TOKENIZE_CAMEL_CASE_REGEXP : TOKENIZE_NON_ALPHANUMERIC_REGEXP;\n\n  for (const value of values) {\n    if (value == null) continue;\n    let stringValue = typeof value === \"string\" ? value : String(value);\n    if (!stringValue) continue;\n    if (opts.omitUriScheme) {\n      const match = stringValue.match(URI_REGEXP);\n      if (match) stringValue = match[2] ?? \"\";\n    }\n    if (opts.omitEmailDomain) {\n      const match = stringValue.match(EMAIL_REGEXP);\n      if (match) stringValue = match[1] ?? \"\";\n    }\n    if (!stringValue) continue;\n    for (const tokenMatch of stringValue.matchAll(regexp)) {\n      let token = tokenMatch[0]!;\n      if (opts.lowerCase) token = token.toLowerCase();\n      if (opts.capitalize) token = capitalize(token);\n      if (!token) continue;\n      for (const override of TOKENIZE_OVERRIDES) {\n        token = override(token, opts);\n        if (!token) break;\n      }\n      if (!token || seen?.has(token)) continue;\n      seen?.add(token);\n      yield token;\n    }\n  }\n}\n\nexport function* tokenize(...values: unknown[]): Generator<string> {\n  yield* tokenizeWithOptions({}, ...values);\n}\n\n/**\n * Join tokenized values with `delimiter`. When the next token would push the\n * result over `maxLength`: `trim` stops adding; `empty` returns `\"\"`; `hash`\n * appends a digest of accepted tokens plus the overflow token if the result\n * still fits, otherwise `\"\"`.\n */\nexport function toIdentifierWithOptions(options: IdentifierOptions, ...values: unknown[]): string {\n  const opts: ResolvedIdentifierOptions = {\n    ...IDENTIFIER_DEFAULTS,\n    ...options,\n    lowerCase: true,\n  };\n  const tokens: string[] = [];\n  let currentLength = 0;\n\n  for (const token of tokenizeWithOptions(opts, ...values)) {\n    const sepLength = tokens.length > 0 ? opts.delimiter.length : 0;\n    const nextLength = currentLength + sepLength + token.length;\n\n    if (nextLength > opts.maxLength) {\n      if (opts.truncateStrategy === \"empty\") return \"\";\n      if (opts.truncateStrategy === \"trim\") break;\n\n      const hash = digestTokens(opts.truncateHashLength, tokens, token);\n      if (currentLength + sepLength + hash.length <= opts.maxLength) {\n        return tokens.length > 0 ? tokens.join(opts.delimiter) + opts.delimiter + hash : hash;\n      }\n      return \"\";\n    }\n\n    tokens.push(token);\n    currentLength = nextLength;\n  }\n\n  return tokens.join(opts.delimiter);\n}\n\nexport function toIdentifier(...values: unknown[]): string {\n  return toIdentifierWithOptions({}, ...values);\n}\n\n/**\n * Slugified identifier: same rules as {@link toIdentifierWithOptions} with the\n * delimiter forced to `-`. Accepts {@link KeyOptions} so callers cannot\n * override the delimiter.\n */\nexport function toSlugWithOptions(options: KeyOptions, ...values: unknown[]): string {\n  return toIdentifierWithOptions({ ...options, delimiter: \"-\" }, ...values);\n}\n\nexport function toSlug(...values: unknown[]): string {\n  return toSlugWithOptions({}, ...values);\n}\n\n/**\n * Trim `value` and return `null` for non-strings, `undefined`, or\n * strings that are empty after trimming. Lets call sites collapse the\n * common\n *\n * ```ts\n * typeof v === \"string\" && v.trim() ? v.trim() : null\n * ```\n *\n * dance into a single helper. Useful for HTTP header / query / form\n * extractors where downstream code wants `string | null` to drive a\n * cheap `??` / `if (x)` cascade.\n */\nexport function trimToNull(value: unknown): string | null {\n  if (typeof value !== \"string\") return null;\n  const trimmed = value.trim();\n  return trimmed ? trimmed : null;\n}\n\n// Config lists arrive either already split (an array) or as one env-var string\n// with entries separated by commas and/or whitespace.\nconst LIST_SEPARATOR_REGEXP = /[\\s,]+/;\n\n/**\n * Normalize a config list that may arrive as an array or as a single\n * comma/whitespace-separated string: split, apply `transform`, drop empties,\n * and de-duplicate (first occurrence wins).\n *\n * This is the shape every allow-list / fallback-order setting in this repo\n * takes, because the same value can come from typed config (`string[]`) or from\n * an environment variable (`\"a, b c\"`). Pass `transform` to normalize entries\n * as they are read; it defaults to trimming.\n *\n * @example\n * parseList(\"docs.example.com, *.databricks.com\");\n * parseList(process.env.MODEL_FALLBACKS);\n * parseList(raw, normalizeUrlPattern);\n */\nexport function parseList(\n  raw: string | readonly string[] | undefined | null,\n  transform: (entry: string) => string = (entry) => entry.trim(),\n): string[] {\n  const entries =\n    typeof raw === \"string\" ? raw.split(LIST_SEPARATOR_REGEXP) : Array.isArray(raw) ? raw : [];\n  const out: string[] = [];\n  const seen = new Set<string>();\n  for (const entry of entries) {\n    const normalized = transform(entry);\n    if (!normalized || seen.has(normalized)) continue;\n    seen.add(normalized);\n    out.push(normalized);\n  }\n  return out;\n}\n\n/**\n * {@link trimToNull} with an empty-string miss instead of `null`, for callers\n * that build a string unconditionally and treat \"absent\" as \"\".\n *\n * Reading loosely-typed JSON is the motivating case: a field that should be a\n * string may be missing or the wrong type, and the caller wants `\"\"` rather\n * than a null check at every access.\n *\n * @example\n * const title = trimToEmpty(record.title); // always a string\n */\nexport function trimToEmpty(value: unknown): string {\n  return trimToNull(value) ?? \"\";\n}\n\n/**\n * Trim the first usable string out of `value`. Returns `null` when\n * `value` is `undefined`, `null`, an empty string, or an array whose\n * first string member is empty. Mirrors how Express / Node header\n * accessors expose single vs. repeated headers - the first\n * non-empty entry wins, everything else is ignored.\n */\nexport function firstNonEmpty(value: unknown): string | null {\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      const trimmed = trimToNull(item);\n      if (trimmed) return trimmed;\n    }\n    return null;\n  }\n  return trimToNull(value);\n}\n\n/**\n * Escape the five characters significant in HTML text and\n * double-quoted attribute values (`&`, `<`, `>`, `\"`, `'`) so an\n * untrusted string can be interpolated into markup without breaking\n * out of its context. `&` is replaced first so ampersands introduced\n * by the later replacements aren't double-escaped.\n */\nexport function escapeHtml(value: string): string {\n  return value\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, \"&gt;\")\n    .replace(/\"/g, \"&quot;\")\n    .replace(/'/g, \"&#39;\");\n}\n\n/**\n * Slugify `value` (using the standard {@link toIdentifierWithOptions}\n * tokenizer + delimiter rules) and **always** suffix a short\n * deterministic hash. Use when you need a stable, slugified id that\n * is guaranteed to be unique across descriptions sharing the same\n * leading tokens (tool ids, cache keys, etc.).\n *\n * Behaviour differs from `toIdentifierWithOptions({ maxLength,\n * truncateStrategy: \"hash\" })`: that helper only appends a hash when\n * the slug *overflows* `maxLength`. This helper appends a hash\n * unconditionally so the result is collision-resistant even for\n * short inputs. The hash is computed over the raw `value` so two\n * descriptions producing the same slug still get different ids.\n *\n * @param value - Source string (typically a tool/agent description).\n * @param options.delimiter - Token separator (default `\"_\"`).\n * @param options.slugMaxLength - Cap on the slug portion (the part\n *   before the hash). Default 32.\n * @param options.hashLength - Length of the suffix produced by\n *   {@link fnvHashWithOptions} (Crockford-style base-32 alphabet, max 7\n *   chars). Default 6.\n * @param options.fallbackPrefix - Prefix used when the slug is empty\n *   (e.g. punctuation-only input). Default `\"id\"`.\n */\nexport function toUniqueSlug(\n  value: string,\n  options: {\n    delimiter?: string;\n    slugMaxLength?: number;\n    hashLength?: number;\n    fallbackPrefix?: string;\n  } = {},\n): string {\n  const delimiter = options.delimiter ?? \"_\";\n  const slugMaxLength = options.slugMaxLength ?? 32;\n  const hashLength = options.hashLength ?? 6;\n  const fallbackPrefix = options.fallbackPrefix ?? \"id\";\n  const slug = toIdentifierWithOptions(\n    { delimiter, maxLength: slugMaxLength, truncateStrategy: \"trim\" },\n    value,\n  );\n  const suffix = fnvHashWithOptions({ length: hashLength }, value);\n  return slug ? `${slug}${delimiter}${suffix}` : `${fallbackPrefix}${delimiter}${suffix}`;\n}\n\nfunction digestTokens(length: number, parts: readonly string[], extra?: string): string {\n  let combined = \"\";\n  for (const part of parts) combined += part + \"\\0\";\n  if (extra !== undefined) combined += extra + \"\\0\";\n  return fnvHashWithOptions({ length }, combined);\n}\n\n/**\n * A node in the description tree consumed by {@link toDescription}.\n *\n * - `string` - a text paragraph.\n * - `Description[]` - a sequence of stacked blocks at the same level\n *   (no list markers). Plain text adjacent to a list (either direction)\n *   flushes together so the prose reads as a lead-in or trailing\n *   summary. Two text paragraphs, two adjacent lists, and anything\n *   touching a map get a blank-line break.\n * - `{ bullets: [...] }` / `{ numbered: [...] }` - explicit list. A\n *   list of one bare string drops its marker (`-` / `1.`); a list of\n *   one item with nested children keeps its marker as the visual anchor\n *   for the indented children.\n * - any other object - headers map: each key becomes a `Header:` line\n *   followed by a blank line and the rendered value.\n */\nexport type Description = string | readonly Description[] | { readonly [key: string]: Description };\n\nconst LIST_KEYS = [\"bullets\", \"numbered\"] as const;\ntype ListKind = (typeof LIST_KEYS)[number];\n\n/**\n * Format a nested description tree as a Markdown-ish string suitable\n * for an LLM system prompt, Zod `.describe()` block, Mastra tool\n * description, or any other long-form text destination.\n *\n * Every string section is dedented (common leading whitespace stripped),\n * right-trimmed line by line, and freed of leading / trailing blank\n * lines, so callers can write multi-line template literals indented\n * naturally in source without leaking that indentation into the\n * consumer-facing output. Plain-string inputs flow through unchanged\n * apart from the same normalization pass, so a single multi-line\n * template literal works directly:\n *\n * ```ts\n * toDescription(`\n *   Ask the Genie space \"${alias}\" a question.\n *   Pass the answer through as-is.\n * `);\n * // Ask the Genie space \"default\" a question.\n * // Pass the answer through as-is.\n *\n * toDescription([\n *   `\n *     Ask the Genie space a question.\n *     Phrase it from the user's perspective.\n *   `,\n *   { bullets: [\n *     [\"Pass the answer through as-is\", { numbered: [\"item\", \"item\"] }],\n *   ]},\n *   { Instructions: \"Reply with the SQL only.\" },\n * ]);\n * // Ask the Genie space a question.\n * // Phrase it from the user's perspective.\n * // - Pass the answer through as-is\n * //   1. item\n * //   2. item\n * //\n * // Instructions:\n * //\n * // Reply with the SQL only.\n * ```\n *\n * See {@link Description} for the node grammar.\n */\nexport function toDescription(node: Description): string {\n  return renderBlock(node, \"\")\n    .replace(/[ \\t]+$/gm, \"\")\n    .replace(/\\n+$/, \"\");\n}\n\nfunction renderBlock(node: Description, pad: string): string {\n  if (node == null) return \"\";\n  if (typeof node === \"string\") return prependPad(dedentSection(node), pad);\n  if (Array.isArray(node)) return renderSequence(node, pad);\n  const kind = listKind(node as Record<string, unknown>);\n  if (kind) {\n    return renderList((node as Record<ListKind, readonly Description[]>)[kind], pad, kind);\n  }\n  return renderMap(node as Record<string, Description>, pad);\n}\n\n/**\n * Normalize a string section: right-strip every line, drop the\n * common leading-whitespace prefix shared by all non-blank lines,\n * and trim leading / trailing blank lines. Matches Python's\n * `textwrap.dedent` semantics so embedded indented template\n * literals round-trip cleanly.\n */\nfunction dedentSection(text: string): string {\n  if (!text) return \"\";\n  const lines = text.split(\"\\n\").map((line) => line.replace(/[ \\t]+$/, \"\"));\n  let min = Infinity;\n  for (const line of lines) {\n    if (!line) continue;\n    const match = /^[ \\t]*/.exec(line);\n    const width = match ? match[0].length : 0;\n    if (width < min) min = width;\n  }\n  const stripped =\n    min === Infinity || min === 0 ? lines : lines.map((line) => (line ? line.slice(min) : \"\"));\n  let start = 0;\n  let end = stripped.length;\n  while (start < end && !stripped[start]) start += 1;\n  while (end > start && !stripped[end - 1]) end -= 1;\n  return stripped.slice(start, end).join(\"\\n\");\n}\n\n/**\n * An object is treated as a typed list only when it has exactly one\n * own key, that key is `bullets` or `numbered`, and the value is an\n * array. Everything else is a headers map - so callers wanting a\n * single header literally named `bullets` or `numbered` can use a\n * multi-key map or rename.\n */\nfunction listKind(node: Record<string, unknown>): ListKind | null {\n  const keys = Object.keys(node);\n  if (keys.length !== 1) return null;\n  const key = keys[0]!;\n  if ((LIST_KEYS as readonly string[]).includes(key) && Array.isArray(node[key])) {\n    return key as ListKind;\n  }\n  return null;\n}\n\nfunction prependPad(text: string, pad: string): string {\n  if (!text) return \"\";\n  if (!pad) return text;\n  return text\n    .split(\"\\n\")\n    .map((line) => (line ? pad + line : \"\"))\n    .join(\"\\n\");\n}\n\nfunction renderSequence(items: readonly Description[], pad: string): string {\n  const rendered: { text: string; node: Description }[] = [];\n  for (const item of items) {\n    const text = renderBlock(item, pad);\n    if (!text) continue;\n    rendered.push({ text, node: item });\n  }\n  if (rendered.length === 0) return \"\";\n  let out = rendered[0]!.text;\n  for (let i = 1; i < rendered.length; i += 1) {\n    const sep = needsBlankLineBetween(rendered[i - 1]!.node, rendered[i]!.node) ? \"\\n\\n\" : \"\\n\";\n    out += sep + rendered[i]!.text;\n  }\n  return out;\n}\n\n/**\n * Maps always create their own section boundary (a `Header:` line plus\n * a blank line before the body), so anything touching a map gets a\n * blank-line break. Plain text adjacent to a typed list flushes\n * together in either direction: text-before-list reads as a lead-in,\n * text-after-list as a trailing summary. Two text paragraphs and two\n * adjacent lists both get a blank-line break for legibility.\n */\nfunction needsBlankLineBetween(prev: Description, curr: Description): boolean {\n  if (isMap(prev) || isMap(curr)) return true;\n  const prevIsText = typeof prev === \"string\";\n  const currIsText = typeof curr === \"string\";\n  if (prevIsText !== currIsText) return false;\n  return true;\n}\n\n/**\n * A node is a headers map when it is a non-array, non-list object.\n * `bullets` / `numbered` single-key objects are the only structured\n * objects that aren't maps.\n */\nfunction isMap(node: Description): boolean {\n  if (node == null) return false;\n  if (typeof node === \"string\") return false;\n  if (Array.isArray(node)) return false;\n  return listKind(node as Record<string, unknown>) === null;\n}\n\nfunction renderList(items: readonly Description[], pad: string, kind: ListKind): string {\n  if (items.length === 0) return \"\";\n  if (items.length === 1 && typeof items[0] === \"string\") {\n    return prependPad(items[0], pad);\n  }\n  const lines: string[] = [];\n  for (let i = 0; i < items.length; i += 1) {\n    const item = items[i]!;\n    const marker = kind === \"bullets\" ? \"- \" : `${i + 1}. `;\n    const body = renderBlock(item, \"\");\n    const bodyLines = body.split(\"\\n\");\n    lines.push(`${pad}${marker}${bodyLines[0] ?? \"\"}`);\n    const continuation = pad + \" \".repeat(marker.length);\n    for (const line of bodyLines.slice(1)) {\n      lines.push(line ? `${continuation}${line}` : \"\");\n    }\n  }\n  return lines.join(\"\\n\");\n}\n\nfunction renderMap(node: Record<string, Description>, pad: string): string {\n  const parts: string[] = [];\n  for (const [header, value] of Object.entries(node)) {\n    const body = renderBlock(value, pad);\n    if (!body && !header.trim()) continue;\n    const headerLine = header.trim() ? `${pad}${header}:` : \"\";\n    parts.push(body ? `${headerLine}\\n\\n${body}` : headerLine);\n  }\n  return parts.join(\"\\n\\n\");\n}\n\n/**\n * Format a count with its noun, pluralizing (naive `+s`) unless the count is 1:\n * `pluralize(1, \"barrel\")` -> `\"1 barrel\"`, `pluralize(3, \"barrel\")` ->\n * `\"3 barrels\"`. Collapses the `${n} noun${n === 1 ? \"\" : \"s\"}` idiom.\n */\nexport function pluralize(count: number, noun: string): string {\n  return `${count} ${noun}${count === 1 ? \"\" : \"s\"}`;\n}\n\n/**\n * Title-case a snake / kebab / camel identifier into a human-readable label:\n * tokenize (lowercased, capitalized), then join with spaces. Falls back to\n * the raw `value` when it yields no tokens (e.g. punctuation-only input).\n * `bge_large_en` -> `\"Bge Large En\"`, `promptId` -> `\"Prompt Id\"`.\n *\n * The single source of truth for the \"humanize a column / field name\" idiom -\n * reused by the chat data-grid headers and the export renderer. Extra\n * {@link TokenizeOptions} (e.g. `camelCase: false`) merge over the defaults.\n */\nexport function toLabel(value: string, options?: TokenizeOptions): string {\n  const tokens = [...tokenizeWithOptions({ lowerCase: true, capitalize: true, ...options }, value)];\n  return tokens.length > 0 ? tokens.join(\" \") : value;\n}\n\n/**\n * Upper-case the first character of `value`, leaving the rest untouched.\n * `\"working\"` -> `\"Working\"`. Collapses the\n * `s.charAt(0).toUpperCase() + s.slice(1)` idiom.\n */\nexport function capitalize(value: string): string {\n  return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/async.ts","../src/brand.ts","../src/error.ts","../src/execution.ts","../src/function.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/pattern.ts","../src/predicate.ts","../src/string.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/async-utils.ts","../src/brand-utils.ts","../src/error-utils.ts","../src/execution.ts","../src/function-utils.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/pattern.ts","../src/predicate.ts","../src/string-utils.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -19,7 +19,7 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/test-polyglot": "^0.9.5",
+    "@dbx-tools/test-polyglot": "^0.9.6",
     "@types/bun": "1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
@@ -41,7 +41,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.5",
+  "version": "0.9.6",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {