@altertable/data-app 0.64.0 → 0.66.0

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

@@ -0,0 +1,12 @@
+/** Host-owned log sink; compatible with console and frontend createLogger(). */
+export type DataAppLogger = {
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export type LogEntry = {
+    method: keyof DataAppLogger;
+    args: unknown[];
+};
+export declare function isLogEntry(value: unknown): value is LogEntry;

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

@@ -1,7 +1,9 @@
+import { type DataAppAnnotationPresentation } from './annotations.js';
 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;
+    annotations?: DataAppAnnotationPresentation;
 };
 export declare function isDataAppPresentation(value: unknown): value is DataAppPresentation;

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

@@ -50,10 +50,8 @@ export type DateRangeSelection = {
 };
 export type DateRangeVariableOptions = {
     label?: string;
-    /** URL key for a relative preset; explicit dates use startKey and endKey. */
+    /** URL key for a relative preset; explicit dates use start/end for period, otherwise key-prefixed fields. */
     key: string;
-    startKey?: string;
-    endKey?: string;
     defaultValue: DateRangeSelection & {
         comparison?: never;
     };
@@ -61,7 +59,6 @@ export type DateRangeVariableOptions = {
     history?: HistoryMode;
     /** Opt into a URL-backed comparison with the preceding equal-length range. */
     comparison?: boolean;
-    comparisonKey?: string;
 };
 export type DateRangeVariable = AppVariable<DateRangeSelection> & {
     kind: 'dateRange';
@@ -79,4 +76,4 @@ export type DateRangeVariable = AppVariable<DateRangeSelection> & {
     comparisonRange: (selection: DateRangeSelection) => DateRange | null;
 };
 /** 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 declare function dateRangeVariable({ key, label, defaultValue, contract, history, comparison, }: DateRangeVariableOptions): DateRangeVariable;

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

@@ -1,4 +1,6 @@
 import type { DataAppPresentation } from '../core/presentation.js';
+import type { DataAppLogger } from '../core/logger.js';
+import { type BridgeMessage } from '../core/bridge.js';
 import { type MessageDispatcher } from '../core/messages.js';
 export type DataAppConnection = {
     type: 'origin';
@@ -10,15 +12,17 @@ export type DataAppConnection = {
 export type DataAppStatus = 'connecting' | 'connected' | 'ready' | 'failed' | 'disconnected';
 export type DataAppDiagnostic = {
     direction: 'send' | 'receive';
-    type: string;
+    type: BridgeMessage['type'];
 };
 export type DataAppHost = {
     dispose: () => void;
     setPresentation: (presentation?: DataAppPresentation) => void;
+    setLogger: (logger?: DataAppLogger) => void;
 };
 export type DataAppHostOptions = {
     iframe: HTMLIFrameElement;
     presentation?: DataAppPresentation;
+    logger?: DataAppLogger;
     onStatusChange?: (status: DataAppStatus) => void;
     onDiagnostic?: (event: DataAppDiagnostic) => void;
     onMessage: MessageDispatcher;
@@ -29,4 +33,4 @@ export type DataAppConnectionOptions = DataAppHostOptions & {
     window?: Window;
 };
 /** 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;
+export declare function attachDataAppConnection({ iframe, connection, javascript, presentation, logger, onStatusChange, onDiagnostic, onMessage, window: host, }: DataAppConnectionOptions): DataAppHost;

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

@@ -11,3 +11,4 @@ export { startDataAppBootstrap } from './bootstrap.js';
 export { createNavigationHandler } from './navigation.js';
 export { createSqlQueryHandler } from './sql.js';
 export type { DataAppPresentation } from '../core/presentation.js';
+export type { DataAppLogger } from '../core/logger.js';

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

@@ -12,4 +12,4 @@ export type DataAppSourceOptions = DataAppHostOptions & {
     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;
+export declare function attachDataAppSource({ iframe, source, presentation, logger, onMessage, onStatusChange, onDiagnostic, startupTimeoutMs, }: DataAppSourceOptions): DataAppHost;

package/dist/types/react/annotations/AnnotationBar.d.ts

@@ -0,0 +1,24 @@
+import type { Theme } from '../../core/appearance.js';
+import { type DataAppAnnotationDraft } from '../../core/annotations.js';
+export type AnnotationBarProps = {
+    annotations: readonly DataAppAnnotationDraft[];
+    active?: boolean;
+    theme?: Theme;
+    disabled?: boolean;
+    deletedAnnotationId?: string;
+    onUndoDelete?: (id: string) => void;
+    onDismissUndo?: () => void;
+    hasUnsavedChanges?: boolean;
+    pinsVisible: boolean;
+    onPinsVisibleChange: (visible: boolean) => void;
+    onSelect: (id: string) => void;
+    onDelete: (id: string) => void;
+    onClear: () => void;
+    /** Let host apps use their existing confirmation dialog. */
+    requestDiscard?: (discard: () => void) => void;
+    /** Resolve only after the outer application's agent API accepts this snapshot. */
+    onSend: (annotations: readonly DataAppAnnotationDraft[]) => Promise<void>;
+    onClose: () => void;
+};
+/** Host-owned batch controls. Collection changes and agent submission stay with the outer app. */
+export declare function AnnotationBar({ annotations, active, theme, disabled, deletedAnnotationId, onUndoDelete, onDismissUndo, hasUnsavedChanges, pinsVisible, onPinsVisibleChange, onSelect, onDelete, onClear, requestDiscard, onSend, onClose, }: AnnotationBarProps): import("react").JSX.Element | null;

package/dist/types/react/annotations/AnnotationControls.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentRef, type RefObject } from 'react';
+import type { DataAppAnnotationPresentation } from '../../core/annotations.js';
+type AnnotationControlsProps = {
+    rootRef: RefObject<ComponentRef<'div'> | null>;
+    presentation: DataAppAnnotationPresentation;
+    displayedInput?: unknown;
+    view?: string;
+};
+export declare function AnnotationControls({ rootRef, presentation, displayedInput, view, }: AnnotationControlsProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/AnnotationEditor.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentRef, CSSProperties, Ref } from 'react';
+import type { AnnotationEditorState } from './annotation-editor-state.js';
+type AnnotationEditorProps = {
+    editor: AnnotationEditorState;
+    editorRef: Ref<ComponentRef<'section'>>;
+    textareaRef: Ref<ComponentRef<'textarea'>>;
+    style: CSSProperties;
+    disabled: boolean;
+    onCommentChange: (comment: string) => void;
+    onSubmit: () => void;
+    onRetryScreenshot: () => void;
+    onShakeEnd: () => void;
+};
+export declare function AnnotationEditor({ editor, editorRef, textareaRef, style, disabled, onCommentChange, onSubmit, onRetryScreenshot, onShakeEnd, }: AnnotationEditorProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/AnnotationMarkers.d.ts

@@ -0,0 +1,19 @@
+import type { AnnotationPoint, AnnotationRect } from './annotation-targets.js';
+export type AnnotationPin = {
+    id: string;
+    number: number;
+    anchor: AnnotationPoint;
+    rect: AnnotationRect;
+};
+type AnnotationMarkersProps = {
+    outline?: AnnotationRect;
+    rounded: boolean;
+    pins: AnnotationPin[];
+    pinsVisible: boolean;
+    disabled: boolean;
+    showHint: boolean;
+    hasDuplicateIds: boolean;
+    onOpenAnnotation: (id: string) => void;
+};
+export declare function AnnotationMarkers({ outline, rounded, pins, pinsVisible, disabled, showHint, hasDuplicateIds, onOpenAnnotation, }: AnnotationMarkersProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/AnnotationSelectionLayer.d.ts

@@ -0,0 +1,12 @@
+import type { AnnotationTargetElement, AnnotationPoint, AnnotationRect } from './annotation-targets.js';
+type AnnotationSelectionLayerProps = {
+    scope: HTMLElement;
+    targets: AnnotationTargetElement[];
+    onHover: (target: AnnotationTargetElement | undefined) => void;
+    onSelect: (target: AnnotationTargetElement, point?: AnnotationPoint, region?: AnnotationRect) => void;
+    disabled: boolean;
+    editing: boolean;
+};
+/** Own pointer selection and keyboard focus while the app underneath is inert. */
+export declare function AnnotationSelectionLayer({ scope, targets, onHover, onSelect, disabled, editing, }: AnnotationSelectionLayerProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/AnnotationTarget.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithRef } from 'react';
+import type { WidgetEvidence } from '../ui/WidgetEvidence.js';
+export type AnnotationTargetProps = ComponentPropsWithRef<'div'> & {
+    annotationId: string;
+    label: string;
+    evidence?: WidgetEvidence;
+};
+/** A stable feedback target for app-owned content outside the built-in widgets. */
+export declare function AnnotationTarget({ annotationId, label, evidence, ...props }: AnnotationTargetProps): import("react").JSX.Element;

package/dist/types/react/annotations/AnnotationTooltip.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import type { Theme } from '../../core/appearance.js';
+type AnnotationTooltipProps = {
+    content: ReactNode;
+    children: ReactNode;
+    theme?: Theme;
+};
+export declare function AnnotationTooltip({ content, children, theme, }: AnnotationTooltipProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/AnnotationTrigger.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentRef, Ref } from 'react';
+type AnnotationTriggerProps = {
+    buttonRef: Ref<ComponentRef<'button'>>;
+    active: boolean;
+    disabled: boolean;
+    count: number;
+    onToggle: () => void;
+};
+export declare function AnnotationTrigger({ buttonRef, active, disabled, count, onToggle, }: AnnotationTriggerProps): import("react").JSX.Element;
+export {};

package/dist/types/react/annotations/annotation-editor-state.d.ts

@@ -0,0 +1,56 @@
+import type { DataAppAnnotationDraft } from '../../core/annotations.js';
+import type { AnnotationTargetElement } from './annotation-targets.js';
+export type AnnotationEditorState = {
+    target: AnnotationTargetElement;
+    draft: DataAppAnnotationDraft;
+    annotationId?: string;
+    comment: string;
+    captureStatus: 'capturing' | 'ready' | 'failed';
+    error: string;
+    discardArmed: boolean;
+    shaking: boolean;
+};
+type AnnotationControlsState = {
+    annotationModeActive: boolean;
+    observedActive: boolean;
+    hoveredTarget?: AnnotationTargetElement;
+    editor?: AnnotationEditorState;
+    saving: boolean;
+};
+type AnnotationControlsAction = {
+    type: 'annotationModeChanged';
+    active: boolean;
+} | {
+    type: 'externalModeObserved';
+    active: boolean;
+} | {
+    type: 'targetHovered';
+    target?: AnnotationTargetElement;
+} | {
+    type: 'editorOpened';
+    editor: AnnotationEditorState;
+} | {
+    type: 'editorClosed';
+} | {
+    type: 'commentChanged';
+    comment: string;
+} | {
+    type: 'captureCompleted';
+    draftId: string;
+    succeeded: boolean;
+} | {
+    type: 'editorEscaped';
+    hasUnsavedChanges: boolean;
+} | {
+    type: 'shakeFinished';
+} | {
+    type: 'saveStarted';
+} | {
+    type: 'saveFailed';
+    error: string;
+} | {
+    type: 'saveFinished';
+};
+export declare function createAnnotationControlsState(active: boolean): AnnotationControlsState;
+export declare function annotationControlsReducer(state: AnnotationControlsState, action: AnnotationControlsAction): AnnotationControlsState;
+export {};

package/dist/types/react/annotations/annotation-screenshot.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationRect } from './annotation-targets.js';
+import type { DataAppAnnotationDraft } from '../../core/annotations.js';
+/** Capture the visible target at selection time; never include annotation controls. */
+export declare function captureAnnotationScreenshot(element: HTMLElement, region?: AnnotationRect): Promise<NonNullable<DataAppAnnotationDraft['context']['screenshot']>>;

package/dist/types/react/annotations/annotation-targets.d.ts

@@ -0,0 +1,33 @@
+export type AnnotationPoint = {
+    x: number;
+    y: number;
+};
+export type AnnotationRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type AnnotationTargetElement = {
+    element: HTMLElement;
+    id: string;
+    label: string;
+    kind: 'widget' | 'element' | 'app';
+};
+export declare function discoverAnnotationTargets(root: HTMLElement | null): {
+    targets: AnnotationTargetElement[];
+    hasDuplicateIds: boolean;
+};
+export declare function annotationGeometry(element: HTMLElement): AnnotationRect;
+export declare function annotationPoint(rect: AnnotationRect, point?: AnnotationPoint): {
+    cursor: AnnotationPoint;
+    anchor: {
+        x: number;
+        y: number;
+    };
+};
+/** The iframe document is a crop surface, never a selectable global-layout target. */
+export declare function annotationRoot(root: HTMLElement | null): AnnotationTargetElement | undefined;
+export declare function findAnnotationTarget(root: HTMLElement | null, id: string | undefined): AnnotationTargetElement | undefined;
+export declare function normalizeAnnotationRect(area: AnnotationRect, target: AnnotationRect): AnnotationRect;
+export declare function projectAnnotationRect(area: AnnotationRect, target: AnnotationRect): AnnotationRect;

package/dist/types/react/annotations/getAnnotationProps.d.ts

@@ -0,0 +1,15 @@
+import type { WidgetEvidence } from '../ui/WidgetEvidence.js';
+type AnnotationPropsOptions = {
+    id?: string;
+    label?: string;
+    evidence?: WidgetEvidence;
+    kind?: 'widget' | 'element';
+};
+export declare function getAnnotationProps({ id, label, evidence, kind, }: AnnotationPropsOptions): {
+    'data-annotation-id': string | undefined;
+    'data-annotation-label': string | undefined;
+    'data-annotation-kind': "element" | "widget";
+    'data-annotation-queries': string;
+    'data-annotation-glossary': string;
+};
+export {};

package/dist/types/react/annotations/styles.d.ts

@@ -0,0 +1,3 @@
+import type { DataAppStylesOptions } from '../styles.js';
+/** Install only the outer-frame annotation controls; leave host page typography and layout intact. */
+export declare function injectDataAppAnnotationStyles(options?: DataAppStylesOptions): HTMLStyleElement;

package/dist/types/react/annotations/useAnnotationGeometry.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentRef, type RefObject } from 'react';
+import type { DataAppAnnotationPresentation } from '../../core/annotations.js';
+import { type AnnotationRect, type AnnotationTargetElement } from './annotation-targets.js';
+import type { AnnotationPin } from './AnnotationMarkers.js';
+type AnnotationRootRef = RefObject<ComponentRef<'div'> | null>;
+export declare function useAnnotationTargets(rootRef: AnnotationRootRef, active: boolean): {
+    targets: AnnotationTargetElement[];
+    hasDuplicateIds: boolean;
+} & {
+    scope?: HTMLElement;
+};
+type AnnotationGeometryOptions = {
+    rootRef: AnnotationRootRef;
+    target?: AnnotationTargetElement;
+    region?: AnnotationRect;
+    targets: DataAppAnnotationPresentation['targets'];
+};
+export declare function useAnnotationGeometry({ rootRef, target, region, targets, }: AnnotationGeometryOptions): {
+    pins: AnnotationPin[];
+    outline?: AnnotationRect;
+};
+export {};

package/dist/types/react/annotations/useDataAppAnnotations.d.ts

@@ -0,0 +1,19 @@
+/** Bind annotation delivery to this app's current iframe bridge. The host owns storage and submission. */
+export declare function useDataAppAnnotations(): {
+    reportAnnotationEditorState(state: {
+        hasUnsavedChanges: boolean;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<null>;
+    addAnnotation(draft: import("../../core/annotations.js").DataAppAnnotationDraft, options?: {
+        signal?: AbortSignal;
+    }): Promise<null>;
+    updateAnnotation(id: string, comment: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<null>;
+    requestAnnotationModeChange(request: {
+        active: boolean;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<null>;
+};

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

@@ -0,0 +1,110 @@
+import type { EvidenceDeclaration } from './ui/data-context.js';
+import type { ReactNode } from 'react';
+import type { DateRangeRequest } from '../core/contract.js';
+import type { DataView, DisplayedSnapshot } from '../core/data-view.js';
+import type { MetricFormat } from '../core/format.js';
+import type { DataReading, MetricValues } from '../core/reading.js';
+import type { CsvCell, CsvTable, CsvExport } from './ui/csv-export.js';
+import type { MetricDefinition } from './ui/metric.js';
+import type { EmptyContent } from './ui/presentation.js';
+import type { TableWidgetColumn } from './ui/TableWidget.js';
+import type { WidgetEvidence } from './ui/WidgetEvidence.js';
+/** Displayed data, or an initial loading reading. Pending filter values are never a source. */
+export type ViewSource<Data, Input> = {
+    loading: true;
+} | {
+    loading?: false;
+    data: Data;
+    input: Input;
+};
+type SourceReading<Source, Value> = Source extends {
+    loading: true;
+} ? {
+    loading: true;
+} : {
+    loading: false;
+    value: Value;
+};
+/** Keys supply IDs; accessors supply raw CSV values. Formats affect display only. */
+export type DatasetColumn<Row> = {
+    label?: string;
+} & ({
+    value: (row: Row) => CsvCell;
+    format?: (row: Row) => ReactNode;
+} | {
+    value: (row: Row) => number | null | undefined;
+    format: MetricFormat;
+});
+export type DatasetDefinition<Data, Input, Row, Evidence = WidgetEvidence> = {
+    name: string;
+    select: (data: Data, input: Input) => readonly Row[];
+    columns: Record<string, DatasetColumn<NoInfer<Row>>>;
+    rowKey: (row: NoInfer<Row>) => string | number;
+    evidence: Evidence;
+    emptyFallback?: EmptyContent;
+};
+/** Authoring references are registered by the owning view. */
+export type DatasetDeclaration<Data, Input, Row> = DatasetDefinition<Data, Input, Row, EvidenceDeclaration>;
+/** Real view ownership and registered references, shared by metrics and datasets. */
+export declare class RegisteredBinding {
+    #private;
+    constructor(owner?: object, evidence?: WidgetEvidence);
+    protected assertSource(source: object): void;
+    static evidence(binding: RegisteredBinding, owner: object): WidgetEvidence;
+}
+export declare function registeredEvidence(binding: RegisteredBinding, owner: object): WidgetEvidence;
+export declare class ExportDataset<Data, Input> extends RegisteredBinding {
+    #private;
+    readonly name: string;
+    constructor(name: string, csv: (snapshot: DisplayedSnapshot<Data, Input>) => CsvTable, owner?: object, evidence?: WidgetEvidence);
+    static csv<Data, Input>(dataset: ExportDataset<Data, Input>, snapshot: DisplayedSnapshot<Data, Input>): CsvTable;
+}
+export declare class Dataset<Data, Input, Row> extends ExportDataset<Data, Input> {
+    #private;
+    readonly evidence: WidgetEvidence;
+    constructor(definition: DatasetDefinition<Data, Input, Row>, owner?: object);
+    read: <Source extends ViewSource<Data, Input>>(source: Source) => SourceReading<Source, readonly Row[]>;
+    static table<Data, Input, Row>(dataset: Dataset<Data, Input, Row>, source: ViewSource<Data, Input>): {
+        title: string;
+        columns: [TableWidgetColumn<Row>, ...TableWidgetColumn<Row>[]];
+        rowKey: (row: Row) => string | number;
+        evidence: WidgetEvidence;
+        emptyFallback: EmptyContent;
+        reading: {
+            loading: true;
+        } | {
+            loading: false;
+            value: readonly Row[];
+        };
+    };
+}
+export declare function bindDataset<Data, Input, Row>(definition: DatasetDefinition<Data, Input, Row>, owner?: object): Dataset<Data, Input, Row>;
+export declare function datasetTable<Data, Input, Row>(dataset: Dataset<Data, Input, Row>, source: ViewSource<Data, Input>): {
+    title: string;
+    columns: [TableWidgetColumn<Row>, ...TableWidgetColumn<Row>[]];
+    rowKey: (row: Row) => string | number;
+    evidence: WidgetEvidence;
+    emptyFallback: EmptyContent;
+    reading: {
+        loading: true;
+    } | {
+        loading: false;
+        value: readonly Row[];
+    };
+};
+export declare function datasetCsv<Data, Input>(dataset: ExportDataset<Data, Input>, snapshot: DisplayedSnapshot<Data, Input>): CsvTable;
+export declare class Metric<Data, Input> extends RegisteredBinding {
+    #private;
+    readonly definition: MetricDefinition;
+    constructor(definition: MetricDefinition, select: (data: Data, input: Input) => MetricValues, date?: (input: Input) => DateRangeRequest, owner?: object);
+    read: <Source extends ViewSource<Data, Input>>(source: Source) => SourceReading<Source, MetricValues & {
+        period?: DateRangeRequest;
+    }>;
+}
+export declare function bindMetric<Data, Input>(definition: MetricDefinition, select: (data: Data, input: Input) => MetricValues, date?: (input: Input) => DateRangeRequest, owner?: object): Metric<Data, Input>;
+export declare function displayedScope<Data, Input>(view: DataView<Data, Input>, describeInput: (input: Input) => string): DataReading<string>;
+export declare function exportDatasets<Data, Input>(datasets: readonly [
+    ExportDataset<Data, Input>,
+    ...ExportDataset<Data, Input>[]
+], snapshot: DisplayedSnapshot<Data, Input>, scope: string, appTitle: string): CsvExport;
+export {};

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

@@ -1,11 +1,9 @@
+import type { DeclaredView } from './view-runtime.js';
 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, Input> = {
-    select: <Value>(select: (data: Data, input: Input) => Value) => DataReading<Value>;
-    metric: (select: (data: Data) => MetricValues) => MetricReading;
-};
-export type DataContentState<Data, Input> = DataContentHelpers<Data, Input> & ({
+import type { DataReading } from '../core/reading.js';
+export type DataContentState<Data, Input> = {
+    scope: DataReading<string>;
+} & ({
     loading: true;
     data?: never;
     input?: never;
@@ -14,10 +12,25 @@ export type DataContentState<Data, Input> = DataContentHelpers<Data, Input> & ({
     data: Data;
     input: Input;
 });
-/** Selectors run only for displayed data. Date comparisons inherit that result's input. */
+/** Content receives only displayed data, its original input, and the derived scope. */
 export declare function defineDataContent<Data, Input>(render: (state: DataContentState<Data, Input>) => ReactNode, options?: {
-    date?: (input: Input) => DateRangeRequest;
+    describeInput?: (input: Input) => string;
 }): {
-    loading: ReactNode;
-    children(data: Data, input: Input): ReactNode;
+    loadingFallback: ReactNode;
+    children(this: void, data: Data, input: Input): ReactNode;
+};
+/** A section's request owner and render layout are declared together. */
+export declare class ViewContent<Data, Input> {
+    #private;
+    constructor(view: DeclaredView<Data, Input>, render: (source: DataContentState<Data, Input>) => ReactNode, describeInput: (input: Input) => string);
+    static section<Data, Input>(content: ViewContent<Data, Input>): {
+        loadingFallback: ReactNode;
+        children(this: void, data: Data, input: Input): ReactNode;
+        view: DeclaredView<Data, Input, unknown>;
+    };
+}
+export declare function sectionContent<Data, Input>(content: ViewContent<Data, Input>): {
+    loadingFallback: ReactNode;
+    children(this: void, data: Data, input: Input): ReactNode;
+    view: DeclaredView<Data, Input, unknown>;
 };

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

@@ -2,7 +2,7 @@ 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'> & ({
+export type DataAppBridgeProps = Pick<DataAppBridgeOptions, 'onMessage' | 'onStatusChange' | 'onDiagnostic' | 'presentation' | 'logger'> & ({
     source: DataAppSource;
     title: string;
     startupTimeoutMs?: number;