@veryfront/ext-content-mdx 0.1.1119 → 0.1.1122

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,30 @@
+/**
+ * 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 { __registerLogRecordEmitter, __registerTraceContextGetter, __registerTraceContextGetter as registerTraceContextGetter, agentLogger, bundlerLogger, cliLogger, createRunUserLogger, getBaseLogger, logger, refreshLoggerConfig, rendererLogger, runWithRequestContextAsync, serverLogger, } from "./logger/index.js";
+export type { LogEntry, Logger, RequestContext } from "./logger/index.js";
+export { redactSensitive, sanitizeUrlCredentials, sanitizeUrlForSpan } from "./logger/redact.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, computeHashBytes, fnv1aHash, shortHash, simpleHash, } from "./hash-utils.js";
+export { base64urlEncode, base64urlEncodeBytes, encodeBase64 } from "./base64url.js";
+export { sleep } from "./sleep.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,0BAA0B,EAC1B,4BAA4B,EAC5B,4BAA4B,IAAI,0BAA0B,EAC1D,WAAW,EACX,aAAa,EACb,SAAS,EACT,mBAAmB,EACnB,aAAa,EACb,MAAM,EACN,mBAAmB,EACnB,cAAc,EACd,0BAA0B,EAC1B,YAAY,GACb,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAEjG,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,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAErF,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,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,29 @@
+/**
+ * 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 { __registerLogRecordEmitter, __registerTraceContextGetter, __registerTraceContextGetter as registerTraceContextGetter, agentLogger, bundlerLogger, cliLogger, createRunUserLogger, getBaseLogger, logger, refreshLoggerConfig, rendererLogger, runWithRequestContextAsync, serverLogger, } from "./logger/index.js";
+// Redaction / URL sanitization helpers
+export { redactSensitive, sanitizeUrlCredentials, sanitizeUrlForSpan } from "./logger/redact.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, computeHashBytes, fnv1aHash, shortHash, simpleHash, } from "./hash-utils.js";
+export { base64urlEncode, base64urlEncodeBytes, encodeBase64 } from "./base64url.js";
+export { sleep } from "./sleep.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/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utils Logger
+ *
+ * @module utils/logger
+ */
+export { __registerLogRecordEmitter, __registerRequestContextGetter, __registerTraceContextGetter, __resetLoggerConfigForTests, __resetLogRecordEmitterForTests, __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,0BAA0B,EAC1B,8BAA8B,EAC9B,4BAA4B,EAC5B,2BAA2B,EAC3B,+BAA+B,EAC/B,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 { __registerLogRecordEmitter, __registerRequestContextGetter, __registerTraceContextGetter, __resetLoggerConfigForTests, __resetLogRecordEmitterForTests, __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";

package/esm/src/utils/logger/request-context.d.ts

@@ -0,0 +1,27 @@
+/**************************
+ * Request Context Store
+ *
+ * Uses AsyncLocalStorage to propagate request-scoped logger context
+ * throughout the call stack without explicit parameter passing.
+ *
+ * @module utils/logger/request-context
+ **************************/
+import { AsyncLocalStorage } from "node:async_hooks";
+import { type Logger } from "./logger.js";
+/** Context for request. */
+export interface RequestContext {
+    logger: Logger;
+    requestId: string;
+    projectSlug?: string;
+    projectId?: string;
+    domain?: string;
+    userId?: string;
+    conversationId?: string;
+}
+export declare const requestContextStore: AsyncLocalStorage<RequestContext>;
+export declare function getRequestContext(): RequestContext | undefined;
+export declare function getRequestLogger(): Logger | undefined;
+export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
+/** Run with request context async. */
+export declare function runWithRequestContextAsync<T>(context: RequestContext, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=request-context.d.ts.map

package/esm/src/utils/logger/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;4BAO4B;AAE5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAkC,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1E,2BAA2B;AAC3B,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,mBAAmB,mCAA0C,CAAC;AAE3E,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,SAAS,CAE9D;AAED,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAErD;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEhF;AAED,sCAAsC;AACtC,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAEZ"}

package/esm/src/utils/logger/request-context.js

@@ -0,0 +1,28 @@
+/**************************
+ * Request Context Store
+ *
+ * Uses AsyncLocalStorage to propagate request-scoped logger context
+ * throughout the call stack without explicit parameter passing.
+ *
+ * @module utils/logger/request-context
+ **************************/
+import { AsyncLocalStorage } from "node:async_hooks";
+import { __registerRequestContextGetter } from "./logger.js";
+export const requestContextStore = new AsyncLocalStorage();
+export function getRequestContext() {
+    return requestContextStore.getStore();
+}
+export function getRequestLogger() {
+    return getRequestContext()?.logger;
+}
+export function runWithRequestContext(context, fn) {
+    return requestContextStore.run(context, fn);
+}
+/** Run with request context async. */
+export function runWithRequestContextAsync(context, fn) {
+    return requestContextStore.run(context, fn);
+}
+// Register the context getter with the logger module.
+// This allows context-aware loggers to access request context
+// without creating a circular dependency.
+__registerRequestContextGetter(getRequestContext);

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

@@ -0,0 +1,19 @@
+/** Implement memo cache. */
+export declare class MemoCache<V> {
+    private cache;
+    get(key: string): V | undefined;
+    set(key: string, value: V): void;
+    has(key: string): boolean;
+    clear(): void;
+    size(): number;
+}
+/** Memoize async. */
+export declare function memoizeAsync<Args extends unknown[], Result>(fn: (...args: Args) => Promise<Result>, keyHasher: (...args: Args) => string): (...args: Args) => Promise<Result>;
+/** Memoize. */
+export declare function memoize<Args extends unknown[], Result>(fn: (...args: Args) => Result, keyHasher: (...args: Args) => string): (...args: Args) => Result;
+/**
+ * FNV-1a hash algorithm for fast cache key generation.
+ * 10-15x faster than JSON.stringify() and uses 70-80% less memory.
+ */
+export declare function simpleHash(...values: unknown[]): string;
+//# sourceMappingURL=memoize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../src/src/utils/memoize.ts"],"names":[],"mappings":"AAGA,4BAA4B;AAC5B,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,KAAK,CAAwB;IAErC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAI/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAIhC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,MAAM;CAGf;AA2CD,qBAAqB;AACrB,wBAAgB,YAAY,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,MAAM,EACzD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,EACtC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GACnC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAEpC;AAED,eAAe;AACf,wBAAgB,OAAO,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,MAAM,EACpD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,EAC7B,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GACnC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAE3B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAavD"}

package/esm/src/utils/memoize.js

@@ -0,0 +1,72 @@
+import { FNV1A_PRIME_32 } from "./constants/crypto.js";
+import { HASH_SEED_FNV1A } from "./constants/hash.js";
+/** Implement memo cache. */
+export class MemoCache {
+    cache = new Map();
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    size() {
+        return this.cache.size;
+    }
+}
+function memoizeWithCache(fn, keyHasher) {
+    const cache = new MemoCache();
+    const inflight = new Map();
+    return (...args) => {
+        const key = keyHasher(...args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const existing = inflight.get(key);
+        if (existing)
+            return existing;
+        const result = fn(...args);
+        if (!(result instanceof Promise)) {
+            cache.set(key, result);
+            return result;
+        }
+        const promise = result.then((resolved) => {
+            cache.set(key, resolved);
+            inflight.delete(key);
+            return resolved;
+        }, (error) => {
+            inflight.delete(key);
+            throw error;
+        });
+        inflight.set(key, promise);
+        return promise;
+    };
+}
+/** Memoize async. */
+export function memoizeAsync(fn, keyHasher) {
+    return memoizeWithCache(fn, keyHasher);
+}
+/** Memoize. */
+export function memoize(fn, keyHasher) {
+    return memoizeWithCache(fn, keyHasher);
+}
+/**
+ * FNV-1a hash algorithm for fast cache key generation.
+ * 10-15x faster than JSON.stringify() and uses 70-80% less memory.
+ */
+export function simpleHash(...values) {
+    let hash = HASH_SEED_FNV1A;
+    for (const value of values) {
+        const str = typeof value === "string" ? value : String(value);
+        for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = Math.imul(hash, FNV1A_PRIME_32);
+        }
+    }
+    return (hash >>> 0).toString(36);
+}