@blaxel/telemetry 0.2.49-dev.213 → 0.2.49-dev1

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { blaxelTelemetry } from "./telemetry";
+export { AuthRefreshingMetricExporter, AuthRefreshingSpanExporter, createMetricExporter, createTraceExporter } from "./auth_refresh_exporters";
+export { setJsonLogger } from "./json_logger";
+export { blaxelTelemetry };

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blaxelTelemetry = exports.setJsonLogger = exports.createTraceExporter = exports.createMetricExporter = exports.AuthRefreshingSpanExporter = exports.AuthRefreshingMetricExporter = void 0;
+const core_1 = require("@blaxel/core");
+const json_logger_1 = require("./json_logger");
+const telemetry_1 = require("./telemetry");
+Object.defineProperty(exports, "blaxelTelemetry", { enumerable: true, get: function () { return telemetry_1.blaxelTelemetry; } });
+telemetry_1.blaxelTelemetry.initialize();
+if (core_1.settings.loggerType === "json") {
+    (0, json_logger_1.setJsonLogger)();
+}
+var auth_refresh_exporters_1 = require("./auth_refresh_exporters");
+Object.defineProperty(exports, "AuthRefreshingMetricExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.AuthRefreshingMetricExporter; } });
+Object.defineProperty(exports, "AuthRefreshingSpanExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.AuthRefreshingSpanExporter; } });
+Object.defineProperty(exports, "createMetricExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.createMetricExporter; } });
+Object.defineProperty(exports, "createTraceExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.createTraceExporter; } });
+var json_logger_2 = require("./json_logger");
+Object.defineProperty(exports, "setJsonLogger", { enumerable: true, get: function () { return json_logger_2.setJsonLogger; } });

package/dist/json_logger.d.ts

@@ -0,0 +1,8 @@
+export declare function setJsonLogger(): void;
+export declare const originalLogger: {
+    info: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    log: (message?: any, ...optionalParams: any[]) => void;
+};

package/dist/json_logger.js

@@ -0,0 +1,155 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.originalLogger = void 0;
+exports.setJsonLogger = setJsonLogger;
+const core_1 = require("@blaxel/core");
+const api_1 = require("@opentelemetry/api");
+function setJsonLogger() {
+    console.debug = (message, ...args) => {
+        const msg = formatLogMessage("DEBUG", message, args);
+        exports.originalLogger.log(msg);
+    };
+    console.log = (message, ...args) => {
+        const msg = formatLogMessage("INFO", message, args);
+        exports.originalLogger.log(msg);
+    };
+    console.info = (message, ...args) => {
+        const msg = formatLogMessage("INFO", message, args);
+        exports.originalLogger.log(msg);
+    };
+    console.warn = (message, ...args) => {
+        const msg = formatLogMessage("WARN", message, args);
+        exports.originalLogger.log(msg);
+    };
+    console.error = (message, ...args) => {
+        const msg = formatLogMessage("ERROR", message, args);
+        exports.originalLogger.log(msg);
+    };
+}
+exports.originalLogger = {
+    info: console.info,
+    error: console.error,
+    warn: console.warn,
+    debug: console.debug,
+    log: console.log,
+};
+const traceIdName = core_1.env.BL_LOGGER_TRACE_ID || 'trace_id';
+const spanIdName = core_1.env.BL_LOGGER_SPAN_ID || 'span_id';
+const labelsName = core_1.env.BL_LOGGER_LABELS || 'labels';
+const traceIdPrefix = core_1.env.BL_LOGGER_TRACE_ID_PREFIX || '';
+const spanIdPrefix = core_1.env.BL_LOGGER_SPAN_ID_PREFIX || '';
+const taskIndex = core_1.env.BL_TASK_KEY || 'TASK_INDEX';
+const taskPrefix = core_1.env.BL_TASK_PREFIX || '';
+const executionKey = core_1.env.BL_EXECUTION_KEY || 'BL_EXECUTION_ID';
+const executionPrefix = core_1.env.BL_EXECUTION_PREFIX || '';
+// Validate environment variables to prevent issues
+function validateEnvVar(value, defaultValue, varName) {
+    if (!value || value.trim() === '') {
+        exports.originalLogger.warn(`Warning: ${varName} environment variable is empty, using default: ${defaultValue}`);
+        return defaultValue;
+    }
+    return value;
+}
+const validatedLabelsName = validateEnvVar(labelsName, 'labels', 'BL_LOGGER_LABELS');
+// Enhanced error serialization to capture all properties
+function serializeError(error) {
+    const serialized = {
+        message: error.message,
+        name: error.name,
+        stack: error.stack
+    };
+    // Capture any additional properties on the error object
+    for (const key of Object.keys(error)) {
+        if (!(key in serialized)) {
+            try {
+                const value = error[key];
+                // Avoid circular references by limiting depth
+                serialized[key] = typeof value === 'object' ? (0, core_1.stringify)(value, 2) : value;
+            }
+            catch {
+                serialized[key] = '[Unserializable]';
+            }
+        }
+    }
+    return serialized;
+}
+// Enhanced stringify function with better error handling
+function enhancedStringify(obj, maxDepth = 2) {
+    if (obj instanceof Error) {
+        return JSON.stringify(serializeError(obj));
+    }
+    // Handle circular references by using a simple set to track seen objects
+    const seen = new WeakSet();
+    const stringifyWithCircularCheck = (value, depth = 0) => {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value !== 'object')
+            return value;
+        if (seen.has(value)) {
+            return '[Circular Reference]';
+        }
+        if (depth >= maxDepth) {
+            return Array.isArray(value) ? '[Array]' : '[Object]';
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+            return value.map(item => stringifyWithCircularCheck(item, depth + 1));
+        }
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = stringifyWithCircularCheck(val, depth + 1);
+        }
+        return result;
+    };
+    try {
+        const processed = stringifyWithCircularCheck(obj);
+        return JSON.stringify(processed);
+    }
+    catch {
+        return (0, core_1.stringify)(obj, maxDepth);
+    }
+}
+// Format a log message with appropriate color and prefix
+function formatLogMessage(severity, message, args) {
+    const messageStr = typeof message === "string" ? message : enhancedStringify(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : enhancedStringify(arg, 2)).join(" ");
+    const msg = `${messageStr}${argsStr ? " " + argsStr : ""}`;
+    const logEntry = {
+        message: msg,
+        severity
+    };
+    logEntry[validatedLabelsName] = {};
+    const currentSpan = api_1.trace.getActiveSpan();
+    if (currentSpan) {
+        const { traceId, spanId } = currentSpan.spanContext();
+        logEntry[traceIdName] = `${traceIdPrefix}${traceId}`;
+        logEntry[spanIdName] = `${spanIdPrefix}${spanId}`;
+    }
+    const taskId = core_1.env[taskIndex] || null;
+    if (taskId) {
+        logEntry[validatedLabelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
+    }
+    const executionId = core_1.env[executionKey] || null;
+    if (executionId) {
+        logEntry[validatedLabelsName]['blaxel-execution'] = `${executionPrefix}${executionId.split('-').pop()}`;
+    }
+    try {
+        return JSON.stringify(logEntry);
+    }
+    catch (error) {
+        // Fallback for serialization errors
+        const fallbackEntry = {
+            message: `JSON serialization failed: ${msg}`,
+            severity,
+            error: error instanceof Error ? error.message : String(error)
+        };
+        try {
+            return JSON.stringify(fallbackEntry);
+        }
+        catch {
+            // Last resort fallback
+            return `{"message":"${severity}: ${msg.replace(/"/g, '\\"')}","severity":"${severity}","error":"Failed to serialize log entry"}`;
+        }
+    }
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,56 @@
+import { Span } from "@opentelemetry/api";
+import { RawResourceAttribute, Resource } from "@opentelemetry/resources";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-node";
+export declare class BlaxelResource implements Resource {
+    attributes: Record<string, string>;
+    constructor(attributes: Record<string, string>);
+    merge(other: Resource | null): Resource;
+    getRawAttributes(): RawResourceAttribute[];
+}
+export declare class DefaultAttributesSpanProcessor implements SpanProcessor {
+    private defaultAttributes;
+    constructor(defaultAttributes: Record<string, string>);
+    onStart(span: Span): void;
+    onEnd(): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+export type TelemetryOptions = {
+    workspace: string | null;
+    name: string | null;
+    authorization: string | null;
+    type: string | null;
+};
+declare class TelemetryManager {
+    private nodeTracerProvider;
+    private meterProvider;
+    private initialized;
+    private configured;
+    private shuttingDown;
+    constructor();
+    initialize(): void;
+    setConfiguration(): Promise<void>;
+    get tracer(): import("@opentelemetry/api").Tracer;
+    get enabled(): boolean;
+    get authHeaders(): Record<string, string>;
+    sleep(ms: number): Promise<unknown>;
+    flush(): Promise<void>;
+    setupSignalHandler(): void;
+    /**
+     * Get resource attributes for OpenTelemetry.
+     */
+    get resourceAttributes(): Record<string, string>;
+    /**
+     * Initialize and return the OTLP Metric Exporter.
+     */
+    getMetricExporter(): import("@opentelemetry/exporter-metrics-otlp-http").OTLPMetricExporter;
+    /**
+     * Initialize and return the OTLP Trace Exporter.
+     */
+    getTraceExporter(): import("@opentelemetry/exporter-trace-otlp-http").OTLPTraceExporter;
+    instrumentApp(): void;
+    setExporters(): void;
+    shutdownApp(): Promise<void>;
+}
+export declare const blaxelTelemetry: TelemetryManager;
+export {};

package/dist/telemetry.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blaxelTelemetry = exports.DefaultAttributesSpanProcessor = exports.BlaxelResource = void 0;
+const core_1 = require("@blaxel/core");
+const api_1 = require("@opentelemetry/api");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const auth_refresh_exporters_1 = require("./auth_refresh_exporters");
+const telemetry_provider_1 = require("./telemetry_provider");
+class BlaxelResource {
+    attributes;
+    constructor(attributes) {
+        this.attributes = attributes;
+    }
+    merge(other) {
+        if (other?.attributes) {
+            for (const [key, value] of Object.entries(other.attributes)) {
+                if (typeof value === "string") {
+                    this.attributes[key] = value;
+                }
+            }
+        }
+        return this;
+    }
+    getRawAttributes() {
+        return Object.entries(this.attributes).map(([key, value]) => [key, value]);
+    }
+}
+exports.BlaxelResource = BlaxelResource;
+class DefaultAttributesSpanProcessor {
+    defaultAttributes;
+    constructor(defaultAttributes) {
+        this.defaultAttributes = defaultAttributes;
+    }
+    onStart(span) {
+        Object.entries(this.defaultAttributes).forEach(([key, value]) => {
+            span.setAttribute(key, value);
+        });
+    }
+    onEnd() { }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+exports.DefaultAttributesSpanProcessor = DefaultAttributesSpanProcessor;
+class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor {
+    constructor(exporter, config) {
+        super(exporter, config);
+    }
+    onEnd(span) {
+        super.onEnd(span);
+    }
+}
+class TelemetryManager {
+    nodeTracerProvider;
+    meterProvider;
+    initialized;
+    configured;
+    shuttingDown;
+    constructor() {
+        this.nodeTracerProvider = null;
+        this.meterProvider = null;
+        this.initialized = false;
+        this.configured = false;
+        this.shuttingDown = false;
+    }
+    // This method need to stay sync to avoid non booted instrumentations
+    initialize() {
+        if (!this.enabled || this.initialized) {
+            core_1.logger.debug(`[TelemetryManager] Initialize skipped - enabled: ${this.enabled}, initialized: ${this.initialized}`);
+            return;
+        }
+        core_1.logger.debug("[TelemetryManager] Starting telemetry initialization");
+        this.instrumentApp();
+        this.setupSignalHandler();
+        this.initialized = true;
+        core_1.logger.debug("[TelemetryManager] Telemetry initialized, setting configuration async");
+        this.setConfiguration().catch((error) => {
+            core_1.logger.error("[TelemetryManager] Error setting configuration:", error);
+        });
+    }
+    async setConfiguration() {
+        if (!this.enabled || this.configured) {
+            core_1.logger.debug(`[TelemetryManager] SetConfiguration skipped - enabled: ${this.enabled}, configured: ${this.configured}`);
+            return;
+        }
+        core_1.logger.debug("[TelemetryManager] Starting authentication for telemetry configuration");
+        await (0, core_1.authenticate)();
+        core_1.logger.debug("[TelemetryManager] Authentication completed, setting up exporters");
+        this.setExporters();
+        core_1.logger.debug("[TelemetryManager] Telemetry configuration complete");
+        this.configured = true;
+    }
+    get tracer() {
+        return api_1.trace.getTracer("blaxel");
+    }
+    get enabled() {
+        return core_1.env.BL_ENABLE_OPENTELEMETRY === "true";
+    }
+    get authHeaders() {
+        const headers = {};
+        if (core_1.settings.authorization) {
+            headers["x-blaxel-authorization"] = core_1.settings.authorization;
+        }
+        if (core_1.settings.workspace) {
+            headers["x-blaxel-workspace"] = core_1.settings.workspace;
+        }
+        return headers;
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async flush() {
+        if (this.nodeTracerProvider) {
+            await this.nodeTracerProvider.shutdown();
+        }
+        if (this.meterProvider) {
+            await this.meterProvider.shutdown();
+        }
+    }
+    setupSignalHandler() {
+        const forward = (sig) => {
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            this.shutdownApp()
+                .catch((error) => {
+                core_1.logger.debug("Fatal error during shutdown:", error);
+            })
+                .finally(() => {
+                try {
+                    // Re-send the original signal to let the default handler terminate the process with the correct code
+                    process.kill(process.pid, sig);
+                }
+                catch {
+                    process.exit(1);
+                }
+            });
+        };
+        process.once("SIGINT", () => forward("SIGINT"));
+        process.once("SIGTERM", () => forward("SIGTERM"));
+        process.once("uncaughtException", (err) => {
+            core_1.logger.error("Uncaught exception:", err);
+            this.shutdownApp().catch((error) => {
+                core_1.logger.debug("Fatal error during shutdown:", error);
+            }).finally(() => {
+                // Re-throw on next tick so Node's default handler sets exit code and prints stack
+                setImmediate(() => {
+                    throw (err instanceof Error ? err : new Error(String(err)));
+                });
+            });
+        });
+    }
+    /**
+     * Get resource attributes for OpenTelemetry.
+     */
+    get resourceAttributes() {
+        const resource = resources_1.envDetector.detect();
+        const attributes = resource.attributes || {};
+        if (core_1.settings.name) {
+            attributes["service.name"] = core_1.settings.name;
+            attributes["workload.id"] = core_1.settings.name;
+        }
+        if (core_1.settings.workspace) {
+            attributes["workspace"] = core_1.settings.workspace;
+        }
+        if (core_1.settings.type) {
+            attributes["workload.type"] = core_1.settings.type + "s";
+        }
+        // Only keep string values
+        const stringAttrs = {};
+        for (const [k, v] of Object.entries(attributes)) {
+            if (typeof v === "string")
+                stringAttrs[k] = v;
+        }
+        return stringAttrs;
+    }
+    /**
+     * Initialize and return the OTLP Metric Exporter.
+     */
+    getMetricExporter() {
+        return (0, auth_refresh_exporters_1.createMetricExporter)();
+    }
+    /**
+     * Initialize and return the OTLP Trace Exporter.
+     */
+    getTraceExporter() {
+        return (0, auth_refresh_exporters_1.createTraceExporter)();
+    }
+    instrumentApp() {
+        core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
+        const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
+            requireParentforOutgoingSpans: true,
+        });
+        (0, instrumentation_1.registerInstrumentations)({
+            instrumentations: [httpInstrumentation],
+        });
+    }
+    setExporters() {
+        const resource = new BlaxelResource(this.resourceAttributes);
+        core_1.logger.debug("[TelemetryManager] Setting up exporters with authentication refresh");
+        // Configure batch processor options with 1-second delay
+        const batchProcessorOptions = {
+            scheduledDelayMillis: 1000, // Export every 1 second
+            exportTimeoutMillis: 5000, // Timeout for export
+            maxExportBatchSize: 512, // Max batch size
+            maxQueueSize: 2048 // Max queue size
+        };
+        core_1.logger.debug("[TelemetryManager] Batch processor options:", batchProcessorOptions);
+        // Create auth-refreshing trace exporter
+        const traceExporter = new auth_refresh_exporters_1.AuthRefreshingSpanExporter(() => this.getTraceExporter());
+        core_1.logger.debug("[TelemetryManager] Created AuthRefreshingSpanExporter");
+        this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            resource,
+            sampler: new sdk_trace_node_1.AlwaysOnSampler(),
+            spanProcessors: [
+                new DefaultAttributesSpanProcessor({
+                    "workload.id": core_1.settings.name || "",
+                    "workload.type": core_1.settings.type ? core_1.settings.type + "s" : "",
+                    workspace: core_1.settings.workspace || "",
+                }),
+                new sdk_trace_node_1.BatchSpanProcessor(traceExporter, batchProcessorOptions),
+                new HasBeenProcessedSpanProcessor(traceExporter, batchProcessorOptions),
+            ],
+        });
+        this.nodeTracerProvider.register();
+        core_1.logger.debug("[TelemetryManager] Trace provider registered");
+        // Create auth-refreshing metric exporter
+        const metricExporter = new auth_refresh_exporters_1.AuthRefreshingMetricExporter(() => this.getMetricExporter());
+        core_1.logger.debug("[TelemetryManager] Created AuthRefreshingMetricExporter");
+        this.meterProvider = new sdk_metrics_1.MeterProvider({
+            resource,
+            readers: [
+                new sdk_metrics_1.PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: 1000, // Changed from 60000 to 1000 (1 second)
+                }),
+            ],
+        });
+        api_1.metrics.setGlobalMeterProvider(this.meterProvider);
+        core_1.logger.debug("[TelemetryManager] Metric provider configured with 1-second export interval");
+    }
+    async shutdownApp() {
+        try {
+            const maxSleepTime = 5000;
+            const startTime = Date.now();
+            while (!this.configured && Date.now() - startTime < maxSleepTime) {
+                await this.sleep(100);
+            }
+            const shutdownPromises = [];
+            if (this.nodeTracerProvider) {
+                shutdownPromises.push(this.nodeTracerProvider
+                    .shutdown()
+                    .catch((error) => core_1.logger.debug("Error shutting down tracer provider:", error)));
+            }
+            if (this.meterProvider) {
+                shutdownPromises.push(this.meterProvider
+                    .shutdown()
+                    .catch((error) => core_1.logger.debug("Error shutting down meter provider:", error)));
+            }
+            // Wait for all providers to shutdown with a timeout
+            await Promise.race([
+                Promise.all(shutdownPromises),
+                new Promise((resolve) => setTimeout(resolve, 5000)), // 5 second timeout
+            ]);
+            core_1.logger.debug("Instrumentation shutdown complete");
+        }
+        catch (error) {
+            core_1.logger.error("Error during shutdown:", error);
+        }
+    }
+}
+exports.blaxelTelemetry = new TelemetryManager();

package/dist/telemetry_provider.d.ts

@@ -0,0 +1,7 @@
+import { BlaxelSpan, BlaxelSpanOptions, BlaxelTelemetryProvider } from "@blaxel/core";
+export declare class OtelTelemetryProvider implements BlaxelTelemetryProvider {
+    private spans;
+    retrieveActiveSpanContext(): import("@opentelemetry/api").Context;
+    startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
+    flush(): Promise<void>;
+}

package/dist/telemetry_provider.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelTelemetryProvider = void 0;
+const api_1 = require("@opentelemetry/api");
+const telemetry_1 = require("./telemetry");
+class OtelSpan {
+    span;
+    closed = false;
+    constructor(span) {
+        this.span = span;
+    }
+    setAttribute(key, value) {
+        this.span.setAttribute(key, value);
+    }
+    setAttributes(attributes) {
+        Object.entries(attributes).forEach(([k, v]) => this.span.setAttribute(k, v));
+    }
+    recordException(error) {
+        this.span.recordException(error);
+        this.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+    }
+    setStatus(status, message) {
+        this.span.setStatus({
+            code: status === 'ok' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
+            message,
+        });
+    }
+    end() {
+        this.closed = true;
+        this.span.end();
+    }
+    getContext() {
+        return this.span.spanContext();
+    }
+}
+class OtelTelemetryProvider {
+    spans = [];
+    retrieveActiveSpanContext() {
+        for (let i = this.spans.length - 1; i >= 0; i--) {
+            const span = this.spans[i];
+            if (!span.closed) {
+                return api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, span.getContext());
+            }
+        }
+        return api_1.context.active();
+    }
+    startSpan(name, options) {
+        const tracer = api_1.trace.getTracer("blaxel");
+        const otelOptions = {
+            attributes: options?.attributes,
+            root: options?.isRoot,
+        };
+        const ctx = this.retrieveActiveSpanContext();
+        const span = new OtelSpan(tracer.startSpan(name, otelOptions, ctx));
+        this.spans.push(span);
+        return span;
+    }
+    async flush() {
+        await telemetry_1.blaxelTelemetry.flush();
+    }
+}
+exports.OtelTelemetryProvider = OtelTelemetryProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/telemetry",
-  "version": "0.2.49-dev.213",
+  "version": "0.2.49-dev1",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -58,7 +58,7 @@
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
     "ai": "^5.0.82",
-    "@blaxel/core": "0.2.49-dev.213"
+    "@blaxel/core": "0.2.49-dev1"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",