@veryfront/ext-observability-opentelemetry 0.1.1032 → 0.1.1035

package/esm/src/utils/hash-utils.js

@@ -0,0 +1,42 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { FNV1A_PRIME_32 } from "./constants/crypto.js";
+import { HASH_SEED_FNV1A } from "./constants/hash.js";
+/** Number of hex characters kept by shortHash (8 hex chars = 32 bits) */
+const SHORT_HASH_LENGTH = 8;
+/** Compute hash. */
+export async function computeHash(content) {
+    const data = new TextEncoder().encode(content);
+    const hashBuffer = await dntShim.crypto.subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hashBuffer), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** Compute code hash. */
+export function computeCodeHash(code) {
+    return computeHash(`${code.code}${code.css ?? ""}${code.sourceMap ?? ""}`);
+}
+/** Create simple hash. */
+export function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash << 5) - hash + str.charCodeAt(i);
+        hash &= hash;
+    }
+    return Math.abs(hash);
+}
+/** Hash string to hex (base 16) - used for module filenames */
+export function hashCodeHex(str) {
+    return simpleHash(str).toString(16);
+}
+/** Create short hash. */
+export async function shortHash(content) {
+    const fullHash = await computeHash(content);
+    return fullHash.slice(0, SHORT_HASH_LENGTH);
+}
+/** FNV-1a hash for strings - returns hex string */
+export function fnv1aHash(input) {
+    let hash = HASH_SEED_FNV1A >>> 0;
+    for (const char of input) {
+        hash ^= char.charCodeAt(0);
+        hash = Math.imul(hash, FNV1A_PRIME_32);
+    }
+    return (hash >>> 0).toString(16);
+}

package/esm/src/utils/import-lockfile.d.ts

@@ -0,0 +1,52 @@
+export interface LockfileEntry {
+    resolved: string;
+    integrity: string;
+    dependencies?: string[];
+    fetchedAt?: string;
+}
+export interface LockfileData {
+    version: 1;
+    imports: Record<string, LockfileEntry>;
+}
+export declare function createEmptyLockfile(): LockfileData;
+/** Compute integrity. */
+export declare function computeIntegrity(content: string): Promise<string>;
+export declare function verifyIntegrity(content: string, integrity: string): Promise<boolean>;
+/** Public API contract for lockfile manager. */
+export interface LockfileManager {
+    read(): Promise<LockfileData | null>;
+    write(data: LockfileData): Promise<void>;
+    get(url: string): Promise<LockfileEntry | null>;
+    set(url: string, entry: LockfileEntry): Promise<void>;
+    has(url: string): Promise<boolean>;
+    clear(): Promise<void>;
+    flush(): Promise<void>;
+}
+export type FSAdapter = {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    remove?(path: string): Promise<void>;
+};
+/** Create lockfile manager. */
+export declare function createLockfileManager(projectDir: string, fsAdapter?: FSAdapter): LockfileManager;
+export interface FetchWithLockOptions {
+    lockfile: LockfileManager;
+    url: string;
+    fetchFn?: typeof fetch;
+    strict?: boolean;
+}
+export interface FetchWithLockResult {
+    content: string;
+    resolvedUrl: string;
+    fromCache: boolean;
+    integrity: string;
+}
+export declare function fetchWithLock(options: FetchWithLockOptions): Promise<FetchWithLockResult>;
+export interface ParsedImport {
+    specifier: string;
+    type: "static" | "dynamic";
+}
+export declare function extractImports(content: string): ParsedImport[];
+export declare function resolveImportUrl(specifier: string, baseUrl: string): string | null;
+//# sourceMappingURL=import-lockfile.d.ts.map

package/esm/src/utils/import-lockfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-lockfile.d.ts","sourceRoot":"","sources":["../../../src/src/utils/import-lockfile.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACxC;AAKD,wBAAgB,mBAAmB,IAAI,YAAY,CAElD;AAED,yBAAyB;AACzB,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGvE;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG1F;AAED,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IACrC,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IAChD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC,CAAC;AAqBF,+BAA+B;AAC/B,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,eAAe,CAkFhG;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,eAAe,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA2D/F;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC5B;AAMD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CAmB9D;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUlF"}

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"}