@altertable/data-app 0.61.0 → 0.63.0

package/dist/types/client/index.d.ts

@@ -3,40 +3,10 @@
  * @module @altertable/data-app/client
  * @see https://github.com/altertable-ai/data-app/blob/main/docs/client.md
  */
-import { type DataTransport } from './transport.js';
+export { createDataClient } from './data-client.js';
+export type { InputOf, OutputOf, DataResponse, DataClient, DataClientOptions, } from './data-client.js';
+export type { DataAppLocation, AppLocation } from './location.js';
+export { createDataAppNavigation, getDataAppNavigation, type DataAppNavigation, } from './navigation.js';
 export { createHttpTransport, DataAppError, type DataTransport, } from './transport.js';
 export { createIframeTransport, installDataAppTransport, getDataAppTransport, type IframeTransport, } from './iframe.js';
 export { createMessageClient } from './messages.js';
-import type { DataOperations, DisclosedQuery } from '../core/contract.js';
-export type InputOf<T> = T extends {
-    input: (value: unknown) => infer Input;
-} ? Input : never;
-export type OutputOf<T> = T extends {
-    output: (value: unknown) => infer Output;
-} ? Output : never;
-/**
- * Parsed operation data and query evidence. `queries` is present only when SQL disclosure is
- * allowed.
- */
-export type DataResponse<Output, Input = unknown> = {
-    data: Output;
-    /** The exact browser input that produced this response. Never infer it from current controls. */
-    input: Input;
-    requestId: string;
-    queriedAt: string;
-    queryIds: string[];
-    queries?: DisclosedQuery[];
-};
-export type DataClient<Operations extends DataOperations> = {
-    query<Name extends keyof Operations & string>(name: Name, input: InputOf<Operations[Name]>, options?: {
-        signal?: AbortSignal;
-    }): Promise<DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>>;
-};
-/** Browser client for named operations; it sends inputs, never SQL or lakehouse credentials. */
-export declare function createDataClient<Operations extends DataOperations>(options?: {
-    transport?: DataTransport;
-    endpoint?: string;
-    fetch?: typeof fetch;
-}): DataClient<Operations>;
-export type { DataAppLocation, AppLocation } from './location.js';
-export { createDataAppNavigation, getDataAppNavigation, type DataAppNavigation, } from './navigation.js';

package/dist/types/client/location.d.ts

@@ -1,14 +1,12 @@
-export type AppLocation = {
-    search: string;
-    hash: string;
-};
+import type { AppLocation, HistoryMode } from '../core/navigation.js';
+export type { AppLocation } from '../core/navigation.js';
 export type DataAppLocation = {
     snapshot(): AppLocation;
     subscribe(listener: () => void): () => void;
-    update(location: AppLocation, mode?: 'push' | 'replace'): void;
+    update(location: AppLocation, mode?: HistoryMode): void;
 };
 /** Opaque sandboxes keep app state in memory; URL frames retain their real URL for HMR. */
-export declare function createAppLocation(frame: Window, virtual: boolean, publish: (location: AppLocation, mode: 'push' | 'replace') => void): {
+export declare function createAppLocation(frame: Window, virtual: boolean, publish: (location: AppLocation, mode: HistoryMode) => void): {
     location: DataAppLocation;
     apply: (next: AppLocation) => void;
     dispose: () => void;

package/dist/types/client/navigation.d.ts

@@ -1,8 +1,9 @@
+import type { HistoryMode } from '../core/navigation.js';
 import { type DataAppLocation } from './location.js';
 import { type IframeTransport } from './iframe.js';
 export type DataAppNavigation = DataAppLocation & {
     /** Publish URL changes made outside the adapter, including the document title. */
-    publish(mode?: 'push' | 'replace'): void;
+    publish(mode?: HistoryMode): void;
     dispose(): void;
 };
 /** Attach app URL behavior to an already authenticated bridge. */

package/dist/types/core/appearance.d.ts

@@ -1,5 +1,7 @@
+export type Theme = 'light' | 'dark';
+export type ThemePreference = Theme | 'system';
 export type AppearanceSettings = {
-    mode: 'light' | 'dark' | 'system';
+    theme: ThemePreference;
     baseColor: 'neutral' | 'slate' | 'warm';
     accentColor: string;
     darkAccentColor?: string;
@@ -12,10 +14,9 @@ export type AppearanceSettings = {
         heading: string;
     };
 };
-export type ThemeMode = AppearanceSettings['mode'];
 export type ThemeController = {
-    getMode: () => ThemeMode;
-    setMode: (mode: ThemeMode) => void;
+    getTheme: () => ThemePreference;
+    setTheme: (theme: ThemePreference) => void;
     subscribe: (listener: () => void) => () => void;
 };
 export declare function parseAppearance(value: unknown): AppearanceSettings;
@@ -24,5 +25,5 @@ export declare function parseAppearance(value: unknown): AppearanceSettings;
  * system-theme listening.
  */
 export declare function applyAppearance(value: unknown): () => void;
-/** Viewer color mode persists independently of app-authored brand tokens. */
-export declare function createThemeController(value: unknown): ThemeController;
+/** Persist a viewer theme preference. Applying appearance belongs to the UI owner. */
+export declare function createThemeController(initialTheme?: ThemePreference): ThemeController;

package/dist/types/core/bridge.d.ts

@@ -5,10 +5,7 @@ export declare const PARENT_PARAM = "__altertable_parent";
  * The host enforces its own limit because frames can send messages directly. */
 export declare const MAX_PENDING = 128;
 export declare const REQUEST_TIMEOUT_MS = 60000;
-export type TransportResponse = {
-    status: number;
-    body: unknown;
-};
+export type { TransportResponse } from './operation-types.js';
 export type BridgeMessage = {
     channel: typeof BRIDGE;
     version: 1;
@@ -29,7 +26,4 @@ export type BridgeMessage = {
 };
 export declare function isBridgeMessage(value: unknown): value is BridgeMessage;
 export declare function validId(value: unknown): value is string;
-export declare function validLocation(message: {
-    search?: unknown;
-    hash?: unknown;
-}): boolean;
+export { validLocation } from './navigation.js';

package/dist/types/core/config.d.ts

@@ -1,10 +1,10 @@
 /**
  * App identity and display scope shared by browser and server.
  * @module @altertable/data-app/config
- * @see https://github.com/altertable-ai/data-app/blob/main/docs/config.md
  */
 export type DataAppConfig = {
     title: string;
+    /** Display labels; scope does not grant data access. */
     scope: {
         organization: string;
         environment: string;

package/dist/types/core/contract.d.ts

@@ -1,17 +1,9 @@
-export type QueryResult = {
-    columns: {
-        name: string;
-        type?: string;
-    }[];
-    rows: unknown[][];
-    queryId?: string;
-};
+import type { DateRange as DateRangeInput } from './date-range.js';
+import type { QueryResult, DataOperation, OperationContext } from './operation-types.js';
+export type { QueryResult, DisclosedQuery, Lakehouse, OperationContext, DataOperation, DataOperations, } from './operation-types.js';
 export declare function parseEmptyInput(value: unknown): Record<string, never>;
 export declare function parseTrue(value: unknown): true;
-export type DateRangeInput = {
-    start: string;
-    end: string;
-};
+export type { DateRange as DateRangeInput } from './date-range.js';
 export type DateRangeRequest = {
     range: DateRangeInput;
     comparison: DateRangeInput | null;
@@ -67,48 +59,16 @@ export declare function parseCount(value: unknown): number;
 export declare function parseLabel(value: unknown, maxLength?: number): string;
 /** Rejects missing or duplicate columns and rows whose width differs from the column list. */
 export declare function rowsAsRecords(result: QueryResult, requiredColumns: readonly string[]): Record<string, unknown>[];
-/** One named statement an operation ran. Returned only when SQL disclosure is allowed. */
-export type DisclosedQuery = {
-    name: string;
-    statement: string;
-    queryId?: string;
-};
 export declare function defineQueryNames<const Names extends Record<string, string>>(names: Names): Names;
+declare const sourceErrorBrand: unique symbol;
 export declare class DataSourceError extends Error {
     readonly reason: 'unauthorized' | 'forbidden' | 'rate_limited' | 'query_rejected' | 'unavailable';
     readonly status?: number | undefined;
+    readonly [sourceErrorBrand] = true;
     queryName?: string;
+    static [Symbol.hasInstance](value: unknown): boolean;
     constructor(reason: 'unauthorized' | 'forbidden' | 'rate_limited' | 'query_rejected' | 'unavailable', status?: number | undefined);
 }
-/** Server-only query interface supplied by a local or hosted adapter. */
-export type Lakehouse = {
-    queryAll(statement: string, options: {
-        limit: number;
-        signal: AbortSignal;
-        name?: string;
-    }): Promise<QueryResult>;
-};
-export type OperationContext = {
-    lakehouse: Lakehouse;
-    signal: AbortSignal;
-};
-/**
- * Both parsers run on the server before results cross the JSON boundary. Schema libraries can be
- * used inside either parser.
- */
-export type DataOperation<Input, Output> = {
-    input: (value: unknown) => Input;
-    output: (value: unknown) => Output;
-    run: (context: OperationContext, input: Input) => Promise<Output>;
-    checks: readonly Input[];
-    queryNames?: Readonly<Record<string, string>>;
-    policy: {
-        maxQueryRows: number;
-        maxDurationMs: number;
-        maxResponseBytes?: number;
-        exposeSql?: boolean;
-    };
-};
 export type OperationQuery<Names extends Readonly<Record<string, string>>> = (name: Names[keyof Names], statement: string, options?: {
     limit?: number;
 }) => Promise<QueryResult>;
@@ -125,15 +85,8 @@ export declare const connectionQueryNames: {
 };
 /** Success requires a bounded SQL query; it does not establish access to a particular dataset. */
 export declare function connectionCheck(): DataOperation<Record<string, never>, true>;
-export type DataOperations = Record<string, {
-    input: (value: unknown) => unknown;
-    output: (value: unknown) => unknown;
-    run: (context: OperationContext, input: never) => Promise<unknown>;
-    checks: readonly unknown[];
-    queryNames?: Readonly<Record<string, string>>;
-    policy: DataOperation<never, unknown>['policy'];
-}>;
 export { dimensionFilter, parseDimensionSelection, parseFacetOptions, dimensionPredicate, } from './dimension.js';
 export type { DimensionSelection, DimensionMember, DimensionOption, DimensionVariable, DimensionFilterOptions, } from './dimension.js';
-export * from './messages.js';
+export { createMessageRouter, defineMessageRoute, defineDataQueryRoute, MessageRoutingError, dataAppRoutes, navigationUpdateRoute, sqlQueryRoute, } from './messages.js';
+export type { MessageContext, RoutedMessage, MessageDispatcher, MessageTransport, MessageRoute, MessageRoutes, MessageInput, MessageHandlers, MessageOutput, OperationContracts, DataQueryInput, DataQueryBody, DataQueryRoute, NavigationUpdate, SqlQueryInput, } from './messages.js';
 export type { TransportResponse } from './bridge.js';

package/dist/types/core/format.d.ts

@@ -1,7 +1,6 @@
 /**
  * Date and number formatting with explicit units and missing-value behavior.
  * @module @altertable/data-app/format
- * @see https://github.com/altertable-ai/data-app/blob/main/docs/format.md
  */
 type CommonOptions = {
     locale?: string;

package/dist/types/core/messages.d.ts

@@ -1,5 +1,7 @@
-import type { TransportResponse } from './bridge.js';
-import type { DisclosedQuery } from './contract.js';
+import type { TransportResponse, QueryResult, OperationContracts, DataQueryInput, DataQueryBody, OutputOf } from './operation-types.js';
+export type { OperationContracts, DataQueryInput, DataQueryBody, } from './operation-types.js';
+import { type NavigationUpdate } from './navigation.js';
+export type { NavigationUpdate } from './navigation.js';
 export type MessageContext = {
     signal: AbortSignal;
 };
@@ -35,43 +37,22 @@ export declare function defineMessageRoute<Input, Output>(route: MessageRoute<In
 export declare function createMessageRouter<const Routes extends MessageRoutes>(routes: Routes, handlers: MessageHandlers<NoInfer<Routes>>): {
     dispatch: (value: unknown, context: MessageContext) => Promise<unknown>;
 };
-export type OperationContracts = Record<string, {
-    input: (value: unknown) => unknown;
-    output: (value: unknown) => unknown;
-}>;
-export type DataQueryInput<Operations extends OperationContracts> = {
-    [Name in keyof Operations & string]: {
-        operation: Name;
-        input: ReturnType<Operations[Name]['input']>;
-    };
-}[keyof Operations & string];
-export type DataQueryBody<Output> = {
-    data: Output;
-    requestId: string;
-    queriedAt: string;
-    queryIds: string[];
-    queries?: DisclosedQuery[];
-};
 export type DataQueryRoute<Operations extends OperationContracts> = MessageRoute<DataQueryInput<Operations>, TransportResponse> & {
     operations: Operations | undefined;
 };
 export type MessageOutput<Route extends MessageRoutes[string], Input> = Route extends DataQueryRoute<infer Operations> ? Input extends {
     operation: infer Name extends keyof Operations;
-} ? {
-    status: number;
-    body: DataQueryBody<ReturnType<Operations[Name]['output']>>;
-} : never : ReturnType<Route['output']>;
+} ? TransportResponse<DataQueryBody<OutputOf<Operations[Name]>>> : never : ReturnType<Route['output']>;
 /** Omit contracts only in generic hosts such as the CLI shell, where Bun validates operations. */
 export declare function defineDataQueryRoute<Operations extends OperationContracts = OperationContracts>(operations?: Operations): DataQueryRoute<Operations>;
-export type NavigationUpdate = {
-    search: string;
-    hash: string;
-    mode: 'push' | 'replace';
-    title?: string;
-};
 export declare const navigationUpdateRoute: MessageRoute<NavigationUpdate, null>;
+export type SqlQueryInput = {
+    statement: string;
+    limit: number;
+};
+/** SQL delivery for browser-owned operations. Hosts must enforce backend access and resource limits. */
+export declare const sqlQueryRoute: MessageRoute<SqlQueryInput, QueryResult>;
 export declare const dataAppRoutes: {
     'data:query': DataQueryRoute<OperationContracts>;
     'navigation:update': MessageRoute<NavigationUpdate, null>;
 };
-export {};

package/dist/types/core/navigation.d.ts

@@ -0,0 +1,11 @@
+/** App-owned URL state shared by controls, frame adapters, and host navigation. */
+export type AppLocation = {
+    search: string;
+    hash: string;
+};
+export type HistoryMode = 'push' | 'replace';
+export type NavigationUpdate = AppLocation & {
+    mode: HistoryMode;
+    title?: string;
+};
+export declare function validLocation(value: unknown): value is AppLocation;

package/dist/types/core/operation-types.d.ts

@@ -0,0 +1,76 @@
+/** Shared operation, query, and response contracts; independent of delivery adapters. */
+export type OperationContracts = Record<string, {
+    input: (value: unknown) => unknown;
+    output: (value: unknown) => unknown;
+}>;
+export type InputOf<T> = T extends {
+    input: (value: unknown) => infer Input;
+} ? Input : never;
+export type OutputOf<T> = T extends {
+    output: (value: unknown) => infer Output;
+} ? Output : never;
+export type QueryResult = {
+    columns: {
+        name: string;
+        type?: string;
+    }[];
+    rows: unknown[][];
+    queryId?: string;
+};
+/** One named statement an operation ran. Returned only when SQL disclosure is allowed. */
+export type DisclosedQuery = {
+    name: string;
+    statement: string;
+    queryId?: string;
+};
+/** Query interface supplied by a server adapter or an authorized iframe bridge. */
+export type Lakehouse = {
+    queryAll(statement: string, options: {
+        limit: number;
+        signal: AbortSignal;
+        name?: string;
+    }): Promise<QueryResult>;
+};
+export type OperationContext = {
+    lakehouse: Lakehouse;
+    signal: AbortSignal;
+};
+/**
+ * Parsers run in the operation executor's runtime: server for HTTP apps, browser for bundle apps.
+ * Browser validation does not replace backend authorization or query limits.
+ */
+export type DataOperation<Input, Output> = {
+    input: (value: unknown) => Input;
+    output: (value: unknown) => Output;
+    run: (context: OperationContext, input: Input) => Promise<Output>;
+    checks: readonly Input[];
+    queryNames?: Readonly<Record<string, string>>;
+    policy: {
+        maxQueryRows: number;
+        maxDurationMs: number;
+        maxResponseBytes?: number;
+        exposeSql?: boolean;
+    };
+};
+/** Heterogeneous registry: inputs vary per operation, so checks retain unknown values. */
+export type DataOperations = Record<string, OperationContracts[string] & Omit<DataOperation<never, unknown>, 'input' | 'output' | 'checks'> & {
+    checks: readonly unknown[];
+}>;
+export type DataQueryInput<Operations extends OperationContracts> = {
+    [Name in keyof Operations & string]: {
+        operation: Name;
+        input: InputOf<Operations[Name]>;
+    };
+}[keyof Operations & string];
+export type DataQueryBody<Output> = {
+    data: Output;
+    requestId: string;
+    queriedAt: string;
+    queryIds: string[];
+    queries?: DisclosedQuery[];
+};
+/** Delivery envelope shared by HTTP and iframe transports. */
+export type TransportResponse<Body = unknown> = {
+    status: number;
+    body: Body;
+};

package/dist/types/core/operation.d.ts

@@ -0,0 +1,21 @@
+import type { DataOperations, Lakehouse, DataQueryBody } from './operation-types.js';
+type Operation = DataOperations[string];
+type OperationExecutionOptions = {
+    operationName: string;
+    lakehouse: Lakehouse;
+    signal: AbortSignal;
+    /** Include query evidence in the response; this does not keep browser-owned SQL private. */
+    includeSql: boolean;
+    requestId: string;
+};
+/** Shared operation execution. Adapters own authorization, delivery, and public errors. */
+export declare function executeDataOperation(operation: Operation, value: unknown, { operationName, lakehouse, signal: requestSignal, includeSql, requestId, }: OperationExecutionOptions): Promise<{
+    body: DataQueryBody<unknown>;
+    serializedBody: string;
+}>;
+export declare function toDataOperationFailure(error: unknown, aborted?: boolean): {
+    status: number;
+    code: string;
+    message: string;
+};
+export {};

package/dist/types/core/presentation.d.ts

@@ -0,0 +1,7 @@
+import type { Theme } from './appearance.js';
+/** Presentation owned by the parent shell, delivered only over a trusted bridge. */
+export type DataAppPresentation = {
+    surface: 'embedded' | 'standalone';
+    theme: Theme;
+};
+export declare function isDataAppPresentation(value: unknown): value is DataAppPresentation;

package/dist/types/core/variables.d.ts

@@ -1,7 +1,8 @@
 import { type DatePresetId, type DateRange } from './date-range.js';
 import type { DateRangeContract, DateRangeRequest } from './contract.js';
 import type { DimensionSelection, DimensionVariable } from './dimension.js';
-export type HistoryMode = 'push' | 'replace';
+import type { HistoryMode } from './navigation.js';
+export type { HistoryMode } from './navigation.js';
 /** An app-owned value with one URL representation. Controls never parse or write routes. */
 export type AppVariable<Value, Kind extends string = Value extends string ? 'text' | 'select' : 'dateRange'> = {
     kind: Kind;
@@ -79,4 +80,3 @@ export type DateRangeVariable = AppVariable<DateRangeSelection> & {
 };
 /** A date variable keeps relative presets relative and validates exact dates against source coverage. */
 export declare function dateRangeVariable({ key, label, startKey, endKey, defaultValue, contract, history, comparison, comparisonKey, }: DateRangeVariableOptions): DateRangeVariable;
-export {};

package/dist/types/embed/bridge.d.ts

@@ -0,0 +1,12 @@
+import { type DataAppConnectionOptions } from './host.js';
+import { type DataAppSourceOptions } from './source.js';
+export type DataAppBridgeOptions = (DataAppSourceOptions & {
+    connection?: never;
+    window?: never;
+    javascript?: never;
+}) | (DataAppConnectionOptions & {
+    source?: never;
+    startupTimeoutMs?: never;
+});
+/** Source mode configures and loads the iframe; connection mode attaches to a host-owned document. */
+export declare function attachDataAppBridge(options: DataAppBridgeOptions): import("./host.js").DataAppHost;

package/dist/types/embed/host.d.ts

@@ -1,3 +1,4 @@
+import type { DataAppPresentation } from '../core/presentation.js';
 import { type MessageDispatcher } from '../core/messages.js';
 export type DataAppConnection = {
     type: 'origin';
@@ -11,13 +12,21 @@ export type DataAppDiagnostic = {
     direction: 'send' | 'receive';
     type: string;
 };
-/** The bridge owns delivery and cancellation; the routed handler owns validation, authorization and execution. */
-export declare function attachDataAppBridge({ iframe, connection, javascript, onStatusChange, onDiagnostic, onMessage, window: host, }: {
+export type DataAppHost = {
+    dispose: () => void;
+    setPresentation: (presentation?: DataAppPresentation) => void;
+};
+export type DataAppHostOptions = {
     iframe: HTMLIFrameElement;
-    connection: DataAppConnection;
-    javascript?: string;
+    presentation?: DataAppPresentation;
     onStatusChange?: (status: DataAppStatus) => void;
     onDiagnostic?: (event: DataAppDiagnostic) => void;
     onMessage: MessageDispatcher;
+};
+export type DataAppConnectionOptions = DataAppHostOptions & {
+    connection: DataAppConnection;
+    javascript?: string;
     window?: Window;
-}): () => void;
+};
+/** The bridge owns delivery and cancellation; the routed handler owns validation, authorization and execution. */
+export declare function attachDataAppConnection({ iframe, connection, javascript, presentation, onStatusChange, onDiagnostic, onMessage, window: host, }: DataAppConnectionOptions): DataAppHost;

package/dist/types/embed/index.d.ts

@@ -3,9 +3,11 @@
  * @module @altertable/data-app/embed
  * @see https://github.com/altertable-ai/data-app/blob/main/docs/embed.md
  */
-export { attachDataAppBridge } from './host.js';
-export type { DataAppConnection, DataAppStatus, DataAppDiagnostic, } from './host.js';
-export { attachDataAppShell } from './shell.js';
-export type { DataAppSource, DataAppShellOptions } from './shell.js';
+export { attachDataAppBridge } from './bridge.js';
+export type { DataAppBridgeOptions } from './bridge.js';
+export type { DataAppHost, DataAppConnection, DataAppStatus, DataAppDiagnostic, } from './host.js';
+export type { DataAppSource } from './source.js';
 export { startDataAppBootstrap } from './bootstrap.js';
 export { createNavigationHandler } from './navigation.js';
+export { createSqlQueryHandler } from './sql.js';
+export type { DataAppPresentation } from '../core/presentation.js';

package/dist/types/embed/source.d.ts

@@ -0,0 +1,15 @@
+import { type DataAppHost, type DataAppHostOptions } from './host.js';
+export type DataAppSource = {
+    type: 'url';
+    url: string;
+} | {
+    type: 'bundle';
+    bootstrapUrl: string;
+    javascript: string;
+};
+export type DataAppSourceOptions = DataAppHostOptions & {
+    source: DataAppSource;
+    startupTimeoutMs?: number;
+};
+/** Owns loading and sandbox policy. Dispose before replacing the source or retrying. */
+export declare function attachDataAppSource({ iframe, source, presentation, onMessage, onStatusChange, onDiagnostic, startupTimeoutMs, }: DataAppSourceOptions): DataAppHost;

package/dist/types/embed/sql.d.ts

@@ -0,0 +1,4 @@
+import type { Lakehouse } from '../core/contract.js';
+import { type MessageContext, type SqlQueryInput } from '../core/messages.js';
+/** Authorize every SQL request and supply a backend that independently enforces access and query limits. */
+export declare function createSqlQueryHandler(authorize: (query: SqlQueryInput, context: MessageContext) => Promise<Lakehouse>): (input: SqlQueryInput, context: MessageContext) => Promise<import("../core/contract.js").QueryResult>;

package/dist/types/react/content.d.ts

@@ -1,11 +1,11 @@
 import type { ReactNode } from 'react';
 import type { DataReading, MetricReading, MetricValues } from '../core/reading.js';
 import type { DateRangeRequest } from '../core/contract.js';
-export type DataContentHelpers<Data> = {
-    select: <Value>(select: (data: Data) => Value) => DataReading<Value>;
+export type DataContentHelpers<Data, Input> = {
+    select: <Value>(select: (data: Data, input: Input) => Value) => DataReading<Value>;
     metric: (select: (data: Data) => MetricValues) => MetricReading;
 };
-export type DataContentState<Data, Input> = DataContentHelpers<Data> & ({
+export type DataContentState<Data, Input> = DataContentHelpers<Data, Input> & ({
     loading: true;
     data?: never;
     input?: never;

package/dist/types/react/embed/bridge.d.ts

@@ -1,12 +1,21 @@
-import { type ComponentRef } from 'react';
-import { type DataAppConnection, type DataAppStatus, type DataAppDiagnostic } from '../../embed/host.js';
-import type { MessageDispatcher } from '../../core/messages.js';
-export type DataAppBridgeProps = {
+import { type ComponentRef, type ComponentPropsWithoutRef } from 'react';
+import { type DataAppBridgeOptions } from '../../embed/bridge.js';
+import type { DataAppConnection } from '../../embed/host.js';
+import type { DataAppSource } from '../../embed/source.js';
+export type DataAppBridgeProps = Pick<DataAppBridgeOptions, 'onMessage' | 'onStatusChange' | 'onDiagnostic' | 'presentation'> & ({
+    source: DataAppSource;
+    title: string;
+    startupTimeoutMs?: number;
+    iframeProps?: Omit<ComponentPropsWithoutRef<'iframe'>, 'src' | 'srcDoc' | 'sandbox' | 'referrerPolicy' | 'loading' | 'children' | 'title'>;
+    iframe?: never;
+    connection?: never;
+} | {
     iframe: ComponentRef<'iframe'> | null;
     connection: DataAppConnection;
-    onMessage: MessageDispatcher;
-    onStatusChange?: (status: DataAppStatus) => void;
-    onDiagnostic?: (event: DataAppDiagnostic) => void;
-};
-/** Delivery only; the host owns the iframe and route handlers, including navigation. */
-export declare function DataAppBridge({ iframe, connection, onMessage, onStatusChange, onDiagnostic, }: DataAppBridgeProps): null;
+    source?: never;
+    title?: never;
+    startupTimeoutMs?: never;
+    iframeProps?: never;
+});
+/** Owns iframe setup and delivery. The consuming shell owns loading, error UI, and retries. */
+export declare function DataAppBridge(props: DataAppBridgeProps): import("react").JSX.Element;

package/dist/types/react/embed/index.d.ts

@@ -5,5 +5,3 @@
  */
 export { DataAppBridge } from './bridge.js';
 export type { DataAppBridgeProps } from './bridge.js';
-export { DataAppShell } from './shell.js';
-export type { DataAppShellProps } from './shell.js';