@shogo-ai/core 1.4.1

package/dist/index.cjs

@@ -0,0 +1,510 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StreamBufferStore: () => StreamBufferStore,
+  TECH_STACK_REGISTRY: () => TECH_STACK_REGISTRY,
+  createBufferingTransform: () => createBufferingTransform,
+  createLogger: () => createLogger,
+  extractUserText: () => extractUserText,
+  findLastUserMessage: () => findLastUserMessage,
+  getStackEntry: () => getStackEntry,
+  initInstrumentation: () => initInstrumentation,
+  isMacOSJunkName: () => isMacOSJunkName,
+  isMacOSJunkPath: () => isMacOSJunkPath,
+  isMobileTechStack: () => isMobileTechStack,
+  shutdownInstrumentation: () => shutdownInstrumentation,
+  stackSeedsItself: () => stackSeedsItself,
+  traceOperation: () => traceOperation,
+  usesMetroBundler: () => usesMetroBundler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var isProduction = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
+var minLevel = LOG_LEVELS[process.env.LOG_LEVEL || "info"] ?? 1;
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= minLevel;
+}
+function formatEntry(entry) {
+  if (isProduction) {
+    return JSON.stringify(entry);
+  }
+  const { level: _level, msg, service, timestamp: _timestamp, ...extra } = entry;
+  const extraStr = Object.keys(extra).length > 0 ? " " + JSON.stringify(extra) : "";
+  return `[${service}] ${msg}${extraStr}`;
+}
+function createLogger(service, defaultExtra) {
+  function log(level, msg, extra) {
+    if (!shouldLog(level)) return;
+    const entry = {
+      level,
+      msg,
+      service,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...defaultExtra,
+      ...extra
+    };
+    const formatted = formatEntry(entry);
+    switch (level) {
+      case "error":
+        console.error(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      default:
+        console.log(formatted);
+        break;
+    }
+  }
+  return {
+    debug: (msg, extra) => log("debug", msg, extra),
+    info: (msg, extra) => log("info", msg, extra),
+    warn: (msg, extra) => log("warn", msg, extra),
+    error: (msg, extra) => log("error", msg, extra),
+    child: (extra) => createLogger(service, { ...defaultExtra, ...extra })
+  };
+}
+
+// src/instrumentation.ts
+var import_api = require("@opentelemetry/api");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var sdk = null;
+function initInstrumentation(config) {
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!endpoint) {
+    console.log(`[OTEL] Tracing disabled for ${config.serviceName} (OTEL_EXPORTER_OTLP_ENDPOINT not set)`);
+    return;
+  }
+  const diagLevel = process.env.OTEL_LOG_LEVEL === "debug" ? import_api.DiagLogLevel.DEBUG : process.env.OTEL_LOG_LEVEL === "info" ? import_api.DiagLogLevel.INFO : import_api.DiagLogLevel.WARN;
+  import_api.diag.setLogger(new import_api.DiagConsoleLogger(), diagLevel);
+  const headers = {};
+  if (process.env.SIGNOZ_INGESTION_KEY) {
+    headers["signoz-ingestion-key"] = process.env.SIGNOZ_INGESTION_KEY;
+  }
+  const serviceName = process.env.OTEL_SERVICE_NAME || config.serviceName;
+  console.log(`[OTEL] Configuring ${serviceName} \u2192 ${endpoint}/v1/traces`);
+  let traceExporter;
+  try {
+    traceExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: `${endpoint}/v1/traces`,
+      headers
+    });
+  } catch (err) {
+    console.error(`[OTEL] Failed to create exporter: ${err.message}`);
+    return;
+  }
+  const isProduction2 = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
+  const spanProcessor = isProduction2 ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  sdk = new import_sdk_node.NodeSDK({
+    resource: (0, import_resources.resourceFromAttributes)({
+      [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+      [import_semantic_conventions.ATTR_SERVICE_VERSION]: config.serviceVersion || "0.1.0",
+      "deployment.environment.name": process.env.NODE_ENV || "development"
+    }),
+    spanProcessors: [spanProcessor],
+    instrumentations: []
+  });
+  try {
+    sdk.start();
+    console.log(`[OTEL] Tracing enabled for ${serviceName}`);
+  } catch (err) {
+    console.error(`[OTEL] SDK failed to start: ${err.message}`);
+    sdk = null;
+    return;
+  }
+  try {
+    const tracer = import_api.trace.getTracer(serviceName);
+    const testSpan = tracer.startSpan("otel.startup-test", {
+      attributes: {
+        "test.type": "startup-verification",
+        "service.name": serviceName,
+        // `process.versions.bun` is present under Bun (always undefined
+        // under plain Node) — avoids referencing the `Bun` global so
+        // this file typechecks without `@types/bun` in tsconfig.
+        "runtime": process.versions.bun ? "bun" : "node"
+      }
+    });
+    testSpan.setStatus({ code: import_api.SpanStatusCode.OK });
+    testSpan.end();
+    console.log(`[OTEL] Startup test span emitted for ${serviceName}`);
+  } catch (err) {
+    console.error(`[OTEL] Failed to emit test span: ${err.message}`);
+  }
+}
+async function shutdownInstrumentation() {
+  if (sdk) {
+    try {
+      await sdk.shutdown();
+      console.log("[OTEL] Tracing shut down");
+    } catch (err) {
+      console.error("[OTEL] Error shutting down:", err.message);
+    }
+  }
+}
+function traceOperation(tracerName, spanName, attributes, fn) {
+  const tracer = import_api.trace.getTracer(tracerName);
+  return tracer.startActiveSpan(spanName, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+      span.recordException(err);
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+
+// src/stream-buffer.ts
+var CLEANUP_INTERVAL_MS = 6e4;
+var MAX_BUFFER_AGE_MS = 30 * 6e4;
+var COMPLETED_GRACE_MS = 3e4;
+var StreamBufferStore = class {
+  constructor() {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.cleanupTimer = null;
+    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+    const handle = this.cleanupTimer;
+    if (handle && typeof handle.unref === "function") {
+      handle.unref();
+    }
+  }
+  /**
+   * Create (or replace) a buffer for the given key. Any existing active
+   * buffer is completed and discarded. Returns a writer bound to this
+   * specific buffer instance, including the new `turnId`.
+   */
+  create(key, opts) {
+    const existing = this.buffers.get(key);
+    if (existing && existing.status === "active") {
+      this.completeBuffer(existing, "replaced");
+    }
+    const now = Date.now();
+    const turnId = opts?.turnId || generateTurnId();
+    const buf = {
+      turnId,
+      frames: [],
+      subscribers: /* @__PURE__ */ new Set(),
+      status: "active",
+      terminal: null,
+      createdAt: now,
+      completedAt: null,
+      lastEventAt: now,
+      nextSeq: 1
+    };
+    this.buffers.set(key, buf);
+    return {
+      get turnId() {
+        return buf.turnId;
+      },
+      get lastSeq() {
+        return buf.nextSeq - 1;
+      },
+      append: (chunk) => {
+        if (buf.status !== "active") return -1;
+        const seq = buf.nextSeq++;
+        buf.frames.push({ seq, chunk });
+        buf.lastEventAt = Date.now();
+        for (const ctrl of buf.subscribers) {
+          try {
+            ctrl.enqueue(chunk);
+          } catch {
+            buf.subscribers.delete(ctrl);
+          }
+        }
+        return seq;
+      },
+      complete: (reason) => {
+        this.completeBuffer(buf, reason);
+      },
+      fail: (error) => {
+        this.failBuffer(buf, error);
+      }
+    };
+  }
+  /**
+   * Append a chunk by key (loose, untyped writer). Returns the seq assigned,
+   * or -1 if the buffer is unknown/inactive.
+   */
+  append(key, chunk) {
+    const buf = this.buffers.get(key);
+    if (!buf || buf.status !== "active") return -1;
+    const seq = buf.nextSeq++;
+    buf.frames.push({ seq, chunk });
+    buf.lastEventAt = Date.now();
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.enqueue(chunk);
+      } catch {
+        buf.subscribers.delete(ctrl);
+      }
+    }
+    return seq;
+  }
+  /** Mark a buffer as completed by key. Optional terminal reason. */
+  complete(key, reason) {
+    const buf = this.buffers.get(key);
+    if (!buf) return;
+    this.completeBuffer(buf, reason);
+  }
+  /**
+   * Abort a stream: complete subscribers and remove the buffer entirely.
+   * Future resume/replay requests for this key will return null (→ 204).
+   */
+  abort(key) {
+    const buf = this.buffers.get(key);
+    if (!buf) return;
+    this.completeBuffer(buf, "aborted");
+    buf.status = "aborted";
+    this.buffers.delete(key);
+  }
+  has(key) {
+    return this.buffers.has(key);
+  }
+  /** Read-only metadata about a buffered turn. Useful for resume responses. */
+  snapshot(key) {
+    const buf = this.buffers.get(key);
+    if (!buf) return null;
+    return {
+      turnId: buf.turnId,
+      status: buf.status,
+      lastSeq: buf.nextSeq - 1,
+      terminal: buf.terminal,
+      createdAt: buf.createdAt,
+      completedAt: buf.completedAt,
+      lastEventAt: buf.lastEventAt
+    };
+  }
+  /**
+   * Create a ReadableStream that first replays all buffered chunks past
+   * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
+   * any further live chunks until the stream completes.
+   *
+   * Returns null if no buffer exists for the key.
+   */
+  createReplayStream(key, opts = {}) {
+    const buf = this.buffers.get(key);
+    if (!buf) return null;
+    const fromSeq = Math.max(0, opts.fromSeq ?? 0);
+    let subscribedController = null;
+    return new ReadableStream({
+      start(controller) {
+        for (const frame of buf.frames) {
+          if (frame.seq <= fromSeq) continue;
+          try {
+            controller.enqueue(frame.chunk);
+          } catch {
+            return;
+          }
+        }
+        if (buf.status !== "active") {
+          try {
+            controller.close();
+          } catch {
+          }
+          return;
+        }
+        subscribedController = controller;
+        buf.subscribers.add(controller);
+      },
+      cancel() {
+        if (subscribedController) {
+          buf.subscribers.delete(subscribedController);
+          subscribedController = null;
+        }
+      }
+    });
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, buf] of this.buffers) {
+      if (buf.status !== "active" && buf.completedAt && now - buf.completedAt > COMPLETED_GRACE_MS) {
+        this.buffers.delete(key);
+      } else if (now - buf.createdAt > MAX_BUFFER_AGE_MS && buf.subscribers.size === 0) {
+        this.completeBuffer(buf, "expired");
+        this.buffers.delete(key);
+      }
+    }
+  }
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    for (const buf of this.buffers.values()) {
+      this.completeBuffer(buf, "disposed");
+    }
+    this.buffers.clear();
+  }
+  completeBuffer(buf, reason) {
+    if (buf.status !== "active") return;
+    buf.status = "completed";
+    buf.terminal = { reason };
+    buf.completedAt = Date.now();
+    buf.lastEventAt = buf.completedAt;
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.close();
+      } catch {
+      }
+    }
+    buf.subscribers.clear();
+  }
+  failBuffer(buf, error) {
+    if (buf.status !== "active") return;
+    buf.status = "failed";
+    buf.terminal = { error };
+    buf.completedAt = Date.now();
+    buf.lastEventAt = buf.completedAt;
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.close();
+      } catch {
+      }
+    }
+    buf.subscribers.clear();
+  }
+};
+function generateTurnId() {
+  try {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `turn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBufferingTransform(store, key) {
+  return new TransformStream({
+    transform(chunk, controller) {
+      store.append(key, chunk);
+      controller.enqueue(chunk);
+    },
+    flush() {
+      store.complete(key);
+    }
+  });
+}
+
+// src/chat-message.ts
+function findLastUserMessage(messages) {
+  return [...messages].reverse().find((m) => m.role === "user") ?? null;
+}
+function extractUserText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (Array.isArray(message.parts)) {
+    return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  }
+  return String(message.content ?? "");
+}
+
+// src/macos-junk.ts
+var MACOS_JUNK_BASENAMES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  ".AppleDouble",
+  ".LSOverride",
+  ".Spotlight-V100",
+  ".Trashes",
+  ".fseventsd",
+  ".TemporaryItems",
+  ".VolumeIcon.icns",
+  ".com.apple.timemachine.donotpresent",
+  "__MACOSX"
+]);
+var ICON_CR = "Icon\r";
+function isMacOSJunkName(name) {
+  if (!name) return false;
+  if (name.startsWith("._")) return true;
+  if (MACOS_JUNK_BASENAMES.has(name)) return true;
+  if (name === ICON_CR) return true;
+  return false;
+}
+function isMacOSJunkPath(relPath) {
+  if (!relPath) return false;
+  return relPath.split("/").some(isMacOSJunkName);
+}
+
+// src/tech-stack-registry.ts
+var TECH_STACK_REGISTRY = {
+  // Web (Vite-based) — share a bundled Vite template, so apps/api seeds them.
+  "react-app": { id: "react-app", target: "web" },
+  "threejs-game": { id: "threejs-game", target: "web" },
+  "phaser-game": { id: "phaser-game", target: "web" },
+  // Mobile (Metro/Expo) — agent-runtime owns the seed.
+  "expo-app": { id: "expo-app", target: "mobile", metro: true, seedsOwnTemplate: true },
+  "expo-three": { id: "expo-three", target: "mobile", metro: true, seedsOwnTemplate: true },
+  "react-native": { id: "react-native", target: "mobile", metro: true, seedsOwnTemplate: true },
+  // Data / scripting
+  "python-data": { id: "python-data", target: "data", seedsOwnTemplate: true },
+  // Native (full game engines)
+  "unity-game": { id: "unity-game", target: "native", seedsOwnTemplate: true },
+  // Bare / no-stack
+  none: { id: "none", target: "none", seedsOwnTemplate: true }
+};
+function getStackEntry(techStackId) {
+  if (!techStackId) return null;
+  return TECH_STACK_REGISTRY[techStackId] ?? null;
+}
+function isMobileTechStack(techStackId) {
+  return getStackEntry(techStackId)?.target === "mobile";
+}
+function usesMetroBundler(techStackId) {
+  return getStackEntry(techStackId)?.metro === true;
+}
+function stackSeedsItself(techStackId) {
+  return getStackEntry(techStackId)?.seedsOwnTemplate === true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamBufferStore,
+  TECH_STACK_REGISTRY,
+  createBufferingTransform,
+  createLogger,
+  extractUserText,
+  findLastUserMessage,
+  getStackEntry,
+  initInstrumentation,
+  isMacOSJunkName,
+  isMacOSJunkPath,
+  isMobileTechStack,
+  shutdownInstrumentation,
+  stackSeedsItself,
+  traceOperation,
+  usesMetroBundler
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+export { LogLevel, Logger, createLogger } from './logger.cjs';
+export { InstrumentationConfig, initInstrumentation, shutdownInstrumentation, traceOperation } from './instrumentation.cjs';
+export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TurnSnapshot, TurnStatus, TurnTerminal, createBufferingTransform } from './stream-buffer.cjs';
+export { extractUserText, findLastUserMessage } from './chat-message.cjs';
+export { isMacOSJunkName, isMacOSJunkPath } from './macos-junk.cjs';
+export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.cjs';
+import '@opentelemetry/api';

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { LogLevel, Logger, createLogger } from './logger.js';
+export { InstrumentationConfig, initInstrumentation, shutdownInstrumentation, traceOperation } from './instrumentation.js';
+export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TurnSnapshot, TurnStatus, TurnTerminal, createBufferingTransform } from './stream-buffer.js';
+export { extractUserText, findLastUserMessage } from './chat-message.js';
+export { isMacOSJunkName, isMacOSJunkPath } from './macos-junk.js';
+export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.js';
+import '@opentelemetry/api';

package/dist/index.js

@@ -0,0 +1,45 @@
+import {
+  extractUserText,
+  findLastUserMessage
+} from "./chunk-4J7NH2WJ.js";
+import {
+  initInstrumentation,
+  shutdownInstrumentation,
+  traceOperation
+} from "./chunk-IDGVRGAL.js";
+import {
+  createLogger
+} from "./chunk-24AL3V6R.js";
+import {
+  isMacOSJunkName,
+  isMacOSJunkPath
+} from "./chunk-VTD7O7YC.js";
+import {
+  StreamBufferStore,
+  createBufferingTransform
+} from "./chunk-ELMG6OXT.js";
+import {
+  TECH_STACK_REGISTRY,
+  getStackEntry,
+  isMobileTechStack,
+  stackSeedsItself,
+  usesMetroBundler
+} from "./chunk-KTDDFWXM.js";
+export {
+  StreamBufferStore,
+  TECH_STACK_REGISTRY,
+  createBufferingTransform,
+  createLogger,
+  extractUserText,
+  findLastUserMessage,
+  getStackEntry,
+  initInstrumentation,
+  isMacOSJunkName,
+  isMacOSJunkPath,
+  isMobileTechStack,
+  shutdownInstrumentation,
+  stackSeedsItself,
+  traceOperation,
+  usesMetroBundler
+};
+//# sourceMappingURL=index.js.map

package/dist/instrumentation.cjs

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/instrumentation.ts
+var instrumentation_exports = {};
+__export(instrumentation_exports, {
+  initInstrumentation: () => initInstrumentation,
+  shutdownInstrumentation: () => shutdownInstrumentation,
+  traceOperation: () => traceOperation
+});
+module.exports = __toCommonJS(instrumentation_exports);
+var import_api = require("@opentelemetry/api");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var sdk = null;
+function initInstrumentation(config) {
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!endpoint) {
+    console.log(`[OTEL] Tracing disabled for ${config.serviceName} (OTEL_EXPORTER_OTLP_ENDPOINT not set)`);
+    return;
+  }
+  const diagLevel = process.env.OTEL_LOG_LEVEL === "debug" ? import_api.DiagLogLevel.DEBUG : process.env.OTEL_LOG_LEVEL === "info" ? import_api.DiagLogLevel.INFO : import_api.DiagLogLevel.WARN;
+  import_api.diag.setLogger(new import_api.DiagConsoleLogger(), diagLevel);
+  const headers = {};
+  if (process.env.SIGNOZ_INGESTION_KEY) {
+    headers["signoz-ingestion-key"] = process.env.SIGNOZ_INGESTION_KEY;
+  }
+  const serviceName = process.env.OTEL_SERVICE_NAME || config.serviceName;
+  console.log(`[OTEL] Configuring ${serviceName} \u2192 ${endpoint}/v1/traces`);
+  let traceExporter;
+  try {
+    traceExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: `${endpoint}/v1/traces`,
+      headers
+    });
+  } catch (err) {
+    console.error(`[OTEL] Failed to create exporter: ${err.message}`);
+    return;
+  }
+  const isProduction = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
+  const spanProcessor = isProduction ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  sdk = new import_sdk_node.NodeSDK({
+    resource: (0, import_resources.resourceFromAttributes)({
+      [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+      [import_semantic_conventions.ATTR_SERVICE_VERSION]: config.serviceVersion || "0.1.0",
+      "deployment.environment.name": process.env.NODE_ENV || "development"
+    }),
+    spanProcessors: [spanProcessor],
+    instrumentations: []
+  });
+  try {
+    sdk.start();
+    console.log(`[OTEL] Tracing enabled for ${serviceName}`);
+  } catch (err) {
+    console.error(`[OTEL] SDK failed to start: ${err.message}`);
+    sdk = null;
+    return;
+  }
+  try {
+    const tracer = import_api.trace.getTracer(serviceName);
+    const testSpan = tracer.startSpan("otel.startup-test", {
+      attributes: {
+        "test.type": "startup-verification",
+        "service.name": serviceName,
+        // `process.versions.bun` is present under Bun (always undefined
+        // under plain Node) — avoids referencing the `Bun` global so
+        // this file typechecks without `@types/bun` in tsconfig.
+        "runtime": process.versions.bun ? "bun" : "node"
+      }
+    });
+    testSpan.setStatus({ code: import_api.SpanStatusCode.OK });
+    testSpan.end();
+    console.log(`[OTEL] Startup test span emitted for ${serviceName}`);
+  } catch (err) {
+    console.error(`[OTEL] Failed to emit test span: ${err.message}`);
+  }
+}
+async function shutdownInstrumentation() {
+  if (sdk) {
+    try {
+      await sdk.shutdown();
+      console.log("[OTEL] Tracing shut down");
+    } catch (err) {
+      console.error("[OTEL] Error shutting down:", err.message);
+    }
+  }
+}
+function traceOperation(tracerName, spanName, attributes, fn) {
+  const tracer = import_api.trace.getTracer(tracerName);
+  return tracer.startActiveSpan(spanName, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+      span.recordException(err);
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initInstrumentation,
+  shutdownInstrumentation,
+  traceOperation
+});
+//# sourceMappingURL=instrumentation.cjs.map