@dbx-tools/shared-core 0.3.44 → 0.4.1

package/lib/src/brand.js

@@ -0,0 +1,123 @@
+/**
+ * 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.");
+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",
+};
+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.");
+export const BrandColorsSchema = z
+    .object({
+    primary: color.default("#FF3621").describe("Primary action and identity color."),
+    primaryHover: color.default("#D92D18").describe("Primary hover or pressed color."),
+    accent: color.default("#2EB88A").describe("Secondary accent color."),
+    foreground: color.default("#0B2026").describe("Default text and mark color."),
+    background: color.default("#FFFFFF").describe("Default page background."),
+    surface: color.default("#F6F7F8").describe("Secondary surface background."),
+    muted: color.default("#5F6B70").describe("Muted text color."),
+    border: color.default("#DCE2E5").describe("Default border color."),
+})
+    .strict()
+    .prefault({});
+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({});
+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("Inter, ui-sans-serif, system-ui, sans-serif"),
+        mono: nonBlankString.default("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);
+}
+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\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\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\nexport const BrandColorsSchema = z\n  .object({\n    primary: color.default(\"#FF3621\").describe(\"Primary action and identity color.\"),\n    primaryHover: color.default(\"#D92D18\").describe(\"Primary hover or pressed color.\"),\n    accent: color.default(\"#2EB88A\").describe(\"Secondary accent color.\"),\n    foreground: color.default(\"#0B2026\").describe(\"Default text and mark color.\"),\n    background: color.default(\"#FFFFFF\").describe(\"Default page background.\"),\n    surface: color.default(\"#F6F7F8\").describe(\"Secondary surface background.\"),\n    muted: color.default(\"#5F6B70\").describe(\"Muted text color.\"),\n    border: color.default(\"#DCE2E5\").describe(\"Default border color.\"),\n  })\n  .strict()\n  .prefault({});\n\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\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(\"Inter, ui-sans-serif, system-ui, sans-serif\"),\n        mono: nonBlankString.default(\"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\nexport type BrandContext = z.output<typeof BrandContextSchema>;\nexport type BrandContextInput = z.input<typeof BrandContextSchema>;\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\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/lib/src/error.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Error normalization helpers: collapse the ubiquitous
+ * `err instanceof Error ? err.message : String(err)` dance into a single
+ * call, walk `cause` / `AggregateError` chains, and coerce any thrown
+ * value into a real `Error`. Dependency-free and browser-safe.
+ *
+ * @module
+ */
+/**
+ * Normalize any thrown value into an `Error`. Returns `value` unchanged
+ * when it already is an `Error`, otherwise wraps its {@link errorMessage}
+ * in a fresh `Error`. Use when a consumer needs a real `Error` object
+ * (React error state, `reject`, rethrow) rather than just a printable
+ * string.
+ */
+export declare function toError(value: unknown): Error;
+/**
+ * Extract a human-readable message from any thrown value. Returns
+ * `value.message` when `value` is an `Error`, otherwise coerces via
+ * `String(value)`. Collapses the ubiquitous
+ *
+ * ```ts
+ * err instanceof Error ? err.message : String(err)
+ * ```
+ *
+ * dance into a single helper, useful for log attributes and any other
+ * "give me something printable" context.
+ */
+export declare function errorMessage(value: unknown): string;
+/**
+ * Yield `message` / `errorCode` strings from every node in the error
+ * tree (see {@link errorNodes}). Used by {@link errorMessage} and
+ * message predicates elsewhere.
+ */
+export declare function errorMessages(value: unknown): Generator<string, void, undefined>;
+/**
+ * Depth-first walk of an error value: the root, then `errors` (e.g.
+ * `AggregateError`) and `cause` chains. Cycle-safe via a `seen` set.
+ */
+export declare function errorNodes(err: unknown): Generator<NonNullable<unknown>, void, undefined>;
+/**
+ * Lazy view over a thrown value for HTTP-status + message classification.
+ * Status comes from the last positive `statusCode` / `code` on the error tree;
+ * messages/tokens come from every `message` / `errorCode` field (including
+ * `cause` and `AggregateError.errors`). Build with {@link errorContext}.
+ */
+export type ErrorContext = ErrorContextImpl;
+declare class ErrorContextImpl {
+    private readonly err;
+    private _statusCode;
+    private _messages;
+    private _messageTokens;
+    constructor(err: NonNullable<unknown>);
+    /** Last positive `statusCode` / `code` found on the error tree, else `undefined` (0 ignored). */
+    get statusCode(): number | undefined;
+    /** Every `message` / `errorCode` string in the error tree. */
+    get messages(): string[];
+    /** Lowercased tokens from {@link messages}. */
+    get messageTokens(): string[];
+    /** True for any 4xx status or message tokens `not exist` / `not found`. */
+    get notAccessible(): boolean;
+    /**
+     * Match HTTP status. Pass a full code (`404`) or a class (`4` for any 4xx).
+     * Extra filters are OR'd. `false` when no status is on the error tree.
+     */
+    hasStatusCode(statusCodeFilter: number, ...statusCodeFilters: number[]): boolean;
+    /**
+     * True when every token from the filter phrase(s) appears in
+     * {@link messageTokens}. Each argument is tokenized on non-alphanumeric
+     * boundaries (e.g. `hasMessage("not", "found")` or `hasMessage("not found")`).
+     */
+    hasMessage(messageFilter: string, ...messageFilters: string[]): boolean;
+}
+/** Build an {@link ErrorContext} for status + message checks. `null` / `undefined` become `{}`. */
+export declare function errorContext(err: unknown): ErrorContext;
+export {};

package/lib/src/error.js

@@ -0,0 +1,168 @@
+/**
+ * Error normalization helpers: collapse the ubiquitous
+ * `err instanceof Error ? err.message : String(err)` dance into a single
+ * call, walk `cause` / `AggregateError` chains, and coerce any thrown
+ * value into a real `Error`. Dependency-free and browser-safe.
+ *
+ * @module
+ */
+import { tokenizeWithOptions } from "./string.js";
+/**
+ * Normalize any thrown value into an `Error`. Returns `value` unchanged
+ * when it already is an `Error`, otherwise wraps its {@link errorMessage}
+ * in a fresh `Error`. Use when a consumer needs a real `Error` object
+ * (React error state, `reject`, rethrow) rather than just a printable
+ * string.
+ */
+export function toError(value) {
+    return value instanceof Error ? value : new Error(errorMessage(value));
+}
+/**
+ * Extract a human-readable message from any thrown value. Returns
+ * `value.message` when `value` is an `Error`, otherwise coerces via
+ * `String(value)`. Collapses the ubiquitous
+ *
+ * ```ts
+ * err instanceof Error ? err.message : String(err)
+ * ```
+ *
+ * dance into a single helper, useful for log attributes and any other
+ * "give me something printable" context.
+ */
+export function errorMessage(value) {
+    const message = errorMessages(value).next().value;
+    return message ?? String(value);
+}
+/**
+ * Yield `message` / `errorCode` strings from every node in the error
+ * tree (see {@link errorNodes}). Used by {@link errorMessage} and
+ * message predicates elsewhere.
+ */
+export function* errorMessages(value) {
+    for (const node of errorNodes(value)) {
+        if (typeof node === "object") {
+            for (const key of ["message", "errorCode"]) {
+                if (key in node) {
+                    const value = node[key];
+                    if (typeof value === "string" && value) {
+                        yield value;
+                    }
+                }
+            }
+        }
+        else if (typeof node === "string" && node) {
+            yield node;
+        }
+    }
+}
+/**
+ * Depth-first walk of an error value: the root, then `errors` (e.g.
+ * `AggregateError`) and `cause` chains. Cycle-safe via a `seen` set.
+ */
+export function* errorNodes(err) {
+    const seen = new Set();
+    function* visit(node) {
+        if (node === undefined || node === null)
+            return;
+        if (Array.isArray(node)) {
+            for (const child of node) {
+                yield* visit(child);
+            }
+            return;
+        }
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        yield node;
+        if (typeof node === "object") {
+            for (const key of ["errors", "cause"]) {
+                if (key in node) {
+                    const value = node[key];
+                    yield* visit(value);
+                }
+            }
+        }
+    }
+    yield* visit(err);
+}
+class ErrorContextImpl {
+    err;
+    _statusCode;
+    _messages;
+    _messageTokens;
+    constructor(err) {
+        this.err = err;
+    }
+    /** Last positive `statusCode` / `code` found on the error tree, else `undefined` (0 ignored). */
+    get statusCode() {
+        if (this._statusCode === undefined) {
+            outer: for (const node of errorNodes(this.err)) {
+                if (typeof node !== "object" || node === null)
+                    continue;
+                for (const key of ["statusCode", "code"]) {
+                    if (!(key in node))
+                        continue;
+                    const value = node[key];
+                    if (typeof value === "number" && value > 99 && value < 600) {
+                        this._statusCode = value;
+                        break outer;
+                    }
+                }
+            }
+            if (this._statusCode === undefined) {
+                this._statusCode = -1;
+            }
+        }
+        return this._statusCode == -1 ? undefined : this._statusCode;
+    }
+    /** Every `message` / `errorCode` string in the error tree. */
+    get messages() {
+        if (this._messages === undefined) {
+            this._messages = [...errorMessages(this.err)];
+        }
+        return this._messages;
+    }
+    /** Lowercased tokens from {@link messages}. */
+    get messageTokens() {
+        if (this._messageTokens === undefined) {
+            this._messageTokens = [...tokenizeWithOptions({ lowerCase: true }, ...this.messages)];
+        }
+        return this._messageTokens;
+    }
+    /** True for any 4xx status or message tokens `not exist` / `not found`. */
+    get notAccessible() {
+        if (this.hasStatusCode(4))
+            return true;
+        return this.hasMessage("not", "exist") || this.hasMessage("not", "found");
+    }
+    /**
+     * Match HTTP status. Pass a full code (`404`) or a class (`4` for any 4xx).
+     * Extra filters are OR'd. `false` when no status is on the error tree.
+     */
+    hasStatusCode(statusCodeFilter, ...statusCodeFilters) {
+        const code = this.statusCode;
+        if (code) {
+            for (const filter of [statusCodeFilter, ...statusCodeFilters]) {
+                const match = (filter < 100 ? Math.trunc(code / 100) : code) === filter;
+                if (match)
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * True when every token from the filter phrase(s) appears in
+     * {@link messageTokens}. Each argument is tokenized on non-alphanumeric
+     * boundaries (e.g. `hasMessage("not", "found")` or `hasMessage("not found")`).
+     */
+    hasMessage(messageFilter, ...messageFilters) {
+        return [messageFilter, ...messageFilters]
+            .flatMap((filter) => Array.from(tokenizeWithOptions({ lowerCase: true }, filter)))
+            .every((filterToken) => this.messageTokens.includes(filterToken));
+    }
+}
+/** Build an {@link ErrorContext} for status + message checks. `null` / `undefined` become `{}`. */
+export function errorContext(err) {
+    return new ErrorContextImpl(err ?? {});
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/error.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Error normalization helpers: collapse the ubiquitous\n * `err instanceof Error ? err.message : String(err)` dance into a single\n * call, walk `cause` / `AggregateError` chains, and coerce any thrown\n * value into a real `Error`. Dependency-free and browser-safe.\n *\n * @module\n */\n\nimport { tokenizeWithOptions } from \"./string\";\n\n/**\n * Normalize any thrown value into an `Error`. Returns `value` unchanged\n * when it already is an `Error`, otherwise wraps its {@link errorMessage}\n * in a fresh `Error`. Use when a consumer needs a real `Error` object\n * (React error state, `reject`, rethrow) rather than just a printable\n * string.\n */\nexport function toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(errorMessage(value));\n}\n\n/**\n * Extract a human-readable message from any thrown value. Returns\n * `value.message` when `value` is an `Error`, otherwise coerces via\n * `String(value)`. Collapses the ubiquitous\n *\n * ```ts\n * err instanceof Error ? err.message : String(err)\n * ```\n *\n * dance into a single helper, useful for log attributes and any other\n * \"give me something printable\" context.\n */\nexport function errorMessage(value: unknown): string {\n  const message = errorMessages(value).next().value;\n  return message ?? String(value);\n}\n\n/**\n * Yield `message` / `errorCode` strings from every node in the error\n * tree (see {@link errorNodes}). Used by {@link errorMessage} and\n * message predicates elsewhere.\n */\nexport function* errorMessages(value: unknown): Generator<string, void, undefined> {\n  for (const node of errorNodes(value)) {\n    if (typeof node === \"object\") {\n      for (const key of [\"message\", \"errorCode\"]) {\n        if (key in node) {\n          const value = (node as Record<string, unknown>)[key];\n          if (typeof value === \"string\" && value) {\n            yield value;\n          }\n        }\n      }\n    } else if (typeof node === \"string\" && node) {\n      yield node;\n    }\n  }\n}\n\n/**\n * Depth-first walk of an error value: the root, then `errors` (e.g.\n * `AggregateError`) and `cause` chains. Cycle-safe via a `seen` set.\n */\nexport function* errorNodes(err: unknown): Generator<NonNullable<unknown>, void, undefined> {\n  const seen = new Set<unknown>();\n\n  function* visit(node: unknown): Generator<NonNullable<unknown>, void, undefined> {\n    if (node === undefined || node === null) return;\n    if (Array.isArray(node)) {\n      for (const child of node) {\n        yield* visit(child);\n      }\n      return;\n    }\n    if (seen.has(node)) return;\n    seen.add(node);\n    yield node;\n    if (typeof node === \"object\") {\n      for (const key of [\"errors\", \"cause\"]) {\n        if (key in node) {\n          const value = (node as Record<string, unknown>)[key];\n          yield* visit(value);\n        }\n      }\n    }\n  }\n  yield* visit(err);\n}\n\n/**\n * Lazy view over a thrown value for HTTP-status + message classification.\n * Status comes from the last positive `statusCode` / `code` on the error tree;\n * messages/tokens come from every `message` / `errorCode` field (including\n * `cause` and `AggregateError.errors`). Build with {@link errorContext}.\n */\nexport type ErrorContext = ErrorContextImpl;\n\nclass ErrorContextImpl {\n  private _statusCode: number | undefined;\n  private _messages: string[] | undefined;\n  private _messageTokens: string[] | undefined;\n\n  constructor(private readonly err: NonNullable<unknown>) {}\n\n  /** Last positive `statusCode` / `code` found on the error tree, else `undefined` (0 ignored). */\n  get statusCode(): number | undefined {\n    if (this._statusCode === undefined) {\n      outer: for (const node of errorNodes(this.err)) {\n        if (typeof node !== \"object\" || node === null) continue;\n        for (const key of [\"statusCode\", \"code\"] as const) {\n          if (!(key in node)) continue;\n          const value = (node as Record<string, unknown>)[key];\n          if (typeof value === \"number\" && value > 99 && value < 600) {\n            this._statusCode = value;\n            break outer;\n          }\n        }\n      }\n      if (this._statusCode === undefined) {\n        this._statusCode = -1;\n      }\n    }\n    return this._statusCode == -1 ? undefined : this._statusCode;\n  }\n\n  /** Every `message` / `errorCode` string in the error tree. */\n  get messages(): string[] {\n    if (this._messages === undefined) {\n      this._messages = [...errorMessages(this.err)];\n    }\n    return this._messages;\n  }\n\n  /** Lowercased tokens from {@link messages}. */\n  get messageTokens(): string[] {\n    if (this._messageTokens === undefined) {\n      this._messageTokens = [...tokenizeWithOptions({ lowerCase: true }, ...this.messages)];\n    }\n    return this._messageTokens;\n  }\n\n  /** True for any 4xx status or message tokens `not exist` / `not found`. */\n  get notAccessible(): boolean {\n    if (this.hasStatusCode(4)) return true;\n    return this.hasMessage(\"not\", \"exist\") || this.hasMessage(\"not\", \"found\");\n  }\n\n  /**\n   * Match HTTP status. Pass a full code (`404`) or a class (`4` for any 4xx).\n   * Extra filters are OR'd. `false` when no status is on the error tree.\n   */\n  hasStatusCode(statusCodeFilter: number, ...statusCodeFilters: number[]): boolean {\n    const code = this.statusCode;\n    if (code) {\n      for (const filter of [statusCodeFilter, ...statusCodeFilters]) {\n        const match = (filter < 100 ? Math.trunc(code / 100) : code) === filter;\n        if (match) return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * True when every token from the filter phrase(s) appears in\n   * {@link messageTokens}. Each argument is tokenized on non-alphanumeric\n   * boundaries (e.g. `hasMessage(\"not\", \"found\")` or `hasMessage(\"not found\")`).\n   */\n  hasMessage(messageFilter: string, ...messageFilters: string[]): boolean {\n    return [messageFilter, ...messageFilters]\n      .flatMap((filter) => Array.from(tokenizeWithOptions({ lowerCase: true }, filter)))\n      .every((filterToken) => this.messageTokens.includes(filterToken));\n  }\n}\n\n/** Build an {@link ErrorContext} for status + message checks. `null` / `undefined` become `{}`. */\nexport function errorContext(err: unknown): ErrorContext {\n  return new ErrorContextImpl(err ?? {});\n}\n"]}

package/lib/src/function.d.ts

@@ -0,0 +1,38 @@
+export interface MemoizeOptions {
+    /**
+     * Time-to-live in milliseconds. The cached value expires `ttlMs` after
+     * it was stored, so the next call past that recomputes; a rejection is
+     * also evicted so a later call retries rather than replaying the error.
+     * Omitted or `<= 0` means a successful value is cached forever (the default).
+     * Errors are never cached - see {@link memoize}.
+     *
+     * Use for periodically-refreshed data (published IP ranges, feature
+     * flags, anything fetched once and reused across requests).
+     */
+    ttlMs?: number;
+}
+/**
+ * Run a zero-argument factory once; later calls return the same result.
+ * The memoized function mirrors the factory's sync / async nature: a
+ * sync factory yields a sync getter (`() => T`), an async / thenable
+ * factory yields a promise-returning getter (`() => Promise<T>`) whose
+ * concurrent callers share the one in-flight promise until it settles.
+ *
+ * Errors are never cached: a sync factory that throws propagates the
+ * throw, and an async factory that rejects evicts the cached promise, so
+ * in both cases the next call retries. Pass `{ ttlMs }` to also expire
+ * and recompute a successful value after a window; without a TTL a
+ * success is cached forever.
+ *
+ * For an async factory the TTL window starts when the promise
+ * *resolves*, not when it was created - a slow in-flight request never
+ * counts as already-expired, and concurrent callers keep sharing the one
+ * pending promise until it settles.
+ *
+ * @example
+ * const ranges = functionModule.memoize(fetchIpRanges, { ttlMs: 24 * 60 * 60 * 1000 });
+ * await ranges(); // fetches
+ * await ranges(); // cached until 24h later
+ */
+export declare function memoize<T>(factory: () => PromiseLike<T>, options?: MemoizeOptions): () => Promise<T>;
+export declare function memoize<T>(factory: () => T, options?: MemoizeOptions): () => T;

package/lib/src/function.js

@@ -0,0 +1,44 @@
+export function memoize(factory, options) {
+    const ttlMs = options?.ttlMs ?? 0;
+    let cache;
+    return () => {
+        if (cache === undefined || (ttlMs > 0 && Date.now() >= cache.expiresAt)) {
+            const result = factory();
+            if (isThenable(result)) {
+                const pending = Promise.resolve(result);
+                // `Infinity` keeps the entry unexpired while in flight (so a slow
+                // request isn't refetched and concurrent callers share it); the
+                // TTL window is stamped from resolution below.
+                const entry = { value: pending, expiresAt: Infinity };
+                cache = entry;
+                void pending.then(() => {
+                    entry.expiresAt = Date.now() + ttlMs;
+                }, 
+                // Never cache a rejection: evict so a later call retries.
+                () => {
+                    if (cache === entry)
+                        cache = undefined;
+                });
+            }
+            else {
+                cache = { value: result, expiresAt: Date.now() + ttlMs };
+            }
+        }
+        return cache.value;
+    };
+}
+/** Duck-type any value with a callable `.then` as a thenable. */
+function isThenable(value) {
+    if (value !== null) {
+        if (value instanceof Promise) {
+            return true;
+        }
+        else if (typeof value === "object" &&
+            "then" in value &&
+            typeof value.then === "function") {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/hash.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Short, deterministic non-cryptographic hashing and id minting.
+ *
+ * {@link fnvHash} / {@link fnvHashWithOptions} produce a stable FNV-1a
+ * digest over arbitrary structured input; {@link toBase32} encodes a
+ * 32-bit integer compactly; {@link id} mints v4 UUIDs (or short hex
+ * slices). All browser-safe - built on `globalThis.crypto`, no
+ * `node:crypto` import. **Never** use these for tokens, signatures, or
+ * anything an attacker shouldn't be able to forge.
+ *
+ * @module
+ */
+/**
+ * Mint a v4 UUID, or a short hex slice of one when `length` is set.
+ *
+ * - `id()` returns a full RFC 4122 v4 UUID. Pick this when global
+ *   uniqueness matters: long-running batches, ids that cross a storage /
+ *   process boundary, anything that may collide across machines.
+ * - `id(length)` returns the first `length` hex chars of a fresh UUID
+ *   with dashes stripped (e.g. `id(8) -> "a3f1c92b"`). Pick this when the
+ *   id has to be short / typeable and the scope is bounded - cache keys
+ *   local to a request, slug suffixes. `length <= 0` throws.
+ *
+ * Prefers `crypto.randomUUID()`, which covers Node (>= 19) and a browser on
+ * a secure origin. Browsers gate `randomUUID` behind a secure context, so a
+ * page served over plain http (a LAN dev host) has `crypto` but not that
+ * method; this package is browser-safe and its callers mint ids on the
+ * render path, so it degrades instead of throwing: `getRandomValues` when
+ * present, else `Math.random`. Every branch returns a well-formed v4 UUID -
+ * only the entropy source differs.
+ *
+ * @example
+ * id();   // "123e4567-e89b-12d3-a456-426614174000"
+ * id(8);  // "a3f1c92b"
+ */
+export declare function id(length?: number): string;
+/**
+ * Short, deterministic FNV-1a hash over one or more values. Wraps
+ * {@link fnvHashWithOptions} with all defaults: 6-char Crockford-style
+ * base-32 output (digits + lowercase, minus `i`/`l`/`o`/`u`).
+ * Browser-safe (no `node:crypto`).
+ *
+ * Accepts any mix of primitives, arrays, plain objects, `Map`s, and
+ * `Set`s; nested structures are walked deterministically so the hash is
+ * order-stable for objects / maps / sets and order-sensitive for arrays.
+ * Cycles are detected and folded into a `circular:` marker.
+ *
+ * Use for cache keys, slug suffixes, log correlation ids, and other
+ * "give me something short and stable" needs - **never** for tokens or
+ * signatures. FNV-1a is a non-cryptographic hash.
+ *
+ * @example
+ * fnvHash("databricks-claude-sonnet-4-6"); // "k3p9q7"
+ * fnvHash([1, 2, 3]) !== fnvHash([3, 2, 1]);
+ */
+export declare function fnvHash(...values: unknown[]): string;
+/**
+ * Configurable counterpart to {@link fnvHash}.
+ *
+ * Options:
+ *   - `length` (default `6`): number of base-32 chars to return. Capped
+ *     at 7 - the underlying digest is 32 bits, which base-32-encodes to
+ *     at most 7 chars. Output is left-padded with the alphabet's zero
+ *     character so short digests still hit the requested width.
+ *   - `alphabet` (default Crockford-style
+ *     `"0123456789abcdefghjkmnpqrstvwxyz"`): 32 distinct characters used
+ *     to encode the digest. Throws when not exactly 32 unique chars.
+ *   - `digest` (default `0x811c9dc5`, the FNV-1a offset basis): the seed
+ *     the running digest starts from. Useful for namespacing so
+ *     otherwise-identical inputs hashed under different namespaces never
+ *     collide, and for chaining hashes across pipeline stages.
+ *
+ * The hash is **not** stable across changes to the alphabet or `length` -
+ * those tune the output, not the digest input.
+ *
+ * @example
+ * fnvHashWithOptions({ length: 4 }, "user@example.com");        // 4 chars
+ * fnvHashWithOptions({ digest: nsHash }, key) !== fnvHash(key); // namespaced
+ */
+export declare function fnvHashWithOptions(options?: {
+    length?: number;
+    alphabet?: string;
+    digest?: number;
+}, ...values: unknown[]): string;
+/**
+ * Encode a 32-bit unsigned integer as base-32 using the default
+ * Crockford-style alphabet (or `alphabet` when provided). The encoding
+ * has **no** zero-padding by default - `toBase32(0)` returns the
+ * alphabet's zero character, otherwise the result is the minimal number
+ * of digits that fits the value. Pad / truncate at the call site when you
+ * need a fixed width.
+ *
+ * `disableAlphabetValidation` skips the unique-32-char check for hot
+ * paths that have already validated the alphabet. The function still
+ * requires `alphabet.length === 32` either way.
+ *
+ * @example
+ * toBase32(0);        // "0"
+ * toBase32(31);       // "z"
+ * toBase32(0xdeadbe); // "6vmtw"
+ */
+export declare function toBase32(value: number, alphabet?: string, disableAlphabetValidation?: boolean): string;