makersclaw 0.5.2 → 0.7.0

package/registry/blocks/product-grid/README.md

@@ -84,37 +84,37 @@ quantities by `key`.
 ## Example
 
 ```jsx
-// surfaces/shop.jsx — server: load, hand over
-import { loadRows } from "../lib/data";
+// surfaces/shop.jsx — client: read, hand over
+"use client";
+import { useRows } from "../lib/data";
 import Shop from "../components/Shop";
 
-export default async function ShopSurface() {
-  const { rows, error } = await loadRows({ source: "public.products", orderBy: "created_at desc" });
-  return <Shop products={rows} error={error} />;
+export default function ShopSurface() {
+  const { rows, error, loading, reload } = useRows({ source: "products", orderBy: "created_at desc" });
+  return <Shop products={rows} loading={loading} error={error} onRetry={reload} />;
 }
 ```
 
 ```jsx
 // components/Shop.jsx — client: the grid and the cart write
 "use client";
-import { useRouter } from "next/navigation";
 import { insertRow } from "../lib/actions";
 import { ProductGrid } from "./blocks/product-grid";
 
-export default function Shop({ products, error }) {
-  const router = useRouter();
+export default function Shop({ products, loading, error, onRetry }) {
   return (
     <ProductGrid
       products={products}
+      loading={loading}
       error={error}
-      onRetry={() => router.refresh()}
+      onRetry={onRetry}
       filters={[
         { key: "category", label: "Category", options: ["Shirts", "Sweaters", "Jackets"] },
         { key: "size", label: "Size", options: ["S", "M", "L", "XL"] },
       ]}
       sort
       onAddToCart={(line) =>
-        insertRow({ source: "public.cart_items", values: { product_id: line.id, line_key: line.key, quantity: 1 }, detail: line.name })
+        insertRow({ source: "cart_items", values: { product_id: line.id, line_key: line.key, quantity: 1 }, detail: line.name })
       }
       label="Shop"
     />
@@ -122,6 +122,8 @@ export default function Shop({ products, error }) {
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 Collection tiles, and a lead picture beside four products:
 
 ```jsx

package/registry/blocks/record-form/README.md

@@ -93,7 +93,7 @@ Validation, first broken rule wins, one message per field:
   error?, errors? }` where `errors` is `{ fieldName: "message" }` — each
   shows under its field and the first one is focused. A throw counts as
   failed. In a Makersclaw app it is one line over `updateRow`:
-  `onSave={(v) => updateRow({ source: "public.products", id: p.id, patch: v })}`.
+  `onSave={(v) => updateRow({ source: "products", id: p.id, patch: v })}`.
 - `container` — `"card"` (default: a Card with `title` and `description`)
   · `"page"` (no box: a page heading, then the sections) · `"dialog"` (a
   centred Sheet; on a phone a bottom sheet). A dialog needs `open` and
@@ -127,10 +127,12 @@ Validation, first broken rule wins, one message per field:
 ## Example
 
 ```jsx
-// components/ProductEditor.jsx — client
+// surfaces/product.jsx — client: one product, edited
 "use client";
-import { updateRow, deleteRow } from "../lib/actions";
-import { RecordForm } from "./blocks/record-form";
+import { useRouter, useSearchParams } from "next/navigation";
+import { useRow } from "../lib/data";
+import { deleteRow, updateRow } from "../lib/actions";
+import { RecordForm } from "../components/blocks/record-form";
 
 const FIELDS = [
   { name: "name", label: "Product name", required: true },
@@ -140,20 +142,35 @@ const FIELDS = [
   { name: "details", label: "Details", type: "textarea" },
 ];
 
-export default function ProductEditor({ product }) {
+export default function ProductEditor() {
+  const router = useRouter();
+  const id = useSearchParams().get("row");
+  const { row: product, loading, error, reload } = useRow({ source: "products", id });
   return (
     <RecordForm
       title="Edit product"
       fields={FIELDS}
-      values={product}
-      onSave={(values) => updateRow({ source: "public.products", id: product.id, patch: values })}
-      onDelete={() => deleteRow({ source: "public.products", id: product.id })}
+      values={product ?? {}}
+      loading={loading}
+      error={error}
+      onRetry={reload}
+      onSave={(values) => updateRow({ source: "products", id, patch: values })}
+      onDelete={async () => {
+        const res = await deleteRow({ source: "products", id });
+        if (res.ok) router.push("/s/products");
+        return res;
+      }}
       deleteLabel="Remove product"
     />
   );
 }
 ```
 
+After a save the row is read again and comes back as `values`: the
+form starts over from what it just saved.
+
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 In a dialog, from a list:
 
 ```jsx
@@ -170,7 +187,7 @@ const [editing, setEditing] = useState(null);
     { title: "Access", fields: [{ name: "role", label: "Role", type: "radio", options: ["Admin", "Member", "Viewer"] }] },
   ]}
   onSave={async (values) => {
-    const res = await updateRow({ source: "public.members", id: editing.id, patch: values });
+    const res = await updateRow({ source: "members", id: editing.id, patch: values });
     return res.ok ? res : { ok: false, errors: res.error?.includes("email") ? { email: "Already in use." } : undefined, error: res.error };
   }}
 />

package/registry/blocks/record-notes/README.md

@@ -73,45 +73,57 @@ One table, a row per note: `record_id`, `author_id`, `body jsonb`,
 ## Example
 
 ```jsx
-// components/DealNotes.jsx — client
+// surfaces/deal-notes.jsx — client: one deal's notes
 "use client";
-import { useState } from "react";
+import { useSearchParams } from "next/navigation";
+import { useArtifact } from "../lib/hooks";
+import { useRows, whenLanded } from "../lib/data";
 import { deleteRow, insertRow, updateRow } from "../lib/actions";
-import { RecordNotes } from "./blocks/record-notes";
-import { docToText } from "./blocks/doc-editor";
+import { RecordNotes } from "../components/blocks/record-notes";
+import { docToText } from "../components/blocks/doc-editor";
 
-export default function DealNotes({ deal, me, team, initial }) {
-  const [notes, setNotes] = useState(initial);
+const source = "deal_notes";
+
+// A write answers once the notes are read again, so the list never shows
+// the notes from before it.
+async function landed(res) {
+  if (res.ok) await whenLanded();
+  return res;
+}
+
+export default function DealNotes() {
+  const dealId = useSearchParams().get("row");
+  const { user } = useArtifact(); // the member signed in: { id, email }
+  const { rows, loading } = useRows({ source, filter: { deal_id: dealId }, orderBy: "created_at desc" });
+  const { rows: team } = useRows({ source: "people", orderBy: "name asc" });
+  const me = { id: user?.email, name: user?.email ?? "You" };
+  // created_by: a before-insert trigger sets it from the member, never the page (the app's README §5)
+  const notes = rows.map((n) => ({
+    id: n.id,
+    author: { id: n.created_by, name: n.created_by },
+    body: n.body,
+    createdAt: n.created_at,
+    updatedAt: n.updated_at,
+  }));
   const findPeople = async (q) =>
     team.filter((p) => p.name.toLowerCase().includes(q.toLowerCase())).map((p) => ({ id: p.id, label: p.name }));
 
-  async function add(doc) {
-    const res = await insertRow({
-      source: "public.deal_notes",
-      values: { deal_id: deal.id, author_id: me.id, body: doc, body_text: docToText(doc) },
-    });
-    if (!res.ok) return res;
-    setNotes((n) => [{ id: res.id, author: me, body: doc, createdAt: new Date() }, ...n]);
-    return { ok: true };
-  }
-
-  async function edit(note, doc) {
-    const updatedAt = new Date();
-    const res = await updateRow({ source: "public.deal_notes", id: note.id, patch: { body: doc, body_text: docToText(doc), updated_at: updatedAt } });
-    if (res.ok) setNotes((n) => n.map((x) => (x.id === note.id ? { ...x, body: doc, updatedAt } : x)));
-    return res;
-  }
-
-  async function remove(note) {
-    const res = await deleteRow({ source: "public.deal_notes", id: note.id });
-    if (res.ok) setNotes((n) => n.filter((x) => x.id !== note.id));
-    return res;
-  }
-
-  return <RecordNotes notes={notes} me={me} onAdd={add} onEdit={edit} onDelete={remove} mentions={findPeople} />;
+  if (loading) return null;
+  return (
+    <RecordNotes
+      notes={notes}
+      me={me}
+      onAdd={(doc) => insertRow({ source, values: { deal_id: dealId, body: doc, body_text: docToText(doc) } }).then(landed)}
+      onEdit={(note, doc) => updateRow({ source, id: note.id, patch: { body: doc, body_text: docToText(doc), updated_at: new Date() } }).then(landed)}
+      onDelete={(note) => deleteRow({ source, id: note.id }).then(landed)}
+      mentions={findPeople}
+    />
+  );
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 Beside the form, on a record page:
 
 ```jsx

package/registry/blocks/search-dialog/README.md

@@ -70,15 +70,29 @@ Both components take these.
 ## Example
 
 ```jsx
+// components/GlobalSearch.jsx — client: search as the member types
 "use client";
-import { useRouter } from "next/navigation";
 import { useState } from "react";
-import { Button } from "../components/ui";
-import { SearchDialog } from "../components/blocks/search-dialog";
+import { useRouter } from "next/navigation";
+import { loadRows, useRows } from "../lib/data";
+import { Button } from "./ui";
+import { SearchDialog } from "./blocks/search-dialog";
+
+const asResult = (d) => ({ id: d.id, kind: "deal", title: d.name, snippet: d.stage });
 
-export function GlobalSearch({ recent, search }) {
+export default function GlobalSearch() {
   const router = useRouter();
   const [open, setOpen] = useState(false);
+  const { rows: recent } = useRows({ source: "deals", orderBy: "updated_at desc", limit: 5 });
+
+  // The app's own table: names that start with what was typed, case ignored.
+  // The dialog aborts the older query through `signal`.
+  async function search(q, { signal }) {
+    const { rows, error } = await loadRows({ source: "deals", filter: { name: { prefix: q } }, orderBy: "name asc", limit: 20, signal });
+    if (error) throw new Error(error); // "Search failed"; an aborted read's answer is ignored
+    return rows.map(asResult);
+  }
+
   return (
     <>
       <Button icon="search" onClick={() => setOpen(true)}>Search</Button>
@@ -86,15 +100,32 @@ export function GlobalSearch({ recent, search }) {
         open={open}
         onOpenChange={setOpen}
         hotkey="k"
-        sections={[{ heading: "Recent", results: recent }]}
-        onSearch={(q) => search(q)}   // a server action returning results
-        onSelect={(r) => router.push(`/${r.kind}s/${r.id}`)}
+        sections={[{ heading: "Recent", results: recent.map(asResult) }]}
+        onSearch={search}
+        onSelect={(r) => router.push(`/s/deals?row=${r.id}`)}
       />
     </>
   );
 }
 ```
 
+The company's records, through the brain (`lib/brain.js`), with
+`meaning: false` while a person types: keywords only, nothing embedded
+or charged. A search by meaning is charged per call; keep it for a
+search page or an Enter.
+
+```jsx
+import { searchBrain } from "../lib/brain";
+
+async function search(q, { signal }) {
+  const { results, error } = await searchBrain({ q, meaning: false, limit: 20, signal });
+  if (error) throw new Error(error);
+  return results.map(({ record, snippet }) => ({ id: record.id, kind: record.kind, title: record.label, snippet }));
+}
+```
+
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 ## What it will not do
 
 - Index anything. It searches the list you give it, or asks your server.

package/registry/blocks/settings-list/README.md

@@ -71,7 +71,7 @@ The matrix (`variant="matrix"`) rows are events:
   false, error }`; a throw counts as failed. Without it, switches and
   selects are shown and cannot be changed. In a Makersclaw app it is one
   line over `saveSetting` (lib/actions.js):
-  `onChange={(row, value) => saveSetting({ source: "public.settings", key: row.key, value })}`.
+  `onChange={(row, value) => saveSetting({ source: "settings", key: row.key, value })}`.
 - `onAction(row, actionKey)` — run a button, a menu item or a remove.
   Return `{ ok }` like `onChange`. Remove the row from `rows` on success
   when it is gone (a signed-out device).
@@ -95,31 +95,43 @@ The matrix (`variant="matrix"`) rows are events:
 ## Example
 
 ```jsx
-// components/Preferences.jsx — client
+// surfaces/preferences.jsx — client: settings, read and saved
 "use client";
+import { useMemo } from "react";
+import { useRows } from "../lib/data";
 import { saveSetting } from "../lib/actions";
-import { SettingsList } from "./blocks/settings-list";
-
-export default function Preferences({ settings }) {
-  const rows = [
-    { key: "digest", icon: "mail", label: "Weekly digest", description: "Every Monday at 8:00.", control: { type: "switch", value: settings.digest === true } },
-    {
-      key: "currency",
-      icon: "dollar",
-      label: "Currency",
-      control: { type: "select", value: settings.currency ?? "usd", options: [{ value: "usd", label: "US dollar" }, { value: "eur", label: "Euro" }] },
-    },
-  ];
+import { SettingsList } from "../components/blocks/settings-list";
+
+export default function Preferences() {
+  const { rows: saved, loading, error, reload } = useRows({ source: "settings" });
+  // Built once per read: until `rows` changes, a row shows the value it saved.
+  const rows = useMemo(() => {
+    const settings = Object.fromEntries(saved.map((s) => [s.key, s.value]));
+    return [
+      { key: "digest", icon: "mail", label: "Weekly digest", description: "Every Monday at 8:00.", control: { type: "switch", value: settings.digest === true } },
+      {
+        key: "currency",
+        icon: "dollar",
+        label: "Currency",
+        control: { type: "select", value: settings.currency ?? "usd", options: [{ value: "usd", label: "US dollar" }, { value: "eur", label: "Euro" }] },
+      },
+    ];
+  }, [saved]);
   return (
     <SettingsList
       title="Preferences"
       rows={rows}
-      onChange={(row, value) => saveSetting({ source: "public.settings", key: row.key, value })}
+      loading={loading}
+      error={error}
+      onRetry={reload}
+      onChange={(row, value) => saveSetting({ source: "settings", key: row.key, value })}
     />
   );
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 Notifications per channel:
 
 ```jsx
@@ -131,7 +143,7 @@ Notifications per channel:
     { key: "mentions", group: "Conversations", label: "Mentions", values: { email: true, push: true } },
     { key: "signin", group: "Security", label: "New sign-in", values: { email: true, push: false }, locked: ["email"] },
   ]}
-  onChange={(row, on, channel) => saveSetting({ mode: "json", source: "public.members", column: "notify", id: me.id, key: `${row.key}.${channel}`, value: on })}
+  onChange={(row, on, channel) => saveSetting({ mode: "json", source: "members", column: "notify", id: me.id, key: `${row.key}.${channel}`, value: on })}
 />
 ```
 
@@ -149,7 +161,7 @@ Signed-in devices, each with sign-out:
     meta: [{ icon: "globe", text: s.place }, { icon: "clock", text: s.lastSeen }],
     control: s.current ? null : { type: "remove", label: `Sign out ${s.device}`, confirm: { title: "Sign out this device?", confirmLabel: "Sign out" } },
   }))}
-  onAction={(row) => deleteRow({ source: "public.sessions", id: row.key })}
+  onAction={(row) => deleteRow({ source: "sessions", id: row.key })}
 />
 ```
 

package/registry/blocks/setup-checklist/README.md

@@ -75,16 +75,15 @@ With no steps it says "Nothing to set up".
 ## Example
 
 ```jsx
-// surfaces/home.jsx — server: work out what is done
-import { loadRows } from "../lib/data";
+// surfaces/home.jsx — client: work out what is done
+"use client";
+import { useCount } from "../lib/data";
 import GettingStarted from "../components/GettingStarted";
 
-export default async function Home() {
-  const [{ rows: members }, { rows: deals }] = await Promise.all([
-    loadRows({ source: "public.members" }),
-    loadRows({ source: "public.deals", limit: 1 }),
-  ]);
-  return <GettingStarted invited={members.length > 1} hasDeal={deals.length > 0} />;
+export default function Home() {
+  const members = useCount({ source: "members" });
+  const deals = useCount({ source: "deals" });
+  return <GettingStarted loading={members.loading || deals.loading} invited={members.count > 1} hasDeal={deals.count > 0} />;
 }
 ```
 
@@ -93,10 +92,11 @@ export default async function Home() {
 "use client";
 import { SetupChecklist } from "./blocks/setup-checklist";
 
-export default function GettingStarted({ invited, hasDeal, onHide }) {
+export default function GettingStarted({ loading, invited, hasDeal, onHide }) {
   return (
     <SetupChecklist
       title="Get started"
+      loading={loading}
       steps={[
         { key: "invite", title: "Invite your team", description: "Bring in the people who own accounts.", actionLabel: "Invite", href: "/team", done: invited },
         { key: "deal", title: "Add your first deal", description: "One deal is enough to see the pipeline work.", actionLabel: "Add a deal", href: "/deals?new=1", done: hasDeal },
@@ -107,6 +107,8 @@ export default function GettingStarted({ invited, hasDeal, onHide }) {
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 In order, with buttons that do the work in place:
 
 ```jsx
@@ -115,11 +117,7 @@ In order, with buttons that do the work in place:
   sequential
   title="Quick start"
   steps={steps}
-  onAction={async (step) => {
-    const res = await runSetupStep(step.key); // your server action, { ok, error }
-    if (res.ok) router.refresh(); // the step comes back done
-    return res;
-  }}
+  onAction={(step) => runAction({ name: "run_setup_step", args: { key: step.key } })} // an action named in references/actions.md; its ok re-reads every hook, so the step comes back done
 />
 ```
 

package/registry/blocks/share-dialog/README.md

@@ -89,7 +89,7 @@ export function ShareProject({ project, members, invite, setRole, remove }) {
         onClose={() => setOpen(false)}
         title={`Share “${project.name}”`}
         people={members}
-        onInvite={(emails, role) => invite(project.id, emails, role)}   // server actions returning { ok, error }
+        onInvite={(emails, role) => invite(project.id, emails, role)}   // each answers { ok } or { ok: false, error }, as lib/actions' writes do
         onRoleChange={(person, role) => setRole(project.id, person.id, role)}
         onRemove={(person) => remove(project.id, person.id)}
         link={`https://app.example.com/p/${project.id}`}

package/registry/blocks/signature-pad/README.md

@@ -109,25 +109,36 @@ under the paper says so. Undo and clear are buttons with names.
 Accepting a quote in a Makersclaw app.
 
 ```jsx
+// surfaces/quote.jsx — client: one quote, accepted and signed
 "use client";
+import { useSearchParams } from "next/navigation";
+import { useArtifact } from "../lib/hooks";
+import { useRow } from "../lib/data";
 import { updateRow } from "../lib/actions";
-import { SignaturePad } from "./blocks/signature-pad";
+import { SignaturePad } from "../components/blocks/signature-pad";
 
-export default function AcceptQuote({ quote, me }) {
+export default function AcceptQuote() {
+  const id = useSearchParams().get("row");
+  const { user } = useArtifact(); // the member signed in: { id, email }
+  const { row: quote, loading } = useRow({ source: "quotes", id });
+  if (loading || !quote) return null;
   return (
     <SignaturePad
-      signer={me.name}
+      signer={user?.email}
       value={quote.signature ?? undefined}
       submitLabel="Accept and sign"
       note="Signing records that you accept this quote. It is not a certified e-signature."
+      // signed_by: a before-update trigger sets it from the member, never the page (the app's README §5)
       onSubmit={(signature) =>
-        updateRow({ source: "public.quotes", id: quote.id, patch: { status: "accepted", signature, signed_by: me.email }, detail: "accepted" })
+        updateRow({ source: "quotes", id: quote.id, patch: { status: "accepted", signature }, detail: "accepted" })
       }
     />
   );
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 ## What it will not do
 
 - Verify who signed, send the document for signature, or keep an audit

package/registry/blocks/sketch-canvas/README.md

@@ -215,22 +215,31 @@ on a partial one:
 A whiteboard that saves itself:
 
 ```jsx
+// surfaces/sketch.jsx — client: one board, saved as it is drawn
 "use client";
-import { SketchCanvas } from "./blocks/sketch-canvas";
+import { useSearchParams } from "next/navigation";
+import { useRow } from "../lib/data";
 import { updateRow } from "../lib/actions";
+import { SketchCanvas } from "../components/blocks/sketch-canvas";
 
-export default function Board({ board }) {
+export default function Board() {
+  const id = useSearchParams().get("row");
+  const { row: board, loading } = useRow({ source: "boards", id });
+  if (loading || !board) return null;
   return (
     <SketchCanvas
+      key={board.id}
       label={board.title}
-      defaultValue={board.sketch}                       // jsonb, may be null
-      onSave={(sketch) => updateRow({ source: "public.boards", id: board.id, patch: { sketch } })}
+      defaultValue={board.sketch}                       // jsonb, may be null; read once per board
+      onSave={(sketch) => updateRow({ source: "boards", id: board.id, patch: { sketch } })}
       className="h-dvh rounded-none border-0"
     />
   );
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 Marking up a screenshot, with numbered notes:
 
 ```jsx

package/registry/blocks/sketch-canvas/sketch-canvas.jsx

@@ -2,7 +2,7 @@
 
 // SketchCanvas — Excalidraw, in the workspace theme, behind one set of props.
 //
-// Client only, one static bundle. Excalidraw needs the DOM, and the app's
+// Client only, one bundle. Excalidraw needs the DOM, and the app's
 // check refuses import() (so no next/dynamic): the modules load with the
 // page (on the server too — see excalidraw.js and ssr-shim.js for how that
 // is made safe), and the canvas itself mounts only after the first effect

package/registry/blocks/sketch-canvas/ssr-shim.js

@@ -5,9 +5,9 @@
 // devicePixelRatio, document.createElement("img"), an Element.prototype
 // polyfill), so evaluating it on the server throws "window is not defined"
 // and the page fails to render — even though the component itself only
-// ever renders in the browser (the mount guard). The app is one static
-// bundle (no import(), no next/dynamic), so the module cannot be kept off
-// the server; instead it is let load against these stand-ins.
+// ever renders in the browser (the mount guard). The app is one bundle
+// (no import(), no next/dynamic), so the module cannot be kept off the
+// server; instead it is let load against these stand-ins.
 //
 // The stand-ins live only for that load: excalidraw.js imports this file,
 // then @excalidraw/excalidraw, then ssr-shim-end.js, which removes them —

package/registry/blocks/spreadsheet/README.md

@@ -241,10 +241,12 @@ Shift+F10 the row menu.
 ## Example
 
 ```jsx
+// surfaces/deals.jsx — client: the deals as a grid
 "use client";
 import { useState } from "react";
-import { updateRow, insertRow, deleteRow } from "../lib/actions";
-import { Spreadsheet } from "./blocks/spreadsheet";
+import { useRows } from "../lib/data";
+import { deleteRow, insertRow, updateRow } from "../lib/actions";
+import { Spreadsheet } from "../components/blocks/spreadsheet";
 
 const COLUMNS = [
   { key: "name", name: "Name", type: "text", required: true },
@@ -253,20 +255,25 @@ const COLUMNS = [
   { key: "close", name: "Close date", type: "date" },
 ];
 
-export default function Deals({ deals, team }) {
+export default function Deals() {
+  const deals = useRows({ source: "deals", orderBy: "created_at asc" });
+  const team = useRows({ source: "people", orderBy: "name asc" });
   const [view, setView] = useState({ sort: [{ key: "amount", dir: "desc" }] });
+  // Each change below is one write, and the door takes 300 a minute: a
+  // paste larger than that belongs in one action (runAction).
   return (
     <Spreadsheet
       label="Deals"
       noun="deal"
-      rows={deals}
+      rows={deals.rows}
+      loading={deals.loading}
       columns={COLUMNS}
-      people={team}
+      people={team.rows}
       view={view}
       onViewChange={setView}
       onChange={async (changes) => {
         for (const c of changes) {
-          const r = await updateRow({ source: "public.deals", id: c.rowId, patch: { [c.key]: c.value } });
+          const r = await updateRow({ source: "deals", id: c.rowId, patch: { [c.key]: c.value } });
           if (!r.ok) return r;
         }
         return { ok: true };
@@ -274,7 +281,7 @@ export default function Deals({ deals, team }) {
       onAddRows={async (rows) => {
         const made = [];
         for (const { id, ...values } of rows) {
-          const r = await insertRow({ source: "public.deals", values: { stage: "lead", ...values } });
+          const r = await insertRow({ source: "deals", values: { stage: "lead", ...values } });
           if (!r.ok) return r;
           made.push({ id: r.id });   // the database's id replaces the one the grid made up
         }
@@ -282,7 +289,7 @@ export default function Deals({ deals, team }) {
       }}
       onDeleteRows={async (ids) => {
         for (const id of ids) {
-          const r = await deleteRow({ source: "public.deals", id });
+          const r = await deleteRow({ source: "deals", id });
           if (!r.ok) return r;
         }
         return { ok: true };
@@ -292,6 +299,8 @@ export default function Deals({ deals, team }) {
 }
 ```
 
+In a server-mode app the same calls are `loadRows` in a server surface and the Server Actions of `lib/actions`.
+
 ## What it will not do
 
 - No formulas. A value is what was typed; a derived column is computed by