weasel-icons 0.16.1 → 0.17.0

package/README.md

@@ -8,6 +8,10 @@ Version `0.10.0` contains 874 icons, adding 200 across documents, collaboration,
 
 Version `0.7.0` contained 469 icons; `0.6.0` contained 265 icons.
 
+## Version 0.17.0
+
+Adds 32 icons for agent workflows, tool calls, approvals, retrieval, knowledge graphs, attention, transformer computation and token sampling. The collection now contains 1,086 icons. All new icons include three typed states, optional ongoing motion, accent colours, matching editable CLI source and related search terms. Existing icon artwork, public states, shared runtime and the customization skill are unchanged.
+
 ## Version 0.16.1
 
 Strengthens the customization skill with a render–inspect–repair loop: inspect real pixels and full motion cycles, correct contact, spacing and reset defects, then replay the same route after each fix. Icon artwork, states, exports and the 1,054-icon collection are unchanged.

package/dist/icons/agent-handoff/agent-handoff-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AgentHandoffState } from "./agent-handoff-rig.js";
+export { agentHandoffStates, type AgentHandoffState } from "./agent-handoff-rig.js";
+export type AgentHandoffIconProps = StatefulIconProps<AgentHandoffState>;
+export declare const AgentHandoffIcon: import("react").NamedExoticComponent<AgentHandoffIconProps>;

package/dist/icons/agent-handoff/agent-handoff-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { agentHandoffArt, agentHandoffStates } from "./agent-handoff-rig.js";
+export { agentHandoffStates } from "./agent-handoff-rig.js";
+export const AgentHandoffIcon = memo(function AgentHandoffIcon(props) {
+    return _jsx(ArticulatedIcon, { art: agentHandoffArt, states: agentHandoffStates, ...props });
+});

package/dist/icons/agent-handoff/agent-handoff-rig.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Agent A hands the conversation (bubble) and the turn (fill level) to agent B. The turn is
+ * poured, not swapped: A's fill drains while B's fills, as the bubble glides across above them.
+ */
+export declare const agentHandoffStates: readonly ["holding", "handing-off", "handed-off"];
+export type AgentHandoffState = (typeof agentHandoffStates)[number];
+export declare const agentHandoffArt: {
+    name: string;
+    parts: ({
+        fillOnly: "ink";
+        accent: true;
+        poses: {
+            flex: number;
+        }[];
+        gestures: {
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                flex: number;
+            } | {
+                at: number;
+                flex?: undefined;
+            })[];
+        }[];
+        paths: string[];
+        pathOffsets: number[][];
+        name: string;
+        pathStates?: undefined;
+        surface?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        poses: {}[];
+        pathStates?: undefined;
+        surface?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        surface: true;
+        poses: ({
+            x?: undefined;
+        } | {
+            x: number;
+        })[];
+        gestures: {
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                x: number;
+            } | {
+                at: number;
+                x?: undefined;
+            })[];
+        }[];
+    })[];
+};

package/dist/icons/agent-handoff/agent-handoff-rig.js

@@ -0,0 +1,74 @@
+/**
+ * Agent A hands the conversation (bubble) and the turn (fill level) to agent B. The turn is
+ * poured, not swapped: A's fill drains while B's fills, as the bubble glides across above them.
+ */
+export const agentHandoffStates = ['holding', 'handing-off', 'handed-off'];
+const box = (x, y, w, h, r) => `M${x + r} ${y}H${x + w - r}A${r} ${r} 0 0 1 ${x + w} ${y + r}V${y + h - r}A${r} ${r} 0 0 1 ${x + w - r} ${y + h}H${x + r}A${r} ${r} 0 0 1 ${x} ${y + h - r}V${y + r}A${r} ${r} 0 0 1 ${x + r} ${y}Z`;
+// Agent bodies: A on the left, B on the right, same size.
+const TOP = 12.8;
+const BOTTOM = 20.4;
+const A = { x: 2.6, w: 7.6 };
+const B = { x: 13.8, w: 7.6 };
+// A plain rectangle: its corners stay under the rounded outline's stroke. flex 1 = empty.
+const level = (x, w) => ({
+    paths: [`M${x} ${TOP}H${x + w}V${BOTTOM}H${x}Z`],
+    pathOffsets: [[0, BOTTOM - TOP, 0, 0, 0]],
+});
+const bubble = (tail) => [
+    // Quadratic corners, not arcs: arc flags would be interpolated by the morph.
+    `M4.2 3H8.6Q10.2 3 10.2 4.6V7Q10.2 8.6 8.6 8.6H7.6L${tail} 10.2L5.2 8.6H4.2Q2.6 8.6 2.6 7V4.6Q2.6 3 4.2 3Z`,
+    'M4.6 5.8H8.2',
+];
+const glide = (dx) => ({
+    duration: 1.4,
+    repeatAfter: 1.4,
+    loop: false,
+    frames: [{ at: 0, x: dx }, { at: 1 }],
+});
+// The turn moves only once the context is mostly across.
+const pour = (dFlex) => ({
+    duration: 1.4,
+    repeatAfter: 1.4,
+    loop: false,
+    frames: [{ at: 0, flex: dFlex }, { at: 0.35, flex: dFlex }, { at: 1 }],
+});
+export const agentHandoffArt = {
+    name: 'agent-handoff',
+    parts: [
+        {
+            name: 'turn-a',
+            ...level(A.x, A.w),
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ flex: 0 }, { flex: 0.5 }, { flex: 1 }],
+            gestures: [pour(0.5), pour(-0.5), pour(-0.5)],
+        },
+        {
+            name: 'turn-b',
+            ...level(B.x, B.w),
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ flex: 1 }, { flex: 0.5 }, { flex: 0 }],
+            gestures: [pour(-0.5), pour(0.5), pour(0.5)],
+        },
+        {
+            name: 'agent-a',
+            paths: [box(A.x, TOP, A.w, BOTTOM - TOP, 1.6)],
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'agent-b',
+            paths: [box(B.x, TOP, B.w, BOTTOM - TOP, 1.6)],
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'context',
+            paths: bubble(6.4),
+            // The tail leans toward B while the context is in transit.
+            pathStates: [bubble(6.4), bubble(7.6), bubble(6.4)],
+            surface: true,
+            poses: [{}, { x: 5.6 }, { x: 11.2 }],
+            gestures: [glide(5.6), glide(-5.6), glide(-5.6)],
+        },
+    ],
+};

package/dist/icons/agent-loop/agent-loop-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AgentLoopState } from "./agent-loop-rig.js";
+export { agentLoopStates, type AgentLoopState } from "./agent-loop-rig.js";
+export type AgentLoopIconProps = StatefulIconProps<AgentLoopState>;
+export declare const AgentLoopIcon: import("react").NamedExoticComponent<AgentLoopIconProps>;

package/dist/icons/agent-loop/agent-loop-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { agentLoopArt, agentLoopStates } from "./agent-loop-rig.js";
+export { agentLoopStates } from "./agent-loop-rig.js";
+export const AgentLoopIcon = memo(function AgentLoopIcon(props) {
+    return _jsx(ArticulatedIcon, { art: agentLoopArt, states: agentLoopStates, ...props });
+});

package/dist/icons/agent-loop/agent-loop-rig.d.ts

@@ -0,0 +1,83 @@
+/**
+ * A ReAct cycle drawn as a one-way loop with three chevron stations (a roundabout). While the agent iterates a
+ * run token orbits the loop; when the stop condition holds the token leaves along the
+ * tangent exit into a UML final node.
+ */
+export declare const agentLoopStates: readonly ["idle", "iterating", "done"];
+export type AgentLoopState = (typeof agentLoopStates)[number];
+export declare const agentLoopArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        detail: true;
+        poses: ({
+            opacity?: undefined;
+        } | {
+            opacity: number;
+        })[];
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        poses: ({
+            opacity?: undefined;
+        } | {
+            opacity: number;
+        })[];
+        detail?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        spin: {
+            state: number;
+            degreesPerSecond: number;
+        };
+        poses: ({
+            opacity: number;
+        } | {
+            opacity?: undefined;
+        })[];
+        detail?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        poses: ({
+            x: number;
+            opacity: number;
+        } | {
+            x: number;
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                x: number;
+            } | {
+                at: number;
+                x?: undefined;
+            })[];
+        } | null)[];
+        detail?: undefined;
+        pivot?: undefined;
+        spin?: undefined;
+    })[];
+};

package/dist/icons/agent-loop/agent-loop-rig.js

@@ -0,0 +1,85 @@
+/**
+ * A ReAct cycle drawn as a one-way loop with three chevron stations (a roundabout). While the agent iterates a
+ * run token orbits the loop; when the stop condition holds the token leaves along the
+ * tangent exit into a UML final node.
+ */
+export const agentLoopStates = ['idle', 'iterating', 'done'];
+const circle = (cx, cy, r) => `M${cx - r} ${cy}a${r} ${r} 0 1 0 ${2 * r} 0a${r} ${r} 0 1 0 ${-2 * r} 0Z`;
+// Loop centre (8.8, 9.2), radius 6.2, travelled counter-clockwise on screen.
+// Stations at 0°, 120° and 240°; the exit leaves tangentially at 90° (bottom; screen angles, y down).
+const CX = 8.8;
+const CY = 9.2;
+const R = 6.2;
+/**
+ * A step station is a chevron astride the loop at angle `deg`, pointing along the
+ * counter-clockwise travel direction: three of them make the loop read as a one-way cycle.
+ */
+const station = (deg) => {
+    const a = (deg * Math.PI) / 180;
+    const n = [Math.cos(a), Math.sin(a)];
+    const d = [Math.sin(a), -Math.cos(a)];
+    const tip = [CX + R * n[0] + 0.55 * d[0], CY + R * n[1] + 0.55 * d[1]];
+    const back = [tip[0] - 1.4 * d[0], tip[1] - 1.4 * d[1]];
+    const p = (x, y) => `${x.toFixed(2)} ${y.toFixed(2)}`;
+    return `M${p(back[0] + 1.4 * n[0], back[1] + 1.4 * n[1])}L${p(tip[0], tip[1])}L${p(back[0] - 1.4 * n[0], back[1] - 1.4 * n[1])}`;
+};
+const decide = [CX, CY + R];
+const finalNode = [18.3, CY + R];
+const exitRun = +(finalNode[0] - decide[0]).toFixed(2);
+export const agentLoopArt = {
+    name: 'agent-loop',
+    parts: [
+        {
+            name: 'loop',
+            paths: [circle(CX, CY, R)],
+            detail: true,
+            poses: [{}, {}, { opacity: 0.4 }],
+        },
+        {
+            // Act, observe, reason: three chevron stations that also give the loop its direction.
+            name: 'stations',
+            paths: [station(0), station(120), station(240)],
+            poses: [{}, {}, { opacity: 0.4 }],
+        },
+        {
+            // Tangent exit: the loop's bottom continues straight on to the final node.
+            name: 'exit',
+            paths: [`M${decide[0]} ${decide[1]}H15.3`],
+            poses: [{ opacity: 0.3 }, { opacity: 0.3 }, {}],
+        },
+        {
+            // UML final node: a ring that the token completes into a bullseye.
+            name: 'final-node',
+            paths: [circle(finalNode[0], finalNode[1], 3)],
+            poses: [{ opacity: 0.3 }, { opacity: 0.3 }, {}],
+        },
+        {
+            // Orbiting run token: constant counter-clockwise travel along the loop while iterating.
+            name: 'token-orbit',
+            paths: [circle(decide[0], decide[1], 1.45)],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [CX, CY],
+            spin: { state: 1, degreesPerSecond: -72 },
+            poses: [{ opacity: 0 }, {}, { opacity: 0 }],
+        },
+        {
+            // Leaving token: rests in the final node; on entry it rides the exit from the bottom of the loop.
+            name: 'token-exit',
+            paths: [circle(decide[0], decide[1], 1.3)],
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ x: exitRun, opacity: 0 }, { x: exitRun, opacity: 0 }, { x: exitRun }],
+            gestures: [
+                null,
+                null,
+                {
+                    duration: 1.1,
+                    repeatAfter: 1.1,
+                    loop: false,
+                    frames: [{ at: 0, x: -exitRun }, { at: 0.1, x: -exitRun }, { at: 0.85 }, { at: 1 }],
+                },
+            ],
+        },
+    ],
+};

package/dist/icons/agent-orchestrator/agent-orchestrator-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AgentOrchestratorState } from "./agent-orchestrator-rig.js";
+export { agentOrchestratorStates, type AgentOrchestratorState } from "./agent-orchestrator-rig.js";
+export type AgentOrchestratorIconProps = StatefulIconProps<AgentOrchestratorState>;
+export declare const AgentOrchestratorIcon: import("react").NamedExoticComponent<AgentOrchestratorIconProps>;

package/dist/icons/agent-orchestrator/agent-orchestrator-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { agentOrchestratorArt, agentOrchestratorStates, } from "./agent-orchestrator-rig.js";
+export { agentOrchestratorStates } from "./agent-orchestrator-rig.js";
+export const AgentOrchestratorIcon = memo(function AgentOrchestratorIcon(props) {
+    return _jsx(ArticulatedIcon, { art: agentOrchestratorArt, states: agentOrchestratorStates, ...props });
+});

package/dist/icons/agent-orchestrator/agent-orchestrator-rig.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Orchestrator–workers: the lead sends three sub-tasks down its edges in parallel, each worker
+ * holds one while it runs, and the results travel back up to fuse into one answer in the lead.
+ * Sub-tasks that are not out with a worker wait hidden inside the lead (occluded, not faded).
+ */
+export declare const agentOrchestratorStates: readonly ["idle", "delegating", "merged"];
+export type AgentOrchestratorState = (typeof agentOrchestratorStates)[number];
+export declare const agentOrchestratorArt: {
+    name: string;
+    parts: ({
+        name: "task-left" | "task-middle" | "task-right";
+        paths: string[];
+        fillOnly: "ink";
+        accent: boolean;
+        poses: ({
+            x: 0 | 6.27 | -6.27;
+            y: -12 | -9.17;
+            opacity: number;
+        } | {
+            x?: undefined;
+            y?: undefined;
+            opacity?: undefined;
+        } | {
+            x: 0 | 6.27 | -6.27;
+            y: -12 | -9.17;
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                x: number;
+                y: number;
+            } | {
+                at: number;
+                x?: undefined;
+                y?: undefined;
+            })[];
+        } | null)[];
+    } | {
+        name: string;
+        paths: string[];
+        detail: true;
+        poses: {}[];
+        surface?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        poses: {}[];
+        detail?: undefined;
+        surface?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        surface: true;
+        poses: {}[];
+        detail?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        poses: ({
+            scaleX: number;
+        } | {
+            scaleX?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                scaleX: number;
+            } | {
+                at: number;
+                scaleX?: undefined;
+            })[];
+        } | null)[];
+        detail?: undefined;
+        surface?: undefined;
+    })[];
+};

package/dist/icons/agent-orchestrator/agent-orchestrator-rig.js

@@ -0,0 +1,84 @@
+/**
+ * Orchestrator–workers: the lead sends three sub-tasks down its edges in parallel, each worker
+ * holds one while it runs, and the results travel back up to fuse into one answer in the lead.
+ * Sub-tasks that are not out with a worker wait hidden inside the lead (occluded, not faded).
+ */
+export const agentOrchestratorStates = ['idle', 'delegating', 'merged'];
+const circle = (cx, cy, r) => `M${cx - r} ${cy}a${r} ${r} 0 1 0 ${2 * r} 0a${r} ${r} 0 1 0 ${-2 * r} 0Z`;
+const WORKER_R = 2.4;
+// Workers sit on a fan below the lead. Offset from each worker centre to the sub-task's
+// waiting place inside the lead, collinear with that worker's edge so travel follows the edge.
+const lanes = [
+    { name: 'task-left', cx: 4.4, cy: 16.2, dx: 6.27, dy: -9.17 },
+    { name: 'task-middle', cx: 12, cy: 19, dx: 0, dy: -12 },
+    { name: 'task-right', cx: 19.6, cy: 16.2, dx: -6.27, dy: -9.17 },
+];
+const task = ({ name, cx, cy, dx, dy }, i) => ({
+    name,
+    paths: [circle(cx, cy, 0.95)],
+    fillOnly: 'ink',
+    accent: true,
+    // Idle hides them in the lead and also fades them, so a cancelled delegation fades out.
+    poses: [{ x: dx, y: dy, opacity: 0 }, {}, { x: dx, y: dy }],
+    gestures: [
+        null,
+        {
+            // Dispatched together (parallel); the shorter side lanes leave a beat later so all land together.
+            duration: 1.3,
+            repeatAfter: 1.3,
+            loop: false,
+            frames: [{ at: 0, x: dx, y: dy }, { at: i === 1 ? 0.01 : 0.06, x: dx, y: dy }, { at: 1 }],
+        },
+        {
+            // Results climb back up their edges and pass under the lead's surface.
+            duration: 1.4,
+            repeatAfter: 1.4,
+            loop: false,
+            frames: [{ at: 0, x: -dx, y: -dy }, { at: 0.6 }, { at: 1 }],
+        },
+    ],
+});
+export const agentOrchestratorArt = {
+    name: 'agent-orchestrator',
+    parts: [
+        {
+            name: 'edges',
+            paths: ['M9.6 8.6L5.76 14.22', 'M12 8.6V16.6', 'M14.4 8.6L18.24 14.22'],
+            detail: true,
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'workers',
+            paths: lanes.map((l) => circle(l.cx, l.cy, WORKER_R)),
+            poses: [{}, {}, {}],
+        },
+        ...lanes.map(task),
+        {
+            name: 'lead',
+            paths: [
+                'M8.6 2.6H15.4A1.6 1.6 0 0 1 17 4.2V7A1.6 1.6 0 0 1 15.4 8.6H8.6A1.6 1.6 0 0 1 7 7V4.2A1.6 1.6 0 0 1 8.6 2.6Z',
+            ],
+            surface: true,
+            poses: [{}, {}, {}],
+        },
+        {
+            name: 'merged-result',
+            paths: ['M10 4.6H14A1 1 0 0 1 15 5.6A1 1 0 0 1 14 6.6H10A1 1 0 0 1 9 5.6A1 1 0 0 1 10 4.6Z'],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [12, 5.6],
+            poses: [{ scaleX: 0 }, { scaleX: 0 }, {}],
+            gestures: [
+                null,
+                null,
+                {
+                    // Grows from the centre once the results have arrived.
+                    duration: 1.4,
+                    repeatAfter: 1.4,
+                    loop: false,
+                    frames: [{ at: 0, scaleX: -1 }, { at: 0.55, scaleX: -1 }, { at: 0.95 }, { at: 1 }],
+                },
+            ],
+        },
+    ],
+};

package/dist/icons/beam-search/beam-search-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type BeamSearchState } from "./beam-search-rig.js";
+export { beamSearchStates, type BeamSearchState } from "./beam-search-rig.js";
+export type BeamSearchIconProps = StatefulIconProps<BeamSearchState>;
+export declare const BeamSearchIcon: import("react").NamedExoticComponent<BeamSearchIconProps>;

package/dist/icons/beam-search/beam-search-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { beamSearchArt, beamSearchStates } from "./beam-search-rig.js";
+export { beamSearchStates } from "./beam-search-rig.js";
+export const BeamSearchIcon = memo(function BeamSearchIcon(props) {
+    return _jsx(ArticulatedIcon, { art: beamSearchArt, states: beamSearchStates, ...props });
+});

package/dist/icons/beam-search/beam-search-rig.d.ts

@@ -0,0 +1,72 @@
+import type { PartGesture } from "../../shared/articulation.js";
+/**
+ * A decoding tree read left to right with beam width 2. Idle shows the two beams solid among
+ * faint pruned alternatives. Searching rescoring: the alternatives wither back
+ * toward their parent and stay as cut stubs (while alive they sprout and wither again as
+ * they are rescored). Decoded traces the highest-scoring sequence in accent.
+ */
+export declare const beamSearchStates: readonly ["idle", "searching", "decoded"];
+export type BeamSearchState = (typeof beamSearchStates)[number];
+export declare const beamSearchArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        traceLength: number;
+        poses: ({
+            opacity: number;
+            draw?: undefined;
+        } | {
+            draw: number;
+            opacity: number;
+        })[];
+        gestures: (PartGesture | null)[];
+        fillOnly?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        poses: ({
+            opacity?: undefined;
+        } | {
+            opacity: number;
+        })[];
+        traceLength?: undefined;
+        gestures?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        poses: {}[];
+        traceLength?: undefined;
+        gestures?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        accent: true;
+        traceLength: number;
+        poses: ({
+            draw: number;
+            opacity: number;
+        } | {
+            draw?: undefined;
+            opacity?: undefined;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: false;
+            frames: ({
+                at: number;
+                draw: number;
+            } | {
+                at: number;
+                draw?: undefined;
+            })[];
+        } | null)[];
+        fillOnly?: undefined;
+    })[];
+};