@vibes.diy/prompts 14.3.32 → 14.3.35

package/llms/backend.md

@@ -384,8 +384,24 @@ const gh = await ctx.github.fetch("/repos/acme/site/issues", { method: "POST", b
   calling convention (codegen has been observed passing these positionally).
   The message lands in that person's bell, inbox, and push notifications.
   - `toHandle` is one handle, and the platform delivers to people already in
-    this app: the owner, an accepted invite or approved request, or a handle
-    named in the access function's persisted grant state.
+    this app: the owner, who always qualifies, an accepted invite or approved
+    request, a handle named in the access function's persisted grant state, or
+    somebody whose authenticated write reached the app (anonymous writes don't
+    count). Invite, request, and writer membership resolve the person through
+    their bound handle; the grant-state clause matches the named handle
+    itself. Explicit revocations deny anyone but the owner. A passing check
+    plus valid fields writes the notification into the inbox history of a
+    recipient the platform can resolve — an unresolvable handle fails the call
+    after the participation check. Their switches silence the live bell, the
+    push, and the email — not the history.
+  - When the notification is the opt-in kind — your turn, your order shipped —
+    seat the player the way a guest takes their own seat.
+    A turn notification goes to a seat its owner took themselves.
+    A join write where the added handle must equal `user.userHandle` qualifies
+    the writer by their own act. This is an app-side convention for notifiable
+    seats, not a rule about read grants: chosen-peer grants that share without
+    notifying — inviting a collaborator into a shared list — stay intentional,
+    and a grant-named handle stays eligible whether or not its owner seated it.
   - `body` is the whole message — plain text, 500 chars max. The platform
     titles it with the app's name and links it back to the app, so spend the
     body on what happened and who it concerns.

package/llms/three-js.md

@@ -1000,7 +1000,13 @@ gltf.scene.traverse((child) => {
 
 ### Minecraft World Generator
 
-Procedural voxel terrain with optimized geometry merging.
+Procedural voxel terrain. **For a block world, the voxel skill is the
+authority**: it draws each chunk as one `InstancedMesh` of the exposed blocks
+(or Block Craft's per-face `BufferGeometry` batching) and never a `Mesh` per
+block — follow it rather than the merge sketch below, which is only the noise
+half. The same rule holds outside voxels: many things of one shape are one
+`InstancedMesh` or `Points`, never a `Mesh` each, and nothing allocates a
+geometry or material inside the frame loop.
 
 ```javascript
 import { ImprovedNoise } from "three/addons/math/ImprovedNoise.js";

package/llms/voxel.md

@@ -13,9 +13,10 @@ veins, endless chunk streaming, day/night, live multiplayer edits, ambient
 wildlife — and its bigger successor **Blockcraft World**, which adds the full
 survival layer: crafting tiers, tool durability, smelting, armor, mob combat,
 hunger, creative mode, nether/end dimensions, per-player inventory, and a
-shared world reset. **Blocktopia** contributes material-colored controls,
-compact procedural island settings, and sparse per-cell edits; **Block Craft**
-contributes exposed-face chunk meshes and survival feedback. Adapt the useful
+shared world reset. **Blocktopia** contributes the instanced chunk renderer,
+material-colored controls, compact procedural island settings, and sparse
+per-cell edits; **Block Craft** contributes exposed-face chunk meshes and
+survival feedback. Adapt the useful
 patterns to the persistence contracts below: whole-world autosaves and durable
 movement heartbeats are expensive examples to improve, rather than defaults.
 
@@ -112,7 +113,8 @@ const state = {
   blocks: new Map(),   // "x|y|z" -> type   (the loaded world, terrain + edits)
   chunks: new Map(),   // "cx,cz" -> Set(blockKey)  currently-resident chunks
   edits:  new Map(),   // "x|y|z" -> type|null  player edits layered over terrain
-  meshes: new Map(),   // "x|y|z" -> THREE.Mesh  (only for EXPOSED blocks)
+  chunkMeshes: new Map(), // "cx,cz" -> THREE.InstancedMesh  (EXPOSED blocks only, one per chunk)
+  dirty: new Set(),    // "cx,cz" chunks whose mesh must be rebuilt after an edit
   pos: new THREE.Vector3(0, 20, 0),
   vel: new THREE.Vector3(),
   yaw: 0, pitch: 0, keys: {}, onGround: false, fly: false,
@@ -196,12 +198,17 @@ outline: the accent reinforces the selected mode rather than being its only
 signal. On touch, keep movement/look separate from Place/Break/Jump controls,
 and clear held input on pointer cancellation or lost capture.
 
-## Rendering: mesh only the EXPOSED blocks (this is the whole performance game)
+## Rendering: instance the EXPOSED blocks (this is the whole performance game)
 
 The single most important rule: **do not create a `THREE.Mesh` per stored
-block.** A chunk is thousands of blocks and most are buried. Keep buried blocks
-in the `blocks` map (collision and raycasting read the map, not the scene), and
-only add a mesh when a block has at least one non-occluding neighbor.
+block, and never allocate a geometry or material inside the block loop.** A
+chunk is thousands of blocks and most are buried. Three.js pays one draw call
+per mesh per material, so a mesh-per-block world with a six-material cube is
+hundreds of thousands of draw calls a frame — CPU-bound, and a faster GPU does
+not help. Keep buried blocks in the `blocks` map (collision and raycasting read
+the map, not the scene) and draw the rest as **one `InstancedMesh` per chunk**.
+
+First, the exposure test — a block with six occluding neighbors is never drawn:
 
 ```js
 const NB = [[1,0,0],[-1,0,0],[0,1,0],[0,-1,0],[0,0,1],[0,0,-1]];
@@ -209,26 +216,62 @@ function occludes(t) { return t && t !== "water" && t !== "glass" && t !== "leav
 function isHidden(x, y, z) {
   for (const [dx, dy, dz] of NB)
     if (!occludes(state.blocks.get(keyOf(x + dx, y + dy, z + dz)))) return false;
-  return true; // fully enclosed → no mesh
+  return true; // fully enclosed → no instance
 }
 ```
 
-Share one `BoxGeometry` and one material array per type across every block (a
-6-material array lets the top face differ from the sides). When a block is
-placed or broken, refresh that block's mesh **and its six neighbors'** — a
-neighbor that was buried may now be exposed, or vice-versa.
+Then the chunk mesh: one shared `BoxGeometry` and one shared material for the
+whole world, built once outside every loop, with the block color carried by
+`instanceColor`. This is Blocktopia's terrain — the whole island is one draw
+call, and the build is a `setMatrixAt` loop rather than vertex arithmetic:
 
-Raycasting and collision must read `state.blocks` (the full model), never the
-meshes — otherwise you can't hit or collide with a face that isn't currently
-meshed.
+```js
+const CUBE = new THREE.BoxGeometry(1, 1, 1);                       // built ONCE
+const TERRAIN_MAT = new THREE.MeshLambertMaterial({ color: 0xffffff }); // built ONCE; white so instanceColor shows
+const tmpM = new THREE.Matrix4(), tmpC = new THREE.Color();
+
+function buildChunkMesh(keys) {                     // keys: the chunk's resident block keys
+  const visible = [];
+  for (const k of keys) { const [x, y, z] = parseKey(k); if (!isHidden(x, y, z)) visible.push([x, y, z, state.blocks.get(k)]); }
+  const mesh = new THREE.InstancedMesh(CUBE, TERRAIN_MAT, visible.length);
+  visible.forEach(([x, y, z, type], i) => {
+    mesh.setMatrixAt(i, tmpM.makeTranslation(x + 0.5, y + 0.5, z + 0.5));
+    mesh.setColorAt(i, tmpC.setHex(BLOCK_TYPES[type].top));
+  });
+  mesh.instanceMatrix.needsUpdate = true;
+  mesh.instanceColor.needsUpdate = true;
+  mesh.frustumCulled = false;                       // a chunk's bounds are its blocks; let the fog bound distance
+  return mesh;
+}
+```
 
-For larger worlds, use Block Craft's **exposed-face chunk batching**: append
-only visible faces into a `BufferGeometry` per material per chunk, sharing
-materials across chunks. An edit dirties its chunk and any neighboring chunk
-whose boundary face changes; rebuild only those chunks and dispose their old
-geometries. Keep transparent faces in a separate material pass with deliberate
-occlusion rules. The small-world shared-cube example above remains a simpler
-starting point.
+Blocks whose *material* differs in kind — transparent water and glass, an
+emissive lava — get their own `InstancedMesh` per type sharing the same `CUBE`,
+so the count of draw calls per chunk stays "one plus the number of special
+materials present". Never mint a material per block; the material table is a
+module-level `Object` keyed by type, built once.
+
+**Edits rebuild the chunk, not the block.** When a block is placed or broken,
+mark its chunk dirty — and the neighboring chunk too when the block sits on a
+chunk boundary, because a face across the border may have just become exposed
+or buried. Each frame, rebuild at most one or two dirty chunks: `scene.remove`
+the old `InstancedMesh`, `dispose()` it, and add the fresh one. Rebuilding a
+16×16 chunk is a few thousand `setMatrixAt` calls, well under a frame. A
+just-placed block can pop in by starting its instance matrix at scale 0 and
+easing it to 1 over a few frames.
+
+Raycasting and collision must read `state.blocks` (the full model), never the
+meshes or the instance buffers — otherwise you can't hit or collide with a face
+that isn't currently drawn.
+
+For texture-heavy or very large worlds, use Block Craft's **exposed-face chunk
+batching** instead: append only the visible *faces* into a `BufferGeometry` per
+material per chunk (position, normal, uv and an index per quad), sharing
+materials across chunks. It uploads less than instancing — a buried face is
+never sent at all — and allows a different texture per face, at the cost of
+writing the six quad windings by hand. The dirty-chunk rule is identical.
+Either of these two patterns is correct; a `Mesh` per block is not, even with
+the exposure test in front of it.
 
 ## Procedural terrain: deterministic noise, layered
 
@@ -274,8 +317,9 @@ function loadChunk(cx, cz) {
     if (t === null) { state.blocks.delete(k); keys.delete(k); }
     else { state.blocks.set(k, t); keys.add(k); }
   }
-  for (const k of keys) { const [x,y,z] = parseKey(k); if (!isHidden(x,y,z)) addMesh(k, state.blocks.get(k)); }
   state.chunks.set(chunkKey(cx, cz), keys);
+  const mesh = buildChunkMesh(keys);                 // one InstancedMesh for the chunk (see Rendering)
+  scene.add(mesh); state.chunkMeshes.set(chunkKey(cx, cz), mesh);
 }
 ```
 
@@ -298,7 +342,7 @@ Each frame, figure out which chunks should be resident around the player
 (`VIEW_RADIUS` chunks in each direction), enqueue the missing ones sorted
 nearest-first, and load **exactly one per frame** so the framerate never
 stalls. Unload chunks that fall outside the radius (delete their blocks and
-meshes). Never load a whole ring in one frame.
+instanced meshes). Never load a whole ring in one frame.
 
 ## The player controller — where "Minecraft" is won or lost
 
@@ -1037,8 +1081,11 @@ None of this needs persistence — keep it purely visual and client-side:
 
 ## Performance checklist
 
-- Mesh only exposed blocks; keep buried ones in the map for collision/raycast.
-- Share one geometry + one material set across all blocks.
+- One `InstancedMesh` per chunk of exposed blocks (or Block Craft face
+  batching); keep buried ones in the map for collision/raycast.
+- Share one geometry + one material table across all blocks, built once
+  outside every loop; never a `Mesh`, geometry or material per block.
+- Edits dirty a chunk; rebuild at most a chunk or two per frame.
 - Stream one chunk per frame; unload out-of-range chunks (dispose meshes).
 - Raycast and collide against the block map, never the scene meshes.
 - Cap mobs and particles; dispose geometries/materials on unmount and on
@@ -1046,7 +1093,7 @@ None of this needs persistence — keep it purely visual and client-side:
 - `renderer.setPixelRatio(Math.min(devicePixelRatio, 2))` and a `Fog` to bound
   draw distance.
 
-That set — exposed-face meshing, per-axis collision with step-up and un-stick,
+That set — instanced exposed-block chunks, per-axis collision with step-up and un-stick,
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibes.diy/prompts",
-  "version": "14.3.32",
+  "version": "14.3.35",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -37,9 +37,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@adviser/cement": "~0.5.34",
-    "@vibes.diy/call-ai-v2": "14.3.32",
-    "@vibes.diy/identity": "14.3.32",
-    "@vibes.diy/use-vibes-types": "14.3.32",
+    "@vibes.diy/call-ai-v2": "14.3.35",
+    "@vibes.diy/identity": "14.3.35",
+    "@vibes.diy/use-vibes-types": "14.3.35",
     "arktype": "~2.2.3",
     "json-schema-faker": "~0.6.3"
   },