@lotics/app-sdk 0.105.0 → 0.106.1

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export type { AppErrorKind } from "./error_report.js";
 export { useWorkflow, useWorkflows, writesSettled, useFileUpload, useAttachments, useAttachmentPiles, useMembers, useAgentRun, useAgentRuns, useAiContext, buildChoiceOutput, } from "./hooks.js";
 export type { UploadedFile, WorkflowResult, MembersOptions, AgentRunOptions, UseAgentRun, AgentRunLanding, AgentRunRecord, AgentRunState, AgentUIPart, PendingChoice, ChoiceQuestion, ChoiceOption, AskUserChoiceOutput, } from "./hooks.js";
 export { useQuery, useQueries, queryAll, exportQuery, useFieldOptions } from "./queries.js";
-export type { QueryRow, QueryCall, QueryState, RowOf, QueryOptions, ColumnKeyOf, QuerySortKey, QueryFilter, QueryFilterCondition, QueryFilterFieldCondition, QueryFilterRecordIdCondition, QueryFilterGroup, FieldOptions, FieldOptionsState, FieldOptionsOptions, FigureUnits, ExportCall, ExportFile, ExportReport, } from "./queries.js";
+export type { QueryRow, QueryCall, QueryState, RowOf, QueryOptions, ColumnKeyOf, QuerySortKey, QueryFilter, QueryFilterCondition, QueryFilterFieldCondition, QueryFilterRecordIdCondition, QueryFilterGroup, FieldOptions, FieldOptionsState, FieldOptionsOptions, FigureUnits, ExportCall, ExportFile, ExportReport, ExportTab, } from "./queries.js";
 export type { AttachedFile, AttachmentPiles, AttachmentPilesOptions, AttachmentsOptions, AttachmentsState } from "./attachments.js";
 export { useComments, useCommentCounts } from "./comments.js";
 export type { AppComment, AppCommentAuthor, AppCommentFile, CommentsState, UseCommentsArgs, CommentCountsState, UseCommentCountsArgs, } from "./comments.js";

package/dist/index.js

@@ -23712,8 +23712,8 @@ var templatePartSchema = zod_default.lazy(
 var MODEL_TIERS = ["haiku", "sonnet", "opus"];
 var TIER_MODELS = {
   haiku: "claude-haiku-4-5",
-  sonnet: "claude-sonnet-5",
-  opus: "claude-opus-5"
+  sonnet: "claude-sonnet-5-5",
+  opus: "claude-opus-5-5"
 };
 var RESOLVED_MODEL_IDS = MODEL_TIERS.map(
   (tier) => TIER_MODELS[tier]
@@ -24214,13 +24214,20 @@ 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", "at", "dates"];
+var APP_EXPORT_REPORT_KEYS = ["title", "lines", "readings", "at", "dates", "period", "per"];
 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), {
     message: `The rows are listed under a key of their own, never ${APP_EXPORT_REPORT_KEYS.join(", ")}.`
-  }).describe(`The key the template lists the rows under, beside ${APP_EXPORT_REPORT_KEYS.join(", ")}.`)
-}).strict();
+  }).describe(`The key the template lists the rows under, beside ${APP_EXPORT_REPORT_KEYS.join(", ")}.`),
+  tabs: zod_default.array(
+    zod_default.string().regex(APP_ALIAS_REGEX).refine((key) => !APP_EXPORT_REPORT_KEYS.some((taken) => taken === key), {
+      message: `A tab's rows are listed under a key of their own, never ${APP_EXPORT_REPORT_KEYS.join(", ")}.`
+    })
+  ).min(1).optional().describe("The keys each of a register's tabs lists its rows under, beside the rows; every export filling the template sends exactly these.")
+}).strict().refine((declared) => declared.tabs === void 0 || new Set(declared.tabs).size === declared.tabs.length && !declared.tabs.includes(declared.rows), {
+  message: "Each tab is listed under a key of its own, apart from the rows."
+});
 var appQueryDeclarationSchema = zod_default.object({
   ast: zod_default.unknown().describe(
     "Query AST template (a QueryNode). Validated server-side via parseQueryNode at deploy. May embed {{params.<name>}} tokens in filter value positions."
@@ -24529,6 +24536,8 @@ var TOOL_INPUT_SEMANTICS = {
     // Also `{fld_*: value}` — a signed number rather than an item array, but the
     // key half is what this classification governs, so it validates the same way.
     increment: { kind: "record_data", table_from: "table_id" },
+    // `{fld_*: [document template id, ...]}` — the key half is a field of the table, as the ops above.
+    remove_made: { kind: "record_data", table_from: "table_id" },
     // Per-record mode — field_keys names the columns; rows holds values
     // positionally. Each cell's semantic depends on field_keys[i], so the
     // tool resolves option names at execute time. Annotated `dynamic` so the
@@ -24655,6 +24664,12 @@ var TOOL_INPUT_SEMANTICS = {
     aggregations: { kind: "dynamic" },
     group_by: { kind: "field_key_ref", table_from: "table_id" }
   },
+  evaluate_formula: {
+    table_id: { kind: "table_ref", rows: "none" },
+    record_id: { kind: "record_ref" },
+    // `{fld_…}` tokens of `table_id`, resolved against its fields at execute time.
+    expression: { kind: "dynamic" }
+  },
   get_record: {
     // Schema only takes `record_id`; table_id is optional/derived.
     record_id: { kind: "record_ref" },
@@ -27042,6 +27057,10 @@ function adjusted(current, items, op) {
   const gone = new Set(given.map(keyOf));
   return held2.filter((item) => !gone.has(keyOf(item)));
 }
+function withoutMade(current, templates) {
+  const gone = new Set(asList(templates));
+  return asList(current).filter((item) => !(item !== null && typeof item === "object" && "document_template_id" in item && gone.has(item.document_template_id)));
+}
 function note(walk, effect) {
   if (walk.unsure && effect.kind !== "unknown") {
     walk.effects.push({ kind: "unknown", table_id: effect.table_id });
@@ -27074,6 +27093,7 @@ async function predictUpdate(walk, input) {
   const removed = await fieldValues(walk, input.remove_from);
   const increments = await fieldValues(walk, input.increment);
   const replaced = await fieldValues(walk, input.replace);
+  const unmade = await fieldValues(walk, input.remove_made);
   for (const id of ids) {
     const before = recordOf(walk, id);
     const cells = {};
@@ -27100,6 +27120,7 @@ async function predictUpdate(walk, input) {
     };
     relative(added, (current, given) => adjusted(current, given, "add_to"));
     relative(removed, (current, given) => adjusted(current, given, "remove_from"));
+    relative(unmade, (current, templates) => withoutMade(current, templates));
     relative(increments, (current, given) => typeof given === "number" ? (typeof current === "number" ? current : 0) + given : current);
     if (unknown2.includes("*")) {
       note(walk, { kind: "unknown", table_id: table });
@@ -30975,7 +30996,8 @@ async function queryAll(alias, params = {}, opts = {}) {
 }
 async function exportQuery(alias, call) {
   const sort = call.sort === void 0 || call.sort.length === 0 ? void 0 : [...call.sort];
-  const body = { alias, params: call.params ?? {}, filter: call.filter, sort, report: call.report, file: call.file };
+  const tabs = call.tabs?.map((tab) => ({ ...tab, sort: tab.sort === void 0 || tab.sort.length === 0 ? void 0 : [...tab.sort] }));
+  const body = { alias, params: call.params ?? {}, filter: call.filter, sort, ...tabs === void 0 ? {} : { tabs }, report: call.report, file: call.file };
   const mocked = getMockExport(alias);
   if (mocked !== null) return mocked(body);
   return (await rpc("export", body)).file;

package/dist/queries.d.ts

@@ -191,6 +191,20 @@ export interface ExportReport {
     }>;
     /** The file's name, in the template grammar over the report; absent, the template's name, or `title`. */
     filename?: string;
+    /** The period a register's tabs read their rows over: its bounds, a day or a minute of one, with no zone. */
+    period?: {
+        from: string;
+        to: string;
+    };
+    /** The value the report was picked for (its `per`), as the reader names it. */
+    per?: string;
+}
+/** One tab of the register: its rows read as the export's own are — same query and params — under its own filter and order. */
+export interface ExportTab {
+    tab: string;
+    label: string;
+    filter?: QueryFilter;
+    sort?: readonly QuerySortKey[];
 }
 /** 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. */
@@ -207,6 +221,9 @@ export interface ExportCall {
     params?: Record<string, unknown>;
     filter?: QueryFilter;
     sort?: readonly QuerySortKey[];
+    /** A register's tabs, each one's rows beside the call's own (the open tab's): a template reads them under each
+     *  tab's name, the workbook holds one sheet per tab. */
+    tabs?: readonly ExportTab[];
     report: ExportReport;
     file: ExportFile;
 }

package/docs/data_fetching.md

@@ -24,7 +24,7 @@ untyped. It is written from the app's live bindings by `lotics app create --cust
 | `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, 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` |
+| `exportQuery(alias, { params, filter, sort, tabs?, 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. `tabs` (2 to 5, each `{ tab, label, filter?, sort? }`) are each read as the export's own rows are — same query and params, under the tab's own filter and sort (absent, the declared order) — and a template reads each one's rows under its `tab`, a name none of the report's keys nor the template's `rows` key holds. `report` is `{ title, lines, readings, dates?, period?, per?, 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; `period` the tabs' `{ from, to }`, bounds of the same form; `per` the value the report was picked for, in the reader's words; `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`, `period.from` or `.to`, `per`, `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; with `tabs`, one sheet per tab named by its `label` in place of `sheet`) or `{ kind: "template", template }`, one the query declares under `templates` by name ([queries](./queries.md)). Past 20,000 rows, in any tab, 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`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.105.0",
+  "version": "0.106.1",
   "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": {