summer-engine 1.4.0 → 2.0.0

package/README.md

@@ -1,103 +1,237 @@
-# Summer Engine CLI
+# Summer
 
-CLI and MCP tools for [Summer Engine](https://summerengine.com) — the AI-native game engine. MIT licensed.
+**Summer Engine is the AI game engine.** Build real 2D and 3D games through conversation. No coding required. Export to Steam, desktop, mobile, and web. Built on the Godot team's work, customized and honed so AI agents and humans can collaborate on great games.
 
-## Install
+This repo is **Summer's open-source agent layer** — a skills framework that gives any coding agent superpowers for game dev. Install once, works everywhere: Claude Code, Cursor, Codex CLI / App, Gemini CLI, OpenCode, Factory Droid, GitHub Copilot CLI, Windsurf. MIT licensed.
+
+It just works. Open your agent, say "let's make an FPS in Summer Engine," and it does.
+
+---
+
+## Install Summer in your agent
+
+Pick your tool. If you use more than one, install for each.
+
+| Agent | Command |
+|---|---|
+| **[Claude Code](#claude-code)** | `claude /plugin install summer@summer-marketplace` |
+| **[Codex CLI](#codex-cli)** | `/plugins` → search `summer` → install |
+| **[Codex App](#codex-app)** | Plugins → Coding → Summer → `+` |
+| **[Cursor](#cursor)** | `/add-plugin summer` |
+| **[Factory Droid](#factory-droid)** | `droid plugin install summer@summer-marketplace` |
+| **[Gemini CLI](#gemini-cli)** | `gemini extensions install https://github.com/SummerEngine/summer` |
+| **[GitHub Copilot CLI](#github-copilot-cli)** | `copilot plugin install summer@summer-marketplace` |
+| **[OpenCode](#opencode)** | Tell it: *"Fetch and follow https://raw.githubusercontent.com/SummerEngine/summer/main/.opencode/INSTALL.md"* |
+| **[Windsurf / others](#windsurf-and-others)** | `npm i -g summer-engine && summer setup <agent> --yes` |
+
+Then talk to your agent:
+
+> Let's make an FPS in Summer Engine.
+
+It loads the right skills, asks what you want, and starts building. That's it.
+
+---
+
+## You'll also need Summer Engine
+
+Most skills need the engine running locally.
 
 ```bash
 npm install -g summer-engine
+summer install        # downloads Summer Engine — see "What gets downloaded" below
+summer login
+summer create 3d-basic my-game
+summer run my-game
 ```
 
-Or use without installing:
+Or download it directly: **[summerengine.com/download](https://summerengine.com/download)**.
+
+You can install the agent plugin first and the engine later — most tools tell you what to do when the engine isn't running.
+
+---
+
+## What gets downloaded
+
+We tell you before we touch your disk.
+
+| What | Size | When | Source |
+|---|---|---|---|
+| `summer-engine` npm package | ~3 MB | `npm install -g summer-engine` | [npmjs.com/package/summer-engine](https://www.npmjs.com/package/summer-engine) |
+| Summer Engine app | ~145 MB | `summer install` | Summer's signed releases |
+| Auth token | ~1 KB | `summer login` | Browser → `~/.summer/auth-token` |
+| Skill files | < 50 KB | bundled in the npm package | no network call |
+| Generated assets (3D / image / audio / video) | varies | only on explicit `summer_generate_*` calls | Summer Engine Studio |
+| URL imports | varies | only on explicit `summer_import_from_url` calls | the URL you provide |
+
+Not downloaded:
+- No background telemetry. Diagnostics stay local.
+- No silent engine updates. You run `summer update` manually.
+- No model weights or AI binaries. Generation runs in Summer Engine Studio.
+
+Every install command takes `--dry-run`. Print the URL, target path, and SHA before anything moves.
+
+---
+
+## What's open and what's not
+
+| Thing | License | Source |
+|---|---|---|
+| **Summer** (this repo: skills, MCP server, CLI, hooks, plugin manifests) | **MIT** | [SummerEngine/summer](https://github.com/SummerEngine/summer) |
+| **Summer Engine** (the engine binary, editor, runtime) | proprietary, free to use | [summerengine.com/download](https://summerengine.com/download) |
+| **Summer Engine Studio** (asset generation, cloud) | proprietary, paid plans | [summerengine.com/pricing](https://summerengine.com/pricing) |
+
+The engine is the moat. The agent layer is open so you can audit it, fork it, extend the skills, and contribute back.
+
+---
+
+## How it works
+
+Two pieces, plus the glue.
+
+**Skills.** Twenty-four markdown files. Each one is a discipline guide for the agent. They auto-fire on natural language:
+
+- "Let's brainstorm a game" → `summer:brainstorm-game`
+- "It crashes when I press play" → `summer:debug`
+- "Add an FPS controller" → `summer:fps-controller`
+- "Make it look prettier" → `summer:art-direction`
+- "Set up multiplayer" → `summer:setup-multiplayer` → `summer:host-authoritative-state`
+
+Skills don't list steps. They encode the **order of operations**: diagnose before editing, scope before building, ask before guessing. [Agent Skills](https://agentskills.io) format, so any conformant tool picks them up.
+
+**MCP bridge.** The `summer-engine` MCP server gives the agent 37 tools that talk to your local engine on `localhost:6550`:
+
+| | |
+|---|---|
+| Scene | `summer_add_node`, `summer_set_prop`, `summer_replace_node`, `summer_get_scene_tree`, `summer_inspect_node`, `summer_batch` |
+| Diagnostics | `summer_get_script_errors`, `summer_get_diagnostics`, `summer_get_console`, `summer_get_debugger_errors` |
+| Runtime | `summer_play`, `summer_stop`, `summer_is_running` |
+| Project | `summer_get_project_context`, `summer_open_main_scene`, `summer_project_setting`, `summer_input_map_bind` |
+| Assets | `summer_search_assets`, `summer_import_asset`, `summer_import_from_url`, `summer_generate_image`, `summer_generate_3d`, `summer_generate_audio`, `summer_generate_video` |
+
+File ops, git, shell, grep — your agent already has those. We don't shadow them.
+
+**Lifecycle hooks.** A `session-start` hook detects whether you're in a Summer Engine project and feeds the agent a one-line orientation. An opt-in `pre-commit doctor` runs `summer doctor` before `git commit` and blocks on failure.
+
+For the full architecture, see [docs/OVERVIEW.md](docs/OVERVIEW.md).
+
+---
+
+## The basic workflow
+
+1. **using-summer** loads on session start. Sets workflow priority and the red-flag list.
+2. **brainstorm-game** scopes a new project. One question, one page, one direction.
+3. **scene-composition** picks the right hierarchy before any node lands.
+4. **fps-controller / design-mechanic / design-level / setup-multiplayer / vfx** produce the artifact.
+5. **gdscript-patterns** guides every `.gd` write.
+6. **play** runs the game and reports clean or broken.
+7. **debug** runs the cheapest diagnostic, forms one specific hypothesis, asks before editing, re-verifies after the fix.
+8. **export-and-ship** runs the pre-flight checklist before producing a release build.
+
+Twenty-four skills replace "agent flailing through tutorials" with measurable craft.
+
+---
+
+## What's inside
+
+**Process** — `using-summer`, `brainstorm-game`, `debug`, `play`
+
+**Project setup** — `new-project`, `browse-templates`, `make-game`, `scene-composition`
+
+**Build** — `fps-controller`, `design-mechanic`, `design-level`, `design-npc`
+
+**Multiplayer** — `setup-multiplayer`, `host-authoritative-state`, `peer-to-peer-multiplayer`
+
+**Look & feel** — `art-direction`, `audio-direction`, `3d-lighting`, `vfx`, `ui-basics`
+
+**Code & assets** — `gdscript-patterns`, `asset-strategy`
+
+**Performance & ship** — `tune-performance`, `export-and-ship`
+
+**Skill authoring** — `skill-create`, `skill-improve`, `skill-test`
+
+C# is supported by the engine. A `summer:csharp-patterns` skill is on the roadmap; for now write C# from Godot 4.5 docs.
+
+Full catalog with HAVE / NEXT / LATER status: [`skills/catalog.yaml`](./skills/catalog.yaml).
+
+## Philosophy
+
+- Skills auto-fire on natural language. No slash command required.
+- Diagnose before guessing. Read the error before grepping the code.
+- Process skills run before build skills.
+- Fewer tools, sharper tools.
+- The user owns decisions. The agent diagnoses and proposes.
+
+---
+
+## Install — full instructions per harness
+
+### Claude Code
 
 ```bash
-npx summer-engine <command>
+claude /plugin marketplace add SummerEngine/summer-marketplace
+claude /plugin install summer@summer-marketplace
 ```
 
-## Quickstart (under 2 minutes)
+When Summer lands on Anthropic's official marketplace, also:
 
 ```bash
-summer install                       # Download the engine
-summer login                         # Sign in via browser
-summer create 3d-basic my-game       # Create a starter project
-summer run my-game                   # Open it in the engine
-summer setup claude-code --yes       # Configure MCP + install recommended skills
+claude /plugin install summer@claude-plugins-official
 ```
 
-Replace `claude-code` with `codex`, `cursor`, or `windsurf`. Add `--scope project` to keep the configuration inside the project.
+### Codex CLI
 
-Verify:
+```
+/plugins
+```
 
-```bash
-summer doctor
+Search `summer`, install.
+
+### Codex App
+
+Sidebar → **Plugins** → **Coding** → click `+` next to **Summer**.
+
+### Cursor
+
+```
+/add-plugin summer
 ```
 
-Then open your agent and try one of the slash commands:
+Or search `summer` in the Cursor plugin marketplace.
 
-| Command | What it does |
-|---|---|
-| `/debug` | Triage and fix a bug end-to-end (reads engine errors, locates code, proposes fix) |
-| `/play` | Run the game and report state (clean run, warnings, or crash) |
-
-Or just describe what you want — the specialist skills (FPS controller, lighting, GDScript patterns, scene composition, UI, asset strategy) auto-trigger on natural language: "make me an FPS", "add lighting", "I need a HUD".
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `summer install` | Download and install Summer Engine |
-| `summer login` | Sign in via browser (Google/GitHub) |
-| `summer logout` | Clear auth tokens |
-| `summer status` | Check engine status, port, auth state |
-| `summer doctor` | Diagnose Node, login, engine, local API, MCP boot |
-| `summer run [path]` | Launch engine (optionally with a project) |
-| `summer open <path>` | Open a project in the running engine |
-| `summer create <template> [name]` | Create new project from template |
-| `summer list templates \| projects` | List available templates or local projects |
-| `summer skills list` | Show available skills |
-| `summer skills install <name>` | Install one skill |
-| `summer skills install --recommended --agent <agent>` | Install the recommended set |
-| `summer mcp` | Start the MCP server (used by Codex/Cursor/Claude Code/Windsurf) |
-| `summer mcp setup <agent>` | Write MCP config for an agent |
-| `summer setup <agent>` | One shot: MCP config + recommended skills + doctor |
-
-Supported agents: `codex`, `claude-code`, `cursor`, `windsurf`. Supported scopes: `user` (default), `project`.
-
-## Plugin install (Claude Code)
+### Factory Droid
 
 ```bash
-claude /plugin install summer-engine
+droid plugin marketplace add https://github.com/SummerEngine/summer-marketplace
+droid plugin install summer@summer-marketplace
 ```
 
-That registers Summer as a plugin under the `summer:` namespace. Skills appear in the slash menu as `summer:brainstorm-game`, `summer:debug`, `summer:play`, etc. The plugin also bundles:
+### Gemini CLI
 
-- A `summer-engine` MCP server (configured automatically — no manual `~/.claude.json` edit needed).
-- Lifecycle hooks: a `session-start` greeter that detects Godot/Summer projects and reads `.summer/GameSoul.md`; a `pre-commit-doctor` hook (opt-in) that runs `summer doctor` before commits.
+```bash
+gemini extensions install https://github.com/SummerEngine/summer
+```
 
-For Cursor, Codex, OpenCode, and Gemini, see [docs/CURSOR.md](docs/CURSOR.md), [docs/CODEX.md](docs/CODEX.md), and the manifests at `.cursor-plugin/`, `.codex-plugin/`, `.opencode/`, `gemini-extension.json` respectively.
+Update later: `gemini extensions update summer`.
 
-## MCP Integration
+### GitHub Copilot CLI
 
-`summer setup <agent>` writes the right config in the right place. If you need to do it by hand:
+```bash
+copilot plugin marketplace add SummerEngine/summer-marketplace
+copilot plugin install summer@summer-marketplace
+```
 
-**Cursor** (`.cursor/mcp.json` per project, or `~/.cursor/mcp.json` user-wide):
+### OpenCode
 
-```json
-{
-  "mcpServers": {
-    "summer-engine": {
-      "command": "npx",
-      "args": ["summer-engine", "mcp"]
-    }
-  }
-}
+```bash
+npm install --save-dev summer-engine
 ```
 
-**Claude Code** (`~/.claude.json` user-wide, or `.mcp.json` per project):
+Add to `opencode.json`:
 
 ```json
 {
-  "mcpServers": {
+  "plugin": ["summer-engine/.opencode/plugins/summer.js"],
+  "mcp": {
     "summer-engine": {
       "command": "npx",
       "args": ["summer-engine", "mcp"]
@@ -106,46 +240,94 @@ For Cursor, Codex, OpenCode, and Gemini, see [docs/CURSOR.md](docs/CURSOR.md), [
 }
 ```
 
-**Codex** (`~/.codex/config.toml`):
+Restart. Full guide: [`.opencode/INSTALL.md`](./.opencode/INSTALL.md).
 
-```toml
-[mcp_servers.summer-engine]
-command = "npx"
-args = ["summer-engine", "mcp"]
+### Windsurf and others
+
+```bash
+npm install -g summer-engine
+summer setup <agent> --yes
+summer doctor
 ```
 
-The MCP server exposes focused tools for scene manipulation, inspector/resource ops, project settings, asset import, play/stop, diagnostics, and asset search/generation. Tools the host agent already has natively (file ops, git, shell, grep) are intentionally not exposed.
+---
+
+## CLI reference
+
+| Command | What it does |
+|---|---|
+| `summer install` | Download Summer Engine. Transparent — prints URL + size first. |
+| `summer login` | Browser-based sign-in. |
+| `summer logout` | Clear auth tokens. |
+| `summer status` | Engine state, port, auth. |
+| `summer doctor` | Diagnose Node, login, engine, MCP. |
+| `summer run [path]` | Launch the engine. |
+| `summer open <path>` | Open a project in a running engine. |
+| `summer create <template> [name]` | Scaffold a project. |
+| `summer list templates` / `projects` | Browse. |
+| `summer skills list` | Show all skills. |
+| `summer skills install <name>` | Install one. |
+| `summer skills install --recommended --agent <agent>` | Install the recommended set. |
+| `summer mcp` | Start the MCP server. |
+| `summer mcp setup <agent>` | Write MCP config for an agent. |
+| `summer setup <agent> [--yes]` | One shot: MCP config + recommended skills + doctor. |
+
+Agents: `claude-code`, `codex`, `cursor`, `gemini`, `opencode`, `windsurf`. Scopes: `--scope user` (default), `--scope project`.
+
+---
+
+## Verify
 
-**Visual feedback** (viewport and game screenshots) is currently available in the Summer Engine app via the built-in Summer Agent. MCP support for screenshots is on the MVP2 roadmap, gated on host clients reliably consuming image content.
+In a fresh agent session:
 
-## How It Works
+> Let's make an FPS in Summer Engine.
 
-1. Summer Engine runs a local API server on `localhost:6550`.
-2. The MCP server (`npx summer-engine mcp`) connects to that local API via a per-machine auth token (`~/.summer/api-token`) and exposes engine ops as MCP tools.
-3. Agents call the MCP tools and edit `.gd`/`.cs`/`.json`/`.md` files directly with their own file tools. Scenes (`.tscn`) flow through MCP.
+The agent should auto-load `summer:fps-controller` before writing code. If it doesn't, run `summer doctor`.
 
-The engine must be running for MCP tools that touch scenes/assets/diagnostics. If it isn't, tools return a clear error pointing at `summer run`.
+---
 
-## Per-Agent Docs
+## Templates
+
+| Template | What you get |
+|---|---|
+| `empty` | Empty 3D project with a root node |
+| `3d-basic` | 3D scene with camera, light, floor |
+
+More coming.
+
+---
+
+## Contributing
+
+Skills evolve fast. Two ways to help:
+
+1. **Open an issue** if a skill misfires. Quote the prompt and the response.
+2. **Submit a SKILL.md** for one of the `NEXT` entries in [`skills/catalog.yaml`](./skills/catalog.yaml). Run `summer:skill-test` against it before opening the PR.
+
+[`docs/DEVELOPMENT.md`](./docs/DEVELOPMENT.md) is the contributor guide.
+
+---
+
+## Per-harness docs
 
-- [Agent Kit overview](docs/AGENT_KIT.md)
 - [Claude Code](docs/CLAUDE_CODE.md)
 - [Codex](docs/CODEX.md)
 - [Cursor](docs/CURSOR.md)
+- [OpenCode](.opencode/INSTALL.md)
 - [Skills overview](docs/SKILLS.md)
-- [Templates overview](docs/TEMPLATES.md)
-
-## Templates
+- [Templates](docs/TEMPLATES.md)
+- [Architecture overview](docs/OVERVIEW.md)
 
-Built-in templates:
+---
 
-- `empty` — Empty 3D project with a root node
-- `3d-basic` — 3D scene with camera, light, and floor
+## License
 
-More templates coming soon.
+MIT for everything in this repo. Summer Engine itself is proprietary. See [What's open and what's not](#whats-open-and-whats-not).
 
 ## Links
 
 - [Website](https://summerengine.com)
+- [Download Summer Engine](https://summerengine.com/download)
 - [Documentation](https://summerengine.com/docs)
 - [Community](https://summerengine.com/community)
+- [Issues](https://github.com/SummerEngine/summer/issues)

package/dist/commands/assets.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const assetsCommand: Command;

package/dist/commands/assets.js

@@ -0,0 +1,189 @@
+import { Command } from "commander";
+import { getAuthToken } from "../lib/auth.js";
+import { getClient } from "../lib/with-engine.js";
+import { outputResult, outputError, isJsonMode } from "../lib/format.js";
+const GATEWAY_URL = process.env.SUMMER_GATEWAY_URL || "https://www.summerengine.com";
+const KENNEY_URL_PATTERN = /\/kenney\/3d\/([^/]+)\//;
+function getPackSlugFromUrl(fileUrl) {
+    return fileUrl.match(KENNEY_URL_PATTERN)?.[1] ?? null;
+}
+function buildKenneyTextureUrl(fileUrl) {
+    const lastSlash = fileUrl.lastIndexOf("/");
+    const base = lastSlash >= 0 ? fileUrl.slice(0, lastSlash) : fileUrl;
+    return `${base}/Textures/colormap.png`;
+}
+async function textureExists(url) {
+    try {
+        const res = await fetch(url, {
+            method: "HEAD",
+            signal: AbortSignal.timeout(5000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function buildKenneyImportEntries(fileUrl, packSlug, fileName) {
+    const textureUrl = buildKenneyTextureUrl(fileUrl);
+    const hasTexture = await textureExists(textureUrl);
+    if (!hasTexture) {
+        return [
+            {
+                url: fileUrl,
+                path: `res://assets/models/kenney/${packSlug}/${fileName}`,
+            },
+        ];
+    }
+    const glbPath = `res://assets/models/kenney/${packSlug}/${fileName}`;
+    const glbDir = glbPath.replace(/\/[^/]+$/, "");
+    const texturePath = `${glbDir}/Textures/colormap.png`;
+    return [
+        { url: textureUrl, path: texturePath },
+        { url: fileUrl, path: glbPath },
+    ];
+}
+async function searchAssetsApi(params) {
+    const token = await getAuthToken();
+    if (!token) {
+        return {
+            error: "Not logged in",
+            message: "Not signed in. Run: summer login\nOr open: https://www.summerengine.com/login\nAsset search requires a Summer Engine account (free to create).",
+        };
+    }
+    const searchParams = new URLSearchParams();
+    searchParams.set("query", params.query);
+    if (params.assetType && params.assetType !== "all") {
+        searchParams.set("assetType", params.assetType);
+    }
+    if (params.limit) {
+        searchParams.set("limit", String(params.limit));
+    }
+    const res = await fetch(`${GATEWAY_URL}/api/mcp/assets?${searchParams}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(15000),
+    });
+    const data = (await res.json());
+    if (!res.ok) {
+        if (res.status === 402) {
+            return {
+                error: "upgrade_required",
+                message: (data.message || "Asset search requires a Pro subscription.") +
+                    "\nUpgrade at: https://www.summerengine.com/pricing",
+                plan: data.plan,
+            };
+        }
+        if (res.status === 401) {
+            return {
+                error: "unauthorized",
+                message: (data.message || "Auth token expired.") +
+                    " Run: summer login --force",
+            };
+        }
+        return {
+            error: data.error || "Search failed",
+            message: data.message || "Asset search failed",
+        };
+    }
+    return data;
+}
+export const assetsCommand = new Command("assets").description("Search and import assets from the Summer Engine library");
+assetsCommand
+    .command("search <query>")
+    .description('Search the asset library (e.g. summer assets search "low-poly tree")')
+    .option("--type <type>", "Filter: 2d_image, animation, 3d_model, audio, music, all", "all")
+    .option("--limit <n>", "Max results (1-20)", "10")
+    .action(async (query, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const result = await searchAssetsApi({
+            query,
+            assetType: opts.type,
+            limit: Math.min(parseInt(opts.limit, 10), 20),
+        });
+        if (result.error) {
+            outputError(result.message || result.error, fmt);
+        }
+        outputResult(result, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});
+assetsCommand
+    .command("import <query>")
+    .description("Search and import the best match into the project in one step")
+    .option("--parent <path>", "Parent node to add the asset under (e.g. ./World)")
+    .option("--type <type>", "Preferred type: 2d_image, animation, 3d_model, audio, music, all", "3d_model")
+    .action(async (query, opts, cmd) => {
+    const fmt = isJsonMode(cmd);
+    try {
+        const searchResult = await searchAssetsApi({
+            query,
+            assetType: opts.type,
+            limit: 5,
+        });
+        if (searchResult.error) {
+            outputError(searchResult.message || searchResult.error, fmt);
+        }
+        const assets = searchResult.assets || [];
+        if (assets.length === 0) {
+            outputError(`No assets found for "${query}". Try different keywords.`, fmt);
+        }
+        const best = assets[0];
+        const fileUrl = best.fileUrl;
+        if (!fileUrl) {
+            outputError("Asset has no download URL.", fmt);
+        }
+        const fileName = fileUrl.split("/").pop()?.split("?")[0] || "asset";
+        const packSlug = best.packSlug ?? getPackSlugFromUrl(fileUrl) ?? "misc";
+        let imports;
+        if (best.type === "3d_model" && fileUrl.includes("kenney/3d/")) {
+            imports = await buildKenneyImportEntries(fileUrl, packSlug, fileName);
+        }
+        else {
+            const path = best.type === "3d_model"
+                ? `res://assets/models/${fileName}`
+                : `res://assets/${fileName}`;
+            imports = [{ url: fileUrl, path }];
+        }
+        const importPath = imports[imports.length - 1].path;
+        const client = await getClient();
+        const importResult = imports.length === 1
+            ? await client.executeOps([
+                {
+                    op: "ImportFromUrl",
+                    url: imports[0].url,
+                    path: imports[0].path,
+                },
+            ])
+            : await client.executeOps([
+                { op: "ImportFromUrlBatch", imports },
+            ]);
+        const ok = importResult?.results?.[0]?.ok;
+        if (!ok) {
+            outputError(`Import failed for "${best.title}". Check engine logs.`, fmt);
+        }
+        if (opts.parent && best.type === "3d_model") {
+            await client.executeOps([
+                {
+                    op: "InstantiateScene",
+                    parent: opts.parent,
+                    scene: importPath,
+                    name: best.title.replace(/\s+/g, "_"),
+                },
+            ]);
+        }
+        outputResult({
+            success: true,
+            asset: best.title,
+            type: best.type,
+            importedTo: importPath,
+            addedToScene: !!opts.parent,
+            parent: opts.parent || null,
+        }, fmt);
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err), fmt);
+    }
+});