@dbx-tools/shared-core 0.9.5 → 0.9.6

package/lib/src/brand-utils.js

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

package/lib/src/error-utils.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-utils.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-utils.js","sourceRoot":"","sources":["../../src/error-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;IAClD,OAAO,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;GAIG;AACH,MAAM,SAAS,CAAC,CAAC,aAAa,CAAC,KAAc;IAC3C,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,CAAC;gBAC3C,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;oBAChB,MAAM,KAAK,GAAI,IAAgC,CAAC,GAAG,CAAC,CAAC;oBACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,EAAE,CAAC;wBACvC,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;aAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC5C,MAAM,IAAI,CAAC;QACb,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,SAAS,CAAC,CAAC,UAAU,CAAC,GAAY;IACtC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAW,CAAC;IAEhC,QAAQ,CAAC,CAAC,KAAK,CAAC,IAAa;QAC3B,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO;QAChD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE,CAAC;gBACzB,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO;QAC3B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,MAAM,IAAI,CAAC;QACX,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAAC;gBACtC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;oBAChB,MAAM,KAAK,GAAI,IAAgC,CAAC,GAAG,CAAC,CAAC;oBACrD,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACtB,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC;AAUD,MAAM,gBAAgB;IAKS;IAJrB,WAAW,CAAqB;IAChC,SAAS,CAAuB;IAChC,cAAc,CAAuB;IAE7C,YAA6B,GAAyB;QAAzB,QAAG,GAAH,GAAG,CAAsB;IAAG,CAAC;IAE1D,iGAAiG;IACjG,IAAI,UAAU;QACZ,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACnC,KAAK,EAAE,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC/C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;oBAAE,SAAS;gBACxD,KAAK,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,CAAU,EAAE,CAAC;oBAClD,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;wBAAE,SAAS;oBAC7B,MAAM,KAAK,GAAI,IAAgC,CAAC,GAAG,CAAC,CAAC;oBACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,GAAG,EAAE,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;wBAC3D,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;wBACzB,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;gBACnC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;IAC/D,CAAC;IAED,8DAA8D;IAC9D,IAAI,QAAQ;QACV,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,SAAS,GAAG,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,+CAA+C;IAC/C,IAAI,aAAa;QACf,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACtC,IAAI,CAAC,cAAc,GAAG,CAAC,GAAG,mBAAmB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QACxF,CAAC;QACD,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,2EAA2E;IAC3E,IAAI,aAAa;QACf,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,gBAAwB,EAAE,GAAG,iBAA2B;QACpE,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;QAC7B,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,MAAM,MAAM,IAAI,CAAC,gBAAgB,EAAE,GAAG,iBAAiB,CAAC,EAAE,CAAC;gBAC9D,MAAM,KAAK,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC;gBACxE,IAAI,KAAK;oBAAE,OAAO,IAAI,CAAC;YACzB,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,aAAqB,EAAE,GAAG,cAAwB;QAC3D,OAAO,CAAC,aAAa,EAAE,GAAG,cAAc,CAAC;aACtC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;aACjF,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;IACtE,CAAC;CACF;AAED,mGAAmG;AACnG,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,OAAO,IAAI,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;AACzC,CAAC","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-utils.ts\";\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/execution.js

@@ -1,6 +1,6 @@
 /** Generic helpers for AppKit-style intercepted execution. */
-import * as async from "./async.js";
-import * as error from "./error.js";
+import * as async from "./async-utils.js";
+import * as error from "./error-utils.js";
 import * as object from "./object.js";
 function errorStatus(value) {
     if (!object.isRecord(value))
@@ -39,4 +39,4 @@ export async function run(options) {
         message: result.message,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/lib/src/function-utils.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/log.js

@@ -34,7 +34,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { memoize } from "./function.js";
+import { memoize } from "./function-utils.js";
 import { toBoolean } from "./object.js";
 const globalProcess = globalThis.process;
 const globalBun = globalThis.Bun;
@@ -328,4 +328,4 @@ export function logger(loggerName) {
     const name = extractLoggerName(loggerName);
     return createLogger(name);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tagged, leveled logging for every runtime - the one logger the whole\n * monorepo shares.\n *\n * {@link logger} resolves a tagged {@link Logger} through a synchronous console\n * sink, then upgrades its server-side formatter when `node:util` resolves.\n * Keeping the sink dependency-free prevents browser bundlers from retaining an\n * optional bare import that downstream apps would still have to install.\n * {@link LogLevel} filtering runs through {@link shouldEmit} in per-level\n * wrappers around the platform console or stderr sink.\n *\n * The console fallback writes formatted lines to `process.stderr` when it is\n * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is\n * unset, otherwise `node:util` `formatWithOptions`), or delegates to global\n * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit\n * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`\n * tag.\n *\n * Env toggles: `LOG_LEVEL` (read per call) and `LOG_BUN_CONSOLE_DISABLED`\n * (read once during factory init).\n *\n * Browser-safe: `process` / `Bun` / `window` / `document` are all reached\n * through `globalThis` and guarded, and `node:util` is imported ONLY on a host\n * that has `process.stderr` - never in a browser, where the specifier is\n * unresolvable - so the module works in any runtime.\n *\n * @module\n */\n\nimport { memoize } from \"./function.ts\";\nimport { type NameLike, toBoolean } from \"./object.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n  stderr?: { write?: (chunk: string) => void; isTTY?: unknown };\n}\n\n/** `Bun`-shaped view off `globalThis`, so no `@types/bun` is needed. */\ninterface BunLike {\n  env?: Record<string, string | undefined>;\n  inspect?: (value: unknown, options?: { colors?: boolean; depth?: number }) => string;\n}\n\nconst globalProcess = (globalThis as { process?: ProcessLike }).process;\nconst globalBun = (globalThis as { Bun?: BunLike }).Bun;\n\n/**\n * Node `process.stderr` when writable, else `undefined` (stable for the\n * process). Typed loosely (`any`) because it is handed to the console sink's\n * `.write`, which our structural {@link ProcessLike} shape does not satisfy\n * nominally.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst globalProcessStdErr: any =\n  globalProcess && typeof globalProcess.stderr?.write === \"function\"\n    ? globalProcess.stderr\n    : undefined;\n\nconst LOG_LEVELS = [\"debug\", \"info\", \"warn\", \"error\"] as const;\nconst LOG_LEVEL_RANK = Object.fromEntries(\n  LOG_LEVELS.map((level, index) => [level, index]),\n) as Record<LogLevel, number>;\nconst LOG_LEVEL_COLORS = Object.fromEntries(\n  LOG_LEVELS.map((level) => {\n    let color = \"\\x1b[90m\"; // gray\n    switch (level) {\n      case \"info\":\n        color = \"\\x1b[34m\"; // blue\n        break;\n      case \"warn\":\n        color = \"\\x1b[33m\"; // yellow\n        break;\n      case \"error\":\n        color = \"\\x1b[31m\"; // red\n        break;\n    }\n    return [level, color];\n  }),\n) as Record<LogLevel, string>;\nconst LOG_LEVEL_COLOR_RESET = \"\\x1b[0m\";\nconst DEFAULT_LEVEL: LogLevel = \"info\";\n\n/**\n * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.\n * A call below the active threshold is discarded before any string work or\n * sink I/O.\n *\n * The threshold comes from `process.env.LOG_LEVEL` on every call\n * (case-insensitive, default `info` when unset, empty, or unknown) so test\n * runners and embedders can change verbosity after import without restarting\n * the process.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/**\n * Dependency-free leveled logger. Standard methods honor `LOG_LEVEL`; `start`\n * and `success` are informational aliases with distinct presentation.\n */\nexport type Logger = {\n  [K in LogLevel]: (...args: any[]) => void;\n} & {\n  /** Success message emitted at `info` level. */\n  success: (...args: any[]) => void;\n  /** Start / in-progress message emitted at `info` level. */\n  start: (...args: any[]) => void;\n};\n\n/** `(name?) => Logger` sink constructor returned by the init-time factory chain. */\ntype LoggerFactory = (name?: string) => Logger;\n\n/**\n * Console {@link LoggerFactory}; always succeeds.\n *\n * When `process.stderr` is available, formats each line and writes only to\n * stderr. Bun `inspect` formats each argument when enabled; otherwise\n * `util.inspect` when `node:util` loads, or a `JSON.stringify` fallback when\n * it does not. When stderr is unavailable (every browser), binds\n * {@link createFormatter} prefixes into global `console.*` calls and skips the\n * `node:util` import entirely.\n */\nasync function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<LoggerFactory> {\n  // Indirect specifier so this browser-safe module doesn't statically pull in\n  // node types: `node:util` is optional (the JSON fallback covers its absence).\n  const nodeUtil = \"node:util\";\n  // Gated, not just caught: the indirect specifier defeats bundler analysis by\n  // design, so a client build emits a literal `import(\"node:util\")` that no\n  // browser can resolve, and the caught rejection still surfaced as a console\n  // error. `utils` only feeds the stderr branch of the emitter below, so no\n  // stderr means the import has nothing to serve and is skipped outright.\n  const utils: { inspect?: any } | undefined =\n    globalProcessStdErr === undefined\n      ? undefined\n      : await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);\n  return consoleLoggerFactory(globalProcessStdErr, utils);\n}\n\n/**\n * The synchronous core of {@link createConsoleLoggerFactory}, split out so the\n * same emitter also serves as the bootstrap sink before any async factory has\n * resolved. `utils` is `node:util` when it loaded; without it, object arguments\n * format through the `JSON.stringify` fallback.\n */\nfunction consoleLoggerFactory(\n  globalProcessStdErr: any,\n  utils?: { inspect?: any } | undefined,\n): LoggerFactory {\n  const bunInspect =\n    globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)\n      ? globalBun.inspect\n      : undefined;\n  const resetColorsPrefix = bunInspect !== undefined;\n\n  const inspect = (arg: any, colors?: boolean) => {\n    if (Array.isArray(arg) || (typeof arg === \"object\" && arg !== null)) {\n      if (bunInspect !== undefined) {\n        return bunInspect(arg, {\n          colors: colors,\n          depth: utils?.inspect?.defaultOptions?.depth ?? undefined,\n        });\n      } else if (utils !== undefined) {\n        return utils.inspect(arg, {\n          ...utils?.inspect?.defaultOptions,\n          colors: false,\n        });\n      } else {\n        const seen = new WeakSet();\n        return JSON.stringify(arg, (_, value) => {\n          if (typeof value === \"object\" && value !== null) {\n            if (seen.has(value)) return \"[Circular]\";\n            seen.add(value);\n          }\n          return value;\n        });\n      }\n    } else {\n      return String(arg);\n    }\n  };\n\n  const factory = (name?: string) => {\n    const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);\n    const logger = Object.fromEntries(\n      LOG_LEVELS.map((level) => {\n        const { prefix, colors, resetColors } = prefixFormatter(level);\n        const emitter = (...args: any[]) => {\n          if (!shouldEmit(level, true)) return;\n          if (globalProcessStdErr !== undefined) {\n            const messageParts = prefix ? [prefix] : [];\n            messageParts.push(...args.map((arg) => inspect(arg, colors)));\n            if (resetColors) messageParts.push(LOG_LEVEL_COLOR_RESET);\n            globalProcessStdErr.write(messageParts.join(\" \") + \"\\n\");\n          } else {\n            let levelFn = console[level];\n            if (typeof levelFn !== \"function\") {\n              levelFn = console.log;\n            }\n            if (prefix) levelFn = levelFn.bind(console, prefix);\n            levelFn(...args);\n          }\n        };\n        return [level, emitter];\n      }),\n    ) as Logger;\n    // Convenience levels share the info sink.\n    logger.success = logger.info;\n    logger.start = logger.info;\n    return logger;\n  };\n  const defaultFactory = memoize(factory);\n  return (name?: string) => (name ? factory(name) : defaultFactory());\n}\n\n/**\n * Full console sink with optional `node:util` inspection. Memoized so\n * concurrent and repeat callers share one in-flight promise and settled result.\n */\nconst resolveFactory = memoize(async (): Promise<LoggerFactory> => {\n  return createConsoleLoggerFactory(globalProcessStdErr);\n});\n\n/**\n * Active factory starts as a sync console sink (no `await`, so this module\n * finishes evaluating immediately) and swaps to {@link resolveFactory}'s\n * result when server-side argument inspection is ready.\n */\nlet activeFactory: LoggerFactory = consoleLoggerFactory(globalProcessStdErr);\nvoid resolveFactory().then(\n  (factory) => {\n    activeFactory = factory;\n  },\n  () => {\n    // Keep the sync console sink; never leave importers without a factory.\n  },\n);\n\n/**\n * Build a logger that rebinds when {@link activeFactory} upgrades. Callers that\n * capture `const log = logger(\"x\")` at module scope still get the upgraded\n * formatter once it arrives, without every call site waiting on a promise.\n */\nfunction createLogger(name?: string): Logger {\n  let bound: { factory: LoggerFactory; logger: Logger } | undefined;\n  const sink = (): Logger => {\n    if (bound?.factory !== activeFactory) {\n      bound = { factory: activeFactory, logger: activeFactory(name) };\n    }\n    return bound.logger;\n  };\n  return Object.fromEntries(\n    [...LOG_LEVELS, \"success\", \"start\"].map((level) => [\n      level,\n      (...args: any[]) => sink()[level as keyof Logger](...args),\n    ]),\n  ) as Logger;\n}\n\n/**\n * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone\n * in browsers (either part omitted when absent). Applies per-level ANSI color\n * when `streamSupportsColor` is true for the given stderr stream.\n */\nfunction createFormatter(\n  name: any,\n  stream: any,\n  resetColorsPrefix?: boolean,\n): (level?: LogLevel) => { prefix: string; colors: boolean; resetColors: boolean } {\n  const glob = globalThis as { window?: unknown; document?: unknown };\n  const isBrowser = glob.window !== undefined && glob.document !== undefined;\n  const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;\n  const namePrefix = name ? \"[\" + name + \"]\" : undefined;\n  return (level?: LogLevel) => {\n    const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;\n    let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]\n      .filter(Boolean)\n      .join(\" \");\n    let resetColors = false;\n    if (color) {\n      const applyResetColorsPrefix = resetColorsPrefix || \"info\" === level;\n      if (!applyResetColorsPrefix) resetColors = true;\n      prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;\n    }\n    return { prefix, colors: color ? true : false, resetColors };\n  };\n}\n\n/** True when `stream` is a TTY and the terminal is not `dumb`. */\nfunction streamSupportsColor(stream?: unknown): boolean {\n  if (globalProcess === undefined || typeof stream !== \"object\" || stream === null) return false;\n  const { isTTY } = stream as { isTTY?: unknown };\n  if (isTTY !== true) return false;\n  const term = globalProcess.env?.TERM?.toLowerCase();\n  if (\"dumb\" == term) return false;\n  return true;\n}\n\n/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */\nfunction parseLogLevel(raw: unknown): LogLevel | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n  let text = typeof raw === \"string\" ? raw : String(raw);\n  for (let i = 0; i < 2; i++) {\n    if (i > 0) {\n      const normalized = text.trim().toLowerCase();\n      if (text === normalized) break;\n      text = normalized;\n    }\n    if (!text) {\n      break;\n    } else if (text in LOG_LEVEL_RANK) {\n      return text as LogLevel;\n    }\n  }\n  return undefined;\n}\n\n/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */\nfunction activeLevel(): LogLevel {\n  return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;\n}\n\n/**\n * Whether `raw` meets the current `LOG_LEVEL` threshold.\n *\n * Parses `raw` as a {@link LogLevel}; when parsing fails, returns\n * `defaultResult` if supplied, otherwise `false`.\n */\nfunction shouldEmit(raw: unknown, defaultResult?: boolean): boolean {\n  const level = parseLogLevel(raw);\n  if (level === undefined) return defaultResult ?? false;\n  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];\n}\n\n/**\n * Whether a call at `level` would be emitted at the current\n * `process.env.LOG_LEVEL` threshold. Use before building expensive debug\n * payloads.\n *\n * @example\n * if (isLevelEnabled(\"debug\")) {\n *   log.debug(\"mounts:resolver\", { contribution: await heavySnapshot() });\n * }\n */\nexport function isLevelEnabled(level: LogLevel): boolean {\n  return shouldEmit(level);\n}\n\nconst LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\\/\\/)?.*\\/([^/.]+)(?:\\.[^/]+)?$/i;\n\n/**\n * Derive the tag string from a logger name, plugin, or path. Slash- and\n * URL-shaped strings use the last path segment (extension stripped); plain\n * strings pass through unchanged. Empty or missing names -> `undefined`\n * (untagged sink).\n */\nfunction extractLoggerName(loggerName: NameLike | string | undefined): string | undefined {\n  if (!loggerName) return undefined;\n  if (typeof loggerName === \"string\") {\n    const match = loggerName.match(LOGGER_NAME_REGEX);\n    return match?.[1] ?? loggerName;\n  }\n  return extractLoggerName(loggerName.name);\n}\n\n/**\n * Build a tagged logger for a plugin or module.\n *\n * The tag is `[name]` when `loggerName` is a non-empty string, a\n * {@link NameLike} with `name`, or a file / URL path (the basename without\n * extension is used). The console sink prepends `LEVEL [name]` on Node/Bun\n * hosts or `[name]` alone in browsers via {@link createFormatter}.\n *\n * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before\n * the sink formats or writes the line.\n *\n * @example\n * import { log } from \"@dbx-tools/shared-core\";\n *\n * const logger = log.logger(\"genie/chat\");\n * logger.info(\"starting\");\n * logger.warn(\"missing optional config\", { reason: \"no env var\" });\n */\nexport function logger(loggerName: NameLike | string | undefined): Logger {\n  const name = extractLoggerName(loggerName);\n  return createLogger(name);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tagged, leveled logging for every runtime - the one logger the whole\n * monorepo shares.\n *\n * {@link logger} resolves a tagged {@link Logger} through a synchronous console\n * sink, then upgrades its server-side formatter when `node:util` resolves.\n * Keeping the sink dependency-free prevents browser bundlers from retaining an\n * optional bare import that downstream apps would still have to install.\n * {@link LogLevel} filtering runs through {@link shouldEmit} in per-level\n * wrappers around the platform console or stderr sink.\n *\n * The console fallback writes formatted lines to `process.stderr` when it is\n * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is\n * unset, otherwise `node:util` `formatWithOptions`), or delegates to global\n * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit\n * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`\n * tag.\n *\n * Env toggles: `LOG_LEVEL` (read per call) and `LOG_BUN_CONSOLE_DISABLED`\n * (read once during factory init).\n *\n * Browser-safe: `process` / `Bun` / `window` / `document` are all reached\n * through `globalThis` and guarded, and `node:util` is imported ONLY on a host\n * that has `process.stderr` - never in a browser, where the specifier is\n * unresolvable - so the module works in any runtime.\n *\n * @module\n */\n\nimport { memoize } from \"./function-utils.ts\";\nimport { type NameLike, toBoolean } from \"./object.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n  stderr?: { write?: (chunk: string) => void; isTTY?: unknown };\n}\n\n/** `Bun`-shaped view off `globalThis`, so no `@types/bun` is needed. */\ninterface BunLike {\n  env?: Record<string, string | undefined>;\n  inspect?: (value: unknown, options?: { colors?: boolean; depth?: number }) => string;\n}\n\nconst globalProcess = (globalThis as { process?: ProcessLike }).process;\nconst globalBun = (globalThis as { Bun?: BunLike }).Bun;\n\n/**\n * Node `process.stderr` when writable, else `undefined` (stable for the\n * process). Typed loosely (`any`) because it is handed to the console sink's\n * `.write`, which our structural {@link ProcessLike} shape does not satisfy\n * nominally.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst globalProcessStdErr: any =\n  globalProcess && typeof globalProcess.stderr?.write === \"function\"\n    ? globalProcess.stderr\n    : undefined;\n\nconst LOG_LEVELS = [\"debug\", \"info\", \"warn\", \"error\"] as const;\nconst LOG_LEVEL_RANK = Object.fromEntries(\n  LOG_LEVELS.map((level, index) => [level, index]),\n) as Record<LogLevel, number>;\nconst LOG_LEVEL_COLORS = Object.fromEntries(\n  LOG_LEVELS.map((level) => {\n    let color = \"\\x1b[90m\"; // gray\n    switch (level) {\n      case \"info\":\n        color = \"\\x1b[34m\"; // blue\n        break;\n      case \"warn\":\n        color = \"\\x1b[33m\"; // yellow\n        break;\n      case \"error\":\n        color = \"\\x1b[31m\"; // red\n        break;\n    }\n    return [level, color];\n  }),\n) as Record<LogLevel, string>;\nconst LOG_LEVEL_COLOR_RESET = \"\\x1b[0m\";\nconst DEFAULT_LEVEL: LogLevel = \"info\";\n\n/**\n * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.\n * A call below the active threshold is discarded before any string work or\n * sink I/O.\n *\n * The threshold comes from `process.env.LOG_LEVEL` on every call\n * (case-insensitive, default `info` when unset, empty, or unknown) so test\n * runners and embedders can change verbosity after import without restarting\n * the process.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/**\n * Dependency-free leveled logger. Standard methods honor `LOG_LEVEL`; `start`\n * and `success` are informational aliases with distinct presentation.\n */\nexport type Logger = {\n  [K in LogLevel]: (...args: any[]) => void;\n} & {\n  /** Success message emitted at `info` level. */\n  success: (...args: any[]) => void;\n  /** Start / in-progress message emitted at `info` level. */\n  start: (...args: any[]) => void;\n};\n\n/** `(name?) => Logger` sink constructor returned by the init-time factory chain. */\ntype LoggerFactory = (name?: string) => Logger;\n\n/**\n * Console {@link LoggerFactory}; always succeeds.\n *\n * When `process.stderr` is available, formats each line and writes only to\n * stderr. Bun `inspect` formats each argument when enabled; otherwise\n * `util.inspect` when `node:util` loads, or a `JSON.stringify` fallback when\n * it does not. When stderr is unavailable (every browser), binds\n * {@link createFormatter} prefixes into global `console.*` calls and skips the\n * `node:util` import entirely.\n */\nasync function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<LoggerFactory> {\n  // Indirect specifier so this browser-safe module doesn't statically pull in\n  // node types: `node:util` is optional (the JSON fallback covers its absence).\n  const nodeUtil = \"node:util\";\n  // Gated, not just caught: the indirect specifier defeats bundler analysis by\n  // design, so a client build emits a literal `import(\"node:util\")` that no\n  // browser can resolve, and the caught rejection still surfaced as a console\n  // error. `utils` only feeds the stderr branch of the emitter below, so no\n  // stderr means the import has nothing to serve and is skipped outright.\n  const utils: { inspect?: any } | undefined =\n    globalProcessStdErr === undefined\n      ? undefined\n      : await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);\n  return consoleLoggerFactory(globalProcessStdErr, utils);\n}\n\n/**\n * The synchronous core of {@link createConsoleLoggerFactory}, split out so the\n * same emitter also serves as the bootstrap sink before any async factory has\n * resolved. `utils` is `node:util` when it loaded; without it, object arguments\n * format through the `JSON.stringify` fallback.\n */\nfunction consoleLoggerFactory(\n  globalProcessStdErr: any,\n  utils?: { inspect?: any } | undefined,\n): LoggerFactory {\n  const bunInspect =\n    globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)\n      ? globalBun.inspect\n      : undefined;\n  const resetColorsPrefix = bunInspect !== undefined;\n\n  const inspect = (arg: any, colors?: boolean) => {\n    if (Array.isArray(arg) || (typeof arg === \"object\" && arg !== null)) {\n      if (bunInspect !== undefined) {\n        return bunInspect(arg, {\n          colors: colors,\n          depth: utils?.inspect?.defaultOptions?.depth ?? undefined,\n        });\n      } else if (utils !== undefined) {\n        return utils.inspect(arg, {\n          ...utils?.inspect?.defaultOptions,\n          colors: false,\n        });\n      } else {\n        const seen = new WeakSet();\n        return JSON.stringify(arg, (_, value) => {\n          if (typeof value === \"object\" && value !== null) {\n            if (seen.has(value)) return \"[Circular]\";\n            seen.add(value);\n          }\n          return value;\n        });\n      }\n    } else {\n      return String(arg);\n    }\n  };\n\n  const factory = (name?: string) => {\n    const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);\n    const logger = Object.fromEntries(\n      LOG_LEVELS.map((level) => {\n        const { prefix, colors, resetColors } = prefixFormatter(level);\n        const emitter = (...args: any[]) => {\n          if (!shouldEmit(level, true)) return;\n          if (globalProcessStdErr !== undefined) {\n            const messageParts = prefix ? [prefix] : [];\n            messageParts.push(...args.map((arg) => inspect(arg, colors)));\n            if (resetColors) messageParts.push(LOG_LEVEL_COLOR_RESET);\n            globalProcessStdErr.write(messageParts.join(\" \") + \"\\n\");\n          } else {\n            let levelFn = console[level];\n            if (typeof levelFn !== \"function\") {\n              levelFn = console.log;\n            }\n            if (prefix) levelFn = levelFn.bind(console, prefix);\n            levelFn(...args);\n          }\n        };\n        return [level, emitter];\n      }),\n    ) as Logger;\n    // Convenience levels share the info sink.\n    logger.success = logger.info;\n    logger.start = logger.info;\n    return logger;\n  };\n  const defaultFactory = memoize(factory);\n  return (name?: string) => (name ? factory(name) : defaultFactory());\n}\n\n/**\n * Full console sink with optional `node:util` inspection. Memoized so\n * concurrent and repeat callers share one in-flight promise and settled result.\n */\nconst resolveFactory = memoize(async (): Promise<LoggerFactory> => {\n  return createConsoleLoggerFactory(globalProcessStdErr);\n});\n\n/**\n * Active factory starts as a sync console sink (no `await`, so this module\n * finishes evaluating immediately) and swaps to {@link resolveFactory}'s\n * result when server-side argument inspection is ready.\n */\nlet activeFactory: LoggerFactory = consoleLoggerFactory(globalProcessStdErr);\nvoid resolveFactory().then(\n  (factory) => {\n    activeFactory = factory;\n  },\n  () => {\n    // Keep the sync console sink; never leave importers without a factory.\n  },\n);\n\n/**\n * Build a logger that rebinds when {@link activeFactory} upgrades. Callers that\n * capture `const log = logger(\"x\")` at module scope still get the upgraded\n * formatter once it arrives, without every call site waiting on a promise.\n */\nfunction createLogger(name?: string): Logger {\n  let bound: { factory: LoggerFactory; logger: Logger } | undefined;\n  const sink = (): Logger => {\n    if (bound?.factory !== activeFactory) {\n      bound = { factory: activeFactory, logger: activeFactory(name) };\n    }\n    return bound.logger;\n  };\n  return Object.fromEntries(\n    [...LOG_LEVELS, \"success\", \"start\"].map((level) => [\n      level,\n      (...args: any[]) => sink()[level as keyof Logger](...args),\n    ]),\n  ) as Logger;\n}\n\n/**\n * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone\n * in browsers (either part omitted when absent). Applies per-level ANSI color\n * when `streamSupportsColor` is true for the given stderr stream.\n */\nfunction createFormatter(\n  name: any,\n  stream: any,\n  resetColorsPrefix?: boolean,\n): (level?: LogLevel) => { prefix: string; colors: boolean; resetColors: boolean } {\n  const glob = globalThis as { window?: unknown; document?: unknown };\n  const isBrowser = glob.window !== undefined && glob.document !== undefined;\n  const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;\n  const namePrefix = name ? \"[\" + name + \"]\" : undefined;\n  return (level?: LogLevel) => {\n    const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;\n    let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]\n      .filter(Boolean)\n      .join(\" \");\n    let resetColors = false;\n    if (color) {\n      const applyResetColorsPrefix = resetColorsPrefix || \"info\" === level;\n      if (!applyResetColorsPrefix) resetColors = true;\n      prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;\n    }\n    return { prefix, colors: color ? true : false, resetColors };\n  };\n}\n\n/** True when `stream` is a TTY and the terminal is not `dumb`. */\nfunction streamSupportsColor(stream?: unknown): boolean {\n  if (globalProcess === undefined || typeof stream !== \"object\" || stream === null) return false;\n  const { isTTY } = stream as { isTTY?: unknown };\n  if (isTTY !== true) return false;\n  const term = globalProcess.env?.TERM?.toLowerCase();\n  if (\"dumb\" == term) return false;\n  return true;\n}\n\n/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */\nfunction parseLogLevel(raw: unknown): LogLevel | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n  let text = typeof raw === \"string\" ? raw : String(raw);\n  for (let i = 0; i < 2; i++) {\n    if (i > 0) {\n      const normalized = text.trim().toLowerCase();\n      if (text === normalized) break;\n      text = normalized;\n    }\n    if (!text) {\n      break;\n    } else if (text in LOG_LEVEL_RANK) {\n      return text as LogLevel;\n    }\n  }\n  return undefined;\n}\n\n/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */\nfunction activeLevel(): LogLevel {\n  return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;\n}\n\n/**\n * Whether `raw` meets the current `LOG_LEVEL` threshold.\n *\n * Parses `raw` as a {@link LogLevel}; when parsing fails, returns\n * `defaultResult` if supplied, otherwise `false`.\n */\nfunction shouldEmit(raw: unknown, defaultResult?: boolean): boolean {\n  const level = parseLogLevel(raw);\n  if (level === undefined) return defaultResult ?? false;\n  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];\n}\n\n/**\n * Whether a call at `level` would be emitted at the current\n * `process.env.LOG_LEVEL` threshold. Use before building expensive debug\n * payloads.\n *\n * @example\n * if (isLevelEnabled(\"debug\")) {\n *   log.debug(\"mounts:resolver\", { contribution: await heavySnapshot() });\n * }\n */\nexport function isLevelEnabled(level: LogLevel): boolean {\n  return shouldEmit(level);\n}\n\nconst LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\\/\\/)?.*\\/([^/.]+)(?:\\.[^/]+)?$/i;\n\n/**\n * Derive the tag string from a logger name, plugin, or path. Slash- and\n * URL-shaped strings use the last path segment (extension stripped); plain\n * strings pass through unchanged. Empty or missing names -> `undefined`\n * (untagged sink).\n */\nfunction extractLoggerName(loggerName: NameLike | string | undefined): string | undefined {\n  if (!loggerName) return undefined;\n  if (typeof loggerName === \"string\") {\n    const match = loggerName.match(LOGGER_NAME_REGEX);\n    return match?.[1] ?? loggerName;\n  }\n  return extractLoggerName(loggerName.name);\n}\n\n/**\n * Build a tagged logger for a plugin or module.\n *\n * The tag is `[name]` when `loggerName` is a non-empty string, a\n * {@link NameLike} with `name`, or a file / URL path (the basename without\n * extension is used). The console sink prepends `LEVEL [name]` on Node/Bun\n * hosts or `[name]` alone in browsers via {@link createFormatter}.\n *\n * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before\n * the sink formats or writes the line.\n *\n * @example\n * import { log } from \"@dbx-tools/shared-core\";\n *\n * const logger = log.logger(\"genie/chat\");\n * logger.info(\"starting\");\n * logger.warn(\"missing optional config\", { reason: \"no env var\" });\n */\nexport function logger(loggerName: NameLike | string | undefined): Logger {\n  const name = extractLoggerName(loggerName);\n  return createLogger(name);\n}\n"]}