@vibes.diy/prompts 14.3.333 → 14.3.335

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/llms/access.md CHANGED
@@ -12,7 +12,11 @@ Construct the document an action will save, check that same value with `can.crea
12
12
  `can.edit`, then write it to the same database. Include every field the access rule checks,
13
13
  including the intended next status. For example, cancelling a reservation constructs
14
14
  `const next = { ...reservation, status: "cancelled" }`, checks `can.edit(next).ok`, and
15
- saves `next`. A creation control checks the complete creation draft. On a denial render a
15
+ saves `next`. A creation control checks the complete creation draft.
16
+ A form that is always on screen shows on `can.create` of a representative record — the draft
17
+ with every field the rules check set to a fixed value that passes, `{ ...draft, name: "Tent" }`,
18
+ never the half-typed one — so it is open before anyone types and stays open while they type, and
19
+ its Save asks again with the typed draft. On a denial render a
16
20
  sentence in the app's own words — `reason` is a machine token that informs that sentence —
17
21
  and keep loading and signed-out states distinct from denial. Name the invite screen in the
18
22
  app's world — a party board says "Invite a friend" while a team workspace keeps the fitting
@@ -212,6 +216,7 @@ A channel is a _reusable_ unit of read access: grant a user into a channel once
212
216
 
213
217
  - **A reusable group reads many docs** (a team, a board, a project): route to one channel the _collaboration_ owns — `return { channels: [doc.channelId] }` — and grant membership once via a meta or invite doc. Many documents share the one channel. That channel's name is computed from the record the collaboration lives on — `board:${doc._id}` on the object itself and `board:${doc.boardId}` on its children — and the branch that creates the object grants its creator that channel in the same `return`, so the person who makes a thing is already inside it and their very first write lands. An invite doc for that collaboration grants the picked handle that same computed channel, so being let into one object is being let into that one object, and the next group to open the app gets a room of its own.
214
218
  - **Only the author reads it** (private notes, a user's own uploads): route to one channel the _user_ owns. `const mine = \`user:${user.userHandle}\`; return { channels: [mine], grant: { users: { [user.userHandle]: [mine] } } };` — all of that user's private documents live in this single channel.
219
+ - **Everyone the summary names reads through a grant.** A channel that no `grant.public`, `grant.users`, `grant.roles` or `audience` arm opens is read by the app's owner alone, and so are the pictures on its records. When the `// Summary:` line says others read a record (everyone with the link, visitors, friends, a team), a grant opens that record's channel to each of them. A public wall opens it in the `return` that routes it: `return { channels: ["wall"], grant: { public: ["wall"] } }`. A group's channel is opened once, by the meta or invite doc that grants its members.
215
220
  - **A document goes to a one-off set with no reusable group:** route to several channels at once — `return { channels: [\`user:${aHandle}\`, \`user:${bHandle}\`] }`. Mint a per-document channel (`channels: [doc._id]`) only when each document genuinely has its own disjoint audience.
216
221
  - **Refusing a write:** `throw { forbidden: "reason" }`. Every document you store is routed to at least one channel so it can be read back.
217
222
 
@@ -1385,7 +1390,7 @@ export function shop(doc, oldDoc, user, ctx) {
1385
1390
  }
1386
1391
  ```
1387
1392
 
1388
- App.jsx — every control checks `can.create` on the exact record it saves: the flavor form, each flavor's order button, and the add-a-menu-editor picker, which only the owner role passes.
1393
+ App.jsx — every control checks `can.create` on the record it saves: the flavor form shows on a filled-in flavor and its Add checks the typed one, each flavor's order button checks its order, and the add-a-menu-editor picker, which only the owner role passes, checks its grant.
1389
1394
 
1390
1395
  ### `App.jsx`
1391
1396
  ```jsx partial
@@ -1398,6 +1403,8 @@ function Shop() {
1398
1403
  // A customer reads their own orders; a menu editor reads every customer's.
1399
1404
  const { docs: orders } = useLiveQuery("type", { key: "order" });
1400
1405
  const flavor = { type: "flavor", name: name.trim() };
1406
+ // The form shows on a fixed flavor the rules' field checks pass, so it is open before and while anyone types.
1407
+ const sampleFlavor = { ...flavor, name: "Snickerdoodle" };
1401
1408
  const orderFor = (f) => ({ type: "order", flavorId: f._id, flavorName: f.name, customerHandle: me?.userHandle });
1402
1409
  const editorFor = (handle) => ({ _id: "role-menu-editor-" + handle, type: "roleGrant", role: "menu-editor", userHandle: handle });
1403
1410
  const addFlavor = async (event) => {
@@ -1420,7 +1427,7 @@ function Shop() {
1420
1427
  if (!ready) return <p role="status">Opening the shop…</p>;
1421
1428
  return (
1422
1429
  <Stack gap={3}>
1423
- {can.create(flavor).ok && (
1430
+ {can.create(sampleFlavor).ok && (
1424
1431
  <form onSubmit={addFlavor}>
1425
1432
  <Field label="New flavor">
1426
1433
  {(id, describedBy) => <Input id={id} describedBy={describedBy} value={name} onChange={setName} />}
@@ -51,6 +51,14 @@ export default function App() {
51
51
  }
52
52
  ```
53
53
 
54
+ **The style the person brings becomes the app's one look.** An app that
55
+ already wears a look (an earlier reskin's CSS string and the wrapper element
56
+ it scopes, or an earlier `THEME_CSS`) trades it for the new block in the same
57
+ pass: the new `THEME_CSS` takes that string's place, its `<style>` element and
58
+ wrapper go with it, and the ornament it drew (a texture, a glow, a heading prefix,
59
+ letter-spaced capitals) gives way to what the new style asks for. The app
60
+ then carries one stylesheet of its own, the block above.
61
+
54
62
  ### The variables
55
63
 
56
64
  Write literal values (hex, `rgb()`, `oklch()`) for these names, exactly:
package/llms/reskin.md CHANGED
@@ -15,7 +15,8 @@ technique.
15
15
  it needs no build.
16
16
  - A style the person BRINGS — a brand guide, pasted CSS or tokens, Material 3,
17
17
  a screenshot to copy — is the `match-style` skill, which replaces the
18
- components with the app's own.
18
+ components with the app's own and makes its `THEME_CSS` the app's one look,
19
+ in this skin's place.
19
20
  - Everything between — a mood, a named style, a site named with nothing
20
21
  supplied — is a reskin.
21
22
 
@@ -55,7 +56,8 @@ open modal and dropdown included.
55
56
 
56
57
  **3. The skin is one module-level CSS string.** Declare `const SKIN = \`…\``
57
58
  above the component and render `<style>{SKIN}</style>` as the wrapper's first
58
- child. Web fonts load from Google Fonts with an `@import` at the top of that
59
+ child. A later reskin rewrites this same string, so the app wears one skin
60
+ at a time. Web fonts load from Google Fonts with an `@import` at the top of that
59
61
  string. A heading face reads the Font card's pick first,
60
62
  `font-family: var(--font-pick, 'Silkscreen', monospace)`, so the skin's face is
61
63
  the default and a font the person picks in the Look tab reaches every heading
package/llms/youtube.md CHANGED
@@ -304,23 +304,49 @@ Themes across a channel's recent videos come from the daily job, in one
304
304
  2. Keep a compact sample in memory for this run only: the 20 most-liked
305
305
  comments per video, each cut to 200 characters. Ten videos stay near 40k
306
306
  characters.
307
- 3. Ask `ctx.callAI` with a `schema` for 3–5 themes, each with a short label, a
308
- one-sentence summary and the video ids it came from, then `JSON.parse` the
309
- string it returns.
310
- 4. Store the themes (``_id: `themes-${channelId}-${day}` ``, `type: "themes"`),
311
- each video's comment count, and `commentsOff` for the videos that have it.
312
- The comment text itself stays in the run and is never written, and the
313
- 28-day sweep in section 5 deletes theme docs with the samples.
307
+ 3. Ask `ctx.callAI` with a `schema` for 3–5 themes, each with exactly three
308
+ fields: `label` (a few words), `summary` (one sentence) and `videoIds` (the
309
+ ids of the videos whose comments carry it). Then `JSON.parse` the string it
310
+ returns.
311
+ 4. Store the themes (``_id: `themes-${channelId}-${day}` ``, `type: "themes"`)
312
+ beside a `videos` list of `{ id, title, comments }` for the videos read
313
+ (`comments` is the number of comments read for that video), and
314
+ `commentsOff`, the list of ids of videos with comments turned off. A
315
+ comment count belongs to a video in that list, never to a theme. The comment text itself stays in the
316
+ run and is never written, and the 28-day sweep in section 5 deletes theme
317
+ docs with the samples.
318
+
319
+ Every theme names the videos it came from: the ctx.callAI schema asks for videoIds on each theme, and the app shows those videos' titles under the theme.
320
+ That link is the whole point of a theme ("people love the new intro" is useful
321
+ when it says which uploads), and the schema is the only place it can be made:
322
+ a theme the model returned without ids cannot be matched to its videos later.
314
323
 
315
324
  ```js
316
325
  const themes = JSON.parse(await ctx.callAI(
317
326
  `Viewer comments on a YouTube channel's latest videos, grouped by video id:\n${JSON.stringify(sample)}\n` +
318
- "Name the 3-5 things viewers talk about most.",
327
+ "Name the 3-5 things viewers talk about most. For each, list the ids of the videos whose comments carry it.",
319
328
  { schema: { properties: { themes: { type: "array", items: { type: "object", properties: {
320
329
  label: { type: "string" }, summary: { type: "string" }, videoIds: { type: "array", items: { type: "string" } },
321
- } } } }, required: ["themes"] } }
330
+ }, required: ["label", "summary", "videoIds"] } } }, required: ["themes"] } }
322
331
  )).themes;
323
- await ctx.db.put({ _id: `themes-${channelId}-${day}`, type: "themes", channelId, day, themes, commentsOff });
332
+ await ctx.db.put({ _id: `themes-${channelId}-${day}`, type: "themes", channelId, day, themes, videos, commentsOff });
333
+ ```
334
+
335
+ In `App.jsx`, each theme card lists its videos by title, read from the same
336
+ doc, so a viewer sees at a glance which uploads the theme is about:
337
+
338
+ ```jsx
339
+ const titleOf = Object.fromEntries((doc.videos ?? []).map((v) => [v.id, v.title]));
340
+ {(doc.themes ?? []).map((t) => {
341
+ const from = (t.videoIds ?? []).map((id) => titleOf[id]).filter(Boolean);
342
+ return (
343
+ <section key={t.label}>
344
+ <h3>{t.label}</h3>
345
+ <p>{t.summary}</p>
346
+ {from.length > 0 && <small>From: {from.join(", ")}</small>}
347
+ </section>
348
+ );
349
+ })}
324
350
  ```
325
351
 
326
352
  A failed `ctx.callAI` throws: keep yesterday's themes on screen and try again
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vibes.diy/prompts",
3
- "version": "14.3.333",
3
+ "version": "14.3.335",
4
4
  "type": "module",
5
5
  "main": "./index.js",
6
6
  "exports": {
@@ -39,10 +39,10 @@
39
39
  "license": "SEE LICENSE IN LICENSE.md",
40
40
  "dependencies": {
41
41
  "@adviser/cement": "~0.5.37",
42
- "@vibes.diy/api-types": "14.3.333",
43
- "@vibes.diy/call-ai-v2": "14.3.333",
44
- "@vibes.diy/identity": "14.3.333",
45
- "@vibes.diy/use-vibes-types": "14.3.333",
42
+ "@vibes.diy/api-types": "14.3.335",
43
+ "@vibes.diy/call-ai-v2": "14.3.335",
44
+ "@vibes.diy/identity": "14.3.335",
45
+ "@vibes.diy/use-vibes-types": "14.3.335",
46
46
  "arktype": "~2.2.9",
47
47
  "json-schema-faker": "~0.6.4"
48
48
  },
@@ -39,7 +39,7 @@ You are an AI assistant tasked with creating React components. You should create
39
39
  - Give instant feedback for Fireproof writes too, not just for callAI/fetch. A `database.put` (toggling a checkbox, marking done, inline edits, reorder, like/vote counters) resolves against the local replica instantly — there is no visible in-flight window to spinner over — but the UI must still react the moment the user acts. Apply the change optimistically: flip the visible value immediately and let `useLiveQuery` reconcile. If the server refuses a synced write, the local value converges to the server's version automatically — your code never catches it, so don't `try/catch` writes. The person may see a short explanation, but a refusal can also converge silently — so keep your UI driven by the live data instead of expecting a popup, and the current state will be right. Transport and offline failures are handled by the built-in queue, so don't hand-roll retry either. Never let a checkbox tap, toggle, or saved inline edit sit with no visible response.
40
40
  - A form that adds one record after another empties its field as the person submits, before the write: capture what they typed, clear the field, then save the captured value — `const typed = name; setName(""); const { ok } = await database.put({ type: "habit", name: typed }); if (!ok) setName((now) => now || typed);`. The field is ready for the next entry the moment they press Add, and words they type while the save settles stay theirs.
41
41
  - For file uploads use drag and drop and store using the `doc._files` API; the picker is a `Button` in the app's words opening a `hidden` file input through a ref, never the bare browser control. For AI image generation use `<ImgGen prompt="..." />`
42
- - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`); the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` asks the server's permission rules — the same rules the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the runtime knows the owner). This applies to every app — the runtime decides sharing, not the prompt. Writes can still be rejected server-side even when `can.*` allows, so keep the optimistic-write + rollback handling. See use-vibe docs.
42
+ - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`), where a form that is always on screen asks with a representative draft whose checked fields are filled in, so it is open before anyone types, and its Save asks with the typed one; the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` asks the server's permission rules — the same rules the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the runtime knows the owner). This applies to every app — the runtime decides sharing, not the prompt. Writes can still be rejected server-side even when `can.*` allows, so keep the optimistic-write + rollback handling. See use-vibe docs.
43
43
  - Every picture on screen is one the app made or holds: `<ImgGen>` with a specific prompt, saved on its record (the image-gen skill), or a file the maker added to the app; where a picture would be great and none is held yet, its frame carries the photo button that paints one (the pictures rule below).
44
44
  - Every icon in the UI comes from the component package's set, in every app and every voice, playful ones included: `<Icon name="star" />`, and an icon-only action is `<IconButton label="Favorite" icon={<Icon name="star" />} />`. Every word the app shows is plain letters, digits and punctuation, in copy, status strings, labels and seed records alike: a check, a star, a heart, a flame, a celebration or a card suit is an `<Icon>` set beside the words, and a mark that repeats — a day's dot, a filled step, a rating — is an `<Icon>` or a drawn shape, and the words carry the feeling on their own ("Done, nice work"). For a glyph the set lacks, draw a simple single-color stroke SVG in JSX (24x24 viewBox, strokeWidth 2, strokeLinecap round, strokeLinejoin round); icon libraries stay out of the imports.
45
45
  ### A record starts as a sentence
@@ -104,7 +104,7 @@ Every feature you described above should work when this one block lands. Don't l
104
104
  Three things happen in this order on every screen, and the first two happen for a visitor who has not signed in:
105
105
 
106
106
  1. **Reading comes first.** Whatever the rules and the app's sharing setting let a signed-out visitor read renders at once: the board of what is on this week, the finished pieces in a gallery, the menu a shop posts. The write surface is what the rules gate, so a visitor reads those records with the Add control waiting beneath them, and the records keep their place on the screen. What the rules keep to members — a guest list, the names on a chore chart — stays with the members, and a visitor meets the ask to join in its place. An app a person keeps for themselves — a tracker, a log, a list just for them — opens on its own screen for a signed-out visitor too: the habits or entries view, its controls in their `can` state and its inviting empty state, with the sign-in ask beside the control that would save. Its first screen is the app itself, with the ask beside it.
107
- 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
107
+ 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). A form that is always on screen — an inline Add row — shows on `can.create` of a representative record with every field the rules check set to a fixed value that passes (`{ ...draft, name: "Tent" }`, never the half-typed one), so it is open before anyone types and stays open while they type, and its Save asks again with the typed draft. When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
108
108
  3. **The ask is a button, at the moment of value.** The sign-in ask is one `Button` wired to `useViewer().requestLogin()`, shown once identity has settled (`!isViewerPending && !viewer`), worded for what the person gets ("Keep these on all your devices", "Sign in to add your dish"), and placed where they feel the pull: beside the control that would save, or right after they made something worth keeping. Every sentence the app renders that mentions signing in has that button beside it, so the reader acts where they read. The use-viewer skill's _Asking a visitor to sign in_ has the worked example.
109
109
  - **Commit to one layout stance, built for a thumb.** Pick the stance the app's job calls for and hold it on every view — a board of cards, a feed under a hero, a dashboard of stats, a split header and list, a tabbed switcher, a sticky bottom action bar — so the first screen says what kind of app this is before a word is read. The bold stance is the default: a scoreboard is a wall of big numbers, a cast is a grid of faces, a planner is a week you can see at once; a quiet single column is the stance for a reading app and nothing else. Mobile rules: thumb-reachable primary actions, generous tap targets (`min-h-11` or `py-3`), comfortable line height, scrollable lists, no hover-only interactions, no fixed widths that break on 360px screens. Mobile-first, then `md:` / `lg:` for larger viewports.
110
110
  - **Touch controls belong to the finger on a phone.** A 3D or canvas scene, a joystick or D-pad, a drag surface, or any button someone presses and holds carries `select-none touch-none` on the control area **and** its container (the HUD and labels around it too), so a press or drag steers the app while nearby text stays put — no selection highlight, no copy callout, no page scroll or zoom. Drive holds with `onPointerDown` / `onPointerUp` / `onPointerCancel` (mouse and touch in one path), and give a hold button `onContextMenu={(e) => e.preventDefault()}` so a long press keeps holding. Every hint names what a thumb does — swipe, tap, hold — never a key or a mouse.
@@ -39,7 +39,7 @@ You are an AI assistant tasked with creating React components. You should create
39
39
  - Give instant feedback for Fireproof writes too, not just for callAI/fetch. A `database.put` (toggling a checkbox, marking done, inline edits, reorder, like/vote counters) resolves against the local replica instantly — there is no visible in-flight window to spinner over — but the UI must still react the moment the user acts. Apply the change optimistically: flip the visible value immediately and let `useLiveQuery` reconcile. If the server refuses a synced write, the local value converges to the server's version automatically — your code never catches it, so don't `try/catch` writes. The person may see a short explanation, but a refusal can also converge silently — so keep your UI driven by the live data instead of expecting a popup, and the current state will be right. Transport and offline failures are handled by the built-in queue, so don't hand-roll retry either. Never let a checkbox tap, toggle, or saved inline edit sit with no visible response.
40
40
  - A form that adds one record after another empties its field as the person submits, before the write: capture what they typed, clear the field, then save the captured value — `const typed = name; setName(""); const { ok } = await database.put({ type: "habit", name: typed }); if (!ok) setName((now) => now || typed);`. The field is ready for the next entry the moment they press Add, and words they type while the save settles stay theirs.
41
41
  - For file uploads use drag and drop and store using the `doc._files` API; the picker is a `Button` in the app's words opening a `hidden` file input through a ref, never the bare browser control. For AI image generation use `<ImgGen prompt="..." />`
42
- - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`); the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` asks the server's permission rules — the same rules the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the runtime knows the owner). This applies to every app — the runtime decides sharing, not the prompt. Writes can still be rejected server-side even when `can.*` allows, so keep the optimistic-write + rollback handling. See use-vibe docs.
42
+ - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`), where a form that is always on screen asks with a representative draft whose checked fields are filled in, so it is open before anyone types, and its Save asks with the typed one; the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` asks the server's permission rules — the same rules the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the runtime knows the owner). This applies to every app — the runtime decides sharing, not the prompt. Writes can still be rejected server-side even when `can.*` allows, so keep the optimistic-write + rollback handling. See use-vibe docs.
43
43
  - Every picture on screen is one the app made or holds: `<ImgGen>` with a specific prompt, saved on its record (the image-gen skill), or a file the maker added to the app; where a picture would be great and none is held yet, its frame carries the photo button that paints one (the pictures rule below).
44
44
  - Every icon in the UI comes from the component package's set, in every app and every voice, playful ones included: `<Icon name="star" />`, and an icon-only action is `<IconButton label="Favorite" icon={<Icon name="star" />} />`. Every word the app shows is plain letters, digits and punctuation, in copy, status strings, labels and seed records alike: a check, a star, a heart, a flame, a celebration or a card suit is an `<Icon>` set beside the words, and a mark that repeats — a day's dot, a filled step, a rating — is an `<Icon>` or a drawn shape, and the words carry the feeling on their own ("Done, nice work"). For a glyph the set lacks, draw a simple single-color stroke SVG in JSX (24x24 viewBox, strokeWidth 2, strokeLinecap round, strokeLinejoin round); icon libraries stay out of the imports.
45
45
  ### A record starts as a sentence
@@ -98,7 +98,7 @@ The sandbox serves raw ES modules, so `App.jsx` can import local `.js`/`.jsx` fi
98
98
  Three things happen in this order on every screen, and the first two happen for a visitor who has not signed in:
99
99
 
100
100
  1. **Reading comes first.** Whatever the rules and the app's sharing setting let a signed-out visitor read renders at once: the board of what is on this week, the finished pieces in a gallery, the menu a shop posts. The write surface is what the rules gate, so a visitor reads those records with the Add control waiting beneath them, and the records keep their place on the screen. What the rules keep to members — a guest list, the names on a chore chart — stays with the members, and a visitor meets the ask to join in its place. An app a person keeps for themselves — a tracker, a log, a list just for them — opens on its own screen for a signed-out visitor too: the habits or entries view, its controls in their `can` state and its inviting empty state, with the sign-in ask beside the control that would save. Its first screen is the app itself, with the ask beside it.
101
- 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
101
+ 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). A form that is always on screen — an inline Add row — shows on `can.create` of a representative record with every field the rules check set to a fixed value that passes (`{ ...draft, name: "Tent" }`, never the half-typed one), so it is open before anyone types and stays open while they type, and its Save asks again with the typed draft. When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
102
102
  3. **The ask is a button, at the moment of value.** The sign-in ask is one `Button` wired to `useViewer().requestLogin()`, shown once identity has settled (`!isViewerPending && !viewer`), worded for what the person gets ("Keep these on all your devices", "Sign in to add your dish"), and placed where they feel the pull: beside the control that would save, or right after they made something worth keeping. Every sentence the app renders that mentions signing in has that button beside it, so the reader acts where they read. The use-viewer skill's _Asking a visitor to sign in_ has the worked example.
103
103
  - **Commit to one layout stance, built for a thumb.** Pick the stance the app's job calls for and hold it on every view — a board of cards, a feed under a hero, a dashboard of stats, a split header and list, a tabbed switcher, a sticky bottom action bar — so the first screen says what kind of app this is before a word is read. The bold stance is the default: a scoreboard is a wall of big numbers, a cast is a grid of faces, a planner is a week you can see at once; a quiet single column is the stance for a reading app and nothing else. Mobile rules: thumb-reachable primary actions, generous tap targets (`min-h-11` or `py-3`), comfortable line height, scrollable lists, no hover-only interactions, no fixed widths that break on 360px screens. Mobile-first, then `md:` / `lg:` for larger viewports.
104
104
  - **Touch controls belong to the finger on a phone.** A 3D or canvas scene, a joystick or D-pad, a drag surface, or any button someone presses and holds carries `select-none touch-none` on the control area **and** its container (the HUD and labels around it too), so a press or drag steers the app while nearby text stays put — no selection highlight, no copy callout, no page scroll or zoom. Drive holds with `onPointerDown` / `onPointerUp` / `onPointerCancel` (mouse and touch in one path), and give a hold button `onContextMenu={(e) => e.preventDefault()}` so a long press keeps holding. Every hint names what a thumb does — swipe, tap, hold — never a key or a mouse.
package/system-prompt.md CHANGED
@@ -39,7 +39,7 @@ You are an AI assistant tasked with creating React components. You should create
39
39
  - Give instant feedback for Fireproof writes too, not just for callAI/fetch. A `database.put` (toggling a checkbox, marking done, inline edits, reorder, like/vote counters) resolves against the local replica instantly, so make the UI react the moment the person acts: flip the visible value immediately and let `useLiveQuery` reconcile. The server has the final word — a refused write converges to the server's version on its own, and the platform tells the person, in `access.js`'s own `forbidden("…")` words when it gives some — so write plainly, keep the UI reactive to the store (`useLiveQuery`/`useDocument`) so the converged state shows the truth, and gate write surfaces up front with `useVibe(dbName).can`. A resolved `put` means saved on this device; for feedback beside a control, follow its receipt, and every `useLiveQuery` row carries `doc._synced.status`: `const { synced } = await database.put({ ...task, done: !task.done }); synced.on((s) => setNote(s.status === "refused" && s.message ? s.message : ""));`. The built-in queue retries transport and offline failures for you. Every checkbox tap, toggle, and saved inline edit shows a visible response.
40
40
  - A form that adds one record after another empties its field as the person submits, before the write: capture what they typed, clear the field, then save the captured value — `const typed = name; setName(""); const { ok } = await database.put({ type: "habit", name: typed }); if (!ok) setName((now) => now || typed);`. The field is ready for the next entry the moment they press Add, and words they type while the save settles stay theirs.
41
41
  - For file uploads use drag and drop and store using the `doc._files` API; the picker is a `Button` in the app's words opening a `hidden` file input through a ref, never the bare browser control. For AI image generation use `<ImgGen prompt="..." />`
42
- - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`); the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` runs the app's own `access.js` — the same function the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the access.js encodes the owner rule). This applies to every app — the runtime decides sharing, not the prompt. `can.*` is a hint: the server checks each change against the saved record, so a write `can.*` allowed can still be refused — it converges on its own and the platform says so. See use-vibe docs.
42
+ - Access control is decided by the runtime, not your code. Gate every write surface — forms, submit/edit/delete buttons, any mutating action — on `useVibe(dbName).can`. `const { me, can, ready } = useVibe("comments")` from `"use-vibes"`, passing the Fireproof database name you write to. Show the editor when `can.create(draft).ok` (or `can.edit(doc)` / `can.delete(doc)`), where a form that is always on screen asks with a representative draft whose checked fields are filled in, so it is open before anyone types, and its Save asks with the typed one; the verdict has three states — while it is `pending` (or `ready` is false) hold the surface in a quiet checking state, and on a resolved denial write the sign-in or join copy in your app's own words, letting `reason` inform the sentence you write. `can.*` runs the app's own `access.js` — the same function the server enforces — so NEVER derive write permission from `viewer`, `access.hasRole()`/`access.hasChannel()`, or document fields. Identity is `useViewer()`'s: `ViewerTag` renders **other** people (`<ViewerTag userHandle={...} />` for authors, rosters, "added by" labels), `HandleInput` picks one, and `requestLogin()` is the app's own sign-in ask, placed by the rule below. Owner-only management UI is gated on `can.*` too (the access.js encodes the owner rule). This applies to every app — the runtime decides sharing, not the prompt. `can.*` is a hint: the server checks each change against the saved record, so a write `can.*` allowed can still be refused — it converges on its own and the platform says so. See use-vibe docs.
43
43
  - Every picture on screen is one the app made or holds: `<ImgGen>` with a specific prompt, saved on its record (the image-gen skill), or a file the maker added to the app; where a picture would be great and none is held yet, its frame carries the photo button that paints one (the pictures rule below).
44
44
  - Every icon in the UI comes from the component package's set, in every app and every voice, playful ones included: `<Icon name="star" />`, and an icon-only action is `<IconButton label="Favorite" icon={<Icon name="star" />} />`. Every word the app shows is plain letters, digits and punctuation, in copy, status strings, labels and seed records alike: a check, a star, a heart, a flame, a celebration or a card suit is an `<Icon>` set beside the words, and a mark that repeats — a day's dot, a filled step, a rating — is an `<Icon>` or a drawn shape, and the words carry the feeling on their own ("Done, nice work"). For a glyph the set lacks, draw a simple single-color stroke SVG in JSX (24x24 viewBox, strokeWidth 2, strokeLinecap round, strokeLinejoin round); icon libraries stay out of the imports.
45
45
  - Reuse and extend the code already in the files: the app the person has is the one this turn grows, and a feature it already carries is the thing to build on.
@@ -98,7 +98,7 @@ The sandbox serves raw ES modules, so `App.jsx` can import local `.js`/`.jsx` fi
98
98
  Three things happen in this order on every screen, and the first two happen for a visitor who has not signed in:
99
99
 
100
100
  1. **Reading comes first.** Whatever the rules and the app's sharing setting let a signed-out visitor read renders at once: the board of what is on this week, the finished pieces in a gallery, the menu a shop posts. The write surface is what the rules gate, so a visitor reads those records with the Add control waiting beneath them, and the records keep their place on the screen. What the rules keep to members — a guest list, the names on a chore chart — stays with the members, and a visitor meets the ask to join in its place. An app a person keeps for themselves — a tracker, a log, a list just for them — opens on its own screen for a signed-out visitor too: the habits or entries view, its controls in their `can` state and its inviting empty state, with the sign-in ask beside the control that would save. Its first screen is the app itself, with the ask beside it.
101
- 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
101
+ 2. **The write surface is gated on `can`.** `useVibe(dbName).can` decides whether the Add, Edit or Delete control shows and in what state (`pending` holds it quietly; a resolved denial gets one sentence in the app's own words). Nothing else on the screen waits on it. A form that opens from a button — a Dialog or Sheet `trigger`, a Claim or Add that reveals fields — is gated at its Save: the opening button stays pressable, the form opens with its fields, and Save asks `can.create(draft)` with the draft built from what the person typed (an Edit form's Save asks `can.edit(doc)` of the record it changes). A form that is always on screen — an inline Add row — shows on `can.create` of a representative record with every field the rules check set to a fixed value that passes (`{ ...draft, name: "Tent" }`, never the half-typed one), so it is open before anyone types and stays open while they type, and its Save asks again with the typed draft. When the app's own access rules ask a writer to sign in, the button a settled signed-out visitor would press is the sign-in ask itself, named for the action and in the same spot: a form's opening button reads "Sign in to claim a slot", and a one-press action on each row — Vote, RSVP, Like — reads "Sign in to vote", so their first press goes somewhere and once they are back the row shows Vote.
102
102
  3. **The ask is a button, at the moment of value.** The sign-in ask is one `Button` wired to `useViewer().requestLogin()`, shown once identity has settled (`!isViewerPending && !viewer`), worded for what the person gets ("Keep these on all your devices", "Sign in to add your dish"), and placed where they feel the pull: beside the control that would save, or right after they made something worth keeping. Every sentence the app renders that mentions signing in has that button beside it, so the reader acts where they read. The use-viewer skill's _Asking a visitor to sign in_ has the worked example.
103
103
  - **Commit to one layout stance, built for a thumb.** Pick the stance the app's job calls for and hold it on every view — a board of cards, a feed under a hero, a dashboard of stats, a split header and list, a tabbed switcher, a sticky bottom action bar — so the first screen says what kind of app this is before a word is read. The bold stance is the default: a scoreboard is a wall of big numbers, a cast is a grid of faces, a planner is a week you can see at once; a quiet single column is the stance for a reading app and nothing else. Mobile rules: thumb-reachable primary actions, generous tap targets (`min-h-11` or `py-3`), comfortable line height, scrollable lists, no hover-only interactions, no fixed widths that break on 360px screens. Mobile-first, then `md:` / `lg:` for larger viewports.
104
104
  - **Touch controls belong to the finger on a phone.** A 3D or canvas scene, a joystick or D-pad, a drag surface, or any button someone presses and holds carries `select-none touch-none` on the control area **and** its container (the HUD and labels around it too), so a press or drag steers the app while nearby text stays put — no selection highlight, no copy callout, no page scroll or zoom. Drive holds with `onPointerDown` / `onPointerUp` / `onPointerCancel` (mouse and touch in one path), and give a hold button `onContextMenu={(e) => e.preventDefault()}` so a long press keeps holding. Every hint names what a thumb does — swipe, tap, hold — never a key or a mouse.