@lotics/app-sdk 0.125.7 → 0.125.9

package/docs/data_fetching.md

@@ -246,9 +246,9 @@ Reads paginate two different ways, and the difference is load-bearing:
   opaque cursor instead of counting an offset, so a deep scroll stays O(page) and — the reason it
   matters — **never skips or duplicates a row as the set shifts** under concurrent inserts/deletes.
   The cursor is internal: the hook sends it and reads the next one back; you never see it. The
-  server keysets a single sortable key (the runtime `sort`, else the template's own order on a
-  column it projects, else the record id) and falls back to offset transparently for a multi-key
-  sort, or a `first` key, it can't seek. So an infinite feed needs **no
+  server keysets the sort's column keys (the runtime `sort`, else the template's own order on the
+  columns it projects, else the record id) and falls back to offset transparently for a `first`
+  key it can't seek. So an infinite feed needs **no
   dedupe** — key rows by `__source_record_id` for stable React keys, not to guard against repeats.
 - **`page`, `limit`, `queryAll` and manual `rpc("query", { limit, offset })` use offset
   pagination** — count `offset` rows, skip them, return the next page. Two consequences a keyset

package/docs/queries.md

@@ -878,7 +878,7 @@ template as derived nodes, in this order: `filter` (narrow) → `sort` (order)
   `offset` (`limit` clamped to the 10,000-row cap, §10); `useQuery` with `more` opts into **keyset
   (seek)** by sending `keyset: true` + the prior page's `cursor`, and the server returns the next
   `next_cursor` (null on the last page). Seek stays O(page) and never skips/duplicates a row as the
-  set shifts, falling back to offset for a multi-key sort, or a `first` key, it can't seek.
+  set shifts, falling back to offset for a `first` key it can't seek.
 - **`count: true`** — returns `{ total }` only: a COUNT over the *filtered* set, ignoring
   sort/limit/offset. Drives "Page 1 of N". With **`count_by: "<column>"`** the same scan also
   returns `counts` — rows per value of that projected column (a multi-value row under each value,

package/docs/workflows.md

@@ -356,13 +356,14 @@ for (const line of trigger.app_workflow.inputs.lines) {
 Precedence is JS's: `? :`, `||`, `??`, `&&`, `== != === !==`, `< <= > >=`, `+ -`, `* / %`,
 prefix `!` and `-`. Both equality forms work as in JS — `==`/`!=` loose, `===`/`!==` strict.
 
-Not supported: `**`, bitwise operators, `in`, `typeof`, `instanceof`, `delete`, `void`.
+Not supported: `**`, bitwise operators, `instanceof`, `delete`, `void`. `typeof x` answers
+JavaScript's words (a null is `"object"`); `k in o` tests an object's own keys.
 `??=`, `||=` and `&&=` are statements (see *The sugar list*), not expressions.
 
-**`undefined` is `null`.** The name is accepted and means the same value, so `x == undefined` is
-`x == null`. `===` and `!==` against `undefined` are refused (`strict_undefined`): they cannot tell
-a missing key from a null one. Test either with `isNull(x)`, and whether a key was sent with
-`includes(keys(o), "k")` (see *Writing records*).
+**`undefined` reads as `null`.** `x == undefined` is `x == null`, and `x === undefined` /
+`x !== undefined` are `isNull(x)` / `isNotNull(x)`: none of them tells a missing key from a null one.
+Test whether a key was sent with `includes(keys(o), "k")` (see *Writing records*). A write tells them
+apart: a field given `undefined` is left as it is, where `null` clears it.
 
 **Ordered comparison against null is `false`, never a throw.** `<`/`>`/`<=`/`>=` with a
 null/undefined operand evaluate to `false`. A mismatch between two *non-null* operands still
@@ -393,7 +394,6 @@ body does not look like what you typed.
 | `[...a, b]` | `concat(a, [b])` |
 | `{ ...a, b: 1 }` | `merge(merge({}, a), { b: 1 })` — later sources win, as in JS — and reads back as the spread, typed as you wrote it |
 | `{ table_id }` | `{ table_id: table_id }` — in expressions **and** tool inputs |
-| `undefined` | `null` |
 | `xs.push(a, b);` | `xs = concat(xs, [a, b])` — statement form |
 | `o.a.items.push(v);` | `o = merge(o, { a: merge(o.a, { items: concat(o.a.items, [v]) }) })` |
 | `o.a.b = v;` | `o = merge(o, { a: merge(o.a, { b: v }) })` — also `o.a.b += v`, `o.n++` |
@@ -469,7 +469,7 @@ is what matters, and expect to re-extract it if you edit the source read back.
 `get → set` is a fixed point on the stored tree, not on your text. A body read back prints the
 canonical form — `concat` for a spread, `merge` for an object spread, `{x: x}` for shorthand,
 `toString`/`lower` for a cast or a method call, the arrow spelling for either callback form,
-`null` for `undefined`, `let` for a `const` the body mutates, and the inlined body at each call
+`let` for a `const` the body mutates, and the inlined body at each call
 site of a declared `function`. `?.` and `??` re-sugar, and a tool-result destructure prints back
 as the destructuring statement (`const { records } = await query_records({…});`, with renames and
 defaults intact); where a `?.` guard lands mid-path it prints as the explicit `isNull(…) ? null :
@@ -625,7 +625,7 @@ if (includes(keys(i), "phone")) {   // NOT `isNull(i.phone)` — that swallows t
 
 An omitted input carries no key at all and a cleared one carries the key with `null`, so presence
 is the only test that separates them — and it has to be `keys`: a body reads `undefined` as `null`,
-so `i.phone === undefined` is refused rather than read as a test of whether the input was sent.
+so `i.phone === undefined` is `isNull(i.phone)`, which a cleared input passes too.
 `""` is never a clear: the validator coerces it to omitted before the body runs.
 
 Value shapes, which the generated types enforce exactly:

package/package.json

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