@astrale-os/kernel-client 0.5.1 → 0.6.0-beta.10

package/dist/store/mutation.d.ts

@@ -0,0 +1,5 @@
+import type { MutationAST as MutationASTValue, MutationInput, MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { GraphApi, MutationAuthor } from '../graph/index.js';
+import type { GraphMemory } from './memory.js';
+import type { StoreMutationOptions } from './store.js';
+export declare function mutateStore(graph: GraphApi, memory: GraphMemory, input: MutationAuthor | MutationASTValue | MutationInput, options?: StoreMutationOptions): Promise<MutationResult>;

package/dist/store/mutation.js

@@ -0,0 +1,34 @@
+import { MutationAST } from '@astrale-os/kernel-core/graph/mutate';
+export async function mutateStore(graph, memory, input, options = {}) {
+    if (options === null || typeof options !== 'object') {
+        throw new TypeError('Store mutation options are invalid.');
+    }
+    if (options.optimistic !== undefined && typeof options.optimistic !== 'boolean') {
+        throw new TypeError('Store optimistic option is invalid.');
+    }
+    const ast = typeof input === 'function'
+        ? MutationAST.build(input)
+        : 'format' in input
+            ? MutationAST.decode(input)
+            : MutationAST.create(input);
+    const transaction = options.optimistic === false ? undefined : memory.overlay.add(ast);
+    if (transaction !== undefined)
+        memory.optimistic();
+    const { optimistic: _optimistic, ...request } = options;
+    try {
+        const result = await graph.mutate(ast, request);
+        if (transaction !== undefined) {
+            memory.overlay.delete(transaction);
+            memory.settleOptimistic();
+        }
+        memory.invalidate();
+        return result;
+    }
+    catch (error) {
+        if (transaction !== undefined) {
+            memory.overlay.delete(transaction);
+            memory.settleOptimistic();
+        }
+        throw error;
+    }
+}

package/dist/store/observe.d.ts

@@ -0,0 +1,3 @@
+import type { StoreQuery, StoreReadOptions, StoreSnapshot } from './store.js';
+import type { GraphStore } from './store.js';
+export declare function observeStore<Query extends StoreQuery>(store: GraphStore, query: Query, listener: (snapshot: StoreSnapshot<Query>) => void, options: StoreReadOptions): () => void;

package/dist/store/observe.js

@@ -0,0 +1,17 @@
+import { admitQuery } from './query-key.js';
+export function observeStore(store, query, listener, options) {
+    if (typeof listener !== 'function')
+        throw new TypeError('Store observer listener is invalid.');
+    const admitted = admitQuery(query);
+    const publish = () => listener(store.getSnapshot(admitted, options));
+    const unsubscribe = store.subscribe(admitted, publish, options);
+    try {
+        publish();
+    }
+    catch (error) {
+        unsubscribe();
+        throw error;
+    }
+    void store.read(admitted, options).catch(() => undefined);
+    return unsubscribe;
+}

package/dist/store/optimistic.d.ts

@@ -0,0 +1,12 @@
+import type { MutationAST } from '@astrale-os/kernel-core/graph/mutate';
+import type { Node, NodeId } from '@astrale-os/kernel-core/graph/node';
+import type { EntityIndex } from './entity-index.js';
+export declare class OptimisticOverlay {
+    private readonly transactions;
+    private sequence;
+    add(ast: MutationAST): number;
+    delete(id: number): void;
+    hasAny(): boolean;
+    node(id: NodeId, entities: EntityIndex): Node | undefined;
+    clear(): void;
+}

package/dist/store/optimistic.js

@@ -0,0 +1,43 @@
+import { apply } from '@astrale-os/kernel-core/graph/properties';
+import { Path } from '@astrale-os/kernel-core/path';
+export class OptimisticOverlay {
+    transactions = new Map();
+    sequence = 0;
+    add(ast) {
+        const id = ++this.sequence;
+        this.transactions.set(id, ast);
+        return id;
+    }
+    delete(id) {
+        this.transactions.delete(id);
+    }
+    hasAny() {
+        return this.transactions.size > 0;
+    }
+    node(id, entities) {
+        let value = entities.node(id);
+        for (const ast of this.transactions.values()) {
+            for (const operation of ast.operations) {
+                if (operation.op !== 'node.update' && operation.op !== 'node.delete')
+                    continue;
+                if (nodeId(operation.node) !== id)
+                    continue;
+                if (operation.op === 'node.delete')
+                    value = undefined;
+                else if (value !== undefined && value.class === operation.class) {
+                    value = Object.freeze({ ...value, props: apply(value.props, operation.props) });
+                }
+            }
+        }
+        return value;
+    }
+    clear() {
+        this.transactions.clear();
+    }
+}
+function nodeId(input) {
+    const path = Path.parse(input);
+    return path.ast.anchor.kind === 'id' && path.ast.steps.length === 0
+        ? path.ast.anchor.id
+        : undefined;
+}

package/dist/store/query-key.d.ts

@@ -0,0 +1,5 @@
+import type { QueryAST as QueryASTValue } from '@astrale-os/kernel-core/graph/query';
+import type { QueryPageRequest } from '../graph/index.js';
+export declare function admitQuery(input: QueryASTValue): QueryASTValue;
+export declare function admitPage(input: QueryPageRequest): QueryPageRequest;
+export declare function queryKey(ast: QueryASTValue, page: QueryPageRequest): string;

package/dist/store/query-key.js

@@ -0,0 +1,22 @@
+import { QueryAST } from '@astrale-os/kernel-core/graph/query';
+export function admitQuery(input) {
+    return QueryAST.decode(input);
+}
+export function admitPage(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Store query page is invalid.');
+    }
+    if (!Number.isSafeInteger(input.size) || input.size < 1) {
+        throw new TypeError('Store query page size must be a positive safe integer.');
+    }
+    if (input.after !== undefined && (typeof input.after !== 'string' || input.after.length === 0)) {
+        throw new TypeError('Store query page continuation is invalid.');
+    }
+    return Object.freeze({
+        size: input.size,
+        ...(input.after === undefined ? {} : { after: input.after }),
+    });
+}
+export function queryKey(ast, page) {
+    return JSON.stringify([QueryAST.fingerprint(ast), page.size, page.after ?? null]);
+}

package/dist/store/shape.d.ts

@@ -0,0 +1,25 @@
+import type { NodeId } from '@astrale-os/kernel-core/graph/node';
+import type { QueryAST } from '@astrale-os/kernel-core/graph/query';
+import type { QueryPageRequest } from '../graph/index.js';
+import type { FactReferences } from './entity-index.js';
+import type { StoreQueryResponse, StoreSnapshot } from './store.js';
+export type ShapeState = StoreSnapshot['state'];
+export declare class QueryShape {
+    readonly key: string;
+    readonly ast: QueryAST;
+    readonly page: QueryPageRequest;
+    readonly listeners: Set<() => void>;
+    state: ShapeState;
+    confirmed?: StoreQueryResponse;
+    response?: StoreQueryResponse;
+    references?: FactReferences;
+    inflight?: Promise<StoreQueryResponse>;
+    releasedAt?: number;
+    accessedAt: number;
+    refreshedAt?: number;
+    snapshot: StoreSnapshot;
+    constructor(key: string, ast: QueryAST, page: QueryPageRequest, now: number);
+    get observed(): boolean;
+    referencesAny(nodes: ReadonlySet<NodeId>, edges: ReadonlySet<string>): boolean;
+}
+export declare const COLD_SNAPSHOT: StoreSnapshot;

package/dist/store/shape.js

@@ -0,0 +1,29 @@
+export class QueryShape {
+    key;
+    ast;
+    page;
+    listeners = new Set();
+    state = 'cold';
+    confirmed;
+    response;
+    references;
+    inflight;
+    releasedAt;
+    accessedAt;
+    refreshedAt;
+    snapshot = COLD_SNAPSHOT;
+    constructor(key, ast, page, now) {
+        this.key = key;
+        this.ast = ast;
+        this.page = page;
+        this.accessedAt = now;
+    }
+    get observed() {
+        return this.listeners.size > 0;
+    }
+    referencesAny(nodes, edges) {
+        return (this.references?.nodes.some((id) => nodes.has(id)) === true ||
+            this.references?.edges.some((key) => edges.has(key)) === true);
+    }
+}
+export const COLD_SNAPSHOT = Object.freeze({ state: 'cold' });

package/dist/store/store.d.ts

@@ -0,0 +1,68 @@
+import type { MutationAST, MutationInput, MutationResult } from '@astrale-os/kernel-core/graph/mutate';
+import type { QueryAST, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { QueryResponse } from '../graph/index.js';
+import type { GraphApi, GraphQueryOptions, MutationAuthor } from '../graph/index.js';
+import type { RequestOptions } from '../transport/index.js';
+export type StoreQuery = QueryAST;
+export type StoreQueryResponse<Query extends StoreQuery = StoreQuery> = QueryResponse<QueryResultFor<Query>>;
+export interface StoreReadOptions extends GraphQueryOptions {
+    readonly freshness?: 'cached' | 'refresh';
+}
+export interface StoreMutationOptions extends RequestOptions {
+    readonly optimistic?: boolean;
+}
+export type StoreSnapshot<Query extends StoreQuery = StoreQuery> = {
+    readonly state: 'cold';
+} | {
+    readonly state: 'loading';
+}
+/** Last read succeeded and no local invalidation occurred; no remote recency is implied. */
+ | {
+    readonly state: 'ready';
+    readonly response: StoreQueryResponse<Query>;
+} | {
+    readonly state: 'stale';
+    readonly response: StoreQueryResponse<Query>;
+} | {
+    readonly state: 'refreshing';
+    readonly response: StoreQueryResponse<Query>;
+} | {
+    readonly state: 'optimistic';
+    readonly response: StoreQueryResponse<Query>;
+} | {
+    readonly state: 'failed';
+    readonly error: unknown;
+    readonly response?: StoreQueryResponse<Query>;
+};
+export interface StoreOptions {
+    /** Must retain one effective authority and semantic schema revision for this Store lifetime. */
+    readonly graph: GraphApi;
+    readonly ttlMs?: number;
+    readonly concurrency?: number;
+    readonly maximumShapes?: number;
+    readonly now?: () => number;
+    readonly onError?: (error: unknown) => void;
+}
+/** Framework-neutral normalized graph memory scoped to one caller-bound GraphApi. */
+export declare class GraphStore {
+    readonly graph: GraphApi;
+    private readonly memory;
+    private readonly lifecycle;
+    private closed;
+    constructor(options: StoreOptions);
+    read<Query extends StoreQuery>(query: Query, options: StoreReadOptions): Promise<StoreQueryResponse<Query>>;
+    peek<Query extends StoreQuery>(query: Query, options: GraphQueryOptions): StoreQueryResponse<Query> | undefined;
+    preload<Query extends StoreQuery>(query: Query, options: StoreReadOptions): Promise<void>;
+    subscribe<Query extends StoreQuery>(query: Query, listener: () => void, options: GraphQueryOptions): () => void;
+    getSnapshot<Query extends StoreQuery>(query: Query, options: GraphQueryOptions): StoreSnapshot<Query>;
+    observe<Query extends StoreQuery>(query: Query, listener: (snapshot: StoreSnapshot<Query>) => void, options: StoreReadOptions): () => void;
+    mutate(author: MutationAuthor, options?: StoreMutationOptions): Promise<MutationResult>;
+    mutate(input: MutationAST | MutationInput, options?: StoreMutationOptions): Promise<MutationResult>;
+    invalidate(): void;
+    invalidate(query: StoreQuery, options: GraphQueryOptions): void;
+    sweep(): void;
+    close(): void;
+    private admit;
+    private identity;
+    private requireOpen;
+}

package/dist/store/store.js

@@ -0,0 +1,144 @@
+import { ClientError } from '../errors/index.js';
+import { GraphMemory } from './memory.js';
+import { mutateStore } from './mutation.js';
+import { observeStore } from './observe.js';
+import { admitPage, admitQuery, queryKey } from './query-key.js';
+/** Framework-neutral normalized graph memory scoped to one caller-bound GraphApi. */
+export class GraphStore {
+    graph;
+    memory;
+    lifecycle = new AbortController();
+    closed = false;
+    constructor(options) {
+        if (options === null || typeof options !== 'object') {
+            throw new TypeError('GraphStore options are invalid.');
+        }
+        if (options.graph === null ||
+            typeof options.graph !== 'object' ||
+            typeof options.graph.query !== 'function' ||
+            typeof options.graph.mutate !== 'function' ||
+            typeof options.graph.get !== 'function' ||
+            typeof options.graph.getOrThrow !== 'function' ||
+            typeof options.graph.neighbors !== 'function') {
+            throw new TypeError('GraphStore graph capability is invalid.');
+        }
+        if (options.now !== undefined && typeof options.now !== 'function') {
+            throw new TypeError('GraphStore clock is invalid.');
+        }
+        if (options.onError !== undefined && typeof options.onError !== 'function') {
+            throw new TypeError('GraphStore error observer is invalid.');
+        }
+        const ttlMs = positive(options.ttlMs ?? 30_000, 'ttlMs');
+        const concurrency = positive(options.concurrency ?? 4, 'concurrency');
+        const maximumShapes = positive(options.maximumShapes ?? 256, 'maximumShapes');
+        this.graph = Object.freeze({
+            query: options.graph.query.bind(options.graph),
+            mutate: options.graph.mutate.bind(options.graph),
+            get: options.graph.get.bind(options.graph),
+            getOrThrow: options.graph.getOrThrow.bind(options.graph),
+            neighbors: options.graph.neighbors.bind(options.graph),
+        });
+        this.memory = new GraphMemory({
+            graph: this.graph,
+            ttlMs,
+            concurrency,
+            maximumShapes,
+            now: options.now ?? Date.now,
+            ...(options.onError === undefined ? {} : { onError: options.onError }),
+            lifecycle: this.lifecycle.signal,
+            requireOpen: () => this.requireOpen(),
+        });
+    }
+    read(query, options) {
+        const admitted = this.admit(query, options);
+        return this.memory.read(admitted.shape, admitted.options);
+    }
+    peek(query, options) {
+        const { key } = this.identity(query, options);
+        return this.memory.get(key)?.response;
+    }
+    async preload(query, options) {
+        await this.read(query, options);
+    }
+    subscribe(query, listener, options) {
+        if (typeof listener !== 'function')
+            throw new TypeError('Store listener is invalid.');
+        const admitted = this.admit(query, options);
+        return this.memory.subscribe(admitted.shape, listener);
+    }
+    getSnapshot(query, options) {
+        const { key } = this.identity(query, options);
+        return this.memory.snapshot(this.memory.get(key));
+    }
+    observe(query, listener, options) {
+        return observeStore(this, query, listener, options);
+    }
+    mutate(input, options) {
+        this.requireOpen();
+        return mutateStore(this.graph, this.memory, input, options);
+    }
+    invalidate(query, options) {
+        this.requireOpen();
+        if (query === undefined)
+            this.memory.invalidate();
+        else {
+            if (options === undefined)
+                throw new TypeError('Store query page is required.');
+            const { key } = this.identity(query, options);
+            const shape = this.memory.get(key);
+            if (shape !== undefined)
+                this.memory.invalidate(shape);
+        }
+    }
+    sweep() {
+        this.memory.sweep();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const error = new ClientError('GraphStore is closed.');
+        this.lifecycle.abort(error);
+        this.memory.close(error);
+    }
+    admit(query, options) {
+        const identity = this.identity(query, options);
+        return {
+            ...identity,
+            shape: this.memory.ensure(identity.key, identity.ast, identity.page),
+            options: options,
+        };
+    }
+    identity(query, options) {
+        this.requireOpen();
+        if (options === null || typeof options !== 'object') {
+            throw new TypeError('Store read options are invalid.');
+        }
+        if ('freshness' in options &&
+            options.freshness !== undefined &&
+            options.freshness !== 'cached' &&
+            options.freshness !== 'refresh') {
+            throw new TypeError('Store freshness option is invalid.');
+        }
+        const page = admitPage(options.page);
+        if (options.timeoutMs !== undefined &&
+            (!Number.isSafeInteger(options.timeoutMs) ||
+                options.timeoutMs < 1 ||
+                options.timeoutMs > 2_147_483_647)) {
+            throw new TypeError('Store read timeoutMs must be a positive platform integer.');
+        }
+        const ast = admitQuery(query);
+        const key = queryKey(ast, page);
+        return { key, ast, page };
+    }
+    requireOpen() {
+        if (this.closed)
+            throw new ClientError('GraphStore is closed.');
+    }
+}
+function positive(input, label) {
+    if (!Number.isSafeInteger(input) || input < 1) {
+        throw new TypeError(`${label} must be a positive safe integer.`);
+    }
+    return input;
+}

package/dist/store/store.typecheck.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/store/store.typecheck.js

@@ -0,0 +1,40 @@
+import { Query } from '../graph/index.js';
+const options = { page: { size: 32 } };
+const nodeGraph = Query.from({ nodes: [path] }).select({ kind: 'graph' });
+const nodeProjection = Query.from({ nodes: [path] }).select({
+    kind: 'nodes',
+    projection: { kind: 'reference' },
+});
+const edgeSource = Query.from({ edges: [edge] });
+const edgeProjection = edgeSource.select({
+    kind: 'edges',
+    projection: { edge: 'reference', source: 'value', target: 'reference' },
+});
+const read = store.read(nodeGraph, options);
+const peek = store.peek(nodeProjection, options);
+const snapshot = store.getSnapshot(edgeProjection, options);
+// @ts-expect-error ready is the successful local snapshot state; fresh is retired.
+const retiredFreshSnapshot = { state: 'fresh' };
+void retiredFreshSnapshot;
+store.subscribe(nodeGraph, () => undefined, options);
+store.observe(nodeProjection, (value) => {
+    if ('response' in value && value.response !== undefined) {
+        const result = value.response.result;
+        void result;
+    }
+}, options);
+// @ts-expect-error Query-page identity is required for every observed Store shape.
+store.read(nodeGraph);
+// @ts-expect-error Query-page identity is required for cache peeks.
+store.peek(nodeGraph);
+// @ts-expect-error Query-page identity is required for preloading.
+store.preload(nodeGraph);
+// @ts-expect-error Query-page identity is required for subscriptions.
+store.subscribe(nodeGraph, () => undefined);
+// @ts-expect-error Query-page identity is required for snapshot lookup.
+store.getSnapshot(nodeGraph);
+// @ts-expect-error Query-page identity is required for observations.
+store.observe(nodeGraph, () => undefined);
+// @ts-expect-error watch is reserved for a future remote-liveness protocol.
+store.watch(nodeGraph, () => undefined, options);
+void {};

package/dist/transport/auto/decision.d.ts

@@ -0,0 +1,22 @@
+export type AutoSelection = 'websocket' | 'http';
+export type AutoDecisionTicket = {
+    readonly kind: 'selected';
+    readonly selection: AutoSelection;
+} | {
+    readonly kind: 'wait';
+    readonly selection: Promise<AutoSelection | undefined>;
+} | {
+    readonly kind: 'probe';
+};
+/** Serializes the one initial transport decision without retaining invocation values. */
+export declare class AutoDecision {
+    private selected;
+    private pending;
+    private closed;
+    begin(): AutoDecisionTicket;
+    select(selection: AutoSelection): void;
+    /** Permanently degrade a prior or pending WebSocket selection to HTTP. */
+    demote(): void;
+    release(): void;
+    close(): void;
+}

package/dist/transport/auto/decision.js

@@ -0,0 +1,48 @@
+/** Serializes the one initial transport decision without retaining invocation values. */
+export class AutoDecision {
+    selected;
+    pending;
+    closed = false;
+    begin() {
+        if (this.closed)
+            return { kind: 'wait', selection: Promise.resolve(undefined) };
+        if (this.selected)
+            return { kind: 'selected', selection: this.selected };
+        if (this.pending)
+            return { kind: 'wait', selection: this.pending.promise };
+        let resolve;
+        const promise = new Promise((settle) => {
+            resolve = settle;
+        });
+        this.pending = { promise, resolve };
+        return { kind: 'probe' };
+    }
+    select(selection) {
+        if (this.closed || this.selected)
+            return;
+        this.selected = selection;
+        this.pending?.resolve(selection);
+        this.pending = undefined;
+    }
+    /** Permanently degrade a prior or pending WebSocket selection to HTTP. */
+    demote() {
+        if (this.closed || this.selected === 'http')
+            return;
+        this.selected = 'http';
+        this.pending?.resolve('http');
+        this.pending = undefined;
+    }
+    release() {
+        if (this.closed || this.selected)
+            return;
+        this.pending?.resolve(undefined);
+        this.pending = undefined;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.pending?.resolve(undefined);
+        this.pending = undefined;
+    }
+}

package/dist/transport/auto/fallback.d.ts

@@ -0,0 +1,16 @@
+import type { RequestOptions, TransportRequest } from '../index.js';
+import { TransportError } from '../../errors/index.js';
+/** One invocation-owned total timeout budget shared by selection and fallback. */
+export declare class InvocationBudget {
+    private readonly input;
+    private readonly started;
+    private readonly timeoutMs;
+    constructor(input: RequestOptions | undefined, defaultTimeoutMs: number);
+    options(): RequestOptions;
+    get cancelled(): boolean;
+    get idempotency(): 'supplied' | 'absent';
+    wait(decision: Promise<'websocket' | 'http' | undefined>): Promise<'websocket' | 'http' | undefined>;
+    private remaining;
+}
+export declare function mayFallback(error: unknown): error is TransportError;
+export declare function warningTarget(input: TransportRequest): TransportRequest['call']['target'];

package/dist/transport/auto/fallback.js

@@ -0,0 +1,75 @@
+import { TransportError } from '../../errors/index.js';
+import { invocationFailure } from '../failure.js';
+import { positiveInteger } from '../index.js';
+const MAXIMUM_TIMEOUT_MS = 2_147_483_647;
+/** One invocation-owned total timeout budget shared by selection and fallback. */
+export class InvocationBudget {
+    input;
+    started = Date.now();
+    timeoutMs;
+    constructor(input, defaultTimeoutMs) {
+        this.input = input;
+        this.timeoutMs = positiveInteger(input?.timeoutMs ?? defaultTimeoutMs, 'timeoutMs');
+    }
+    options() {
+        const remaining = this.remaining();
+        return Object.freeze({
+            ...(this.input?.signal === undefined ? {} : { signal: this.input.signal }),
+            timeoutMs: remaining,
+            ...(this.input?.idempotencyKey === undefined
+                ? {}
+                : { idempotencyKey: this.input.idempotencyKey }),
+        });
+    }
+    get cancelled() {
+        return this.input?.signal?.aborted === true;
+    }
+    get idempotency() {
+        return this.input?.idempotencyKey === undefined ? 'absent' : 'supplied';
+    }
+    async wait(decision) {
+        if (this.input?.signal?.aborted)
+            throw abortReason(this.input.signal);
+        const remaining = this.remaining();
+        let timer;
+        let abort;
+        const interrupted = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(invocationFailure('Automatic transport decision exceeded its timeout.', 'timeout')), remaining);
+            if (this.input?.signal) {
+                abort = () => reject(abortReason(this.input.signal));
+                this.input.signal.addEventListener('abort', abort, { once: true });
+            }
+        });
+        try {
+            return await Promise.race([decision, interrupted]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (abort && this.input?.signal)
+                this.input.signal.removeEventListener('abort', abort);
+        }
+    }
+    remaining() {
+        const remaining = Math.min(MAXIMUM_TIMEOUT_MS, this.timeoutMs - (Date.now() - this.started));
+        if (remaining < 1) {
+            throw invocationFailure('Automatic transport invocation exceeded its timeout.', 'timeout');
+        }
+        return remaining;
+    }
+}
+export function mayFallback(error) {
+    return (error instanceof TransportError &&
+        error.context.kind === 'invocation' &&
+        error.context.delivery === 'not-sent' &&
+        error.phase !== 'closed' &&
+        error.phase !== 'timeout');
+}
+export function warningTarget(input) {
+    return input.call.target;
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error(signal.reason === undefined ? 'request was cancelled' : String(signal.reason));
+}

package/dist/transport/auto/index.d.ts

@@ -0,0 +1,2 @@
+export { AutoTransport, type AutoTransportOptions } from './transport.js';
+export { formatClientWarning, type ClientWarning } from './warning.js';

package/dist/transport/auto/index.js

@@ -0,0 +1,2 @@
+export { AutoTransport } from './transport.js';
+export { formatClientWarning } from './warning.js';