@veryfront/ext-content-mdx 0.1.985

package/esm/src/utils/import-lockfile.js

@@ -0,0 +1,187 @@
+import { computeHash } from "./hash-utils.js";
+import { serverLogger } from "./logger/index.js";
+import { createFileSystem } from "../platform/compat/fs.js";
+import { CACHE_ERROR, NETWORK_ERROR } from "../errors/error-registry.js";
+const logger = serverLogger.component("lockfile");
+const LOCKFILE_NAME = "veryfront.lock";
+const LOCKFILE_VERSION = 1;
+export function createEmptyLockfile() {
+    return { version: LOCKFILE_VERSION, imports: {} };
+}
+/** Compute integrity. */
+export async function computeIntegrity(content) {
+    const hash = await computeHash(content);
+    return `sha256-${hash}`;
+}
+export async function verifyIntegrity(content, integrity) {
+    const computed = await computeIntegrity(content);
+    return computed === integrity;
+}
+function createPlatformFSAdapter() {
+    const fs = createFileSystem();
+    return {
+        readFile(path) {
+            return fs.readTextFile(path);
+        },
+        writeFile(path, content) {
+            return fs.writeTextFile(path, content);
+        },
+        exists(path) {
+            return fs.exists(path);
+        },
+        remove(path) {
+            return fs.remove(path);
+        },
+    };
+}
+/** Create lockfile manager. */
+export function createLockfileManager(projectDir, fsAdapter) {
+    const fs = fsAdapter ?? createPlatformFSAdapter();
+    const lockfilePath = `${projectDir}/${LOCKFILE_NAME}`;
+    let cache = null;
+    let dirty = false;
+    async function read() {
+        if (cache)
+            return cache;
+        try {
+            const exists = await fs.exists(lockfilePath);
+            if (!exists)
+                return null;
+            const content = await fs.readFile(lockfilePath);
+            const parsed = JSON.parse(content);
+            if (parsed.version !== LOCKFILE_VERSION) {
+                logger.warn(`[lockfile] Version mismatch, expected ${LOCKFILE_VERSION}, got ${parsed.version}`);
+                cache = createEmptyLockfile();
+                return cache;
+            }
+            cache = parsed;
+            return cache;
+        }
+        catch (e) {
+            logger.debug(`Could not read lockfile: ${e}`);
+            return null;
+        }
+    }
+    async function write(data) {
+        cache = data;
+        const sorted = {
+            version: data.version,
+            imports: Object.fromEntries(Object.entries(data.imports).sort(([a], [b]) => a.localeCompare(b))),
+        };
+        await fs.writeFile(lockfilePath, `${JSON.stringify(sorted, null, 2)}\n`);
+        dirty = false;
+        logger.debug(`Written ${Object.keys(data.imports).length} entries`);
+    }
+    async function get(url) {
+        const data = await read();
+        return data?.imports[url] ?? null;
+    }
+    async function set(url, entry) {
+        const data = (await read()) ?? createEmptyLockfile();
+        data.imports[url] = entry;
+        cache = data;
+        dirty = true;
+    }
+    async function has(url) {
+        const data = await read();
+        return url in (data?.imports ?? {});
+    }
+    async function clear() {
+        cache = createEmptyLockfile();
+        dirty = false;
+        if (!fs.remove)
+            return;
+        const exists = await fs.exists(lockfilePath);
+        if (!exists)
+            return;
+        await fs.remove(lockfilePath);
+    }
+    async function flush() {
+        if (!dirty || !cache)
+            return;
+        await write(cache);
+    }
+    return { read, write, get, set, has, clear, flush };
+}
+const USER_AGENT_HEADERS = { "user-agent": "Mozilla/5.0 Veryfront/1.0" };
+export async function fetchWithLock(options) {
+    const { lockfile, url, fetchFn = fetch, strict = false } = options;
+    const entry = await lockfile.get(url);
+    if (entry) {
+        logger.debug(`Cache hit for ${url}`);
+        const res = await fetchFn(entry.resolved, { headers: USER_AGENT_HEADERS });
+        if (!res.ok) {
+            if (strict) {
+                throw CACHE_ERROR.create({
+                    detail: `Lockfile entry stale: ${url} resolved to ${entry.resolved} returned ${res.status}`,
+                });
+            }
+            logger.warn(`Cached URL ${entry.resolved} returned ${res.status}, refetching`);
+        }
+        else {
+            const content = await res.text();
+            const currentIntegrity = await computeIntegrity(content);
+            if (currentIntegrity === entry.integrity) {
+                return {
+                    content,
+                    resolvedUrl: entry.resolved,
+                    fromCache: true,
+                    integrity: entry.integrity,
+                };
+            }
+            if (strict) {
+                throw CACHE_ERROR.create({
+                    detail: `Integrity mismatch for ${url}: expected ${entry.integrity}, got ${currentIntegrity}`,
+                });
+            }
+            logger.warn(`Integrity mismatch for ${url}, updating lockfile`);
+        }
+    }
+    logger.debug(`Fetching fresh: ${url}`);
+    const res = await fetchFn(url, { headers: USER_AGENT_HEADERS, redirect: "follow" });
+    if (!res.ok)
+        throw NETWORK_ERROR.create({ detail: `Failed to fetch ${url}: ${res.status}` });
+    const content = await res.text();
+    const resolvedUrl = res.url || url;
+    const integrity = await computeIntegrity(content);
+    await lockfile.set(url, {
+        resolved: resolvedUrl,
+        integrity,
+        fetchedAt: new Date().toISOString(),
+    });
+    await lockfile.flush();
+    return { content, resolvedUrl, fromCache: false, integrity };
+}
+const IMPORT_REGEX = /import\s+(?:(?:[\w*\s{},]*)\s+from\s+)?['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_REGEX = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const EXPORT_FROM_REGEX = /export\s+(?:[\w*\s{},]*)\s+from\s+['"]([^'"]+)['"]/g;
+export function extractImports(content) {
+    const imports = [];
+    const seen = new Set();
+    function addMatches(regex, type) {
+        for (const match of content.matchAll(regex)) {
+            const specifier = match[1];
+            if (!specifier || seen.has(specifier))
+                continue;
+            seen.add(specifier);
+            imports.push({ specifier, type });
+        }
+    }
+    addMatches(IMPORT_REGEX, "static");
+    addMatches(EXPORT_FROM_REGEX, "static");
+    addMatches(DYNAMIC_IMPORT_REGEX, "dynamic");
+    return imports;
+}
+export function resolveImportUrl(specifier, baseUrl) {
+    if (specifier.startsWith("http://") || specifier.startsWith("https://"))
+        return specifier;
+    if (!specifier.startsWith("./") && !specifier.startsWith("../"))
+        return null;
+    try {
+        return new URL(specifier, baseUrl).toString();
+    }
+    catch (_) {
+        /* expected: specifier may not be a valid relative URL */
+        return null;
+    }
+}

package/esm/src/utils/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Runtime detection, logging, constants, hashing, and feature flags.
+ *
+ * @module utils
+ *
+ * @example Structured logging
+ * ```ts
+ * import { serverLogger } from "veryfront/utils";
+ *
+ * serverLogger.info("Booting server", { project_id: "proj_123" });
+ * ```
+ */
+export { type GlobalWithBun, type GlobalWithDeno, type GlobalWithProcess, hasBunRuntime, hasDenoRuntime, hasNodeProcess, } from "./runtime-guards.js";
+export { __registerTraceContextGetter, __registerTraceContextGetter as registerTraceContextGetter, agentLogger, bundlerLogger, createRunUserLogger, logger, refreshLoggerConfig, rendererLogger, runWithRequestContextAsync, serverLogger, } from "./logger/index.js";
+export type { Logger, RequestContext } from "./logger/index.js";
+export { BREAKPOINT_LG, BREAKPOINT_MD, BREAKPOINT_SM, BREAKPOINT_XL, BYTES_PER_KB, DEFAULT_ALLOWED_CDN_HOSTS, DEFAULT_BUILD_CONCURRENCY, DEFAULT_DASHBOARD_PORT, DEFAULT_LRU_MAX_ENTRIES, DEV_SERVER_ENDPOINTS, FORBIDDEN_PATH_PATTERNS, getDenoStdNodeBase, getReactImportMap, HASH_SEED_DJB2, HASH_SEED_FNV1A, HMR_CLIENT_RELOAD_DELAY_MS, HMR_CLOSE_MESSAGE_TOO_LARGE, HMR_CLOSE_NORMAL, HMR_CLOSE_RATE_LIMIT, HMR_MAX_MESSAGE_SIZE_BYTES, HMR_MAX_MESSAGES_PER_MINUTE, HMR_RATE_LIMIT_WINDOW_MS, HTTP_BAD_REQUEST, HTTP_CONTENT_TYPE_IMAGE_GIF, HTTP_CONTENT_TYPE_IMAGE_ICO, HTTP_CONTENT_TYPE_IMAGE_JPEG, HTTP_CONTENT_TYPE_IMAGE_PNG, HTTP_CONTENT_TYPE_IMAGE_SVG, HTTP_CONTENT_TYPE_IMAGE_WEBP, HTTP_CONTENT_TYPES, HTTP_MODULE_FETCH_TIMEOUT_MS, HTTP_NETWORK_CONNECT_TIMEOUT, HTTP_NOT_FOUND, HTTP_NOT_IMPLEMENTED, HTTP_OK, HTTP_REDIRECT_FOUND, HTTP_SERVER_ERROR, HTTP_STATUS_CLIENT_ERROR_MIN, HTTP_STATUS_REDIRECT_MIN, HTTP_STATUS_SERVER_ERROR_MIN, HTTP_STATUS_SUCCESS_MIN, HTTP_UNAVAILABLE, IMAGE_OPTIMIZATION, MAX_BATCH_SIZE, MAX_PATH_LENGTH, MAX_PATH_TRAVERSAL_DEPTH, MS_PER_SECOND, PREFETCH_DEFAULT_DELAY_MS, PREFETCH_DEFAULT_TIMEOUT_MS, PREFETCH_MAX_SIZE_BYTES, REACT_DEFAULT_VERSION, RESPONSIVE_IMAGE_WIDTH_LG, RESPONSIVE_IMAGE_WIDTHS, RSC_MANIFEST_CACHE_TTL_MS, TSX_LAYOUT_MAX_ENTRIES, TSX_LAYOUT_PER_PROJECT_MAX_ENTRIES, Z_INDEX_DEV_INDICATOR, Z_INDEX_ERROR_OVERLAY, } from "./constants/index.js";
+export { VERSION } from "./version.js";
+export { type BundleCode as HashBundleCode, computeCodeHash, computeHash, fnv1aHash, shortHash, simpleHash, } from "./hash-utils.js";
+export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
+export { normalizePath } from "./path-utils.js";
+export { type BundleCode, type BundleMetadata, getBundleManifestStore } from "./bundle-manifest.js";
+export { isRSCEnabled } from "./feature-flags.js";
+export { isCompiledBinary } from "./platform.js";
+export { computeIntegrity, createLockfileManager, type LockfileManager, } from "./import-lockfile.js";
+export { endRequest, isEnabled, startRequest, startTimer, timeAsync } from "./perf-timer.js";
+export { parallelMap } from "./parallel.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,aAAa,EACb,cAAc,EACd,cAAc,GACf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,4BAA4B,EAC5B,4BAA4B,IAAI,0BAA0B,EAC1D,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,MAAM,EACN,mBAAmB,EACnB,cAAc,EACd,0BAA0B,EAC1B,YAAY,GACb,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACZ,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,0BAA0B,EAC1B,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,gBAAgB,EAChB,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,EAClB,4BAA4B,EAC5B,4BAA4B,EAC5B,cAAc,EACd,oBAAoB,EACpB,OAAO,EACP,mBAAmB,EACnB,iBAAiB,EACjB,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACvB,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,wBAAwB,EACxB,aAAa,EACb,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,kCAAkC,EAClC,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EACL,KAAK,UAAU,IAAI,cAAc,EACjC,eAAe,EACf,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3F,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEpG,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,eAAe,GACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE7F,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/esm/src/utils/index.js

@@ -0,0 +1,25 @@
+/**
+ * Runtime detection, logging, constants, hashing, and feature flags.
+ *
+ * @module utils
+ *
+ * @example Structured logging
+ * ```ts
+ * import { serverLogger } from "veryfront/utils";
+ *
+ * serverLogger.info("Booting server", { project_id: "proj_123" });
+ * ```
+ */
+export { hasBunRuntime, hasDenoRuntime, hasNodeProcess, } from "./runtime-guards.js";
+export { __registerTraceContextGetter, __registerTraceContextGetter as registerTraceContextGetter, agentLogger, bundlerLogger, createRunUserLogger, logger, refreshLoggerConfig, rendererLogger, runWithRequestContextAsync, serverLogger, } from "./logger/index.js";
+export { BREAKPOINT_LG, BREAKPOINT_MD, BREAKPOINT_SM, BREAKPOINT_XL, BYTES_PER_KB, DEFAULT_ALLOWED_CDN_HOSTS, DEFAULT_BUILD_CONCURRENCY, DEFAULT_DASHBOARD_PORT, DEFAULT_LRU_MAX_ENTRIES, DEV_SERVER_ENDPOINTS, FORBIDDEN_PATH_PATTERNS, getDenoStdNodeBase, getReactImportMap, HASH_SEED_DJB2, HASH_SEED_FNV1A, HMR_CLIENT_RELOAD_DELAY_MS, HMR_CLOSE_MESSAGE_TOO_LARGE, HMR_CLOSE_NORMAL, HMR_CLOSE_RATE_LIMIT, HMR_MAX_MESSAGE_SIZE_BYTES, HMR_MAX_MESSAGES_PER_MINUTE, HMR_RATE_LIMIT_WINDOW_MS, HTTP_BAD_REQUEST, HTTP_CONTENT_TYPE_IMAGE_GIF, HTTP_CONTENT_TYPE_IMAGE_ICO, HTTP_CONTENT_TYPE_IMAGE_JPEG, HTTP_CONTENT_TYPE_IMAGE_PNG, HTTP_CONTENT_TYPE_IMAGE_SVG, HTTP_CONTENT_TYPE_IMAGE_WEBP, HTTP_CONTENT_TYPES, HTTP_MODULE_FETCH_TIMEOUT_MS, HTTP_NETWORK_CONNECT_TIMEOUT, HTTP_NOT_FOUND, HTTP_NOT_IMPLEMENTED, HTTP_OK, HTTP_REDIRECT_FOUND, HTTP_SERVER_ERROR, HTTP_STATUS_CLIENT_ERROR_MIN, HTTP_STATUS_REDIRECT_MIN, HTTP_STATUS_SERVER_ERROR_MIN, HTTP_STATUS_SUCCESS_MIN, HTTP_UNAVAILABLE, IMAGE_OPTIMIZATION, MAX_BATCH_SIZE, MAX_PATH_LENGTH, MAX_PATH_TRAVERSAL_DEPTH, MS_PER_SECOND, PREFETCH_DEFAULT_DELAY_MS, PREFETCH_DEFAULT_TIMEOUT_MS, PREFETCH_MAX_SIZE_BYTES, REACT_DEFAULT_VERSION, RESPONSIVE_IMAGE_WIDTH_LG, RESPONSIVE_IMAGE_WIDTHS, RSC_MANIFEST_CACHE_TTL_MS, TSX_LAYOUT_MAX_ENTRIES, TSX_LAYOUT_PER_PROJECT_MAX_ENTRIES, Z_INDEX_DEV_INDICATOR, Z_INDEX_ERROR_OVERLAY, } from "./constants/index.js";
+export { VERSION } from "./version.js";
+export { computeCodeHash, computeHash, fnv1aHash, shortHash, simpleHash, } from "./hash-utils.js";
+export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
+export { normalizePath } from "./path-utils.js";
+export { getBundleManifestStore } from "./bundle-manifest.js";
+export { isRSCEnabled } from "./feature-flags.js";
+export { isCompiledBinary } from "./platform.js";
+export { computeIntegrity, createLockfileManager, } from "./import-lockfile.js";
+export { endRequest, isEnabled, startRequest, startTimer, timeAsync } from "./perf-timer.js";
+export { parallelMap } from "./parallel.js";

package/esm/src/utils/logger/components.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Canonical component names for structured logging.
+ *
+ * These names are used with `logger.component("name")` to create
+ * component-scoped loggers. The component field appears in JSON output
+ * for Grafana/Loki filtering and as `[name]` in text output.
+ *
+ * Convention: lowercase-kebab-case.
+ * Not enforced at runtime — any string is accepted. This registry is a
+ * non-exhaustive reference to promote reuse and discoverability.
+ *
+ * @module
+ */
+export declare const LogComponents: {
+    readonly server: "server";
+    readonly config: "config";
+    readonly middleware: "middleware";
+    readonly cors: "cors";
+    readonly security: "security";
+    readonly discovery: "discovery";
+    readonly pipeline: "pipeline";
+    readonly global: "global";
+    readonly ssr: "ssr";
+    readonly ssrService: "ssr-service";
+    readonly ssrOrchestrator: "ssr-orchestrator";
+    readonly rsc: "rsc";
+    readonly html: "html";
+    readonly htmlGenerator: "html-generator";
+    readonly mdx: "mdx";
+    readonly mdxCompiler: "mdx-compiler";
+    readonly mdxCache: "mdx-cache";
+    readonly hmr: "hmr";
+    readonly hmrHandler: "hmr-handler";
+    readonly hmrServer: "hmr-server";
+    readonly renderer: "renderer";
+    readonly snippetRenderer: "snippet-renderer";
+    readonly build: "build";
+    readonly esm: "esm";
+    readonly esmTransform: "esm-transform";
+    readonly ssrTransform: "ssr-transform";
+    readonly ssrModuleLoader: "ssr-module-loader";
+    readonly moduleLoader: "module-loader";
+    readonly moduleServer: "module-server";
+    readonly cache: "cache";
+    readonly cacheRegistry: "cache-registry";
+    readonly distributedCache: "distributed-cache";
+    readonly httpCache: "http-cache";
+    readonly httpCacheWrapper: "http-cache-wrapper";
+    readonly ssrHttpCache: "ssr-http-cache";
+    readonly fileCache: "file-cache";
+    readonly moduleCache: "module-cache";
+    readonly transformCache: "transform-cache";
+    readonly api: "api";
+    readonly httpHandler: "http-handler";
+    readonly client: "client";
+    readonly runtimeHandler: "runtime-handler";
+    readonly redis: "redis";
+    readonly fsIntegration: "fs-integration";
+    readonly readOperations: "read-operations";
+    readonly otel: "otel";
+    readonly tracing: "tracing";
+    readonly metrics: "metrics";
+    readonly autoInstrument: "auto-instrument";
+    readonly perf: "perf";
+    readonly agent: "agent";
+    readonly tool: "tool";
+    readonly workflowDiscovery: "workflow-discovery";
+    readonly validator: "validator";
+    readonly error: "error";
+    readonly env: "env";
+};
+export type LogComponent = (typeof LogComponents)[keyof typeof LogComponents];
+//# sourceMappingURL=components.d.ts.map

package/esm/src/utils/logger/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/components.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC"}

package/esm/src/utils/logger/components.js

@@ -0,0 +1,81 @@
+/**
+ * Canonical component names for structured logging.
+ *
+ * These names are used with `logger.component("name")` to create
+ * component-scoped loggers. The component field appears in JSON output
+ * for Grafana/Loki filtering and as `[name]` in text output.
+ *
+ * Convention: lowercase-kebab-case.
+ * Not enforced at runtime — any string is accepted. This registry is a
+ * non-exhaustive reference to promote reuse and discoverability.
+ *
+ * @module
+ */
+export const LogComponents = {
+    // Server & infrastructure
+    server: "server",
+    config: "config",
+    middleware: "middleware",
+    cors: "cors",
+    security: "security",
+    discovery: "discovery",
+    pipeline: "pipeline",
+    global: "global",
+    // Rendering
+    ssr: "ssr",
+    ssrService: "ssr-service",
+    ssrOrchestrator: "ssr-orchestrator",
+    rsc: "rsc",
+    html: "html",
+    htmlGenerator: "html-generator",
+    mdx: "mdx",
+    mdxCompiler: "mdx-compiler",
+    mdxCache: "mdx-cache",
+    hmr: "hmr",
+    hmrHandler: "hmr-handler",
+    hmrServer: "hmr-server",
+    renderer: "renderer",
+    snippetRenderer: "snippet-renderer",
+    // Build & transforms
+    build: "build",
+    esm: "esm",
+    esmTransform: "esm-transform",
+    ssrTransform: "ssr-transform",
+    ssrModuleLoader: "ssr-module-loader",
+    moduleLoader: "module-loader",
+    moduleServer: "module-server",
+    // Caching
+    cache: "cache",
+    cacheRegistry: "cache-registry",
+    distributedCache: "distributed-cache",
+    httpCache: "http-cache",
+    httpCacheWrapper: "http-cache-wrapper",
+    ssrHttpCache: "ssr-http-cache",
+    fileCache: "file-cache",
+    moduleCache: "module-cache",
+    transformCache: "transform-cache",
+    // API & HTTP
+    api: "api",
+    httpHandler: "http-handler",
+    client: "client",
+    runtimeHandler: "runtime-handler",
+    // Platform & adapters
+    redis: "redis",
+    fsIntegration: "fs-integration",
+    readOperations: "read-operations",
+    // Observability
+    otel: "otel",
+    tracing: "tracing",
+    metrics: "metrics",
+    autoInstrument: "auto-instrument",
+    perf: "perf",
+    // Agent & AI
+    agent: "agent",
+    tool: "tool",
+    // Workflow
+    workflowDiscovery: "workflow-discovery",
+    // Misc
+    validator: "validator",
+    error: "error",
+    env: "env",
+};

package/esm/src/utils/logger/core.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Shared logger formatting utilities.
+ * This module contains pure formatting functions with no external dependencies,
+ * enabling reuse between the main logger and proxy logger.
+ *
+ * @module
+ */
+export declare const TAG_WIDTH = 10;
+export declare const PREFIX_WIDTH = 23;
+export type LogLevelName = "debug" | "info" | "warn" | "error";
+export declare const LEVEL_GLYPHS: Record<LogLevelName, string>;
+export declare const ANSI: {
+    readonly reset: "\u001B[0m";
+    readonly dim: "\u001B[2m";
+    readonly gray: "\u001B[90m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+};
+export declare const LEVEL_COLORS: Record<LogLevelName, string>;
+/**
+ * Pad or truncate a tag to fixed width for aligned output.
+ */
+export declare function padTag(tag: string): string;
+/**
+ * Format a timestamp as HH:MM:SS.
+ */
+export declare function formatTimestamp(date?: Date): string;
+/**
+ * Apply ANSI color codes to text if enabled.
+ */
+export declare function colorize(text: string, color: string | undefined, enable: boolean): string;
+/**
+ * Normalize whitespace in text (collapse multiple spaces to single space).
+ */
+export declare function normalizeText(value: string): string;
+/**
+ * Truncate text to maxLength, adding ellipsis if truncated.
+ */
+export declare function truncateText(value: string, maxLength?: number): string;
+/**
+ * Format a value for log output (handles strings, numbers, booleans, objects).
+ */
+export declare function formatValue(value: unknown): string;
+/**
+ * Serialized error structure for structured logging.
+ */
+export interface SerializedError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Format a serialized error for text output.
+ */
+export declare function formatErrorText(error: SerializedError | undefined): string;
+/**
+ * Serialize an error object for structured logging.
+ */
+export declare function serializeError(error: unknown): SerializedError | undefined;
+/**
+ * Format context and error as indented key=value pairs.
+ * Filters out undefined values for cleaner output.
+ */
+export declare function formatContextText(context: Record<string, unknown>, error: SerializedError | undefined, enableColor: boolean): string;
+/**
+ * Check if value is a non-null, non-array object (plain record).
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=core.d.ts.map

package/esm/src/utils/logger/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE/D,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAKrD,CAAC;AAEF,eAAO,MAAM,IAAI;;;;;;;;;;CAUP,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAKrD,CAAC;AAMF;;GAEG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,IAAiB,GAAG,MAAM,CAG/D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAGzF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,SAAK,GAAG,MAAM,CAGlE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAoBlD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CAI1E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,SAAS,CAM1E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,KAAK,EAAE,eAAe,GAAG,SAAS,EAClC,WAAW,EAAE,OAAO,GACnB,MAAM,CASR;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/esm/src/utils/logger/core.js

@@ -0,0 +1,143 @@
+/**
+ * Shared logger formatting utilities.
+ * This module contains pure formatting functions with no external dependencies,
+ * enabling reuse between the main logger and proxy logger.
+ *
+ * @module
+ */
+// ============================================================================
+// Constants
+// ============================================================================
+export const TAG_WIDTH = 10;
+export const PREFIX_WIDTH = 23; // timestamp(8) + gap(2) + tag(10) + space(1) + glyph(1) + space(1)
+export const LEVEL_GLYPHS = {
+    debug: "·",
+    info: "●",
+    warn: "▲",
+    error: "✖",
+};
+export const ANSI = {
+    reset: "\u001b[0m",
+    dim: "\u001b[2m",
+    gray: "\u001b[90m",
+    red: "\u001b[31m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    blue: "\u001b[34m",
+    magenta: "\u001b[35m",
+    cyan: "\u001b[36m",
+};
+export const LEVEL_COLORS = {
+    debug: ANSI.gray,
+    info: ANSI.green,
+    warn: ANSI.yellow,
+    error: ANSI.red,
+};
+// ============================================================================
+// Pure Formatting Functions (no dependencies)
+// ============================================================================
+/**
+ * Pad or truncate a tag to fixed width for aligned output.
+ */
+export function padTag(tag) {
+    if (tag.length >= TAG_WIDTH)
+        return tag.slice(0, TAG_WIDTH);
+    return tag.padEnd(TAG_WIDTH, " ");
+}
+/**
+ * Format a timestamp as HH:MM:SS.
+ */
+export function formatTimestamp(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+ * Apply ANSI color codes to text if enabled.
+ */
+export function colorize(text, color, enable) {
+    if (!enable || !color)
+        return text;
+    return `${color}${text}${ANSI.reset}`;
+}
+/**
+ * Normalize whitespace in text (collapse multiple spaces to single space).
+ */
+export function normalizeText(value) {
+    return value.replace(/\s+/g, " ");
+}
+/**
+ * Truncate text to maxLength, adding ellipsis if truncated.
+ */
+export function truncateText(value, maxLength = 80) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength - 1)}…`;
+}
+/**
+ * Format a value for log output (handles strings, numbers, booleans, objects).
+ */
+export function formatValue(value) {
+    if (typeof value === "string") {
+        const trimmed = normalizeText(value);
+        return /\s/.test(trimmed) ? JSON.stringify(trimmed) : trimmed;
+    }
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    let text;
+    try {
+        text = JSON.stringify(value);
+    }
+    catch (_) {
+        /* expected: JSON.stringify fails on circular references */
+        text = String(value);
+    }
+    // JSON.stringify can return undefined for certain values (e.g., functions, symbols)
+    if (text === undefined)
+        return "undefined";
+    return truncateText(normalizeText(text));
+}
+/**
+ * Format a serialized error for text output.
+ */
+export function formatErrorText(error) {
+    if (!error)
+        return "";
+    const text = `${error.name}: ${error.message}`;
+    return truncateText(normalizeText(text), 120);
+}
+/**
+ * Serialize an error object for structured logging.
+ */
+export function serializeError(error) {
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message, stack: error.stack };
+    }
+    if (error == null)
+        return undefined;
+    return { name: "UnknownError", message: String(error) };
+}
+/**
+ * Format context and error as indented key=value pairs.
+ * Filters out undefined values for cleaner output.
+ */
+export function formatContextText(context, error, enableColor) {
+    const entries = Object.entries(context)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${key}=${formatValue(value)}`);
+    if (error)
+        entries.push(`err=${formatErrorText(error)}`);
+    if (entries.length === 0)
+        return "";
+    const indent = " ".repeat(PREFIX_WIDTH);
+    return `\n${indent}${colorize(entries.join(" "), ANSI.dim, enableColor)}`;
+}
+/**
+ * Check if value is a non-null, non-array object (plain record).
+ */
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/esm/src/utils/logger/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utils Logger
+ *
+ * @module utils/logger
+ */
+export { __registerRequestContextGetter, __registerTraceContextGetter, __resetLoggerConfigForTests, __resetTraceContextGetterForTests, agentLogger, bundlerLogger, cliLogger, createRequestLogger, createRunUserLogger, getBaseLogger, getDefaultLevel, type LogEntry, type LogFormat, type Logger, logger, LogLevel, proxyLogger, refreshLoggerConfig, rendererLogger, serverLogger, } from "./logger.js";
+export { ANSI, colorize, formatContextText, formatErrorText, formatTimestamp, formatValue, isRecord, LEVEL_COLORS, LEVEL_GLYPHS, type LogLevelName, normalizeText, padTag, PREFIX_WIDTH, type SerializedError, serializeError, TAG_WIDTH, truncateText, } from "./core.js";
+export { getRequestContext, getRequestLogger, type RequestContext, requestContextStore, runWithRequestContext, runWithRequestContextAsync, } from "./request-context.js";
+export { type LogComponent, LogComponents } from "./components.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/utils/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,EAC5B,2BAA2B,EAC3B,iCAAiC,EACjC,WAAW,EACX,aAAa,EACb,SAAS,EACT,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,eAAe,EACf,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,MAAM,EACX,MAAM,EACN,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,KAAK,YAAY,EACjB,aAAa,EACb,MAAM,EACN,YAAY,EACZ,KAAK,eAAe,EACpB,cAAc,EACd,SAAS,EACT,YAAY,GACb,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,cAAc,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/esm/src/utils/logger/index.js

@@ -0,0 +1,9 @@
+/**
+ * Utils Logger
+ *
+ * @module utils/logger
+ */
+export { __registerRequestContextGetter, __registerTraceContextGetter, __resetLoggerConfigForTests, __resetTraceContextGetterForTests, agentLogger, bundlerLogger, cliLogger, createRequestLogger, createRunUserLogger, getBaseLogger, getDefaultLevel, logger, LogLevel, proxyLogger, refreshLoggerConfig, rendererLogger, serverLogger, } from "./logger.js";
+export { ANSI, colorize, formatContextText, formatErrorText, formatTimestamp, formatValue, isRecord, LEVEL_COLORS, LEVEL_GLYPHS, normalizeText, padTag, PREFIX_WIDTH, serializeError, TAG_WIDTH, truncateText, } from "./core.js";
+export { getRequestContext, getRequestLogger, requestContextStore, runWithRequestContext, runWithRequestContextAsync, } from "./request-context.js";
+export { LogComponents } from "./components.js";