@vibes.diy/prompts 8.1.1 → 8.2.0

package/llms/fireproof.md

@@ -404,375 +404,9 @@ const { useLiveQuery, database } = useFireproof("favorites", {
 
 Notes: use it only where anonymous-first state makes sense (favorites, drafts, a scratch list). A returning signed-out visitor is automatically steered to sign in rather than starting a fresh throwaway local session. Migration keeps local data intact if it fails, so nothing is lost.
 
-## Reading Resolved Grants (`access`)
+## Reading Resolved Grants and worked access examples
 
-`useFireproof()` returns an `access` property — the viewer's resolved roles and channels for that database, computed server-side from the access function's `members` and `grant` declarations. Use `access.roles` (ReadonlySet), `access.channels` (ReadonlySet), `access.hasRole(name)`, and `access.hasChannel(name)`. Use these to reflect roles/channels in the UI; gate writes with `useVibe(dbName).can`.
-
-For databases without an access function export, `access` has empty roles and channels. No separate pending flag — grants arrive alongside the viewer identity, so `useViewer().isViewerPending` covers both.
-
-App.jsx
-
-```jsx
-<<<<<<< SEARCH
-import { useFireproof } from "use-fireproof";
-=======
-import { useFireproof } from "use-fireproof";
-import { useVibe } from "use-vibes";
->>>>>>> REPLACE
-```
-
-App.jsx
-
-```jsx
-<<<<<<< SEARCH
-  const { useLiveQuery, database } = useFireproof("announcements", {
-    acl: { write: ["members"], delete: ["editors"] },
-  });
-=======
-  const { database, useLiveQuery, access } = useFireproof("comments");
-  const { can, me } = useVibe("comments");
->>>>>>> REPLACE
-```
-
-App.jsx
-
-```jsx
-<<<<<<< SEARCH
-      <h3>Recent Documents</h3>
-      <ul>
-        {docs.map((doc) => (
-          <li key={doc._id}>
-            {doc.text}
-            <button onClick={() => database.put({ ...doc, favorite: !doc.favorite })}>
-              {doc.favorite ? "★" : "☆"}
-            </button>
-          </li>
-        ))}
-      </ul>
-=======
-      {/* gate writes with useVibe().can, not access.* — and gate the SAME db you write to */}
-      {can.create({ type: "comment", authorHandle: me?.userHandle }).ok && <CommentForm database={database} />}
-      {access.hasRole("moderator") && <ModToolsBadge />}
-      {access.hasChannel("announcements") && <Announcements />}
->>>>>>> REPLACE
-```
-
-The AI agent writes the access function (so it knows the role names) and writes the UI (so it knows which roles gate which components). The `access` object is the bridge — it lets the UI reflect server-enforced permissions without duplicating the logic.
-
-The access function is the single source of truth for permissions. Gate write surfaces with `useVibe(dbName).can`, which runs this same access function. The `access` object (`access.hasRole(name)`, `access.hasChannel(name)`) reflects the viewer's resolved roles/channels for DISPLAY — role badges, showing/hiding read-only sections — not as the write gate.
-
-`access.hasChannel()` covers every grant path — public channels, restricted channels, role-expanded channels. The access function decides who gets access and how; the UI uses `access.hasChannel(name)` to reflect membership for display.
-
-### Complete example: Team announcements with channels
-
-This example shows the full round-trip — access.js declares channels and grants; App.jsx reads them back via `access`. Key details:
-
-- **Owner bootstrap:** the vibe owner is auto-seeded into the reserved `owner` role, so gate management operations (channel setup, role grants, moderation) on `ctx.requireRole("owner")` — **never on a display flag** (the UI gates on `can.*`). No bootstrap problem — the seed means the owner can manage without a prior grant. Default content, though, should be author-owned (anyone signed-in creates and edits their own); reserve owner-gating for shared admin surfaces.
-- **Channel identity:** Channel docs use `_id: "ch:" + name` so names are unique. The `_id` is the channel identifier everywhere — in `channels`, `grant`, and `ctx.requireAccess()`.
-- **Channel grant:** A channel document grants the creator (`grant.users`), adds `grant.public` so all members can read, and `grant.roles` so posters can write.
-- **Write surfaces** are gated with `useVibe(dbName).can.create/edit/delete` — it runs this same access function, so the UI verdict matches the server. Render `.reason` when denied. (See use-vibe docs.)
-- **`ViewerTag`** takes `userHandle` to render another user (authors, rosters). The current viewer's own pill and sign-in button are system chrome in the Vibes Switch (the logo) — don't add one to the app's UI, except a guarded no-prop `{viewer && <ViewerTag />}` when you want inline avatar self-edit for any signed-in member (see use-viewer docs).
-
-access.js
-
-```js
-export function announcements(doc, oldDoc, user, ctx) {
-  if (!user) throw { forbidden: "sign in" };
-
-  if (doc.type === "channel") {
-    ctx.requireRole("owner");
-    return {
-      channels: [doc._id],
-      grant: {
-        users: { [user.userHandle]: [doc._id] },
-        public: [doc._id],
-        roles: { poster: [doc._id] },
-      },
-    };
-  }
-
-  if (doc.type === "roleGrant") {
-    ctx.requireRole("owner");
-    // A grant doc must ALSO route to a channel — a result with no `channels`
-    // (only `members`/`grant`) is rejected as an "unreadable write". Route it to
-    // an owner-readable admin channel (not a public one) so the grant persists
-    // and the owner can read the roster back; the membership then applies.
-    return {
-      channels: ["admin:grants"],
-      members: { [doc.role]: [doc.userHandle] },
-      grant: { users: { [user.userHandle]: ["admin:grants"] } },
-    };
-  }
-
-  if (doc.type === "post") {
-    // Author fixed at create; ownership immutable. On update a non-author may
-    // only append one legitimate ImgGen version — the platform predicate
-    // ctx.isImgGenVersionAppend decides that (oldDoc is null on create).
-    if (oldDoc === null) {
-      if (doc.authorHandle !== user.userHandle) throw { forbidden: "not author" };
-    } else if (doc.authorHandle !== oldDoc.authorHandle) {
-      throw { forbidden: "cannot change author" };
-    } else if (ctx.isImgGenVersionAppend(doc, oldDoc) === false && oldDoc.authorHandle !== user.userHandle) {
-      throw { forbidden: "not author" };
-    }
-    ctx.requireAccess(doc.channel);
-    return { channels: [doc.channel] };
-  }
-
-  throw { forbidden: "unknown document type" };
-}
-```
-
-App.jsx — `useVibe().can` gates every write surface (posts AND owner-only management); `access.hasChannel()` reflects display-only membership:
-
-```jsx
-import React from "react";
-import { useFireproof } from "use-fireproof";
-import { useViewer, useVibe } from "use-vibes";
-
-export default function App() {
-  const { viewer, isViewerPending, ViewerTag } = useViewer();
-  const { database, useLiveQuery, access } = useFireproof("announcements");
-  const { can } = useVibe("announcements");
-
-  const { docs: posts } = useLiveQuery("type", { key: "post" });
-  const [draft, setDraft] = React.useState("");
-  const [channel, setChannel] = React.useState("general");
-  // Build each candidate from the doc you'll actually write — the access function
-  // checks authorHandle/channel (and owner-only for roleGrant), so a bare partial
-  // would be denied and hide the control even from users who can act.
-  const canPost = can.create({ type: "post", channel, authorHandle: viewer?.userHandle });
-  // Owner-only management gates on can.* too — the access fn calls
-  // ctx.requireRole("owner"), so this verdict is false for everyone but the owner.
-  const canGrant = can.create({ type: "roleGrant", role: "poster", userHandle: "newUser" });
-
-  if (isViewerPending) return null;
-
-  async function submitPost() {
-    if (!draft.trim() || !viewer) return;
-    await database.put({
-      type: "post",
-      channel,
-      body: draft.trim(),
-      authorHandle: viewer.userHandle,
-      createdAt: Date.now(),
-    });
-    setDraft("");
-  }
-
-  return (
-    <div>
-      {/* No current-user pill / sign-in button here — that's system chrome in the
-          Vibes Switch (the panel the logo opens). ViewerTag below renders post authors. */}
-
-      {/* gate the write surface on useVibe().can — it runs the access function */}
-      {canPost.ok ? (
-        <form
-          onSubmit={(e) => {
-            e.preventDefault();
-            submitPost();
-          }}
-        >
-          <textarea value={draft} onChange={(e) => setDraft(e.target.value)} />
-          <button type="submit">Post</button>
-        </form>
-      ) : (
-        viewer && <p style={{ color: "var(--muted, #888)" }}>{canPost.reason}</p>
-      )}
-
-      {/* owner-only management — gated on can.* */}
-      {canGrant.ok && (
-        <button onClick={() => database.put({ type: "roleGrant", role: "poster", userHandle: "newUser" })}>
-          Grant poster role
-        </button>
-      )}
-
-      {posts.map((p) => (
-        <div key={p._id}>
-          <ViewerTag userHandle={p.authorHandle} />
-          <p>{p.body}</p>
-          {can.delete(p).ok && <button onClick={() => database.del(p._id)}>Delete</button>}
-        </div>
-      ))}
-    </div>
-  );
-}
-```
-
-The pattern: `useVibe().can` gates every write surface — including owner-only management, which the access function enforces via `ctx.requireRole("owner")` so `can.create({ type: "roleGrant", … })` is false for non-owners. `access.hasChannel()` reflects display-only membership; the write gate is always `can.*`. The access function is the server-side authority — `useVibe().can` is how the UI reflects its decisions for writes.
-
-**Owner-management panels (appoint/revoke moderators, grant/revoke roles) gate on `can.*`.** Gate each mutating control — and the panel's visibility — on the `can.*` verdict from the doc you'll actually write: appoint on `can.create({ type: "modGrant", role: "moderator", userHandle }).ok`, revoke on `can.delete(grantDoc).ok` — and render `.reason` when denied. `can.*` runs the app's own `access.js` to produce the verdict, so the control's enabled state and message track what the access function decides and stay correct as the rule grows beyond owner-only (a delegated admin role, say).
-
-```jsx
-// Gate visibility AND each write on the can.* verdict, and supply the denial reason
-const canAppoint = can.create({ type: "modGrant", role: "moderator", userHandle });
-const canRevoke = can.delete(grantDoc);
-{(canAppoint.ok || canRevoke.ok) && (
-  <ModeratorPanel>
-    {canAppoint.ok && (
-      <button onClick={() => database.put({ type: "modGrant", role: "moderator", userHandle })}>Appoint</button>
-    )}
-    {canRevoke.ok ? (
-      <button onClick={() => database.del(grantDoc._id)}>Revoke</button>
-    ) : (
-      <p>{canRevoke.reason}</p>
-    )}
-  </ModeratorPanel>
-)}
-```
-
-### Example: Channel board with open channels (any member posts)
-
-Channels everyone can read, and any signed-in user can post to. The channel doc is `grant.public` (read for everyone) and the post rule checks only the author — **no `ctx.requireAccess`**, because public is read-only and would block every non-owner. (For a members-only board where the owner appoints who can post, grant a poster role and `requireAccess` it, as in the announcements example above.) The UI uses `access.hasChannel()` to filter which channels to display, and `useVibe().can` to gate writes.
-
-access.js
-
-```js
-export function chat(doc, oldDoc, user, ctx) {
-  if (!user) throw { forbidden: "sign in" };
-
-  if (doc.type === "channel") {
-    ctx.requireRole("owner");
-    // Open channel: public READ for everyone. No write-membership grant is
-    // needed — any signed-in user may post (see the post rule below).
-    return { channels: [doc._id], grant: { public: [doc._id] } };
-  }
-
-  if (doc.type === "post") {
-    // Author fixed at create; ownership immutable. On update a non-author may
-    // only append one legitimate ImgGen version — the platform predicate
-    // ctx.isImgGenVersionAppend decides that (oldDoc is null on create).
-    if (oldDoc === null) {
-      if (doc.authorHandle !== user.userHandle) throw { forbidden: "not author" };
-    } else if (doc.authorHandle !== oldDoc.authorHandle) {
-      throw { forbidden: "cannot change author" };
-    } else if (ctx.isImgGenVersionAppend(doc, oldDoc) === false && oldDoc.authorHandle !== user.userHandle) {
-      throw { forbidden: "not author" };
-    }
-    // Any signed-in author may post to this open channel. Do NOT call
-    // ctx.requireAccess(doc.channel) here: the channel is grant.public
-    // (read-only), which never satisfies requireAccess, so gating on it would
-    // block every non-owner from posting. requireAccess is for members-only
-    // channels whose writers were granted membership (see announcements above).
-    return { channels: [doc.channel] };
-  }
-
-  throw { forbidden: "unknown document type" };
-}
-```
-
-App.jsx — `access.hasChannel()` filters which channels are visible (display); `useVibe().can` gates the write surface:
-
-```jsx
-<<<<<<< SEARCH
-  const { database, useLiveQuery, access } = useFireproof("announcements");
-=======
-  const { database, useLiveQuery, access } = useFireproof("chat");
-  const { docs: channels } = useLiveQuery("type", { key: "channel" });
-  // Build the candidate from the doc you'll write — the access fn checks
-  // authorHandle, so a bare { type: "post" } would be denied and hide the form.
-  const canPost = useVibe("chat").can.create({ type: "post", channel, authorHandle: viewer?.userHandle });
->>>>>>> REPLACE
-```
-
-```jsx
-<<<<<<< SEARCH
-      {viewer && access.hasChannel(channel) && (
-=======
-      {/* filter to channels the viewer can see — use _id as channel identifier (display only) */}
-      {channels.filter((ch) => access.hasChannel(ch._id)).map((ch) => (
-        <button key={ch._id} onClick={() => setChannel(ch._id)}>{ch.name}</button>
-      ))}
-
-      {/* gate the write surface on useVibe().can */}
-      {canPost.ok ? (
->>>>>>> REPLACE
-```
-
-Channel `_id` is the channel identifier everywhere. The access function uses `doc._id` for routing and grants. A deterministic `_id` like `"ch:" + name` enforces uniqueness — two users can't create duplicate channels.
-
-### Example: Per-object sharing (collaborate on your own objects, no admin)
-
-Reach for this whenever the prompt says **invite, join, collaborate, share with, together, with my partner/team** — a shared shopping list you invite a partner to, a whiteboard people can join, a trip a group plans together. A list app where every signed-in user makes their own lists, sees only their own, and can invite anyone to collaborate on a specific list — peer to peer, with no app admin in the loop. The pattern: **a channel per object** (`list:<id>`); the creator grants themselves that channel at creation; child docs (items) gate on `ctx.requireAccess` of the list's channel, so **any member edits any item**; any current member shares the list by granting another user the same channel. Membership is direct `grant.users`, so each viewer's access scales with their own memberships.
-
-access.js
-
-```js
-export default function (doc, oldDoc, user, ctx) {
-  if (!user) throw { forbidden: "sign in" };
-  const ch = (id) => `list:${id}`;
-
-  if (doc.type === "list") {
-    // Creator owns the list doc; route it to its own channel and grant self.
-    const author = oldDoc ? oldDoc.author : doc.author;
-    if (author !== user.userHandle) throw { forbidden: "not your list" };
-    // author is write-once: an update must not re-author the list (which would
-    // change who can edit it and hand control to someone never granted).
-    if (oldDoc && doc.author !== oldDoc.author) throw { forbidden: "cannot change author" };
-    return { channels: [ch(doc._id)], grant: { users: { [user.userHandle]: [ch(doc._id)] } } };
-  }
-
-  if (doc.type === "item") {
-    // Any member of the list may add/edit items in it. listId is immutable —
-    // without this, a member of list X could re-point an existing item from a
-    // list they don't belong to into X (it would still pass requireAccess(X)).
-    if (oldDoc && oldDoc.listId !== doc.listId) throw { forbidden: "cannot move item" };
-    ctx.requireAccess(ch(doc.listId));
-    return { channels: [ch(doc.listId)] };
-  }
-
-  if (doc.type === "share") {
-    // Any current member invites a peer by handle — grants them the list channel.
-    // Route the share doc to the list channel itself (every member already holds
-    // it), so members see who was added without a second channel to grant.
-    ctx.requireAccess(ch(doc.listId));
-    return { channels: [ch(doc.listId)], grant: { users: { [doc.invitee]: [ch(doc.listId)] } } };
-  }
-
-  throw { forbidden: "unknown document type" };
-}
-```
-
-To invite someone who isn't a member yet without knowing their handle in advance, invert the flow with a request doc: a `request` type takes **no** `ctx.requireAccess` (any signed-in user may create one — their handle is `user.userHandle`, unforgeable) and routes to the list channel `ch(doc.listId)`, where current members read it (the requester can't read their own request back — they aren't a member yet — which is fine; they just wait to be granted). A member then writes the `share` above to approve.
-
-App.jsx — `access.hasChannel()` shows only the lists the viewer belongs to; `useVibe("lists").can` gates each write surface (create list, add item, invite peer):
-
-```jsx
-<<<<<<< SEARCH
-  const { database, useLiveQuery, access } = useFireproof("notes");
-=======
-  const { database, useLiveQuery, access } = useFireproof("lists");
-  const { me, can } = useVibe("lists");
-  const { docs: lists } = useLiveQuery("type", { key: "list" });
-  const visible = lists.filter((l) => access.hasChannel(`list:${l._id}`));
-  // Each member edits any item — items gate on requireAccess(list:<id>), not authorHandle.
-  const canAddItem = (list) => can.create({ type: "item", listId: list._id, authorHandle: me?.userHandle }).ok;
-  const canShare = (list) => can.create({ type: "share", listId: list._id, invitee: "x" }).ok;
->>>>>>> REPLACE
-```
-
-```jsx
-<<<<<<< SEARCH
-      {viewer && <button onClick={addNote}>+ note</button>}
-=======
-      {/* create list — any signed-in visitor can start their own */}
-      {can.create({ type: "list", author: me?.userHandle }).ok && (
-        <button onClick={() => database.put({ type: "list", author: me.userHandle, name: "new list" })}>
-          + new list
-        </button>
-      )}
-
-      {visible.map((list) => (
-        <section key={list._id}>
-          <h3>{list.name}</h3>
-          {/* add-item form is shown only when the access fn would accept the write */}
-          {canAddItem(list) && <AddItemForm listId={list._id} />}
-          {/* invite peer — only shown to members of this list */}
-          {canShare(list) && <ShareForm listId={list._id} />}
-        </section>
-      ))}
->>>>>>> REPLACE
-```
+`useFireproof()` returns an `access` property (resolved roles/channels for display) and the full worked round-trip examples — team announcements, open channel boards, per-object sharing, workspace chat, anonymous surveys, public guestbooks — live in the **access skill** (`access.js`), which is included whenever the app is permission-shaped (privacy, sharing, teams, members, roles, approval). Gate every write surface with `useVibe(dbName).can`; reflect membership for display with `access.hasRole(name)` / `access.hasChannel(name)`.
 
 ---
 
@@ -852,222 +486,6 @@ A channel is a _reusable_ unit of read access: grant a user into a channel once
 - **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.
 - **Refusing a write:** `throw { forbidden: "reason" }`. Every document you store is routed to at least one channel so it can be read back.
 
-### Example: Workspace chat with channels
-
-access.js
-
-```js
-export function chat(doc, oldDoc, user, ctx) {
-  if (!user) throw { forbidden: "authentication required" };
-
-  if (doc.type === "channel-meta") {
-    if (doc.ownerHandle !== user.userHandle) throw { forbidden: "not owner" };
-    if (oldDoc && oldDoc.ownerHandle !== user.userHandle) throw { forbidden: "not owner" };
-    return {
-      channels: [doc._id],
-      grant: {
-        users: Object.fromEntries([[doc.ownerHandle, [doc._id]], ...doc.memberHandles.map((h) => [h, [doc._id]])]),
-      },
-    };
-  }
-
-  if (doc.type === "message") {
-    // Author fixed at create; ownership immutable. On update a non-author may
-    // only append one legitimate ImgGen version — the platform predicate
-    // ctx.isImgGenVersionAppend decides that (oldDoc is null on create).
-    if (oldDoc === null) {
-      if (doc.userHandle !== user.userHandle) throw { forbidden: "not author" };
-    } else if (doc.userHandle !== oldDoc.userHandle) {
-      throw { forbidden: "cannot change author" };
-    } else if (ctx.isImgGenVersionAppend(doc, oldDoc) === false && oldDoc.userHandle !== user.userHandle) {
-      throw { forbidden: "not author" };
-    }
-    ctx.requireAccess(doc.channelId);
-    return { channels: [doc.channelId] };
-  }
-
-  if (doc.type === "channel-invite") {
-    if (doc.senderHandle !== user.userHandle) throw { forbidden: "not sender" };
-    if (oldDoc && oldDoc.senderHandle !== user.userHandle) throw { forbidden: "not sender" };
-    ctx.requireAccess(doc.channelId);
-    return {
-      channels: [doc.channelId],
-      grant: { users: { [doc.inviteeHandle]: [doc.channelId] } },
-    };
-  }
-
-  throw { forbidden: "unknown document type" };
-}
-```
-
-This single access function handles three document types: **channel-meta** — owner creates a channel and grants access to listed members, **message** — only the author can post, must already have channel access, **channel-invite** — any channel member can invite others; deleting the invite revokes the grant.
-
-App.jsx — show only channels the viewer is in (`access.hasChannel`), gate the compose box and invite form on `useVibe().can`:
-
-```jsx
-<<<<<<< SEARCH
-  const { database, useLiveQuery, access } = useFireproof("notes");
-=======
-  const { database, useLiveQuery, access } = useFireproof("chat");
-  const { me, can } = useVibe("chat");
-  const { docs: channels } = useLiveQuery("type", { key: "channel-meta" });
-  // Filter to channels the viewer has been granted into — non-members never see them in the list.
-  const myChannels = channels.filter((ch) => access.hasChannel(ch._id));
-  const [channelId, setChannelId] = React.useState(null);
-  const canPost = can.create({ type: "message", channelId, userHandle: me?.userHandle });
-  const canInvite = can.create({ type: "channel-invite", channelId, senderHandle: me?.userHandle, inviteeHandle: "x" });
->>>>>>> REPLACE
-```
-
-```jsx
-<<<<<<< SEARCH
-      {viewer && <Compose onSend={send} />}
-=======
-      {/* sidebar lists only the channels the viewer is in */}
-      <nav>{myChannels.map((ch) => <button key={ch._id} onClick={() => setChannelId(ch._id)}>{ch.name}</button>)}</nav>
-
-      {/* compose is shown only when the viewer is a member of the selected channel */}
-      {channelId && canPost.ok ? (
-        <Compose onSend={(text) => database.put({ type: "message", channelId, userHandle: me.userHandle, text })} />
-      ) : (
-        <p>{canPost.reason || "Pick a channel"}</p>
-      )}
-
-      {/* any member of this channel may invite a peer */}
-      {channelId && canInvite.ok && <InviteForm channelId={channelId} senderHandle={me.userHandle} />}
->>>>>>> REPLACE
-```
-
-### Example: Anonymous survey with role-gated results
-
-access.js
-
-```js
-export function survey(doc, oldDoc, user, ctx) {
-  if (doc.type === "survey-response") {
-    if (oldDoc) throw { forbidden: "responses are write-once" };
-    return { channels: ["inbound-responses"], allowAnonymous: true };
-  }
-
-  if (doc.type === "survey-config") {
-    ctx.requireRole("owner");
-    // Route this grant/config doc to an owner-readable admin channel — a
-    // grant-only result (no `channels`) is rejected as an "unreadable write".
-    return {
-      channels: ["admin:grants"],
-      grant: {
-        users: { [user.userHandle]: ["admin:grants"] },
-        roles: { "feedback-team": ["inbound-responses"] },
-      },
-    };
-  }
-
-  if (doc.type === "final-results") {
-    ctx.requireRole("feedback-team");
-    return { channels: [doc._id], grant: { public: [doc._id] } };
-  }
-
-  throw { forbidden: "unknown document type" };
-}
-```
-
-Key patterns: `allowAnonymous: true` on survey-response lets unauthenticated visitors submit, `grant.public` on final-results makes them readable by any member without a specific channel grant, and the **singleton grant doc** pattern (survey-config) wires role-to-channel access in one place.
-
-App.jsx — anonymous-friendly submit form, owner-only config panel, role-gated results view:
-
-```jsx
-<<<<<<< SEARCH
-  const { database } = useFireproof("notes");
-=======
-  const { database, useLiveQuery, access } = useFireproof("survey");
-  const { me, can } = useVibe("survey");
-  // Submit form is shown for anyone — allowAnonymous makes this can.create return ok for null user.
-  const canSubmit = can.create({ type: "survey-response", question: "q1", answer: "" });
-  // Owner-only — survey-config rule calls ctx.requireRole("owner").
-  const canConfigure = can.create({ type: "survey-config" });
-  const { docs: results } = useLiveQuery("type", { key: "final-results" });
->>>>>>> REPLACE
-```
-
-```jsx
-<<<<<<< SEARCH
-      <input value={answer} onChange={(e) => setAnswer(e.target.value)} />
-=======
-      {/* anyone (signed in OR anonymous) can submit — only stamp authorHandle when present */}
-      {canSubmit.ok ? (
-        <form onSubmit={(e) => {
-          e.preventDefault();
-          database.put({ type: "survey-response", question: "q1", answer, ...(me && { authorHandle: me.userHandle }) });
-        }}>
-          <input value={answer} onChange={(e) => setAnswer(e.target.value)} />
-          <button type="submit">Submit</button>
-        </form>
-      ) : <p>{canSubmit.reason}</p>}
-
-      {/* owner-only admin to wire up the feedback-team role */}
-      {canConfigure.ok && <ConfigPanel />}
-
-      {/* results render only for users with the feedback-team role — access.hasChannel filters them in */}
-      {results.filter((r) => access.hasChannel(r._id)).map((r) => <ResultCard key={r._id} doc={r} />)}
->>>>>>> REPLACE
-```
-
-### Example: Public guestbook / contact form (anonymous writes)
-
-When the prompt says **anyone can sign / submit without logging in** (a guestbook, a contact form, an RSVP), do **not** throw on `!user` — return `allowAnonymous: true` so the write is accepted for anonymous visitors. `useVibe().can.create(...)` then returns `ok` for an anonymous viewer, and the form shows instead of a sign-in wall. Stamp `authorHandle` only when there is a user.
-
-access.js
-
-```js
-export function guestbook(doc, oldDoc, user, ctx) {
-  if (doc.type === "entry") {
-    if (oldDoc) throw { forbidden: "entries are write-once" };
-    // No `if (!user) throw` — anyone may sign. allowAnonymous opts the write in.
-    return { channels: ["public"], grant: { public: ["public"] }, allowAnonymous: true };
-  }
-  throw { forbidden: "unknown document type" };
-}
-```
-
-In `App.jsx`, gate the form on `useVibe("guestbook").can.create({ type: "entry" }).ok` (true for anon here) and stamp `authorHandle: me?.userHandle` only when signed in. Without `allowAnonymous: true` the runtime rejects the null-user write even though the function didn't throw — so the guestbook would silently require login, the exact miss to avoid.
-
-App.jsx — gate the form on `can.create({ type: "entry" }).ok`, which is true even when nobody is signed in:
-
-```jsx
-<<<<<<< SEARCH
-  const { database } = useFireproof("notes");
-=======
-  const { database, useLiveQuery } = useFireproof("guestbook");
-  const { me, can } = useVibe("guestbook");
-  const { docs: entries } = useLiveQuery("type", { key: "entry" });
-  // allowAnonymous: true on the access fn → this returns ok for an anon viewer.
-  // The form is visible from first load, no sign-in wall.
-  const canSign = can.create({ type: "entry", message: "" });
->>>>>>> REPLACE
-```
-
-```jsx
-<<<<<<< SEARCH
-      <SignInGate>
-        <input value={message} onChange={(e) => setMessage(e.target.value)} />
-      </SignInGate>
-=======
-      {canSign.ok ? (
-        <form onSubmit={(e) => {
-          e.preventDefault();
-          // Stamp authorHandle only when signed in — anon entries simply omit it.
-          database.put({ type: "entry", message, createdAt: Date.now(), ...(me && { authorHandle: me.userHandle }) });
-          setMessage("");
-        }}>
-          <input value={message} onChange={(e) => setMessage(e.target.value)} placeholder="Leave a note" />
-          <button type="submit">Sign</button>
-        </form>
-      ) : <p>{canSign.reason}</p>}
-
-      {entries.map((e) => <li key={e._id}>{e.message} — {e.authorHandle || "anonymous"}</li>)}
->>>>>>> REPLACE
-```
-
 ### Multiple databases in one file
 
 Each named export gates its own database. A single `/access.js` can gate all databases the app uses:

package/llms/index.d.ts

@@ -11,5 +11,6 @@ export { webxrConfig } from "./webxr.js";
 export { useViewerConfig } from "./use-viewer.js";
 export { useVibeConfig } from "./use-vibe.js";
 export { createVibeConfig } from "./create-vibe.js";
+export { accessConfig } from "./access.js";
 export type { LlmConfig } from "./types.js";
-export declare const allConfigs: readonly [import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig];
+export declare const allConfigs: readonly [import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig];

package/llms/index.js

@@ -11,6 +11,7 @@ import { webxrConfig } from "./webxr.js";
 import { useViewerConfig } from "./use-viewer.js";
 import { useVibeConfig } from "./use-vibe.js";
 import { createVibeConfig } from "./create-vibe.js";
+import { accessConfig } from "./access.js";
 export { backendConfig } from "./backend.js";
 export { calendarConfig } from "./calendar.js";
 export { callaiConfig } from "./callai.js";
@@ -24,6 +25,7 @@ export { webxrConfig } from "./webxr.js";
 export { useViewerConfig } from "./use-viewer.js";
 export { useVibeConfig } from "./use-vibe.js";
 export { createVibeConfig } from "./create-vibe.js";
+export { accessConfig } from "./access.js";
 export const allConfigs = [
     callaiConfig,
     imageGenConfig,
@@ -38,5 +40,6 @@ export const allConfigs = [
     createVibeConfig,
     backendConfig,
     calendarConfig,
+    accessConfig,
 ];
 //# sourceMappingURL=index.js.map

package/llms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../jsr/llms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAIpD,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,YAAY;IACZ,cAAc;IACd,cAAc;IACd,QAAQ;IACR,aAAa;IACb,WAAW;IACX,eAAe;IACf,WAAW;IACX,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,aAAa;IACb,cAAc;CACN,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../jsr/llms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,YAAY;IACZ,cAAc;IACd,cAAc;IACd,QAAQ;IACR,aAAa;IACb,WAAW;IACX,eAAe;IACf,WAAW;IACX,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,aAAa;IACb,cAAc;IACd,YAAY;CACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibes.diy/prompts",
-  "version": "8.1.1",
+  "version": "8.2.0",
   "type": "module",
   "main": "./index.js",
   "description": "",
@@ -24,9 +24,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@adviser/cement": "~0.5.34",
-    "@vibes.diy/call-ai-v2": "^8.1.1",
-    "@vibes.diy/identity": "^8.1.1",
-    "@vibes.diy/use-vibes-types": "^8.1.1",
+    "@vibes.diy/call-ai-v2": "^8.2.0",
+    "@vibes.diy/identity": "^8.2.0",
+    "@vibes.diy/use-vibes-types": "^8.2.0",
     "arktype": "~2.2.3",
     "json-schema-faker": "~0.6.2"
   },