@vibes.diy/prompts 5.5.17 → 6.0.0

package/llms/fireproof.md

@@ -374,9 +374,23 @@ Each capability (`read`, `write`, `delete`) is independent. Omitting one falls b
 
 Other `acl` variants: `useFireproof("drafts", { acl: { read: ["editors"], write: ["editors"], delete: ["editors"] } })` for editors-only space, or omit `acl` entirely to fall back to app-level role gates (existing behavior, always safe).
 
+## Offline writes are on by default (`offlineQueue`)
+
+For signed-in users, writes are **local-first by default**: a `put`/`del` that fails on the network is durably queued on the device (it resolves, stays visible, and syncs to the cloud when you're back online) instead of rolling back. You don't opt in — every signed-in vibe gets this. A server rejection (access-denied, validation) still rolls back and throws; only transport failures queue.
+
+Pass `{ offlineQueue: false }` for **server-first, fail-fast** writes: a `put` resolves only when the server accepts it, and a network failure rejects immediately with nothing queued. Choose this for **collaborative multi-writer apps** where two people may edit the same doc — sync is blind last-arrival-wins (Firefly has no `_rev`), so a stale write replayed on reconnect can silently overwrite a newer one. When a lost write is safer than a surprise overwrite, opt out.
+
+```js
+// Default (single-user apps): durable offline writes, no config needed.
+const { useLiveQuery } = useFireproof("todos");
+
+// Collaborative app: fail fast instead of queueing a stale write.
+const { useLiveQuery } = useFireproof("shared-board", { offlineQueue: false });
+```
+
 ## Anonymous local writes (`anonymousLocal`)
 
-For "let a logged-out visitor try it and save a little state before signing in," pass `{ anonymousLocal: true }`. While logged out, `put`/`del`/`useLiveQuery`/`useDocument` run against a local (localStorage) store with the identical API — no auth branching in your code. On first sign-in the local docs migrate into the cloud database, then local storage clears.
+For "let a logged-out visitor try it and save a little state before signing in," pass `{ anonymousLocal: true }`. While logged out, `put`/`del`/`useLiveQuery`/`useDocument` run against a local (localStorage) store with the identical API — no auth branching in your code. On first sign-in the local docs migrate into the cloud database, then local storage clears. (This is the signed-**out** read-path opt-in; the offline write queue above is separate and already on for signed-in users.)
 
 ```js
 const { useLiveQuery, database } = useFireproof("favorites", {

package/llms/voxel.md

@@ -311,29 +311,296 @@ when a block breaks — cheap, and it makes mining feel real.
 
 ## Multiplayer: live block edits over Fireproof
 
-Persist each edit as **exactly one document per voxel coordinate** so concurrent
-builders converge and late joiners see the whole world. Give that document a
-**deterministic `_id` of `block:<key>`** so every edit at a coordinate *updates
-the same doc* — do NOT `put` a fresh doc per edit. Without the deterministic id
-Fireproof mints a new `_id` each time, the database grows without bound, and the
-live query below replays every historical value in index order, so a stale doc
-can overwrite a newer break/place. A break writes a `removed: true` tombstone at
+**Know exactly what the substrate gives you before you design for it.** A live
+query returns the **full, latest-per-document result set**, deliveries are
+**unordered** (notifications can be delayed; overlapping re-queries can resolve
+out of order), and when two writes target the **same `_id`** the durable head is
+whichever the **server wrote last by arrival order — not the higher client
+timestamp.** That last fact is the one that bites: a client-side fold can order
+what a session *observes*, but it cannot change which revision the server keeps,
+so **there is no free lunch here.** Pick a model with eyes open:
+
+- **Model A — one doc per coordinate (bounded, eventually-consistent-per-session).**
+  Deterministic `_id: block:<key>`, so each edit *overwrites* the same doc and the
+  database stays one-doc-per-cell. A client fold makes every session that
+  *observes* both of two concurrent writes converge on the same winner. **Its
+  honest limit:** the durable head at a coordinate is whatever persisted last by
+  server order, so a **late joiner** — who only ever receives that one head —
+  can see a *lower*-timestamp write win. And because the fold orders by
+  client-supplied `(at, wid)`, even among *accepted* writes a skewed writer's
+  clock can transiently order a lower-real-time edit ahead until the skew
+  window passes — the stamps order by *observed* time, not truth. Fine for a
+  casual shared toy; not actually strong consistency, and only server-assigned
+  ordering ([#3777](https://github.com/VibesDIY/vibes.diy/issues/3777)) removes
+  the client-clock dependence entirely. This is the model shown below and used
+  by the example app.
+- **Model B — append-only op log (unbounded, strongly convergent).** Every edit
+  is its **own immutable doc** (unique `_id`, never overwritten), so the full set
+  of ops is durably present and *every* client — late joiners included — folds
+  the identical total order to the identical world. This is the model to reach
+  for when correctness across joiners matters. **Its cost:** the doc set grows
+  with every edit; you must compact (delete ops below the reset watermark, or
+  snapshot). The delta from Model A is small and called out after the code.
+- **The real fix for bounded *and* strong is server-assigned ordering** (a
+  compare-and-set on `at`, or a server write-sequence exposed to the fold). The
+  platform does not expose that yet — [#3777](https://github.com/VibesDIY/vibes.diy/issues/3777).
+  Until it does, neither model is both bounded and joiner-correct, and this
+  section says so rather than pretending a client fold closes the gap.
+
+### Model A: one doc per coordinate
+
+Give the doc a **deterministic `_id` of `block:<key>`** so every edit at a
+coordinate updates the same doc — the database stays one-doc-per-cell instead of
+replaying every historical value. A break writes a `removed: true` tombstone at
 the same id (keep it so the removal survives streaming, rather than deleting it):
 
 ```js
-// on place/break — apply locally for instant feedback, then upsert the ONE doc for this cell
+// A per-WRITE unique id. It is the tiebreaker AND the identity: authorHandle is
+// neither (two tabs on one handle, or two anonymous players, collide), and `by`
+// defaulting to "" would let distinct writes tie and fall back to arrival order.
+const wid = crypto.randomUUID();
+
+// on place/break — apply locally for instant feedback, fold the intent into
+// the world map NOW, then upsert the ONE doc for this cell.
+// Stamp with a STRICTLY monotonic local time: never <= our previous write
+// (Date.now() can tie or step backwards), and always above the reset watermark.
+// We clamp OUR OWN clock here on write, so an honest client never emits a
+// future-dated stamp; readers drop the rest (see fold).
 eng.applyBlock(key, type);                    // type=null for a break
-await database.put(brk
-  ? { _id: `block:${key}`, type: "block", key, removed: true,  authorHandle: me?.userHandle, at: Date.now() }
-  : { _id: `block:${key}`, type: "block", key, blockType: type, authorHandle: me?.userHandle, at: Date.now() });
+const at = (lastAtRef.current = Math.max(Date.now(), lastAtRef.current + 1, resetAtRef.current + 1));
+const doc = brk
+  ? { _id: `block:${key}`, type: "block", key, removed: true,  authorHandle: me?.userHandle, wid, at }
+  : { _id: `block:${key}`, type: "block", key, blockType: type, authorHandle: me?.userHandle, wid, at };
+if (wins(at, wid, blockStateRef.current.get(key)))
+  blockStateRef.current.set(key, { at, wid, doc }); // local write folds in at put time
+await database.put(doc);
+```
+
+### Consistency: fold snapshots FORWARD — never rebuild the world from a snapshot
+
+Because deliveries are unordered, a snapshot missing your newest write can land
+*after* one that had it. If each delivery rebuilds the world from scratch, that
+stale delivery silently resurrects old state: **mined blocks visibly fill back
+in behind the player, then "stabilize" back to correct when a fresh delivery
+lands** — the single most disorienting multiplayer bug a voxel game can have.
+The rule that kills it: **a voxel only ever moves forward in time.** Keep a
+monotonic accumulator keyed by coordinate holding `{ at, wid, doc }` and fold
+every snapshot into it — an older write can never overwrite a newer one. Local
+writes fold in at put time (above), so the player's own intent is the newest
+state by definition and no delivery ordering can outrace it:
+
+```js
+const MAX_SKEW = 30_000; // reject another client's clock more than ~30s ahead
+const blockStateRef = React.useRef(new Map()); // key -> { at, wid, doc }
+const lastAtRef = React.useRef(0); // makes our own stamps strictly increasing
+// One deterministic TOTAL order, used for local folds and snapshot folds alike:
+// higher at wins; equal at breaks the tie by the per-write uuid, so every client
+// converges to the same value with no collisions and no arrival-order dependence.
+const wins = (at, wid, cur) =>
+  !cur || at > cur.at || (at === cur.at && wid > cur.wid);
+
+// The reset watermark must be monotonic ACROSS deliveries — a stale, out-of-
+// order snapshot of the worldReset singleton must never lower it. Fold it into
+// a ref with max(previous, incoming); mirror to state so the block fold re-runs.
+// CRITICAL: apply the SAME future-stamp filter as blocks. The watermark only
+// ever rises AND is destructive (it clears the world and forces local writes
+// above it), so a single future-dated reset is far more damaging than a future
+// block — it would poison the watermark permanently. Drop resets beyond the
+// horizon here, and reject them server-side in access.js (below).
+const resetAtRef = React.useRef(0);
+const [resetAt, setResetAt] = React.useState(0);
+const { docs: resetDocs } = useLiveQuery("type", { key: "worldReset" });
+React.useEffect(() => {
+  const horizon = Date.now() + MAX_SKEW;
+  const hi = resetDocs.reduce((mx, d) => (d.at && d.at <= horizon ? Math.max(mx, d.at) : mx), resetAtRef.current);
+  if (hi > resetAtRef.current) { resetAtRef.current = hi; setResetAt(hi); }
+}, [resetDocs]);
+
+// Time-driven re-fold: a near-future write dropped by the skew filter becomes
+// eligible once wall time passes its stamp. Without this tick the fold only
+// re-runs on a new delivery, so in a quiet world a legit slightly-ahead write
+// would stay dropped. `tick` is a fold dependency below.
+const [tick, setTick] = React.useState(0);
+React.useEffect(() => {
+  const id = setInterval(() => setTick((t) => t + 1), MAX_SKEW);
+  return () => clearInterval(id);
+}, []);
 
-// stream everyone's edits back into the engine — one current doc per coordinate
 const { docs: blockDocs } = useLiveQuery("type", { key: "block" });
+// Fold in an EFFECT, not during render: the accumulator is a mutable store,
+// and mutating it in a useMemo is a render-phase side effect (unsafe under
+// concurrent/strict rendering even when the fold is idempotent).
+const [blocks, setBlocks] = React.useState(() => new Map());
+React.useEffect(() => {
+  const st = blockStateRef.current;
+  const horizon = Date.now() + MAX_SKEW;
+  for (const d of blockDocs) {
+    const at = d.at || 0, wid = d.wid || "";
+    if (at <= resetAt) continue;   // watermark filters EVERY fold — deliveries re-ship old docs forever
+    if (at > horizon) continue;    // Defense-in-depth: skip a stamp beyond the horizon THIS fold. The
+                                   // authoritative bound is server-side (access.js rejects at > now+skew
+                                   // at WRITE time), so a far-future doc should never persist; this local
+                                   // skip just absorbs a small clock lead until the tick re-admits it.
+                                   // NOTE: with the tick, this drop is NOT a durable filter — a fold that
+                                   // re-runs after wall time passes `at` will admit it. Keeping hostile
+                                   // far-future state out is the SERVER's job, not this line's.
+    if (wins(at, wid, st.get(d.key))) st.set(d.key, { at, wid, doc: d });
+  }
+  if (resetAt) for (const [k, v] of st) { if (v.at <= resetAt) st.delete(k); } // drop held entries when the watermark advances
+  const m = new Map();
+  for (const [k, v] of st) m.set(k, v.doc.removed ? null : v.doc.blockType);
+  setBlocks(m);
+}, [blockDocs, resetAt, tick]);
+// Apply to the engine — including keys that DISAPPEARED (a reset purged them):
+// only pushing present keys would leave pre-reset blocks rendered forever.
+// applyBlock(k, null) means "revert to generated terrain" in the engine model.
+const prevKeysRef = React.useRef(new Set());
 React.useEffect(() => {
-  for (const d of blockDocs) eng.applyBlock(d.key, d.removed ? null : d.blockType);
-}, [blockDocs]);
+  const seen = new Set();
+  for (const [k, b] of blocks) { seen.add(k); eng.applyBlock(k, b); }
+  for (const k of prevKeysRef.current) if (!seen.has(k)) eng.applyBlock(k, null);
+  prevKeysRef.current = seen;
+}, [blocks]);
 ```
 
+### Model B: append-only op log (the delta) — design sketch, not drop-in code
+
+The runnable example above is Model A. Model B is described as a **delta** — the
+invariants and access branches are exact, but the fold/compaction below is a
+**design sketch, not copy-paste code**: you must wire the snapshot query,
+validation, and seeding into your own fold (spelled out under Compaction), and
+for a production world you likely want server ordering ([#3777](https://github.com/VibesDIY/vibes.diy/issues/3777))
+rather than hand-rolling compaction. Treat it as "here is the shape and the
+traps," not a finished implementation.
+
+To make **late joiners** correct too, stop overwriting: give every edit its own
+immutable doc and never `put` the same `_id` twice.
+
+- **Write:** `_id: op:${wid}` instead of `block:<key>` (each op is a distinct,
+  never-updated doc); keep `key`, `at`, `wid`, and `blockType`/`removed` as-is.
+- **Fold:** unchanged — the same `wins(at, wid, …)` reduction over the op set
+  produces one winner per `key`. Because *no doc is ever overwritten*, the full
+  history is durably present, so any client that has received the same set of ops
+  folds to the same world regardless of join time — that is what makes it
+  convergent where Model A is only per-session. **The one caveat is the shared
+  future-stamp filter:** two clients whose clocks straddle a near-future op's
+  stamp momentarily include different op sets, so identical convergence is
+  *eventual* (it holds once every client's horizon passes the op, or absent
+  adversarial future stamps) — the same client-clock residual as Model A, closed
+  only by server ordering ([#3777](https://github.com/VibesDIY/vibes.diy/issues/3777)).
+- **Compaction (required, but it needs a completeness boundary):** the op set
+  grows with every edit, and a live query that re-ships an ever-growing set
+  eventually stalls. Two things make a *delete* safe, and both matter:
+  1. **The fold must read the snapshot it produces.** Fold the world into one
+     `snapshot` doc `{ at: <cut>, blocks: {key → blockType} }`; the fold then
+     **seeds the accumulator from the latest snapshot** (prime `blockStateRef`
+     from `snapshot.blocks` at `snapshot.at`) and applies only ops with
+     `at > snapshot.at`. Without this a late joiner reconstructs from partial
+     history.
+  2. **You may only delete ops the snapshot provably covers.** The compactor's
+     own query is eventually-consistent, so "delete every op with `at <= cut`"
+     is **unsafe** — an op at `at <= cut` that hadn't yet reached the compactor
+     is deleted forever, and every late joiner then reconstructs the wrong
+     world. The only boundary a *client* can trust is the owner's `worldReset`
+     watermark: ops below it are already semantically void (the reset voided
+     them), so deleting `at <= resetAt` is safe and is the degenerate snapshot
+     (an empty world at `resetAt`). Reclaiming space in a **long-lived, never-
+     reset** world needs a completeness guarantee no client query provides —
+     that is server-coordinated compaction (the server vouches the snapshot saw
+     every op `<= cut`), i.e. the same server-ordering gap as
+     [#3777](https://github.com/VibesDIY/vibes.diy/issues/3777). Until then,
+     compact only at resets, or accept unbounded growth.
+- **Access — Model B needs its own branches** (the shown `access.js` is Model A
+  and would *reject* every Model B write). Two things make the "append-only"
+  claim real, and both are easy to miss: **op docs must be create-only** (an open
+  branch that ignores `oldDoc` lets anyone who sees an `op:<wid>` rewrite that
+  supposedly-immutable op), and **deletes must be owner-only** (a delete is a
+  put of a tombstone under delete-as-put, so `allowAnonymous` would otherwise let
+  any client erase history and blow past the compaction boundary). Gate deletes
+  once at the top, keep the op branch create-only, and add the owner `snapshot`
+  singleton:
+  ```js
+  // Deletes exist ONLY for owner op-compaction, and ONLY for op docs. Route by
+  // oldDoc (the doc being removed), never by the tombstone's own fields. A blanket
+  // owner-delete would let db.del drop world:reset (lowering the watermark, so
+  // pre-reset ops flood back to a late joiner) or world:snapshot (stranding late
+  // joiners) — so reject those explicitly. NOTE: the documented `at <= resetAt`
+  // compaction boundary itself CANNOT be enforced here — the access fn can't read
+  // the current watermark (no doc reads in ctx) — so a client is trusted to only
+  // delete voided ops; a server revision/CAS would make it enforceable (#3777).
+  if (doc._deleted) {
+    if (!user) throw { forbidden: "sign in" };
+    ctx.requireRole("owner");
+    if (!oldDoc) throw { forbidden: "nothing to delete" };
+    if (oldDoc._id === "world:reset" || oldDoc._id === "world:snapshot") throw { forbidden: "reset/snapshot are not deletable" };
+    if (oldDoc.type !== "block") throw { forbidden: "only op docs are compactable" };
+    return { channels: [WORLD], grant: { public: [WORLD] } };
+  }
+  if (doc.type === "block") {
+    // op-log id, unique per write — NOT the block:<key> pin
+    if (doc._id !== `op:${doc.wid}`) throw { forbidden: "op docs live at op:<wid>" };
+    // CREATE-ONLY: a live op is immutable. Any update (oldDoc present) is a
+    // rewrite of history — reject it, or "append-only" is a lie on an open db.
+    if (oldDoc) throw { forbidden: "op docs are append-only" };
+    if (user && doc.authorHandle && doc.authorHandle !== user.userHandle) throw { forbidden: "not author" };
+    if (typeof doc.at !== "number" || doc.at > Date.now() + MAX_SKEW) throw { forbidden: "stamp too far in the future" };
+    return { channels: [WORLD], grant: { public: [WORLD] }, allowAnonymous: true };
+  }
+  if (doc.type === "snapshot") {
+    // Group-destructive (it authorizes op deletion) — owner only, fixed _id, and
+    // MONOTONIC. It is one durable head selected by server arrival order, so
+    // without the monotonic guard an older snapshot arriving late overwrites a
+    // newer one — and once ops below the newer cut are deleted a late joiner
+    // seeding the regressed snapshot can't rebuild. Same guard as worldReset;
+    // the fold must seed only from a snapshot whose `at >= resetAt`.
+    if (!user) throw { forbidden: "sign in" };
+    ctx.requireRole("owner");
+    if (doc._id !== "world:snapshot") throw { forbidden: "singleton lives at world:snapshot" };
+    if (typeof doc.at !== "number" || (oldDoc && !(doc.at > oldDoc.at))) throw { forbidden: "snapshot cut must move forward" };
+    return { channels: [WORLD], grant: { public: [WORLD] } };
+  }
+  ```
+
+Ordering rules, each load-bearing (both models):
+
+- **Bound future stamps SERVER-SIDE; the client drop is only defense-in-depth.**
+  An honest client stamps `max(now, last+1, resetAt+1)`, so it never emits a
+  future `at`. The authoritative guard against a hostile future stamp is in
+  `access.js`: reject any `block` or `worldReset` write with `at > now + MAX_SKEW`
+  so it never persists. The client fold *also* skips docs beyond its horizon, but
+  do **not** rely on that to keep hostile state out — because the fold re-runs on
+  the tick, a client-only skip is eventually undone once wall time passes the
+  stamp (a `now + 1h` block would surface ~an hour later). The client skip's real
+  job is smaller: absorb a legit small clock lead until the tick re-admits it.
+  The reset needs the same server bound *and* the client horizon filter, because
+  its watermark is monotonic and destructive — a single future reset that slips
+  through is the worst case. And **do not** clamp-and-remember on read — a
+  per-client clamp diverges between clients and can't be made Byzantine-safe.
+  Only server-assigned ordering
+  ([#3777](https://github.com/VibesDIY/vibes.diy/issues/3777)) removes the
+  client-clock dependence entirely.
+- **The order must be total, identical everywhere, and collision-free.** Break
+  equal-`at` ties by a **per-write uuid** (`wid`) in every fold. `authorHandle`
+  is not an identity (same-handle tabs, anonymous players tie) and a
+  session-scoped id still collides across a session's own writes; only a
+  per-write uuid is total. A server-assigned revision, when available, replaces
+  the whole `(at, wid)` scheme.
+- **The reset watermark must gate every fold, and be monotonic across
+  deliveries.** Deliveries re-ship the full doc set forever, so a purged
+  pre-reset doc comes straight back unless the fold rejects `at <= resetAt`
+  every time. The watermark itself must only ever rise: fold the `worldReset`
+  singleton into a ref with `max(previous, incoming)`, or an out-of-order stale
+  snapshot lowers it and readmits pre-reset blocks. Local writes stamp above it
+  by construction (the `resetAtRef.current + 1` term).
+- **Propagate disappearances to the engine.** A reset removes keys from the
+  derived map; if you only apply the keys that are present, everything mined
+  before the reset stays rendered. Diff against the previous key set and
+  apply `null` (revert-to-terrain) for keys that vanished.
+- **Clear an optimistic overlay only when the synced value AGREES with it**,
+  never when the key merely exists. A re-edited voxel always has an older doc,
+  so key-presence clears the overlay against stale data — the same refill bug
+  through a different door. `if (blocks.get(k) === pending.get(k)) pending.delete(k)`.
+
 Apply the local edit **before** the `put` so the world never waits on the
 network, and read live handles/permissions through refs (a value captured in the
 engine closure at load time goes stale — bind live state via `state.on*`
@@ -347,6 +614,7 @@ with their natural owner. Every type the app writes needs its own branch
 ```js
 export default function (doc, oldDoc, user, ctx) {
   const WORLD = "world:overworld";
+  const MAX_SKEW = 30_000;
   // No branch may change a doc's type: without this, the open block branch
   // could squat a reserved _id (inv:<handle>, world:reset) and lock out the
   // legitimate writer.
@@ -356,6 +624,11 @@ export default function (doc, oldDoc, user, ctx) {
     // accepted arbitrary _ids could occupy other types' reserved keys.
     if (doc._id !== `block:${doc.key}`) throw { forbidden: "block docs live at block:<key>" };
     if (user && doc.authorHandle && doc.authorHandle !== user.userHandle) throw { forbidden: "not author" };
+    // Bound the stamp SERVER-SIDE — this, not the client fold, is what keeps a
+    // hostile far-future write out. The client skip is undone once the tick's
+    // wall clock passes `at`; only a write-time rejection prevents a `now + 1h`
+    // block from persisting and surfacing an hour later.
+    if (typeof doc.at !== "number" || doc.at > Date.now() + MAX_SKEW) throw { forbidden: "block stamp too far in the future" };
     return { channels: [WORLD], grant: { public: [WORLD] }, allowAnonymous: true };
   }
   if (doc.type === "inventory") {
@@ -384,6 +657,10 @@ export default function (doc, oldDoc, user, ctx) {
     ctx.requireRole("owner");
     if (doc._id !== "world:reset") throw { forbidden: "singleton lives at world:reset" };
     if (typeof doc.at !== "number" || (oldDoc && !(doc.at > oldDoc.at))) throw { forbidden: "watermark must move forward" };
+    // Reject a far-future stamp SERVER-SIDE: the watermark is monotonic and
+    // destructive, so a future-dated reset would poison it for everyone and
+    // survive the client-side skew drop on the writer's own machine.
+    if (doc.at > Date.now() + MAX_SKEW) throw { forbidden: "reset stamp too far in the future" };
     return { channels: [WORLD], grant: { public: [WORLD] } };
   }
   throw { forbidden: "unknown document type" };
@@ -472,6 +749,7 @@ None of this needs persistence — keep it purely visual and client-side:
   draw distance.
 
 That set — exposed-face meshing, per-axis collision with step-up and un-stick,
-a click-to-play pointer-lock overlay, a DDA raycast, per-voxel Fireproof docs,
-table-driven survival systems, and a flat multi-file split once it grows — is
-what turns a voxel tech demo into a game people actually play.
+a click-to-play pointer-lock overlay, a DDA raycast, per-voxel Fireproof docs
+folded forward monotonically, table-driven survival systems, and a flat
+multi-file split once it grows — is what turns a voxel tech demo into a game
+people actually play.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibes.diy/prompts",
-  "version": "5.5.17",
+  "version": "6.0.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": "^5.5.17",
-    "@vibes.diy/identity": "^5.5.17",
-    "@vibes.diy/use-vibes-types": "^5.5.17",
+    "@vibes.diy/call-ai-v2": "^6.0.0",
+    "@vibes.diy/identity": "^6.0.0",
+    "@vibes.diy/use-vibes-types": "^6.0.0",
     "arktype": "~2.2.3",
     "json-schema-faker": "~0.6.2"
   },