@vibes.diy/prompts 14.3.64 → 14.3.65

package/llms/pouf-feed.md

@@ -0,0 +1,249 @@
+# Pouf Feed
+
+A stream of short posts that people write, like and talk under: a club's news board, a family update wall, a class's shout-outs, a team's wins channel. Reach for it whenever the app's core is people posting a few sentences for each other and reacting to what others posted. Posts, likes and comments persist, so the conversation is waiting on the next visit and on every device that opens the app.
+
+Built from @vibes.diy/pouf components; persisted state lives in Fireproof. Every write surface is gated on `useVibe(dbName).can`.
+
+## The block
+
+One view with one job: the feed. The `Heading` and a muted count open the page; the composer sits on a `Card` with a `Textarea` in a `Field`, and its `Post` button is the view's one lead. Each post is its own `Card`: the author as a `ViewerTag`, a muted time, the words in `Text`, then a `Row` of quiet buttons for like and comments, each with a `label` because the visible child is an icon and a number. Opening the comments shows them indented under the post with a reply composer of their own. Deleting a post is irreversible, so it asks first with a `Confirm` wearing `tone="down"` and says it is done with a `toast`; an `Empty` stands in before the first post. A like is its own document with a deterministic `_id`, so two people liking at once never overwrite a counter. Every write waits on its `can` verdict from `useVibe("feed")`, the database the posts live in: the composer shows a `Skeleton` inside an `aria-busy` wrapper while the verdict resolves and a sentence in the app's own words when posting is closed to this visitor; a like button is disabled unless its like can be created (or, to unlike, deleted); the reply composer follows the same three states; and the delete button renders only where `can.delete(post).ok`.
+
+### `App.jsx`
+```jsx
+import React, { useState } from "react";
+import { useFireproof } from "use-fireproof";
+import { useViewer, useVibe } from "use-vibes";
+import { Button, Card, Empty, Field, Heading, Icon, IconButton, Input, Row, Skeleton, Spacer, Stack, Text, Textarea } from "@vibes.diy/pouf";
+import { Confirm, Toaster, toast } from "@vibes.diy/pouf/interactive";
+
+const when = (ms) => new Date(ms).toLocaleString([], { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+
+function Author({ handle }) {
+  const { ViewerTag } = useViewer();
+  return handle ? <ViewerTag userHandle={handle} /> : <Text>A guest</Text>;
+}
+
+function Post({ post, likes, comments, database, can, me }) {
+  const [open, setOpen] = useState(false);
+  const [reply, setReply] = useState("");
+
+  const mine = likes.find((l) => l.authorHandle === me?.userHandle);
+  // The like this visitor would write: a deterministic id, so liking twice lands on one document.
+  const likeDraft = { _id: `like:${post._id}:${me?.userHandle}`, type: "like", postId: post._id, authorHandle: me?.userHandle };
+  const canToggle = mine ? can.delete(mine) : can.create(likeDraft);
+  const canReply = can.create({ type: "comment", postId: post._id, authorHandle: me?.userHandle });
+
+  function toggleLike() {
+    if (mine) database.del(mine._id);
+    else database.put(likeDraft);
+  }
+
+  async function sendReply(e) {
+    e.preventDefault();
+    const text = reply.trim();
+    if (text === "") return;
+    await database.put({ type: "comment", postId: post._id, text, authorHandle: me?.userHandle, createdAt: Date.now() });
+    setReply("");
+  }
+
+  async function remove() {
+    // The post goes; its likes and comments go too wherever this visitor may remove them.
+    const gone = [post, ...likes, ...comments].filter((d) => can.delete(d).ok);
+    await Promise.all(gone.map((d) => database.del(d._id)));
+    toast.success("Post deleted");
+  }
+
+  return (
+    <Card>
+      <Stack gap={3}>
+        <Row gap={2} wrap={false}>
+          <Author handle={post.authorHandle} />
+          <Text size="sm" muted>
+            {when(post.createdAt)}
+          </Text>
+          <Spacer />
+          {can.delete(post).ok && (
+            <Confirm
+              title="Delete this post?"
+              body="The post is removed for everyone, along with the comments and likes you're allowed to remove. This can't be undone."
+              confirmLabel="Delete post"
+              cancelLabel="Keep it"
+              tone="down"
+              onConfirm={remove}
+            >
+              <IconButton size="sm" label="Delete post" icon={<Icon name="remove" size="sm" />} />
+            </Confirm>
+          )}
+        </Row>
+        <Text>{post.text}</Text>
+        <Row gap={2}>
+          <Button
+            size="sm"
+            variant="quiet"
+            aria-pressed={Boolean(mine)}
+            disabled={!canToggle.ok}
+            label={mine ? "Unlike this post" : "Like this post"}
+            onClick={toggleLike}
+          >
+            <Icon name={mine ? "heart-filled" : "heart"} size="sm" /> {likes.length}
+          </Button>
+          <Button
+            size="sm"
+            variant="quiet"
+            aria-expanded={open}
+            label={`${open ? "Hide" : "Show"} ${comments.length === 1 ? "1 comment" : `${comments.length} comments`}`}
+            onClick={() => setOpen((o) => !o)}
+          >
+            <Icon name="comment" size="sm" /> {comments.length}
+          </Button>
+        </Row>
+
+        {open && (
+          // Indented under the author, the way a reply nests under its post.
+          <div className="pl-10">
+            <Stack gap={3}>
+              {comments.map((c) => (
+                <Stack key={c._id} gap={1}>
+                  <Row gap={2} wrap={false}>
+                    <Author handle={c.authorHandle} />
+                    <Text size="sm" muted>
+                      {when(c.createdAt)}
+                    </Text>
+                  </Row>
+                  <Text size="sm">{c.text}</Text>
+                </Stack>
+              ))}
+              {canReply.pending ? (
+                <div aria-busy="true">
+                  <Skeleton variant="row" />
+                </div>
+              ) : !canReply.ok ? (
+                <Text size="sm" muted>
+                  Comments open up once you've joined the club.
+                </Text>
+              ) : (
+                <form onSubmit={sendReply}>
+                  <Row gap={2} wrap={false}>
+                    <div className="min-w-0 flex-1">
+                      <Input value={reply} onChange={setReply} placeholder="Write a comment" label="Your comment" autoComplete="off" />
+                    </div>
+                    <Button size="sm" variant="quiet" type="submit" disabled={reply.trim() === ""}>
+                      Reply
+                    </Button>
+                  </Row>
+                </form>
+              )}
+            </Stack>
+          </div>
+        )}
+      </Stack>
+    </Card>
+  );
+}
+
+export default function App() {
+  const { database, useLiveQuery } = useFireproof("feed");
+  const { can, me } = useVibe("feed");
+  const { docs: postDocs } = useLiveQuery("type", { key: "post" });
+  const { docs: likes } = useLiveQuery("type", { key: "like" });
+  const { docs: comments } = useLiveQuery("type", { key: "comment" });
+  const posts = [...postDocs].sort((a, b) => b.createdAt - a.createdAt);
+
+  const [draft, setDraft] = useState("");
+  const [error, setError] = useState(undefined);
+  // The verdict for the doc publish writes, carrying the same fields it stamps.
+  const canPost = can.create({ type: "post", authorHandle: me?.userHandle });
+
+  async function publish(e) {
+    e.preventDefault();
+    const text = draft.trim();
+    if (text === "") {
+      setError("Write something first.");
+      return;
+    }
+    setError(undefined);
+    await database.put({ type: "post", text, authorHandle: me?.userHandle, createdAt: Date.now() });
+    // Cleared only once the write lands, so a local failure keeps the typed words.
+    setDraft("");
+  }
+
+  return (
+    <main className="mx-auto max-w-xl px-4 py-8">
+      <Stack gap={5}>
+        <Stack gap={1}>
+          <Heading level={1}>Club news</Heading>
+          <Text muted>{posts.length === 1 ? "1 post" : `${posts.length} posts`}</Text>
+        </Stack>
+
+        {canPost.pending ? (
+          <div aria-busy="true">
+            <Skeleton variant="card" />
+          </div>
+        ) : !canPost.ok ? (
+          <Text muted>You're reading along. Posting opens up once you've joined the club.</Text>
+        ) : (
+          <Card>
+            <form onSubmit={publish} noValidate>
+              <Stack gap={3}>
+                <Field label="What's new?" error={error}>
+                  {(id, describedBy) => (
+                    <Textarea
+                      id={id}
+                      describedBy={describedBy}
+                      value={draft}
+                      onChange={(value) => {
+                        setDraft(value);
+                        if (error) setError(undefined);
+                      }}
+                      placeholder="Finished chapter four, the twist got me"
+                      rows={2}
+                      invalid={error !== undefined}
+                    />
+                  )}
+                </Field>
+                <Row justify="end">
+                  <Button type="submit">Post</Button>
+                </Row>
+              </Stack>
+            </form>
+          </Card>
+        )}
+
+        {posts.length === 0 ? (
+          <Empty icon="comment" title="No posts yet">
+            The first update you share shows up here.
+          </Empty>
+        ) : (
+          <Stack gap={4}>
+            {posts.map((post) => (
+              <Post
+                key={post._id}
+                post={post}
+                likes={likes.filter((l) => l.postId === post._id)}
+                comments={comments.filter((c) => c.postId === post._id).sort((a, b) => a.createdAt - b.createdAt)}
+                database={database}
+                can={can}
+                me={me}
+              />
+            ))}
+          </Stack>
+        )}
+      </Stack>
+      <div className="pouf-toasts">
+        <Toaster />
+      </div>
+    </main>
+  );
+}
+```
+
+## Adapting
+
+- Rename the record to the app's own noun (`update`, `shout-out`, `win`) in the `type` key, the heading and the copy; keep one document per post, per comment and per like.
+- Keep a like as its own document keyed `like:<post>:<person>`; a counter on the post loses likes when two people tap at once.
+- A photo on a post is a `_files` attachment on the post document, shown with `Figure`; a tag is a `Badge` with an explicit meaning tone.
+- Comments and likes another person wrote stay behind when a post goes if this visitor may not delete them; they never show, because the feed only lists children of posts that exist. An access rule that lets a post's author delete what sits under it clears them too.
+- Authors are always `ViewerTag` with the stored handle; never type a name or build an avatar by hand.
+- A new write surface gets its own verdict: `can.create(draft)` with the fields the write stamps, `can.edit(doc)` or `can.delete(doc)` on the document it changes, always on `useVibe` of the database it writes.
+
+Adapted from 1st-Pouf (MIT) https://1st-pouf.worksonmy.dev/r/feed.json

package/llms/pouf-game.d.ts

@@ -0,0 +1,2 @@
+import type { LlmConfig } from "./types.js";
+export declare const poufGameConfig: LlmConfig;

package/llms/pouf-game.js

@@ -0,0 +1,6 @@
+export const poufGameConfig = {
+    name: "pouf-game",
+    label: "Pouf game block",
+    description: "Turn-based game screen with health bars, inventory and saved high scores",
+};
+//# sourceMappingURL=pouf-game.js.map

package/llms/pouf-game.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pouf-game.js","sourceRoot":"","sources":["../../jsr/llms/pouf-game.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,cAAc,GAAc;IACvC,IAAI,EAAE,WAAW;IACjB,KAAK,EAAE,iBAAiB;IACxB,WAAW,EAAE,0EAA0E;CACxF,CAAC"}

package/llms/pouf-game.md

@@ -0,0 +1,273 @@
+# Pouf Game
+
+A small turn-based game screen with a scoreboard that remembers: a boss fight for friends, a kids' dungeon run, a classroom quiz battle, a quick office break game. Reach for it whenever the app's core is a short run someone plays through, with bars that move, a few items to equip and a high-score table to beat. The run itself lives in the page while it is played; each finished run that someone saves is its own score document, so the leaderboard is there on the next visit and for everyone who opens the app.
+
+Built from @vibes.diy/pouf components; persisted state lives in Fireproof. Every write surface is gated on `useVibe(dbName).can`.
+
+## The block
+
+One view with one job: play the run, then post the score. An `Eyebrow`, the `Heading` and two `Stat`s (this run's score `info`, the visitor's best `up`) open the page. The fight sits on a `Card`: the boss's health as a `Progress` toned `down`, the player's as `up` (turning `warn` when low), the spell charge as `info`, each with a muted numeric readout, and `Attack` as the view's one lead beside a quiet `Cast spell`. The boss hits back after every move it survives, a cast that only charges included, so attacking and casting both cost health and the scores spread out instead of piling up at one ceiling. The inventory is one clickable `RowCard` per item with a decorative `orange` `Blob`, its name and effect in `Text`, and a `Badge` for its state (`up` equipped, `idle` not). When the run ends the actions give way to the result: `Save score` becomes the lead, with `loading` while the write lands, and a quiet `Play again`. The leaderboard `Table` shows each player's best saved run, the player as a `ViewerTag`. Saving waits on its `can` verdict from `useVibe("arcade")`, the database the scores live in: a `Skeleton` inside an `aria-busy` wrapper while it resolves, a `Sign in to save your score` lead wired to `useViewer().requestLogin()` for a visitor who has not signed in, and a sentence in the app's own words when saving is closed. Anyone can play without signing in. The finished run lives only in the page until it is saved, so if signing in reloads the app that run is gone; the copy says so rather than promising otherwise.
+
+### `App.jsx`
+```jsx
+import React, { useState } from "react";
+import { useFireproof } from "use-fireproof";
+import { useViewer, useVibe } from "use-vibes";
+import { Badge, Blob, Button, Card, Empty, Eyebrow, Grid, Heading, Row, RowCard, Skeleton, Stack, Stat, Table, Text } from "@vibes.diy/pouf";
+import { Progress } from "@vibes.diy/pouf/interactive";
+
+const BOSS_MAX = 120;
+// The boss's counter-hit: 10 to 16 each turn, less whatever armour blocks.
+const BOSS_HIT = 10;
+const ITEMS = [
+  { id: "sword", name: "Iron sword", effect: "Hits for 14 to 19", icon: "sword", slot: "weapon", atk: 14, cost: 0 },
+  { id: "wand", name: "Clay wand", effect: "Hits for 22 to 27, costs 6 health a swing", icon: "wand", slot: "weapon", atk: 22, cost: 6 },
+  { id: "shield", name: "Oak shield", effect: "Blocks 5 of every counter-hit", icon: "shield", slot: "armor", block: 5 },
+  { id: "charm", name: "Spark charm", effect: "Each cast charges 10 more", icon: "sparkle", slot: "charm", boost: 10 },
+  { id: "potion", name: "Health potion", effect: "Restores 30 health, once", icon: "drop", slot: "potion", heal: 30 },
+];
+const FRESH = { hp: 100, boss: BOSS_MAX, charge: 0, score: 0, gear: { weapon: "sword" }, potionUsed: false };
+
+function Player({ handle }) {
+  const { ViewerTag } = useViewer();
+  return <ViewerTag userHandle={handle} />;
+}
+
+export default function App() {
+  const { database, useLiveQuery } = useFireproof("arcade");
+  const { docs: scores } = useLiveQuery("type", { key: "score" });
+  const { can, me } = useVibe("arcade");
+  const { requestLogin } = useViewer();
+
+  // The run is a draft: it lives in the page until it ends and someone saves it.
+  const [run, setRun] = useState(FRESH);
+  const [saving, setSaving] = useState(false);
+  const [savedRun, setSavedRun] = useState(undefined);
+
+  const over = run.boss <= 0 ? "won" : run.hp <= 0 ? "lost" : undefined;
+  const gearOf = (r, slot) => ITEMS.find((i) => i.id === r.gear[slot]);
+
+  // One score document per saved run; the board keeps each player's best.
+  const best = new Map();
+  for (const s of scores) if ((best.get(s.authorHandle)?.score ?? -1) < s.score) best.set(s.authorHandle, s);
+  const board = [...best.values()]
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 10)
+    .map((s, i) => ({ ...s, rank: i + 1 }));
+  const myBest = me ? best.get(me.userHandle)?.score : undefined;
+
+  // The verdict for the doc saveScore writes, carrying the same fields it stamps.
+  const canSave = can.create({ type: "score", authorHandle: me?.userHandle });
+
+  // The boss strikes back after every move it survives, so neither move is free;
+  // winning pays a bonus for the health left over. The dice are rolled before
+  // the update so it stays pure.
+  function endTurn(r, selfCost, roll) {
+    if (r.boss === 0) return { ...r, score: r.score + 500 + r.hp * 10 };
+    const counter = Math.max(2, BOSS_HIT + roll - (gearOf(r, "armor")?.block ?? 0));
+    return { ...r, hp: Math.max(0, r.hp - counter - selfCost) };
+  }
+
+  // Every move reads the latest run through setRun((r) => …), so two quick
+  // clicks play two turns instead of one overwriting the other, and a move made
+  // after the fight ended changes nothing.
+  function attack() {
+    const roll = Math.floor(Math.random() * 6);
+    const counter = Math.floor(Math.random() * 7);
+    setRun((r) => {
+      if (r.boss <= 0 || r.hp <= 0) return r;
+      const weapon = gearOf(r, "weapon");
+      const hit = (weapon?.atk ?? 8) + roll;
+      return endTurn({ ...r, boss: Math.max(0, r.boss - hit), score: r.score + hit * 10 }, weapon?.cost ?? 0, counter);
+    });
+  }
+
+  function cast() {
+    const blast = 40 + Math.floor(Math.random() * 11);
+    const counter = Math.floor(Math.random() * 7);
+    setRun((r) => {
+      if (r.boss <= 0 || r.hp <= 0) return r;
+      const charge = r.charge + 25 + (gearOf(r, "charm")?.boost ?? 0);
+      // Charging spends the turn, so the boss still hits back.
+      if (charge < 100) return endTurn({ ...r, charge }, 0, counter);
+      // A full charge fires the spell: a big hit that scores like any other damage.
+      return endTurn({ ...r, charge: 0, boss: Math.max(0, r.boss - blast), score: r.score + blast * 10 }, 0, counter);
+    });
+  }
+
+  function toggleItem(item) {
+    setRun((r) => {
+      if (item.slot === "potion") return r.potionUsed ? r : { ...r, potionUsed: true, hp: Math.min(100, r.hp + item.heal) };
+      const on = r.gear[item.slot] === item.id;
+      return { ...r, gear: { ...r.gear, [item.slot]: on ? undefined : item.id } };
+    });
+  }
+
+  function playAgain() {
+    setRun(FRESH);
+    setSavedRun(undefined);
+  }
+
+  async function saveScore() {
+    setSaving(true);
+    try {
+      await database.put({ type: "score", score: run.score, result: over, authorHandle: me?.userHandle, createdAt: Date.now() });
+      setSavedRun(run);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  let ending;
+  if (savedRun === run) ending = <Text muted>Saved. Your run is on the board.</Text>;
+  else if (canSave.pending)
+    ending = (
+      <div aria-busy="true">
+        <Skeleton variant="row" />
+      </div>
+    );
+  else if (!me)
+    ending = (
+      <Stack gap={2}>
+        <Text size="sm" muted>
+          Sign in to put this run on the board. Signing in may start a fresh run.
+        </Text>
+        <Button onClick={requestLogin}>Sign in to save your score</Button>
+      </Stack>
+    );
+  else if (!canSave.ok) ending = <Text muted>The board is closed to new scores right now. Play on for fun.</Text>;
+  else
+    ending = (
+      <Button loading={saving} onClick={saveScore}>
+        Save score
+      </Button>
+    );
+
+  return (
+    <main className="mx-auto max-w-3xl px-4 py-8">
+      <Stack gap={5}>
+        <Stack gap={1}>
+          <Eyebrow>Cushion Caverns</Eyebrow>
+          <Heading level={1}>Boss fight</Heading>
+        </Stack>
+
+        <Grid cols={2}>
+          <Stat label="This run" value={run.score.toLocaleString()} icon="target" tone="info" />
+          <Stat label="Your best" value={myBest === undefined ? "—" : myBest.toLocaleString()} icon="trophy" tone="up" />
+        </Grid>
+
+        <Card>
+          <Stack gap={4}>
+            <Stack gap={2}>
+              <Row justify="between">
+                <Text>The Clay Golem</Text>
+                <Text num muted>
+                  {run.boss} / {BOSS_MAX}
+                </Text>
+              </Row>
+              <Progress value={run.boss} max={BOSS_MAX} tone="down" label="Boss health" />
+            </Stack>
+            <Stack gap={2}>
+              <Row justify="between">
+                <Text>Your health</Text>
+                <Text num muted>
+                  {run.hp} / 100
+                </Text>
+              </Row>
+              <Progress value={run.hp} tone={run.hp < 30 ? "warn" : "up"} label="Your health" />
+            </Stack>
+            <Stack gap={2}>
+              <Row justify="between">
+                <Text>Spell charge</Text>
+                <Text num muted>
+                  {run.charge} / 100
+                </Text>
+              </Row>
+              <Progress value={run.charge} tone="info" label="Spell charge" />
+            </Stack>
+
+            {over ? (
+              <Stack gap={3}>
+                <Heading level={2}>{over === "won" ? "The golem crumbles!" : "Knocked out"}</Heading>
+                <Row gap={2}>
+                  {ending}
+                  <Button variant="quiet" onClick={playAgain}>
+                    Play again
+                  </Button>
+                </Row>
+              </Stack>
+            ) : (
+              <Row gap={2}>
+                <Button onClick={attack}>Attack</Button>
+                <Button variant="quiet" onClick={cast}>
+                  Cast spell
+                </Button>
+              </Row>
+            )}
+          </Stack>
+        </Card>
+
+        <Card>
+          <Stack gap={4}>
+            <Heading level={2}>Inventory</Heading>
+            <Stack gap={2}>
+              {ITEMS.map((item) => {
+                const used = item.slot === "potion" && run.potionUsed;
+                const equipped = item.slot !== "potion" && run.gear[item.slot] === item.id;
+                const state = item.slot === "potion" ? (used ? "Used" : "Use") : equipped ? "Equipped" : "Equip";
+                return (
+                  <RowCard key={item.id} onClick={used || over ? undefined : () => toggleItem(item)}>
+                    <Row justify="between" wrap={false}>
+                      <Row gap={3} wrap={false}>
+                        <Blob icon={item.icon} tone="orange" size="sm" />
+                        <Stack gap={1}>
+                          <Text>{item.name}</Text>
+                          <Text size="sm" muted>
+                            {item.effect}
+                          </Text>
+                        </Stack>
+                      </Row>
+                      <Badge tone={equipped ? "up" : "idle"}>{state}</Badge>
+                    </Row>
+                  </RowCard>
+                );
+              })}
+            </Stack>
+          </Stack>
+        </Card>
+
+        <Card>
+          <Stack gap={4}>
+            <Heading level={2}>Leaderboard</Heading>
+            {board.length === 0 ? (
+              <Empty icon="trophy" title="No scores yet">
+                Finish a run and save it to take the top spot.
+              </Empty>
+            ) : (
+              <Table
+                rows={board}
+                getKey={(s) => s._id}
+                columns={[
+                  { key: "rank", header: "#", render: (s) => <Text num>{s.rank}</Text> },
+                  { key: "player", header: "Player", render: (s) => <Player handle={s.authorHandle} /> },
+                  { key: "score", header: "Best run", align: "right", mono: true, render: (s) => <Text num>{s.score.toLocaleString()}</Text> },
+                ]}
+              />
+            )}
+          </Stack>
+        </Card>
+      </Stack>
+    </main>
+  );
+}
+```
+
+## Adapting
+
+- Change the fight, not the shape: the run is one state object, every move updates it through `setRun((r) => …)` and ends in `endTurn` so the boss answers it, and the run only touches the database when it is saved. Keep every move costing something; a free move becomes the only move and every score ties at its ceiling.
+- Keep one score document per saved run and compute the board from them (best per player, top ten); a single "high score" document that every player rewrites loses scores when two runs finish at once.
+- Store the facts of the run that a board might sort or filter on (`score`, `result`, a `level` or a `mode`) on the score document, and show them as extra `Table` columns with `sort`.
+- Player names are always `ViewerTag` with the stored `authorHandle`; never type a name onto a score.
+- A new write surface gets its own verdict: `can.create(draft)` with the fields the write stamps, `can.edit(doc)` or `can.delete(doc)` on the document it changes, always on `useVibe` of the database it writes.
+
+Adapted from 1st-Pouf (MIT) https://1st-pouf.worksonmy.dev/r/game.json

package/llms/pouf-inbox.d.ts

@@ -0,0 +1,2 @@
+import type { LlmConfig } from "./types.js";
+export declare const poufInboxConfig: LlmConfig;

package/llms/pouf-inbox.js

@@ -0,0 +1,6 @@
+export const poufInboxConfig = {
+    name: "pouf-inbox",
+    label: "Pouf inbox block",
+    description: "Shared inbox to send notes, search, read, reply and archive",
+};
+//# sourceMappingURL=pouf-inbox.js.map

package/llms/pouf-inbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pouf-inbox.js","sourceRoot":"","sources":["../../jsr/llms/pouf-inbox.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,eAAe,GAAc;IACxC,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,kBAAkB;IACzB,WAAW,EAAE,6DAA6D;CAC3E,CAAC"}