@nodegx/mcp 0.2.4 → 0.2.6

package/dist/render-harness/data/node-catalog-enriched.json

@@ -7928,11 +7928,9 @@
       ],
       "dynamicPorts": {
         "mechanisms": [
-          "runtime-discovered",
-          "editor-adapter"
+          "runtime-discovered"
         ],
-        "description": "Filter/sort input ports are generated by the editor from the visual query (QueryRecordsAdapter) and the selected class schema.",
-        "editorAdapter": "QueryRecordsAdapter"
+        "description": "Every input is drawn from the parameters, so the static port list is empty: \"collectionName\" (the class), \"visualFilter\", \"visualSort\", \"storageEnableLimit\" + \"storageLimit\"/\"storageSkip\", \"storageEnableCount\", \"search\", \"realtime\", and the \"runOnChange-<input>\" boxes. A server-side filter is \"visualFilter\": {\"combinator\": \"and\", \"rules\": [{\"property\": \"<field>\", \"operator\": \"equal to\", \"input\": \"<name>\"}]}; each rule's \"input\" mints the input port \"qp-<name>\" a connection feeds, or the rule carries a literal \"value\" instead. Any other parameter name is stored and never read."
       },
       "parameterEncoding": {
         "known": true,
@@ -8057,8 +8055,9 @@
           "changedRecords": "All records of the last batch; for deletes, an array of primary-key strings.",
           "changedRecordId": "Primary key of the first affected record, across all three event types."
         },
-        "runtimeBehavior": "All *inputs* are runtime-determined (runtime-discovered + editor-adapter): the class choice, filter values, sort keys and paging inputs are generated from the project's database schema and the visual filter you build in the editor — e.g. each 'value' placeholder in a filter becomes its own input port, and actions like fetch ('storageFetch') are registered on demand. A generator cannot enumerate them statically; an authoring tool should set `collectionName` and filter parameters, and may wire signals to fetch-related inputs which the runtime registers when used.",
+        "runtimeBehavior": "Every input is drawn from the parameters (the static list is empty). Set `collectionName` (the class). FILTER ON THE SERVER with `visualFilter`: {\"combinator\": \"and\", \"rules\": [{\"property\": \"<field>\", \"operator\": \"equal to\", \"input\": \"<name>\"}]} — each rule's `input` mints an input port `qp-<name>`; wire the value into it (e.g. a User node's `id` → `qp-ownerId`), or give the rule a literal `\"value\"` instead of `input`. Operators: \"equal to\", \"not equal to\", \"greater than\", \"greater than or equal to\", \"less than\", \"less than or equal to\", \"contain\" (case-insensitive), \"exist\", \"not exist\" (no value), \"points to\" (a pointer field equals a record id), and \"related to\" (with `relatedTo` and `relationProperty`). A rule may itself be a {\"combinator\": \"or\", \"rules\": [...]} group. The filter is compiled to the backend's `where`, so only matching rows leave the server. Sort: `visualSort`: [{\"property\": \"<field>\", \"order\": \"ascending\" | \"descending\"}]. Paging: `storageEnableLimit`: true with `storageLimit` and `storageSkip` (both ignored without it); `storageEnableCount`: true adds the `storageTotalCount` output. `storageFetch` (Do) is the signal that re-runs it. ⚠️ A rule whose `qp-` value has not arrived yet is DROPPED, not failed, so the query that runs when the graph is built returns every row the user may read: with a wired filter value set `\"runOnChange-collectionName\": false` and `\"runOnChange-querySettings\": false` and leave Do unwired, so the value's arrival is what runs the query (get_example cloud-query-own-rows). Any other parameter name (`querySettings`, `filter`, `where`…) is stored and never read, and the write is refused. Once the filter is opened in the editor's panel it is saved as {\"type\": \"and\", \"conditions\": [{\"field\", \"operator\": \"equalTo\", \"valueSource\": \"connected\", \"valuePortName\": \"qp-<name>\"}]}; the runtime reads both shapes.",
         "examples": [
+          "cloud-query-own-rows",
           "repeater-query-records",
           "send-event-across-components",
           "cloud-record-live-refresh",
@@ -8068,12 +8067,14 @@
           "community-email-signup-validat"
         ],
         "patterns": [
+          "A signed-in user's own rows: `visualFilter` rule {\"property\": \"owner\", \"operator\": \"equal to\", \"input\": \"owner\"}, the User node's `id` wired into `qp-owner`, and both fetch-at-build boxes off — the server answers with only that user's rows. `owner` is the backend's: it writes the creator into every record from their session, and a page never sends it. A field the page filled from the User id (an ownerId, a familyId) is the caller's word, never proof of whose a record is.",
           "`items` → Repeater `items`, with record properties delivered to the item component via Component Inputs: the canonical list page.",
           "Event Receiver `eventReceived` → fetch input: re-run a query on demand from anywhere in the app.",
           "Turn on Subscribe To Changes and wire `Changed` back into this node's own `Do`: the list stays current without polling, on every backend whose descriptor allows it — SSE on the built-in backend and PocketBase, a WebSocket on Directus.",
           "`Subscribed` → a status indicator's visibility, so people can see when live updates are actually running rather than assuming."
         ],
         "antiPatterns": [
+          "Fetching every row and dropping the ones a user should not see in a Function or Filter Records: every row still reaches every browser. Filter on the server with `visualFilter` and a `qp-` port.",
           "Re-querying on a timer to feel 'live' — results already update from cloud events; explicit re-fetch is only needed when the server changed outside those events.",
           "Treating `Changed Record` as the full record on a delete — delete events carry only primary keys, so it is null and only `Changed Record Id` is populated.",
           "Polling with a Timer while Subscribe To Changes is available on this backend. Subscribe and re-fetch on `Changed` instead.",
@@ -8539,7 +8540,7 @@
             "name": "signal"
           },
           "isSignal": true,
-          "description": "Fires when the Id binds a record, and again when a Fetch finishes reading it — a bind has read nothing, so use Done to act on data that is really there"
+          "description": "Fires when the Id binds a record already in memory, when a record the Id names is first read from the backend, and when a Fetch finishes reading it; use Done to act on the answer to a Fetch"
         },
         {
           "name": "id",
@@ -8632,14 +8633,14 @@
       "enrichment": {
         "typeName": "DbModel2",
         "summary": "Record: binds to one cloud database record by id and exposes each of its properties as an output that follows the record.",
-        "description": "DbModel2 (Record) points at a single record of a cloud database class and exposes one value output per property of that class (registered as `prop-<property>`), plus a `changed-<property>` signal per property. Setting `modelId` binds the node to the record in the app's local record store — properties already known locally (for example from a Query Records result) appear immediately, and `fetched` fires. Triggering `fetch` (Fetch, signal) loads the record fresh from the server by id; while `fetch` is connected, local change events no longer drive the outputs, so updates arrive only when you fetch. `changed` fires whenever the bound record changes from anywhere in the app (a Update Record elsewhere, a live query update). `fetched` and `changed` are value-level announcements and fire on binding as well as on a fetch; `done`/`failure`/`completed` are the outcome of a `fetch` invocation specifically, so wire those to sequence a chain and `fetched` to react to the data.",
+        "description": "DbModel2 (Record) points at a single record of a cloud database class and exposes one value output per property of that class (registered as `prop-<property>`), plus a `changed-<property>` signal per property. Setting `modelId` binds the node to that record. A record already in memory (for example from a Query Records result on the page you came from) appears at once and `fetched` fires. A record nothing in memory holds yet (a page opened by its own URL: a reload, a bookmark, a shared link) is read from the backend first, and `fetched` fires when it arrives; until then the property outputs are empty. Triggering `fetch` (Fetch, signal) re-reads the record from the server by id. `changed` fires whenever the bound record changes from anywhere in the app (an Update Record elsewhere, a live query update). `fetched` and `changed` are value-level announcements; `done`/`failure`/`completed` are the outcome of a `fetch` invocation specifically, so wire those to sequence a chain and `fetched` to react to the data. A read the bind makes on its own reports a failure on `error`, not on `failure`.",
         "whenToUse": "Use it to read one record's properties — a detail page, or the current item inside a repeater (set `idSource` to 'From repeater'). It does not write: pair it with SetDbModelProperties to save edits. For lists of records use DbCollection2 (Query Records); for records from a non-cloud (BYOB) backend use noodl.byob.QueryData, whose results are plain objects, not records.",
         "ports": {
           "modelId": "Value input (connections only): the record id to bind to; a full record object is also accepted and dereferenced to its id.",
           "idSource": "Edit-only choice: 'Specify explicitly' uses `modelId`; 'From repeater' binds to the record driving the nearest enclosing For Each item.",
-          "fetch": "Signal; fetches the record from the server by the current `modelId`. Connecting it also switches the node to fetch-driven mode: outputs update on Fetch instead of on local record changes.",
-          "fetched": "Signal; fires after the record resolves — on bind when `fetch` is not connected, or after a server fetch completes.",
-          "changed": "Signal; fires when the bound record's data changes anywhere in the app (suppressed while `fetch` is connected).",
+          "fetch": "Signal; re-reads the record from the server by the current `modelId`, replacing the copy held in memory. Not needed for a page opened by its own URL: binding an id nothing in memory holds already reads it.",
+          "fetched": "Signal; fires when the record is there to read: on bind for a record already in memory, when the backend answers for one that was not, and after a Fetch completes.",
+          "changed": "Signal; fires when the bound record's data changes anywhere in the app.",
           "id": "String value; the id of the currently bound record."
         },
         "runtimeBehavior": "Property ports are runtime-determined from the cloud database class selected via the `collectionName` parameter (itself a runtime-registered enum of the project's classes plus _User and _Role): each schema property becomes a value output `prop-<name>` (typed from the schema) and a signal output `changed-<name>`. Relation properties get no ports. An authoring tool should set `collectionName` in parameters and may reference `prop-<name>`/`changed-<name>` for properties it knows exist in the class schema.",
@@ -8651,7 +8652,7 @@
           "`prop-<name>` → a Text Input's `startValue`, edited text → Update Record `prop-<name>`: prefill an edit form and save it back."
         ],
         "antiPatterns": [
-          "Connecting `fetch` just to 'refresh' — while `fetch` is connected the node stops following local record changes, so only do it when you explicitly want server-fetch-driven updates.",
+          "Reading the property outputs before `fetched` on a page that can be opened by its own URL — until the backend answers they are empty, and an Update Record fed from them then writes the empties back. Act on `fetched` (or a Fetch's `done`).",
           "Comparing a read-back Object field with `JSON.stringify` — an Object field does not keep the order of its names (a backend on PostgreSQL gives them back with shorter names first), so two equal objects can give different text. Compare them name by name, and sort the names yourself where a page shows them in an order."
         ],
         "relatedNodes": [
@@ -21824,7 +21825,8 @@
           "`done` → a navigation or Event Sender, with `id` as payload: jump straight to the new record's detail page."
         ],
         "antiPatterns": [
-          "Re-fetching a Query Records node after `done` — live queries already receive the new record; only re-fetch when the query is not live."
+          "Re-fetching a Query Records node after `done` — live queries already receive the new record; only re-fetch when the query is not live.",
+          "Wiring the User node's `id` into a field of your own (an ownerId, a familyId, a teamId) to say whose the record is. The backend already writes the creator into `owner` from the session and drops an `owner` the page sends; a field the page fills is whatever the caller sent, so anyone signed in can name another id. Read `owner` wherever it is decided who sees the record (example `cloud-share-my-records-with-someone`)."
         ],
         "relatedNodes": [
           "SetDbModelProperties",
@@ -31286,6 +31288,17 @@
           "description": "Read and write rules stored on the record as it is written, each rule adding its own Target, Read and Write ports; the NodeGX backend enforces them on every query and every realtime event, and backends with no per-record access control ignore them",
           "index": 1000
         },
+        {
+          "name": "addTo",
+          "displayName": "Add To",
+          "group": "General",
+          "plug": "input",
+          "type": {
+            "name": "string"
+          },
+          "isSignal": false,
+          "description": "Property names, comma-separated (e.g. points). For these, the value wired in is an amount added to what the backend holds, in one step on the backend, instead of replacing it: two devices adding at once both count. Wire the amount (1, -1, 5). The record then shows the backend's total. Leave empty to write every value as given."
+        },
         {
           "name": "idSource",
           "displayName": "Id Source",
@@ -31575,6 +31588,9 @@
         "onlyIfUnchanged": [
           "always: read by the next save — the fields the backend must still hold as this record holds them, or the save is refused"
         ],
+        "addTo": [
+          "always: read by the next Do — the fields whose value is an amount the backend adds, not a value it stores"
+        ],
         "accessControl": [
           "always: read by the next call — the access rules sent with the record"
         ],
@@ -31588,7 +31604,7 @@
         "typeName": "SetDbModelProperties",
         "summary": "Update Record: writes property values to an existing cloud database record when Do is triggered.",
         "description": "SetDbModelProperties (Update Record) updates the record identified by `modelId` in the class chosen with the `collectionName` (Class) parameter. Each class property becomes a value input; triggering `store` (Do) applies the connected inputs to the local record and saves them to the server, firing `done` (Done) on confirmation or `failure` with `error` on problems, and `completed` after either. `storeType` (Store to) can switch the node to 'Local only', which updates the in-memory record without any server call — useful for optimistic UI or scratch state. By default only the properties you actually supply are sent (`storeProperties` = 'Only specified'); 'All' sends the record's entire current data. Because the shared local record is updated, every bound Record node and live query in the app sees the change immediately.",
-        "whenToUse": "The save half of every edit form, and the way to flip a single field ('mark done') from a list row. To create a record use NewDbModelProperties; to remove one use DeleteDbModelProperties; for BYOB backends use noodl.byob.UpdateRecord.",
+        "whenToUse": "The save half of every edit form, and the way to flip a single field ('mark done') from a list row. To create a record use NewDbModelProperties; to remove one use DeleteDbModelProperties; for BYOB backends use noodl.byob.UpdateRecord. For a count, score, balance or progress, set `addTo` and wire the change, not the new total.",
         "ports": {
           "store": "Signal (displayed as Do); saves to cloud (default) or applies locally, depending on `storeType`.",
           "done": "Signal (displayed as Done); fires after the server confirms the save, or immediately after a local-only store.",
@@ -31598,21 +31614,26 @@
           "storeProperties": "Edit-only choice ('Only specified' / 'All'): whether to send just the supplied property inputs or the record's whole data. Shown while `storeType` is cloud.",
           "storeType": "Edit-only choice ('Cloud and local' / 'Local only'): whether the save reaches the server or only the in-memory record.",
           "accessControl": "Edit-only list of access rules applied with the save; each rule expands into its own Target/Read/Write inputs.",
-          "onlyIfUnchanged": "Edit-only text (displayed as Only If Unchanged): property names, comma-separated, usually `version`. The update applies only if those properties still hold the values the record had when it was read (taken before this node's inputs are applied), checked by the backend inside the UPDATE itself. If someone else wrote the record in between, nothing is written, `failure` fires, `error` says so, and the local record goes back to what it held (the backend answered 409 with reason `precondition-failed`). To retry, FETCH the record again first: retrying with the same values fails the same way. NodeGX backends only; other backends refuse it. Empty: always write."
+          "onlyIfUnchanged": "Edit-only text (displayed as Only If Unchanged): property names, comma-separated, usually `version`. The update applies only if those properties still hold the values the record had when it was read (taken before this node's inputs are applied), checked by the backend inside the UPDATE itself. If someone else wrote the record in between, nothing is written, `failure` fires, `error` says so, and the local record goes back to what it held (the backend answered 409 with reason `precondition-failed`). To retry, FETCH the record again first: retrying with the same values fails the same way. NodeGX backends only; other backends refuse it. Empty: always write.",
+          "addTo": "Edit-only text (displayed as Add To): property names, comma-separated. For these, the value wired into `prop-<name>` is an AMOUNT (1, -1, 5) the backend adds to what it holds, in one step, instead of a value that replaces it, so two devices or tabs adding at once both count. The record then shows the backend's total. The other properties are saved first, so `onlyIfUnchanged` still guards them and a refused save adds nothing. A value that is not a number fails the Do and says so. 'Local only' adds the amount to the record held in memory."
         },
         "runtimeBehavior": "Ports are runtime-determined: `collectionName` (Class) is registered as an edit-only enum of the project's classes plus _User/_Role, and each schema property of the chosen class becomes a value input `prop-<name>` typed from the schema. Access Control rules spawn `acl-<ruleId>-*` inputs like on Create Record. An authoring tool should set `collectionName` in parameters and drive the `prop-<name>` inputs it intends to change.",
         "examples": [
           "cloud-edit-record",
-          "cloud-record-crud"
+          "cloud-record-crud",
+          "cloud-shared-counter"
         ],
         "patterns": [
+          "A count, score, balance or progress: `addTo` = `points`, `prop-points` = 1 (or the change a Function works out), Button `onClick` → `store`. No script, no read of the old value: the backend adds it, and two devices pressing together both count (example `cloud-shared-counter`).",
           "DbModel2 `prop-<name>` → Text Input `startValue`, edited `text` → `prop-<name>`, Button `onClick` → `store`: prefill, edit, save.",
           "'From repeater' `idSource` inside a list row: one node updates whichever record the row represents.",
           "Two people editing one record: bump a `version` property on every save and set `onlyIfUnchanged` to `version`. The second save to land gets `failure` instead of silently replacing the first; on `failure`, fetch the record again (DbModel2) and let the person re-apply their change."
         ],
         "antiPatterns": [
           "Setting `storeProperties` to 'All' to 'be safe' — it uploads the record's entire local data and can overwrite fields other users changed; send only what the form edits.",
-          "Retrying a `failure` from `onlyIfUnchanged` by pressing Do again without fetching the record first: the precondition is taken from the record as it was read, so the retry fails the same way until the record is re-read."
+          "Retrying a `failure` from `onlyIfUnchanged` by pressing Do again without fetching the record first: the precondition is taken from the record as it was read, so the retry fails the same way until the record is re-read.",
+          "Saving a count, score, balance or progress that several tabs or devices change from the value the page holds (read it, add one in a Function, wire the new total into `prop-<name>`, Do): of two such saves the later erases the earlier. Set `addTo` to that property and wire the CHANGE (1, -1) instead: one node, no script (example `cloud-shared-counter`). For a value that is not a count, guard the whole-value save with `onlyIfUnchanged`.",
+          "Wiring two controls (a Button's Click and a Text Input's On Enter) to two DIFFERENT nodes that each lead to this Do. A press that starts a save is taken once (the control's `repeatWhileSaving` is off by default), and controls wired to the SAME node share that guard; wired to different nodes, one press of each still saves twice. Wire both into the same node (the same Function's Run, or this Do)."
         ],
         "relatedNodes": [
           "DbModel2",
@@ -50480,6 +50501,18 @@
           "description": "How the element is placed: In Layout follows its siblings, Absolute ignores them, Sticky pins to the parent edge on overflow, Fixed stays put and takes no space",
           "index": 11
         },
+        {
+          "name": "repeatWhileSaving",
+          "displayName": "Repeat While Saving",
+          "group": "General",
+          "plug": "input",
+          "type": {
+            "name": "boolean"
+          },
+          "isSignal": false,
+          "default": false,
+          "description": "Off (the default): when a click starts a save, the next click is ignored until the backend has answered, and for at least half a second, so a double press saves once. Controls wired to the same node share this. On: every click fires, for a control that saves each quick tap"
+        },
         {
           "name": "scrollIntoView",
           "displayName": "Scroll Into View",
@@ -51279,9 +51312,10 @@
         "ports": {
           "label": "The button caption string.",
           "onClick": "Signal; the click event — wire this to the action (Condition `eval`, Navigate `navigate`, Send Event `sendEvent`, …).",
-          "enabled": "Boolean level input; false renders the disabled state and suppresses `onClick`. The current value is also mirrored as an output of the same name."
+          "enabled": "Boolean level input; false renders the disabled state and suppresses `onClick`. The current value is also mirrored as an output of the same name.",
+          "repeatWhileSaving": "Boolean (displayed as Repeat While Saving), default off. Off: when a click starts a backend save (a Record node's Do, a `Noodl.Records` call made before its first await), the next `onClick` from this control, or from any control wired to the same node, is ignored until the backend has answered and for at least half a second, so a double press saves once. A press that starts no save is never held. On: every `onClick` fires (a stepper that saves each tap)."
         },
-        "runtimeBehavior": "Declared-port-groups: icon ports appear when an icon source is chosen, and each visual state (hover, pressed, disabled, focused) contributes state-scoped styling ports. The catalog list is the superset; the editor shows the subset matching current parameters.",
+        "runtimeBehavior": "Declared-port-groups: icon ports appear when an icon source is chosen, and each visual state (hover, pressed, disabled, focused) contributes state-scoped styling ports. The catalog list is the superset; the editor shows the subset matching current parameters. A `onClick` that starts a backend save is taken once: a second one is ignored while that save is waiting and for half a second after the press (`repeatWhileSaving` turns this off). There is no need to wire a busy flag back to `enabled` for a double press.",
         "examples": [
           "validate-before-submit",
           "navigate-on-click",
@@ -62677,6 +62711,18 @@
           "description": "How the element is placed: In Layout follows its siblings, Absolute ignores them, Sticky pins to the parent edge on overflow, Fixed stays put and takes no space",
           "index": 11
         },
+        {
+          "name": "repeatWhileSaving",
+          "displayName": "Repeat While Saving",
+          "group": "General",
+          "plug": "input",
+          "type": {
+            "name": "boolean"
+          },
+          "isSignal": false,
+          "default": false,
+          "description": "Off (the default): when Enter starts a save, the next Enter is ignored until the backend has answered, and for at least half a second, so a double press saves once. Controls wired to the same node share this. On: every Enter fires, for a control that saves each quick tap"
+        },
         {
           "name": "runOnChange-startValue",
           "displayName": "Value",
@@ -63650,9 +63696,10 @@
           "set": "Signal; applies the pending `startValue` to the field.",
           "clear": "Signal; empties the field.",
           "focus": "Signal; gives the field keyboard focus (`blur` removes it).",
-          "type": "Enum: text, textArea, email, number, password or url. textArea renders a multi-line editor."
+          "type": "Enum: text, textArea, email, number, password or url. textArea renders a multi-line editor.",
+          "repeatWhileSaving": "Boolean (displayed as Repeat While Saving), default off. Off: when Enter starts a backend save (a Record node's Do, a `Noodl.Records` call made before its first await), the next `onEnter` from this control, or from any control wired to the same node, is ignored until the backend has answered and for at least half a second, so a double press saves once. A press that starts no save is never held. On: every `onEnter` fires (a stepper that saves each tap)."
         },
-        "runtimeBehavior": "Declared-port-groups: `width`/`height` appear per `sizeMode`, icon ports per `useIcon`/`iconSourceType`, label styling ports when `useLabel` is true, and border/shadow ports per border-style and `boxShadowEnabled` settings. The catalog list is the superset; the editor shows the subset matching current parameters.",
+        "runtimeBehavior": "Declared-port-groups: `width`/`height` appear per `sizeMode`, icon ports per `useIcon`/`iconSourceType`, label styling ports when `useLabel` is true, and border/shadow ports per border-style and `boxShadowEnabled` settings. The catalog list is the superset; the editor shows the subset matching current parameters. An `onEnter` that starts a backend save is taken once: a second one is ignored while that save is waiting and for half a second after the press (`repeatWhileSaving` turns this off). There is no need to wire a busy flag back to `enabled` for a double press.",
         "examples": [
           "ctl-settings-form",
           "community-email-signup-validat"
@@ -74299,6 +74346,135 @@
         }
       ]
     },
+    {
+      "id": "cloud-query-own-rows",
+      "title": "Only my records: a Query Records filtered on the server by the signed-in user's id",
+      "description": "A signed-in user's own rows, with the filter on the server (a server-side filter, the backend's where clause), not a Filter Records or a Function after the fetch. The Query Records node's `visualFilter` holds one rule, {\"property\": \"owner\", \"operator\": \"equal to\", \"input\": \"owner\"}, and that `input` mints the input port `qp-owner`; the User node's `id` is wired into it, so other users' rows never leave the server. `owner` is the backend's own field: it writes the creator's id into every record a signed-in user makes, from their session, and drops any `owner` a page sends, so the page that creates a Note sends no owner field at all. Never copy the user's id into a field of your own (an ownerId, a familyId, a teamId) to say whose a record is: that is the caller's word, and anyone signed in can send another id. Both fetch-at-build boxes are off (`runOnChange-collectionName` and `runOnChange-querySettings`: false) and Do is unwired: a rule whose qp- value has not arrived yet is dropped, so a query run before the id arrives would return every row the user may read; this way the id's arrival is what runs it. Sort and limit sit beside the filter (`visualSort`, `storageEnableLimit` + `storageLimit`). When a collection keeps its default creatorOwns rule and the backend enforces it, a user's query already returns only rows they own; the filter is how you narrow further, or how you ask for one person's rows in a shared collection.",
+      "demonstrates": [
+        "DbCollection2",
+        "net.noodl.user.User",
+        "For Each",
+        "Component Inputs"
+      ],
+      "components": [
+        {
+          "name": "/My Notes",
+          "nodes": [
+            {
+              "id": "notes_root",
+              "type": "Group",
+              "label": "My notes",
+              "parameters": {
+                "flexDirection": "column"
+              },
+              "children": [
+                "notes_list"
+              ]
+            },
+            {
+              "id": "notes_list",
+              "type": "For Each",
+              "label": "One row per note of mine",
+              "parent": "notes_root",
+              "parameters": {
+                "template": "/Note Row"
+              }
+            },
+            {
+              "id": "me",
+              "type": "net.noodl.user.User",
+              "label": "Signed-in user"
+            },
+            {
+              "id": "my_notes",
+              "type": "DbCollection2",
+              "label": "Notes where owner = my id",
+              "parameters": {
+                "collectionName": "Note",
+                "visualFilter": {
+                  "combinator": "and",
+                  "rules": [
+                    {
+                      "property": "owner",
+                      "operator": "equal to",
+                      "input": "owner"
+                    }
+                  ]
+                },
+                "visualSort": [
+                  {
+                    "property": "createdAt",
+                    "order": "descending"
+                  }
+                ],
+                "storageEnableLimit": true,
+                "storageLimit": 50,
+                "runOnChange-collectionName": false,
+                "runOnChange-querySettings": false
+              }
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "me",
+              "fromProperty": "id",
+              "toId": "my_notes",
+              "toProperty": "qp-owner"
+            },
+            {
+              "fromId": "my_notes",
+              "fromProperty": "items",
+              "toId": "notes_list",
+              "toProperty": "items"
+            }
+          ]
+        },
+        {
+          "name": "/Note Row",
+          "nodes": [
+            {
+              "id": "row_root",
+              "type": "Group",
+              "label": "Note row",
+              "parameters": {
+                "flexDirection": "column",
+                "paddingTop": "var(--space-2)",
+                "paddingBottom": "var(--space-2)"
+              },
+              "children": [
+                "row_title"
+              ]
+            },
+            {
+              "id": "row_title",
+              "type": "Text",
+              "label": "Note title",
+              "parent": "row_root"
+            },
+            {
+              "id": "row_inputs",
+              "type": "Component Inputs",
+              "label": "Record properties in",
+              "ports": [
+                {
+                  "name": "title",
+                  "plug": "output",
+                  "type": "*"
+                }
+              ]
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "row_inputs",
+              "fromProperty": "title",
+              "toId": "row_title",
+              "toProperty": "text"
+            }
+          ]
+        }
+      ]
+    },
     {
       "id": "cloud-record-crud",
       "title": "Records on a REST backend: query, create, update, delete",
@@ -74983,6 +75159,424 @@
         }
       ]
     },
+    {
+      "id": "cloud-share-my-records-with-someone",
+      "title": "Invite someone to see my records: a share row, and a cloud function that trusts its owner",
+      "description": "Letting another person see your records (invite a teacher, a coach, a family member, a colleague by email). The page creates a Share record holding only the address it is shared with: it sends no field naming whose records these are, because the backend already writes that into the record's `owner`, from the signed-in caller's own session, and drops any `owner` a page sends. A cloud function answers \"what has been shared with me\": the caller's address comes from a User node inside the function (the caller's session, not the request body), the shares that name that address say WHO shared (their `owner`), and the notes returned are exactly the notes those people own (`note.owner`). Never decide it by a field the page wrote (a familyId, a teamId, an ownerId set from the User id): anyone signed in can create a Share saying any id they like, and only `owner` is the server's word. The records stay creator-owned (the default rules), so the function, which reads as the system, is the only door to another person's notes, and it answers read-only. The address match is done in the function rather than as a server filter on purpose: a filter rule whose value has not arrived yet is dropped, which would widen a system read to every share.",
+      "demonstrates": [
+        "NewDbModelProperties",
+        "noodl.cloud.request",
+        "net.noodl.user.User",
+        "DbCollection2",
+        "JavaScriptFunction",
+        "noodl.cloud.response",
+        "CloudFunction2"
+      ],
+      "components": [
+        {
+          "name": "/Share My Notes",
+          "nodes": [
+            {
+              "id": "share_root",
+              "type": "Group",
+              "label": "Share my notes",
+              "parameters": {
+                "flexDirection": "column",
+                "rowGap": "var(--space-3)"
+              },
+              "children": [
+                "share_address",
+                "share_button",
+                "share_error"
+              ]
+            },
+            {
+              "id": "share_address",
+              "type": "net.noodl.controls.textinput",
+              "label": "Their email address",
+              "parent": "share_root",
+              "parameters": {
+                "type": "email",
+                "placeholder": "name@example.com"
+              }
+            },
+            {
+              "id": "share_button",
+              "type": "net.noodl.controls.button",
+              "label": "Share with them",
+              "parent": "share_root",
+              "parameters": {
+                "label": "Share my notes"
+              }
+            },
+            {
+              "id": "share_error",
+              "type": "Text",
+              "label": "Why it did not save",
+              "parent": "share_root",
+              "parameters": {
+                "text": ""
+              }
+            },
+            {
+              "id": "share_create",
+              "type": "NewDbModelProperties",
+              "label": "A Share naming only their address (owner is the backend's)",
+              "parameters": {
+                "collectionName": "Share"
+              }
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "share_address",
+              "fromProperty": "onTextChanged",
+              "toId": "share_create",
+              "toProperty": "prop-withEmail"
+            },
+            {
+              "fromId": "share_button",
+              "fromProperty": "onClick",
+              "toId": "share_create",
+              "toProperty": "store"
+            },
+            {
+              "fromId": "share_create",
+              "fromProperty": "error",
+              "toId": "share_error",
+              "toProperty": "text"
+            }
+          ]
+        },
+        {
+          "name": "/Shared With Me",
+          "nodes": [
+            {
+              "id": "seen_root",
+              "type": "Group",
+              "label": "Notes shared with me",
+              "parameters": {
+                "flexDirection": "column",
+                "rowGap": "var(--space-2)"
+              },
+              "children": [
+                "seen_refresh",
+                "seen_list"
+              ]
+            },
+            {
+              "id": "seen_refresh",
+              "type": "net.noodl.controls.button",
+              "label": "Refresh",
+              "parent": "seen_root",
+              "parameters": {
+                "label": "Refresh"
+              }
+            },
+            {
+              "id": "seen_list",
+              "type": "For Each",
+              "label": "One row per shared note",
+              "parent": "seen_root",
+              "parameters": {
+                "template": "/Shared Note Row"
+              }
+            },
+            {
+              "id": "seen_call",
+              "type": "CloudFunction2",
+              "label": "Ask the server what was shared with me",
+              "parameters": {
+                "function": "Cloud Functions/Shared With Me"
+              }
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "seen_refresh",
+              "fromProperty": "onClick",
+              "toId": "seen_call",
+              "toProperty": "call"
+            },
+            {
+              "fromId": "seen_call",
+              "fromProperty": "out-notes",
+              "toId": "seen_list",
+              "toProperty": "items"
+            }
+          ]
+        },
+        {
+          "name": "/Shared Note Row",
+          "nodes": [
+            {
+              "id": "row_root",
+              "type": "Group",
+              "label": "Shared note row",
+              "parameters": {
+                "flexDirection": "column",
+                "paddingTop": "var(--space-2)",
+                "paddingBottom": "var(--space-2)"
+              },
+              "children": [
+                "row_title"
+              ]
+            },
+            {
+              "id": "row_title",
+              "type": "Text",
+              "label": "Note title",
+              "parent": "row_root"
+            },
+            {
+              "id": "row_inputs",
+              "type": "Component Inputs",
+              "label": "Note in",
+              "ports": [
+                {
+                  "name": "title",
+                  "plug": "output",
+                  "type": "*"
+                }
+              ]
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "row_inputs",
+              "fromProperty": "title",
+              "toId": "row_title",
+              "toProperty": "text"
+            }
+          ]
+        },
+        {
+          "name": "/#__cloud__/Cloud Functions/Shared With Me",
+          "nodes": [
+            {
+              "id": "fn_request",
+              "type": "noodl.cloud.request",
+              "label": "The caller (no parameters: nothing to forge)",
+              "parameters": {
+                "allowNoAuth": false
+              }
+            },
+            {
+              "id": "fn_me",
+              "type": "net.noodl.user.User",
+              "label": "The caller's own session"
+            },
+            {
+              "id": "fn_shares",
+              "type": "DbCollection2",
+              "label": "Every share",
+              "parameters": {
+                "collectionName": "Share",
+                "runOnChange-collectionName": false,
+                "runOnChange-querySettings": false
+              }
+            },
+            {
+              "id": "fn_notes",
+              "type": "DbCollection2",
+              "label": "Every note",
+              "parameters": {
+                "collectionName": "Note",
+                "runOnChange-collectionName": false,
+                "runOnChange-querySettings": false
+              }
+            },
+            {
+              "id": "fn_pick",
+              "type": "JavaScriptFunction",
+              "label": "The notes of the people who shared with this address",
+              "parameters": {
+                "functionScript": "if (Inputs.email === undefined || Inputs.shares === undefined || Inputs.notes === undefined) return;\nconst me = String(Inputs.email || '').trim().toLowerCase();\n// WHO shared is each share's owner: the backend wrote it from their session and nobody can change it.\n// withEmail is only what they typed. A field the page wrote (a groupId, an ownerId) proves nothing.\nconst from = new Set(\n  Inputs.shares\n    .filter((s) => me !== '' && String(s.withEmail || '').trim().toLowerCase() === me)\n    .map((s) => s.owner)\n);\nOutputs.notes = Inputs.notes\n  .filter((n) => from.has(n.owner))\n  .map((n) => ({ id: n.objectId || n.id, title: n.title || '' }));\nOutputs.answer();"
+              }
+            },
+            {
+              "id": "fn_response",
+              "type": "noodl.cloud.response",
+              "label": "What this caller may see",
+              "parameters": {
+                "params": "notes"
+              }
+            },
+            {
+              "id": "fn_fail",
+              "type": "noodl.cloud.response",
+              "label": "Tell the caller it went wrong",
+              "parameters": {
+                "status": "failure"
+              }
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "fn_request",
+              "fromProperty": "receive",
+              "toId": "fn_me",
+              "toProperty": "fetch"
+            },
+            {
+              "fromId": "fn_request",
+              "fromProperty": "receive",
+              "toId": "fn_shares",
+              "toProperty": "storageFetch"
+            },
+            {
+              "fromId": "fn_request",
+              "fromProperty": "receive",
+              "toId": "fn_notes",
+              "toProperty": "storageFetch"
+            },
+            {
+              "fromId": "fn_me",
+              "fromProperty": "email",
+              "toId": "fn_pick",
+              "toProperty": "in-email"
+            },
+            {
+              "fromId": "fn_shares",
+              "fromProperty": "items",
+              "toId": "fn_pick",
+              "toProperty": "in-shares"
+            },
+            {
+              "fromId": "fn_notes",
+              "fromProperty": "items",
+              "toId": "fn_pick",
+              "toProperty": "in-notes"
+            },
+            {
+              "fromId": "fn_pick",
+              "fromProperty": "out-notes",
+              "toId": "fn_response",
+              "toProperty": "pm-notes"
+            },
+            {
+              "fromId": "fn_pick",
+              "fromProperty": "out-answer",
+              "toId": "fn_response",
+              "toProperty": "send"
+            },
+            {
+              "fromId": "fn_pick",
+              "fromProperty": "error",
+              "toId": "fn_fail",
+              "toProperty": "errorMessage"
+            },
+            {
+              "fromId": "fn_pick",
+              "fromProperty": "failure",
+              "toId": "fn_fail",
+              "toProperty": "send"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "cloud-shared-counter",
+      "title": "A count several devices change: Update Record adds on the server, each press taken once",
+      "description": "A value two tabs or two devices change at once (a count, a score, a balance, progress) is changed on the server by the amount, never read into the page, changed, and written back whole: of two such whole saves the later erases the earlier. Here Update Record names `points` in Add To, so the 1 on `prop-points` is an amount the backend adds in one step, and the Record node bound to the same id shows the backend's total. No script, and no read of the old value. The press is taken once with no wiring: while the save a click started is waiting, and for half a second, the Button's next click is ignored (its Repeat While Saving is off). A Text Input's On Enter wired to the same Do shares that guard. To add a different amount, wire it into `prop-points` (a Function's output, -1 for a take-away button). To replace a whole value instead, use Update Record with `onlyIfUnchanged`. For a change that also needs `Noodl.Records.increment` in a script, read `recordId` once at the top so the answer belongs to the record the press was for.",
+      "demonstrates": [
+        "SetDbModelProperties",
+        "DbModel2",
+        "net.noodl.controls.button"
+      ],
+      "components": [
+        {
+          "name": "/Shared Count",
+          "nodes": [
+            {
+              "id": "root",
+              "type": "Group",
+              "label": "Count",
+              "parameters": {
+                "flexDirection": "row",
+                "alignItems": "center"
+              },
+              "children": [
+                "count_text",
+                "add_btn"
+              ]
+            },
+            {
+              "id": "count_text",
+              "type": "Text",
+              "label": "Total so far",
+              "parent": "root"
+            },
+            {
+              "id": "add_btn",
+              "type": "net.noodl.controls.button",
+              "label": "Add one",
+              "parent": "root",
+              "parameters": {
+                "label": "+1"
+              }
+            },
+            {
+              "id": "count_inputs",
+              "type": "Component Inputs",
+              "label": "Record id in",
+              "ports": [
+                {
+                  "name": "recordId",
+                  "plug": "output",
+                  "type": "string"
+                }
+              ]
+            },
+            {
+              "id": "count_record",
+              "type": "DbModel2",
+              "label": "The shared record",
+              "parameters": {
+                "collectionName": "Score"
+              }
+            },
+            {
+              "id": "add_one",
+              "type": "SetDbModelProperties",
+              "label": "Add one on the server",
+              "parameters": {
+                "collectionName": "Score",
+                "addTo": "points",
+                "prop-points": 1
+              }
+            }
+          ],
+          "connections": [
+            {
+              "fromId": "count_inputs",
+              "fromProperty": "recordId",
+              "toId": "count_record",
+              "toProperty": "modelId"
+            },
+            {
+              "fromId": "count_inputs",
+              "fromProperty": "recordId",
+              "toId": "add_one",
+              "toProperty": "modelId"
+            },
+            {
+              "fromId": "count_record",
+              "fromProperty": "prop-points",
+              "toId": "count_text",
+              "toProperty": "text"
+            },
+            {
+              "fromId": "add_btn",
+              "fromProperty": "onClick",
+              "toId": "add_one",
+              "toProperty": "store"
+            }
+          ]
+        }
+      ]
+    },
     {
       "id": "cloud-sign-a-token-with-a-stored-secret",
       "title": "Mint a signed token for another service to check",