@toa.io/extensions.configuration 1.0.0-alpha.274 → 1.0.0-alpha.276

package/ui/.agents/skills/shadcn-svelte/rules/styling.md

@@ -1,195 +0,0 @@
-# Styling & Customization
-
-See [customization.md](../customization.md) for theming, CSS variables, and adding custom colors.
-
-## Contents
-
-- Semantic colors
-- Built-in variants first
-- class for layout only
-- No space-x-_ / space-y-_
-- Prefer size-_ over w-_ h-\* when equal
-- Prefer truncate shorthand
-- No manual dark: color overrides
-- Use cn() for conditional classes
-- No manual z-index on overlay components
-
----
-
-## Semantic colors
-
-**Incorrect:**
-
-```svelte
-<div class="bg-blue-500 text-white">
-  <p class="text-gray-600">Secondary text</p>
-</div>
-```
-
-**Correct:**
-
-```svelte
-<div class="bg-primary text-primary-foreground">
-  <p class="text-muted-foreground">Secondary text</p>
-</div>
-```
-
----
-
-## No raw color values for status/state indicators
-
-For positive, negative, or status indicators, use Badge variants, semantic tokens like `text-destructive`, or define custom CSS variables — don't reach for raw Tailwind colors.
-
-**Incorrect:**
-
-```svelte
-<span class="text-emerald-600">+20.1%</span>
-<span class="text-green-500">Active</span>
-<span class="text-red-600">-3.2%</span>
-```
-
-**Correct:**
-
-```svelte
-<script lang="ts">
-  import { Badge } from "$lib/components/ui/badge";
-</script>
-
-<Badge variant="secondary">+20.1%</Badge>
-<Badge>Active</Badge>
-<span class="text-destructive">-3.2%</span>
-```
-
-If you need a success/positive color that doesn't exist as a semantic token, use a Badge variant or ask the user about adding a custom CSS variable to the theme (see [customization.md](../customization.md)).
-
----
-
-## Built-in variants first
-
-**Incorrect:**
-
-```svelte
-<script lang="ts">
-  import { Button } from "$lib/components/ui/button";
-</script>
-
-<Button class="border-input hover:bg-accent border bg-transparent"
-  >Click me</Button
->
-```
-
-**Correct:**
-
-```svelte
-<script lang="ts">
-  import { Button } from "$lib/components/ui/button";
-</script>
-
-<Button variant="outline">Click me</Button>
-```
-
----
-
-## class for layout only
-
-Use `class` for layout (e.g. `max-w-md`, `mx-auto`, `mt-4`), **not** for overriding component colors or typography. To change colors, use semantic tokens, built-in variants, or CSS variables.
-
-**Incorrect:**
-
-```svelte
-<script lang="ts">
-  import * as Card from "$lib/components/ui/card";
-</script>
-
-<Card.Root class="bg-blue-100 font-bold text-blue-900">
-  <Card.Content>Dashboard</Card.Content>
-</Card.Root>
-```
-
-**Correct:**
-
-```svelte
-<script lang="ts">
-  import * as Card from "$lib/components/ui/card";
-</script>
-
-<Card.Root class="mx-auto max-w-md">
-  <Card.Content>Dashboard</Card.Content>
-</Card.Root>
-```
-
-To customize a component's appearance, prefer these approaches in order:
-
-1. **Built-in variants** — `variant="outline"`, `variant="destructive"`, etc.
-2. **Semantic color tokens** — `bg-primary`, `text-muted-foreground`.
-3. **CSS variables** — define custom colors in the global CSS file (see [customization.md](../customization.md)).
-
----
-
-## No space-x-_ / space-y-_
-
-Use `gap-*` instead. `space-y-4` → `flex flex-col gap-4`. `space-x-2` → `flex gap-2`.
-
-```svelte
-<script lang="ts">
-  import { Input } from "$lib/components/ui/input";
-  import { Button } from "$lib/components/ui/button";
-</script>
-
-<div class="flex flex-col gap-4">
-  <Input />
-  <Input />
-  <Button>Submit</Button>
-</div>
-```
-
----
-
-## Prefer size-_ over w-_ h-\* when equal
-
-`size-10` not `w-10 h-10`. Applies to icons, avatars, skeletons, etc.
-
----
-
-## Prefer truncate shorthand
-
-`truncate` not `overflow-hidden text-ellipsis whitespace-nowrap`.
-
----
-
-## No manual dark: color overrides
-
-Use semantic tokens — they handle light/dark via CSS variables. `bg-background text-foreground` not `bg-white dark:bg-gray-950`.
-
----
-
-## Use cn() for conditional classes
-
-Use the `cn()` utility from the project for conditional or merged class names. Don't write manual ternaries in `class` strings.
-
-**Incorrect:**
-
-```svelte
-<script lang="ts">
-  let isActive = $state(false);
-</script>
-
-<div class={`flex items-center ${isActive ? "bg-primary text-primary-foreground" : "bg-muted"}`}>
-```
-
-**Correct:**
-
-```svelte
-<script lang="ts">
-  import { cn } from "$lib/utils";
-  let isActive = $state(false);
-</script>
-
-<div class={cn("flex items-center", isActive ? "bg-primary text-primary-foreground" : "bg-muted")}>
-```
-
----
-
-## No manual z-index on overlay components
-
-`Dialog`, `Sheet`, `Drawer`, `AlertDialog`, `DropdownMenu`, `Popover`, `Tooltip`, `HoverCard` handle their own stacking. Never add `z-50` or `z-[999]`.

package/ui/.agents/skills/svas/SKILL.md

@@ -1,169 +0,0 @@
----
-name: svas
-description: >
-  Async Svelte stores (svas): fetching, caching, revalidation, persistence.
-  Use when UI presents data from the API.
----
-
-# svas — Svelte Async Stores
-
-Stores that fetch lazily, cache, revalidate, and persist. Every store emits one of three types:
-
-```ts
-type Maybe<T, E extends Error = Error> = null | T | E
-//   null  → no data yet (loading / cleared / not fetched)
-//   T     → resolved value
-//   E     → fetch error (errors are values, never thrown)
-```
-
-```ts
-import {
-  value, values, collection,           // stores
-  ok, ensure, having, awaited, once,   // guards & awaiting
-  combined, sync, Async,               // compose & render
-  type Maybe
-} from 'svas'
-```
-
-## Shared lifecycle
-
-Every store fetches on **first subscribe**, then auto-revalidates. Common options:
-
-| Option | Meaning |
-|--------|---------|
-| `get` | fetcher returning `Promise<T \| Error>` |
-| `revalidate` | ms before re-fetch (default `300_000`; `Infinity` disables) |
-| `persist` | mirror into local storage under this key |
-| `session` | use `sessionStorage` instead of `localStorage` |
-| `stale` | keep previous value visible while revalidating (default `false`) |
-| `bind` | `Readable<unknown \| null>` — reset/clear store when bound store is `null` (tie data to a user) |
-| `default` | initial value when nothing is persisted |
-
-## Stores
-
-All stores implements Readable interface from svelte/store.
-
-Use `persist` whenever it makes sense to persist the data, it will vastly speed up the initial load.
-If store contains user-bound data, use `bind` to reset the store when the user is logged out.
-
-### `value<T>` — one async value
-
-`Writable<T | null>`. For single fetched values, auth tokens, transient UI flags.
-
-```ts
-const me = value<User>({ get: () => api.me(), persist: 'user' })
-const seen = value<number>({ persist: 'seen', default: 0 }) // transient/local-only
-```
-
-Methods: `set(v)`, `update(fn)`, `extract(): T | null` (sync read), `sync()` (revalidate if stale).
-
-### `values<T>` — keyed cache
-
-A map of independent `Readable<Maybe<T>>` lifecycles, one per key.
-
-```ts
-const products = values<Product>({ get: (id) => api.product(id), stale: true, persist: 'products' })
-
-const one = products.get('42')      // Readable<Maybe<Product>>, fetches if missing
-products.set('42', next)            // write by key
-products.extract('42')              // Product | null, sync
-```
-
-Methods: `get(key, { fetch? })` · `set(key, v, { stash? })` · `reset(key)` (restore stashed value) · `extract(key)` · `delete(key)` · `clear()`.
-
-Extra options: `permanent` (don't revalidate persisted entries on startup). `stash: true` on `set` remembers the prior persisted value so `reset(key)` can roll back — use for optimistic updates.
-
-### `collection<T>` — list of `Identifiable` items
-
-`Readable<Maybe<T[]>>`. Items must have `{ id: string }`. Pass a `values` store to also observe items individually via `get(id)`.
-
-```ts
-const todos = collection<Todo>({
-  get: () => api.todos(),
-  values: values<Todo>(), // enables todos.get(id) / extract(id)
-  stale: true, 
-  persist: 'todos', 
-  bind: session
-})
-```
-
-Methods: `subscribe` · `add(item)` · `set(item, { add? })` (replace by id; `add` inserts if absent) · `update(id, fn, opts?)` · `delete(id)` · `replace(items)` · `get(id)`/`extract(id)` (require `values`) · `sync(): this` · `fetch(): Promise<this>`.
-
-Mutations mirror into the `values` store, so components subscribed via `get(id)` update without re-fetching.
-
-## Guards & extraction
-
-Never use `?.` on a `Maybe<T>` — an `Error` has no domain properties. Narrow first.
-
-```ts
-ok($store)          // boolean type guard: narrows Maybe<T> → T (excludes null | Error)
-ensure(store)       // sync read, THROWS if null/Error — use when value must exist now (e.g. unsafe net requests in response to user action)
-store.extract(key?) // sync read, T | null (ignores errors) — never throws
-```
-
-```ts
-if (ok($todos)) $todos.length        // typed as T
-items.filter((i) => ok(i.account) && !i.account.deleted)   // ✅ guard before access
-```
-
-## Awaiting
-
-```ts
-await having(store)   // first non-null value; REJECTS on Error — services needing auth
-await awaited(store)  // first non-null value; returns Error as a value (never rejects)
-await once(store, (v) => v === 'ready')   // first value satisfying a condition
-```
-
-## Compose & render
-
-### `<Async>` — render a `Maybe`
-
-```svelte
-<Async store={todos}>
-  {#snippet awaited(todos)}
-    <!-- here todos are T[] -->
-    {#each todos as t}<Row {t} />{/each}
-  {/snippet}
-  {#snippet waiting()}<Spinner />{/snippet}   <!-- optional; default loader otherwise -->
-  {#snippet error(e)}<Err {e} />{/snippet}    <!-- optional; default error UI otherwise -->
-</Async>
-```
-
-Props: `store` (required), `awaited` snippet (required), optional `waiting` / `error` snippets, `silent` (suppress default loader/error chrome). Combine with `combined` to await several at once.
-
-### `combined(...stores)`
-
-One `Maybe` from many: tuple when **all** resolve, first `Error`, else `null`. Spreadable.
-
-```svelte
-<Async store={combined(account, todos)}>
-  {#snippet awaited([account, todos])}
-    <!-- here account is U and todos is T[] -->
-    <Profile {account} />
-    {#each todos as t}<Row {t} />{/each}
-  {/snippet}
-</Async>
-```
-
-### `sync(store, item, { delete? })`
-
-Conflict-free update.
-
-T must implement interface Comparable { id: string; _version: number;_deleted?: number | null }
-
-Merge a versioned item into a `collection` or `value`, respecting `_version`; removes on `_deleted` (unless `delete: false`). For applying server/realtime events.
-
-```ts
-events.on('todos.sync', (todo) => sync(todos, todo))
-```
-
-## Rules
-
-- **Errors are values** — fetchers and services return `T | Error`; check `instanceof Error`, never `try/catch` for expected failures.
-- **Guard before access** — `ok()`/`ensure()`/`extract()`, never `?.` on `Maybe<T>`.
-- **One store per source** — derive everything else; don't duplicate fetched data into local state.
-- **Lazy by design** — a store does nothing until subscribed; `$store`, `<Async>`, `get`, `having`, or `.subscribe` triggers it.
-
-## Advanced
-
-For derived `Maybe` stores with live subscriptions/cleanup, realtime event wiring, linked/enriched entities, and optimistic update patterns, see [references/patterns.md](references/patterns.md).

package/ui/.agents/skills/svas/references/patterns.md

@@ -1,95 +0,0 @@
-# svas — advanced patterns
-
-Idioms for non-trivial usage. All build on `Maybe<T> = null | T | Error` and the `ok()` guard.
-
-## Derived `Maybe` stores
-
-Compute one async store from others with `svelte/store`'s `derived`. Forward `null`/`Error` early, and return a cleanup function when you subscribe to linked entities.
-
-```ts
-const internal = collection<Item>({ get: () => api.get(), persist: 'items' })
-
-export const items = derived<[typeof internal, typeof me], Maybe<Item[]>>(
-  [list, me],
-  ([$list, $me], set, update) => {
-    if (!ok($list)) return set($list)   // forward loading/error verbatim
-    if (!ok($me)) return set($me)
-
-    const items = $list.map((i) => map(i, $me.id))
-    set(items)
-
-    // live updates: re-emit when a linked entity changes
-    const unsubs = items.map((item) =>
-      accounts.get(item.owner).subscribe((account) =>
-        update((items) => {
-          if (!ok(items) || !ok(account)) return items
-          const i = items.findIndex((v) => v.owner === account.id)
-          if (i < 0) return items
-          items[i] = { ...items[i], account }
-          return items
-        })
-      )
-    )
-
-    return () => unsubs.forEach((u) => u())   // cleanup on unsubscribe
-  }
-)
-```
-
-Key moves: `if (!ok(x)) return set(x)` to forward non-resolved states, `update()` for incremental edits, return a teardown for any subscriptions you open.
-
-## Realtime event wiring
-
-> Usually used with antcn/@realtime
-
-Apply server events into stores with `sync` (collections/values-backed) or `.set` (standalone `values`). Mutating functions sync their own result so the optimistic and authoritative paths converge.
-
-```ts
-// collection backed by a values side store
-events.on('todos.sync', (todo) => sync(todos, todo))
-
-// standalone values map
-events.on('accounts.sync', (a) => accounts.set(a.id, a))
-
-export async function add(input: Input): Promise<Todo | Error> {
-  const me = await having(account)        // wait for auth
-  const res = await net.add(me.id, input)
-  if (res instanceof Error) return res     // error as value
-  sync(todos, res)                         // merge authoritative result
-  return res
-}
-```
-
-## Linked / enriched entities
-
-Join a network type with domain data. Use `.extract()` for a sync snapshot at map time; subscribe via `.get()` inside derived stores for live enrichment.
-
-```ts
-export interface Contact extends net.Contact {
-  account: Maybe<Account>
-}
-
-export function map(entry: net.Contact): Contact {
-  return { ...entry, account: accounts.extract(entry.owner) }  // sync snapshot
-}
-```
-
-Hold a `Maybe<T>` per link; never reach through it with `?.` — guard with `ok()` before use. For many links, `Record<string, Maybe<T>>` keyed by id.
-
-## Optimistic updates with rollback
-
-`values.set(key, v, { stash: true })` remembers the prior persisted value; `reset(key)` restores it if the request fails.
-
-```ts
-products.update(id, (product) => ({ ...product, ...properties }))
-
-const res = await net.patch(id, properties)
-
-if (res instanceof Error) return res
-else sync(products, res)
-```
-
-## `ensure` vs `having`
-
-- `ensure(store)` — **sync**, throws if `null`/`Error`. Use when the value must already exist (auth checks inside service functions called in response to user action).
-- `await having(store)` — **async**, waits for a resolved value, rejects on `Error`. Use at init time when the value may still be loading (initial data fetching when app is starting).

package/ui/.agents/skills/svintl/SKILL.md

@@ -1,176 +0,0 @@
----
-name: svintl
-description: >
-  svintl CLI for i18n — translations, locales, pluralization, mounts, building typed dictionaries. Triggers on `npx intl`, YAML locale files, intl directories, or any translation/i18n work in Svelte projects.
----
-
-# svintl — i18n for Svelte
-
-CLI tool for managing internationalization dictionaries with automatic translation via OpenAI.
-
-## Core Rule
-
-The `*.yaml`, `built.js`, and `types.ts` files in intl directories are generated — they're edited through the `npx intl` CLI, not by hand.
-
-## CLI Commands
-
-```bash
-npx intl hola                               # init dictionaries (default: src/lib/intl/)
-npx intl hola -p ./custom/path              # init at custom path
-npx intl add key.path "Value" "context"     # add a new key — fails if it already exists; context optional
-npx intl set key.path "Updated value"       # update a key that already exists — fails if missing
-npx intl set "mount/key.path" "Value"       # target a mount with the mount/ prefix
-npx intl add key.path "Value" --debug       # --debug (add or set): print the OpenAI request first
-npx intl const key.path "Same everywhere"   # same value across all locales (no translation)
-npx intl unit items.count "item"            # pluralized entry (auto-generates plural forms)
-npx intl move old.key new.key               # rename key/branch
-npx intl del key.path                       # delete key/branch
-npx intl create es                          # add a locale (BCP 47 tag) — auto-translates the whole dictionary into it
-npx intl destroy es                         # delete locale
-npx intl mount foo ./any/path               # create empty mount
-npx intl import foo ./any/path              # adopt existing dict dir as mount, reconcile locales
-npx intl unmount foo                        # remove mount (keeps files)
-npx intl context "Project description"      # set project-wide translation guidance
-npx intl context --clear                    # clear project context
-npx intl genders he she none                # enable gender-aware translations (list the gender values)
-npx intl genders                            # print current gender values
-npx intl sync en key.path                   # reconcile: re-translate one key into all locales from source en
-npx intl sync en                            # reconcile: re-translate the whole dictionary from source en
-npx intl build                              # rebuild JS/TS from YAML
-```
-
-## Dictionary Format
-
-YAML with arbitrary nesting, strings at leaves:
-
-```yaml
-native: English
-example:
-  hello: "Hello world"
-```
-
-Usage: `{$dict.example.hello}`
-
-### Dynamic Values — Placeholders
-
-For simple cases the CLI auto-generates `!js` functions from placeholder syntax — no need to write them manually:
-
-```bash
-npx intl set greeting "Hello, {name}!"            # {name} → function param
-npx intl set joined "[names] joined {groupName}"  # [names] → Intl.ListFormat
-```
-
-For complex logic, pass `!js` functions via `intl set`:
-
-```bash
-npx intl set greeting '!js (count) => `${count || "No"} item${count === 1 ? "" : "s"}`'
-```
-
-Usage in components: `{$dict.greeting(user.name)}`
-
-**Keep the whole phrase in the dictionary.** Never split a sentence around a dynamic value in the template:
-
-```svelte
-<!-- ❌ Wrong: breaks the phrase for translators -->
-<strong>{brand}</strong>{$dict.form.destroyDescription}
-
-<!-- ✅ Right: one entry, function accepts the value -->
-{@html $dict.form.destroyDescription(brand)}
-```
-
-```bash
-npx intl set "apps/form.destroyDescription" \
-  '!js (brand) => `<strong>${brand}</strong> and all accumulated data will be permanently deleted.`'
-```
-
-When a name needs markup and is always at the start of the phrase across languages, put the tags inside the `!js` function and render with `{@html}` — escape user-controlled values before passing them in.
-
-### Pluralization
-
-Use `npx intl unit` — generates `Intl.PluralRules`-based functions:
-
-```bash
-npx intl unit items.count "item"
-```
-
-Produces:
-```yaml
-items:
-  count:
-    - one: item
-      other: items
-```
-
-Usage: `{$dict.items.count(count)}`
-
-Complex locales (Russian, Arabic) auto-get `few`, `many`, etc.
-
-### Genders
-
-When enabled (`npx intl genders he she none`), gender-dependent phrases become functions whose **last** argument is the gender (`'he' | 'she' | 'none'`) — the phrase's own arguments come first, e.g. `(name, gender) => …`. The listed values become the generated `Grammar` union.
-
-## Mounts
-
-Organize translations into separate directories:
-
-```bash
-npx intl mount admin ./src/features/admin/intl
-npx intl set "admin/dashboard.title" "Admin Dashboard"
-```
-
-Mount keys use `{mount}/` prefix in CLI commands.
-
-`mount` scaffolds an empty mount; `import` adopts a populated dir (with its own `context.yaml`) and reconciles its locales to the root — drops languages the root lacks, generates ones it lacks (translating the imported `inputs`), leaves shared locales untouched.
-
-## Import Pattern
-
-**Root dictionary:**
-```svelte
-<script lang="ts">
-  import { dict, locale } from '$lib/intl'
-</script>
-<h1>{$dict.example.hello}</h1>
-```
-
-**Mount dictionary:**
-```svelte
-<script lang="ts">
-  import { dict } from './intl'
-</script>
-<h1>{$dict.dashboard.title}</h1>
-```
-
-**Mount's `intl/index.ts`:**
-```typescript
-import { derived } from 'svelte/store'
-import { locale } from '$lib/intl'
-import { dictionaries } from './built.js'
-import type { Locale, Dictionary } from './types'
-
-const dict = derived(locale, ($locale) => dictionaries[$locale])
-export { dict, dictionaries, locale }
-export type { Locale, Dictionary }
-```
-
-## Context for Translation Accuracy
-
-```bash
-npx intl set app.welcome "Welcome" "greeting shown on homepage"
-npx intl context "B2B SaaS for enterprise users"
-```
-
-Context is stored in `context.yaml` and used by OpenAI when creating new locales.
-
-## Workflow
-
-1. Use `npx intl add/set/unit/const` to add/update translations
-2. Run `npx intl build` to generate JS/TS (often auto-runs)
-3. Import `dict` store in components
-4. Use `$dict.key.path` in templates
-
-## Avoid
-
-- **Editing YAML by hand** — go through the CLI
-- **`npx intl sync` for routine edits** — it's only for reconciling after a manual source edit; use `add`/`set` instead
-- **Non-BCP47 locale codes** — use valid tags like `en-US`, `es`, `pt-BR`
-- **Splitting phrases in the template** — don't concatenate a dynamic value with a dictionary suffix/prefix; use one `{placeholder}` / `!js` entry for the full sentence

package/ui/.claude/settings.json

@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/tools/hooks/guard-intl.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

package/ui/.codex/hooks.json

@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "apply_patch|Edit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$(git rev-parse --show-toplevel)\"/tools/hooks/guard-intl.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

package/ui/.cursor/hooks.json

@@ -1,11 +0,0 @@
-{
-  "version": 1,
-  "hooks": {
-    "preToolUse": [
-      {
-        "command": "./tools/hooks/guard-intl.sh",
-        "matcher": "Write|Edit"
-      }
-    ]
-  }
-}

package/ui/.env.example

@@ -1 +0,0 @@
-OPENAI_API_KEY=<put your openai api key here>

package/ui/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "useTabs": false,
-  "singleQuote": true,
-  "printWidth": 100,
-  "semi": false,
-  "tabWidth": 2,
-  "bracketSameLine": true,
-  "htmlWhitespaceSensitivity": "ignore"
-}