@kaana.ai/sdk 0.0.0-stage → 1.0.0

package/dist/realtime.js

@@ -0,0 +1,322 @@
+/** `GET /v1/realtime`: one WebSocket session, resumable, settled once on close. */
+import { KAANA_REALTIME_BEARER_PROTOCOL_PREFIX, KAANA_REALTIME_SUBPROTOCOL, KAANA_REALTIME_USER_PROTOCOL_PREFIX, modelReferenceSchema, realtimeClientCommandSchema, realtimePublicServerEventSchema, realtimeSessionOpenSchema, } from '@kaana.ai/contracts';
+import { encodeBase64, encodeBase64Url, utf8 } from './base64.js';
+import { cancelledByCaller, clientRefusal, fromPublicError, KaanaConnectionError, KaanaProtocolError, } from './errors.js';
+import { deferred } from './stream.js';
+/** The most audio one `input_audio.append` frame carries. */
+export const MAX_REALTIME_AUDIO_FRAME_BYTES = 49_152;
+class EventQueue {
+    #entries = [];
+    #waiters = [];
+    #ended = false;
+    push(entry) {
+        if (this.#ended)
+            return;
+        if (entry.kind === 'end')
+            this.#ended = true;
+        const waiter = this.#waiters.shift();
+        if (waiter !== undefined)
+            waiter(entry);
+        else
+            this.#entries.push(entry);
+        if (this.#ended) {
+            for (const pending of this.#waiters.splice(0))
+                pending({ kind: 'end' });
+        }
+    }
+    take() {
+        const entry = this.#entries.shift();
+        if (entry !== undefined)
+            return Promise.resolve(entry);
+        if (this.#ended)
+            return Promise.resolve({ kind: 'end' });
+        return new Promise((resolve) => this.#waiters.push(resolve));
+    }
+}
+export async function connectRealtime(transport, request, options) {
+    const { model, ...open } = request;
+    if (!modelReferenceSchema.safeParse(model).success) {
+        throw clientRefusal('model', 'realtime.connect needs a model reference publisher/model[@revision]');
+    }
+    const parsed = realtimeSessionOpenSchema.safeParse(open);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        throw clientRefusal(issue?.path.map(String).join('.') || 'session', issue?.message ?? 'invalid');
+    }
+    const WebSocketImpl = transport.WebSocket;
+    if (typeof WebSocketImpl !== 'function') {
+        throw new TypeError('Kaana: no WebSocket is available; pass options.WebSocket');
+    }
+    const credential = await transport.credential();
+    const protocols = [
+        KAANA_REALTIME_SUBPROTOCOL,
+        `${KAANA_REALTIME_BEARER_PROTOCOL_PREFIX}${encodeBase64Url(utf8(credential))}`,
+    ];
+    if (options.onBehalfOfUserId !== undefined) {
+        protocols.push(`${KAANA_REALTIME_USER_PROTOCOL_PREFIX}${encodeBase64Url(utf8(options.onBehalfOfUserId))}`);
+    }
+    const url = `${transport.baseURL.replace(/^http/, 'ws')}/realtime?${new URLSearchParams({ model })}`;
+    const session = new Session(WebSocketImpl, url, protocols, options.timeoutMs ?? transport.timeoutMs);
+    await session.open(JSON.stringify(open), options.signal);
+    return session;
+}
+class Session {
+    #WebSocket;
+    #url;
+    #protocols;
+    #timeoutMs;
+    #queue = new EventQueue();
+    #ws;
+    #state = 'opening';
+    #sessionId = '';
+    #lastSequence = -1;
+    #fatal;
+    #units;
+    #commands = 0;
+    #pending;
+    #closing = deferred();
+    constructor(WebSocketImpl, url, protocols, timeoutMs) {
+        this.#WebSocket = WebSocketImpl;
+        this.#url = url;
+        this.#protocols = protocols;
+        this.#timeoutMs = timeoutMs;
+    }
+    get sessionId() {
+        return this.#sessionId;
+    }
+    open(frame, signal) {
+        return this.#attach(frame, 'opening', signal);
+    }
+    resume() {
+        if (this.#state === 'closed') {
+            return Promise.reject(new KaanaConnectionError('The session has ended.'));
+        }
+        if (this.#state === 'resuming' || this.#state === 'opening') {
+            return Promise.reject(new KaanaConnectionError('The session is already reattaching.'));
+        }
+        const frame = JSON.stringify({
+            schemaVersion: 1,
+            requestId: this.#sessionId,
+            commandId: this.#nextCommandId(),
+            type: 'session.resume',
+            afterSequence: this.#lastSequence,
+        });
+        const previous = this.#ws;
+        this.#ws = undefined;
+        previous?.close(1000);
+        return this.#attach(frame, 'resuming', undefined);
+    }
+    send(event) {
+        if (this.#state !== 'open' || this.#ws === undefined) {
+            throw new KaanaConnectionError(this.#state === 'closed'
+                ? 'The session has ended.'
+                : 'The session is not attached; call resume().');
+        }
+        const command = {
+            ...event,
+            schemaVersion: event.schemaVersion ?? 1,
+            requestId: event.requestId ?? this.#sessionId,
+            commandId: event.commandId ?? this.#nextCommandId(),
+        };
+        const parsed = realtimeClientCommandSchema.safeParse(command);
+        if (!parsed.success) {
+            const issue = parsed.error.issues[0];
+            throw clientRefusal(issue?.path.map(String).join('.') || 'event', issue?.message ?? 'invalid');
+        }
+        this.#ws.send(JSON.stringify(command));
+    }
+    appendAudio(pcm16) {
+        for (let offset = 0; offset < pcm16.byteLength; offset += MAX_REALTIME_AUDIO_FRAME_BYTES) {
+            const chunk = pcm16.subarray(offset, offset + MAX_REALTIME_AUDIO_FRAME_BYTES);
+            this.send({ type: 'input_audio.append', data: encodeBase64(chunk) });
+        }
+    }
+    close() {
+        if (this.#units !== undefined)
+            return Promise.resolve(this.#units);
+        if (this.#state === 'closed') {
+            return Promise.reject(this.#fatal ?? new KaanaConnectionError('The session ended without settling here.'));
+        }
+        this.send({ type: 'session.close' });
+        const timer = setTimeout(() => {
+            this.#closing.reject(new KaanaConnectionError('The session did not close in time.', { timedOut: true }));
+        }, this.#timeoutMs);
+        return this.#closing.promise.finally(() => clearTimeout(timer));
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const entry = await this.#queue.take();
+            if (entry.kind === 'end')
+                return;
+            if (entry.kind === 'error')
+                throw entry.error;
+            yield entry.event;
+        }
+    }
+    /* ------------------------------------------------------------------------ */
+    #nextCommandId() {
+        this.#commands += 1;
+        const random = typeof globalThis.crypto?.randomUUID === 'function'
+            ? globalThis.crypto.randomUUID()
+            : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+        return `cmd_${this.#commands}_${random}`;
+    }
+    #attach(frame, state, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(cancelledByCaller(null));
+                return;
+            }
+            this.#state = state;
+            let ws;
+            try {
+                ws = new this.#WebSocket(this.#url, this.#protocols);
+            }
+            catch (cause) {
+                if (state === 'resuming')
+                    this.#state = 'dropped';
+                reject(new KaanaConnectionError('The realtime connection could not be opened.', { cause }));
+                return;
+            }
+            this.#ws = ws;
+            const settle = (error) => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                this.#pending = undefined;
+                if (error === undefined)
+                    resolve();
+                else
+                    reject(error);
+            };
+            const timer = setTimeout(() => {
+                this.#fail(ws, new KaanaConnectionError('The realtime session did not open in time.', {
+                    timedOut: true,
+                }));
+            }, this.#timeoutMs);
+            const onAbort = () => this.#fail(ws, cancelledByCaller(this.#sessionId || null));
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.#pending = { resolve: () => settle(), reject: (error) => settle(error) };
+            ws.onopen = () => {
+                if (ws !== this.#ws)
+                    return;
+                if (typeof ws.protocol === 'string' &&
+                    ws.protocol.length > 0 &&
+                    ws.protocol !== KAANA_REALTIME_SUBPROTOCOL) {
+                    this.#fail(ws, new KaanaProtocolError(`The server selected ${ws.protocol}.`, null));
+                    return;
+                }
+                ws.send(frame);
+            };
+            ws.onmessage = (message) => this.#receive(ws, message.data);
+            ws.onclose = () => this.#closed(ws);
+            ws.onerror = () => {
+                // A close always follows; it decides what the failure means.
+            };
+        });
+    }
+    /** Fail the pending open/resume (if any) and drop the connection. */
+    #fail(ws, error) {
+        if (ws !== this.#ws)
+            return;
+        const pending = this.#pending;
+        if (pending !== undefined) {
+            this.#state = this.#state === 'opening' ? 'closed' : 'dropped';
+            this.#ws = undefined;
+            ws.close(1000);
+            pending.reject(error);
+            return;
+        }
+        this.#ws = undefined;
+        ws.close(1000);
+        this.#drop(error);
+    }
+    #receive(ws, data) {
+        if (ws !== this.#ws)
+            return;
+        if (typeof data !== 'string') {
+            this.#fail(ws, new KaanaProtocolError('The server sent a binary frame.', this.#sessionId || null));
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(data);
+        }
+        catch (_error) {
+            this.#fail(ws, new KaanaProtocolError('The server sent a frame that is not JSON.', null));
+            return;
+        }
+        const parsed = realtimePublicServerEventSchema.safeParse(payload);
+        if (!parsed.success) {
+            const path = parsed.error.issues[0]?.path.map(String).join('.') || 'its root';
+            this.#fail(ws, new KaanaProtocolError(`The server sent an event outside @kaana.ai/contracts at ${path}.`, this.#sessionId || null));
+            return;
+        }
+        const event = parsed.data;
+        if (this.#state === 'opening') {
+            if (event.type === 'session.created') {
+                this.#sessionId = event.requestId;
+                this.#lastSequence = event.sequence;
+                this.#state = 'open';
+                this.#queue.push({ kind: 'event', event });
+                this.#pending?.resolve();
+            }
+            else if (event.type === 'error') {
+                this.#fail(ws, fromPublicError(event.error, null));
+            }
+            else {
+                this.#fail(ws, new KaanaProtocolError(`The session began with ${event.type}.`, null));
+            }
+            return;
+        }
+        if (event.sequence <= this.#lastSequence) {
+            if (this.#state === 'resuming' && event.type === 'error') {
+                // The refusal of a resume stands outside the session's sequence.
+                this.#fail(ws, fromPublicError(event.error, null));
+            }
+            return; // Already delivered before the resume.
+        }
+        this.#lastSequence = event.sequence;
+        if (event.type === 'error' && event.fatal) {
+            this.#fatal = fromPublicError(event.error, null, true);
+        }
+        this.#queue.push({ kind: 'event', event });
+        if (event.type === 'session.resumed' && this.#state === 'resuming') {
+            this.#state = 'open';
+            this.#pending?.resolve();
+        }
+        if (event.type === 'session.closed') {
+            this.#units = event.units;
+            this.#state = 'closed';
+            this.#queue.push({ kind: 'end' });
+            this.#closing.resolve(event.units);
+        }
+    }
+    #closed(ws) {
+        if (ws !== this.#ws)
+            return;
+        this.#ws = undefined;
+        if (this.#pending !== undefined) {
+            const opening = this.#state === 'opening';
+            this.#state = opening ? 'closed' : 'dropped';
+            this.#pending.reject(new KaanaConnectionError(opening
+                ? 'The connection closed before the session opened.'
+                : 'The connection closed before the session resumed.'));
+            return;
+        }
+        if (this.#state === 'closed')
+            return;
+        this.#drop(new KaanaConnectionError('The realtime connection dropped; call resume() within the resume window.'));
+    }
+    #drop(error) {
+        if (this.#fatal !== undefined) {
+            // The server ended the session with a fatal error and no session.closed.
+            this.#state = 'closed';
+            this.#queue.push({ kind: 'error', error: this.#fatal });
+            this.#queue.push({ kind: 'end' });
+            this.#closing.reject(this.#fatal);
+            return;
+        }
+        this.#state = 'dropped';
+        this.#queue.push({ kind: 'error', error });
+    }
+}

package/dist/responses.d.ts

@@ -0,0 +1,11 @@
+/** `POST /v1/responses`: whole, and streamed with a fold into the whole. */
+import { type Response, type ResponseStreamEvent, type RoutingPolicyReference } from '@kaana.ai/contracts';
+import type { RequestOptions, Transport } from './http.js';
+import { type KaanaStream } from './stream.js';
+export declare function responsesStream(transport: Transport, body: string, options: RequestOptions): KaanaStream<ResponseStreamEvent, Response>;
+/** Folds the events of one response into the `Response` it describes. */
+export declare class ResponseFold {
+    #private;
+    add(event: ResponseStreamEvent): void;
+    response(requestId: string, routingPolicy: RoutingPolicyReference): Response;
+}

package/dist/responses.js

@@ -0,0 +1,152 @@
+/** `POST /v1/responses`: whole, and streamed with a fold into the whole. */
+import { KAANA_ROUTING_POLICY_ID_HEADER, KAANA_ROUTING_POLICY_VERSION_HEADER, responseSchema, responseStreamEventSchema, routingPolicyReferenceSchema, } from '@kaana.ai/contracts';
+import { concatBytes, decodeBase64, encodeBase64 } from './base64.js';
+import { fromPublicError, KaanaProtocolError } from './errors.js';
+import { cutOff, frameJson, readFrames } from './events.js';
+import { validate } from './http.js';
+import { StreamHandle } from './stream.js';
+export function responsesStream(transport, body, options) {
+    return new StreamHandle(async function* (context) {
+        const sent = await transport.send({
+            method: 'POST',
+            path: '/responses',
+            body,
+            accept: 'text/event-stream',
+            options: { ...options, signal: context.signal },
+            stream: true,
+        });
+        const requestId = sent.requestId;
+        context.setRequestId(requestId);
+        const routingPolicy = routingPolicyFrom(sent.response, requestId);
+        const fold = new ResponseFold();
+        let lastSequence = -1;
+        let output = false;
+        for await (const frame of readFrames(sent, () => output)) {
+            const event = validate(frameJson(frame, requestId), responseStreamEventSchema, requestId, 'stream event');
+            if (frame.event !== event.type) {
+                throw new KaanaProtocolError(`The stream framed a ${event.type} event as ${frame.event || 'unnamed'}.`, requestId);
+            }
+            if (event.requestId !== requestId) {
+                throw new KaanaProtocolError('The stream sent an event of another request.', requestId);
+            }
+            if (event.sequence <= lastSequence) {
+                throw new KaanaProtocolError('The stream sequence did not advance.', requestId);
+            }
+            if (lastSequence === -1 && event.type !== 'start') {
+                throw new KaanaProtocolError('The stream did not begin with start.', requestId);
+            }
+            lastSequence = event.sequence;
+            if (event.type === 'delta' || event.type === 'audio' || event.type === 'tool_call') {
+                output = true;
+                context.markOutput();
+            }
+            fold.add(event);
+            yield event;
+            if (event.type === 'error') {
+                throw fromPublicError(event.error, null, output);
+            }
+            if (event.type === 'done') {
+                return fold.response(requestId, routingPolicy);
+            }
+        }
+        throw cutOff(requestId);
+    }, options.signal);
+}
+function routingPolicyFrom(response, requestId) {
+    const routingPolicyId = response.headers.get(KAANA_ROUTING_POLICY_ID_HEADER);
+    const version = response.headers.get(KAANA_ROUTING_POLICY_VERSION_HEADER);
+    return validate({
+        routingPolicyId,
+        policyVersion: version !== null && /^\d+$/.test(version) ? Number(version) : version,
+    }, routingPolicyReferenceSchema, requestId, `${KAANA_ROUTING_POLICY_ID_HEADER}/${KAANA_ROUTING_POLICY_VERSION_HEADER} headers`);
+}
+/** Folds the events of one response into the `Response` it describes. */
+export class ResponseFold {
+    #start;
+    #done;
+    #text = '';
+    #refusal = '';
+    #audio = [];
+    #audioMediaType;
+    #usage = [];
+    #toolCalls = new Map();
+    add(event) {
+        switch (event.type) {
+            case 'start':
+                this.#start = event;
+                break;
+            case 'delta':
+                if (event.channel === 'output_text' || event.channel === 'output_audio_transcript') {
+                    this.#text += event.text;
+                }
+                else if (event.channel === 'refusal') {
+                    this.#refusal += event.text;
+                }
+                break;
+            case 'audio':
+                this.#audioMediaType = event.mediaType;
+                this.#audio.push(decodeBase64(event.data));
+                break;
+            case 'tool_call': {
+                const call = this.#toolCalls.get(event.toolCallId) ?? { name: '', arguments: '' };
+                if (event.name !== undefined)
+                    call.name = event.name;
+                if (event.argumentsDelta !== undefined)
+                    call.arguments += event.argumentsDelta;
+                this.#toolCalls.set(event.toolCallId, call);
+                break;
+            }
+            case 'usage':
+                this.#usage = [...event.units];
+                break;
+            case 'done':
+                this.#done = event;
+                break;
+            case 'error':
+                break;
+        }
+    }
+    response(requestId, routingPolicy) {
+        const start = this.#start;
+        const done = this.#done;
+        if (start === undefined || done === undefined) {
+            throw new KaanaProtocolError('The stream ended without start and done.', requestId);
+        }
+        const content = [];
+        if (this.#text.length > 0)
+            content.push({ type: 'text', text: this.#text });
+        if (this.#refusal.length > 0)
+            content.push({ type: 'refusal', text: this.#refusal });
+        if (this.#audio.length > 0 && this.#audioMediaType !== undefined) {
+            content.push({
+                type: 'audio',
+                source: {
+                    kind: 'inline',
+                    mediaType: this.#audioMediaType,
+                    data: encodeBase64(concatBytes(this.#audio)),
+                },
+            });
+        }
+        const message = { role: 'assistant', content };
+        if (this.#toolCalls.size > 0) {
+            message.toolCalls = [...this.#toolCalls].map(([id, call]) => ({
+                id,
+                name: call.name,
+                arguments: call.arguments,
+            }));
+        }
+        const generationId = done.generationId ?? start.generationId;
+        const latencyMs = Math.max(0, Date.parse(done.completedAt) - Date.parse(start.startedAt));
+        return validate({
+            schemaVersion: 1,
+            requestId,
+            ...(generationId === undefined ? {} : { generationId }),
+            model: start.model,
+            finishReason: done.finishReason,
+            output: [message],
+            usage: this.#usage,
+            routingPolicy,
+            latencyMs: Number.isFinite(latencyMs) ? latencyMs : 0,
+        }, responseSchema, requestId, 'folded response');
+    }
+}

package/dist/sse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A bounded Server-Sent Events decoder over a fetch body.
+ *
+ * Multiple `data:` lines join with a newline, comments are ignored and a final
+ * frame does not need a trailing blank line. Cancelling the iterator cancels
+ * the body reader, which is how breaking out of `for await` closes the HTTP
+ * request instead of leaving generation running upstream.
+ */
+/** One SSE frame. `event` is empty when the frame named none. */
+export interface SseFrame {
+    readonly event: string;
+    readonly data: string;
+}
+export declare function decodeEventStream(body: ReadableStream<Uint8Array>, requestId: string | null): AsyncGenerator<SseFrame>;

package/dist/sse.js

@@ -0,0 +1,94 @@
+/**
+ * A bounded Server-Sent Events decoder over a fetch body.
+ *
+ * Multiple `data:` lines join with a newline, comments are ignored and a final
+ * frame does not need a trailing blank line. Cancelling the iterator cancels
+ * the body reader, which is how breaking out of `for await` closes the HTTP
+ * request instead of leaving generation running upstream.
+ */
+import { KaanaProtocolError } from './errors.js';
+/** The largest one frame's data may be: a 49 152-byte audio chunk in base64 plus JSON. */
+const MAX_FRAME_CHARACTERS = 4 * 1024 * 1024;
+const MAX_FRAME_DATA_LINES = 4096;
+export async function* decodeEventStream(body, requestId) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let pending = '';
+    let event = '';
+    let data = [];
+    let characters = 0;
+    let finished = false;
+    const decode = (chunk, options) => {
+        try {
+            return decoder.decode(chunk, options);
+        }
+        catch (_error) {
+            throw new KaanaProtocolError('The stream is not valid UTF-8.', requestId);
+        }
+    };
+    const dispatch = () => {
+        if (data.length === 0 && event.length === 0)
+            return undefined;
+        const frame = { event, data: data.join('\n') };
+        event = '';
+        data = [];
+        characters = 0;
+        return frame;
+    };
+    const consume = (raw) => {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (line.length === 0)
+            return dispatch();
+        if (line.startsWith(':'))
+            return undefined;
+        const separator = line.indexOf(':');
+        const field = separator === -1 ? line : line.slice(0, separator);
+        const rawValue = separator === -1 ? '' : line.slice(separator + 1);
+        const value = rawValue.startsWith(' ') ? rawValue.slice(1) : rawValue;
+        if (field === 'data') {
+            characters += value.length;
+            if (data.length >= MAX_FRAME_DATA_LINES || characters > MAX_FRAME_CHARACTERS) {
+                throw new KaanaProtocolError('The stream sent a frame over its size limit.', requestId);
+            }
+            data.push(value);
+        }
+        else if (field === 'event') {
+            event = value;
+        }
+        return undefined;
+    };
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            pending += decode(next.value, { stream: true });
+            let newline = pending.indexOf('\n');
+            while (newline !== -1) {
+                const frame = consume(pending.slice(0, newline));
+                pending = pending.slice(newline + 1);
+                if (frame !== undefined)
+                    yield frame;
+                newline = pending.indexOf('\n');
+            }
+            if (pending.length > MAX_FRAME_CHARACTERS) {
+                throw new KaanaProtocolError('The stream sent a line over its size limit.', requestId);
+            }
+        }
+        pending += decode();
+        if (pending.length > 0) {
+            const frame = consume(pending);
+            if (frame !== undefined)
+                yield frame;
+        }
+        const last = dispatch();
+        if (last !== undefined)
+            yield last;
+        finished = true;
+    }
+    finally {
+        if (!finished)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}

package/dist/stream.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The stream handle every streaming method returns: an async iterable of
+ * validated events that also resolves to the folded result.
+ */
+/**
+ * Validated events; `final` resolves with the folded response or rejects with
+ * the KaanaError of the terminal `error` event.
+ *
+ * Iterate it, or await `final` alone (which drains it). A stream is consumed
+ * once: iterate it before reading `final` if you want both. Breaking out of
+ * the loop or calling `abort()` cancels the request upstream.
+ */
+export interface KaanaStream<E, F> extends AsyncIterable<E> {
+    readonly requestId: Promise<string>;
+    readonly final: Promise<F>;
+    abort(reason?: unknown): void;
+}
+export interface SourceContext {
+    readonly signal: AbortSignal;
+    setRequestId(requestId: string): void;
+    /** Called by the source once output reached the caller. */
+    markOutput(): void;
+}
+export type Source<E, F> = (context: SourceContext) => AsyncGenerator<E, F, undefined>;
+interface Deferred<T> {
+    promise: Promise<T>;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}
+export declare function deferred<T>(): Deferred<T>;
+/** Link the caller's signal to a controller the stream owns. */
+export declare function linkSignal(controller: AbortController, caller: AbortSignal | undefined): void;
+export declare class StreamHandle<E, F> implements KaanaStream<E, F> {
+    #private;
+    constructor(source: Source<E, F>, callerSignal: AbortSignal | undefined);
+    get requestId(): Promise<string>;
+    get final(): Promise<F>;
+    abort(reason?: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<E>;
+}
+export {};