@veryfront/ext-observability-opentelemetry 0.1.1032 → 0.1.1035

package/esm/{index.js → extensions/ext-observability-opentelemetry/src/index.js}

@@ -13,7 +13,9 @@
  *
  * @module extensions/ext-observability-opentelemetry
  */
-import * as dntShim from "./_dnt.shims.js";
+import "../../../_dnt.polyfills.js";
+import * as dntShim from "../../../_dnt.shims.js";
+import { VERSION } from "../../../src/utils/index.js";
 const NOOP_SPAN = {
     setAttribute() {
         return NOOP_SPAN;
@@ -124,9 +126,79 @@ function parseHeaders(headerInput) {
     }
     return result;
 }
+function parseResourceAttributes(value) {
+    if (!value)
+        return {};
+    const attributes = {};
+    for (const part of value.split(",")) {
+        const [rawKey, ...rawValueParts] = part.split("=");
+        const key = rawKey?.trim();
+        if (!key || rawValueParts.length === 0)
+            continue;
+        attributes[key] = rawValueParts.join("=").trim();
+    }
+    return attributes;
+}
+function resolveServiceName(read, resourceAttributes) {
+    return read("OTEL_SERVICE_NAME") ?? resourceAttributes["service.name"] ??
+        read("DD_SERVICE") ?? "veryfront";
+}
+function resolveServiceVersion(read, resourceAttributes) {
+    return resourceAttributes["service.version"] ??
+        read("OTEL_SERVICE_VERSION") ??
+        read("DD_VERSION") ??
+        read("VERYFRONT_VERSION") ??
+        read("RELEASE_VERSION") ??
+        read("npm_package_version") ??
+        VERSION;
+}
+function resolveDeploymentEnvironment(read, resourceAttributes) {
+    return resourceAttributes["deployment.environment.name"] ??
+        resourceAttributes["deployment.environment"] ??
+        read("OTEL_DEPLOYMENT_ENVIRONMENT") ??
+        read("DD_ENV") ??
+        read("APP_ENVIRONMENT") ??
+        read("VERYFRONT_ENVIRONMENT") ??
+        read("NODE_ENV") ??
+        "development";
+}
 function headersOrDefault(signalHeaders, defaultHeaders) {
     return signalHeaders ?? defaultHeaders;
 }
+function getHeaderValue(headers, headerName) {
+    const normalizedName = headerName.toLowerCase();
+    return Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === normalizedName)?.[1];
+}
+function setHeaderValue(headers, headerName, value) {
+    const normalizedName = headerName.toLowerCase();
+    for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === normalizedName && key !== headerName) {
+            delete headers[key];
+        }
+    }
+    headers[headerName] = value;
+}
+function resolveLlmObservabilityEnabled(read, tracesHeaders) {
+    const explicitFlag = isTruthySignalFlag(read("DD_LLMOBS_ENABLED") ?? read("OTEL_LLMOBS_ENABLED"));
+    if (explicitFlag !== undefined)
+        return explicitFlag;
+    return getHeaderValue(tracesHeaders, "dd-otlp-source") === "llmobs";
+}
+function resolveLlmObservabilityHeaders(read, tracesHeaders) {
+    const headers = { ...tracesHeaders };
+    const datadogApiKey = getHeaderValue(headers, "dd-api-key") ??
+        read("DD_API_KEY") ??
+        read("DATADOG_OTLP_API_KEY");
+    if (datadogApiKey) {
+        setHeaderValue(headers, "dd-api-key", datadogApiKey);
+    }
+    setHeaderValue(headers, "dd-otlp-source", "llmobs");
+    const mlApp = read("DD_LLMOBS_ML_APP");
+    if (mlApp) {
+        setHeaderValue(headers, "dd-ml-app", mlApp);
+    }
+    return headers;
+}
 function metricTemporalityPreference(otel, preference) {
     const enumValue = otel.metricsExporter.AggregationTemporalityPreference;
     if (preference === "cumulative")
@@ -148,7 +220,79 @@ function logSeverityNumber(otel, level) {
             return otel.apiLogs.SeverityNumber.INFO;
     }
 }
-function logAttributes(record) {
+const TRACE_ID_LOG_ALIASES = ["trace.id", "otel.trace_id"];
+const SPAN_ID_LOG_ALIASES = ["span.id", "otel.span_id"];
+const PROJECT_ID_LOG_ALIASES = ["project.id"];
+const RUN_ID_LOG_ALIASES = ["run.id"];
+const AGENT_ID_LOG_ALIASES = ["agent.id", "gen_ai.agent.id"];
+const THREAD_ID_LOG_ALIASES = ["thread.id"];
+const SCHEDULE_ID_LOG_ALIASES = ["schedule.id", "run.trigger.id"];
+const SCHEDULE_NAME_LOG_ALIASES = ["schedule.name"];
+const TOOL_NAME_LOG_ALIASES = ["tool.name", "gen_ai.tool.name"];
+const TOOL_CALL_ID_LOG_ALIASES = ["tool.call.id", "gen_ai.tool.call.id"];
+const LOG_ATTRIBUTE_ALIASES = {
+    trace_id: TRACE_ID_LOG_ALIASES,
+    span_id: SPAN_ID_LOG_ALIASES,
+    project_id: PROJECT_ID_LOG_ALIASES,
+    run_id: RUN_ID_LOG_ALIASES,
+    agent_id: AGENT_ID_LOG_ALIASES,
+    thread_id: THREAD_ID_LOG_ALIASES,
+    schedule_id: SCHEDULE_ID_LOG_ALIASES,
+    schedule_name: SCHEDULE_NAME_LOG_ALIASES,
+    tool_name: TOOL_NAME_LOG_ALIASES,
+    tool_call_id: TOOL_CALL_ID_LOG_ALIASES,
+};
+const CONTEXT_LOG_ATTRIBUTE_ALIASES = {
+    traceId: TRACE_ID_LOG_ALIASES,
+    trace_id: TRACE_ID_LOG_ALIASES,
+    spanId: SPAN_ID_LOG_ALIASES,
+    span_id: SPAN_ID_LOG_ALIASES,
+    projectId: PROJECT_ID_LOG_ALIASES,
+    project_id: PROJECT_ID_LOG_ALIASES,
+    runId: RUN_ID_LOG_ALIASES,
+    run_id: RUN_ID_LOG_ALIASES,
+    agentId: AGENT_ID_LOG_ALIASES,
+    agent_id: AGENT_ID_LOG_ALIASES,
+    threadId: THREAD_ID_LOG_ALIASES,
+    thread_id: THREAD_ID_LOG_ALIASES,
+    scheduleId: SCHEDULE_ID_LOG_ALIASES,
+    schedule_id: SCHEDULE_ID_LOG_ALIASES,
+    scheduleName: SCHEDULE_NAME_LOG_ALIASES,
+    schedule_name: SCHEDULE_NAME_LOG_ALIASES,
+    toolName: TOOL_NAME_LOG_ALIASES,
+    tool_name: TOOL_NAME_LOG_ALIASES,
+    toolCallId: TOOL_CALL_ID_LOG_ALIASES,
+    tool_call_id: TOOL_CALL_ID_LOG_ALIASES,
+};
+function isLogAttributeValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function hexToUnsignedDecimal(value) {
+    const normalized = value?.trim().replace(/^0x/, "");
+    if (!normalized || !/^[0-9a-f]+$/i.test(normalized))
+        return undefined;
+    try {
+        return BigInt(`0x${normalized}`).toString(10);
+    }
+    catch {
+        return undefined;
+    }
+}
+function addLogAttributeAliases(attributes, key, value) {
+    const aliases = LOG_ATTRIBUTE_ALIASES[key] ?? CONTEXT_LOG_ATTRIBUTE_ALIASES[key];
+    for (const alias of aliases ?? []) {
+        attributes[alias] ??= value;
+    }
+    if (key === "trace_id" || key === "traceId") {
+        const traceId = typeof value === "string" ? value : String(value);
+        attributes["dd.trace_id"] ??= hexToUnsignedDecimal(traceId.slice(-16)) ?? traceId;
+    }
+    if (key === "span_id" || key === "spanId") {
+        const spanId = typeof value === "string" ? value : String(value);
+        attributes["dd.span_id"] ??= hexToUnsignedDecimal(spanId) ?? spanId;
+    }
+}
+export function logAttributes(record) {
     const attributes = {};
     for (const [key, value] of Object.entries(record)) {
         if (key === "timestamp" ||
@@ -158,14 +302,16 @@ function logAttributes(record) {
             key === "error") {
             continue;
         }
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        if (isLogAttributeValue(value)) {
             attributes[key] = value;
+            addLogAttributeAliases(attributes, key, value);
         }
     }
     if (record.context) {
         for (const [key, value] of Object.entries(record.context)) {
-            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            if (isLogAttributeValue(value)) {
                 attributes[`context.${key}`] = value;
+                addLogAttributeAliases(attributes, key, value);
             }
         }
     }
@@ -213,8 +359,12 @@ function resolveMetricsTemporalityPreference(value) {
     return "delta";
 }
 export function resolveOtlpExtensionConfig(read = readEnv) {
+    const resourceAttributes = parseResourceAttributes(read("OTEL_RESOURCE_ATTRIBUTES"));
     const endpoint = read("OTEL_EXPORTER_OTLP_ENDPOINT");
     const tracesEndpoint = read("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") ?? endpoint;
+    const llmObservabilityEndpoint = read("OTEL_EXPORTER_OTLP_LLMOBS_ENDPOINT") ??
+        read("DD_LLMOBS_OTLP_ENDPOINT") ??
+        tracesEndpoint;
     const metricsEndpoint = read("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT") ?? endpoint;
     const logsEndpoint = read("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT") ?? endpoint;
     const metricsExportIntervalMillis = Number.parseInt(read("OTEL_METRIC_EXPORT_INTERVAL") ?? "60000", 10);
@@ -222,17 +372,22 @@ export function resolveOtlpExtensionConfig(read = readEnv) {
     const tracesHeaders = mergeHeaders(headers, parseHeaders(read("OTEL_EXPORTER_OTLP_TRACES_HEADERS")));
     const metricsHeaders = mergeHeaders(headers, parseHeaders(read("OTEL_EXPORTER_OTLP_METRICS_HEADERS")));
     const logsHeaders = mergeHeaders(headers, parseHeaders(read("OTEL_EXPORTER_OTLP_LOGS_HEADERS")));
+    const llmObservabilityHeaders = resolveLlmObservabilityHeaders(read, tracesHeaders);
     return {
-        serviceName: read("OTEL_SERVICE_NAME") ?? "veryfront",
-        serviceVersion: "0.1.0",
+        serviceName: resolveServiceName(read, resourceAttributes),
+        serviceVersion: resolveServiceVersion(read, resourceAttributes),
+        deploymentEnvironment: resolveDeploymentEnvironment(read, resourceAttributes),
         headers,
         tracesHeaders,
         metricsHeaders,
         logsHeaders,
+        llmObservabilityHeaders,
         tracesEnabled: resolveSignalEnabled(read("OTEL_TRACES_ENABLED"), read("OTEL_TRACES_EXPORTER")),
+        llmObservabilityEnabled: resolveLlmObservabilityEnabled(read, tracesHeaders),
         metricsEnabled: resolveSignalEnabled(read("OTEL_METRICS_ENABLED"), read("OTEL_METRICS_EXPORTER")),
         logsEnabled: resolveSignalEnabled(read("OTEL_LOGS_ENABLED"), read("OTEL_LOGS_EXPORTER")),
         tracesUrl: resolveOtlpSignalUrl(tracesEndpoint, "traces"),
+        llmObservabilityUrl: resolveOtlpSignalUrl(llmObservabilityEndpoint, "traces"),
         metricsUrl: resolveOtlpSignalUrl(metricsEndpoint, "metrics"),
         logsUrl: resolveOtlpSignalUrl(logsEndpoint, "logs"),
         metricsExportIntervalMillis: Number.isFinite(metricsExportIntervalMillis)
@@ -241,6 +396,34 @@ export function resolveOtlpExtensionConfig(read = readEnv) {
         metricsTemporalityPreference: resolveMetricsTemporalityPreference(read("OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE")),
     };
 }
+function isGenAiSpan(span) {
+    const attributes = span.attributes;
+    return typeof attributes?.["gen_ai.operation.name"] === "string";
+}
+class FilteringSpanExporter {
+    delegate;
+    includeSpan;
+    successCode;
+    constructor(delegate, includeSpan, successCode) {
+        this.delegate = delegate;
+        this.includeSpan = includeSpan;
+        this.successCode = successCode;
+    }
+    export(spans, resultCallback) {
+        const includedSpans = spans.filter(this.includeSpan);
+        if (includedSpans.length === 0) {
+            resultCallback({ code: this.successCode });
+            return;
+        }
+        this.delegate.export(includedSpans, resultCallback);
+    }
+    shutdown() {
+        return this.delegate.shutdown();
+    }
+    forceFlush() {
+        return this.delegate.forceFlush?.() ?? Promise.resolve();
+    }
+}
 class OtlpTracingExporter {
     sdkProvider = null;
     meterProvider = null;
@@ -251,26 +434,41 @@ class OtlpTracingExporter {
     logRecordEmitter = null;
     async start(_ctxConfig) {
         const cfg = resolveOtlpExtensionConfig(readEnv);
-        // Honor OTEL_TRACES_ENABLED: when unset/false, skip exporter wiring so
-        // deployments opting out never create OTLP traffic or set globals.
-        if (!cfg.tracesEnabled && !cfg.metricsEnabled && !cfg.logsEnabled)
+        // Honor signal gates: when unset/false, skip exporter wiring so deployments
+        // opting out never create OTLP traffic or set globals.
+        if (!cfg.tracesEnabled && !cfg.llmObservabilityEnabled && !cfg.metricsEnabled && !cfg.logsEnabled) {
             return;
+        }
         const otel = await loadOpenTelemetryRuntime();
         const resource = otel.resources.resourceFromAttributes({
             [otel.semanticConventions.ATTR_SERVICE_NAME]: cfg.serviceName,
             [otel.semanticConventions.ATTR_SERVICE_VERSION]: cfg.serviceVersion,
+            "deployment.environment": cfg.deploymentEnvironment,
+            "deployment.environment.name": cfg.deploymentEnvironment,
         });
-        if (cfg.tracesEnabled) {
-            if (!cfg.tracesUrl) {
+        if (cfg.tracesEnabled || cfg.llmObservabilityEnabled) {
+            if (cfg.tracesEnabled && !cfg.tracesUrl) {
                 throw new Error("OTEL_TRACES_ENABLED=true requires OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");
             }
-            const exporter = new otel.traceExporter.OTLPTraceExporter({
-                url: cfg.tracesUrl,
-                headers: cfg.tracesHeaders,
-            });
+            if (cfg.llmObservabilityEnabled && !cfg.llmObservabilityUrl) {
+                throw new Error("DD_LLMOBS_ENABLED=true requires OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, or OTEL_EXPORTER_OTLP_LLMOBS_ENDPOINT");
+            }
+            const spanProcessors = [];
+            if (cfg.tracesEnabled && cfg.tracesUrl) {
+                spanProcessors.push(new otel.sdkTraceBase.BatchSpanProcessor(new otel.traceExporter.OTLPTraceExporter({
+                    url: cfg.tracesUrl,
+                    headers: cfg.tracesHeaders,
+                })));
+            }
+            if (cfg.llmObservabilityEnabled && cfg.llmObservabilityUrl) {
+                spanProcessors.push(new otel.sdkTraceBase.BatchSpanProcessor(new FilteringSpanExporter(new otel.traceExporter.OTLPTraceExporter({
+                    url: cfg.llmObservabilityUrl,
+                    headers: cfg.llmObservabilityHeaders,
+                }), isGenAiSpan, otel.core.ExportResultCode.SUCCESS)));
+            }
             const provider = new otel.sdkTraceBase.BasicTracerProvider({
                 resource,
-                spanProcessors: [new otel.sdkTraceBase.BatchSpanProcessor(exporter)],
+                spanProcessors,
             });
             // Wire OTel SDK globals so the real API delegates to this provider.
             // The shim also gets wired separately in bootstrap.ts via getProvider().
@@ -400,27 +598,37 @@ class OpenTelemetryNodeTelemetryProvider {
     sdk = null;
     async initialize(options) {
         const tracesEnabled = options.tracesEnabled ?? true;
+        const llmObservabilityEnabled = options.llmObservabilityEnabled ?? false;
         const metricsEnabled = options.metricsEnabled ?? false;
         const logsEnabled = options.logsEnabled ?? false;
-        if (!tracesEnabled && !metricsEnabled && !logsEnabled)
+        if (!tracesEnabled && !llmObservabilityEnabled && !metricsEnabled && !logsEnabled)
             return false;
         const otel = await loadOpenTelemetryRuntime();
         const resource = otel.resources.resourceFromAttributes({
             "service.name": options.serviceName,
             "service.version": options.serviceVersion,
             "deployment.environment": options.deploymentEnvironment,
+            "deployment.environment.name": options.deploymentEnvironment,
         });
-        const spanProcessors = tracesEnabled
-            ? [
-                new otel.sdkTraceBase.BatchSpanProcessor(new otel.traceExporter.OTLPTraceExporter({
-                    url: options.tracesEndpoint,
-                    headers: headersOrDefault(options.tracesHeaders, options.exporterHeaders),
-                }), {
-                    maxExportBatchSize: 100,
-                    scheduledDelayMillis: 500,
-                }),
-            ]
-            : [];
+        const spanProcessors = [];
+        if (tracesEnabled) {
+            spanProcessors.push(new otel.sdkTraceBase.BatchSpanProcessor(new otel.traceExporter.OTLPTraceExporter({
+                url: options.tracesEndpoint,
+                headers: headersOrDefault(options.tracesHeaders, options.exporterHeaders),
+            }), {
+                maxExportBatchSize: 100,
+                scheduledDelayMillis: 500,
+            }));
+        }
+        if (llmObservabilityEnabled) {
+            spanProcessors.push(new otel.sdkTraceBase.BatchSpanProcessor(new FilteringSpanExporter(new otel.traceExporter.OTLPTraceExporter({
+                url: options.llmObservabilityEndpoint ?? options.tracesEndpoint,
+                headers: headersOrDefault(options.llmObservabilityHeaders, options.tracesHeaders),
+            }), isGenAiSpan, otel.core.ExportResultCode.SUCCESS), {
+                maxExportBatchSize: 100,
+                scheduledDelayMillis: 500,
+            }));
+        }
         const metricReaders = metricsEnabled
             ? [
                 new otel.sdkMetrics.PeriodicExportingMetricReader({
@@ -495,6 +703,7 @@ class OpenTelemetryNodeTelemetryProvider {
             tracesEnabled,
             metricsEnabled,
             logsEnabled,
+            llmObservabilityEnabled,
         });
         options.processTarget?.on("SIGTERM", async () => {
             await this.shutdown();
@@ -535,13 +744,31 @@ const extOpenTelemetry = () => {
                 keys: [
                     "OTEL_EXPORTER_OTLP_ENDPOINT",
                     "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+                    "OTEL_EXPORTER_OTLP_LLMOBS_ENDPOINT",
                     "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
                     "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
                     "OTEL_EXPORTER_OTLP_HEADERS",
                     "OTEL_EXPORTER_OTLP_TRACES_HEADERS",
                     "OTEL_EXPORTER_OTLP_METRICS_HEADERS",
                     "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+                    "OTEL_RESOURCE_ATTRIBUTES",
                     "OTEL_SERVICE_NAME",
+                    "OTEL_SERVICE_VERSION",
+                    "OTEL_DEPLOYMENT_ENVIRONMENT",
+                    "DD_SERVICE",
+                    "DD_VERSION",
+                    "DD_ENV",
+                    "DD_API_KEY",
+                    "DATADOG_OTLP_API_KEY",
+                    "DD_LLMOBS_ENABLED",
+                    "DD_LLMOBS_ML_APP",
+                    "DD_LLMOBS_OTLP_ENDPOINT",
+                    "OTEL_LLMOBS_ENABLED",
+                    "VERYFRONT_VERSION",
+                    "RELEASE_VERSION",
+                    "APP_ENVIRONMENT",
+                    "VERYFRONT_ENVIRONMENT",
+                    "NODE_ENV",
                     "OTEL_TRACES_ENABLED",
                     "OTEL_METRICS_ENABLED",
                     "OTEL_LOGS_ENABLED",

package/esm/src/config/defaults.d.ts

@@ -0,0 +1,39 @@
+import { DEFAULT_PORT } from "../platform/compat/constants.js";
+export { DEFAULT_PORT };
+export declare const DEFAULT_TIMEOUT_MS = 5000;
+export declare const SSR_TIMEOUT_MS = 10000;
+export declare const SANDBOX_TIMEOUT_MS = 5000;
+/** Timeout for user data fetching functions (getServerData, getStaticData) */
+export declare const DATA_FETCH_TIMEOUT_MS = 10000;
+export declare const DEFAULT_CACHE_MAX_SIZE = 100;
+export declare const DURATION_HISTOGRAM_BOUNDARIES_MS: readonly [5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
+export declare const SIZE_HISTOGRAM_BOUNDARIES_KB: readonly [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
+export declare const defaultConfig: {
+    readonly server: {
+        readonly port: 3000;
+        readonly hostname: "0.0.0.0";
+    };
+    readonly timeouts: {
+        readonly default: 5000;
+        readonly api: 30000;
+        readonly ssr: 10000;
+        readonly hmr: 30000;
+        readonly sandbox: 5000;
+    };
+    readonly cache: {
+        readonly jit: {
+            readonly maxSize: 100;
+            readonly tempDirPrefix: "vf-bundle-";
+        };
+    };
+    readonly metrics: {
+        readonly ssrBoundaries: readonly [5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
+    };
+};
+export declare const DEFAULT_PREFETCH_DELAY_MS = 100;
+export declare const DEFAULT_METRICS_COLLECT_INTERVAL_MS = 60000;
+export declare const DEFAULT_REDIS_SCAN_COUNT = 100;
+export declare const DEFAULT_REDIS_BATCH_DELETE_SIZE = 1000;
+export declare const PAGE_TRANSITION_DELAY_MS = 150;
+export type DefaultConfig = typeof defaultConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/esm/src/config/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/src/config/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,eAAO,MAAM,kBAAkB,OAAO,CAAC;AACvC,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,eAAO,MAAM,gCAAgC,iFAenC,CAAC;AAEX,eAAO,MAAM,4BAA4B,qEAa/B,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAqBhB,CAAC;AAEX,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,mCAAmC,QAAQ,CAAC;AACzD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,+BAA+B,OAAO,CAAC;AACpD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}

package/esm/src/config/defaults.js

@@ -0,0 +1,65 @@
+import { DEFAULT_PORT } from "../platform/compat/constants.js";
+export { DEFAULT_PORT };
+export const DEFAULT_TIMEOUT_MS = 5000;
+export const SSR_TIMEOUT_MS = 10000;
+export const SANDBOX_TIMEOUT_MS = 5000;
+/** Timeout for user data fetching functions (getServerData, getStaticData) */
+export const DATA_FETCH_TIMEOUT_MS = 10000;
+export const DEFAULT_CACHE_MAX_SIZE = 100;
+export const DURATION_HISTOGRAM_BOUNDARIES_MS = [
+    5,
+    10,
+    25,
+    50,
+    75,
+    100,
+    250,
+    500,
+    750,
+    1000,
+    2500,
+    5000,
+    7500,
+    10000,
+];
+export const SIZE_HISTOGRAM_BOUNDARIES_KB = [
+    1,
+    5,
+    10,
+    25,
+    50,
+    100,
+    250,
+    500,
+    1000,
+    2500,
+    5000,
+    10000,
+];
+export const defaultConfig = {
+    server: {
+        port: DEFAULT_PORT,
+        hostname: "0.0.0.0",
+    },
+    timeouts: {
+        default: DEFAULT_TIMEOUT_MS,
+        api: 30000,
+        ssr: SSR_TIMEOUT_MS,
+        hmr: 30000,
+        sandbox: SANDBOX_TIMEOUT_MS,
+    },
+    cache: {
+        jit: {
+            maxSize: DEFAULT_CACHE_MAX_SIZE,
+            tempDirPrefix: "vf-bundle-",
+        },
+    },
+    metrics: {
+        ssrBoundaries: DURATION_HISTOGRAM_BOUNDARIES_MS,
+    },
+};
+export const DEFAULT_PREFETCH_DELAY_MS = 100;
+export const DEFAULT_METRICS_COLLECT_INTERVAL_MS = 60000;
+export const DEFAULT_REDIS_SCAN_COUNT = 100;
+export const DEFAULT_REDIS_BATCH_DELETE_SIZE = 1000;
+export const PAGE_TRANSITION_DELAY_MS = 150;

package/esm/src/errors/error-registry/agent.d.ts

@@ -0,0 +1,18 @@
+export declare const AGENT_ERROR: import("../types.js").RegisteredError;
+export declare const AGENT_NOT_FOUND: import("../types.js").RegisteredError;
+export declare const AGENT_TIMEOUT: import("../types.js").RegisteredError;
+export declare const AGENT_INTENT_ERROR: import("../types.js").RegisteredError;
+export declare const ORCHESTRATION_ERROR: import("../types.js").RegisteredError;
+export declare const COST_LIMIT_EXCEEDED: import("../types.js").RegisteredError;
+export declare const TOOL_ID_CONFLICT: import("../types.js").RegisteredError;
+/** Registry fragment for AGENT errors (slug → definition). */
+export declare const AGENT_REGISTRY: {
+    readonly "agent-error": import("../types.js").RegisteredError;
+    readonly "agent-not-found": import("../types.js").RegisteredError;
+    readonly "agent-timeout": import("../types.js").RegisteredError;
+    readonly "agent-intent-error": import("../types.js").RegisteredError;
+    readonly "orchestration-error": import("../types.js").RegisteredError;
+    readonly "cost-limit-exceeded": import("../types.js").RegisteredError;
+    readonly "tool-id-conflict": import("../types.js").RegisteredError;
+};
+//# sourceMappingURL=agent.d.ts.map

package/esm/src/errors/error-registry/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/agent.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,uCAMtB,CAAC;AAEH,eAAO,MAAM,eAAe,uCAM1B,CAAC;AAEH,eAAO,MAAM,aAAa,uCAMxB,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,eAAO,MAAM,mBAAmB,uCAM9B,CAAC;AAEH,eAAO,MAAM,gBAAgB,uCAM3B,CAAC;AAEH,8DAA8D;AAC9D,eAAO,MAAM,cAAc;;;;;;;;CAQjB,CAAC"}

package/esm/src/errors/error-registry/agent.js

@@ -0,0 +1,60 @@
+import { defineError } from "../types.js";
+export const AGENT_ERROR = defineError({
+    slug: "agent-error",
+    category: "AGENT",
+    status: 500,
+    title: "Agent operation error",
+    suggestion: "Check agent configuration and logs",
+});
+export const AGENT_NOT_FOUND = defineError({
+    slug: "agent-not-found",
+    category: "AGENT",
+    status: 404,
+    title: "Agent not found",
+    suggestion: "Verify the agent ID exists",
+});
+export const AGENT_TIMEOUT = defineError({
+    slug: "agent-timeout",
+    category: "AGENT",
+    status: 408,
+    title: "Agent operation timed out",
+    suggestion: "Increase timeout or simplify the request",
+});
+export const AGENT_INTENT_ERROR = defineError({
+    slug: "agent-intent-error",
+    category: "AGENT",
+    status: 400,
+    title: "Agent intent parsing error",
+    suggestion: "Rephrase the request more clearly",
+});
+export const ORCHESTRATION_ERROR = defineError({
+    slug: "orchestration-error",
+    category: "AGENT",
+    status: 500,
+    title: "Multi-agent orchestration error",
+    suggestion: "Check agent coordination logic",
+});
+export const COST_LIMIT_EXCEEDED = defineError({
+    slug: "cost-limit-exceeded",
+    category: "AGENT",
+    status: 429,
+    title: "Cost limit exceeded",
+    suggestion: "Wait for the budget period to reset or increase the limit",
+});
+export const TOOL_ID_CONFLICT = defineError({
+    slug: "tool-id-conflict",
+    category: "AGENT",
+    status: 409,
+    title: "Tool ID conflict",
+    suggestion: "Use a unique tool ID or rename one of the conflicting tools",
+});
+/** Registry fragment for AGENT errors (slug → definition). */
+export const AGENT_REGISTRY = {
+    "agent-error": AGENT_ERROR,
+    "agent-not-found": AGENT_NOT_FOUND,
+    "agent-timeout": AGENT_TIMEOUT,
+    "agent-intent-error": AGENT_INTENT_ERROR,
+    "orchestration-error": ORCHESTRATION_ERROR,
+    "cost-limit-exceeded": COST_LIMIT_EXCEEDED,
+    "tool-id-conflict": TOOL_ID_CONFLICT,
+};

package/esm/src/errors/error-registry/boundary.d.ts

@@ -0,0 +1,16 @@
+export declare const CLIENT_BOUNDARY_VIOLATION: import("../types.js").RegisteredError;
+export declare const SERVER_ONLY_IN_CLIENT: import("../types.js").RegisteredError;
+export declare const CLIENT_ONLY_IN_SERVER: import("../types.js").RegisteredError;
+export declare const INVALID_USE_CLIENT: import("../types.js").RegisteredError;
+export declare const INVALID_USE_SERVER: import("../types.js").RegisteredError;
+export declare const RSC_PAYLOAD_ERROR: import("../types.js").RegisteredError;
+/** Registry fragment for BOUNDARY errors (slug → definition). */
+export declare const BOUNDARY_REGISTRY: {
+    readonly "client-boundary-violation": import("../types.js").RegisteredError;
+    readonly "server-only-in-client": import("../types.js").RegisteredError;
+    readonly "client-only-in-server": import("../types.js").RegisteredError;
+    readonly "invalid-use-client": import("../types.js").RegisteredError;
+    readonly "invalid-use-server": import("../types.js").RegisteredError;
+    readonly "rsc-payload-error": import("../types.js").RegisteredError;
+};
+//# sourceMappingURL=boundary.d.ts.map

package/esm/src/errors/error-registry/boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/src/errors/error-registry/boundary.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,uCAMpC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uCAMhC,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,kBAAkB,uCAM7B,CAAC;AAEH,eAAO,MAAM,iBAAiB,uCAM5B,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAC"}

package/esm/src/errors/error-registry/boundary.js

@@ -0,0 +1,52 @@
+import { defineError } from "../types.js";
+export const CLIENT_BOUNDARY_VIOLATION = defineError({
+    slug: "client-boundary-violation",
+    category: "BOUNDARY",
+    status: 400,
+    title: "Client boundary rule violation",
+    suggestion: "Add 'use client' directive or move code to a client component",
+});
+export const SERVER_ONLY_IN_CLIENT = defineError({
+    slug: "server-only-in-client",
+    category: "BOUNDARY",
+    status: 400,
+    title: "Server-only code in client component",
+    suggestion: "Move server-only code to a server component",
+});
+export const CLIENT_ONLY_IN_SERVER = defineError({
+    slug: "client-only-in-server",
+    category: "BOUNDARY",
+    status: 400,
+    title: "Client-only code in server component",
+    suggestion: "Move client-only code to a client component",
+});
+export const INVALID_USE_CLIENT = defineError({
+    slug: "invalid-use-client",
+    category: "BOUNDARY",
+    status: 400,
+    title: "Invalid 'use client' directive",
+    suggestion: "Place 'use client' at the top of the file",
+});
+export const INVALID_USE_SERVER = defineError({
+    slug: "invalid-use-server",
+    category: "BOUNDARY",
+    status: 400,
+    title: "Invalid 'use server' directive",
+    suggestion: "Place 'use server' at the top of the file or function",
+});
+export const RSC_PAYLOAD_ERROR = defineError({
+    slug: "rsc-payload-error",
+    category: "BOUNDARY",
+    status: 500,
+    title: "RSC payload serialization error",
+    suggestion: "Ensure props are serializable (no functions, symbols, etc.)",
+});
+/** Registry fragment for BOUNDARY errors (slug → definition). */
+export const BOUNDARY_REGISTRY = {
+    "client-boundary-violation": CLIENT_BOUNDARY_VIOLATION,
+    "server-only-in-client": SERVER_ONLY_IN_CLIENT,
+    "client-only-in-server": CLIENT_ONLY_IN_SERVER,
+    "invalid-use-client": INVALID_USE_CLIENT,
+    "invalid-use-server": INVALID_USE_SERVER,
+    "rsc-payload-error": RSC_PAYLOAD_ERROR,
+};