@glasstrace/sdk 1.9.0 → 1.10.0

package/dist/{chunk-HD6JIFKN.js → chunk-BSVWJSVX.js}

@@ -1,6 +1,6 @@
 import {
   createBuildHash
-} from "./chunk-JHUNLPSS.js";
+} from "./chunk-6RKS3DNA.js";
 
 // src/import-graph.ts
 import * as fs from "node:fs/promises";
@@ -175,4 +175,4 @@ export {
   extractImports,
   buildImportGraph
 };
-//# sourceMappingURL=chunk-HD6JIFKN.js.map
+//# sourceMappingURL=chunk-BSVWJSVX.js.map

package/dist/{chunk-QHV7NFON.js → chunk-D54FMQHF.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-DQ25VOKK.js";
 import {
   GLASSTRACE_ATTRIBUTE_NAMES
-} from "./chunk-JHUNLPSS.js";
+} from "./chunk-6RKS3DNA.js";
 
 // src/middleware/index.ts
 var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
@@ -58,49 +58,58 @@ function tracedRequestMiddleware(options, handler) {
   }
   const wrapped = ((req, ...rest) => {
     const tracer = trace.getTracer(TRACER_NAME);
-    return tracer.startActiveSpan(options.name, (span) => {
-      if (isNoopSpan(span)) {
-        if (!_skippedUninstalledEmitted) {
-          _skippedUninstalledEmitted = true;
-          tryEmitLifecycleEvent("middleware:skipped_uninstalled", {});
+    let callbackInvoked = false;
+    try {
+      return tracer.startActiveSpan(options.name, (span) => {
+        callbackInvoked = true;
+        if (isNoopSpan(span)) {
+          if (!_skippedUninstalledEmitted) {
+            _skippedUninstalledEmitted = true;
+            tryEmitLifecycleEvent("middleware:skipped_uninstalled", {});
+          }
+          endSpanSafely(span);
+          return handler(req, ...rest);
         }
-        endSpanSafely(span);
-        return handler(req, ...rest);
-      }
-      try {
-        if (options.attributes) {
-          span.setAttributes(options.attributes);
+        try {
+          if (options.attributes) {
+            span.setAttributes(options.attributes);
+          }
+          const path = extractRequestPath(req);
+          if (path !== void 0) {
+            span.setAttribute(ATTR.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);
+          }
+        } catch {
         }
-        const path = extractRequestPath(req);
-        if (path !== void 0) {
-          span.setAttribute(ATTR.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);
+        let result;
+        try {
+          result = handler(req, ...rest);
+        } catch (error) {
+          recordSpanError(span, error);
+          endSpanSafely(span);
+          throw error;
+        }
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              endSpanSafely(span);
+              return value;
+            },
+            (error) => {
+              recordSpanError(span, error);
+              endSpanSafely(span);
+              throw error;
+            }
+          );
         }
-      } catch {
-      }
-      let result;
-      try {
-        result = handler(req, ...rest);
-      } catch (error) {
-        recordSpanError(span, error);
         endSpanSafely(span);
-        throw error;
-      }
-      if (result !== null && typeof result === "object" && typeof result.then === "function") {
-        return result.then(
-          (value) => {
-            endSpanSafely(span);
-            return value;
-          },
-          (error) => {
-            recordSpanError(span, error);
-            endSpanSafely(span);
-            throw error;
-          }
-        );
+        return result;
+      });
+    } catch (err) {
+      if (callbackInvoked) {
+        throw err;
       }
-      endSpanSafely(span);
-      return result;
-    });
+      return handler(req, ...rest);
+    }
   });
   return wrapped;
 }
@@ -127,4 +136,4 @@ export {
   _resetForTesting,
   tracedRequestMiddleware
 };
-//# sourceMappingURL=chunk-QHV7NFON.js.map
+//# sourceMappingURL=chunk-D54FMQHF.js.map

package/dist/chunk-D54FMQHF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/index.ts"],"sourcesContent":["/**\n * Request-middleware-ownership instrumentation for Glasstrace.\n *\n * Subpath: `@glasstrace/sdk/middleware`\n *\n * This module exposes {@link tracedRequestMiddleware}, a wrapper that\n * turns a Next.js `middleware.ts` function (or any generic\n * `Request → Response`-shaped handler) into a span-emitting middleware\n * function. Each invocation opens a child span and tags it with the\n * `glasstrace.causal.middleware_for_request` causal-evidence attribute\n * carrying the originating request's normalized path so the\n * product-side trace-summary transform can link the middleware span\n * to the owning HTTP request trace (DISC-1537 / SDK-046).\n *\n * Edge-runtime safety\n * -------------------\n * The wrapper is included in the SDK's edge bundle\n * (`packages/sdk/src/edge-entry.ts`). Its closure imports only the\n * OTel API, the protocol constants, and the\n * `./optional-lifecycle.js` bridge — none of which reach into\n * `node:*` built-ins or the `process` global. The F003 closure scan\n * (`packages/sdk/scripts/check-edge-bundle.mjs`) enforces this on\n * every build.\n *\n * Causal-evidence form\n * --------------------\n * The wrapper attaches the originating request path as a span\n * attribute (`glasstrace.causal.middleware_for_request`). It does NOT\n * emit an OTel `Link`. Reasons:\n *\n *   1. The Next.js Edge runtime does not propagate AsyncLocalStorage\n *      into `middleware.ts`, so there is no in-process\n *      `SpanContext` to link to in that environment. Attribute-only\n *      causality works in both Node and Edge runtimes; a Link would\n *      degrade to a no-op (no parent context) on Edge.\n *   2. The product-side trace-summary transform reconstructs\n *      ownership from `glasstrace.causal.*` attributes per\n *      DISC-1539 §51-58; it does not require a Link.\n *\n * Invariants\n * ----------\n *\n *   - The wrapped function preserves the user's call-site type so\n *     Next.js's `middleware` export contract (`(req: NextRequest) =>\n *     NextResponse | Response`) flows through unchanged.\n *   - The middleware span MUST NOT overwrite `glasstrace.route`,\n *     `glasstrace.http.status_code`, or `glasstrace.http.duration_ms`\n *     on the parent HTTP span — root-request semantics are owned by\n *     the enriching exporter (`packages/sdk/src/enriching-exporter.ts`).\n *   - On a thrown handler error: span ends with `ERROR` status +\n *     `recordException`; rethrows. The exception is normalized to\n *     `Error | string` first so non-Error throwables (number, plain\n *     object) do not crash `recordException`.\n *   - Always ends the span (`finally`), even on `throw`.\n *\n * @module @glasstrace/sdk/middleware\n */\n\nimport {\n  trace,\n  SpanStatusCode,\n  type AttributeValue,\n} from \"@opentelemetry/api\";\nimport { GLASSTRACE_ATTRIBUTE_NAMES } from \"@glasstrace/protocol\";\nimport { tryEmitLifecycleEvent } from \"../optional-lifecycle.js\";\n\nconst ATTR = GLASSTRACE_ATTRIBUTE_NAMES;\n\n/**\n * Module-level OTel tracer name for the middleware subpath. Resolves\n * through the global `ProxyTracerProvider` so the wrapper picks up\n * whatever provider the SDK has detected or registered (the SDK's\n * own enriching exporter, Sentry's processor in coexistence mode,\n * etc.). Re-resolved on every call site rather than cached at module\n * top level so test harnesses can install a provider after this\n * module is imported. This mirrors the tRPC subpath at\n * `packages/sdk/src/trpc/index.ts:128`.\n */\nconst TRACER_NAME = \"@glasstrace/sdk/middleware\";\n\n/**\n * Module-level once-flag for the\n * `middleware:skipped_uninstalled` lifecycle event. The flag is\n * exported via {@link _resetForTesting} so unit tests can re-arm it\n * between scenarios.\n */\nlet _skippedUninstalledEmitted = false;\n\n/**\n * INTERNAL — clears the once-flag for the\n * `middleware:skipped_uninstalled` lifecycle event. Invoked by\n * Vitest fixtures only; not part of the public surface.\n */\nexport function _resetForTesting(): void {\n  _skippedUninstalledEmitted = false;\n}\n\n/**\n * Permissive structural bound for a request-middleware function. The\n * shape is the intersection of Next.js's `middleware.ts` export\n * (`(req: NextRequest, event?: NextFetchEvent) => NextResponse |\n * Response | Promise<NextResponse | Response> | undefined`) and the\n * generic Web Fetch API (`(req: Request, ...rest: any[]) => Response\n * | Promise<Response>`). The parameter list is typed with `any[]` for\n * the rest position so any caller-narrowed signature is assignable\n * without the wrapper having to import `next/server` types.\n *\n * Exported so consumers can reference it for type-inference assertions\n * (e.g., proving a strongly-typed handler fits the bound). The\n * runtime contract is fixed by the Web Fetch API: the first argument\n * is a `Request`-shaped object and the return is a `Response`-shaped\n * value (or a Promise of one).\n */\n// The `any[]` in the rest position is load-bearing: a tighter bound\n// (e.g. `unknown[]`) would reject `(req, event?) => ...` because\n// `unknown` cannot be passed in the contravariant parameter position\n// without an explicit cast at every call site. Capturing\n// `H extends RequestMiddlewareFunction` preserves caller types\n// through the wrapper's `: H` return.\n//\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequestMiddlewareFunction = (req: any, ...rest: any[]) => unknown;\n\n/**\n * Options for {@link tracedRequestMiddleware}.\n *\n * @example\n * ```ts\n * import { tracedRequestMiddleware } from \"@glasstrace/sdk/middleware\";\n * import type { NextRequest } from \"next/server\";\n *\n * export const middleware = tracedRequestMiddleware(\n *   { name: \"auth-middleware\", attributes: { \"auth.required\": true } },\n *   async (req: NextRequest) => {\n *     // … your auth logic here …\n *     return NextResponse.next();\n *   },\n * );\n * ```\n */\nexport interface TracedRequestMiddlewareOptions {\n  /**\n   * Span name. Required, non-empty string. Used as the OTel span name\n   * and appears in trace timelines. Names should be stable across\n   * runs so the product-side transform can reason about middleware\n   * identity (e.g., \"auth-middleware\", \"rate-limiter\"); avoid\n   * embedding request data in the name.\n   */\n  name: string;\n  /**\n   * Optional attributes attached to the span before the wrapped\n   * handler runs. Forwarded to OTel as-is via `span.setAttributes()`.\n   * The SDK does not redact, sanitize, or scan values here — callers\n   * MUST avoid placing tokens, credentials, or other sensitive data\n   * in `attributes`.\n   *\n   * Sensitive request/response data is captured through gated SDK\n   * paths (e.g., `glasstrace.error.response_body`), not through this\n   * surface.\n   */\n  attributes?: Record<string, AttributeValue>;\n}\n\n/**\n * Extract the originating request path from a Fetch-API `Request` or\n * `NextRequest`-shaped object. Preference order:\n *\n *   1. `req.nextUrl.pathname` — present on `NextRequest`. This is\n *      Next.js's parsed URL and is the most reliable source on the\n *      Next.js Edge runtime, where `req.url` may be a relative form\n *      depending on framework-internal rewrites.\n *   2. `new URL(req.url).pathname` — present on the generic Fetch\n *      `Request`. The URL constructor accepts an absolute URL; if\n *      `req.url` is relative we synthesize a base of\n *      `http://localhost` to make parsing succeed (the host is\n *      discarded — only the path is used).\n *   3. `undefined` — when neither field exists or both fail to\n *      parse, the wrapper omits the causal attribute rather than\n *      emitting a guessed value, per the SDK-046 product brief's\n *      \"missing or unknown evidence is preferable to guessed\n *      evidence\" rule (DISC-1537 / DISC-1539 product handoff).\n *\n * This function never throws.\n */\nfunction extractRequestPath(req: unknown): string | undefined {\n  if (req === null || typeof req !== \"object\") return undefined;\n  try {\n    // NextRequest.nextUrl — already a URL-like object with .pathname.\n    const nextUrl = (req as { nextUrl?: unknown }).nextUrl;\n    if (nextUrl !== null && typeof nextUrl === \"object\") {\n      const pathname = (nextUrl as { pathname?: unknown }).pathname;\n      if (typeof pathname === \"string\" && pathname.length > 0) {\n        return pathname;\n      }\n    }\n    // Fall back to req.url. On Edge / Web Fetch this is always\n    // absolute; on some Node frameworks it can be relative\n    // (`/api/foo?x=1`), so synthesize a base if the URL constructor\n    // throws on the absolute parse.\n    const url = (req as { url?: unknown }).url;\n    if (typeof url === \"string\" && url.length > 0) {\n      try {\n        return new URL(url).pathname;\n      } catch {\n        try {\n          return new URL(url, \"http://localhost\").pathname;\n        } catch {\n          return undefined;\n        }\n      }\n    }\n  } catch {\n    // Defensive: any unexpected shape failure returns undefined.\n  }\n  return undefined;\n}\n\n/**\n * Sentinel trace ID returned by the OTel API's noop tracer\n * (`@opentelemetry/api`'s `NonRecordingSpan`). Per the OTel\n * specification's noop semantics, the noop SpanContext exposes\n * `traceId === \"00000000000000000000000000000000\"`. Used by\n * {@link isNoopSpan} below to discriminate \"no provider registered\"\n * from \"real provider whose sampler dropped this span\" — the latter\n * also returns `isRecording() === false` but produces a valid\n * 32-char hex trace ID because the SDK assigns one before sampler\n * invocation for propagation purposes.\n */\nconst INVALID_TRACE_ID = \"00000000000000000000000000000000\";\n\n/**\n * Type guard for OTel spans created by the noop tracer. The OTel\n * API's noop SpanContext returns the all-zeros sentinel for\n * `traceId`; real SDK-emitted spans always have a valid 32-char hex\n * trace ID (even when a sampler decided to DROP the span). Using\n * the SpanContext discriminator keeps the SDK-not-registered fast\n * path from misfiring under normal head sampling configurations\n * (Copilot review 2026-05-08).\n *\n * Returning `true` here means the caller should NOT proceed with\n * span enrichment; the noop tracer would discard everything anyway.\n */\nfunction isNoopSpan(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): boolean {\n  try {\n    return span.spanContext().traceId === INVALID_TRACE_ID;\n  } catch {\n    // Defensive: treat \"could not determine\" as not-noop so we\n    // continue down the enrichment path. The noop tracer itself\n    // never throws from `spanContext()`.\n    return false;\n  }\n}\n\n/**\n * Wrap a Next.js / generic-fetch request-middleware function in an\n * OTel span tagged with `glasstrace.causal.middleware_for_request`.\n *\n * **Privacy:** the value of\n * `glasstrace.causal.middleware_for_request` is the raw URL\n * pathname. Pathnames can carry user-controlled data (IDs, emails,\n * opaque keys). The SDK does NOT redact this attribute. Callers MUST\n * NOT place secrets, tokens, or other sensitive data in URL paths;\n * the same general HTTP best practice that keeps secrets out of\n * server logs keeps them out of Glasstrace trace evidence.\n *\n * Each call to the returned function:\n *\n *   1. Detects the SDK's registration state. When the OTel API is\n *      still on the noop tracer (SDK not registered, or\n *      `OtelState.UNCONFIGURED`), runs the wrapped handler directly\n *      and emits a `middleware:skipped_uninstalled` lifecycle event\n *      (at most once per process). No span is opened.\n *   2. Otherwise opens a span named `options.name` under the active\n *      OTel context (typically the HTTP server span on Node;\n *      detached on Edge where AsyncLocalStorage is not available).\n *      Sets `options.attributes` first, then attaches the originating\n *      request's path (via {@link extractRequestPath}) as\n *      `glasstrace.causal.middleware_for_request`. The path is\n *      omitted when extraction returns `undefined` so absent evidence\n *      is preferred over guessed evidence.\n *   3. Awaits the wrapped handler.\n *   4. On a thrown error: normalizes the throwable to `Error | string`\n *      so `recordException` does not throw on non-Error values; sets\n *      `span.status` to `ERROR` with the error's message; rethrows the\n *      original (un-normalized) error verbatim.\n *   5. On a successful return: leaves the span status `UNSET` per OTel\n *      instrumentation-library guidance (explicit `OK` would shadow\n *      downstream consumers' error transitions).\n *   6. Always ends the span, even on `throw` or `return`.\n *\n * Type-inference: the returned function preserves the input function's\n * type `H`, so caller-narrowed signatures (e.g., `(req: NextRequest)\n * => NextResponse`) flow through unchanged.\n *\n * @param options - Span name and optional pre-start attributes.\n * @param handler - The user's middleware handler. Must accept a\n *   request-shaped object as its first argument and return (or\n *   resolve to) a response-shaped value.\n * @returns The wrapped handler with the same call signature and\n *   return type as `handler`.\n *\n * @example Next.js middleware.ts\n * ```ts\n * import { tracedRequestMiddleware } from \"@glasstrace/sdk/middleware\";\n * import { NextResponse, type NextRequest } from \"next/server\";\n *\n * export const middleware = tracedRequestMiddleware(\n *   { name: \"auth-middleware\" },\n *   async (req: NextRequest) => {\n *     if (!req.cookies.get(\"session\")) {\n *       return NextResponse.redirect(new URL(\"/login\", req.url));\n *     }\n *     return NextResponse.next();\n *   },\n * );\n *\n * export const config = { matcher: [\"/dashboard/:path*\"] };\n * ```\n */\nexport function tracedRequestMiddleware<H extends RequestMiddlewareFunction>(\n  options: TracedRequestMiddlewareOptions,\n  handler: H,\n): H {\n  // Eager validation: a mis-typed call site fails at wrapper-\n  // construction time (typically at module load) rather than at\n  // first request, when the failure is harder to diagnose.\n  if (typeof options.name !== \"string\" || options.name.length === 0) {\n    throw new TypeError(\n      \"tracedRequestMiddleware: options.name must be a non-empty string\",\n    );\n  }\n\n  // Capture options + handler lexically. Do not read from `this` —\n  // Next.js's middleware loader invokes this as a plain function, not\n  // a method, so `this` is undefined.\n  const wrapped = ((req: Parameters<H>[0], ...rest: unknown[]): unknown => {\n    const tracer = trace.getTracer(TRACER_NAME);\n    // Defensive wrap around `tracer.startActiveSpan` itself.\n    // OTel's noop tracer never throws; a real provider could\n    // (e.g., a misbehaving custom processor in coexistence). If the\n    // tracer call throws BEFORE invoking our callback, fall back to\n    // running the handler directly so instrumentation does not break\n    // the user's middleware.\n    //\n    // CRITICAL: the fallback runs ONLY when the tracer failed\n    // pre-callback. The callback itself rethrows handler errors\n    // (`recordSpanError` + `throw error`) which would otherwise be\n    // intercepted here and cause the handler to run a second time\n    // (Codex P1, 2026-05-08). The `callbackInvoked` flag\n    // distinguishes pre-callback tracer failure from post-callback\n    // handler-error rethrow.\n    let callbackInvoked = false;\n    try {\n      return tracer.startActiveSpan(options.name, (span) => {\n      callbackInvoked = true;\n      // SDK-not-registered fast path. Detecting via the public\n      // `isRecording()` method on the started span is the canonical\n      // OTel-API-only probe — the noop tracer's `NonRecordingSpan`\n      // returns `false`, real SDK-emitted spans return `true`. This\n      // avoids the more expensive workaround of opening a probe span\n      // ahead of time, which would emit a useless span on every\n      // request when a real provider is registered.\n      if (isNoopSpan(span)) {\n        if (!_skippedUninstalledEmitted) {\n          _skippedUninstalledEmitted = true;\n          tryEmitLifecycleEvent(\"middleware:skipped_uninstalled\", {});\n        }\n        // The noop span needs no enrichment and no end() because the\n        // noop implementation is a no-op for both, but call end()\n        // anyway for symmetry with the real-span path.\n        endSpanSafely(span);\n        return (handler as (...args: unknown[]) => unknown)(req, ...rest);\n      }\n\n      // Set caller-supplied attributes first so they appear on the\n      // span before any internal attribute we add below.\n      try {\n        if (options.attributes) {\n          span.setAttributes(options.attributes);\n        }\n        const path = extractRequestPath(req);\n        if (path !== undefined) {\n          span.setAttribute(ATTR.CAUSAL_MIDDLEWARE_FOR_REQUEST, path);\n        }\n      } catch {\n        // Attribute-setting failures are advisory; never block the\n        // wrapped handler from running.\n      }\n\n      let result: unknown;\n      try {\n        result = (handler as (...args: unknown[]) => unknown)(req, ...rest);\n      } catch (error) {\n        recordSpanError(span, error);\n        endSpanSafely(span);\n        throw error;\n      }\n\n      // The handler may be sync or async. If async, attach the\n      // span-end + error-recording on the promise chain; otherwise\n      // end the span synchronously and return the value.\n      if (\n        result !== null &&\n        typeof result === \"object\" &&\n        typeof (result as Promise<unknown>).then === \"function\"\n      ) {\n        return (result as Promise<unknown>).then(\n          (value) => {\n            endSpanSafely(span);\n            return value;\n          },\n          (error: unknown) => {\n            recordSpanError(span, error);\n            endSpanSafely(span);\n            throw error;\n          },\n        );\n      }\n\n      endSpanSafely(span);\n      return result;\n    });\n    } catch (err) {\n      if (callbackInvoked) {\n        // The tracer's callback ran and our code (or the user's\n        // handler via our rethrow) threw. That error is intentional;\n        // propagate it without invoking the handler again.\n        throw err;\n      }\n      // `tracer.startActiveSpan` failed BEFORE invoking our callback.\n      // Drop instrumentation for this invocation and run the user's\n      // handler directly so the request does not break.\n      return (handler as (...args: unknown[]) => unknown)(req, ...rest);\n    }\n  }) as H;\n\n  return wrapped;\n}\n\n/**\n * Records an exception on a span and sets the span status to `ERROR`.\n * Both calls are independently guarded so a failing `recordException`\n * cannot prevent the status transition, and vice versa. The user's\n * original error value is preserved verbatim — wrapping is purely a\n * span-side normalization.\n */\nfunction recordSpanError(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n  error: unknown,\n): void {\n  const normalized: Error | string =\n    error instanceof Error\n      ? error\n      : typeof error === \"string\"\n        ? error\n        : new Error(String(error));\n  const statusMessage =\n    normalized instanceof Error ? normalized.message : normalized;\n  try {\n    span.recordException(normalized);\n  } catch {\n    // Swallow: instrumentation must never replace the user's error.\n  }\n  try {\n    span.setStatus({ code: SpanStatusCode.ERROR, message: statusMessage });\n  } catch {\n    // Swallow: independent from recordException so a failing\n    // recordException does not prevent the ERROR status.\n  }\n}\n\n/**\n * Ends a span, swallowing any throw from the OTel implementation. A\n * misbehaving `span.end()` must not replace the wrapped handler's\n * return value or thrown error with an unrelated one.\n */\nfunction endSpanSafely(\n  span: ReturnType<ReturnType<typeof trace.getTracer>[\"startSpan\"]>,\n): void {\n  try {\n    span.end();\n  } catch {\n    // Span lifecycle errors are always non-fatal at this layer.\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-I2DVVSKW.js

@@ -0,0 +1,419 @@
+import {
+  _registerLifecycleEmitForBridge
+} from "./chunk-CL3OVHPO.js";
+
+// src/lifecycle.ts
+import { EventEmitter } from "node:events";
+
+// src/signal-handler.ts
+var coexistenceState = "unknown";
+function setCoexistenceState(s) {
+  coexistenceState = s;
+}
+function getCoexistenceState() {
+  return coexistenceState;
+}
+
+// src/lifecycle.ts
+var CoreState = {
+  IDLE: "IDLE",
+  REGISTERING: "REGISTERING",
+  KEY_PENDING: "KEY_PENDING",
+  KEY_RESOLVED: "KEY_RESOLVED",
+  ACTIVE: "ACTIVE",
+  ACTIVE_DEGRADED: "ACTIVE_DEGRADED",
+  SHUTTING_DOWN: "SHUTTING_DOWN",
+  SHUTDOWN: "SHUTDOWN",
+  PRODUCTION_DISABLED: "PRODUCTION_DISABLED",
+  REGISTRATION_FAILED: "REGISTRATION_FAILED"
+};
+var AuthState = {
+  ANONYMOUS: "ANONYMOUS",
+  AUTHENTICATED: "AUTHENTICATED",
+  CLAIMING: "CLAIMING",
+  CLAIMED: "CLAIMED"
+};
+var OtelState = {
+  UNCONFIGURED: "UNCONFIGURED",
+  CONFIGURING: "CONFIGURING",
+  OWNS_PROVIDER: "OWNS_PROVIDER",
+  AUTO_ATTACHED: "AUTO_ATTACHED",
+  PROCESSOR_PRESENT: "PROCESSOR_PRESENT",
+  COEXISTENCE_FAILED: "COEXISTENCE_FAILED"
+};
+var VALID_CORE_TRANSITIONS = {
+  [CoreState.IDLE]: [CoreState.REGISTERING, CoreState.REGISTRATION_FAILED, CoreState.SHUTTING_DOWN],
+  [CoreState.REGISTERING]: [
+    CoreState.KEY_PENDING,
+    CoreState.PRODUCTION_DISABLED,
+    CoreState.REGISTRATION_FAILED,
+    CoreState.SHUTTING_DOWN
+  ],
+  [CoreState.KEY_PENDING]: [
+    CoreState.KEY_RESOLVED,
+    CoreState.REGISTRATION_FAILED,
+    CoreState.SHUTTING_DOWN
+  ],
+  [CoreState.KEY_RESOLVED]: [
+    CoreState.ACTIVE,
+    CoreState.ACTIVE_DEGRADED,
+    CoreState.SHUTTING_DOWN
+  ],
+  [CoreState.ACTIVE]: [
+    CoreState.ACTIVE_DEGRADED,
+    CoreState.SHUTTING_DOWN
+  ],
+  [CoreState.ACTIVE_DEGRADED]: [
+    CoreState.ACTIVE,
+    CoreState.SHUTTING_DOWN
+  ],
+  [CoreState.SHUTTING_DOWN]: [CoreState.SHUTDOWN],
+  [CoreState.SHUTDOWN]: [],
+  [CoreState.PRODUCTION_DISABLED]: [],
+  [CoreState.REGISTRATION_FAILED]: []
+};
+var VALID_AUTH_TRANSITIONS = {
+  [AuthState.ANONYMOUS]: [AuthState.CLAIMING],
+  [AuthState.AUTHENTICATED]: [AuthState.CLAIMING],
+  [AuthState.CLAIMING]: [AuthState.CLAIMED],
+  [AuthState.CLAIMED]: [AuthState.CLAIMING]
+};
+var VALID_OTEL_TRANSITIONS = {
+  [OtelState.UNCONFIGURED]: [OtelState.CONFIGURING],
+  [OtelState.CONFIGURING]: [
+    OtelState.OWNS_PROVIDER,
+    OtelState.AUTO_ATTACHED,
+    OtelState.PROCESSOR_PRESENT,
+    OtelState.COEXISTENCE_FAILED
+  ],
+  [OtelState.OWNS_PROVIDER]: [],
+  [OtelState.AUTO_ATTACHED]: [],
+  [OtelState.PROCESSOR_PRESENT]: [],
+  [OtelState.COEXISTENCE_FAILED]: []
+};
+var _coreState = CoreState.IDLE;
+var _authState = AuthState.ANONYMOUS;
+var _otelState = OtelState.UNCONFIGURED;
+var _emitter = new EventEmitter();
+var _logger = null;
+var _initialized = false;
+var _initWarned = false;
+var _coreReadyEmitted = false;
+var _authInitialized = false;
+var _emitting = false;
+function initLifecycle(options) {
+  if (_initialized) {
+    options.logger("warn", "[glasstrace] initLifecycle() called twice \u2014 ignored.");
+    return;
+  }
+  _logger = options.logger;
+  _initialized = true;
+  _registerLifecycleEmitForBridge((event, payload) => {
+    emitLifecycleEvent(
+      event,
+      payload
+    );
+  });
+}
+function warnIfNotInitialized() {
+  if (!_initialized && !_initWarned) {
+    _initWarned = true;
+    console.warn(
+      "[glasstrace] Lifecycle state changed before initLifecycle() was called. Logger not available \u2014 errors will be silent."
+    );
+  }
+}
+function setCoreState(to) {
+  warnIfNotInitialized();
+  const from = _coreState;
+  if (from === to) return;
+  const valid = VALID_CORE_TRANSITIONS[from];
+  if (!valid.includes(to)) {
+    _logger?.(
+      "warn",
+      `[glasstrace] Invalid core state transition: ${from} \u2192 ${to}. Ignored.`
+    );
+    return;
+  }
+  _coreState = to;
+  if (_emitting) return;
+  _emitting = true;
+  try {
+    emitSafe("core:state_changed", { from, to });
+    const current = _coreState;
+    if (!_coreReadyEmitted && (current === CoreState.ACTIVE || current === CoreState.ACTIVE_DEGRADED)) {
+      _coreReadyEmitted = true;
+      emitSafe("core:ready", {});
+    }
+    if (current === CoreState.SHUTTING_DOWN) {
+      emitSafe("core:shutdown_started", {});
+    }
+    if (current === CoreState.SHUTDOWN) {
+      emitSafe("core:shutdown_completed", {});
+    }
+  } finally {
+    _emitting = false;
+  }
+  if (to === CoreState.ACTIVE && _degradationSources.size > 0) {
+    recomputeCoreFromDegradationSources();
+  }
+}
+function initAuthState(state) {
+  if (_authInitialized) {
+    _logger?.(
+      "warn",
+      "[glasstrace] initAuthState() called after auth state already initialized. Ignored."
+    );
+    return;
+  }
+  _authInitialized = true;
+  _authState = state;
+}
+function setAuthState(to) {
+  warnIfNotInitialized();
+  const from = _authState;
+  if (from === to) return;
+  const valid = VALID_AUTH_TRANSITIONS[from];
+  if (!valid.includes(to)) {
+    _logger?.(
+      "warn",
+      `[glasstrace] Invalid auth state transition: ${from} \u2192 ${to}. Ignored.`
+    );
+    return;
+  }
+  _authState = to;
+}
+function setOtelState(to) {
+  warnIfNotInitialized();
+  const from = _otelState;
+  if (from === to) return;
+  const valid = VALID_OTEL_TRANSITIONS[from];
+  if (!valid.includes(to)) {
+    _logger?.(
+      "warn",
+      `[glasstrace] Invalid OTel state transition: ${from} \u2192 ${to}. Ignored.`
+    );
+    return;
+  }
+  _otelState = to;
+}
+var _degradationSources = /* @__PURE__ */ new Set();
+function pushDegradationSource(key) {
+  _degradationSources.add(key);
+  recomputeCoreFromDegradationSources();
+}
+function clearDegradationSource(key) {
+  _degradationSources.delete(key);
+  recomputeCoreFromDegradationSources();
+}
+function recomputeCoreFromDegradationSources() {
+  const hasDegradation = _degradationSources.size > 0;
+  if (hasDegradation && _coreState === CoreState.ACTIVE) {
+    setCoreState(CoreState.ACTIVE_DEGRADED);
+    return;
+  }
+  if (!hasDegradation && _coreState === CoreState.ACTIVE_DEGRADED) {
+    setCoreState(CoreState.ACTIVE);
+  }
+}
+function getCoreState() {
+  return _coreState;
+}
+function getSdkState() {
+  return {
+    core: _coreState,
+    auth: _authState,
+    otel: _otelState
+  };
+}
+function onLifecycleEvent(event, listener) {
+  _emitter.on(event, listener);
+}
+function emitLifecycleEvent(event, payload) {
+  emitSafe(event, payload);
+}
+function offLifecycleEvent(event, listener) {
+  _emitter.off(event, listener);
+}
+function emitSafe(event, payload) {
+  const listeners = _emitter.listeners(event);
+  for (const listener of listeners) {
+    try {
+      const result = listener(payload);
+      if (result && typeof result.catch === "function") {
+        result.catch((err) => {
+          _logger?.(
+            "error",
+            `[glasstrace] Async error in lifecycle event listener for "${event}": ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      }
+    } catch (err) {
+      _logger?.(
+        "error",
+        `[glasstrace] Error in lifecycle event listener for "${event}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+function isReady() {
+  return _coreState === CoreState.ACTIVE || _coreState === CoreState.ACTIVE_DEGRADED;
+}
+function waitForReady(timeoutMs = 3e4) {
+  if (isReady()) {
+    return Promise.resolve();
+  }
+  if (_coreState === CoreState.PRODUCTION_DISABLED || _coreState === CoreState.REGISTRATION_FAILED || _coreState === CoreState.SHUTTING_DOWN || _coreState === CoreState.SHUTDOWN) {
+    return Promise.reject(new Error(`SDK is in terminal state: ${_coreState}`));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const listener = ({ to }) => {
+      if (settled) return;
+      if (to === CoreState.ACTIVE || to === CoreState.ACTIVE_DEGRADED) {
+        settled = true;
+        offLifecycleEvent("core:state_changed", listener);
+        resolve();
+      } else if (to === CoreState.PRODUCTION_DISABLED || to === CoreState.REGISTRATION_FAILED || to === CoreState.SHUTTING_DOWN || to === CoreState.SHUTDOWN) {
+        settled = true;
+        offLifecycleEvent("core:state_changed", listener);
+        reject(new Error(`SDK reached terminal state: ${to}`));
+      }
+    };
+    onLifecycleEvent("core:state_changed", listener);
+    if (timeoutMs > 0) {
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        offLifecycleEvent("core:state_changed", listener);
+        reject(new Error(`waitForReady timed out after ${timeoutMs}ms (state: ${_coreState})`));
+      }, timeoutMs);
+      if (typeof timer === "object" && "unref" in timer) {
+        timer.unref();
+      }
+    }
+  });
+}
+function getStatus() {
+  let mode;
+  if (_coreState === CoreState.PRODUCTION_DISABLED) {
+    mode = "disabled";
+  } else if (_authState === AuthState.CLAIMING || _authState === AuthState.CLAIMED) {
+    mode = "claiming";
+  } else if (_authState === AuthState.AUTHENTICATED) {
+    mode = "authenticated";
+  } else {
+    mode = "anonymous";
+  }
+  let tracing;
+  if (_otelState === OtelState.COEXISTENCE_FAILED || _otelState === OtelState.UNCONFIGURED || _otelState === OtelState.CONFIGURING) {
+    tracing = "not-configured";
+  } else if (_coreState === CoreState.ACTIVE_DEGRADED) {
+    tracing = "degraded";
+  } else if (_otelState === OtelState.AUTO_ATTACHED || _otelState === OtelState.PROCESSOR_PRESENT) {
+    tracing = "coexistence";
+  } else {
+    tracing = "active";
+  }
+  return {
+    ready: isReady(),
+    mode,
+    tracing
+  };
+}
+var _shutdownHooks = [];
+var _signalHandlersRegistered = false;
+var _signalHandler = null;
+var _beforeExitRegistered = false;
+var _beforeExitHandler = null;
+var _shutdownExecuted = false;
+function registerShutdownHook(hook) {
+  _shutdownHooks.push(hook);
+  _shutdownHooks.sort((a, b) => a.priority - b.priority);
+}
+async function executeShutdown(timeoutMs = 5e3) {
+  if (_shutdownExecuted) return;
+  _shutdownExecuted = true;
+  setCoreState(CoreState.SHUTTING_DOWN);
+  for (const hook of _shutdownHooks) {
+    try {
+      const hookPromise = hook.fn();
+      hookPromise.catch(() => {
+      });
+      await Promise.race([
+        hookPromise,
+        new Promise((_, reject) => {
+          const timer = setTimeout(() => reject(new Error(`Shutdown hook "${hook.name}" timed out`)), timeoutMs);
+          if (typeof timer === "object" && "unref" in timer) {
+            timer.unref();
+          }
+        })
+      ]);
+    } catch (err) {
+      _logger?.(
+        "warn",
+        `[glasstrace] Shutdown hook "${hook.name}" failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  setCoreState(CoreState.SHUTDOWN);
+}
+function registerSignalHandlers() {
+  if (_signalHandlersRegistered) return;
+  if (typeof process === "undefined" || typeof process.once !== "function") return;
+  _signalHandlersRegistered = true;
+  const otherSigtermListeners = process.listenerCount("SIGTERM");
+  const otherSigintListeners = process.listenerCount("SIGINT");
+  const handler = (signal) => {
+    void executeShutdown().finally(() => {
+      if (_signalHandler) {
+        process.removeListener("SIGTERM", _signalHandler);
+        process.removeListener("SIGINT", _signalHandler);
+      }
+      const otherListeners = signal === "SIGTERM" ? otherSigtermListeners : otherSigintListeners;
+      const otherProviderOwnsSignal = getCoexistenceState() === "coexisting" && otherListeners > 0;
+      if (!otherProviderOwnsSignal) {
+        process.kill(process.pid, signal);
+      }
+    });
+  };
+  _signalHandler = handler;
+  process.once("SIGTERM", handler);
+  process.once("SIGINT", handler);
+}
+function registerBeforeExitTrigger() {
+  if (_beforeExitRegistered) return;
+  if (typeof process === "undefined" || typeof process.once !== "function") return;
+  _beforeExitRegistered = true;
+  const handler = () => {
+    void executeShutdown();
+  };
+  _beforeExitHandler = handler;
+  process.once("beforeExit", handler);
+}
+
+export {
+  setCoexistenceState,
+  CoreState,
+  AuthState,
+  OtelState,
+  initLifecycle,
+  setCoreState,
+  initAuthState,
+  setAuthState,
+  setOtelState,
+  pushDegradationSource,
+  clearDegradationSource,
+  getCoreState,
+  getSdkState,
+  onLifecycleEvent,
+  emitLifecycleEvent,
+  isReady,
+  waitForReady,
+  getStatus,
+  registerShutdownHook,
+  executeShutdown,
+  registerSignalHandlers,
+  registerBeforeExitTrigger
+};
+//# sourceMappingURL=chunk-I2DVVSKW.js.map