fimo 0.7.0-experimental.3 → 0.7.0-staging.1

package/README.md

@@ -49,8 +49,7 @@ Manage content, schemas, media, and labels from the CLI:
 ```bash
 fimo schemas push          # sync your content models
 fimo entries list          # browse content
-fimo assets upload <file>  # add existing media
-fimo image generate --prompt "..."  # create an image with AI
+fimo assets upload <file>  # add media (or `fimo assets generate` with AI)
 fimo labels list           # manage labels and localized copy
 ```
 
@@ -86,4 +85,4 @@ fimo domains add example.com
 
 ## Documentation
 
-Full documentation lives at **[fimo.ai/docs](https://fimo.ai/docs)**. Run `fimo --help` to see every command.
+Full documentation lives at **[docs.fimo.ai](https://docs.fimo.ai)**. Run `fimo --help` to see every command.

package/assets/skills/fimo/SKILL.md

@@ -58,7 +58,7 @@ Workflow / CLI-side concerns (pushing schemas, generating images, managing label
 - **Hardcoding content in JSX** — `<h1>My Blog</h1>` + an array of posts in code. Use schemas + entries + `t()`.
 - **Raw HTML for schema content** — `<img src={post.coverImage.url}>` instead of `<Image value={post.coverImage}>`. The `fimo/ui` components carry metadata for inline editing in the admin.
 - **Raw `<a href>` for internal navigation** — causes full page reloads. Use `<FimoLink>` for locale-aware internal links or React Router `<Link>` when intentionally bypassing locale helpers. Reserve `<a>` for external links.
-- **Pulling stock photos from external URLs** — editors can't manage them. Use a Fimo media task such as `fimo image generate`.
+- **Pulling stock photos from external URLs** — editors can't manage them. Use `fimo generate` (CLI).
 - **Editing generated `.ts` files** under `src/schemas/` or `src/forms/` — regenerate them through `fimo validate` or the matching push command.
 - **Writing raw HTML in `richtext` fields** — must be Tiptap JSONContent.
 - **Calling `t()` with a dynamic first argument** — the key must be a string literal so the extractor finds it.

package/assets/skills/fimo/references/assets.md

@@ -1,12 +1,12 @@
 # Assets — package surface
 
-> For the CLI commands (`fimo assets upload`, `fimo image generate`, folder management) and the "when to generate AI images" workflow rules, see **`fimo-cli/references/assets.md`**.
+> For the CLI commands (`fimo assets upload`, `fimo generate`, folder management) and the "when to generate AI images" workflow rules, see **`fimo-cli/references/assets.md`**.
 
 This file covers the **package surface** for working with assets in code: the `media` field value shape, how to render assets with `fimo/ui` components, the URL format.
 
 ## `media` field value (stored/wire shape)
 
-Asset values returned from `fimo assets upload` or Fimo media tasks, and stored in `media` content-type fields:
+Asset values returned from `fimo assets upload` or `fimo generate`, and stored in `media` content-type fields:
 
 ```json
 {

package/assets/skills/fimo/references/content.md

@@ -176,7 +176,7 @@ Always provide a meaningful `slug` when creating an entry — it appears in URLs
 - **Stable** — once an entry is live, changing the slug breaks inbound links. Only update intentionally.
 - If you omit `slug`, the backend generates a random one — never rely on this for content you want to link to.
 
-For `media` fields, prefer `source: "local"` with assets uploaded via `fimo assets upload` or generated with a Fimo media task such as `fimo image generate` (see `fimo-cli/references/media.md`).
+For `media` fields, prefer `source: "local"` with assets uploaded via `fimo assets upload` or generated via `fimo generate` (see `fimo-cli/assets.md`).
 
 ## Generated React Query hooks
 

package/assets/skills/fimo/references/design.md

@@ -124,7 +124,7 @@ Write into `src/index.css` as shadcn CSS variables, then use `bg-background` / `
 - **Treatment:** Full-bleed, contained, overlays, filters
 - **Hero:** Specific direction for hero imagery
 
-If the user hasn't supplied images and one is needed, run `fimo image generate --prompt "..."` and reuse the returned `url` or `id`. Run `fimo image generate --help` for current flags. See `references/assets.md`.
+If the user hasn't supplied images and one is needed, generate via `fimo generate <model> --prompt "..."` (run `fimo models list` to pick a model, `fimo models show <model>` for its flags) and reuse the returned `url` / `id`. See `references/assets.md`.
 
 ### Iconography
 

package/assets/skills/fimo-cli/SKILL.md

@@ -73,7 +73,7 @@ Load the matching reference when the user's request fires its trigger. Recipes t
 - "Add a contact / signup / feedback / newsletter form" → `references/forms.md` (workflow) **+ load `fimo/references/forms.md` for the JSON spec and generated client**
 - "View form submissions / who filled out the contact form / inspect what users sent / how many signups" → `references/forms.md` § Reading submissions
 - "Upload an image / hero / cover / existing media file" → `references/assets.md` (workflow: upload, browse, open, delete) **+ load `fimo/references/assets.md` for the `FimoMedia` shape and rendering**
-- "Generate AI image / video / draft preview / image edit / cover from a prompt" → `references/media.md` (task commands, quality, recipes, and verification) **+ load `fimo/references/assets.md` for the `FimoMedia` shape if you'll plug the result into UI**
+- "Generate AI image / video / draft preview / image edit / cover from a prompt" → `references/media.md` (the `fimo generate <model>` surface — recipes, defaults, the one-verb shape) **+ load `fimo/references/assets.md` for the `FimoMedia` shape if you'll plug the result into UI**
 - "Add labels / update static copy / fix missing `t()` values" → `references/labels.md` (workflow) **+ load `fimo/references/labels.md` for the `t()` helper and wrap rules**
 - "Enable locales / configure default locale / route by locale prefix / fix locale route validation" → `references/locales.md` **+ load `fimo/references/locales.md` for code helpers**
 - "What's in this project / show the project structure / describe the project / what schemas does it have / how many routes / project tree / show me what's here" → `references/describe.md`

package/assets/skills/fimo-cli/references/assets.md

@@ -3,7 +3,7 @@
 > **Run via `npx fimo@latest <command>`** — always the latest CLI, no install needed.
 
 > For how to plug returned media into UI components (`FimoMedia` shape, `<Image>` integration), see **`fimo/references/assets.md`** and **`fimo/references/ui.md`**.
-> For **generating** new images / videos with AI, see **`references/media.md`** for the task commands and recipes.
+> For **generating** new images / videos with AI, see **`references/media.md`** — the `fimo generate <model>` surface is documented there.
 
 This file covers the **CLI workflow** for media that already exists: uploading files, browsing the library, opening an asset to inspect it, moving / deleting items.
 
@@ -39,15 +39,15 @@ Use `--folder-path` when an agent needs a non-interactive upload target and does
 
 ## Generate AI media
 
-Moved to **`references/media.md`**. Choose the task that describes the outcome:
+Moved to **`references/media.md`**. The generation surface is one verb:
 
 ```bash
-fimo image generate --prompt "<prompt>"
-fimo image edit --prompt "<instruction>" --images <asset-id-or-url>
-fimo video generate --prompt "<prompt>"
+fimo generate <model-id-or-shortname> [--flag value ...]
 ```
 
-Task flags come from the API. Run `fimo <namespace> <task> --help` for the current options. Fimo owns the internal generation route.
+Per-model flags come from the API. `fimo models list` lists models;
+`fimo generate <model> --help` lists that model's flags. See `media.md` for
+the recipes block and the default-pick table.
 
 ### When to prefer generation over uploads / placeholders
 
@@ -59,6 +59,23 @@ Task flags come from the API. Run `fimo <namespace> <task> --help` for the curre
 - The user has already uploaded or referenced a specific file.
 - The image must be a real photo of a real thing (team photos, real product shots).
 
+## Browse models — `fimo models`
+
+```bash
+fimo models list                              # all, grouped by modality
+fimo models list --modality image             # filter by modality
+fimo models list --tag draft --tag fast       # filter by tag (repeatable, AND)
+fimo models list --provider pruna             # filter by provider
+fimo models list --json                       # machine-readable
+fimo models show pruna/p-image                # full detail + per-flag schema
+fimo models show gpt-image-2 --json           # JSON dump (for agents)
+```
+
+Model selection is **not** persisted per project. Picks live in
+`media.md` (baseline) → `CLAUDE.md` / `AGENTS.md` (project policy) → the
+prompt itself (highest priority). To target a specific model, name it on the
+command: `fimo generate <model> …`.
+
 ## Browse the library — `fimo assets list`
 
 ```bash
@@ -127,6 +144,6 @@ fimo assets delete <asset-id>
 
 ## End-to-end workflow
 
-1. Upload with `fimo assets upload` or generate with a task command such as `fimo image generate`.
+1. Upload (`fimo assets upload`) OR generate (`fimo generate <model> ...`) the asset.
 2. Keep the returned `url` (for direct use) or `id` (to attach to a `media` content-type field).
 3. To use in JSX, see `fimo/references/ui.md` — schema media → `<Image>` / `<Video>`, hardcoded URLs → `<StaticImage>`. **Never** use raw `<img src={asset.url}>`.

package/assets/skills/fimo-cli/references/content.md

@@ -11,7 +11,7 @@ This file covers the **CLI workflow** for content. Use it when the user wants to
 1. Write `src/schemas/{Uid}.json` — PascalCase filename (e.g. `BlogPost.json`). For the JSON shape and field types, load `fimo/references/content.md`.
 2. Run `fimo schemas push {Uid}`. It generates `src/schemas/{Uid}.types.ts` and `src/schemas/{Uid}.ts`, then registers the schema with Fimo. It does not run whole-project validation.
 3. App code imports the generated client from `@/schemas/{Uid}`, not from `.types.ts` directly. See `fimo/references/content.md` for the hook API.
-4. Seed entries via `fimo entries create`. Generate cover images first with `fimo image generate` if needed (see `media.md` / `assets.md`).
+4. Seed entries via `fimo entries create`. Generate cover images first with `fimo generate <model>` if needed (see `media.md` / `assets.md`).
 5. Write React pages that import from `@/schemas/{Uid}` and render with `fimo/ui` components.
 
 Steps 1, 3, and 5 reference the project skill (`fimo`) for shape and React API. Steps 2 and 4 are CLI commands documented here.
@@ -108,7 +108,7 @@ Use `"isSingleton": true` for a type with exactly one logical document. Generate
 1. Load `fimo/references/content.md` for the JSON shape and field types.
 2. Write `src/schemas/BlogPost.json` with fields `title`, `body` (richtext), `coverImage` (media), etc. Do NOT declare a `slug` field — `slug` (and `id`, `entryId`, `documentId`, `locale`, `createdAt`, `updatedAt`, `__fimo`) is reserved entry metadata and will be rejected; every entry gets a `slug` for free.
 3. Run `fimo schemas push BlogPost`.
-4. Generate cover images: `fimo image generate --prompt "..." --aspect-ratio 16:9` (see `media.md`).
+4. Generate cover images: `fimo generate pruna/p-image --prompt "..."` (per-model flags come from `fimo models show <model>`; see `media.md`).
 5. Seed entries: `fimo entries create BlogPost --body '{"data": {"slug": "first-post", "title": "...", "coverImage": {...}}}'`.
 6. Load `fimo/references/ui.md` for the `<Text>`, `<Image>`, `<RichText>` components.
 7. Load `fimo/references/labels.md` for wrapping labels in `t()`.

package/assets/skills/fimo-cli/references/domains.md

@@ -132,7 +132,7 @@ Propagation: typically 15–30 minutes, up to 48 hours rarely.
 
 ## Web app equivalent
 
-For users on the dashboard, the same workflow lives at **Settings → Domains** (custom domain) and **Organization → Domains** (buy/owned). See `fimo-studio/references/custom-domains.md` and the [public docs](https://fimo.ai/docs/publish/custom-domains).
+For users on the dashboard, the same workflow lives at **Settings → Domains** (custom domain) and **Organization → Domains** (buy/owned). See `fimo-studio/references/custom-domains.md` and the [public docs](https://docs.fimo.ai/publish/custom-domains).
 
 ## Anti-patterns
 

package/assets/skills/fimo-cli/references/media.md

@@ -1,171 +1,181 @@
-# AI media tasks
+# Media generation
 
-> **Run via `npx fimo@latest <command>`** so the task catalog and CLI stay aligned.
+> **Run via `npx fimo@latest <command>`** — always the latest CLI, no install needed.
 
-Use task commands for AI media. The command describes the outcome; Fimo chooses and can change the underlying generation route without changing agent instructions.
+> For uploading existing files, browsing the library, and opening assets, see
+> `references/assets.md`. This file is **only** about generating new media
+> via AI — the `fimo generate <model>` surface.
+
+The CLI exposes **one verb** for all media generation. The model is positional;
+every other input is a flag declared by that model's schema.
 
 ```bash
-fimo image generate --prompt "<prompt>"
-fimo image edit --prompt "<instruction>" --images <asset-id-or-url>
-fimo image remove-background --image <asset-id-or-url>
-fimo image upscale --image <asset-id-or-url>
-
-fimo video generate --prompt "<prompt>"
-fimo video animate --video <asset-id-or-url> --image <asset-id-or-url>
-fimo video replace --video <asset-id-or-url> --images <asset-id-or-url>
+fimo generate <model-id-or-shortname> [--flag value ...] [--json] [--dry-run]
 ```
 
-Use only task commands in new workflows. Internal routing details are not part of the public interface.
+`<model>` is either a canonical id (`pruna/p-image`) or its terminal-friendly
+shortName (`pruna-p-image`, `gpt-image-2`). The CLI fetches each model's flags
+and base price from the API (`GET /api/models`); the server validates the
+options. So flags, defaults, enum values, and pricing all come from one source
+and can't drift — `fimo models show <model>` prints them.
 
-## Shared behavior
+---
 
-- Run `fimo <namespace> <task> --help` for the current task flags.
-- Add `--dry-run` to validate inputs and get a cost estimate without creating media.
-- Add `--json` for structured output.
-- Add `--name "..."` to set the media-library name.
-- Add `--parent <folder-id>` to save into a folder.
-- Source media can be a Fimo asset ID or an absolute URL.
-- Repeat `--images` for tasks that accept multiple references.
-- The response returns the created asset, cost, credits, task, and quality when applicable. Keep the asset `id` for content fields or the public `url` for direct use.
+## Models
 
-## Quality
+Deliberately small, curated catalog (8 image + 3 video). This file documents the **defaults and recipes** below; for the live list with prices, tags, best-for, and flags, run `fimo models list --extended` (or `fimo models show <model>` for one model's options).
 
-Tasks that expose `--quality` accept:
+---
 
-- `draft`: faster and cheaper for iteration.
-- `standard`: default for ordinary work.
-- `premium`: higher quality for final, prominent media.
+## Defaults — pick the cheapest model that does the job
 
-Start with `standard`. Use `draft` for disposable exploration. Use `premium` only when the user asks for the best result or the media is especially prominent.
+**Default to `pruna/p-image` (images) and `pruna/p-video` (video).** The cheap baseline covers the large majority of requests. For anything it can't do — img2img edit, vector/SVG, background removal, upscale, virtual try-on, image-to-video — see the **Recipes** below; each names its model.
 
-Preview the choice before spending credits:
+**Don't reach for the expensive models (`openai/gpt-image-2`, `fal-ai/bytedance/seedream`) unless explicitly asked** (e.g. a hero or other prominent image), or the project's `AGENTS.md` / `CLAUDE.md` sets a different default.
 
-```bash
-fimo image generate \
-  --prompt "editorial illustration of a quiet coastal town at sunrise" \
-  --quality standard \
-  --aspect-ratio 16:9 \
-  --dry-run
-```
+Model selection lives here (and in project `AGENTS.md` / `CLAUDE.md`). Run `fimo models list` for the live catalog, and
+**`fimo models show <model>` to read a model's options before you use it** —
+options are NOT standardized across models (e.g. pruna takes `--aspect-ratio`,
+while `gpt-image-2` / `seedream` size via `--image-size`). Don't assume a flag
+exists on a model you haven't inspected.
 
-## Image recipes
+### Parameters for the default (pruna) models
 
-### Generate an image
+Inlined so you don't need `models show` for the common path. For **any other
+model**, run `fimo models show <model>` — its options will differ. (This list is
+a convenience snapshot; `models show` is the live source of truth.)
 
-```bash
-fimo image generate \
-  --prompt "editorial illustration of a quiet coastal town at sunrise" \
-  --quality standard \
-  --aspect-ratio 16:9 \
-  --name "Coastal sunrise hero"
-```
+**`pruna/p-image`** — text-to-image
 
-Supported aspect ratios are `1:1`, `16:9`, `9:16`, `4:3`, and `3:4`.
+- `--prompt <string>` · **required** · generation prompt
+- `--aspect-ratio <1:1|16:9|9:16|4:3|3:4>` · default `1:1`
 
-### Edit one or more images
+**`pruna/p-image-edit`** — img2img / prompt-driven edit
 
-```bash
-fimo image edit \
-  --prompt "change the background to a warm sunset while preserving the subject" \
-  --images <asset-id-or-url> \
-  --aspect-ratio 16:9
-```
+- `--prompt <string>` · **required** · editing instruction
+- `--source-images <asset-id|url>` · **required** · repeatable, up to 5 (an `ast_*` asset id or an absolute URL)
+- `--aspect-ratio <1:1|16:9|9:16|4:3|3:4>` · default `1:1`
 
-Repeat `--images` to provide up to five references.
+**`pruna/p-video`** — text-to-video (add `--source-images` to do image-to-video)
 
-### Remove a background
+- `--prompt <string>` · **required**
+- `--source-images <asset-id>` · optional · one `ast_*` asset id; passing it flips to image-to-video
+- `--aspect-ratio <1:1|16:9|9:16|4:3|3:4|3:2|2:3>` · default `16:9`
+- `--duration <int 1–10>` · default `5` (seconds)
+- `--resolution <720p|1080p>` · default `720p`
+- `--include-audio` · default off (pass the flag to enable)
 
-```bash
-fimo image remove-background --image <asset-id-or-url>
-```
-
-### Upscale an image
+**`pruna/p-video-draft`** — same flags as `pruna/p-video`; ~4× cheaper, lower quality.
 
-```bash
-fimo image upscale \
-  --image <asset-id-or-url> \
-  --target-megapixels 8 \
-  --output-format png \
-  --enhance-details
-```
+---
 
-Use `--enhance-realism` for photographic material. Use `--no-enhance-details` when preserving the original texture matters more than reconstruction.
+## Recipes — user intent → exact command
 
-## Video recipes
-
-### Generate from text
+Each recipe is **one** command. The "Why" line tells the agent when to reach
+for this vs. an alternative.
 
 ```bash
-fimo video generate \
-  --prompt "slow camera push through a greenhouse after rain" \
-  --quality standard \
-  --duration 6 \
-  --aspect-ratio 16:9
+# "Generate an image" (default — cheapest workhorse)
+fimo generate pruna/p-image --prompt "<prompt>"
+# Why: fast, cheap, good enough for most cases.
+
+# "Generate a high-quality / typography / hero image"
+fimo generate openai/gpt-image-2 --prompt "<prompt>" --quality high
+# Why: premium quality, typography + realism. ~10–40× the baseline cost — use
+# only on an explicit request (e.g. hero / prominent media), never by default.
+# --quality low/medium saves cost (metered: ~$0.22 high → ~$0.02 low).
+
+# "Generate a 4K image" (native high resolution, no upscale needed)
+fimo generate fal-ai/bytedance/seedream/v4.5/text-to-image \
+  --prompt "<prompt>" --image-size auto_4K
+# Why: outputs at 4K natively — skip the clarity-upscaler step.
+
+# "Edit an existing image with a prompt"
+fimo generate pruna/p-image-edit \
+  --prompt "<edit instruction>" --source-images <asset-id-or-url>
+# Why: img2img with prompt-driven transforms. Style changes,
+# object swaps, scene relighting.
+
+# "Try a garment on a person" (e-commerce / fashion)
+fimo generate fal-ai/flux-pro/v1/vto \
+  --prompt "<styling instruction>" \
+  --human-image-url <person-url> --garment-image-url <garment-url>
+# Why: virtual try-on. Specific to fashion; don't use for general edits.
+
+# "Remove the background of an image"
+fimo generate fal-ai/bria/background/remove --source-images <image-url>
+# Why: deterministic transparent-PNG cutout. No prompt needed.
+# Note: this fal model takes an image URL, not a library asset-id.
+
+# "Upscale an image to higher resolution"
+fimo generate fal-ai/clarity-upscaler \
+  --source-images <image-url> --upscale-factor 4
+# Why: 2×/3×/4× super-resolution. Best quality at 2×. Takes a URL, not an asset-id.
+
+# "Generate a vector illustration / SVG / icon"
+fimo generate fal-ai/recraft/v3/text-to-image \
+  --prompt "<prompt>" --style vector_illustration/bold_stroke
+# Why: only model that returns SVG. Six style variants
+# (bold_stroke, line_art, cutout, infographical, marker_outline, seamless).
+
+# "Generate a video from text"
+fimo generate pruna/p-video --prompt "<prompt>" --duration 6 --aspect-ratio 16:9
+# Why: baseline video model. Add --include-audio for sound.
+
+# "Quick rough video preview"
+fimo generate pruna/p-video-draft --prompt "<prompt>" --duration 4
+# Why: ~4× cheaper than pruna/p-video. Same shape; switch to pruna/p-video for final.
+
+# "Generate a video from an existing image"
+fimo generate pruna/p-video \
+  --prompt "<motion description>" --source-images <asset-id-or-url>
+# Why: same Pruna model — passing --source-images flips it to image-to-video mode.
+
+# "Cheap image-to-video alternative"
+fimo generate fal-ai/minimax/hailuo-02/standard/image-to-video \
+  --prompt "<motion>" --source-images <image-url> --duration 6
+# Why: cheap i2v. Source is an image URL (not an asset-id); duration is 6 or 10.
+# Output aspect comes from the source image.
 ```
 
-Add `--include-audio` when the result should contain generated audio.
-
-### Generate from an image
-
-```bash
-fimo video generate \
-  --prompt "subtle wind moves the leaves, locked camera" \
-  --image <asset-id-or-url> \
-  --duration 5 \
-  --aspect-ratio 16:9
-```
+---
 
-### Make a loop
+## Universal flags (every model)
 
-```bash
-fimo video generate \
-  --prompt "gentle water movement, seamless return to the first frame" \
-  --image <asset-id-or-url> \
-  --loop \
-  --duration 5
-```
+| Flag                  | Default        | Meaning                                                    |
+| --------------------- | -------------- | ---------------------------------------------------------- |
+| `--name <str>`        | slug of prompt | Asset display name in the library                          |
+| `--parent <asset-id>` | —              | Library placement (folder asset-id)                        |
+| `-C, --cwd <dir>`     | current dir    | Project directory to resolve the env from                  |
+| `--json`              | —              | Machine-readable output (jq-friendly)                      |
+| `--dry-run`           | —              | Validate flags + show resolved request, don't call the API |
 
-`--loop` requires `--image` and cannot be combined with `--include-audio`.
+> Cost: there is no cost flag on `generate`. Pricing lives in discovery and is
+> shown as the provider's **per-unit rate** (e.g. `$0.045 / second`,
+> `$0.04 / image`), not a synthesized total. `fimo models list` shows the rate
+> per model; `fimo models show <model>` prints a `PRICING` block. With `--json`,
+> each model carries `price: { unitPrice, unit, confidence }` (or `null`). A `~`
+> prefix means even the rate is approximate (metered).
 
-### Transfer motion from a video to an image
+---
 
-```bash
-fimo video animate \
-  --video <motion-source-asset-id-or-url> \
-  --image <subject-image-asset-id-or-url> \
-  --quality standard \
-  --duration 5
-```
+## Discovery — read a model's options before you use it
 
-### Replace people in a video
+Options are **not standardized across models** — each model declares its own
+flags. Before generating with a model you haven't used, read its options to
+understand what it can do (and what it expects): `fimo models show <model>`
+prints every flag with its type, default, enum values, description, and a usage
+example; `fimo generate <model> --help` prints the same flag list. Both come
+from the API (introspected server-side from the model's schema), so they can't
+drift. **Don't assume a flag carries across models** — e.g. `--aspect-ratio`
+exists on pruna but not on `gpt-image-2` / `seedream` (which size via
+`--image-size`).
 
 ```bash
-fimo video replace \
-  --video <source-video-asset-id-or-url> \
-  --images <identity-image-asset-id-or-url> \
-  --quality standard \
-  --duration 5
+fimo generate openai/gpt-image-2 --help
+fimo models list --modality video
+fimo models list --tag draft         # filter by tag (repeatable, AND semantics)
+fimo models list --extended          # per-model card: alias, provider, tags, price, best-for, flags
+fimo models show fal-ai/flux-pro/v1/vto          # PRICING rate + per-flag docs with usage examples
+fimo models show fal-ai/flux-pro/v1/vto --json   # same, machine-readable (price.unitPrice / price.unit + flags)
 ```
-
-Repeat `--images` for up to three identities. Add `--prompt` when placement needs clarification.
-
-## When to generate
-
-Generate when the page needs original artwork, a hero, a card thumbnail, an avatar, an empty-state illustration, or a short motion asset and the user has not supplied one.
-
-Do not generate when:
-
-- the user supplied or named a specific asset;
-- the result must depict a real person, team, product, or place accurately;
-- an existing media-library asset already fits the request.
-
-Upload real files with `fimo assets upload`. Browse reusable media with `fimo assets list` before spending credits.
-
-## Verification
-
-After generation:
-
-1. Confirm the command exited successfully and returned an asset ID.
-2. Open or download the asset with `fimo assets open <id>`.
-3. Verify it matches the request before inserting it into content or UI.
-4. Use the whole media value with Fimo's `<Image>` or `<Video>` components rather than raw HTML elements.

package/assets/skills/fimo-studio/references/custom-domains.md

@@ -1,6 +1,6 @@
 ## Also available via CLI
 
-If you're driving Fimo from the terminal, the equivalent commands are `fimo domains add`, `fimo domains refresh`, and `fimo domains remove`. The default URL (the `<slug>.fimo.site` subdomain) is managed with `fimo domains rename-default` and `fimo domains suggest-default` — both free, no Premium needed. See the `fimo-cli` skill's `references/domains.md`. Full docs: https://fimo.ai/docs/publish/custom-domains.
+If you're driving Fimo from the terminal, the equivalent commands are `fimo domains add`, `fimo domains refresh`, and `fimo domains remove`. The default URL (the `<slug>.fimo.site` subdomain) is managed with `fimo domains rename-default` and `fimo domains suggest-default` — both free, no Premium needed. See the `fimo-cli` skill's `references/domains.md`. Full docs: https://docs.fimo.ai/publish/custom-domains.
 
 ## Before You Start
 

package/dist/build/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/build/vite/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,YAAY,EAAE,MAAM,MAAM,CAAC;AAmFjD,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAGD,wBAAgB,IAAI,CAAC,IAAI,GAAE,eAAoB,GAAG,YAAY,EAAE,CAsB/D"}

package/dist/build/vite/plugins/content-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-sync.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/content-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAKlD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,IAAI,MAAM,CAkClD"}

package/dist/build/vite/plugins/content-sync.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=content-sync.test.d.ts.map

package/dist/build/vite/plugins/content-sync.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-sync.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/content-sync.test.ts"],"names":[],"mappings":""}

package/dist/build/vite/plugins/content-sync.test.js

@@ -0,0 +1,64 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import contentSyncPlugin from './content-sync';
+let scratch = null;
+const pluginContext = {
+    addWatchFile: vi.fn(),
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+    vi.clearAllMocks();
+});
+function createProjectRoot() {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-content-sync-plugin-'));
+    mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+    return scratch;
+}
+function configurePlugin(plugin, root) {
+    if (typeof plugin.configResolved === 'function') {
+        plugin.configResolved.call(pluginContext, { root });
+    }
+}
+describe('contentSyncPlugin', () => {
+    it('does not mutate generated files during a production build', () => {
+        const plugin = contentSyncPlugin();
+        expect(plugin.buildStart).toBeUndefined();
+        expect(plugin.generateBundle).toBeUndefined();
+        expect(plugin.writeBundle).toBeUndefined();
+    });
+    it('regenerates schema clients after a schema changes in dev', () => {
+        const root = createProjectRoot();
+        const schemaPath = join(root, 'src/schemas/Post.json');
+        writeFileSync(schemaPath, JSON.stringify({ uid: 'Post', name: 'Posts', fields: { title: { type: 'string' } } }, null, 2));
+        const listeners = new Map();
+        const server = {
+            watcher: {
+                add: vi.fn(),
+                on: vi.fn((event, listener) => {
+                    listeners.set(event, listener);
+                }),
+            },
+        };
+        const plugin = contentSyncPlugin();
+        configurePlugin(plugin, root);
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        listeners.get('change')?.(schemaPath);
+        expect(readFileSync(join(root, 'src/schemas/Post.ts'), 'utf8')).toContain('from "./Post.types";');
+        expect(readFileSync(join(root, 'src/schemas/Post.types.ts'), 'utf8')).toContain('export interface Post');
+    });
+});

package/dist/build/vite/plugins/data-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-id.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/data-id.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAOnC,MAAM,CAAC,OAAO,UAAU,YAAY,IAAI,MAAM,CA2F7C"}

package/dist/build/vite/plugins/fimo-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,IAAI,MAAM,CA6CjD"}

package/dist/build/vite/plugins/fimo-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fimo-config.test.d.ts.map

package/dist/build/vite/plugins/fimo-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.test.ts"],"names":[],"mappings":""}