@parity-app/cli 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity-app/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "description": "Drive the Parity app from a terminal or an agent: read state, run edits, take screenshots, serve MCP.",
@@ -34,6 +34,11 @@
     "dist",
     "skills"
   ],
+  "scripts": {
+    "build": "vp pack",
+    "prepack": "vp pack",
+    "try-packed": "node scripts/try-packed.ts"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -42,12 +47,9 @@
     "typescript": "6.0.3"
   },
   "devDependencies": {
+    "@parity-app/agent": "0.0.0",
     "@parity-app/core": "0.0.0",
     "@parity-app/libgen": "0.0.0",
     "@parity-app/registry": "0.0.0"
-  },
-  "scripts": {
-    "build": "vp pack",
-    "try-packed": "node scripts/try-packed.ts"
   }
-}
+}

package/skills/SKILL.md

@@ -22,25 +22,62 @@ it.
 
 ## Tools
 
-The same tools are MCP tools and `parity` commands in a terminal. They act on a tab, which is one open project; the
-active tab is the default.
+The same tools are MCP tools and `parity` commands in a terminal. They act on a tab, which is one open project. Without
+`tab`, they act on the open project your working folder is in, and otherwise on `active`: what the person is looking at,
+the active tab of the Parity window they used last. When the person says "this" or "what I've selected" without naming a
+project, pass `tab: "active"` (`--tab active`) and read `get_app_state` for the selection.
 
 | MCP                   | CLI                          | What it does                                                                                                                                               |
 | --------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `get_app_state`       | `parity state`               | Designs, the selection, modes, components and token names, and what Parity detected (builder and config, package manager, installed versions). Start here. |
-| `execute`             | `parity exec`                | Runs a JavaScript snippet against the designs. All changes land as one undo step.                                                                          |
+| `get_status`          | `parity status`              | The revision, whether anything is unsaved and which files and tokens, the last save, and undo and redo; `summary` names them.                              |
+| `get_modes`           | `parity modes [design]`      | Viewports (the ids `Responsive` takes), modes (the ids renders take) and what each design shows; a design adds its frames.                                 |
+| `execute`             | `parity exec`                | Runs a JavaScript snippet against the designs. Its changes land as one undo step, merged per design with edits made meanwhile.                             |
 | `screenshot`          | `parity screenshot <design>` | Renders a design in its states and modes, offscreen, and returns the images.                                                                               |
 | `find_problems`       | `parity problems <design>`   | Render errors, overflow, clipping and unknown components, per frame.                                                                                       |
 | `check_accessibility` | `parity a11y <design>`       | axe-core against WCAG 2.2 AA, per frame, on the layers that break each rule.                                                                               |
 | `get_console`         | `parity console`             | What the project's own code wrote to the console, on the canvas and offscreen.                                                                             |
+| `get_tokens`          | `parity tokens`              | Tokens filtered by category, source or name, with values in every theme.                                                                                   |
+| `get_components`      | `parity components`          | Components, libraries, icon sets and exports left out or failing to render.                                                                                |
+| `get_props`           | `parity props <Component>`   | Props from source; `all` includes passed-through attributes.                                                                                               |
 | `get_tabs`            | `parity tabs`                | The open projects.                                                                                                                                         |
 | `open_project`        | `parity open <folder>`       | Opens a project in a new tab.                                                                                                                              |
 | `read_skill`          | `parity skill [file]`        | This skill.                                                                                                                                                |
 
-In a terminal, `parity tokens`, `parity components` and `parity props <Component>` read what designs can use without
-writing a snippet. `parity components` also says which of the app's exports aren't components and why, which components
-fail to draw on the canvas and why (often a missing provider, which a decorator adds), and what the person listed or
-took off the list by hand.
+The token, component and prop tools read what designs can use without writing a snippet in either transport.
+`parity components` also says which of the app's exports aren't components and why, which components fail to draw on the
+canvas and why (often a missing provider, which a decorator adds), and what the person listed or took off the list by
+hand.
+
+CLI commands and MCP tools share validation and defaults. Screenshot scale defaults to 1 and accepts 0.25 to 3. Audits
+check every state and shown mode unless narrowed; a single-element selector list is equivalent to a string. Screenshot
+failures and audit findings exit with 1 in the CLI and set MCP `isError`, with details retained. `get_console` defaults
+`clear` to false; `get_props` defaults `all` to false. MCP project paths must be absolute; the CLI resolves relative
+folders from its working directory. Skill reading is local and needs no running app.
+
+Several copies of Parity can run at once, each with its own projects open. Each call goes to the copy that has its
+project open, so naming the project is enough; `get_tabs` lists every copy's projects. A project open in two copies goes
+to the one that has been running longest. A copy kept apart with `PARITY_AGENT_FILE` is reached only through that file:
+
+```sh
+parity tabs                                         # every project open in any copy
+parity state --tab active                           # what the person is looking at, and their selection
+PARITY_AGENT_FILE=copy/agent.json pnpm dev &        # a copy of Parity kept apart
+PARITY_AGENT_FILE=copy/agent.json parity tabs       # just that copy
+```
+
+Every tool returns its result as data too: MCP `structuredContent`, or `--json` in the CLI. Read that rather than the
+text. A failure has `error.code` to branch on, `retryable` (send it again unchanged), `path` (the input at fault) and
+`alternatives` (valid ids for one it didn't know), so a mistyped id is fixed in one retry:
+
+```sh
+parity problems button --state loading --json
+# {"error": {"code": "unknown_state", "path": "/state", "alternatives": ["default", "outline", "destructive", "disabled"], ...}}
+parity problems button --state disabled --json
+```
+
+`get_tokens` returns the first 100 tokens and `get_console` the newest 50 messages, with `total` and `truncated`; narrow
+the read or raise `limit` when `truncated` is true.
 
 When a library's components, tokens or icons don't show, `parity lib <package> --root <project>` describes the package
 in a `.lib.par`: its components, tokens and the providers its frames need. It writes `./<id>.lib.par` in the current
@@ -54,7 +91,8 @@ keeping the designs there, so ask before running that in someone's project.
 2. **Look before you change.** Read the design with `Get("design-id", { depth: 3 })` in `execute`, and take a screenshot
    of what's there. Find the components you need with `Components()` and their props with `Props()`.
 3. **Change it in one snippet.** Build or edit the design with `Insert`, `Update`, `Replace`, `Move` and the rest. A
-   snippet either applies whole, as one step the person can undo, or changes nothing. Name the layouts you make.
+   snippet either applies whole, as one step the person can undo, or changes nothing. Name the layouts you make. If it
+   fails because the person changed a design it changes, run it again by its `editId`.
 4. **Cover every state.** A screen that loads has a loading state, a list has an empty one, a form has an error one. Add
    them with `AddState`, as changes to the base design, not as copies.
 5. **Check every frame.** Screenshot the design in all its states and the modes it shows (`state: "all"`,
@@ -65,7 +103,15 @@ keeping the designs there, so ask before running that in someone's project.
 
 Your changes to designs are on the canvas but not saved: the person saves (Ctrl+S) or undoes them, as with their own
 edits. Don't say they're saved. Token values from `SetTokens` are the same: they show at once, and go into the project's
-stylesheet when the person saves.
+stylesheet when the person saves. `get_status` says what's saved and what isn't, and its `revision` (also in
+`get_app_state`) stays the same until something changes, so compare it before reading the board again:
+
+```sh
+parity status --summary
+# shadcn-vite is at revision 7c612c04:1.
+# 1 file isn't saved. They wait for the person to save; agents can't.
+#   shadcn-vite.par: changed button
+```
 
 ## Rules
 
@@ -86,11 +132,12 @@ stylesheet when the person saves.
 - **Reuse what repeats.** When a row, card or list item appears more than twice, make it a component design with
   `ExtractComponent`, so each copy is an instance with its own content.
 - **Leave the canvas tidy.** New designs go into empty space (`FindEmptySpace`); `Overlaps()` tells you if boards
-  collide.
+  collide, sizing boards the canvas hasn't drawn yet from their frames (`estimated: true`).
 
 ## When something fails
 
-`execute` returns an `editId` when a snippet throws, and nothing changes. Fix it with `editId` and `edits` (exact find
-and replace on the snippet) instead of sending it all again. The error names the line. Common causes: a node path that
-matches two designs (write it as `design/node`), a node property that doesn't exist, and a state change to something
-states can't change (only `hidden`, `text`, `props` and `style`).
+`execute` returns an `editId` when a snippet throws, and nothing changes; `error.code` says why, and
+`error.alternatives` names the valid ids when a design, state, mode or component wasn't found. Fix it with `editId` and
+`edits` (exact find and replace on the snippet) instead of sending it all again. The error names the line. Common
+causes: a node path that matches two designs (write it as `design/node`), a node property that doesn't exist, and a
+state change to something states can't change (only `hidden`, `text`, `props` and `style`).

package/skills/document.md

@@ -154,7 +154,8 @@ or hides the node. `ExtractComponent` sets all of this up from the occurrences i
 A **variant** is a param whose `options` each patch the component design, the way a state does: a size or a tone the
 instance chooses. Its `default` is an option's id, else the first option. An instance picks one in its `args`, and
 `view.variants` picks which one the component's own board shows. Patches apply in this order: the viewport's, the
-variant options', the state's, then the instance's overrides.
+variant options', the state's, then the instance's overrides. `Get` returns the stored node, with the text it was given;
+`Get(path, { state })` returns it as the board shows it, the param's value filled in and `bind` kept (see execute.md).
 
 ```json
 "params": {

package/skills/execute.md

@@ -4,12 +4,30 @@
 `await` works at the top level. When the snippet finishes, every change lands on the canvas as one step the person can
 undo; when it throws, nothing changes and you get an `editId` to fix it with.
 
-- Pass `description`: 3 to 8 words the person sees while it runs, such as "Add a pricing section".
+The person, and other agents, can change the tab while your snippet runs. Only the designs your snippet changed, created
+or deleted are applied, over what's there by then, so their edits to other designs, even in the same file, stay. If a
+design you changed was changed or deleted in the meantime, or the modes were and you set them, nothing is applied and
+the call fails naming it:
+
+```text
+Failed, nothing changed: Not applied: since this call read the tab, "Pricing" (app.par) was changed in the editor, and
+this call changes it too. Run the call again to work from what's there now.
+```
+
+Run it again with its `editId` and no edits (`parity exec --edit-id <id>`, or `execute` with just `editId`): the snippet
+reads the tab afresh, so it works from their change. Read the design again first if your snippet depends on what it
+held.
+
+- Prefer a `description` of 3 to 8 words, such as "Add a pricing section". CLI `exec` calls it `--label`. Both default
+  to "Edit designs" if omitted.
 - `Print(...)` (or `console.log`) is how you see values. Objects print as JSON.
 - Values assigned without `const` or `let` carry over to your next snippet in the same tab.
 - A snippet has 5 seconds of computing time. Rendering (screenshots and checks) doesn't count against it.
 - To retry a failed snippet, send `editId` with `edits`, each an exact `{ find, replace }` on the snippet text (`all` to
-  replace every match).
+  replace every match). Omitted edits default to an empty list. Do not send a new snippet with `editId`.
+- Both CLI and MCP validate the same request: a nonblank snippet or `editId`, nonblank label and tab when supplied, and
+  patches with a nonempty `find`, string `replace` (which can be empty), and optional boolean `all`. Invalid requests
+  are rejected before reaching the app.
 
 ## API
 
@@ -17,14 +35,15 @@ undo; when it throws, nothing changes and you get an `editId` to fix it with.
 // Reading
 Designs(): DesignSummary[]                       // every design: id, name, kind, states, what it shows, size
 GetDesign(design): Design                        // a whole design, as in document.md
-Get(path, { depth?, state? }?): Node             // a design's root or a node; depth cuts children off with "…"
+Get(path, { depth?, state?, mode? }?): Node      // a design's root or a node; depth cuts children off with "…"
 Get(path?, visit): any[]                         // walks nodes, collecting what visit returns
+Get(path, visit, { state?, mode? }): any[]       // walks nodes as a frame draws them
 Components(): string[]                           // the components designs can use
 Props(component, { all? }?): PropsInfo           // a component's props, from its source
 Icons(): IconSet[]                               // the project's icon sets, with their styles
 Icons(set, { search?, style?, limit? }): Icon[]  // async: a set's icons, as component nodes name them
 GetTokens({ category?, source?, search? }?): Token[]
-GetModes(): { settings, modes }                  // the project's modes, and each resolved
+GetModes(design?): { settings, variables, viewports, modes, designs }   // modes resolved; what each design shows
 Selection(): { design?, node?, mode? }           // what the person has selected
 
 // Designs
@@ -82,11 +101,27 @@ canvas, the main mode and the modes beside it. Start here to find ids.
 ### Get
 
 `Get("dashboard", { depth: 2 })` returns the design's root with two levels of children; deeper ones show as `"…"`. Read
-a branch with a node path, as in `Get("dashboard/Stats", { depth: 2 })`. With `state`, the result shows the nodes as
-that state changes them.
+a branch with a node path, as in `Get("dashboard/Stats", { depth: 2 })`. Without `state` or `mode`, Get returns the
+nodes as stored, which is what `Update` and the other edits change.
+
+With `state`, `mode` or both, Get returns the nodes as that frame of the board draws them: the design's variant options
+(`view.variants`), its params' defaults filled into bound values, its responsive patches for the mode, then the state's
+patches. `mode` is a mode id from `GetModes()`, as Screenshot takes. A state alone is read in the design's main mode,
+and a mode alone in the state the design shows. A bound value comes back filled in, with its `bind` kept so you can tell
+it comes from a param. An instance comes back as its own node with the args it's drawn with; read what's inside it by
+its path, `design/instance/inner`, which only works with `state` or `mode`.
+
+```js
+// A component whose title is bound to its "title" param: stored, then as the board shows it.
+Print(Get("card/title").text) // "Title"
+Print(Get("card/title", { state: "base" }).text) // "Card title", the param's default
+// A copy of the card on a screen, inside the instance, in a state and on mobile.
+Print(Get("profile/person/title", { state: "selected", mode: "mobile-light" }).text) // "Selected"
+```
 
 `Get(path, visit)` walks the nodes under `path`, or every design without one, and returns what `visit` returns for each.
-`visit(node, { design, path, depth, index, parent, skipChildren })`. Return `undefined` to collect nothing.
+`visit(node, { design, path, depth, index, parent, skipChildren })`. Return `undefined` to collect nothing. Given a
+path, `Get(path, visit, { state, mode })` visits the nodes as that frame draws them, as above.
 
 ```js
 // Every Button in the project, with where it is.
@@ -239,6 +274,18 @@ ExtractComponent("team-members", rows.nodes, { name: "Member row", params: { [ro
 `SetModes(settings)` replaces the project's modes: take `GetModes().settings`, change it, and pass it back. Modes are
 shared by every design.
 
+`GetModes()` also gives `viewports`, the ids `Responsive` takes, each with its width and window height; `modes`, the ids
+`Screenshot` and the checks take, each with its `values` (one option per variable), width, window height, classes and
+attributes; and `designs`, each design's `state` (or `states` when it shows every state), `main` mode and `beside`
+modes. `GetModes("dashboard")` gives just that design, with each frame's width, fixed `height` if it has one, and
+`window`.
+
+```js
+const { viewports, designs } = GetModes("dashboard")
+Print(viewports.map((viewport) => viewport.id)) // ["desktop", "tablet", "mobile"]: for Responsive
+Print(designs[0].frames.map((frame) => `${frame.mode} ${frame.window.width}x${frame.window.height}`))
+```
+
 `SetTokens` changes token values in the project's stylesheets: `SetTokens({ primary: "oklch(0.55 0.2 260)" })` for every
 theme, or `SetTokens({ primary: { default: "…", dark: "…" } })` per theme. Every frame shows the new values at once, and
 saving writes them into the project's code, so do it only when the person asks to change the design system, not to style
@@ -250,15 +297,34 @@ one design. They're undone with the call's other changes.
 result. `state` and `mode` take an id, a list, or `"all"`; `mode` also takes `"shown"`, the modes the design shows. The
 defaults are the state on the canvas and the main mode.
 
+Frames draw as the canvas does: instances of a library's component designs (from its `.lib.par`) draw that design, and
+token values not yet saved show, the person's edits and this call's own `SetTokens` alike, so
+`SetTokens({ primary: "red" }); await Screenshot(id)` shows the new value in the same call.
+
 `Measure` lays out one frame and returns its size, whether it overflows sideways, and every node's box (`clipped` when a
 parent cuts it off). `Problems` checks frames for render errors, overflow, clipping and unknown components.
 `Accessibility` returns axe-core's findings per node and frame, with the rule, its impact and what's wrong.
 
+These frames are drawn in the same window as the canvas's: as wide as the frame, and as tall as the design's fixed
+height for the viewport, else the viewport's screen height, else the device nearest its width. So `100vh` and window
+size checks measure the same in `Measure` and `Screenshot` as on the canvas, even when the frame grows past that height.
+
 ## The canvas
 
 `FindEmptySpace({ width, height })` finds room for a new board, to the right of the others unless `direction: "below"`,
 or next to the design named in `near`. `Overlaps()` lists boards that collide, titles included; move one with
-`UpdateDesign(design, { x, y })`.
+`UpdateDesign(design, { x, y })`. A board is as big as the canvas last drew it. One it hasn't drawn yet is sized from
+its frames, laid out as the canvas lays them out: each shown mode's frame size (`frames` on the design, else the mode's
+width), companions shrunk to 640 wide, and a frame without a fixed height as tall as its window. Those overlaps say
+`estimated: true`.
+
+```js
+// With the default modes: a 1280 main frame, the dark one beside it at half size and the 390 phone, 2505 wide in all.
+const dashboard = CreateDesign({ name: "Dashboard", x: 0, y: 0 })
+UpdateDesign(dashboard, { showModes: ["desktop-dark", "mobile-light"] })
+CreateDesign({ name: "Settings", x: 2200, y: 0 })
+Print(Overlaps(dashboard)) // Dashboard and Settings, 305 across, estimated: true
+```
 
 ## Examples
 

package/skills/guide/states-and-modes.md

@@ -30,9 +30,11 @@ Modes are the project's, shared by every design. Each mode picks one option of e
 - **Theme:** a class on the frame, such as `dark`, that switches the project's tokens.
 - **Locale:** `lang` and `dir` attributes, for languages and right-to-left scripts.
 
-`GetModes()` lists them. A design shows its main mode and, beside it, any others you choose with
-`UpdateDesign(design, { showModes: ["desktop-dark", "mobile-light"] })`. Show the modes that matter for the design: a
-dashboard in desktop and mobile, a component in light and dark.
+`get_modes` (`parity modes`) lists them, and `get_modes` with a design gives its frames: run it before a responsive
+change, since the ids `Responsive` takes are viewports (`mobile`) and the ids screenshots take are modes
+(`mobile-light`). `GetModes()` gives the same in a snippet. A design shows its main mode and, beside it, any others you
+choose with `UpdateDesign(design, { showModes: ["desktop-dark", "mobile-light"] })`. Show the modes that matter for the
+design: a dashboard in desktop and mobile, a component in light and dark.
 
 ## Viewports and responsive patches
 

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Andrew Craswell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/client-DsTLQ2lT.mjs

@@ -1,286 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-import { homedir } from "node:os";
-// src/caller.ts
-/** Who is driving Parity, named the way people know it, for the agent's cursor on the canvas. */
-/** Known clients, by the name they give MCP's `initialize`, most specific first. */
-const clients = [
-	[/claude[-_ ]?code/i, "Claude Code"],
-	[/^claude/i, "Claude"],
-	[/cursor/i, "Cursor"],
-	[/codex/i, "Codex"],
-	[/gemini/i, "Gemini CLI"],
-	[/windsurf|codeium/i, "Windsurf"],
-	[/copilot|visual studio code|^vscode/i, "Copilot"],
-	[/zed/i, "Zed"],
-	[/cline/i, "Cline"],
-	[/goose/i, "Goose"]
-];
-/**
-* An MCP client's name for people: a known agent's own name, else the title it gives, else its name with its
-* separators made spaces and its words capitalized ("my-agent" becomes "My Agent").
-*/
-function mcpCallerName(clientInfo) {
-	const name = typeof clientInfo?.name === "string" ? clientInfo.name.trim() : "";
-	const title = typeof clientInfo?.title === "string" ? clientInfo.title.trim() : "";
-	for (const [pattern, known] of clients) if (pattern.test(name) || pattern.test(title)) return known;
-	if (title) return title;
-	if (!name) return void 0;
-	return name.replace(/[-_]+(mcp[-_]?)?client$/i, "").split(/[-_\s]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
-}
-/**
-* Who runs the CLI, from what agents put in their shell's environment. `PARITY_AGENT_NAME` names it outright; with
-* no sign of an agent, it's someone at a terminal.
-*/
-function cliCallerName(env) {
-	const named = env.PARITY_AGENT_NAME?.trim();
-	if (named) return named;
-	if (env.CLAUDECODE === "1") return "Claude Code";
-	if (env.GEMINI_CLI === "1") return "Gemini CLI";
-	if (Object.keys(env).some((key) => key.startsWith("CODEX_"))) return "Codex";
-	return "Terminal";
-}
-// src/client.ts
-/** Where the running app writes its address and token. */
-const agentFile = process.env.PARITY_AGENT_FILE ?? join(homedir(), ".parity", "agent.json");
-let caller = cliCallerName(process.env);
-/** Tells callers with the same name apart. A terminal's calls are separate processes, so they share their name. */
-let callerId = process.env.PARITY_AGENT_ID?.trim() || caller;
-/**
-* Names who's calling in later calls, so the canvas can say who's at work. The MCP server learns the name from its
-* client, and is one session: its calls share an id, apart from any other session of the same agent.
-*/
-function setCaller(name, session = false) {
-	caller = name ?? caller;
-	callerId = session ? `${caller}#${randomUUID().slice(0, 8)}` : caller;
-}
-/** Calls the running Parity app. Fails with a clear message when it isn't running. */
-async function call(method, params = {}) {
-	let connection;
-	try {
-		connection = JSON.parse(await readFile(agentFile, "utf8"));
-	} catch {
-		throw new Error(`Parity isn't running (no ${agentFile}). Start the app, then try again.`);
-	}
-	let response;
-	try {
-		response = await fetch(`${connection.url}/rpc`, {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-				authorization: `Bearer ${connection.token}`
-			},
-			body: JSON.stringify({
-				method,
-				params,
-				agent: caller,
-				agentId: callerId
-			})
-		});
-	} catch {
-		throw new Error(`Parity isn't answering at ${connection.url}. Is the app still running?`);
-	}
-	const body = await response.json();
-	if (body.error !== void 0) throw new Error(body.error);
-	return body.result;
-}
-/** A readable account of an exec call, for terminals and for agents. */
-function describeExec(result) {
-	const lines = [];
-	if (result.ok) lines.push(result.applied ? "Done. The changes are on the canvas as one undoable step." : "Done. Nothing changed.");
-	else {
-		lines.push(`Failed, nothing changed: ${result.error}`);
-		lines.push(`Fix it by retrying with editId "${result.editId}" and edits ({find, replace}) to the snippet.`);
-	}
-	if (result.output.length > 0) lines.push("", "Output:", ...result.output);
-	const created = Object.entries(result.created);
-	if (created.length > 0) lines.push("", "Created:", ...created.map(([name, id]) => `  ${name} = ${id}`));
-	if (result.warnings.length > 0) lines.push("", "Warnings (fix these next):", ...result.warnings.map((warning) => `  ${warning}`));
-	if (result.screenshots.length > 0) lines.push("", "Screenshots:", ...result.screenshots.map((shot) => `  ${shot.design} / ${shot.state} / ${shot.mode}: ${shot.path}`));
-	return lines.join("\n");
-}
-const impactOrder = [
-	"critical",
-	"serious",
-	"moderate",
-	"minor"
-];
-/**
-* A readable account of an accessibility check: each rule broken, worst first, with the layers that break it, the
-* frames they break it in and what's wrong. Alike layers, such as the rows of a list, share a line.
-*/
-function describeAccessibility(result) {
-	const { design, findings, frames } = result;
-	const checked = `${design.name} (${design.id}), ${frames === 1 ? "1 frame" : `${frames} frames`}`;
-	const rules = /* @__PURE__ */ new Map();
-	for (const finding of findings) rules.set(finding.rule, [...rules.get(finding.rule) ?? [], finding]);
-	const lines = [rules.size === 0 ? `No issues found in ${checked}, with axe-core against WCAG 2.2 AA.` : `${rules.size === 1 ? "1 rule" : `${rules.size} rules`} broken in ${checked}, with axe-core against WCAG 2.2 AA.`];
-	const groups = [...rules.values()].sort((a, b) => impactOrder.indexOf(a[0].impact) - impactOrder.indexOf(b[0].impact));
-	for (const group of groups) {
-		const { impact, rule, help, helpUrl } = group[0];
-		lines.push("", `${impact}: ${help} (${rule})`);
-		const byLayer = /* @__PURE__ */ new Map();
-		for (const finding of group) {
-			const key = `${finding.node ?? ""}\n${finding.detail}`;
-			const layer = byLayer.get(key) ?? {
-				name: finding.name ?? "The design",
-				nodes: finding.node ? [finding.node] : [],
-				detail: finding.detail,
-				frames: []
-			};
-			layer.frames.push({
-				state: finding.state,
-				mode: finding.mode
-			});
-			byLayer.set(key, layer);
-		}
-		const alike = /* @__PURE__ */ new Map();
-		for (const layer of byLayer.values()) {
-			const same = JSON.stringify([
-				layer.name,
-				layer.detail,
-				layer.frames
-			]);
-			const existing = alike.get(same);
-			if (existing) existing.nodes.push(...layer.nodes);
-			else alike.set(same, layer);
-		}
-		for (const layer of alike.values()) {
-			const where = layer.frames.length === frames && frames > 1 ? "every frame" : frameList(layer.frames);
-			const ids = layer.nodes.length > 0 ? ` (${layer.nodes.join(", ")})` : "";
-			lines.push(`  ${layer.name}${ids}, in ${where}: ${layer.detail}`);
-		}
-		lines.push(`  How to fix it: ${helpUrl}`);
-	}
-	if (result.warnings.length > 0) lines.push("", "Warnings:", ...result.warnings.map((warning) => `  ${warning}`));
-	lines.push("", "Automated checks find some issues, not all. Try the design with a keyboard and a screen reader too.");
-	return lines.join("\n");
-}
-/** A readable account of the layout problems in a design's frames, each once with the frames it's in. */
-function describeProblems(result) {
-	const { design, problems, frames } = result;
-	const checked = `${design.name} (${design.id}), ${frames === 1 ? "1 frame" : `${frames} frames`}`;
-	const grouped = /* @__PURE__ */ new Map();
-	for (const { problem, node, state, mode } of problems) {
-		const key = `${node ?? ""}\n${problem}`;
-		const entry = grouped.get(key) ?? {
-			problem,
-			...node ? { node } : {},
-			frames: []
-		};
-		entry.frames.push({
-			state,
-			mode
-		});
-		grouped.set(key, entry);
-	}
-	const count = grouped.size === 1 ? "1 problem" : `${grouped.size} problems`;
-	const lines = [grouped.size === 0 ? `No problems found in ${checked}.` : `${count} in ${checked}:`];
-	for (const { problem, node, frames: where } of grouped.values()) {
-		const every = where.length === frames && frames > 1 ? "every frame" : frameList(where);
-		lines.push(`  ${node ? `${node}: ` : ""}${problem}, in ${every}`);
-	}
-	if (result.warnings.length > 0) lines.push("", "Warnings:", ...result.warnings.map((warning) => `  ${warning}`));
-	return lines.join("\n");
-}
-/** Tokens by category, each with its value in every theme that sets one. */
-function describeTokens(tokens) {
-	if (tokens.length === 0) return "No tokens match.";
-	const lines = [`${tokens.length === 1 ? "1 token" : `${tokens.length} tokens`}. Name them in styles without "--".`];
-	const categories = /* @__PURE__ */ new Map();
-	for (const token of tokens) {
-		const key = `${token.category}, ${token.source}`;
-		categories.set(key, [...categories.get(key) ?? [], token]);
-	}
-	for (const [category, list] of categories) {
-		lines.push("", `${category}:`);
-		for (const token of list) {
-			const values = Object.entries(token.values).sort(([a], [b]) => first("default", a, b)).map(([theme, value]) => `${theme} ${value}`);
-			lines.push(`  ${token.name}: ${values.join(", ")}`);
-		}
-	}
-	return lines.join("\n");
-}
-/**
-* The project's own components, then each library's, then the icon libraries, then the exports left out and why, the
-* components failing to draw and why, and what the person corrected by hand.
-*/
-function describeComponents({ components, iconLibraries = [], leftOut = [], drawn = 0, failing = [], corrections = {} }) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const component of components) {
-		const slash = component.indexOf("/");
-		const group = slash > 0 ? component.slice(0, slash) : "";
-		groups.set(group, [...groups.get(group) ?? [], slash > 0 ? component.slice(slash + 1) : component]);
-	}
-	const lines = [];
-	for (const [group, names] of [...groups].sort(([a], [b]) => first("", a, b))) lines.push(group ? `${group}, as ${group}/Name:` : "The project's own:", `  ${names.join(", ")}`, "");
-	if (iconLibraries.length > 0) lines.push(`Icons: ${iconLibraries.map((library) => `${library}, as ${library}/Name`).join("; ")}`, "");
-	if (leftOut.length > 0) {
-		lines.push("Not components:");
-		for (const entry of leftOut) lines.push(`  ${entry.name}, in ${entry.path}: ${entry.undecided ? "can't tell, " : ""}${entry.reason}`);
-		lines.push("");
-	}
-	if (failing.length > 0) {
-		lines.push(`Failing to draw on the canvas, ${failing.length} of ${failing.length + drawn} drawn so far:`);
-		for (const entry of failing) lines.push(`  ${entry.id}: ${entry.reason}`);
-		lines.push("");
-	}
-	const { include = [], exclude = [] } = corrections;
-	if (include.length > 0 || exclude.length > 0) {
-		const name = (ref) => ref.export === "default" ? "the default export" : ref.export;
-		lines.push("Corrected by hand in the project file:");
-		for (const ref of include) lines.push(`  listed: ${name(ref)}, in ${ref.path}`);
-		for (const ref of exclude) lines.push(`  taken off: ${name(ref)}, in ${ref.path}`);
-	}
-	return lines.join("\n").trimEnd();
-}
-/** A component's props, with each variant's options and default. */
-function describeProps(result) {
-	if (!result.known) return `${result.component}'s props haven't been read from its source yet. Try again in a moment.`;
-	const imported = result.import && result.import !== result.path ? `, imported from "${result.import}"` : "";
-	const lines = [`${result.component}, from ${result.path}${imported}:`];
-	for (const prop of result.props) {
-		const options = prop.options ? `: ${prop.options.map((option) => JSON.stringify(option)).join(", ")}` : "";
-		const fallback = prop.default === void 0 ? "" : `, default ${JSON.stringify(prop.default)}`;
-		lines.push(`  ${prop.name} (${prop.kind}${prop.required ? ", required" : ""})${options}${fallback}`);
-	}
-	if (result.props.length === 0) lines.push("  No props of its own. --all lists the attributes it passes on.");
-	return lines.join("\n");
-}
-/** Frames as state and mode ids, naming a mode once when they share it: "default, error in desktop-light". */
-function frameList(frames) {
-	const modes = [...new Set(frames.map((frame) => frame.mode))];
-	if (modes.length === 1) return `${frames.map((frame) => frame.state).join(", ")} in ${modes[0]}`;
-	return frames.map((frame) => `${frame.state} in ${frame.mode}`).join(", ");
-}
-/** A readable account of what a project's code wrote to the console, oldest first, with where each came from. */
-function describeConsole(result) {
-	const { tab, entries } = result;
-	if (entries.length === 0) return `${tab.name}'s code hasn't written anything to the console.`;
-	const lines = [`${entries.length === 1 ? "1 message" : `${entries.length} messages`} from ${tab.name}'s code, oldest first:`];
-	for (const entry of entries) {
-		const time = new Date(entry.last).toLocaleTimeString([], { hour12: false });
-		const repeats = entry.count > 1 ? ` (${entry.count} times)` : "";
-		const [first = "", ...rest] = entry.text.split("\n");
-		lines.push("", `${time} ${entry.level}${repeats}: ${first}`, ...rest.map((line) => `  ${line}`));
-		const offscreen = entry.where === "offscreen" ? ", in an offscreen render" : "";
-		lines.push(`  at ${scriptPath(entry.source)}:${entry.line}${offscreen}`);
-	}
-	return lines.join("\n");
-}
-/** Compares two names alphabetically, with `name` before every other. */
-function first(name, a, b) {
-	if (a === name) return -1;
-	if (b === name) return 1;
-	return a.localeCompare(b);
-}
-/** A script's path on its server, without the cache-busting query Vite adds. */
-function scriptPath(url) {
-	try {
-		return new URL(url).pathname;
-	} catch {
-		return url || "an unknown script";
-	}
-}
-export { describeConsole as a, describeProps as c, mcpCallerName as d, describeComponents as i, describeTokens as l, call as n, describeExec as o, describeAccessibility as r, describeProblems as s, agentFile as t, setCaller as u };