@everfur/sdk 0.1.0

package/dist/config-CiJ0PVBB.d.ts

@@ -0,0 +1,501 @@
+import { E as EverfurResult, f as EverfurError } from './EverfurResult-D92-uL82.js';
+
+/** The closed set of frame discriminators. `unknown` is the forward-compat catch-all. */
+type FrameKind = 'accepted' | 'heartbeat' | 'delta' | 'done' | 'error' | 'analysisStarted' | 'analysisComplete' | 'unknown';
+/** One of `emergency` | `schedule_soon` | `home_care`, or null when the slot is empty. */
+type UrgencyLevel = 'emergency' | 'schedule_soon' | 'home_care';
+interface FrameBase {
+    /** SSE `id:` line value, or null for pre-stream frames emitted before the sequence counter exists. */
+    readonly lastEventId: string | null;
+    /** A terminal frame ends the stream; frames after it are dropped. */
+    readonly terminal: boolean;
+    /**
+     * The `X-Request-ID` of the HTTP response that opened this stream, hoisted onto EVERY frame so a
+     * failure discovered mid-stream still carries something a partner can quote. A stream has already
+     * returned 200 and its headers by the time an SSE error frame is written, so the frame body itself
+     * carries no request id (the contract records that gap explicitly); the header captured at open time
+     * is the only correlation handle there is.
+     *
+     * null when unavailable: the server sent no header, or the RN EventSource fallback path is in use
+     * (react-native-sse exposes no response headers to its consumer).
+     *
+     * DISTINCT from `AnalysisStartedFrame.requestId`, which is the analysis job id minted per analyze call
+     * (`chat_analysis_service.analyze_in_chat`) and travels in the frame payload, not the HTTP headers.
+     */
+    readonly serverRequestId: string | null;
+}
+/** First frame of a send. Wire: `{type:'accepted'}` OR legacy `{status:'reasoning'}`. */
+interface AcceptedFrame extends FrameBase {
+    readonly kind: 'accepted';
+    readonly streamId: string | null;
+    readonly terminal: false;
+}
+/** Keep-alive (~15s). Silent; resets client stall timers only. Wire: `{type:'heartbeat'}` OR `{heartbeat:true}`. */
+interface HeartbeatFrame extends FrameBase {
+    readonly kind: 'heartbeat';
+    readonly terminal: false;
+}
+/** One streamed token. `delta` == legacy `token`. Wire: `{type:'text.delta'}` OR `{delta}`/`{token}`. */
+interface DeltaFrame extends FrameBase {
+    readonly kind: 'delta';
+    readonly delta: string;
+    readonly terminal: false;
+}
+/** Terminal success. Wire: `{type:'done'}` OR `{done:true}` (bare-done is still terminal). */
+interface DoneFrame extends FrameBase {
+    readonly kind: 'done';
+    readonly terminal: true;
+    /** '' if the wire omitted conversation_id. */
+    readonly conversationId: string;
+    readonly messageId: string | null;
+    /**
+     * PLANE-SPECIFIC, measured 2026-08-22. Populated on the CONSUMER chat plane, whose `_sse_done` writes it
+     * onto the done payload. **Always null on the `/widget/v1` partner plane this SDK targets**: that router
+     * builds a done payload of only `{done, conversation_id, follow_up_questions}` (+ optional message_id,
+     * citations, clinical_sections) and defers `title` / urgency to a LATER `{"metadata": true}` frame — which
+     * `done`'s terminal semantics stop this parser from reading.
+     *
+     * The parse is deliberately kept: it is correct on the consumer plane, the cross-language SSE conformance
+     * vectors pin it, and these are public fields a partner may already read via `handlers.onFrame`.
+     *
+     * Do NOT "fix" this by making `done` non-terminal. The server guards the metadata yield behind
+     * `if metadata:`, so a turn with no title/urgency ends right after `done`, and this parser's EOF path
+     * would then synthesize a terminal `streamIncomplete` ERROR on every such turn — converting a working
+     * turn into a user-visible failure. If the widget plane needs urgency, the field belongs on the server's
+     * done payload, at the cost of re-serializing the 1-5s metadata generation ahead of it.
+     */
+    readonly title: string | null;
+    /**
+     * Present on the widget plane's done payload, but it carries `[]` there — the GENERATED follow-ups ride
+     * the later metadata frame (see `title`). Populated for real on the consumer plane.
+     */
+    readonly followUpQuestions: readonly string[];
+    readonly citations: readonly Record<string, unknown>[];
+    readonly citationStatus: string | null;
+    /**
+     * null = slot present but empty; absent on non-urgency turns (folded to null here).
+     * Consumer plane only in practice — see `title` for why this is always null on `/widget/v1`.
+     */
+    readonly urgencyLevel: UrgencyLevel | null;
+    /** Consumer plane only in practice — see `title`. */
+    readonly urgencyReason: string | null;
+    /** present on the terminal frame of an analyze stream. */
+    readonly resultId: string | null;
+}
+/**
+ * Terminal error. `wireMessage` is UNTRUSTED and MUST NOT reach the UI (§3).
+ * Wire: `{type:'error'}` OR `{error}`. Normalize `code` via `fromWire` (./errors/codes.ts).
+ */
+interface ErrorFrame extends FrameBase {
+    readonly kind: 'error';
+    readonly terminal: true;
+    /** raw wire code, mixed casing; normalize via `fromWire`. */
+    readonly code: string;
+    /** wire `retryable === true`. */
+    readonly retryable: boolean;
+    /** raw `error` text; telemetry/logs only, NEVER rendered. */
+    readonly wireMessage: string | null;
+    /** true when the SDK fabricated this (body ended without a terminal frame). */
+    readonly synthesized: boolean;
+}
+/** First frame of POST /analyze (skin/eye/audio). Keyed on `event`. Wire: `{event:'analysis_started'}`. */
+interface AnalysisStartedFrame extends FrameBase {
+    readonly kind: 'analysisStarted';
+    readonly requestId: string | null;
+    readonly terminal: false;
+}
+/** ML result before the AI discusses it. Wire: `{event:'analysis_complete'}`. */
+interface AnalysisCompleteFrame extends FrameBase {
+    readonly kind: 'analysisComplete';
+    readonly terminal: false;
+    readonly resultId: string | null;
+    readonly analysisType: string | null;
+    readonly modelVersion: string | null;
+    readonly confidence: number | null;
+    readonly detections: readonly Record<string, unknown>[];
+    readonly interpretation: string | null;
+}
+/**
+ * Forward-compat catch-all. A discriminator this frozen build does not recognize degrades HERE; the
+ * parser NEVER throws on an unknown `type`/`event` (sse_frame.dart:127-130). A future backend frame
+ * type must not crash an app-store-frozen client. Non-terminal, so an unknown frame never ends a stream.
+ */
+interface UnknownFrame extends FrameBase {
+    readonly kind: 'unknown';
+    readonly raw: Record<string, unknown>;
+    readonly terminal: false;
+}
+/** The ONLY frame surface the rest of the SDK consumes. */
+type Frame = AcceptedFrame | HeartbeatFrame | DeltaFrame | DoneFrame | ErrorFrame | AnalysisStartedFrame | AnalysisCompleteFrame | UnknownFrame;
+/**
+ * Exhaustiveness guard for `switch (frame.kind)`. Adding a `FrameKind` fails the build at every switch
+ * that does not handle it. The single deliberate escape is `UnknownFrame`, which every switch handles
+ * explicitly; `assertNever` is reached only for a genuinely impossible (non-additive) variant.
+ *
+ * This lives in the framework-free client layer, where a plain `throw` is permitted (the
+ * `no-throw-nonconfig` rule scopes to src/core and src/rn only).
+ */
+declare function assertNever(x: never): never;
+declare function acceptedFrame(streamId: string | null, lastEventId: string | null, serverRequestId?: string | null): AcceptedFrame;
+declare function heartbeatFrame(lastEventId: string | null, serverRequestId?: string | null): HeartbeatFrame;
+declare function deltaFrame(delta: string, lastEventId: string | null, serverRequestId?: string | null): DeltaFrame;
+declare function doneFrame(fields: Omit<DoneFrame, 'kind' | 'terminal' | 'serverRequestId'>, serverRequestId?: string | null): DoneFrame;
+declare function errorFrame(fields: {
+    code: string;
+    retryable: boolean;
+    wireMessage: string | null;
+    synthesized: boolean;
+    lastEventId: string | null;
+    serverRequestId?: string | null;
+}): ErrorFrame;
+declare function analysisStartedFrame(requestId: string | null, lastEventId: string | null, serverRequestId?: string | null): AnalysisStartedFrame;
+declare function analysisCompleteFrame(fields: Omit<AnalysisCompleteFrame, 'kind' | 'terminal' | 'serverRequestId'>, serverRequestId?: string | null): AnalysisCompleteFrame;
+declare function unknownFrame(raw: Record<string, unknown>, lastEventId: string | null, serverRequestId?: string | null): UnknownFrame;
+declare const EMPTY_FRAME_ARRAYS: Readonly<{
+    strings: readonly string[];
+    maps: readonly Record<string, unknown>[];
+}>;
+
+/**
+ * The byte-source abstraction. Any transport tier (react-native-sse, expo/fetch,
+ * buffered text) adapts to this. Interchangeable so the parser stays pure.
+ */
+type ByteSource = AsyncIterable<Uint8Array>;
+/**
+ * How the parser learns the stream's `X-Request-ID`.
+ *
+ * A plain `string | null` is the fetch path: the transport has already read the response headers before
+ * the first byte of the body, so the id is known up front. A THUNK is the RN EventSource path: the
+ * connection is opened by the adapter and its response headers only exist once the underlying XHR has
+ * reached HEADERS_RECEIVED, which happens after `parseSse` has been handed the byte source. The thunk is
+ * resolved lazily and memoized on its first non-null answer, so the id still lands on every frame the
+ * stream emits without the transport having to block on the open.
+ */
+type ServerRequestIdSource = string | null | (() => string | null);
+/**
+ * Pure: bytes in, typed frames out. Never throws; a malformed block is skipped, not fatal.
+ *
+ * Behavioral contract (identical in TS and Dart, sse_parser.dart:82-118):
+ *  1. Decode UTF-8 incrementally; split on `\n\n`; buffer a partial trailing block across chunks.
+ *  2. Per block: read optional `id:` and one-or-more `data:` lines; ignore blank / `:`-comment lines;
+ *     strip exactly one leading space after `data:`; join multi-line `data:` with `\n`; JSON.parse.
+ *  3. Dispatch is terminal-first (see frameFromWire).
+ *  4. Stop after the first terminal frame; later frames are dropped (not yielded).
+ *  5. Synthesize on incomplete: EOF with no terminal frame emits a terminal synthesized ErrorFrame.
+ *  6. A JSON parse error on one block skips that block only; the stream keeps flowing.
+ *
+ * `serverRequestId` is the `X-Request-ID` of the response that opened the stream. It is stamped onto every
+ * frame this parser emits, including the synthesized terminal errors below, because an SSE error frame
+ * carries no request id of its own: by the time the failure is known the 200 and its headers are already
+ * on the wire. On the fetch path the transport reads it BEFORE the body and passes the string; on the RN
+ * EventSource path it passes a thunk, because the adapter's response headers only become readable after
+ * the connection opens (see `ServerRequestIdSource`). Null when the adapter cannot expose one at all, which
+ * is honest: the parser never invents an id.
+ */
+declare function parseSse(bytes: ByteSource, serverRequestId?: ServerRequestIdSource): AsyncIterable<Frame>;
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+interface EverfurRequestBase {
+    readonly method: HttpMethod;
+    /** relative path, e.g. /widget/v1/entitlements; a leading slash is optional. */
+    readonly path: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly query?: Readonly<Record<string, string | number | undefined>>;
+    readonly signal?: AbortSignal;
+}
+/**
+ * One request, in exactly one body shape.
+ *
+ * `body` and `multipart` are MUTUALLY EXCLUSIVE, and that is enforced by the type rather than left to a
+ * docblock. Carrying both is not a preference but a broken request: the JSON branch would set a
+ * `content-type` without the platform-generated multipart boundary, and the server cannot parse the result.
+ * The suppression that avoids it is a single `&&` clause at three call sites, exactly the kind of line a
+ * later edit deletes as redundant -- so the illegal combination is made unrepresentable instead.
+ */
+type EverfurRequest = EverfurRequestBase & ({
+    /**
+     * JSON-serialized on EVERY path: `requestJson`, `requestRaw`, and both `stream()` branches (the
+     * fetch branch via `buildInit`, the RN EventSource branch via `buildEventSourceInit`).
+     *
+     * This line previously read "ignored by requestRaw / stream", which is false and load-bearing:
+     * `ChatController.buildSendRequest` puts the user's message in `body` and sends it over `stream()`.
+     * Believing the docblock is what produced the multipart content-type finding.
+     */
+    readonly body?: unknown;
+    readonly multipart?: undefined;
+} | {
+    readonly body?: undefined;
+    /**
+     * A multipart body, passed to `fetch` UNTOUCHED so the platform sets the `multipart/form-data`
+     * boundary itself. Nothing is JSON-serialized and no `content-type` header is set.
+     *
+     * Exists for `POST /widget/v1/conversations/{id}/analyze`, the partner plane's photo/audio analysis
+     * route, which takes a file. Every other call on this transport stays JSON.
+     */
+    readonly multipart: MultipartBody;
+});
+interface RawResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly bytes: ByteSource;
+}
+/** The port both the real transport and the MockTransport implement. Exactly two wire shapes. */
+interface TransportPort {
+    request<T>(req: EverfurRequest): Promise<EverfurResult<T>>;
+    stream(req: EverfurRequest, signal: AbortSignal): AsyncIterable<Frame>;
+}
+/**
+ * The FormData surface this layer needs. Declared structurally, like `FetchInit` and `FetchResponseLike`
+ * above, so the framework-free client depends on no DOM lib and no react-native import. A platform
+ * `FormData` satisfies it.
+ */
+interface MultipartBody {
+    append(name: string, value: unknown, fileName?: string): void;
+}
+interface FetchInit {
+    method: string;
+    headers: Record<string, string>;
+    body?: string | MultipartBody;
+    signal?: AbortSignal;
+}
+interface ReadableStreamLike {
+    getReader(): {
+        read(): Promise<{
+            done: boolean;
+            value?: Uint8Array;
+        }>;
+        cancel?(): void | Promise<void>;
+    };
+}
+interface FetchResponseLike {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly headers: {
+        get(name: string): string | null;
+        forEach?(cb: (v: string, k: string) => void): void;
+    };
+    readonly body: ReadableStreamLike | null;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+type FetchLike = (input: string, init: FetchInit) => Promise<FetchResponseLike>;
+interface TransportDeps {
+    readonly config: ResolvedClientConfig;
+    /** default globalThis.fetch; injected for tests. */
+    readonly fetchImpl?: FetchLike;
+    /**
+     * Injected EventSource factory (react-native-sse on RN, wired from the rn layer). Used ONLY when a streaming
+     * `res.body` is unavailable (stock RN fetch, >=0.74): the SSE turn streams over XHR instead of silently
+     * failing to streamIncomplete. Absent, or on web/expo where `res.body` streams, the fetch byte-source path is
+     * used unchanged. Kept as an injected seam so Layer 1 never imports react-native-sse (native-free client).
+     */
+    readonly eventSourceFactory?: EventSourceFactory;
+}
+/** expo / fetch: read a Response body (a ReadableStream of Uint8Array). */
+declare function fetchByteSource(body: ReadableStreamLike | null): ByteSource;
+/** buffered text: yield a whole SSE body, optionally split at byte offsets (drives the chunk-split vector). */
+declare function bufferedTextByteSource(text: string, splitAt?: readonly number[]): ByteSource;
+/** A minimal react-native-sse EventSource surface (parsed events), injected to keep Layer 1 native-free. */
+interface EventSourceMessage {
+    readonly lastEventId?: string | null;
+    readonly data?: string | null;
+    /**
+     * On an `error` event (react-native-sse ErrorEvent): the underlying XHR HTTP status. A non-2xx status here is
+     * a pre-stream HTTP error (401/403/429/...) that must map to the SAME terminal wire code the fetch path
+     * produces; 0 / null / undefined is a transport-level failure (no HTTP response) -> a retryable synthetic error.
+     */
+    readonly xhrStatus?: number | null;
+}
+interface EventSourceLike {
+    addEventListener(type: string, listener: (ev: EventSourceMessage) => void): void;
+    removeEventListener(type: string, listener: (ev: EventSourceMessage) => void): void;
+    close(): void;
+    /**
+     * A RESPONSE header of the connection the adapter opened, or null when it is not (yet) readable.
+     *
+     * OPTIONAL, because it is an adapter capability rather than part of the EventSource idea: react-native-sse
+     * hands its consumer parsed events only, so the rn adapter reaches the header off the XMLHttpRequest it
+     * holds. An adapter that cannot expose one simply omits this method, and the stream's frames carry a null
+     * `serverRequestId` rather than an invented value.
+     *
+     * Read LAZILY. An XHR only exposes response headers from HEADERS_RECEIVED onward, which is after the
+     * factory returned, so the transport passes a thunk to `parseSse` instead of a value.
+     */
+    getResponseHeader?(name: string): string | null;
+}
+/**
+ * Init for an injected EventSource open, a structural subset of react-native-sse's EventSourceOptions. Layer 1
+ * stays native-free: it names only the fields streamFrames sets, never the concrete react-native-sse type.
+ */
+interface EventSourceInit {
+    readonly method: string;
+    readonly headers: Record<string, string>;
+    /** JSON string; present for a POST send, absent for a bodyless stream. */
+    readonly body?: string;
+    /** Disable react-native-sse's auto-reconnect: a chat turn is a single one-shot stream, not a polling loop. */
+    readonly pollingInterval?: number;
+}
+/**
+ * Opens an EventSource for a URL. INJECTED (never imported) into Layer 1 so the client stays native-free: the
+ * concrete factory is react-native-sse in the rn layer, a fake in tests. Used only on the RN fallback path.
+ */
+type EventSourceFactory = (url: string, init: EventSourceInit) => EventSourceLike;
+/**
+ * react-native-sse: reconstruct raw SSE wire bytes from parsed EventSource events so parseSse stays the ONE
+ * frame authority (a library that pre-parses SSE is re-serialized back to `id:` / `data:` blocks here).
+ */
+declare function eventSourceByteSource(es: EventSourceLike): ByteSource;
+/**
+ * Unary JSON request. Never throws for an expected 4xx/5xx; maps it to a typed EverfurError.
+ *
+ * Every unary hop is bounded by a per-request deadline (PERF2): a stalled connection settles to a retryable
+ * `internalError` instead of hanging the caller's spinner forever. The deadline is MERGED with any caller
+ * `req.signal` (each individual attempt is bounded even under a long-lived caller signal, e.g. the poll loop),
+ * and the timer is always cleared once the fetch settles so a completed request leaves no dangling timer.
+ */
+declare function requestJson<T>(req: EverfurRequest, deps: TransportDeps): Promise<EverfurResult<T>>;
+/** Raw request for streaming. On a non-2xx it settles to an Err; on 2xx it hands back a ByteSource. */
+declare function requestRaw(req: EverfurRequest, deps: TransportDeps, byteSourceFor?: (res: FetchResponseLike) => ByteSource): Promise<EverfurResult<RawResponse>>;
+declare function createHttpTransport(deps: TransportDeps): TransportPort;
+/**
+ * Build a typed EverfurError from a response status + parsed body. Prefers the wire code over the status.
+ *
+ * `requestId` is the captured `X-Request-ID`. The raw wire code is handed through so the contract
+ * registry can resolve the row and, from it, the site-relative `docUrl`; the parsed body rides along as
+ * the non-enumerable `raw` for debugging. `retryable` is only FORCED when the body says so explicitly,
+ * otherwise it is derived from the code, which is how a registry-declared retryable code (a 503
+ * `unavailable`, say) gets its retry affordance without the caller restating the policy.
+ */
+declare function errorFromResponse(status: number, body: unknown, requestId?: string | null): EverfurError;
+/** A fetch rejection (offline / DNS): retryable internalError; the cause text is telemetry-only. */
+declare function networkError(cause: unknown): EverfurError;
+/**
+ * The `X-Request-ID` of a response, or null. Read through `headers.get`, which is case-insensitive on a
+ * real `Headers`; an injected fetch whose header bag is a plain object is expected to match the same
+ * lowercase spelling the rest of this file uses.
+ */
+/**
+ * The `X-Request-ID` of a completed response, or null.
+ *
+ * Exported so the server-side session mint reuses this one implementation. The mint runs on the
+ * partner's backend and deliberately does NOT go through the device funnel (that funnel enforces the
+ * bearer-XOR-publishable-key device rule, which has no meaning server-side), but a failed mint still
+ * needs a request id a partner can quote in a support ticket.
+ */
+declare function requestIdOf(res: FetchResponseLike): string | null;
+/**
+ * The `X-Request-ID` of an open EventSource connection, or null.
+ *
+ * The EventSource counterpart of `requestIdOf`. Null in three honest cases, none of them an error: the
+ * adapter exposes no header accessor at all, the response headers have not landed yet, or the server sent
+ * no id. Defensive around the accessor because it reaches into a native XHR: a throwing adapter must
+ * degrade to "no id", never take the stream down.
+ */
+declare function eventSourceRequestId(es: EventSourceLike): string | null;
+declare function getGlobalFetch(): FetchLike;
+
+/**
+ * Package semver, sent as X-Everfur-SDK-Version. MUST track package.json version (release checklist Item 12
+ * keeps the npm semver tag and this constant in lockstep). Set inside the SDK, never by partner code.
+ */
+declare const SDK_VERSION = "0.1.0";
+/** Sent as X-Everfur-SDK-Platform. */
+declare const SDK_PLATFORM = "react-native";
+/** Dated wire contract axis (SPEC-00 §4.2). Server is additive-only. Override via config.contractVersion. */
+declare const DEFAULT_CONTRACT_VERSION = "2026-08-01";
+/** The environment variable the base URL is derived from when config.apiBaseUrl is absent. */
+declare const ENV_API_BASE_URL = "EVERFUR_API_BASE_URL";
+interface EverfurConfig {
+    /** pk_live_... ; tenant-resolved server-side. The keyless-fallback (anonymous-mode) credential. */
+    readonly publishableKey: string;
+    /** REQUIRED via config or EVERFUR_API_BASE_URL; no hardcoded host default (INV-ORG-AGNOSTIC). */
+    readonly apiBaseUrl?: string;
+    /** Sent as X-Everfur-Contract; server additive-only. Defaults to DEFAULT_CONTRACT_VERSION. */
+    readonly contractVersion?: string;
+    /** Test seam; production builds the real transport from apiBaseUrl. */
+    readonly transport?: TransportPort;
+    /** Structured, redacted LogPort events when true. */
+    readonly debug?: boolean;
+}
+/**
+ * The validated, frozen subset the Layer 1 transport / identity actually consume.
+ */
+interface ResolvedClientConfig {
+    readonly publishableKey: string;
+    /** normalized absolute URL, no trailing slash */
+    readonly apiBaseUrl: string;
+    readonly contractVersion: string;
+    readonly sdkVersion: string;
+    readonly platform: string;
+    readonly debug: boolean;
+}
+/**
+ * CONFIG FAILURE IS A VALUE, NOT A THROW.
+ *
+ * Every check has exactly one implementation, in `tryResolveClientConfig`, which SETTLES to an outcome.
+ * `resolveClientConfig` is a thin throwing wrapper over it and preserves the historical messages
+ * verbatim, so a caller that wants fail-fast keeps it, while `EverfurProvider` can instead build a
+ * DISABLED runtime and still render children. SPEC-10 §8 already establishes non-throwing init: see
+ * `core/bootstrap.ts`, "A failure is a VALUE, not a throw".
+ *
+ * Why this matters in a RELEASE build: `babel-preset-expo` inlines only `EXPO_PUBLIC_*`, so a partner
+ * who sets a correctly-named but unprefixed variable ships a bundle where `EVERFUR_API_BASE_URL` is
+ * absent at runtime. Every local check passed. The throw then lands inside the provider's own render,
+ * ABOVE every error boundary the partner can install, which is a white screen with no diagnostic.
+ */
+type ClientConfigFailureReason = 'missing-publishable-key' | 'secret-key-as-publishable-key' | 'missing-api-base-url' | 'malformed-api-base-url' | 'insecure-api-base-url' | 'unsupported-api-base-url-scheme';
+interface ClientConfigFailure {
+    readonly reason: ClientConfigFailureReason;
+    /**
+     * Developer-facing copy. Names the field and how to supply it, and NEVER carries a credential.
+     *
+     * This is load-bearing, not decorative: `reportConfigFailure` prints this string to `console.error` on
+     * every mount, and on React Native `console.error` is captured as breadcrumbs by Sentry / Crashlytics /
+     * Bugsnag and written to logcat and the Xcode device log. So the URL branches echo a REDACTED ORIGIN
+     * (`scheme://host`) built by `safeOrigin`, never the raw value: a raw base URL can carry userinfo
+     * (`http://svc:s3cr3t@internal.example.com`), and cleartext-with-basic-auth is exactly the shape that
+     * lands in the insecure branch. The malformed branch echoes nothing at all, because an unparseable value
+     * is most often a mis-paste of something else, such as a key.
+     */
+    readonly message: string;
+}
+type ClientConfigOutcome = {
+    readonly ok: true;
+    readonly config: ResolvedClientConfig;
+} | {
+    readonly ok: false;
+    readonly failure: ClientConfigFailure;
+};
+type BaseUrlOutcome = {
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly failure: ClientConfigFailure;
+};
+/**
+ * The ONE implementation of the publishable-key rule. Exported because the runtime validates the key even
+ * on the injected-transport path, where the base URL is not required and `tryResolveClientConfig` is
+ * therefore never called; without this both places would carry a copy and drift.
+ */
+declare function checkPublishableKey(raw: unknown): ClientConfigFailure | null;
+/** Validate the partner-supplied config into the frozen client subset. Settles; never throws. */
+declare function tryResolveClientConfig(config: EverfurConfig): ClientConfigOutcome;
+/**
+ * Validate the partner-supplied config into the frozen client subset. Throws EverfurConfigError
+ * synchronously for programmer error (missing publishableKey, unresolvable/invalid base URL) -- never for
+ * network/domain failure. Prefer `tryResolveClientConfig` wherever a blank screen is the alternative.
+ */
+declare function resolveClientConfig(config: EverfurConfig): ResolvedClientConfig;
+/**
+ * Resolve the base URL from (in order) an explicit value then EVERFUR_API_BASE_URL, then normalize.
+ * Settles; never throws. There is deliberately no hardcoded host default (INV-ORG-AGNOSTIC).
+ */
+declare function tryResolveApiBaseUrl(apiBaseUrl?: string): BaseUrlOutcome;
+/** Resolve the base URL, throwing on failure. Thin wrapper over `tryResolveApiBaseUrl`. */
+declare function resolveApiBaseUrl(apiBaseUrl?: string): string;
+/** The always-on SDK protocol headers (version / platform / contract). Set inside the transport only. */
+declare function buildBaseHeaders(cfg: Pick<ResolvedClientConfig, 'sdkVersion' | 'platform' | 'contractVersion'>): Record<string, string>;
+
+export { fetchByteSource as $, type AcceptedFrame as A, type ByteSource as B, type ClientConfigFailure as C, DEFAULT_CONTRACT_VERSION as D, type EverfurRequest as E, type Frame as F, type UrgencyLevel as G, type HeartbeatFrame as H, acceptedFrame as I, analysisCompleteFrame as J, analysisStartedFrame as K, assertNever as L, type MultipartBody as M, bufferedTextByteSource as N, buildBaseHeaders as O, checkPublishableKey as P, createHttpTransport as Q, type RawResponse as R, SDK_PLATFORM as S, type TransportPort as T, type UnknownFrame as U, deltaFrame as V, doneFrame as W, errorFrame as X, errorFromResponse as Y, eventSourceByteSource as Z, eventSourceRequestId as _, type FetchLike as a, getGlobalFetch as a0, heartbeatFrame as a1, networkError as a2, parseSse as a3, requestIdOf as a4, requestJson as a5, requestRaw as a6, resolveApiBaseUrl as a7, resolveClientConfig as a8, tryResolveApiBaseUrl as a9, tryResolveClientConfig as aa, unknownFrame as ab, type AnalysisCompleteFrame as b, type AnalysisStartedFrame as c, type ClientConfigFailureReason as d, type ClientConfigOutcome as e, type DeltaFrame as f, type DoneFrame as g, EMPTY_FRAME_ARRAYS as h, ENV_API_BASE_URL as i, type ErrorFrame as j, type EventSourceFactory as k, type EventSourceInit as l, type EventSourceLike as m, type EventSourceMessage as n, type EverfurConfig as o, type EverfurRequestBase as p, type FetchInit as q, type FetchResponseLike as r, type FrameBase as s, type FrameKind as t, type HttpMethod as u, type ReadableStreamLike as v, type ResolvedClientConfig as w, SDK_VERSION as x, type ServerRequestIdSource as y, type TransportDeps as z };