@lotics/app-sdk 0.103.0 → 0.105.0

package/AGENTS.md

@@ -4,9 +4,8 @@
 hooks over the host bridge, the cell readers and `mount()`; `@lotics/app-sdk/router` is
 `AppRouter`. Data and RPC only — no component. What the app draws is its own.
 
-**`@lotics/ui` and its engines are not on npm.** The component kit is installed only inside a
-sandbox session's working tree; an app scaffolded on your machine draws with its own components.
-Where a doc pairs an SDK value with a kit component, that pairing applies in a sandbox session.
+**Draw with any UI library.** The SDK hands over data and nothing to draw it with, so the app
+picks its own components; the docs' examples use plain elements.
 
 This file is the index. The **exact type** of anything is its shipped declaration,
 `dist/<name>.d.ts` for a hook or reader — **never guess a shape; open the file.**

package/dist/agent_stream.d.ts

@@ -1,6 +1,6 @@
 /**
- * Folds the AI-SDK UI-message SSE stream into the `UIMessagePart[]` shape
- * `@lotics/ui` `AgentRun` renders. `ai` is imported for types only, so no `ai`
+ * Folds the AI-SDK UI-message SSE stream into the ai-sdk `UIMessagePart[]`
+ * shape. `ai` is imported for types only, so no `ai`
  * runtime enters the app bundle; unknown chunk types are ignored. A structured
  * agent's `output` is the result the server accepted (`data-run-output`, sent
  * before `finish`); until it arrives, `submit_result`'s input — never a part.
@@ -74,7 +74,7 @@ export interface PendingChoice {
 }
 /** The pending `ask_user_choice`, non-null exactly while parked. */
 export declare function pendingInteractiveCall(state: AgentRunState): PendingChoice | null;
-/** `answers` align to `questions` by index (`ClarifyWizard`'s contract); a missing or empty one is skipped. */
+/** `answers` align to `questions` by index; a missing or empty one is skipped. */
 export declare function buildChoiceOutput(questions: ChoiceQuestion[], answers: {
     value: string;
     custom: boolean;

package/dist/hooks.d.ts

@@ -91,14 +91,8 @@ export declare function useFileUpload(): FileUploadState;
  * ```tsx
  * const { files, add, remove, clear, uploading, fileIds } = useAttachments();
  * const design = useWorkflow("design");
- * // attach:  <Button icon="paperclip" onPress={() => pickFiles({ accept: "image/*" }).then(add)} />
- * // preview: map each AttachedFile to a @lotics/ui DisplayFile (snake_case → camelCase) — the
- * //          app owns this data→UI adapter; the SDK never imports @lotics/ui:
- * //   files.map((f) => (
- * //     <FileThumbnail
- * //       file={{ id: f.id, filename: f.filename, mimeType: f.mime_type, url: f.preview_url }}
- * //       uploading={f.status === "uploading"} onRemove={() => remove(f.id)} />
- * //   ))
+ * // attach:  <button onClick={() => pickFiles({ accept: "image/*" }).then(add)}>Attach</button>
+ * // preview: files.map((f) => <img key={f.id} src={f.preview_url} alt={f.filename} />)
  * // send:    design({ photo: fileIds[0] }); clear();
  * ```
  */
@@ -161,9 +155,7 @@ export interface MembersOptions {
  *
  * ```tsx
  * const { members } = useMembers({ group: GRP.sale });
- * // <Select variant="native" options={members.map((m) => ({
- * //   value: m.id, label: m.name || m.email || m.id, image: m.image,
- * // }))} />
+ * // members.map((m) => <option key={m.id} value={m.id}>{m.name || m.email || m.id}</option>)
  * ```
  */
 export declare function useMembers(opts?: MembersOptions): MembersState;
@@ -186,9 +178,9 @@ export interface UseAgentRun<TInput, TOutput> {
     cancel: () => void;
     /** `awaiting_input`: parked on the agent's question (`pendingChoice`). */
     status: "idle" | "streaming" | "awaiting_input" | "completed" | "error";
-    /** The ordered transcript, for `@lotics/ui` `AgentRun` as is. */
+    /** The ordered transcript, as ai-sdk `UIMessage.parts`. */
     parts: AgentUIPart[];
-    /** Non-null exactly while `awaiting_input`; `questions` map onto `ClarifyWizard`. */
+    /** Non-null exactly while `awaiting_input`. */
     pendingChoice: PendingChoice | null;
     /** Answer the pending ask (one `{value, custom}` per question, by index) and
      *  continue the run; resolves like `run`. Rejects when nothing is pending or
@@ -211,8 +203,8 @@ export interface UseAgentRun<TInput, TOutput> {
  * ```tsx
  * const recognize = useAgentRun("recognize");
  * await recognize.run({ image_file_id }, { sessionId });
- * // <AgentRun parts={recognize.parts} state={recognize.status === "streaming" ? "streaming" : "done"} />
- * // then read recognize.output (structured) or recognize.text (free-text)
+ * // recognize.parts streams the transcript; then read recognize.output
+ * // (structured) or recognize.text (free-text)
  * ```
  */
 export declare function useAgentRun<K extends keyof AppAgents & string>(alias: K): UseAgentRun<AppAgents[K], AgentOutputOf<K>>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-/** `@lotics/app-sdk`: hooks, cell readers and `mount()`. Data and RPC only — no kit component. */
+/** `@lotics/app-sdk`: hooks, cell readers and `mount()`. Data and RPC only — no component. */
 export { mount } from "./mount.js";
 export type { MountOptions } from "./mount.js";
 export { reportAppError } from "./error_report.js";

package/dist/index.js

@@ -24214,7 +24214,7 @@ var appWorkflowContractSchema = zod_default.object({
   inputs: zod_default.record(zod_default.string(), appWorkflowInputSchema).optional(),
   outputs: zod_default.record(zod_default.string(), appWorkflowOutputSchema).optional()
 });
-var APP_EXPORT_REPORT_KEYS = ["title", "lines", "readings"];
+var APP_EXPORT_REPORT_KEYS = ["title", "lines", "readings", "at", "dates"];
 var appExportTemplateSchema = zod_default.object({
   template_id: zod_default.string().min(1).describe("The document template (`dtl_\u2026`) filled: an Excel workbook, or an HTML page made a PDF."),
   rows: zod_default.string().regex(APP_ALIAS_REGEX).refine((key) => !APP_EXPORT_REPORT_KEYS.some((taken) => taken === key), {

package/dist/members.d.ts

@@ -22,9 +22,8 @@ export interface ResolvedMember {
     /** ISO timestamp of joining the organization. */
     joined?: string;
     /**
-     * `true` for a member who has left; never `false`. Feed it to `inactive` on
-     * `MemberChip` / `MemberProfileCard`. The roster never returns one, since a
-     * departed member cannot be assigned.
+     * `true` for a member who has left; never `false`. The roster never returns
+     * one, since a departed member cannot be assigned.
      */
     archived?: true;
 }

package/dist/queries.d.ts

@@ -56,8 +56,7 @@ export interface QueryFilterGroup<C extends string = string> {
 }
 /**
  * Runtime filter applied after the named query, bounded to its projected
- * columns — by `C` at compile time and again on the server. Build a group with
- * `columnFilterToConditions` (`@lotics/ui/column_filter`).
+ * columns — by `C` at compile time and again on the server.
  */
 export type QueryFilter<C extends string = string> = QueryFilterCondition<C> | QueryFilterGroup<C>;
 /** A `filter`/`sort` key on alias `K`: its projected columns, else `string`. */
@@ -185,6 +184,13 @@ export interface ExportReport {
     title: string;
     lines: string[];
     readings: ReportReading[];
+    /** Each date filter narrowing the rows, by field alias: its bounds, a day or a minute of one, with no zone. */
+    dates?: Record<string, {
+        from?: string;
+        to?: string;
+    }>;
+    /** The file's name, in the template grammar over the report; absent, the template's name, or `title`. */
+    filename?: string;
 }
 /** The file an export makes: the default report workbook — its words in `language`, the rows under `columns` on the
  *  tab `sheet` — or a template the query declares under `templates`, by its name there. */
@@ -232,8 +238,8 @@ export interface FieldOptionsState<C extends string = string> {
     fields: Partial<Record<C, FieldOptions>>;
     /**
      * A number column read in each row's own unit or currency, keyed the same way: a
-     * condition comparing it names one of these as its `unit_option` — pass it whole as
-     * a `FilterChip` column's `units`. A figure read in one unit for every row has none.
+     * condition comparing it names one of these as its `unit_option`. A figure read in one
+     * unit for every row has none.
      */
     units: Partial<Record<C, FigureUnits>>;
     loading: boolean;
@@ -252,13 +258,12 @@ export interface FieldOptionsOptions {
  *
  * ```tsx
  * const { fields, units } = useFieldOptions("records");
- * // populate + color a picker:
- * <Select variant="native" options={fields.status?.options ?? []}
- *   renderOptionContent={(o) => <Status option={o} />} />
+ * // populate a picker:
+ * (fields.status?.options ?? []).map((o) => <option key={o.key} value={o.key}>{o.label}</option>)
  * // color a stored value:
- * <Status option={fields.status?.byKey(readSelect(r.status)[0]?.key ?? "")} />
- * // a range on a figure each row reads in its own unit:
- * <FilterChip column={{ key: "weight", label: "Weight", type: "number", units: units.weight }} … />
+ * fields.status?.byKey(readSelect(r.status)[0]?.key ?? "")?.color
+ * // a range on a figure each row reads in its own unit names one:
+ * units.weight?.options.map((o) => o.key) // → a condition's `unit_option`
  * ```
  */
 export declare function useFieldOptions<K extends keyof AppQueries & string>(alias: K, opts?: FieldOptionsOptions): FieldOptionsState<ColumnKeyOf<K>>;

package/dist/recording.d.ts

@@ -33,12 +33,12 @@ export interface UseRecording<I> {
  * const visit = useRecording("log_visit");
  * if (!visit.available) return null;
  * if (visit.state.phase === "live" && visit.state.inputs.site === siteId) {
- *   return <Button onPress={() => visit.stop()}>Stop</Button>;
+ *   return <button onClick={() => visit.stop()}>Stop</button>;
  * }
  * return (
- *   <Button disabled={visit.busy} onPress={() => visit.start({ site: siteId })}>
+ *   <button disabled={visit.busy} onClick={() => visit.start({ site: siteId })}>
  *     Record the visit
- *   </Button>
+ *   </button>
  * );
  * ```
  */

package/dist/row.d.ts

@@ -54,8 +54,7 @@ export interface AppFile {
     document_template_id?: string;
 }
 /**
- * The presigned files, skipping any without a `url`; `toDisplayFile`
- * (`@lotics/ui/file_thumbnail`) converts one for the kit. A lookup arrives one
+ * The presigned files, skipping any without a `url`. A lookup arrives one
  * level deeper, flattened as in {@link readLinks}.
  */
 export declare function readFiles(v: unknown): AppFile[];

package/dist/select.d.ts

@@ -5,10 +5,10 @@ export interface ResolvedOption {
     label: string;
     /**
      * A palette token (`"blue"`), from `useFieldOptions` only — a cell carries
-     * key and label. `@lotics/ui` `Status` takes the option whole.
+     * key and label.
      */
     color?: string;
-    /** A brand or icon mark, from `useFieldOptions` only; `Status` draws it in the dot's place. */
+    /** A brand or icon mark, from `useFieldOptions` only. */
     mark?: {
         kind: "brand";
         name: string;

package/dist/viewer.d.ts

@@ -27,7 +27,7 @@ export declare function useAppContext(): {
 export declare function useWorkspaceTimezone(): string | undefined;
 /**
  * The ISO 4217 code for money whose field states none — pass it as `currency`,
- * or the kit prints its home market. `undefined` until resolved.
+ * or a money format prints a default market. `undefined` until resolved.
  */
 export declare function useWorkspaceCurrency(): string | undefined;
 /**

package/docs/ai.md

@@ -13,7 +13,7 @@ Don't run a structured extraction through `askAi` (the result is stranded in a c
 
 ## Declared agents — what `useAgentRun` runs
 
-An agent is **declared on the app server-side, by alias**, with the `set_app_agent` tool (removed with `remove_app_agent`) — the one way an agent is bound or changed, each write a new version of the app; a deploy never touches it, and `get_app_agent` reads one back. Invoking an alias that isn't bound fails with a "no agent alias" error naming `set_app_agent`, and a sandbox deploy warns about any alias the code calls that is not bound.
+An agent is **declared on the app server-side, by alias**, with the `set_app_agent` tool (removed with `remove_app_agent`) — the one way an agent is bound or changed, each write a new version of the app; a deploy never touches it, and `get_app_agent` reads one back. Invoking an alias that isn't bound fails with a "no agent alias" error naming `set_app_agent`.
 
 A declaration carries:
 
@@ -39,7 +39,7 @@ A declaration carries:
 
 So an agent that reads or writes records needs a named query or workflow for each thing it touches — the same declaration the app's own UI uses. Declare only what that agent needs; a second agent in the same app can declare a narrower set.
 
-**Typing.** `.lotics/app_agents.d.ts`, generated from the app's live bindings whenever a sandbox session opens on the app and by `lotics app create --custom` and `lotics app deploy`, augments the SDK's `AppAgents` (alias → input shape) and `AppAgentResults` (alias → declared output shape) interfaces — `useAgentRun("recognize")` then types both `run(input)` and `output`. An alias it does not carry falls back to `Record<string, unknown>` input / `unknown` output.
+**Typing.** `.lotics/app_agents.d.ts`, generated from the app's live bindings by `lotics app create --custom` and `lotics app deploy`, augments the SDK's `AppAgents` (alias → input shape) and `AppAgentResults` (alias → declared output shape) interfaces — `useAgentRun("recognize")` then types both `run(input)` and `output`. An alias it does not carry falls back to `Record<string, unknown>` input / `unknown` output.
 
 ---
 
@@ -62,35 +62,26 @@ await recognize.run({ image_file_id: fileId }, { sessionId });
 | `cancel` | `() => void` | Stop the run **server-side** (saves tokens) and locally. Wire a user-facing Stop button to this; the platform stamps `app_agent_runs.cancel_requested_at` |
 | `abort` | `() => void` | Stop listening **locally only** — the run keeps executing server-side and its result is still persisted. This is the unmount path (the hook calls it automatically on unmount) |
 | `status` | `"idle" \| "streaming" \| "awaiting_input" \| "completed" \| "error"` | Whole-run state. `awaiting_input` = the run is PARKED on a question the agent asked (see the ask-back section below). `abort`/`cancel` reset it to `"idle"` (and clear the partial transcript) |
-| `pendingChoice` | `PendingChoice \| null` | The agent's pending question(s) — non-null exactly while `status` is `awaiting_input`. `questions` maps 1:1 onto `@lotics/ui`'s `ClarifyWizard` (`{question, options: {label, description}[], allow_custom}`) |
-| `answerChoice` | `(answers: {value, custom}[]) => Promise<AgentRunLanding<TOutput>>` | Answer the pending question(s) and CONTINUE the run — one entry per question, aligned by index (exactly what `ClarifyWizard`'s `onSubmit` yields). Streams the continuation into the same `parts`; resolves like `run`. Rejects when nothing is pending — and when the server refuses the answer, in which case the pending question is restored for a retry |
-| `parts` | `AgentUIPart[]` | The ordered live transcript as **ai-sdk `UIMessage.parts`** — answer prose, thinking, and tool calls, in stream order. The single source of truth for the feed; hand it straight to `@lotics/ui` `AgentRun` |
+| `pendingChoice` | `PendingChoice \| null` | The agent's pending question(s) — non-null exactly while `status` is `awaiting_input`. Each of its `questions` is `{question, options: {label, description}[], allow_custom}` |
+| `answerChoice` | `(answers: {value, custom}[]) => Promise<AgentRunLanding<TOutput>>` | Answer the pending question(s) and CONTINUE the run — one entry per question, aligned by index. Streams the continuation into the same `parts`; resolves like `run`. Rejects when nothing is pending — and when the server refuses the answer, in which case the pending question is restored for a retry |
+| `parts` | `AgentUIPart[]` | The ordered live transcript as **ai-sdk `UIMessage.parts`** — answer prose, thinking, and tool calls, in stream order. The single source of truth for the feed |
 | `text` | `string` | The agent's **answer prose** (every `text` part concatenated), accumulating live. Excludes thinking. For a free-text agent this IS the result |
 | `output` | `TOutput \| undefined` | The structured result the server accepted — read it once `status` is `"completed"`. `undefined` for a free-text agent |
 | `error` | `string \| undefined` | The failure message when `status` is `"error"` |
 
-### The `parts` transcript → `@lotics/ui` `AgentRun`
+### The `parts` transcript
 
 `parts` is the **ai-sdk `UIMessagePart[]`** shape — the same wire model chat and app agents both emit, so there is no bespoke transcript type to keep in sync. The reducer folds the run's SSE chunks into it, in stream order:
 
 | Part `type` | Carries | Rendering intent |
 |---|---|---|
 | `"text"` | `text`, `state` | Answer prose, grows as it streams |
-| `"reasoning"` | `text`, `state` | The agent's thinking — a **distinct part**, kept out of `text`, so `AgentRun` shows it collapsed / revealed on demand. Only produced when the agent's declared model supports thinking (**Sonnet / Opus**, not Haiku) — a Haiku agent never emits reasoning |
-| `"dynamic-tool"` | `toolName`, `toolCallId`, `state` (ai's tool lifecycle — `input-available` → `output-available` / `output-error`), `input`, `output`, `errorText` | One tool call — opens running the moment it fires, settles when its result arrives. `input`/`output` ride along for `AgentRun`'s on-demand reveal, not for the feed row |
+| `"reasoning"` | `text`, `state` | The agent's thinking — a **distinct part**, kept out of `text`, so a feed can show it collapsed and reveal it on demand. Only produced when the agent's declared model supports thinking (**Sonnet / Opus**, not Haiku) — a Haiku agent never emits reasoning |
+| `"dynamic-tool"` | `toolName`, `toolCallId`, `state` (ai's tool lifecycle — `input-available` → `output-available` / `output-error`), `input`, `output`, `errorText` | One tool call — opens running the moment it fires, settles when its result arrives. `input`/`output` ride along for an on-demand reveal, not for the feed row |
 
-The terminal `submit_result` call is **not** rendered as a tool part (structured agents therefore have no visible final step); `output` is the result the server accepted, sent as the run finishes. Source/file parts aren't emitted by app agents. `parts` is exactly what `@lotics/ui` `AgentRun` renders, so the pairing needs **no adapter and no hand-assembly**:
+The terminal `submit_result` call is **not** rendered as a tool part (structured agents therefore have no visible final step); `output` is the result the server accepted, sent as the run finishes. Source/file parts aren't emitted by app agents. Because `parts` is the ai-sdk shape, any renderer of ai-sdk message parts draws it with no adapter.
 
-```tsx
-<AgentRun
-  parts={run.parts}
-  state={run.status === "streaming" ? "streaming" : run.status === "error" ? "error" : "done"}
-  error={run.error}                                 // the breaking error — a terminal danger row
-  labelForCall={(call) => toolLabels[call.toolName]}  // optional: localize tool labels
-/>
-```
-
-`AgentRun` renders thinking collapsed, groups consecutive tool calls, and expands each tool's input/output in place on press — all for free. Running it in a bounded container (a dialog, a panel)? Wrap it in `@lotics/ui`'s `FollowScroll` so the container follows the stream instead of letting new content grow below the fold. **Errors surface two ways:** a per-tool failure is an `output-error` part (amber dot, reason in the expanded Error panel — the feed flows on, exactly like a run that retried and recovered); a **breaking** error that killed the run lives in `run.error` (not in `parts`) — pass it as `error` and it renders as a terminal danger row. Never rebuild this feed by hand. To see its live, done and failed states without a run, mock the agent (`fixture.agents`, [runtime](./runtime.md)): the run is played through the same stream reader, never billed.
+**Errors surface two ways:** a per-tool failure is an `output-error` part — the feed flows on, exactly like a run that retried and recovered; a **breaking** error that killed the run lives in `run.error` (not in `parts`), and is the run's last word. A feed in a bounded container (a dialog, a panel) should follow the stream, so new content never grows below the fold. To see its live, done and failed states without a run, mock the agent (`fixture.agents`, [runtime](./runtime.md)): the run is played through the same stream reader, never billed.
 
 `run.error` is always a **sentence to show a person**, never a payload — on both the ways a run can fail.
 
@@ -114,20 +105,16 @@ same eventual `output`:
 const run = useAgentRun("importer");
 // …
 {run.pendingChoice ? (
-  <ClarifyWizard
-    questions={run.pendingChoice.questions.map((q) => ({
-      question: q.question,
-      answers: q.options.map((o) => ({ value: o.label, label: o.label, description: o.description })),
-      allowCustom: q.allow_custom,
-    }))}
-    onSubmit={(answers) => { void run.answerChoice(answers); }}
+  <ChoiceForm
+    questions={run.pendingChoice.questions} // your own form: one pick (or free text) per question
+    onSubmit={(answers) => { void run.answerChoice(answers); }} // [{ value, custom }], one per question
     onCancel={() => run.cancel()}
   />
 ) : null}
 ```
 
 The ask renders in the feed as a settled tool row once answered. `run()` resolves
-`{kind:"parked"}` when the run parks — the wizard renders off `pendingChoice` — and the
+`{kind:"parked"}` when the run parks — the form renders off `pendingChoice` — and the
 continuation's landing (from `answerChoice`) carries the final output, or `parked` again for a
 follow-up ask. A dropped stream can't lose the question: the recovery poll rebuilds it from the
 persisted run, so `awaiting_input` always yields an answerable `pendingChoice` (or a retryable

package/docs/data_fetching.md

@@ -11,20 +11,20 @@ alias** (bound with `set_app_query`) and fills the template's declared `{{params
 value holes; the server holds the canonical AST and runs it under the **app owner's** authority
 ([./security.md](./security.md)). The generated `.lotics/app_queries.d.ts` augments `AppQueries`,
 so params are typed per the binding; an alias it does not carry is accepted as a plain string,
-untyped. It is written from the app's live bindings whenever a sandbox session opens on the app,
-and by `lotics app create --custom` and `lotics app deploy`. Every hook reads through the SDK's own cache, over the host RPC bridge.
+untyped. It is written from the app's live bindings by `lotics app create --custom` and
+`lotics app deploy`. Every hook reads through the SDK's own cache, over the host RPC bridge.
 
 ## Choosing a read
 
 | Call | Answers | Reach for it when |
 |---|---|---|
 | `useQuery(alias, params?, opts?)` | `rows` up to the server's cap, or the first `limit` | a detail read, a dashboard block, a combobox's top-N — anything that is not a long list |
-| `useQuery(alias, params?, { page: n })` | one numbered page of `n` rows, `total`, `pageCount`, `setPage` | numbered, jumpable pages behind `@lotics/ui` `Pagination` |
+| `useQuery(alias, params?, { page: n })` | one numbered page of `n` rows, `total`, `pageCount`, `setPage` | numbered, jumpable pages |
 | `useQuery(alias, params?, { more: n })` | accumulated `rows` + `loadMore` | infinite scroll / "load more" feeds |
 | `useQuery(alias, params?, { rows: false, total: true })` | `total` only, no rows (`total: { by: column }` adds `counts`) | a facet chip, a queue badge, an "N awaiting approval" tile — the size of a set you are not listing |
 | `useQueries(calls, opts?)` | one state per `{ alias, params?, filter?, sort?, aggregate?, total?, rows? }`, in order — a `sort` orders that call's rows before the cap cuts them | reads that are DATA — a list known only at render, one read per item, or one count per stage (`rows: false, total: true`, each state's `.total`); the deploy's alias scan reads a list as dynamic, so every alias in it is still declared. With `aggregate` a call answers the groups of its filtered rows instead of the rows ([queries](./queries.md)) |
 | `queryAll(alias, params?, { filter, sort })` | a promise of every row | outside React, for a job that must hold the whole narrowed set in the browser (the ids an act runs on): it asks page after page until the server says the set ended, never stopping at the 10,000-row cap. The server's rows as stored — no write of this app is drawn over them |
-| `exportQuery(alias, { params, filter, sort, report, file })` | a promise of the file | every row the narrowed set holds, made into one file by the server — no row reaches the browser. `report` is `{ title, lines, readings }`; `file` is `{ kind: "workbook", language, sheet, columns }` (the default report workbook, each column `{ key, header, type }` an output column of the query — a `number` one on a number column, a `date` one on a date or datetime) or `{ kind: "template", template }`, one the query declares under `templates` by name ([queries](./queries.md)). Past 20,000 rows it rejects, never cuts; each caller makes at most 60 exports a minute. The file's `url` is signed for the caller: open it with `openExternal` |
+| `exportQuery(alias, { params, filter, sort, report, file })` | a promise of the file | every row the narrowed set holds, made into one file by the server — no row reaches the browser. `report` is `{ title, lines, readings, dates?, filename? }` — `dates` each date filter's `{ from?, to? }` by field alias, each bound a day (`yyyy-MM-dd`) or a minute of one (`yyyy-MM-ddTHH:mm`) with no zone; `filename` the file's name in the template grammar over one value each — `title`, `at` (the moment the server made the file), `dates.<field>.from` or `.to`, `lines | lookup:<n>` — at most 200 bytes once filled (absent, the template's name, or `title`); `file` is `{ kind: "workbook", language, sheet, columns }` (the default report workbook, its head closing with the moment the server made it, each column `{ key, header, type }` an output column of the query — a `number` one on a number column, a `date` one on a date or datetime) or `{ kind: "template", template }`, one the query declares under `templates` by name ([queries](./queries.md)). Past 20,000 rows it rejects, never cuts; each caller makes at most 60 exports a minute. The file's `url` is signed for the caller: open it with `openExternal` |
 
 Every hook answers the same `QueryState`: `rows`, `truncated`, `total`, `counts`, `loading`,
 `isValidating`, `error`, `pending`, `refetch`, `page`, `setPage`, `pageCount`, `hasMore`,
@@ -86,7 +86,7 @@ all its calls, and each call states its own `filter`, `sort`, `total` and `rows`
 | `enabled` | `boolean` | `true` | `false` = no request is sent, `rows` is `[]`, `loading` is `false`. Flip to `true` to fetch. The gate for search-as-you-type and on-demand detail. Disabling also **hides** previously loaded rows (the cached answer survives; it re-renders instantly when re-enabled). |
 | `revalidateOnFocus` | `boolean` | `true` | `false` = no re-read on window focus / tab return / network reconnect (`refetch()` still works). Keep the default for dashboards; turn off for transient queries (a search bound to an ephemeral term) where a refocus re-run is wasted work and a visible reload. |
 | `sort` | `QuerySortKey[]` | — | Runtime sort, applied server-side **after** the named query, over its output columns: `[{ field_key, order: "asc" \| "desc", blank_position? }]`. An empty/omitted array leaves the query's own order intact. Part of the read's key — changing it re-queries. |
-| `filter` | `QueryFilter` | — | Runtime filter, applied server-side after the named query, over its output columns. A single condition or a recursive `{ node_type: "group", logic: "and" \| "or", children }`. Part of the read's key. Build from per-column UI state with `columnFilterToConditions` (`@lotics/ui/column_filter`). |
+| `filter` | `QueryFilter` | — | Runtime filter, applied server-side after the named query, over its output columns. A single condition or a recursive `{ node_type: "group", logic: "and" \| "or", children }`. Part of the read's key. |
 | `limit` | `number` | — | The first `limit` rows only — a **cap**, not pages; omit to read up to the server's row cap. |
 | `page` | `number` | — | Numbered pages of `page` rows: `page` (from 0), `setPage`, `pageCount`, `hasMore`, and `total`, counted by default. |
 | `pageAt` | `{ at, onChange }` | — | With `page`, the page the screen keeps (its address, so a way back or a reload opens on it): `at` is read, `setPage` calls `onChange`, and nothing resets it — send a changed read back to 0 yourself. |
@@ -119,10 +119,6 @@ check reaches the helper that derives the key, not only the hook call that sends
 projected columns — ask the alias that CARRIES the column
 ([./members_and_options.md](./members_and_options.md)).
 
-`@lotics/ui`'s `columnFilterToConditions` carries the same parameter (`FilterableColumn<C>` →
-`FilterConditionNode<C>`), so a per-column filter UI built over a typed alias composes without a
-cast.
-
 Refinement order is fixed: the runtime **filter narrows** the named query's result, then **sort
 orders** it, then **`limit` / `page` / `more` cut** it. The template's own filters/sort/limit run first,
 inside the named query.
@@ -304,7 +300,7 @@ const { rows, total, pageCount, page, setPage, hasMore } =
   useQuery("orders", { q }, { page: 25, sort, filter });
 ```
 
-The page model behind a numbered table (pairs with `@lotics/ui` `Pagination`). It owns the page
+The page model behind a numbered table. It owns the page
 index and reads two things: the current page, and a count over the filtered set.
 
 - **Result-set identity is `(params, filter, sort)`.** Changing any of them resets to page 0.
@@ -416,14 +412,14 @@ and the UI prints `00:00`. When you need the time, the query must output the col
 `"2026-05"` (month) or `"2026"` (year) — when a document carries only that precision. Both decoders
 resolve it to its **period start** (missing month/day → 1): `row.date("2026-05")` →
 May 1 2026 at local midnight, `row.date("2026")` → Jan 1 2026 — never `null`. For DISPLAY that
-respects the precision (show "05/2026", not "01/05/2026"), format with `@lotics/ui`'s `formatDate`
-on the raw cell string rather than the decoded `Date`. Sorting/filtering server-side already treats
+respects the precision (show "05/2026", not "01/05/2026"), format the raw cell string rather than
+the decoded `Date`. Sorting/filtering server-side already treats
 a partial as its period start.
 
 **`readSelect`.** A query **cell** carries `key` + `label` only — `color` comes from
 `useFieldOptions`, not the cell. An option deleted after the cell was written surfaces as
-`label === key` (the stale state is explicit, never hidden). Render with `@lotics/ui` `Status`
-— see [./members_and_options.md](./members_and_options.md).
+`label === key` (the stale state is explicit, never hidden) — see
+[./members_and_options.md](./members_and_options.md).
 
 **`readMembers`.** The member shape, its gates and its `null` name:
 [./members_and_options.md](./members_and_options.md#member-cells-readmembers).
@@ -446,8 +442,8 @@ show the locked state and route edits through the locked-change request flow
 
 **`readCreatedAt` / `readUpdatedAt`.** Take the whole row object, not a cell. Unlike a `date`/`datetime` CELL (a timezone-less
 workspace wall-clock at minute precision), these are true **instants**: ISO-8601 with an offset on
-the wire, parsed as instants, dated in the workspace's zone — `useWorkspaceTimezone()`, which
-the app's root hands the kit's locale ([members & options](./members_and_options.md)). `null` on a grouped row, which has no
+the wire, parsed as instants, dated in the workspace's zone — `useWorkspaceTimezone()`
+([members & options](./members_and_options.md)). `null` on a grouped row, which has no
 originating record.
 
 ## Complete select option sets
@@ -471,18 +467,12 @@ never options derived from loaded rows, which are incomplete until every page lo
 - **Diff before update.** An edit form snapshots the record at load and sends only the CHANGED
   fields to its update workflow. The full rule and the locked-record path:
   [./mutations.md](./mutations.md).
-- **Reuse the kit's utilities.** `@lotics/ui` ships the formatters (`formatMoney`, `formatDate` /
-  `parseDate` / `toISODate`) — never hand-roll `dd/MM` or currency strings. Grep `@lotics/ui`
-  exports before writing one.
 
 ## Search-as-you-type
 
-A search-first picker (type → ranked results → pick) is one `@lotics/ui` component plus three SDK
+A search-first picker (type → ranked results → pick) is the app's own combobox over three SDK
 pieces. Compose these — don't hand-roll search:
 
-- **`Combobox`** (`@lotics/ui/combobox`) owns the interaction — debounced `onSearchChange`, a
-  popover listbox with rich rows (`renderOptionContent`), keyboard navigation, `recentOptions`,
-  `allowCustom`. (For a known small list with no search box, `Select`.)
 - **A parameterized `search` query** — a `from_table` with `search: "{{params.q}}"` over the
   maintained search document: **diacritics- and case-insensitive**, trigram-indexed, and AND-ed
   with the template's `filter` (search within a scope). The full `search` contract is in
@@ -497,19 +487,17 @@ pieces. Compose these — don't hand-roll search:
 - **Debounce the term — `enabled` is not a substitute.** `enabled` decides *whether* to ask, not
   *how often*: wire an input's own state into `params` and every keystroke past the first is a
   fresh cache key and a fresh request (and a re-count, where `total` is asked). Keep the input's
-  value in one state and debounce the COMMIT into a second (`useDebouncedCallback` from
-  `@lotics/ui/use_debounced_callback`, ~250 ms); anything reporting on the results (an empty state,
-  a count) reads the committed one. `Combobox` already
-  debounces its own `onSearchChange`; this is for a search box you built yourself.
-- **`useRecents(key, { max })`** — persist the picked option locally; pass its list as
-  `recentOptions` ([./navigation_and_state.md](./navigation_and_state.md)).
+  value in one state and debounce the COMMIT into a second (~250 ms); anything reporting on the
+  results (an empty state, a count) reads the committed one.
+- **`useRecents(key, { max })`** — persist the picked option locally and offer the list before
+  anything is typed ([./navigation_and_state.md](./navigation_and_state.md)).
 
 ```tsx
 const [typed, setTyped] = useState("");          // the input's own value, every keystroke
 const [term, setTerm] = useState("");            // what the server is asked, once typing settles
-const commit = useDebouncedCallback(setTerm, 250);
+const commit = useDebouncedCallback(setTerm, 250); // any debounce helper
 
-<TextInput type="search" value={typed} onChangeText={(v) => { setTyped(v); commit(v.trim()); }} />;
+<input type="search" value={typed} onChange={(e) => { setTyped(e.target.value); commit(e.target.value.trim()); }} />;
 
 const { rows, loading } = useQuery(
   "searchCustomers",
@@ -529,13 +517,13 @@ relationship exists.
 When the user doesn't know the term — "show me everything, let me narrow it" — build a modal table
 they can browse (numbered pages), search, sort, and filter:
 
-- **The screen is app-owned**, composed from `@lotics/ui`: a `Dialog` over a search `TextInput` + filter
-  pills (`FilterChip column=`) + `Table` + `Pagination`. It needs both `@lotics/ui` and the SDK (which is
-  UI-free), so it lives in the app (e.g. a `record_picker.tsx`) — reuse it for any table by passing
-  a different `alias` + column config.
+- **The screen is app-owned**: a dialog over a search input, filter pills, a table and
+  pagination, drawn with whatever UI the app uses over the SDK (which is UI-free). It lives in the
+  app (e.g. a `record_picker.tsx`) — reuse it for any table by passing a different `alias` + column
+  config.
 - **`useQuery(alias, params, { page: n, sort, filter })`** drives it: the page of rows, the
   `total` and `pageCount` for "Page 1 of N" (counted by default with `page`), and `setPage`.
-- **Filter pills → runtime `filter`** via `columnFilterToConditions` (`@lotics/ui/column_filter`);
+- **Filter pills → runtime `filter`**, one condition per pill;
   **column-header sort → runtime `sort`** by mapping the table's `{ key, order }` to
   `[{ field_key: key, order }]`. Both are server-bounded to the query's output columns — the picker
   can't widen exposure ([./queries.md](./queries.md)).

package/docs/files.md

@@ -13,7 +13,7 @@ discipline in [data fetching](./data_fetching.md).
 | Attach to a record | a declared workflow with a `{ type: "file" }` input | the workflow writes the id(s) into a `files` field — the **only** write path |
 | Read back from records | `useQuery` + `readFiles(cell)` | `AppFile[]` — presigned `url`/`thumbnail_url` (24 h) + `size`/`created_at` |
 | Receive a generated document | `useWorkflow` → `WorkflowResult.files` | presigned files auto-extracted from the run |
-| Show it | `@lotics/ui` `FileThumbnail` / `FileThumbnailGrid` / `FileGalleryDialog` | map to `DisplayFile` (see below) |
+| Show it | the app's own thumbnail and viewer | `url` / `thumbnail_url` (see below) |
 | Save browser-built bytes | `downloadFile(filename, data, mimeType?)` | a client-side download (see [runtime](./runtime.md)) |
 | Rename one a record holds | `renameFile(file_id, filename)` | an `AppFile` — a new, unattached file over the same bytes |
 
@@ -145,16 +145,14 @@ const { files, add, remove, clear, uploading, fileIds } = useAttachments();
 const design = useWorkflow("design");
 
 // attach: picking is the app's choice — button, paste, or drop
-<Button icon="paperclip" onPress={() => pickFiles({ accept: "image/*" }).then(add)} />
+<button type="button" onClick={() => pickFiles({ accept: "image/*" }).then(add)}>Attach</button>
 
-// preview: map each AttachedFile to a @lotics/ui DisplayFile (snake -> camel)
+// preview: the local preview is there before the upload finishes
 {files.map((f) => (
-  <FileThumbnail
-    key={f.id}
-    file={{ id: f.id, filename: f.filename, mimeType: f.mime_type, url: f.preview_url }}
-    uploading={f.status === "uploading"}
-    onRemove={() => remove(f.id)}
-  />
+  <figure key={f.id} aria-busy={f.status === "uploading"}>
+    <img src={f.preview_url} alt={f.filename} />
+    <button type="button" onClick={() => remove(f.id)}>Remove</button>
+  </figure>
 ))}
 
 // send: gate on `uploading`, payload is `fileIds`
@@ -174,15 +172,10 @@ const onAdd = async (picked: File[]) => {
   await save({ item_id: r.__source_record_id, photo_added: stored });
 };
 
-<RecordFiles
-  files={held.map(toDisplayFile)}
-  uploads={queue.files.map((f) => ({
-    id: f.id,
-    filename: f.filename,
-    mimeType: f.mime_type,
-    previewUrl: f.preview_url,
-    status: f.status === "error" ? "error" : "uploading",
-  }))}
+// One grid: the stored pile, then the queue still uploading (or failed) beside it.
+<FileGrid
+  stored={held}                 // AppFile[]: url, thumbnail_url, filename, mime_type
+  pending={queue.files}         // AttachedFile[]: preview_url, status
   onAdd={(picked) => { void onAdd(picked).catch(report); }}
 />
 ```
@@ -216,13 +209,10 @@ Each `AttachedFile` is `{ id, filename, mime_type, preview_url, status, file_id?
 - `file_id` — the stored id, set once `status` is `"ready"`. `fileIds` includes only ready
   entries, so sending while `uploading` is true would silently drop in-flight files — gate on it.
 
-Wiring to `@lotics/ui`: in a `Composer`, trigger picking from `actionsButton` (via `pickFiles`),
-render the attachment pills with `FileThumbnail` as above, and gate `sendDisabled` on `uploading`.
-A record's section passes the queue to `RecordFiles` `uploads` (a `PendingUpload` each) so the
-picked file and the stored pile stand in one grid. For a full add-files *screen*, map each
-`AttachedFile` to a `FileThumbnailGrid` `FileUpload` entry — ready -> `{ status: "complete", id:
-file_id, file: <DisplayFile> }`, else `{ status, id, filename, mimeType: mime_type, previewUrl:
-preview_url }` — and the grid renders the uploading/error/retry tiles itself.
+In a composer, trigger picking with `pickFiles`, show each attachment's `preview_url` as above,
+and disable Send while `uploading`. A record's section draws the queue beside the stored pile, so
+the picked file and the files the record holds stand in one grid; an entry whose `status` is
+`"error"` offers remove and re-add.
 
 ## File cells in query results — `readFiles` and `AppFile`
 
@@ -263,8 +253,8 @@ file. It is pure and never throws.
   nothing.
 
 - **Thumbnails are optimistic.** `thumbnail_url` is emitted for every image without checking that
-  the variant exists; a not-yet-generated variant 404s on fetch. `@lotics/ui`'s `FileThumbnail`
-  falls back to `url` on image error — a hand-rolled `<img src={thumbnail_url}>` must do the same.
+  the variant exists; a not-yet-generated variant 404s on fetch. An `<img src={thumbnail_url}>`
+  falls back to `url` on image error.
 - **A presigned `url` is a bearer credential for the bytes.** It carries its own authorization —
   anyone holding it fetches the file for 24 h with no session — so it must never leave the render
   path: not into a log line, not into telemetry, not into an error report or a bug ticket. Don't
@@ -360,35 +350,17 @@ over 200 characters, punctuation alone, or the empty string a name expression yi
 nothing. `null` is the one absence that is not an error (an empty record field reads as `null`): it
 means "no name", and that entry keeps the stored filename.
 
-## Previewing — wiring to `@lotics/ui`
+## Previewing
 
-Render any file inline — image, PDF, video, audio, Word, Excel, CSV — with `@lotics/ui`. Never
-hand-roll per-type rendering, and don't use `openExternal` as a preview (that's "open elsewhere",
-not viewing). The kit is installed only in a sandbox session (see [AGENTS.md](../AGENTS.md)); the
-SDK-side contract is only the data mapping:
+Render a file inline with whatever viewer the app uses — `openExternal` is not a preview (that's
+"open elsewhere", not viewing). What the SDK hands over: `url` (the bytes), `thumbnail_url` (an
+image's smaller variant), `filename` and `mime_type` to choose a viewer by. For an `AttachedFile`
+still uploading, `preview_url` stands in for `url` (there is no server URL yet).
 
-| `AppFile` (SDK) | `DisplayFile` (`@lotics/ui`) |
-|---|---|
-| `id` | `id` |
-| `filename` | `filename` |
-| `mime_type` | `mimeType` |
-| `url` | `url` |
-| `thumbnail_url` | `thumbnailUrl` |
-
-For an `AttachedFile` still uploading, map `preview_url` → `url` (there is no server URL yet).
-
-- **`FileThumbnail`** — one square tile; `uploading` takes the queue status and overlays the
-  scrim, the spinner or the retry, images fall back from `previewUrl` to `thumbnailUrl` to `url`.
-- **`FileThumbnailGrid`** — a grid of stored files plus a live `uploads` queue, in one grid.
-- **`FileGalleryDialog`** — the full-screen viewer (filename · counter · actions · close, with
-  prev/next + ESC), delegating per-file to **`FilePreview`**, which dispatches by MIME. Wire
-  `onFilePress` → a `number | null` `activeIndex`.
-- PDF renders **inline to a canvas** (a nested PDF browsing context is blocked in the sandboxed
-  iframe; a canvas isn't). The PDF, Word, and Excel/CSV engines ship as `@lotics/ui`
-  dependencies — no separate install — and are lazy-loaded, so apps that never preview a type pay
-  no bundle cost.
-- The gallery's "open in new tab" action can't pop a window in the sandbox — pass
-  `onOpenExternal` wired to the SDK's `openExternal` (omit it and the action hides).
+- **A PDF draws to a canvas.** A nested PDF browsing context is blocked in the sandboxed iframe; a
+  canvas isn't, so a PDF viewer has to render pages itself.
+- **"Open in new tab" goes through `openExternal`.** The sandbox drops `window.open`, so an action
+  that opens a file elsewhere calls the SDK's `openExternal(url)`.
 
 ## Filtering on files fields
 

package/docs/members_and_options.md

@@ -54,13 +54,12 @@ up table edits with no app change.
 
 ```tsx
 const { fields } = useFieldOptions("orders");   // same alias you query
-// populate + color a picker (Select is @lotics/ui's rich select; its options
-// are { value, label }, so map the option key to `value`):
-<Select
-  options={(fields.status?.options ?? []).map((o) => ({ value: o.key, label: o.label }))}
-  renderOptionContent={(o) => <Status option={fields.status?.byKey(o.value)} />}
-  value={status} onValueChange={setStatus}
-/>
+// populate a picker: the option KEY is the value a workflow input takes
+<select value={status} onChange={(e) => setStatus(e.target.value)}>
+  {(fields.status?.options ?? []).map((o) => (
+    <option key={o.key} value={o.key}>{o.label}</option>
+  ))}
+</select>
 ```
 
 ### What comes back
@@ -75,8 +74,8 @@ a compile error, and every key is optional. Each `FieldOptions`:
 | `options` | Every option of the field — `{ key, label, color, mark? }` (the option's own brand or glyph, where the field marks every option) — in field-config order, **including options not present in any current row** |
 | `byKey(key)` | Resolve one option by key; `undefined` for an unknown key (option removed after the cell was written) |
 
-- `color` is a named palette token (e.g. `"blue"`, `"emerald"`). Pass the option straight to
-  `@lotics/ui`'s `Status`; a missing/unrecognized token degrades to a neutral badge.
+- `color` is a named palette token (e.g. `"blue"`, `"emerald"`), mapped to a color by the app;
+  draw a missing or unrecognized token neutral.
 - **A column the server can't map to a single source select field is simply absent** from
   `fields` — a UNION output whose arms disagree on the source field, or a computed column:
   `fields.status?.options ?? []`.
@@ -91,13 +90,15 @@ A number whose field names a `unit_field` or `currency_field` reads each row in
 on that row holds, so a comparison on it states which one as `unit_option` — the server refuses one
 that does not, and keeps only the rows in that unit (a measured unit's kin, `kg` beside `t`,
 converted). `units` is keyed like `fields`: `{ vocabulary: "unit" | "currency", options: { key, label }[] }`
-per such column, whether or not the query projects the select. Pass it whole to a range filter:
+per such column, whether or not the query projects the select. A range filter on such a column
+offers its `options` and puts the picked key on each condition:
 
 ```tsx
 const { units } = useFieldOptions("loads");
-<FilterChip column={{ key: "weight", label: "Weight", type: "number", units: units.weight }}
-  value={weight} onChange={setWeight} />
-// columnFilterToConditions puts the picked unit on each condition as `unit_option`
+const filter = {
+  field_key: "weight", operator: "greater_than", value: 10,
+  unit_option: unit,  // one of units.weight?.options[].key
+};
 ```
 
 ### Caching & freshness
@@ -112,7 +113,8 @@ until an edit drawer opens). State: `{ fields, units, loading, isValidating, err
 
 ```tsx
 const opt = readSelect(row.status)[0];
-<Status option={opt ? (fields.status?.byKey(opt.key) ?? opt) : null} />
+const shown = opt ? (fields.status?.byKey(opt.key) ?? opt) : null; // carries `color` when known
+{shown ? <Badge color={shown.color} label={shown.label} /> : null}
 ```
 
 `byKey` hit → the configured color. `byKey` miss (option removed post-write) → fall back to the
@@ -141,12 +143,11 @@ projected `select_member` cell to `Array<{ id, name, email?, image?, groups?, ro
   "Admin" beside a name as rank. If the question your screen asks is "who is this person in the
   company", the answer is `groups`.
 - **`joined` is an ISO timestamp of when the membership began.** Render it at whatever precision
-  your question needs — `@lotics/ui`'s `MemberPeek` shows month and year, because "is this
-  the new person?" does not want a day. Absent on a public response, and on an id that did not
+  your question needs — "is this the new person?" wants month and year, not a day. Absent on a public response, and on an id that did not
   resolve: there is no membership to have begun.
 - **`archived: true` marks someone who has LEFT** — omitted otherwise, never `false`. It is the one
   field that is NOT gated (a departed colleague reading as a current assignee is wrong on a public
-  app too). Feed it to `inactive` on `MemberChip` / `MemberPeek`.
+  app too). Draw such a person as inactive wherever they appear.
 - **An id that no longer resolves** (removed member, id outside the org) comes back with
   `name: null` — an explicit missing state, never an empty string. Render a placeholder.
 - Only ids already present in the projected rows are resolved — a member cell never exposes the
@@ -219,11 +220,11 @@ the `select_member` field in the query, and the cell already carries the name.
 ```tsx
 // No useMembers. The projected cell is the member source.
 {readMembers(row.assignee).map((m) => (
-  <MemberChip key={m.id} name={m.name ?? "—"} />
+  <span key={m.id}>{m.name ?? "—"}</span>
 ))}
 ```
 
-Names render; only the avatar photo is unavailable (`MemberChip` falls back to initials). If a chip
+Names render; only the avatar photo is unavailable, so draw initials in its place. If a name
 renders blank, fix the query projection — never widen the bindings.
 
 ## `useViewer()` — display-only identity
@@ -251,11 +252,9 @@ surface that dates or counts by them draws the failure rather than guessing the
 
 ## The workspace's zone at the root
 
-An app that draws with `@lotics/ui` mounts the kit's `LoticsLocaleProvider` at the root of
-`src/main.tsx` with `zone` set to `useAppContext().timezone`, and draws nothing until the context
-has `settled` — where it failed, it draws `failure` with its `retry` in place of the app. Then every
-instant the kit prints (`useFormatDate`) and every day it files by or counts to (`useCalendarDay`)
-is the workspace's, never the browser's. The sandbox starter's `src/main.tsx` does exactly this.
+An app's root draws nothing until `useAppContext()` has `settled` — where it failed, it draws
+`failure` with its `retry` in place of the app — and then dates every instant it prints, and every
+day it files by or counts to, in `useAppContext().timezone`: the workspace's, never the browser's.
 
 ## `useWorkspaceTimezone()` / `useWorkspaceCurrency()` — what the workspace states
 
@@ -264,11 +263,11 @@ until it resolves, where it failed, and from a host that predates them.
 
 - **`useWorkspaceTimezone()`** → the workspace's IANA zone (`Asia/Ho_Chi_Minh`). It dates an
   INSTANT — a record's own `__created_at`, a comment's time. A stored `date`/`datetime` cell is a
-  wall clock and needs none. The kit reads it through the root locale provider (above) — never
-  passed to a date call by hand.
+  wall clock and needs none. Hand it to the root's date formatting once (above), rather than to
+  each date call.
 - **`useWorkspaceCurrency()`** → the workspace's ISO 4217 code (`VND`), what money is counted in
   where the field states no code of its own. Pass it as the money's `currency`: a money format
-  given no code prints the kit's home market, which says nothing about this workspace.
+  given no code prints a default market, which says nothing about this workspace.
 
 ## Comments: `useComments` / `useCommentCounts`
 
@@ -319,8 +318,8 @@ columns, and a hook cannot be called conditionally, so the guard belongs at the
 renders the panel. State: `{ comments, loading, error, available, createComment,
 updateComment, deleteComment, refetch }`.
 
-- `comments` — newest first on the wire (server order). Pass the array as-is to `@lotics/ui`'s
-  `Timeline`, which re-sorts oldest-first for display. Each `AppComment`: `{ id, record_id,
+- `comments` — newest first on the wire (server order); a thread usually reads oldest-first, so
+  reverse it for display. Each `AppComment`: `{ id, record_id,
   table_id, member_id, author, content, files, workspace_id, created_at, updated_at }`. Attachments
   (`AppCommentFile`) carry `id` / `filename` / `mime_type` — a file's identity is its `id`, and
   the server re-reads every attachment from storage by that id, so nothing else you hold about a
@@ -358,18 +357,6 @@ table's id: read it off a row of the query that renders the badges (`rows[0]?.__
 rather than pasting a `tbl_` id, which a copy of the app cannot carry. Pass `undefined` while no
 row is on screen — no request is sent and `counts` is `{}`.
 
-## Pairing with `@lotics/ui`
-
-The SDK ships zero components; these `@lotics/ui` components (a sandbox session's kit, see
-[AGENTS.md](../AGENTS.md)) are shaped to accept SDK values directly:
-
-| Value | Component | Feed it |
-| --- | --- | --- |
-| A select value (stored or picker option) | `Status` | A `useFieldOptions` option, or `byKey(readSelect(cell)[0]?.key)`; accepts a single option, an array (multi → one badge each), or null (renders nothing). Missing/unknown color → neutral. |
-| A person, inline | `MemberChip` | `name` / `image` from a roster or a cell — both carry it; no image → initials |
-| A member picker | `MemberSelect` | `members={useMembers().members}` — renders each option as a `MemberChip`; `MEMBER_UNASSIGNED` marks its optional "unassigned" option |
-| A comment thread | `Timeline` + `Composer` (`@lotics/ui/composer`) | `useComments` state; `resolveMember` reads each comment's own `author` (`{ name, image }`) — no roster needed |
-
 ## Where each hook works
 
 | Surface | Embedded (signed-in member) | Standalone / public (anonymous) |

package/docs/mutations.md

@@ -40,8 +40,8 @@ Exact signature: `dist/hooks.d.ts`. `useWorkflow(alias)` returns a stable async
 render: one callable per alias, each run exactly as `useWorkflow`'s.
 
 Typing comes from `.lotics/app_workflows.d.ts`, which augments the SDK's `AppWorkflows` and
-`AppWorkflowResults` interfaces from the app's bound declarations. The declarations are generated from the app's live bindings into `.lotics/` whenever a sandbox
-session opens on the app, and by `lotics app create --custom` and `lotics app deploy`. The result:
+`AppWorkflowResults` interfaces from the app's bound declarations. The declarations are generated from the app's live bindings into `.lotics/` by
+`lotics app create --custom` and `lotics app deploy`. The result:
 
 | Declaration | Call-site type |
 |---|---|
@@ -379,9 +379,7 @@ The same trap one level up: **an action takes an ID, never a captured object.**
 `onPress={() => issueInvoice(invoice)}` closes over the invoice as it was when the press
 happened, so no amount of waiting refreshes it — the confirm quotes, and the mint bills, the
 pre-edit total. Pass the key and resolve at use (`onPress={() => setConfirmKey(invoice.key)}`,
-then re-read or `find` where it is consumed). `@lotics/ui` gates the press itself
-(`docs/data_entry.md` § A field that saves itself), which fixes the ordering; the captured value is the app's
-to get right.
+then re-read or `find` where it is consumed).
 
 ## Diff before update — send only what changed
 
@@ -685,8 +683,8 @@ any alias: stand the other acts down, since the host would refuse them. A record
 app or the chat is invisible to this app, so `start` can still be refused while `busy` is false.
 
 **Filed means written.** When `state` becomes `filed`, every mounted query re-reads, exactly as
-after a successful `useWorkflow` call ([refetch](#refetch-after-a-mutation)). Draw the filed row's
-files and transcript with `@lotics/ui/recording`.
+after a successful `useWorkflow` call ([refetch](#refetch-after-a-mutation)), and the filed row's
+files and transcript read like any other.
 
 A mock fixture's `recordings` map (alias → `state`) draws each phase without a host
 ([runtime](./runtime.md#the-mock-harness-optionsfixture--__mock1)).

package/docs/navigation_and_state.md

@@ -69,8 +69,7 @@ routes, and splats all work. Inside the tree, use react-router normally:
   ```
 
   `message` takes the path so the words may place it where the language needs
-  it. Where the app uses `@lotics/ui`, read both from the kit's locale — the
-  SDK ships none of its own.
+  it. The SDK ships no words of its own.
 - **Limitation: element routing only.** `AppRouter` mounts a plain browser
   router, not a react-router *data* router — route `loader`/`action` fields
   are ignored, and `useLoaderData` **throws** ("must be used within a data

package/docs/runtime.md

@@ -279,11 +279,12 @@ predates the two workspace facts answers without them; the recording fields are
 context type is not exported from the package root, so type the result yourself
 via the `rpc<T>` generic.
 
-An app's root draws nothing until this op has answered or failed, then hands
-the zone to the kit's locale, so every instant the kit formats is dated in the
-workspace's zone ([members & options](./members_and_options.md)); money whose
-field states no code is counted in the workspace's currency. Where neither the field nor the host names a
-currency, the screen refuses by name rather than printing one nobody stated.
+An app's root draws nothing until this op has answered or failed, then dates
+every instant it formats in the workspace's zone
+([members & options](./members_and_options.md)); money whose field states no
+code is counted in the workspace's currency. Where neither the field nor the
+host names a currency, the screen refuses by name rather than printing one
+nobody stated.
 
 ## `openExternal()` — open a link in a new tab
 
@@ -306,9 +307,8 @@ page (standalone). Opens in a new tab with `noopener,noreferrer`.
   its own side — a URL handed across the bridge is never trusted.
 - Typical use: opening a workflow-generated file's `url` from
   `WorkflowResult.files[]` (see [mutations](./mutations.md)).
-- **Not a preview mechanism.** To *view* a file inline, use `@lotics/ui`'s
-  `FilePreview`/`FileGalleryDialog` (see [files](./files.md)); `openExternal` is
-  "leave the app".
+- **Not a preview mechanism.** To *view* a file inline, render it in the app
+  (see [files](./files.md)); `openExternal` is "leave the app".
 
 ## `openApp()` — the cross-app hop
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.103.0",
+  "version": "0.105.0",
   "description": "The SDK a Lotics custom-code app reads and writes through \u2014 typed hooks over the host bridge, cell readers, mount() and AppRouter",
   "type": "module",
   "exports": {