@proveanything/smartlinks 2.1.15 → 2.1.17

package/dist/types/appManifest.d.ts

@@ -490,6 +490,53 @@ export interface ServerFunctionBookings {
         }>;
     };
 }
+/** One write in ctx.sl.transaction. */
+export type RecordTransactionOp = {
+    op: 'create';
+    record: Record<string, any>;
+} | {
+    op: 'update';
+    recordId: string;
+    fields: Record<string, any>;
+} | {
+    op: 'adjust';
+    recordId: string;
+    by: Record<string, number>;
+    atLeast?: Record<string, number>;
+    atMost?: Record<string, number>;
+} | {
+    op: 'delete';
+    recordId: string;
+}
+/** An event in the app's history (BigQuery): commits with the other ops, delivered after. Needs sl:history:write. */
+ | {
+    op: 'log';
+    type: string;
+    data?: Record<string, any>;
+    entityId?: string;
+};
+/** One event from an app's history. */
+export interface AppHistoryEvent {
+    id: string;
+    at: string;
+    type: string;
+    entityId: string | null;
+    data: Record<string, any>;
+    actorType: 'user' | 'contact' | null;
+    actorId: string | null;
+}
+/** Reading an app's history: its own events in this collection, newest first. */
+export interface AppHistoryQuery {
+    types?: string | string[];
+    entityId?: string;
+    /** Exact match on top-level data keys (one value or several). */
+    data?: Record<string, string | number | boolean | Array<string | number | boolean>>;
+    /** ISO dates. Default: the last 30 days; at most 400 days. */
+    from?: string;
+    to?: string;
+    /** Default 100, at most 1000. */
+    limit?: number;
+}
 export interface ServerFunctionSl {
     /** THIS app's bookings, slots and blocks (`sl:bookings:read` / `sl:bookings:write`). */
     bookings: ServerFunctionBookings;
@@ -502,8 +549,48 @@ export interface ServerFunctionSl {
      */
     appRecords: {
         claim(fields: Record<string, any>): Promise<AppRecordClaimResult>;
+        /**
+         * Numbers in a record's `data`, changed in place in one statement: two scanners on one bin never lose
+         * a count. `by` `{ qty: -5 }` (missing counts as 0). `atLeast` / `atMost` are checked on the values
+         * AFTER the change: `{ atLeast: { qty: 0 } }` never takes a bin below zero. Refusals carry `code`:
+         * `NOT_FOUND`, `NOT_A_NUMBER`, `CONDITION_FAILED` (with `current` values). → the updated record.
+         */
+        adjust(recordId: string, by: Record<string, number>, opts?: {
+            atLeast?: Record<string, number>;
+            atMost?: Record<string, number>;
+        }): Promise<any>;
+        /** Totals over THIS app's records: count, sum/avg/min/max of data numbers, grouped by data keys. */
+        aggregate(params?: import('./appObjects.js').AggregateRequest): Promise<import('./appObjects.js').AggregateResponse & Record<string, unknown>>;
         [method: string]: any;
     };
+    /**
+     * Several record writes that land together or not at all (take 5 from bin A AND add 5 to order line B
+     * AND log the move). Needs `sl:records:write`; THIS app's records in THIS collection only. A failing op
+     * rolls everything back; its error says which (`opIndex`) and why (`code`). With `idempotencyKey`, a
+     * repeat of the key (a scanner retrying after a dropped signal) returns the first results
+     * (`replayed: true`) instead of writing twice; keys are remembered for 30 days.
+     */
+    transaction(ops: RecordTransactionOp[], opts?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        results: any[];
+        replayed: boolean;
+    }>;
+    /**
+     * The app's HISTORY: append-only events kept in BigQuery (stock moved, a count taken, an order shipped),
+     * so the app's records hold current state and never grow with activity. `log` (`sl:history:write`)
+     * stores one event (it arrives within seconds; a failed delivery is retried, never lost); inside a
+     * transaction use a `log` op instead, so it commits with the change. `query` (`sl:history:read`) reads
+     * this app's events in this collection, newest first.
+     */
+    history: {
+        log(type: string, data?: Record<string, any>, opts?: {
+            entityId?: string;
+        }): Promise<{
+            id: string;
+        }>;
+        query(params?: AppHistoryQuery): Promise<AppHistoryEvent[]>;
+    };
     /** Atomic named counters for this app in this collection (`sl:data:write` / `sl:data:read`). */
     counters: ServerFunctionCounters;
     /** Tags (`sl:tags:read`): `resolve(id)` → the real tag in THIS collection, or `null` for a made-up id. */

package/dist/types/appObjects.d.ts

@@ -55,8 +55,29 @@ export interface AggregateRequest {
         expires_at?: {
             lte?: string;
         };
+        updated_at?: {
+            gte?: string;
+            lte?: string;
+        };
+        /** Records only: exact match on top-level data keys, one value or any of several. */
+        data?: Record<string, string | number | boolean | Array<string | number | boolean>>;
+        /** Records only: numeric comparisons on top-level data keys (numbers only; others never match). */
+        dataRange?: Record<string, {
+            gte?: number;
+            gt?: number;
+            lte?: number;
+            lt?: number;
+        }>;
     };
+    /**
+     * Columns per resource; records also take top-level data keys as `'data.<key>'` (e.g. `'data.location'`),
+     * up to 5. Each group comes back with its key under the same name.
+     */
     groupBy?: string[];
+    /**
+     * `'count'`; records also take `'sum:<key>'`, `'avg:<key>'`, `'min:<key>'`, `'max:<key>'` over numbers in a
+     * top-level data key (non-numbers ignored) → `sum_<key>`, `avg_<key>`… in the result.
+     */
     metrics?: string[];
     timeSeriesField?: string;
     timeSeriesInterval?: 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
@@ -66,7 +87,7 @@ export interface AggregateRequest {
  */
 export interface AggregateResponse {
     groups?: ({
-        count: number;
+        count?: number;
     } & Record<string, unknown>)[];
     timeSeries?: ({
         bucket: string;

package/dist/types/claimSet.d.ts

@@ -129,21 +129,32 @@ export type ClaimSetScope = {
     partnerId: string;
 };
 export type ClaimSetTagType = 'ntag424' | 'ntag21x' | 'qr';
-export type ClaimSetRangeStatus = 'minting' | 'minted' | 'sent' | 'received' | 'assigned';
+/**
+ * range: a contiguous block of indexes minted up front. open: grows one index per tag programmed on a phone
+ * (count unknown in advance), closed into a range later. group: existing tags added by tapping, assigned by
+ * hand and moved together; no indexes.
+ */
+export type ClaimSetRangeKind = 'range' | 'open' | 'group';
+export type ClaimSetRangeStatus = 'minting' | 'minted' | 'sent' | 'received' | 'assigned' | 'open' | 'group';
 export interface ClaimSetRange {
     id: string;
     claimSetId: string;
     namespace: string;
+    kind: ClaimSetRangeKind;
     name: string;
     notes: string | null;
-    startIndex: number;
-    endIndex: number;
+    /** null for a group */
+    startIndex: number | null;
+    /** open: the highest index minted so far (null until the first); group: null */
+    endIndex: number | null;
+    /** range: the block; open: minted so far; group: its members */
     quantity: number;
     tagType: ClaimSetTagType;
+    /** open ranges and groups are always 'sidekick' */
     fulfilment: 'printer' | 'sidekick';
-    /** The stored step: minting | minted | sent | received */
+    /** The stored step: minting | minted | sent | received (always 'minted' for open ranges and groups) */
     stage: 'minting' | 'minted' | 'sent' | 'received';
-    /** What to show: the stage, or 'assigned' once every tag is assigned */
+    /** What to show: the stage, 'open', 'group', or 'assigned' once every tag is assigned */
     status: ClaimSetRangeStatus;
     intendedCollectionId: string | null;
     intendedProductId: string | null;
@@ -162,9 +173,11 @@ export interface ClaimSetRange {
     updatedAt: string;
 }
 export interface CreateClaimSetRangeRequest {
+    /** Default 'range'. Owners and admins make ranges and open ranges; assigners may make groups too. */
+    kind?: ClaimSetRangeKind;
     name: string;
-    /** 1 to 10,000 */
-    quantity: number;
+    /** 1 to 10,000 (a range); ignored for open ranges and groups */
+    quantity?: number;
     /** Pre-assign every tag at mint time (you must administer the collection) */
     intendedCollectionId?: string;
     intendedProductId?: string;
@@ -194,6 +207,10 @@ export interface ClaimSetRangeTag {
     productId: string | null;
     batchId: string | null;
     proofId: string | null;
+    /** The range it was minted into, if any */
+    rangeId: string | null;
+    /** The group it was added to, if any */
+    groupId: string | null;
     programmedAt: string | null;
     scans: number;
 }
@@ -207,8 +224,42 @@ export interface ClaimSetRangeNextTag extends ClaimSetRangeTag {
     url: string;
     piccOffset?: number;
     mirrorOffset?: number;
-    remaining: number;
+    /** Tags still without a chip; null for an open range (it grows as you go) */
+    remaining: number | null;
+}
+/** Add an existing tag of the set to a group, and (with a collection, or clear) assign it as you go. */
+export interface AddClaimSetRangeMemberRequest {
+    /** The tag's code, printed or bare… */
+    code?: string;
+    /** …or its chip UID (14 hex) */
+    uid?: string;
+    collectionId?: string;
+    productId?: string;
+    batchId?: string;
+    data?: Record<string, unknown>;
+    clear?: boolean;
 }
+export interface AddClaimSetRangeMemberResponse {
+    tag: ClaimSetRangeTag;
+    range: ClaimSetRange;
+    /** The assignment, with the same skips as assign (has_proof, assigned_elsewhere) */
+    assigned: {
+        changed: number;
+        skipped: Array<{
+            code: string;
+            index: number | null;
+            reason: 'other_range' | 'has_proof' | 'assigned_elsewhere';
+            collectionId?: string;
+        }>;
+    };
+    /** The group the tag was taken from, if it was in another one */
+    movedFrom: string | null;
+}
+/** Closing an open range: the range it became, or that it was removed because nothing was minted. */
+export type CloseClaimSetRangeResponse = ClaimSetRange | {
+    id: string;
+    deleted: true;
+};
 export type ClaimSetImportResult = 'ok' | 'unchanged' | 'unknown_code' | 'duplicate_row' | 'index_mismatch' | 'no_uid' | 'bad_uid' | 'duplicate_uid' | 'uid_in_use' | 'uid_conflict';
 export interface ImportClaimSetRangeUidsRequest {
     /** The manufacturer's file as CSV text (the file we sent, with UID filled in) */
@@ -310,6 +361,8 @@ export interface PartnerTagHit {
         url: string | null;
     };
     range: ClaimSetRange | null;
+    /** The group the tag was added to, if any */
+    group: ClaimSetRange | null;
 }
 export interface CreatePartnerClaimSetRequest {
     name: string;

package/dist/types/clientLog.d.ts

@@ -0,0 +1,46 @@
+/**
+ * An app reporting an error it saw (errors.report): kept in the platform's one error log (CloudEvents + ECS
+ * rows in BigQuery), the same place server-side errors go. Say what it was about with entityType/entityId
+ * (a tag's chip UID, a product id, an order id), put routing facts in labels and the detail in context.
+ * Never include keys, passwords or tokens: the server drops any field whose name looks like one.
+ */
+export interface ClientErrorReport {
+    /** Which app: 'sidekick', 'studio', a site's app id. Default 'client'. */
+    app?: string;
+    appVersion?: string;
+    /** The collection it concerns, when there is one (owners see their collection's errors) */
+    collectionId?: string;
+    /** What was being done: 'tag.program', 'order.submit', … */
+    operation?: string;
+    severity?: 'debug' | 'info' | 'warning' | 'error' | 'critical';
+    /** A short stable code: 'TAG_LOST', 'TIMEOUT', … (this or message is required) */
+    errorCode?: string;
+    errorType?: string;
+    message?: string;
+    stack?: string;
+    /** What it was about: 'tag', 'product', 'order', … */
+    entityType?: string;
+    /** …and which one: a chip UID (normalised for 'tag'), a product id, … */
+    entityId?: string;
+    labels?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    /** An operation id to group by (a batch, a job) */
+    refId?: string;
+    correlationId?: string;
+}
+/** One kept error event, as the lookups return it (newest first). */
+export interface ClientErrorEvent {
+    id: string;
+    time: string;
+    event_category: string;
+    event_action: string | null;
+    log_level: string;
+    error_code: string | null;
+    error_message: string | null;
+    service_name: string | null;
+    service_version: string | null;
+    collection_id: string | null;
+    user_id: string | null;
+    labels: Record<string, unknown> | null;
+    context: Record<string, unknown> | null;
+}

package/dist/types/clientLog.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -45,3 +45,4 @@ export * from "./research.js";
 export * from "./config.js";
 export * from "./widgets.js";
 export * from "./headless.js";
+export * from "./clientLog.js";

package/dist/types/index.js

@@ -47,3 +47,4 @@ export * from "./research.js";
 export * from "./config.js";
 export * from "./widgets.js";
 export * from "./headless.js";
+export * from "./clientLog.js";

package/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 2.1.15  |  Generated: 2026-11-09T15:17:42.472Z
+Version: 2.1.17  |  Generated: 2026-11-11T09:04:21.796Z
 
 This is a concise summary of all available API functions and types.
 
@@ -144,6 +144,7 @@ The Smartlinks SDK is organized into the following namespaces:
 - **bookings** - Functions for bookings operations
 - **config** - Functions for config operations
 - **containers** - Functions for containers operations
+- **errors** - Functions for errors operations
 - **facets** - Functions for facets operations
 - **functions** - Functions for functions operations
 - **http** - Functions for http operations
@@ -2838,11 +2839,46 @@ interface ServerFunctionBookings {
 }
 ```
 
+**AppHistoryEvent** (interface)
+```typescript
+interface AppHistoryEvent {
+  id: string;
+  at: string;
+  type: string;
+  entityId: string | null;
+  data: Record<string, any>;
+  actorType: 'user' | 'contact' | null;
+  actorId: string | null;
+}
+```
+
+**AppHistoryQuery** (interface)
+```typescript
+interface AppHistoryQuery {
+  types?: string | string[];
+  entityId?: string;
+  data?: Record<string, string | number | boolean | Array<string | number | boolean>>;
+  from?: string;
+  to?: string;
+  limit?: number;
+}
+```
+
 **ServerFunctionSl** (interface)
 ```typescript
 interface ServerFunctionSl {
   bookings: ServerFunctionBookings;
-  appRecords: { claim(fields: Record<string, any>): Promise<AppRecordClaimResult>; [method: string]: any };
+  appRecords: {
+  claim(fields: Record<string, any>): Promise<AppRecordClaimResult>;
+  adjust(recordId: string, by: Record<string, number>, opts?: { atLeast?: Record<string, number>; atMost?: Record<string, number> }): Promise<any>;
+  aggregate(params?: import('./appObjects').AggregateRequest): Promise<import('./appObjects').AggregateResponse & Record<string, unknown>>;
+  [method: string]: any;
+  };
+  transaction(ops: RecordTransactionOp[], opts?: { idempotencyKey?: string }): Promise<{ results: any[]; replayed: boolean }>;
+  history: {
+  log(type: string, data?: Record<string, any>, opts?: { entityId?: string }): Promise<{ id: string }>;
+  query(params?: AppHistoryQuery): Promise<AppHistoryEvent[]>;
+  };
   counters: ServerFunctionCounters;
   tags: { resolve(id: string): Promise<ResolvedTag | null> };
   contacts: {
@@ -3298,6 +3334,8 @@ interface GetCollectionWidgetsOptions {
 
 **AppFunctionAuthority** = `'caller' | 'collection'`
 
+**RecordTransactionOp** = ``
+
 ### appObjects
 
 **PaginatedResponse<T>** (interface)
@@ -3324,9 +3362,12 @@ interface AggregateRequest {
   created_at?: { gte?: string; lte?: string }
   closed_at?: '__notnull__' | { gte?: string; lte?: string } // cases only
   expires_at?: { lte?: string } // records only
+  updated_at?: { gte?: string; lte?: string } // records only
+  data?: Record<string, string | number | boolean | Array<string | number | boolean>>
+  dataRange?: Record<string, { gte?: number; gt?: number; lte?: number; lt?: number }>
   }
-  groupBy?: string[] // see per-resource allowed values
-  metrics?: string[] // see per-resource allowed values below
+  groupBy?: string[]
+  metrics?: string[]
   timeSeriesField?: string // e.g. 'created_at'
   timeSeriesInterval?: 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year'
 }
@@ -3335,7 +3376,7 @@ interface AggregateRequest {
 **AggregateResponse** (interface)
 ```typescript
 interface AggregateResponse {
-  groups?: ({ count: number } & Record<string, unknown>)[]
+  groups?: ({ count?: number } & Record<string, unknown>)[]
   timeSeries?: ({ bucket: string; count: number } & Record<string, unknown>)[]
   count?: number
   avg_close_time_seconds?: number
@@ -5775,10 +5816,11 @@ interface ClaimSetRange {
   id: string
   claimSetId: string
   namespace: string
+  kind: ClaimSetRangeKind
   name: string
   notes: string | null
-  startIndex: number
-  endIndex: number
+  startIndex: number | null
+  endIndex: number | null
   quantity: number
   tagType: ClaimSetTagType
   fulfilment: 'printer' | 'sidekick'
@@ -5801,8 +5843,9 @@ interface ClaimSetRange {
 **CreateClaimSetRangeRequest** (interface)
 ```typescript
 interface CreateClaimSetRangeRequest {
+  kind?: ClaimSetRangeKind
   name: string
-  quantity: number
+  quantity?: number
   intendedCollectionId?: string
   intendedProductId?: string
   intendedBatchId?: string
@@ -5837,6 +5880,8 @@ interface ClaimSetRangeTag {
   productId: string | null
   batchId: string | null
   proofId: string | null
+  rangeId: string | null
+  groupId: string | null
   programmedAt: string | null
   scans: number
 }
@@ -5850,6 +5895,29 @@ interface ClaimSetRangeTagsPage {
 }
 ```
 
+**AddClaimSetRangeMemberRequest** (interface)
+```typescript
+interface AddClaimSetRangeMemberRequest {
+  code?: string
+  uid?: string
+  collectionId?: string
+  productId?: string
+  batchId?: string
+  data?: Record<string, unknown>
+  clear?: boolean
+}
+```
+
+**AddClaimSetRangeMemberResponse** (interface)
+```typescript
+interface AddClaimSetRangeMemberResponse {
+  tag: ClaimSetRangeTag
+  range: ClaimSetRange
+  assigned: { changed: number; skipped: Array<{ code: string; index: number | null; reason: 'other_range' | 'has_proof' | 'assigned_elsewhere'; collectionId?: string }> }
+  movedFrom: string | null
+}
+```
+
 **ImportClaimSetRangeUidsRequest** (interface)
 ```typescript
 interface ImportClaimSetRangeUidsRequest {
@@ -5939,6 +6007,7 @@ interface PartnerTagHit {
   set: PartnerClaimSet | null
   tag: ClaimSetRangeTag & { url: string | null }
   range: ClaimSetRange | null
+  group: ClaimSetRange | null
 }
 ```
 
@@ -5958,10 +6027,56 @@ type ClaimSetScope = { collectionId: string }
 
 **ClaimSetTagType** = `'ntag424' | 'ntag21x' | 'qr'`
 
-**ClaimSetRangeStatus** = `'minting' | 'minted' | 'sent' | 'received' | 'assigned'`
+**ClaimSetRangeKind** = `'range' | 'open' | 'group'`
+
+**ClaimSetRangeStatus** = `'minting' | 'minted' | 'sent' | 'received' | 'assigned' | 'open' | 'group'`
+
+**CloseClaimSetRangeResponse** = `ClaimSetRange | { id: string`
 
 **ClaimSetImportResult** = ``
 
+### clientLog
+
+**ClientErrorReport** (interface)
+```typescript
+interface ClientErrorReport {
+  app?: string
+  appVersion?: string
+  collectionId?: string
+  operation?: string
+  severity?: 'debug' | 'info' | 'warning' | 'error' | 'critical'
+  errorCode?: string
+  errorType?: string
+  message?: string
+  stack?: string
+  entityType?: string
+  entityId?: string
+  labels?: Record<string, unknown>
+  context?: Record<string, unknown>
+  refId?: string
+  correlationId?: string
+}
+```
+
+**ClientErrorEvent** (interface)
+```typescript
+interface ClientErrorEvent {
+  id: string
+  time: string
+  event_category: string
+  event_action: string | null
+  log_level: string
+  error_code: string | null
+  error_message: string | null
+  service_name: string | null
+  service_version: string | null
+  collection_id: string | null
+  user_id: string | null
+  labels: Record<string, unknown> | null
+  context: Record<string, unknown> | null
+}
+```
+
 ### collection
 
 **Collection** (interface)
@@ -12464,6 +12579,15 @@ Name, notes, order details, or a stage move (sent to the printer, received).
 **resume**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<ClaimSetRange>`
 Finish minting a range that was interrupted.
 
+**close**(scope: ClaimSetScope, claimSetId: string, rangeId: string) → `Promise<CloseClaimSetRangeResponse>`
+Close an open range: it becomes a range with the quantity it reached (removed if nothing was minted).
+
+**addMember**(scope: ClaimSetScope, claimSetId: string, groupId: string, params: AddClaimSetRangeMemberRequest) → `Promise<AddClaimSetRangeMemberResponse>`
+Put an existing tag of the set into a group (by code or chip UID), assigning it if a collection is given.
+
+**removeMember**(scope: ClaimSetScope, claimSetId: string, groupId: string, code: string) → `Promise<`
+Take a tag out of a group. Its assignment is left as it is.
+
 **tags**(scope: ClaimSetScope, claimSetId: string, rangeId: string,
       options: { from?: number; limit?: number; keys?: boolean } = {}) → `Promise<ClaimSetRangeTagsPage>`
 The range's tags in index order, a page at a time (keys: owners/admins only).
@@ -12790,6 +12914,10 @@ Update a crate for a collection (admin only). ```typescript const updated = awai
     crateId: string) → `Promise<DeleteCrateResponse>`
 Delete a crate for a collection (admin only). This performs a soft delete. ```typescript await crate.remove('coll_123', 'crate_abc123') ```
 
+### errors
+
+**report**(event: ClientErrorReport) → `Promise<`
+
 ### facets
 
 **list**(collectionId: string,
@@ -13422,6 +13550,9 @@ A new claim set for the partner, on one of its tap domains (owners and admins).
 **lookupTags**(partnerId: string, query: { uid?: string; code?: string }) → `Promise<PartnerTagHit[]>`
 Find a tag across the partner's sets by its chip UID (8 or 14 hex) or its code (printed or bare). Never returns keys.
 
+**tagAttempts**(partnerId: string, uid: string) → `Promise<ClientErrorEvent[]>`
+What phones reported about one chip (errors.report with entityType 'tag'), newest first: a tag that failed to program or register, with the host's NFC log in context. For a chip in the partner's sets, or attempts that named one of them.
+
 ### podcast
 
 **generate**(collectionId: string,

package/docs/app-objects.md

@@ -807,6 +807,29 @@ await app.records.upsert(collectionId, appId, {
 // customId is stored for later reverse-lookup via ?customId=&sourceSystem=
 ```
 
+### Totals over data (sum, average, min, max)
+
+Records also total the numbers in their `data`, grouped by top-level data keys, with data filters and
+numeric ranges. Stock per location, forecast per SKU:
+
+```typescript
+const stock = await app.records.aggregate(collectionId, appId, {
+  groupBy: ['data.location'],                       // up to 5: columns or 'data.<key>'
+  metrics: ['count', 'sum:qty', 'min:qty'],         // count; sum: / avg: / min: / max: + a data key
+  filters: {
+    record_type: 'bin',
+    data: { warehouse: ['north', 'south'] },        // exact match, one value or any of several
+    dataRange: { qty: { gt: 0 } },                  // gte / gt / lte / lt, numbers only
+    updated_at: { gte: '2026-11-01T00:00:00Z' },
+  },
+}, true)
+// stock.groups → [{ 'data.location': 'A1', count: 12, sum_qty: 340, min_qty: 2 }, …]
+```
+
+Values that aren't numbers are left out of sums and averages. To CHANGE numbers safely (stock moves,
+counts), use a server function: `ctx.sl.appRecords.adjust` and `ctx.sl.transaction`
+([server-functions.md](server-functions.md)).
+
 ### Counts by Record Type
 
 `aggregate()` returns counts grouped by `record_type` in a single round-trip — no separate endpoint needed: