@vibes.diy/prompts 14.3.64 → 14.3.65

package/llms/pouf-settings.md

@@ -0,0 +1,220 @@
+# Pouf Settings
+
+A settings screen for each person's own preferences: the display name in a habit tracker, reminder emails for a reading log, a compact or comfortable layout, how loud an alert should be. Reach for it whenever the app lets someone tune how it treats them and expects those choices to stick. Each person's settings persist as their own document, so a choice made on the phone is there on the laptop.
+
+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: change your settings and save them. An `Eyebrow`, the `Heading` and a status `Badge` open it (`warn` while there are unsaved changes, `up` once saved). A `Card` holds `Tabs` (`tone="info"`) with two panels: Profile, with a display name `Input`, a bio `Textarea` and a `RadioGroup` for density, each in a `Field`; and Notifications, with two `Switch`es separated by a `Separator` and a `Slider` for alert volume. A save bar closes the card: a quiet `Cancel` that puts back the last saved values and `Save changes`, the view's one lead, which shows `loading` while the write lands. Both buttons wake only when something changed, the edit is checked in plain state (each error on its own `Field`, its control `invalid`), and a `beforeunload` guard warns before an unsaved change is lost. A person's settings are one document with a deterministic `_id` (`settings:<handle>`), written in place because only its owner ever writes it. The save waits on its `can` verdict from `useVibe("settings")`: `can.create` of the draft before the first save, `can.edit` of the saved document after; a `Skeleton` inside an `aria-busy` wrapper stands in while the verdict resolves, a sentence in the app's own words when saving is closed, and a visitor who has not signed in is asked to with a button wired to `useViewer().requestLogin()`, because settings belong to a person.
+
+### `App.jsx`
+```jsx
+import React, { useEffect, useState } from "react";
+import { useFireproof } from "use-fireproof";
+import { useViewer, useVibe } from "use-vibes";
+import { Badge, Button, Card, Eyebrow, Field, Heading, Input, Row, Skeleton, Stack, Text, Textarea } from "@vibes.diy/pouf";
+import { RadioGroup, Separator, Slider, Switch, Tabs, Toaster, toast } from "@vibes.diy/pouf/interactive";
+
+const DEFAULTS = { name: "", bio: "", density: "comfortable", emailNotif: true, pushNotif: false, volume: 60 };
+const KEYS = Object.keys(DEFAULTS);
+const DENSITY = [
+  { value: "comfortable", label: "Comfortable" },
+  { value: "compact", label: "Compact" },
+];
+
+const pick = (doc) => Object.fromEntries(KEYS.map((k) => [k, doc?.[k] ?? DEFAULTS[k]]));
+const same = (a, b) => KEYS.every((k) => a[k] === b[k]);
+
+function SettingsForm({ saved, database, can, me }) {
+  const base = pick(saved);
+  const [form, setForm] = useState(base);
+  const [tab, setTab] = useState("profile");
+  const [errors, setErrors] = useState({});
+  const [saving, setSaving] = useState(false);
+  const dirty = !same(form, base);
+  // The document this save writes: one per person, so every save lands on the same one.
+  const draft = { _id: `settings:${me.userHandle}`, type: "settings", authorHandle: me.userHandle };
+  const verdict = saved ? can.edit(saved) : can.create(draft);
+
+  useEffect(() => {
+    if (!dirty) return;
+    const warn = (e) => e.preventDefault();
+    window.addEventListener("beforeunload", warn);
+    return () => window.removeEventListener("beforeunload", warn);
+  }, [dirty]);
+
+  const set = (key) => (value) => {
+    setForm((f) => ({ ...f, [key]: value }));
+    if (errors[key]) setErrors((e) => ({ ...e, [key]: undefined }));
+  };
+
+  async function save(e) {
+    e.preventDefault();
+    const found = {
+      name: form.name.trim() === "" ? "Add the name you'd like to show." : undefined,
+      bio: form.bio.length > 160 ? "Keep the bio to 160 characters." : undefined,
+    };
+    setErrors(found);
+    if (found.name || found.bio) {
+      setTab("profile");
+      return;
+    }
+    setSaving(true);
+    try {
+      const written = { ...saved, ...draft, ...form, name: form.name.trim(), updatedAt: Date.now() };
+      await database.put(written);
+      // Match the form to what was stored (trimmed), so it reads clean after saving.
+      setForm(pick(written));
+      toast.success("Settings saved");
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  if (verdict.pending)
+    return (
+      <div aria-busy="true">
+        <Skeleton variant="card" />
+      </div>
+    );
+  if (!verdict.ok) return <Text muted>Settings here are kept by the people this app is shared with.</Text>;
+
+  const profile = (
+    <Stack gap={4}>
+      <Field label="Display name" error={errors.name}>
+        {(id, describedBy) => (
+          <Input id={id} describedBy={describedBy} value={form.name} onChange={set("name")} autoComplete="nickname" invalid={errors.name !== undefined} />
+        )}
+      </Field>
+      <Field label="Bio" hint="A sentence or two." error={errors.bio}>
+        {(id, describedBy) => (
+          <Textarea id={id} describedBy={describedBy} value={form.bio} onChange={set("bio")} rows={3} invalid={errors.bio !== undefined} />
+        )}
+      </Field>
+      <RadioGroup label="Density" value={form.density} onChange={set("density")} options={DENSITY} />
+    </Stack>
+  );
+
+  const notifications = (
+    <Stack gap={4}>
+      <Row justify="between" wrap={false}>
+        <Stack gap={1}>
+          <Text>Email reminders</Text>
+          <Text size="sm" muted>
+            A nudge when something is due.
+          </Text>
+        </Stack>
+        <Switch label="Email reminders" checked={form.emailNotif} onChange={set("emailNotif")} />
+      </Row>
+      <Separator />
+      <Row justify="between" wrap={false}>
+        <Stack gap={1}>
+          <Text>Push notifications</Text>
+          <Text size="sm" muted>
+            Sent to your devices right away.
+          </Text>
+        </Stack>
+        <Switch label="Push notifications" checked={form.pushNotif} onChange={set("pushNotif")} />
+      </Row>
+      <Separator />
+      <Stack gap={2}>
+        <Row justify="between">
+          <Text>Alert volume</Text>
+          <Text size="sm" muted num>
+            {form.volume}
+          </Text>
+        </Row>
+        <Slider label="Alert volume" value={[form.volume]} onChange={(value) => set("volume")(value[0] ?? 0)} />
+      </Stack>
+    </Stack>
+  );
+
+  return (
+    <Stack gap={5}>
+      <Row justify="between" align="top">
+        <Stack gap={1}>
+          <Eyebrow>Account</Eyebrow>
+          <Heading level={1}>Settings</Heading>
+        </Stack>
+        {dirty ? <Badge tone="warn">Unsaved changes</Badge> : saved ? <Badge tone="up">Saved</Badge> : null}
+      </Row>
+      <Card>
+        <form onSubmit={save} noValidate>
+          <Stack gap={5}>
+            <Tabs
+              tone="info"
+              value={tab}
+              onChange={setTab}
+              tabs={[
+                { value: "profile", label: "Profile", content: profile },
+                { value: "notifications", label: "Notifications", content: notifications },
+              ]}
+            />
+            <Separator />
+            <Row gap={2} justify="end">
+              <Button
+                variant="quiet"
+                disabled={!dirty || saving}
+                onClick={() => {
+                  setForm(base);
+                  setErrors({});
+                }}
+              >
+                Cancel
+              </Button>
+              <Button type="submit" disabled={!dirty} loading={saving}>
+                Save changes
+              </Button>
+            </Row>
+          </Stack>
+        </form>
+      </Card>
+    </Stack>
+  );
+}
+
+export default function App() {
+  const { database, useLiveQuery } = useFireproof("settings");
+  const { docs } = useLiveQuery("type", { key: "settings" });
+  const { can, me, ready } = useVibe("settings");
+  const { requestLogin } = useViewer();
+  const saved = me ? docs.find((d) => d._id === `settings:${me.userHandle}`) : undefined;
+
+  return (
+    <main className="mx-auto max-w-2xl px-4 py-8">
+      {!ready ? (
+        <div aria-busy="true">
+          <Skeleton variant="card" />
+        </div>
+      ) : !me ? (
+        <Card>
+          <Stack gap={3}>
+            <Heading level={1}>Settings</Heading>
+            <Text muted>Your settings follow you once you're signed in, on every device.</Text>
+            <Row justify="end">
+              <Button onClick={requestLogin}>Sign in to keep your settings</Button>
+            </Row>
+          </Stack>
+        </Card>
+      ) : (
+        // Re-keyed when the saved copy first arrives, so the form starts from it.
+        <SettingsForm key={saved ? "saved" : "new"} saved={saved} database={database} can={can} me={me} />
+      )}
+      <div className="pouf-toasts">
+        <Toaster />
+      </div>
+    </main>
+  );
+}
+```
+
+## Adapting
+
+- Add a setting by adding its key and default to `DEFAULTS` and its control to a panel; the dirty check, the quiet Cancel and the `Save changes` lead all follow from that one object.
+- A yes/no that applies on its own is a `Switch`; a choice of a few is a `RadioGroup` or `Select`; a number in a range is a `Slider` with `min`/`max`.
+- Settings the whole group shares (a club's name, a team's currency) are one owner-kept document gated on its own `can.edit`, not a field on each person's settings.
+- Save writes the whole form, so a change made on another device while this form is open is overwritten by it; for settings several devices edit at once, reload the form from the saved document when it changes and the form is clean.
+- 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/settings.json

package/llms/pouf-storefront.d.ts

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

package/llms/pouf-storefront.js

@@ -0,0 +1,6 @@
+export const poufStorefrontConfig = {
+    name: "pouf-storefront",
+    label: "Pouf storefront block",
+    description: "Product grid with filters, a shopping bag and checkout, no payments",
+};
+//# sourceMappingURL=pouf-storefront.js.map

package/llms/pouf-storefront.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pouf-storefront.js","sourceRoot":"","sources":["../../jsr/llms/pouf-storefront.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,oBAAoB,GAAc;IAC7C,IAAI,EAAE,iBAAiB;IACvB,KAAK,EAAE,uBAAuB;IAC9B,WAAW,EAAE,qEAAqE;CACnF,CAAC"}

package/llms/pouf-storefront.md

@@ -0,0 +1,293 @@
+# Pouf Storefront
+
+A small shop: product cards to browse, a category filter and a search, a bag that adds things up, and a checkout that places the order. It fits a potter's ceramics, a bakery's preorders, a club's merch table or a school fair's stall. Reach for it whenever the app's core is a short catalogue that people pick from and then order. The catalogue stays inline in the code, and the bag lives in the page while someone shops. Each placed order persists as its own document, so the shop can see what to make and the buyer can see what they ordered. It records orders only; taking payment is a separate integration this block does not pretend to do.
+
+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: fill the bag and place the order. A `Navbar` carries the brand and a quiet bag button with a live count, and the `Heading` puts an `orange` `Highlight` on one word beside a muted line. A `Segmented` category filter (`tone="info"`) and a search `Input` in a `Field` sit above a `Grid cols="sidebar"`: on the main side a two-column grid of product `Card`s, each with a decorative `orange` `Blob`, an `info` `Badge` for "New" or "Bestseller", the price in numeric `Text` and a quiet `Add to bag` (an `Empty` stands in when nothing matches); on the side the bag's `Card`, one line per product with its total and `IconButton`s to take one away or add one, then the subtotal, shipping and total. `Place order` is the view's one lead; it shows `loading` while the write lands, and the bag empties only after it does. An order is one document holding a snapshot of each line's name, price and quantity, the totals and the buyer's handle, so a later price change never rewrites an order already placed; the person's own orders list under the bag, each with a `Badge` for its status (`info` received, `warn` ready to collect, `up` collected). Checkout waits on its `can` verdict from `useVibe("shop")`: a `Skeleton` inside an `aria-busy` wrapper while it resolves, a sentence in the app's own words when ordering is closed, and for a visitor who has not signed in a `Sign in to place your order` lead wired to `useViewer().requestLogin()`, with the bag they filled kept in place. Sign-in is required here, unlike a local-first note, because a signed-out write stays on the device until sign-in: an order placed that way would never reach the shop.
+
+### `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,
+  Field,
+  Grid,
+  Heading,
+  Highlight,
+  Icon,
+  IconButton,
+  Input,
+  Navbar,
+  Row,
+  Segmented,
+  Skeleton,
+  Spacer,
+  Stack,
+  Text,
+} from "@vibes.diy/pouf";
+import { Separator, Toaster, toast } from "@vibes.diy/pouf/interactive";
+
+const PRODUCTS = [
+  { id: "mug", name: "Speckled mug", blurb: "Holds a generous coffee, glazed oatmeal.", price: 28, category: "table", icon: "drop", badge: "Bestseller" },
+  { id: "bowl", name: "Nesting bowls", blurb: "A set of three for salads and snacks.", price: 64, category: "table", icon: "home" },
+  { id: "vase", name: "Bud vase", blurb: "A small home for a few stems.", price: 36, category: "home", icon: "sparkle", badge: "New" },
+  { id: "planter", name: "Hanging planter", blurb: "Thrown stoneware with a jute cord.", price: 48, category: "home", icon: "sun" },
+  { id: "dish", name: "Ring dish", blurb: "A shallow dish for keys and rings.", price: 18, category: "gifts", icon: "heart" },
+  { id: "card", name: "Gift card", blurb: "Let them pick their own favourite.", price: 50, category: "gifts", icon: "tag" },
+];
+const CATEGORIES = [
+  { value: "all", label: "All" },
+  { value: "table", label: "Table" },
+  { value: "home", label: "Home" },
+  { value: "gifts", label: "Gifts" },
+];
+const MONEY = new Intl.NumberFormat(undefined, { style: "currency", currency: "USD" });
+const FREE_SHIPPING = 100;
+const ORDER_STATUS = {
+  received: { label: "Received", tone: "info" },
+  ready: { label: "Ready to collect", tone: "warn" },
+  collected: { label: "Collected", tone: "up" },
+};
+const plural = (n, one, many) => (n === 1 ? `1 ${one}` : `${n} ${many}`);
+
+export default function App() {
+  const { database, useLiveQuery } = useFireproof("shop");
+  const { docs: orders } = useLiveQuery("type", { key: "order" });
+  const { can, me } = useVibe("shop");
+  const { requestLogin } = useViewer();
+
+  const [category, setCategory] = useState("all");
+  const [query, setQuery] = useState("");
+  // The bag is a draft: it lives in the page until the order is placed.
+  const [bag, setBag] = useState({});
+  const [placing, setPlacing] = useState(false);
+
+  const needle = query.trim().toLowerCase();
+  const visible = PRODUCTS.filter(
+    (p) => (category === "all" || p.category === category) && (needle === "" || `${p.name} ${p.blurb}`.toLowerCase().includes(needle))
+  );
+  const lines = PRODUCTS.filter((p) => (bag[p.id] ?? 0) > 0).map((p) => ({ productId: p.id, name: p.name, price: p.price, qty: bag[p.id] }));
+  const count = lines.reduce((n, l) => n + l.qty, 0);
+  const subtotal = lines.reduce((n, l) => n + l.price * l.qty, 0);
+  const shipping = subtotal === 0 || subtotal >= FREE_SHIPPING ? 0 : 8;
+  const mine = me ? orders.filter((o) => o.authorHandle === me.userHandle).sort((a, b) => b.createdAt - a.createdAt) : [];
+
+  // The verdict for the order placeOrder writes, carrying the same fields it stamps.
+  const orderDraft = { type: "order", status: "received", authorHandle: me?.userHandle };
+  const canOrder = can.create(orderDraft);
+
+  function change(id, delta) {
+    setBag((b) => {
+      const qty = Math.max(0, (b[id] ?? 0) + delta);
+      const { [id]: _gone, ...rest } = b;
+      return qty === 0 ? rest : { ...rest, [id]: qty };
+    });
+  }
+
+  async function placeOrder() {
+    setPlacing(true);
+    try {
+      await database.put({ ...orderDraft, lines, subtotal, shipping, total: subtotal + shipping, createdAt: Date.now() });
+      // Emptied only once the order lands, so a local failure keeps the bag.
+      setBag({});
+      toast.success("Order placed. We'll be in touch about collection.");
+    } finally {
+      setPlacing(false);
+    }
+  }
+
+  let checkout;
+  if (canOrder.pending)
+    checkout = (
+      <div aria-busy="true">
+        <Skeleton variant="row" />
+      </div>
+    );
+  else if (!me)
+    checkout = (
+      <Button block disabled={count === 0} onClick={requestLogin}>
+        Sign in to place your order
+      </Button>
+    );
+  else if (!canOrder.ok) checkout = <Text muted>The shop isn't taking orders right now. Check back soon.</Text>;
+  else
+    checkout = (
+      <Button block disabled={count === 0} loading={placing} onClick={placeOrder}>
+        Place order
+      </Button>
+    );
+
+  return (
+    <main className="mx-auto max-w-6xl px-4 py-6">
+      <Stack gap={6}>
+        <Navbar
+          brand={
+            <Row gap={2} wrap={false}>
+              <Blob icon="sparkle" tone="orange" size="sm" />
+              <Text>Kiln &amp; Co.</Text>
+            </Row>
+          }
+          actions={
+            <Button size="sm" variant="quiet" onClick={() => document.getElementById("bag")?.scrollIntoView({ block: "nearest" })}>
+              <Icon name="cart" size="sm" />
+              Bag ({count})
+            </Button>
+          }
+        />
+
+        <Stack gap={2}>
+          <Eyebrow>Handmade in small batches</Eyebrow>
+          <Heading level={1}>
+            Pots for <Highlight tone="orange">everyday</Highlight> things.
+          </Heading>
+          <Text muted>Free shipping over {MONEY.format(FREE_SHIPPING)}. Every piece is thrown and glazed by hand.</Text>
+        </Stack>
+
+        <Row justify="between" align="top">
+          <Segmented label="Category" tone="info" value={category} onChange={setCategory} options={CATEGORIES} />
+          <Field label="Search the shop">
+            {(id, describedBy) => <Input id={id} describedBy={describedBy} value={query} onChange={setQuery} inputMode="search" placeholder="Mug, vase…" />}
+          </Field>
+        </Row>
+
+        <Grid cols="sidebar" gap={5}>
+          {visible.length === 0 ? (
+            <Empty icon="search" title="Nothing matches">
+              Try another word or a different category.
+            </Empty>
+          ) : (
+            <Grid cols={2} gap={4}>
+              {visible.map((p) => (
+                <Card key={p.id}>
+                  <Stack gap={3}>
+                    <Row justify="between" align="top">
+                      <Blob icon={p.icon} tone="orange" />
+                      {p.badge && <Badge tone="info">{p.badge}</Badge>}
+                    </Row>
+                    <Stack gap={1}>
+                      <Heading level={3}>{p.name}</Heading>
+                      <Text size="sm" muted>
+                        {p.blurb}
+                      </Text>
+                    </Stack>
+                    <Row justify="between">
+                      <Text num>{MONEY.format(p.price)}</Text>
+                      <Button size="sm" variant="quiet" onClick={() => change(p.id, 1)}>
+                        Add to bag
+                      </Button>
+                    </Row>
+                  </Stack>
+                </Card>
+              ))}
+            </Grid>
+          )}
+
+          <div id="bag">
+            <Stack gap={4}>
+              <Card>
+                <Stack gap={4}>
+                  <Row justify="between">
+                    <Heading level={2}>Your bag</Heading>
+                    <Text size="sm" muted>
+                      {plural(count, "item", "items")}
+                    </Text>
+                  </Row>
+                  {lines.length === 0 ? (
+                    <Empty icon="cart" title="Your bag is empty">
+                      Add something you love and it waits here.
+                    </Empty>
+                  ) : (
+                    <Stack gap={3}>
+                      {lines.map((l) => (
+                        <Row key={l.productId} gap={2} wrap={false}>
+                          <Stack gap={1}>
+                            <Text truncate>{l.name}</Text>
+                            <Text size="sm" muted num>
+                              {MONEY.format(l.price * l.qty)}
+                            </Text>
+                          </Stack>
+                          <Spacer />
+                          <IconButton size="sm" variant="quiet" icon={<Icon name="remove" size="sm" />} label={`One fewer ${l.name}`} onClick={() => change(l.productId, -1)} />
+                          <Text num>{l.qty}</Text>
+                          <IconButton size="sm" variant="quiet" icon={<Icon name="add" size="sm" />} label={`One more ${l.name}`} onClick={() => change(l.productId, 1)} />
+                        </Row>
+                      ))}
+                      <Separator />
+                      <Row justify="between">
+                        <Text size="sm" muted>
+                          Subtotal
+                        </Text>
+                        <Text size="sm" num>
+                          {MONEY.format(subtotal)}
+                        </Text>
+                      </Row>
+                      <Row justify="between">
+                        <Text size="sm" muted>
+                          Shipping
+                        </Text>
+                        <Text size="sm" num>
+                          {shipping === 0 ? "Free" : MONEY.format(shipping)}
+                        </Text>
+                      </Row>
+                      <Row justify="between">
+                        <Text>Total</Text>
+                        <Text num>{MONEY.format(subtotal + shipping)}</Text>
+                      </Row>
+                    </Stack>
+                  )}
+                  {checkout}
+                  <Text size="sm" muted>
+                    No payment is taken here. We confirm your order and arrange payment when you collect.
+                  </Text>
+                </Stack>
+              </Card>
+
+              {mine.length > 0 && (
+                <Card variant="tight">
+                  <Stack gap={3}>
+                    <Heading level={3}>Your orders</Heading>
+                    {mine.map((o) => (
+                      <Row key={o._id} justify="between" wrap={false}>
+                        <Stack gap={1}>
+                          <Text num>{MONEY.format(o.total)}</Text>
+                          <Text size="sm" muted>
+                            {new Date(o.createdAt).toLocaleDateString()} · {plural(o.lines.reduce((n, l) => n + l.qty, 0), "item", "items")}
+                          </Text>
+                        </Stack>
+                        <Badge tone={ORDER_STATUS[o.status]?.tone ?? "info"}>{ORDER_STATUS[o.status]?.label ?? "Received"}</Badge>
+                      </Row>
+                    ))}
+                  </Stack>
+                </Card>
+              )}
+            </Stack>
+          </div>
+        </Grid>
+      </Stack>
+      <div className="pouf-toasts">
+        <Toaster />
+      </div>
+    </main>
+  );
+}
+```
+
+## Adapting
+
+- Swap `PRODUCTS` for the shop's own catalogue; a catalogue the owner edits in the app becomes `product` documents behind an owner-only `can.create`, read with `useLiveQuery("type", { key: "product" })`.
+- Keep the order a snapshot of names, prices and quantities: an order is a record of what was agreed, so a later price change must not touch it.
+- Orders hold who bought what, so `access.js` and the app's sharing should keep each order between its buyer and the shop: a buyer creates and reads their own, the shop reads them all and moves each through `ORDER_STATUS` behind `can.edit(order)`.
+- Real payment is a separate integration with its own provider; until there is one, keep the "no payment is taken here" line truthful.
+- 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/storefront.json

package/llms/pouf-support.d.ts

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

package/llms/pouf-support.js

@@ -0,0 +1,6 @@
+export const poufSupportConfig = {
+    name: "pouf-support",
+    label: "Pouf support block",
+    description: "Support desk to log tickets, filter the queue, reply, resolve",
+};
+//# sourceMappingURL=pouf-support.js.map

package/llms/pouf-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pouf-support.js","sourceRoot":"","sources":["../../jsr/llms/pouf-support.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,iBAAiB,GAAc;IAC1C,IAAI,EAAE,cAAc;IACpB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EAAE,+DAA+D;CAC7E,CAAC"}