@lotics/app-sdk 0.125.8 → 0.125.9

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.8",
+  "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": {