@hue-run/sdk 0.1.4 → 0.1.5

package/README.md

@@ -93,7 +93,7 @@ Reuse the client across server requests. Await stream completion before flushing
 returning a streaming `Response` does not mean its stream has finished. The
 [Next.js streaming recipe](https://docs.hue.run/integrations/opentelemetry#flush-streamed-responses-in-next-js)
 shows how to keep completion and flushing within the request's background lifetime.
-For a standalone script, put the operation in `try` and call `await hue.shutdown()`
+For a standalone script, put the operation in `try` and call `await hue.shutdownSafe()`
 in `finally`. Shut down a shared server client only when the application stops.
 
 The integration creates real Vercel provider, streaming and tool spans and passes
@@ -117,8 +117,7 @@ names cannot be classified automatically; use them deliberately.
 there is no SDK retention timer or automatic content expiry. To redact strings
 before export, supply `redact(value, path)`; it applies to supported strings in
 attributes, resources, event/link attributes and log bodies. Return a string.
-A throwing callback or invalid/oversized content fails closed: that record is
-counted as failed and the flush reports it. Shared resources are redacted once per
+Invalid/oversized helper content is omitted with an instrumentation failure; the span can still be delivered. Export-time redactor failures reject the affected record and are reported by flush. Shared resources are redacted once per
 export batch. Do not put user content or secrets in span names or scope names.
 
 Manual helpers encode JSON values without converting null into absence. Unknown
@@ -165,7 +164,7 @@ flush. This is an in-memory queue, not durable storage.
 
 `flush()` waits for the current trace and log export work. A partial rejection,
 invalid acknowledgement, queue drop or failure throws `HueExportError`; its
-`report` contains cumulative accepted/rejected/failed/pending counts. Accepted
+`report` contains cumulative accepted/rejected/failed counts and current pending gauges. Accepted
 means the collector acknowledged receipt, not that a complete trace has arrived.
 A malformed response reports uncertain acceptance as failure. Partial successes
 are not retried. Warning-only acknowledgements with zero rejected records remain
@@ -255,3 +254,11 @@ Use a 120-second host request limit for the default 90-second execution and
 See the [managed-run guide](https://docs.hue.run/evaluations/managed-runs) and the
 [full adapter contract](MANAGED_TARGETS.md) for registration, file handling,
 existing-provider flush callbacks and recovery. Local/CI runners remain available.
+
+## Serving safely
+
+Use `createHueSafe(options)` for best-effort startup. Invalid initialization returns a disabled client with an instrumentation failure recorded. Pass `enabled: false` to disable Hue without a key; disabled helpers still execute the application callback. `flushSafe({ timeoutMillis: 1000 })` and `shutdownSafe({ timeoutMillis: 1000 })` return `{ ok, timedOut, report }` without rejecting. Strict initialization, connection checks and `flush()` remain available for diagnostics; do not gate application readiness or responses on them.
+
+Capture/serialization/redaction/provider failures omit unsafe telemetry, record failures, and preserve the original business result/error. Async diagnostic rejections are contained; diagnostics are rate-limited. The default `maxQueueBytes` is 8 MiB across traces/logs including in-flight work, alongside the existing record cap. `pendingBytes` is a current queue gauge; `droppedSpans`, `droppedLogs` and `instrumentationFailures` are cumulative failure counters. This is a telemetry budget, not a total process memory ceiling. A timeout bounds the caller and does not cancel a borrowed provider. Never retry the business operation to recover telemetry. See [production safety](https://docs.hue.run/guides/production-safety).
+
+Queued records snapshot supported telemetry values when a span ends or a log is emitted; later caller mutations cannot change queued data. Resource attributes still awaiting detection are omitted with a sanitized warning. Later records include them after detection finishes; await resource detection before instrumentation when those attributes are required.

package/dist/ai-sdk.js

@@ -1,10 +1,19 @@
 import { OpenTelemetry } from "@ai-sdk/otel";
 /** Use as the call's telemetry option; it does not change global AI SDK integrations. */
 export function hueTelemetry(hue) {
+    // Core tracing also installs beside AI SDK 6. This adapter requires the v7
+    // per-call integration API; fail explicitly during configuration on v6.
+    if (hue.enabled) {
+        const { version } = createRequire(import.meta.url)("ai/package.json");
+        const [major, minor, patch] = version.split(".").map(Number);
+        if (major !== 7 || (minor === 0 && patch < 99))
+            throw new TypeError("hueTelemetry requires ai@^7.0.99; AI SDK 6 applications can use Hue core tracing with their existing OpenTelemetry integration");
+    }
     return {
-        isEnabled: true,
+        isEnabled: hue.enabled,
         recordInputs: hue.captureContent,
         recordOutputs: hue.captureContent,
         integrations: [new OpenTelemetry({ tracer: hue.tracer, usage: true })],
     };
 }
+import { createRequire } from "node:module";

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { type Context, type Span, type Tracer } from "@opentelemetry/api";
 import { HueTransport } from "./transport.js";
-import type { ExportReport, FlushableLoggerProvider, FlushableTracerProvider, HueOptions, HueSpan, JsonValue, ProjectConnection, SpanOptions, VerifyTraceOptions, TraceVerification } from "./types.js";
+import type { ExportReport, FlushableLoggerProvider, FlushableTracerProvider, HueOptions, HueSpan, JsonValue, ProjectConnection, SpanOptions, VerifyTraceOptions, TraceVerification, SafeLifecycleOptions, SafeLifecycleResult } from "./types.js";
 export interface ExistingHueProviders {
     transport: HueTransport;
     tracerProvider: FlushableTracerProvider;
@@ -14,6 +14,7 @@ export declare class HueClient {
     readonly transport: HueTransport;
     readonly tracer: Tracer;
     readonly captureContent: boolean;
+    readonly enabled: boolean;
     private logger;
     private storage;
     private tracerProvider;
@@ -22,6 +23,8 @@ export declare class HueClient {
     private closed;
     private shutdownPromise?;
     private flushPromise?;
+    private safeFlushPromise?;
+    private safeShutdownPromise?;
     constructor(options: HueOptions | ExistingHueProviders);
     verifyTrace(traceId: string, options?: VerifyTraceOptions): Promise<TraceVerification>;
     getContext(): Context;
@@ -34,8 +37,15 @@ export declare class HueClient {
     }, explicitContext?: Context): void;
     private setContent;
     checkConnection(): Promise<ProjectConnection>;
+    /** Production lifecycle path: never rejects; timeouts do not cancel borrowed provider work. */
+    flushSafe(options?: SafeLifecycleOptions): Promise<SafeLifecycleResult>;
+    /** Safe for finally blocks; preserves the application's result or original exception. */
+    shutdownSafe(options?: SafeLifecycleOptions): Promise<SafeLifecycleResult>;
+    private safeLifecycle;
     flush(): Promise<ExportReport>;
     private flushOnce;
     shutdown(): Promise<ExportReport>;
 }
 export declare function createHue(options: HueOptions | ExistingHueProviders): HueClient;
+/** Fail-open initialization for production; strict createHue remains available for setup/CI. */
+export declare function createHueSafe(options: HueOptions | ExistingHueProviders): HueClient;

package/dist/client.js

@@ -1,10 +1,10 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { context, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { context, ROOT_CONTEXT, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
 import { TracerProvider } from "@opentelemetry/sdk-trace";
 import { resourceFromAttributes } from "@opentelemetry/resources";
-import { MAX_CONTENT_BYTES } from "./config.js";
+import { encodeContent, noopSpan, safeSpan } from "./safety.js";
 import { createHueTransport, HueExportError } from "./transport.js";
 import { verifyTrace } from "./receipt.js";
 export class HueConnectionError extends Error {
@@ -30,20 +30,32 @@ function identifier(value) {
 class ContextualTracer {
     source;
     storage;
-    constructor(source, storage) {
+    enabled;
+    failed;
+    constructor(source, storage, enabled, failed) {
         this.source = source;
         this.storage = storage;
+        this.enabled = enabled;
+        this.failed = failed;
     }
     startSpan(name, options = {}, parent) {
-        const active = this.storage.getStore();
-        return this.source.startSpan(name, {
-            ...options,
-            attributes: {
-                ...options.attributes,
-                ...(active?.sessionId ? { "gen_ai.conversation.id": active.sessionId } : {}),
-                ...(active?.userId ? { "user.id": active.userId } : {}),
-            },
-        }, parent ?? active?.context ?? context.active());
+        if (!this.enabled())
+            return noopSpan();
+        try {
+            const active = this.storage.getStore();
+            return safeSpan(this.source.startSpan(name, {
+                ...options,
+                attributes: {
+                    ...options.attributes,
+                    ...(active?.sessionId ? { "gen_ai.conversation.id": active.sessionId } : {}),
+                    ...(active?.userId ? { "user.id": active.userId } : {}),
+                },
+            }, parent ?? active?.context ?? context.active()), this.failed);
+        }
+        catch {
+            this.failed();
+            return noopSpan();
+        }
     }
     startActiveSpan(name, optionsOrFn, contextOrFn, fn) {
         const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
@@ -54,17 +66,33 @@ class ContextualTracer {
                 : fn;
         if (!callback)
             throw new TypeError("A span callback is required");
-        const parent = typeof contextOrFn === "object"
-            ? contextOrFn
-            : (this.storage.getStore()?.context ?? context.active());
+        let parent = ROOT_CONTEXT;
+        try {
+            parent =
+                typeof contextOrFn === "object"
+                    ? contextOrFn
+                    : (this.storage.getStore()?.context ?? context.active());
+        }
+        catch {
+            this.failed();
+        }
         const span = this.startSpan(name, options, parent);
-        return this.storage.run({ ...this.storage.getStore(), context: trace.setSpan(parent, span) }, () => callback(span));
+        let active = ROOT_CONTEXT;
+        try {
+            active = trace.setSpan(parent, span);
+        }
+        catch {
+            this.failed();
+            active = trace.setSpan(ROOT_CONTEXT, span);
+        }
+        return this.storage.run({ ...this.storage.getStore(), context: active }, () => callback(span));
     }
 }
 export class HueClient {
     transport;
     tracer;
     captureContent;
+    enabled;
     logger;
     storage = new AsyncLocalStorage();
     tracerProvider;
@@ -73,6 +101,8 @@ export class HueClient {
     closed = false;
     shutdownPromise;
     flushPromise;
+    safeFlushPromise;
+    safeShutdownPromise;
     constructor(options) {
         if ("transport" in options) {
             this.transport = options.transport;
@@ -87,59 +117,87 @@ export class HueClient {
             });
             const tracer = new TracerProvider({
                 resource,
-                spanProcessors: [this.transport.spanProcessor],
+                spanProcessors: this.transport.options.enabled === false ? [] : [this.transport.spanProcessor],
             });
             const logger = new LoggerProvider({
                 resource,
-                processors: [this.transport.logRecordProcessor],
+                processors: this.transport.options.enabled === false ? [] : [this.transport.logRecordProcessor],
             });
             this.ownedProviders = { tracer, logger };
             this.tracerProvider = tracer;
             this.loggerProvider = logger;
         }
         this.captureContent = this.transport.options.captureContent;
-        this.tracer = new ContextualTracer(this.tracerProvider.getTracer("@hue-run/sdk", "0.1.4"), this.storage);
-        this.logger = this.loggerProvider.getLogger("@hue-run/sdk", "0.1.4");
+        this.enabled = this.transport.options.enabled !== false;
+        this.tracer = new ContextualTracer(this.tracerProvider.getTracer("@hue-run/sdk", "0.1.5"), this.storage, () => this.enabled && !this.closed, () => this.transport.instrumentationFailure());
+        this.logger = this.loggerProvider.getLogger("@hue-run/sdk", "0.1.5");
     }
     verifyTrace(traceId, options = {}) {
+        if (!this.enabled)
+            return Promise.reject(new HueConnectionError("Hue telemetry is disabled"));
         return verifyTrace(this.transport.options, traceId, options);
     }
     getContext() {
-        return this.storage.getStore()?.context ?? context.active();
+        try {
+            return this.storage.getStore()?.context ?? context.active();
+        }
+        catch {
+            this.transport.instrumentationFailure();
+            return ROOT_CONTEXT;
+        }
     }
     async withSpan(name, callback, options = {}) {
-        if (this.closed)
-            throw new Error("Hue client is shut down");
-        const inherited = this.storage.getStore();
-        const sessionId = identifier(options.sessionId ?? inherited?.sessionId);
-        const userId = identifier(options.userId ?? inherited?.userId);
-        const parent = options.parentContext ?? inherited?.context ?? context.active();
-        const active = { context: parent, sessionId, userId };
-        return this.storage.run(active, async () => {
-            const span = this.tracer.startSpan(name, { kind: options.kind ?? SpanKind.INTERNAL, attributes: options.attributes }, parent);
-            const spanContext = trace.setSpan(parent, span);
-            const handle = {
-                span,
-                context: spanContext,
-                traceId: span.spanContext().traceId,
-                spanId: span.spanContext().spanId,
-                setInput: (value) => this.setContent(span, "input.value", value),
-                setOutput: (value) => this.setContent(span, "output.value", value),
-            };
-            return this.storage.run({ ...active, context: spanContext }, async () => {
-                try {
-                    if (options.input !== undefined)
-                        handle.setInput(options.input);
-                    return await callback(handle);
-                }
-                catch (error) {
-                    this.recordError(span, error);
-                    throw error;
-                }
-                finally {
-                    span.end();
-                }
-            });
+        let span = noopSpan();
+        let active = { context: this.getContext() };
+        if (this.enabled && !this.closed) {
+            try {
+                const inherited = this.storage.getStore();
+                active = {
+                    context: options.parentContext ?? inherited?.context ?? context.active(),
+                    sessionId: identifier(options.sessionId ?? inherited?.sessionId),
+                    userId: identifier(options.userId ?? inherited?.userId),
+                };
+                span = this.storage.run(active, () => this.tracer.startSpan(name, { kind: options.kind ?? SpanKind.INTERNAL, attributes: options.attributes }, active.context));
+            }
+            catch {
+                this.transport.instrumentationFailure();
+            }
+        }
+        let spanContext;
+        try {
+            spanContext = trace.setSpan(active.context, span);
+        }
+        catch {
+            this.transport.instrumentationFailure();
+            spanContext = trace.setSpan(ROOT_CONTEXT, span);
+        }
+        const handle = {
+            span,
+            context: spanContext,
+            traceId: span.spanContext().traceId,
+            spanId: span.spanContext().spanId,
+            setInput: (value) => this.setContent(span, "input.value", value),
+            setOutput: (value) => this.setContent(span, "output.value", value),
+        };
+        return this.storage.run({ ...active, context: spanContext }, async () => {
+            // Setup, capture and cleanup have separate failure boundaries from customer code.
+            try {
+                if (this.enabled && !this.closed && options.input !== undefined)
+                    handle.setInput(options.input);
+            }
+            catch {
+                this.transport.instrumentationFailure();
+            }
+            try {
+                return await callback(handle);
+            }
+            catch (error) {
+                this.recordError(span, error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
         });
     }
     async tool(name, input, execute) {
@@ -152,56 +210,66 @@ export class HueClient {
         }, { attributes: { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": name } });
     }
     recordError(span, error) {
-        const type = error instanceof Error ? error.name : "Error";
-        span.setStatus({
-            code: SpanStatusCode.ERROR,
-            ...(this.captureContent
-                ? { message: error instanceof Error ? error.message : "Operation failed" }
-                : {}),
-        });
-        span.addEvent("exception", {
-            "exception.type": type,
-            ...(this.captureContent && error instanceof Error
-                ? {
-                    "exception.message": error.message,
-                    ...(error.stack ? { "exception.stacktrace": error.stack } : {}),
-                }
-                : {}),
-        });
+        if (!this.enabled || this.closed)
+            return;
+        try {
+            const type = error instanceof Error ? error.name : "Error";
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                ...(this.captureContent
+                    ? { message: error instanceof Error ? error.message : "Operation failed" }
+                    : {}),
+            });
+            span.addEvent("exception", {
+                "exception.type": type,
+                ...(this.captureContent && error instanceof Error
+                    ? {
+                        "exception.message": error.message,
+                        ...(error.stack ? { "exception.stacktrace": error.stack } : {}),
+                    }
+                    : {}),
+            });
+        }
+        catch {
+            this.transport.instrumentationFailure();
+        }
     }
     recordMessages(messages, explicitContext) {
-        if (this.closed)
-            throw new Error("Hue client is shut down");
-        if (!this.captureContent)
+        if (!this.enabled || this.closed || !this.captureContent)
             return;
-        const active = explicitContext ?? this.getContext();
-        if (!trace.getSpanContext(active))
-            throw new Error("Message records require an active span or explicit span context");
-        const body = {};
-        if (messages.input !== undefined)
-            body["gen_ai.input.messages"] = messages.input;
-        if (messages.output !== undefined)
-            body["gen_ai.output.messages"] = messages.output;
-        this.logger.emit({
-            context: active,
-            severityNumber: SeverityNumber.INFO,
-            eventName: "gen_ai.client.inference.operation.details",
-            body,
-        });
+        try {
+            const active = explicitContext ?? this.getContext();
+            if (!trace.getSpanContext(active))
+                throw new Error("Message records require an active span or explicit span context");
+            const body = {};
+            if (messages.input !== undefined)
+                body["gen_ai.input.messages"] = messages.input;
+            if (messages.output !== undefined)
+                body["gen_ai.output.messages"] = messages.output;
+            this.logger.emit({
+                context: active,
+                severityNumber: SeverityNumber.INFO,
+                eventName: "gen_ai.client.inference.operation.details",
+                body: JSON.parse(encodeContent(body)),
+            });
+        }
+        catch {
+            this.transport.instrumentationFailure("logs");
+        }
     }
     setContent(span, key, value) {
-        if (!this.captureContent)
+        if (!this.enabled || this.closed || !this.captureContent)
             return;
-        const encoded = JSON.stringify(value, (_key, item) => {
-            if (typeof item === "number" && !Number.isFinite(item))
-                throw new TypeError("Captured JSON numbers must be finite");
-            return item;
-        });
-        if (encoded === undefined || Buffer.byteLength(encoded) > MAX_CONTENT_BYTES)
-            throw new RangeError("Captured content must be JSON and no more than 256 KiB");
-        span.setAttribute(key, encoded);
+        try {
+            span.setAttribute(key, encodeContent(value));
+        }
+        catch {
+            this.transport.instrumentationFailure();
+        }
     }
     async checkConnection() {
+        if (!this.enabled)
+            throw new HueConnectionError("Hue telemetry is disabled");
         const options = this.transport.options;
         let response;
         try {
@@ -258,6 +326,62 @@ export class HueClient {
             throw new HueConnectionError("Hue returned an invalid project response");
         }
     }
+    /** Production lifecycle path: never rejects; timeouts do not cancel borrowed provider work. */
+    flushSafe(options = {}) {
+        if (this.safeFlushPromise)
+            return this.safeFlushPromise;
+        const work = this.flushPromise ?? this.flush();
+        const result = this.safeLifecycle(() => work, options);
+        this.safeFlushPromise = result;
+        const clear = () => {
+            this.safeFlushPromise = undefined;
+        };
+        // Retain the timed-out result until its underlying drain settles. Repeated
+        // timeouts must not accumulate promises against a hung borrowed provider.
+        void work.then(clear, clear);
+        return result;
+    }
+    /** Safe for finally blocks; preserves the application's result or original exception. */
+    shutdownSafe(options = {}) {
+        if (this.safeShutdownPromise)
+            return this.safeShutdownPromise;
+        const work = this.shutdown();
+        const result = this.safeLifecycle(() => work, options);
+        this.safeShutdownPromise = result;
+        const clear = () => {
+            this.safeShutdownPromise = undefined;
+        };
+        void work.then(clear, clear);
+        return result;
+    }
+    async safeLifecycle(work, options) {
+        let timer;
+        try {
+            const timeout = options.timeoutMillis ?? 1000;
+            if (!Number.isInteger(timeout) || timeout < 1 || timeout > 60000)
+                throw new TypeError("Invalid lifecycle budget");
+            const outcome = await Promise.race([
+                work().then(() => "complete"),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve("timeout"), timeout);
+                }),
+            ]);
+            const report = this.transport.getReport();
+            return {
+                ok: outcome === "complete" &&
+                    this.transport.getFailureSequence() === 0 &&
+                    report.pendingSpans + report.pendingLogs === 0,
+                timedOut: outcome === "timeout",
+                report,
+            };
+        }
+        catch {
+            return { ok: false, timedOut: false, report: this.transport.getReport() };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     flush() {
         // Each caller needs a drain after its own preceding span/log emissions.
         // Joining an earlier drain can acknowledge records that were not in its batch.
@@ -281,8 +405,8 @@ export class HueClient {
     }
     async flushOnce() {
         const results = await Promise.allSettled([
-            this.tracerProvider.forceFlush(),
-            this.loggerProvider.forceFlush(),
+            Promise.resolve().then(() => this.tracerProvider.forceFlush()),
+            Promise.resolve().then(() => this.loggerProvider.forceFlush()),
         ]);
         for (const [index, result] of results.entries())
             if (result.status === "rejected")
@@ -311,3 +435,14 @@ export class HueClient {
 export function createHue(options) {
     return new HueClient(options);
 }
+/** Fail-open initialization for production; strict createHue remains available for setup/CI. */
+export function createHueSafe(options) {
+    try {
+        return new HueClient(options);
+    }
+    catch {
+        const disabled = new HueClient({ enabled: false, captureContent: false });
+        disabled.transport.instrumentationFailure();
+        return disabled;
+    }
+}

package/dist/config.d.ts

@@ -1,4 +1,4 @@
 import type { HueOptions } from "./types.js";
 export declare const MAX_BODY_BYTES: number;
 export declare const MAX_CONTENT_BYTES: number;
-export declare function validateOptions(options: HueOptions): Required<Pick<HueOptions, "apiKey" | "serviceName" | "baseUrl" | "captureContent" | "timeoutMillis">> & HueOptions;
+export declare function validateOptions(options: HueOptions): Required<Pick<HueOptions, "apiKey" | "serviceName" | "baseUrl" | "captureContent" | "timeoutMillis" | "maxQueueBytes">> & HueOptions;

package/dist/config.js

@@ -3,6 +3,18 @@ export const MAX_CONTENT_BYTES = 256 * 1024;
 export function validateOptions(options) {
     if (typeof options.captureContent !== "boolean")
         throw new TypeError("Choose captureContent explicitly: true or false");
+    if (options.enabled !== undefined && typeof options.enabled !== "boolean")
+        throw new TypeError("enabled must be a boolean");
+    if (options.enabled === false)
+        return {
+            captureContent: options.captureContent,
+            enabled: false,
+            apiKey: "",
+            serviceName: "hue-disabled",
+            baseUrl: "https://app.hue.run",
+            timeoutMillis: 10000,
+            maxQueueBytes: 8 * 1024 * 1024,
+        };
     if (typeof options.apiKey !== "string" ||
         !options.apiKey ||
         options.apiKey.length > 4096 ||
@@ -28,5 +40,10 @@ export function validateOptions(options) {
     const timeoutMillis = options.timeoutMillis ?? 10000;
     if (!Number.isInteger(timeoutMillis) || timeoutMillis < 100 || timeoutMillis > 60000)
         throw new TypeError("timeoutMillis must be 100–60000");
-    return { ...options, baseUrl: url.origin, timeoutMillis };
+    const maxQueueBytes = options.maxQueueBytes ?? 8 * 1024 * 1024;
+    if (!Number.isSafeInteger(maxQueueBytes) ||
+        maxQueueBytes < 1024 ||
+        maxQueueBytes > 64 * 1024 * 1024)
+        throw new TypeError("maxQueueBytes must be 1024–67108864");
+    return { ...options, baseUrl: url.origin, timeoutMillis, maxQueueBytes };
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { createHue, HueClient, HueConnectionError, type ExistingHueProviders } from "./client.js";
+export { createHue, createHueSafe, HueClient, HueConnectionError, type ExistingHueProviders, } from "./client.js";
 export { createHueTransport, HueTransport, HueExportError } from "./transport.js";
 export { HueTraceVerificationError } from "./receipt.js";
 export type * from "./types.js";

package/dist/index.js

@@ -1,3 +1,3 @@
-export { createHue, HueClient, HueConnectionError } from "./client.js";
+export { createHue, createHueSafe, HueClient, HueConnectionError, } from "./client.js";
 export { createHueTransport, HueTransport, HueExportError } from "./transport.js";
 export { HueTraceVerificationError } from "./receipt.js";