@altertable/data-app 0.64.0 → 0.66.0

package/docs/ui.md

@@ -0,0 +1,41 @@
+# Direct UI composition
+
+Import from `@altertable/data-app/react/ui` for setup/static screens, custom
+controls, or a deliberately custom shell. Standard data apps use declared views
+and bound widgets from `/react`.
+
+`<DataApp>` here renders a static screen and accepts optional direct CSV data.
+Direct widget forms accept local values or rows. `<DataWidget>` supplies a generic
+frame for deliberately custom content. Use `<GettingStarted>` for
+connection setup. Fetched data belongs to a declared view; avoid inventing
+request states to populate a shell.
+
+Direct `<DateRangePicker>`, `<DimensionPicker>`, and `useAppVariables()` support
+custom control ownership. The caller supplies values and change handlers.
+Custom tables use `<DataTable>` and its cell helpers; controls and overlays
+include `<SearchField>`, `<Combobox>`, `<Tabs>`, `<Sheet>`, and `<HelpPopover>`.
+
+Standalone `<AboutData>`, glossary components, and `<PresentStory>` support
+custom inspection and presentation. Supply registered context and evidence, and
+derive findings from the displayed data. Standard widgets and `<DataApp>`
+already own these experiences.
+
+For framework mounting, `<DataAppProvider>` supplies shared requests and one inspection sheet. Wrap custom shells in it.
+Call `injectDataAppStyles()` before mounting either entry; imports do not install
+styles.
+
+## Charts
+
+Choose a chart using the [visualization guide](widgets.md#choose-a-visualization).
+Import `<BarChart>`, `<LineChart>`, `<AreaChart>`, `<PieChart>`, or `<ScatterChart>` from
+`/react/ui`. Compose the visual inside `<VisualizationWidget dataset={dataset} source={result}>`
+so rows, loading state, evidence, and inspection come from that dataset.
+Pass ordered items with unique, nonblank IDs and finite numbers. Bar and pie
+values must be nonnegative. Use `formatValue` for domain formatting.
+
+Line and area charts show equally spaced samples; include missing periods in the
+input. These charts space items evenly, so they do not represent irregular time
+intervals. Distinguish a missing observation from measured zero when preparing
+the samples. Pie slices represent mutually exclusive parts of one total; shares
+use the sum of supplied items, so include Other when showing a subset of the
+whole. Scatter points represent independent X/Y observations.

package/docs/variables.md

@@ -0,0 +1,98 @@
+# Variables and filters
+
+## Time views and field filters
+
+`createDataHooks(client).defineTimeView()` owns the `period` variable, calendar
+controls, and displayed-period label. Declare `time: { contract, defaultValue }`,
+an operation, `isEmpty` (a predicate), and `emptyFallback` (a title and optional
+description for an empty result). With no additional variables, its default
+input is the calendar request. With additional variables, it is `{ period, ...variables }`.
+Supply an `input` mapper for a different operation shape and `bindings` to extract
+nested period or field-filter inputs. Mappings must preserve the selected values.
+
+`dimensionFilter()` from `/contract` requires exactly one option source: fixed `options` or a `facet`.
+Use `defineFacetFilter()` to bind a facet operation and its typed input. `<DimensionPicker>` offers missing values separately and keeps selected values
+available when they have zero matches.
+
+## Declare controls once
+
+Use `textVariable()`, `selectVariable()`, and `dateRangeVariable()` in a view's
+`variables`. `<DataApp view={view}>` generates their controls and keeps values in the URL.
+Keep local search out of the operation input when it only filters loaded rows.
+
+The [date range contract](contract.md#shared-date-ranges) owns source coverage,
+maximum range, time zone, and comparison rules. `defineTimeView()` is the compact
+path for a view whose primary input is a period. Use `defineDataView()` for fixed
+snapshots or other input shapes.
+
+```ts
+const activity = defineTimeView({
+  dataContext,
+  operation: 'activity',
+  time: { contract: calendar, defaultValue: { kind: 'preset', id: 'last-7' } },
+  variables: { region: textVariable({ key: 'region' }) },
+  input: values => ({
+    filters: { period: values.period, region: values.region },
+  }),
+  bindings: {
+    period: input => input.filters.period,
+    region: input => input.filters.region,
+  },
+  isEmpty: data => data.rows.length === 0,
+  emptyFallback: { title: 'No activity' },
+});
+```
+
+The operation, calendar, and row shape are app-owned. Bindings must extract
+selected values unchanged.
+
+## URL state and custom controls
+
+Relative date presets remain relative. Explicit dates use `start`, `end`, and
+`compare` for the `period` variable; other date variables derive these keys from
+their own key. Invalid URL values fall back to validated defaults. Do not use
+reserved inspection, presentation, or navigation keys for app variables.
+
+Choose push history for meaningful selections and replace history for typing.
+Back/Forward restores the same values and controls. Use generated controls for
+standard data apps. Direct pickers and standalone URL state belong to
+[direct UI composition](ui.md).
+
+## Fixed options and query-backed facets
+
+Declare fixed choices with `dimensionFilter()` from `/contract`:
+
+```ts
+const region = dimensionFilter({
+  key: 'region',
+  label: 'Region',
+  valueType: 'string',
+  selection: 'multiple',
+  options: [{ value: 'Europe', label: 'Europe' }],
+});
+```
+
+For query-backed choices use the hooks factory's `defineFacetFilter()`. The
+facet operation returns parsed dimension options. Its input mapper reads current
+resolved variables, including other filters:
+
+```ts
+const { defineFacetFilter, defineTimeView } = createDataHooks(client);
+const region = defineFacetFilter({
+  key: 'region',
+  label: 'Region',
+  valueType: 'string',
+  selection: 'multiple',
+  facet: {
+    operation: 'regions',
+    input: values => ({ period: values.period as DateRangeRequest }),
+  },
+});
+```
+
+The client registry defines the `regions` operation and its typed period input;
+import `DateRangeRequest` from `/contract`. Put `region` in the view's `variables`
+alongside its period. Use `parseFacetOptions()` to validate facet results, and
+`dimensionPredicate()` to build a bounded SQL filter from parsed selections.
+For the operation's input parser, use `parseDimensionSelection(value, region)` from `/contract`.
+A dimension without an explicit selection represents all members.

package/docs/views.md

@@ -0,0 +1,127 @@
+# Views and displayed results
+
+## Bind a view
+
+```tsx
+import { createDataClient } from '@altertable/data-app/client';
+import {
+  createDataHooks,
+  DataApp,
+  DataSection,
+} from '@altertable/data-app/react';
+import type { operations } from '#app/operations.ts';
+
+const client = createDataClient<typeof operations>();
+const { defineDataView } = createDataHooks(client);
+const activityView = defineDataView({
+  dataContext,
+  operation: 'activity',
+  describeInput: () => 'all activity',
+  isEmpty: data => data.rows.length === 0,
+  emptyFallback: { title: 'No activity' },
+});
+const content = activityView.content(result => (
+  <ActivityWidgets source={result} />
+));
+
+function App() {
+  return (
+    <DataApp
+      config={config}
+      view={activityView}
+      story={story}
+      datasets={[activityDataset]}
+    >
+      <DataSection content={content} />
+    </DataApp>
+  );
+}
+```
+
+Omit `variables` when there are no controls. Omit `input` when the resolved
+variables match the operation input; nested or different inputs need a mapper.
+The operation and `ActivityWidgets` are app-owned. The bound widgets derive
+loading content from their source; see [widgets](widgets.md) and the
+[complete starter](../examples/starter-data-app/index.tsx). Define
+[filters](variables.md), [context and evidence](data-context.md), and
+[story and datasets](stories-and-export.md) for the app's question.
+
+Render static text immediately; skeletonize only dynamic content. Keep section
+introductions outside request boundaries so they remain visible on empty and
+error states.
+
+Use `<DataSection>` for each independently fetched subtree and `view.content()`
+to share its loading and ready layout. Refreshes retain displayed content.
+
+Use `<DataValue>` for a dynamic value within static prose:
+
+```tsx
+<p>
+  Orders in the last 7 days: <DataValue metric={weeklyOrders} source={result} />
+</p>
+```
+
+Bind the whole sentence with `<TextWidget>` when its wording depends on the result.
+Use `<DataValue scope={result.scope} />` for the displayed scope label.
+
+Use the same [date range contract](contract.md#shared-date-ranges) for the
+operation and its view. For nested inputs, bind the range with
+`input: input => input.period`.
+
+Use `result.scope` inside `view.content()` as a reading for scope text. In stories and exports,
+`view.scope(snapshot)` returns the same label from the displayed input, using
+`describeInput` or the view's date label.
+
+Declare standard controls in the view's [variables](variables.md). Keep
+local-only filters out of the operation's `input`.
+
+For large tables, use query-backed pagination with a stable sort and total
+count. Client pagination and search cover only the rows already returned.
+
+Declare evidence references on `view.dataset()` for charts and tables. `<MetricWidget>` uses
+its metric definition for the label, format, and evidence; keep view-specific
+descriptions on the widget.
+
+`<MetricWidget>` and `<Comparison>` share a metric reading. Comparisons
+follow the displayed result's range.
+
+Use the [format helpers](formatting-and-appearance.md) for metric formats and values in tables,
+charts, and custom views.
+
+## Preserve displayed results
+
+The callback in `view.content()` receives a displayed source with `loading`,
+`data`, `input`, and `scope`. Bind widgets to that source. Its input remains the
+one that produced the visible data during refreshes and failures.
+
+Keep the client stable across renders; create it outside the component.
+
+## Request ownership
+
+`<DataApp>` owns the toolbar, controls, inspection, and page feedback for its
+primary `view`. It always renders children, so introductions and static
+context remain visible while a section loads. It requires both
+[story and CSV export](stories-and-export.md) for a data request.
+
+Place `<DataSection content={content}>` around each independently fetched subtree.
+Declare its shared loading and ready layout with `view.content()`. The section
+inherits empty copy from its view, with an optional local override, and handles
+initial errors and retries. Primary content shares the app's displayed result;
+independent content uses its own context and executed queries.
+
+Keep related datasets in one view so export and story share a coherent snapshot.
+
+| State           | Display                                                   |
+| --------------- | --------------------------------------------------------- |
+| Initial loading | The authored loading fallback; selectors do not run       |
+| Initial error   | A source-aware error with retry when recovery is possible |
+| Empty result    | The authored empty fallback                               |
+| Ready           | Data and the input that produced it                       |
+| Updating        | The prior result and its original input, fully readable   |
+| Failed refresh  | The prior result and its evidence, with recovery feedback |
+
+`isEmpty` is app-owned. A measured zero is valid data unless the analysis explicitly
+says otherwise. Use the displayed input in content, export, and story callbacks for scope labels.
+
+`<DataApp>` owns request execution, refresh, and cancellation. Keep raw request
+state out of app code.

package/docs/widgets.md

@@ -0,0 +1,142 @@
+# Widgets and narrative
+
+## Choose a widget
+
+Metrics, tables, and visualizations from `/react` consume view bindings and a source. For static displays, use
+[direct UI composition](ui.md).
+Manage requests in the [view and section](views.md); show skeletons for loading
+readings without inventing values. Use `isEmpty` for the predicate and
+`emptyFallback` for empty-result copy.
+
+| Need                                             | Component               |
+| ------------------------------------------------ | ----------------------- |
+| Metric with formatting, comparison, and evidence | `<MetricWidget>`        |
+| Custom chart or alternate chart views            | `<VisualizationWidget>` |
+| Defined columns, local search, and pagination    | `<TableWidget>`         |
+| Narrative panel                                  | `<TextWidget>`          |
+| Borderless explanatory prose                     | `<TextContent>`         |
+| One data-dependent phrase within static prose    | `<DataValue>`           |
+
+Use [layout](layout.md) for `<Stack>`, `<Grid>`, and responsive `<GridItem>` spans.
+`<Skeleton>` supports custom fallback content; `/react/ui` supplies
+`<DataAppSkeleton>` for iframe startup.
+
+## Choose a visualization
+
+Choose the component by the reader's question. Compose dataset visuals inside
+`<VisualizationWidget>`; use `<MetricWidget>` for a headline value. Built-in
+charts come from `/react/ui`; `<Ranking>`, `<Breakdown>`, and `<Comparison>`
+are also available from `/react`.
+
+| Question or need                                          | Component        | Guidance                                                                                                           |
+| --------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------ |
+| How do categories compare?                                | `<BarChart>`     | Compare nonnegative category values; order by value for rank or by a meaningful category order.                    |
+| Which items lead?                                         | `<Ranking>`      | Use a compact ordered list with values and optional detail. Tracks scale to the largest visible item, not a total. |
+| How does a measure change over time?                      | `<LineChart>`    | Use ordered, equally spaced samples to emphasize the trend.                                                        |
+| How large is the measure over time?                       | `<AreaChart>`    | Use the same samples as a line chart when filled magnitude relative to zero helps answer the question.             |
+| What makes up the whole?                                  | `<PieChart>`     | Use a few mutually exclusive parts of one total; include the remainder as Other.                                   |
+| What share of an observed total does each part represent? | `<Breakdown>`    | Use a compact display of values and shares with an explicit total, including when only some parts are shown.       |
+| How are two numeric measures related?                     | `<ScatterChart>` | Use independent X/Y observations to explore relationships, clusters, and outliers.                                 |
+| How did one metric change between periods?                | `<Comparison>`   | Use the metric reading and its displayed comparison period.                                                        |
+| What are the exact values or row details?                 | `<TableWidget>`  | Use a bound table for lookup, search, and precise comparisons.                                                     |
+
+Prefer bars or a ranking when readers need to compare similarly sized categories;
+use a pie for a simple composition question. Prefer a line when the trend is
+enough; use area when the fill adds meaning. Keep exact values available in a
+table when they matter. Follow the [chart input constraints](ui.md#charts).
+
+Use widget `views` when a chart and another representation answer the same
+question from the same dataset.
+
+## Declare datasets and metrics
+
+Bind reusable selections to the view. Declare evidence references directly;
+the view validates them against its own context. A dataset's columns supply both formatted
+table cells and raw CSV values. Widgets derive their readings, evidence, and empty fallback from the binding.
+
+```tsx
+const countries = activityView.dataset({
+  name: 'Countries',
+  select: data => data.countries,
+  rowKey: row => row.country,
+  evidence: { id: 'countries', glossaryIds: ['identities'] },
+  columns: {
+    country: { value: row => row.country },
+    count: { value: row => row.count, format: { kind: 'count' } },
+  },
+});
+const total = activityView.metric(
+  {
+    id: 'tracked-identities',
+    glossaryId: 'identities',
+    format: { kind: 'count' },
+  },
+  data => ({
+    current: data.count,
+    previous: data.previousCount,
+  })
+);
+const content = activityView.content(result => (
+  <Grid columns={2}>
+    <MetricWidget metric={total} source={result} />
+    <TableWidget dataset={countries} source={result} />
+    <VisualizationWidget dataset={countries} source={result}>
+      {rows => <CountryChart rows={rows} />}
+    </VisualizationWidget>
+  </Grid>
+));
+```
+
+Column keys supply unique IDs and readable default labels. Use `label` for a
+specific display/export header. Declare selectors, raw value accessors, and
+row-key callbacks explicitly; row keys must be stable and unique.
+Metric comparisons require a
+view date binding. `read()` returns a loading-aware value for custom prose.
+Pass the binding and `source={snapshot}` to reuse a widget in a story. Use the
+source supplied by that binding's own view; reconstructed or foreign sources
+are rejected before selection.
+Selectors do not run during loading. Table search, pagination, descriptions, and
+actions remain local choices. For custom cells, use `format: row => ...`; CSV
+still uses the raw `value` accessor. Datasets default to “No results”; supply
+`emptyFallback` for specific copy. See [export](stories-and-export.md).
+
+## Narrative text
+
+Use `<TextContent>` for prose within a page or custom layout, and `<TextWidget>`
+when the explanation belongs in a titled panel alongside other widgets.
+
+Give text a purpose: frame the question, explain how to interpret a comparison,
+qualify a finding, or suggest what to explore next. Choose the content for the
+reader's question.
+
+For data-dependent text, pass `metric` or `dataset` and `source` to `<TextWidget>`.
+It derives its title and evidence. A metric formats its current value by default;
+use a child renderer for authored prose. Dataset renderers receive displayed rows,
+including an empty selection, so they can explain zero activity.
+
+Use `<DataValue metric={total} source={result} />` for a formatted value inside
+static prose, or pass a dataset and row renderer. Its default loading fallback is
+an inline skeleton. Use `<DataValue scope={result.scope} />` for a scope label.
+All selectors use the displayed source; loading selectors do not run.
+Use `<TextContent>` for static instructions; local filters should feed the same
+filtered data to the text and its related visualization.
+
+## Custom visuals and controls
+
+`<Ranking>`, `<Breakdown>`, and `<Comparison>`
+compose inside authored widgets. Use [built-in charts](ui.md#charts) from `/react/ui`
+inside `<VisualizationWidget dataset={dataset} source={result}>` for displayed rows.
+The dataset owns evidence and empty copy; an empty row selection shows that fallback. A visualization's `views` declaration keeps
+alternate-view selection shared with its inspection sheet. Give views stable IDs
+and keep interactive state above the widget, since inspection may render it again.
+
+`<TableWidget>` searches and paginates only the supplied rows. Use query-backed
+pagination with a stable sort and total count for larger datasets. The `limit`
+mode shows a bounded preview without local pagination. Custom tables can use
+`<DataTable>`, `<DataTableEmptyRow>`, `<DataTableTimestamp>`, and `<DataTableShare>`.
+
+For custom controls, tables, and overlays, see [direct UI composition](ui.md).
+For embedded theme and chrome, see [parent presentation](embed.md#parent-presentation).
+
+`<TooltipProvider>` shares hover timing outside `<DataApp>`; the app already
+provides it.

package/examples/starter-data-app/index.tsx

@@ -1,3 +1,4 @@
+import { formatMetric } from '@altertable/data-app/format';
 import { createDataClient } from '@altertable/data-app/client';
 import type { DataAppConfig } from '@altertable/data-app/config';
 import {
@@ -9,6 +10,12 @@ import {
   createDataContext,
   createDataHooks,
   DataApp,
+  DataSection,
+  DataValue,
+  TableWidget,
+  Grid,
+  Stack,
+  TextContent,
   injectDataAppStyles,
   mountDataApp,
   MetricWidget,
@@ -90,68 +97,106 @@ const sampleDataContext = createDataContext(queryNames)({
     },
   },
 });
-const { defineDataView, useView } = createDataHooks(
-  createDataClient({ operations })
-);
+const { defineDataView } = createDataHooks(createDataClient({ operations }));
 const sampleCountsView = defineDataView({
+  dataContext: sampleDataContext,
   operation: 'sampleCountsByGroup',
   variables: {
     groupName: textVariable({ key: 'group', label: 'Group', defaultValue: '' }),
   },
-  input: ({ groupName }) => ({ groupName }),
   describeInput: ({ groupName }) =>
     groupName ? `group ${groupName}` : 'all groups',
   isEmpty: sampleCounts => sampleCounts.length === 0,
-  empty: {
+  emptyFallback: {
     title: 'No matching groups',
     description: 'Try Alpha, Beta, or clear the group filter.',
   },
 });
+const sampleCounts = sampleCountsView.dataset({
+  name: 'Sample counts',
+  select: rows => rows,
+  rowKey: row => row.groupName,
+  columns: {
+    groupName: { label: 'Group', value: row => row.groupName },
+    sampleCount: { value: row => row.sampleCount, format: { kind: 'count' } },
+  },
+  evidence: {
+    id: 'counts-by-group',
+    glossaryIds: ['sampleCount'],
+  },
+});
+const totalSamples = sampleCountsView.metric(
+  {
+    id: 'total-samples',
+    glossaryId: 'sampleCount',
+    label: 'Total samples',
+    format: { kind: 'count' },
+  },
+  rows => ({ current: rows.reduce((sum, row) => sum + row.sampleCount, 0) })
+);
+const sampleContent = sampleCountsView.content(result => (
+  <Stack aria-label="Sample results">
+    <TextContent>
+      <p>
+        Showing <DataValue scope={result.scope} />
+      </p>
+    </TextContent>
+    <Grid columns={2}>
+      <MetricWidget
+        metric={totalSamples}
+        source={result}
+        description="Sum of the fixture counts in the selected groups."
+      />
+      <TableWidget
+        dataset={sampleCounts}
+        source={result}
+        title="Counts by group"
+        description="Alpha and Beta demonstrate measured values, including zero."
+        pagination={false}
+      />
+    </Grid>
+  </Stack>
+));
 function App() {
-  const sampleCountsRequest = useView(sampleCountsView);
   return (
     <DataApp
       config={appConfig}
-      dataContext={sampleDataContext}
-      request={sampleCountsRequest}
-      story={
-        sampleCountsRequest.snapshot?.data.length
-          ? ({ data: sampleCounts, input: displayedInput }) =>
-              sampleCounts.map(({ groupName, sampleCount }) =>
-                sampleDataContext.finding({
-                  id: `sample-count-${groupName}`,
-                  headline: `${groupName} has ${sampleCount} samples`,
-                  context: `Demonstration values for ${displayedInput.groupName || 'all groups'}.`,
-                  visual: (
-                    <MetricWidget
-                      label="Sample count"
-                      value={sampleCount}
-                      format={{ kind: 'count' }}
-                    />
-                  ),
-                  visualKind: 'metric',
-                  evidence: {
-                    id: `sample-count-${groupName}`,
-                    glossaryIds: ['sampleCount'],
-                  },
-                })
-              )
-          : undefined
-      }
+      view={sampleCountsView}
+      datasets={[sampleCounts]}
+      story={snapshot => {
+        const total = totalSamples.read(snapshot);
+        const scope = sampleCountsView.scope(snapshot);
+        return [
+          {
+            id: 'total-samples',
+            headline: `Total samples: ${formatMetric(total.value.current, totalSamples.definition.format)}`,
+            context: `Demonstration values for ${scope}.`,
+            visual: <MetricWidget metric={totalSamples} source={snapshot} />,
+            visualKind: 'metric',
+            evidence: totalSamples,
+          },
+          {
+            id: 'counts-by-group',
+            headline: 'Counts by group',
+            context: `Demonstration values for ${scope}.`,
+            visual: (
+              <TableWidget
+                dataset={sampleCounts}
+                source={snapshot}
+                pagination={false}
+              />
+            ),
+            evidence: sampleCounts,
+          },
+        ];
+      }}
     >
-      {(sampleCounts, displayedInput) => (
-        <section aria-label="Sample results">
+      <Stack>
+        <TextContent>
           <h2>Sample counts</h2>
-          <p>Showing {displayedInput.groupName || 'all groups'}</p>
-          <ul>
-            {sampleCounts.map(({ groupName, sampleCount }) => (
-              <li key={groupName}>
-                {groupName}: {sampleCount}
-              </li>
-            ))}
-          </ul>
-        </section>
-      )}
+        </TextContent>
+        <DataSection content={sampleContent} />
+      </Stack>
     </DataApp>
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altertable/data-app",
-  "version": "0.64.0",
+  "version": "0.66.0",
   "description": "Contracts, transport, and React UI for Altertable data apps",
   "keywords": [
     "altertable",
@@ -78,6 +78,10 @@
     "./react/embed": {
       "types": "./dist/types/react/embed/index.d.ts",
       "import": "./dist/react/embed/index.js"
+    },
+    "./react/ui": {
+      "types": "./dist/types/react/ui/index.d.ts",
+      "import": "./dist/react/ui/index.js"
     }
   },
   "publishConfig": {
@@ -86,12 +90,13 @@
   },
   "scripts": {
     "build": "bun run scripts/build.ts && tsc -p tsconfig.build.json && bun run scripts/build-declarations.ts",
+    "dev": "bun run scripts/dev.ts",
     "typecheck": "bun install --frozen-lockfile && tsc --noEmit",
-    "lint": "oxlint --type-aware src tests scripts browser-tests examples/starter-data-app",
+    "lint": "oxlint --type-aware src tests scripts browser-tests dev examples/starter-data-app",
     "format": "oxfmt .",
     "format:check": "oxfmt --check .",
     "test": "bun test ./tests",
-    "check": "bun run build && bun run typecheck && bun run lint && bun run lint:md && bun run check:links && bun run format:check && bun run test && bun run test:package && bun run test:starter",
+    "check": "bun run build && bun run typecheck && bun run lint && bun run check:styles && bun run lint:md && bun run check:links && bun run format:check && bun run test && bun run test:package && bun run test:starter",
     "test:package": "bun run scripts/check-package.ts",
     "check:workflows": "bash scripts/check-workflows.sh",
     "test:browser": "playwright test --config browser-tests/playwright.config.ts",
@@ -99,13 +104,16 @@
     "test:starter": "bun run scripts/check-starter.ts",
     "lint:md": "markdownlint-cli2",
     "check:links": "remark . --ext md --rc-path .remarkrc.json --frail --no-stdout",
-    "check:links:external": "remark . --ext md --rc-path .remarkrc-external.json --frail --no-stdout"
+    "check:links:external": "remark . --ext md --rc-path .remarkrc-external.json --frail --no-stdout",
+    "check:styles": "bun run scripts/check-app-styles.ts"
   },
   "dependencies": {
     "@floating-ui/react": "0.27.20",
     "@internationalized/date": "3.12.4",
     "@tanstack/react-query": "5.104.0",
+    "fflate": "0.8.3",
     "fuzzysort": "4.0.2",
+    "html-to-image": "1.11.13",
     "lucide-react": "1.48.0",
     "react-aria-components": "1.21.1"
   },
@@ -124,6 +132,7 @@
     "remark-gfm": "4.0.1",
     "remark-lint-no-dead-urls": "2.0.1",
     "remark-validate-links": "13.1.0",
+    "testcontainers": "12.2.0",
     "typescript": "7.0.2"
   },
   "peerDependencies": {

package/dist/chunks/contract-cxr9t12b.js

@@ -1,18 +0,0 @@
-// src/core/bridge.ts
-var BRIDGE = "altertable:data-app";
-var PARENT_PARAM = "__altertable_parent";
-var MAX_PENDING = 128;
-var REQUEST_TIMEOUT_MS = 60000;
-function isBridgeMessage(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const message = value;
-  return message.channel === BRIDGE && message.version === 1 && typeof message.type === "string" && typeof message.documentId === "string" && message.documentId.length > 0 && message.documentId.length <= 128;
-}
-function validId(value) {
-  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value);
-}
-
-export { BRIDGE, PARENT_PARAM, MAX_PENDING, REQUEST_TIMEOUT_MS, isBridgeMessage, validId };
-
-//# debugId=416EADDA2C8ACEA064756E2164756E21