@genart-dev/mcp-server 0.1.1 → 0.2.0

package/dist/lib.cjs

@@ -470,10 +470,40 @@ async function createSketch(state, input) {
     const adapter = registry4.resolve(rendererType);
     algorithm = adapter.getAlgorithmTemplate();
   }
+  let resolvedComponents;
+  if (input.components && Object.keys(input.components).length > 0) {
+    const shorthand = {};
+    for (const [name, value] of Object.entries(input.components)) {
+      if (typeof value === "string") {
+        shorthand[name] = value;
+      } else if (value.version) {
+        shorthand[name] = value.version;
+      } else if (value.code) {
+        if (!resolvedComponents) resolvedComponents = {};
+        resolvedComponents[name] = {
+          ...value.version ? { version: value.version } : {},
+          code: value.code,
+          ...value.exports ? { exports: value.exports } : {}
+        };
+      }
+    }
+    if (Object.keys(shorthand).length > 0) {
+      const resolved = (0, import_core2.resolveComponents)(shorthand, rendererType);
+      if (!resolvedComponents) resolvedComponents = {};
+      for (const rc of resolved) {
+        resolvedComponents[rc.name] = {
+          version: rc.version,
+          code: rc.code,
+          exports: [...rc.exports]
+        };
+      }
+    }
+  }
   const seed = input.seed ?? Math.floor(Math.random() * 1e5);
   const ts = now2();
+  const hasComponents = resolvedComponents && Object.keys(resolvedComponents).length > 0;
   const sketch = {
-    genart: "1.1",
+    genart: hasComponents ? "1.2" : "1.1",
     id: input.id,
     title: input.title,
     created: ts,
@@ -487,6 +517,7 @@ async function createSketch(state, input) {
     ...input.philosophy ? { philosophy: input.philosophy } : {},
     ...input.themes && input.themes.length > 0 ? { themes: input.themes } : {},
     ...input.skills && input.skills.length > 0 ? { skills: input.skills } : {},
+    ...hasComponents ? { components: resolvedComponents } : {},
     ...input.agent ? { agent: input.agent } : {},
     ...input.model ? { model: input.model } : {}
   };
@@ -670,10 +701,44 @@ async function updateAlgorithm(state, input) {
       );
     }
   }
+  let resolvedComponents;
+  if (input.components && Object.keys(input.components).length > 0) {
+    const renderer = def.renderer.type;
+    const shorthand = {};
+    for (const [name, value] of Object.entries(input.components)) {
+      if (typeof value === "string") {
+        shorthand[name] = value;
+      } else if (value.version) {
+        shorthand[name] = value.version;
+      } else if (value.code) {
+        if (!resolvedComponents) resolvedComponents = {};
+        resolvedComponents[name] = {
+          ...value.version ? { version: value.version } : {},
+          code: value.code,
+          ...value.exports ? { exports: value.exports } : {}
+        };
+      }
+    }
+    if (Object.keys(shorthand).length > 0) {
+      const resolved = (0, import_core2.resolveComponents)(shorthand, renderer);
+      if (!resolvedComponents) resolvedComponents = {};
+      for (const rc of resolved) {
+        resolvedComponents[rc.name] = {
+          version: rc.version,
+          code: rc.code,
+          exports: [...rc.exports]
+        };
+      }
+    }
+  }
+  const updated = ["algorithm"];
+  const hasNewComponents = resolvedComponents && Object.keys(resolvedComponents).length > 0;
+  if (hasNewComponents) updated.push("components");
   const newDef = {
     ...def,
     modified: now2(),
     algorithm: input.algorithm,
+    ...hasNewComponents ? { genart: "1.2", components: resolvedComponents } : {},
     ...input.agent ? { agent: input.agent } : {},
     ...input.model ? { model: input.model } : {}
   };
@@ -687,7 +752,7 @@ async function updateAlgorithm(state, input) {
   }
   state.emitMutation("sketch:updated", {
     id: input.sketchId,
-    updated: ["algorithm"]
+    updated
   });
   return {
     success: true,
@@ -695,6 +760,7 @@ async function updateAlgorithm(state, input) {
     renderer: def.renderer.type,
     algorithmLength: input.algorithm.length,
     validationPassed,
+    ...hasNewComponents ? { componentsUpdated: true } : {},
     fileContent: json
   };
 }
@@ -1992,9 +2058,216 @@ ${guidelines}`,
   };
 }
 
-// src/tools/capture.ts
+// src/tools/components.ts
 var import_promises5 = require("fs/promises");
 var import_core7 = require("@genart-dev/core");
+var VALID_RENDERERS2 = [
+  "p5",
+  "three",
+  "glsl",
+  "canvas2d",
+  "svg"
+];
+var RENDERER_TARGET = {
+  p5: "js",
+  three: "js",
+  canvas2d: "js",
+  svg: "js",
+  glsl: "glsl"
+};
+async function listComponents(_state, input) {
+  let entries = Object.values(import_core7.COMPONENT_REGISTRY);
+  if (input.renderer) {
+    const renderer = input.renderer;
+    const target = RENDERER_TARGET[renderer];
+    if (!target) {
+      throw new Error(
+        `Unknown renderer type: '${input.renderer}'. Valid types: ${VALID_RENDERERS2.join(", ")}`
+      );
+    }
+    entries = entries.filter(
+      (e) => e.target === target && (e.renderers.length === 0 || e.renderers.includes(renderer))
+    );
+  }
+  if (input.category) {
+    const cat = input.category;
+    entries = entries.filter((e) => e.category === cat);
+  }
+  entries.sort((a, b) => {
+    const catCmp = a.category.localeCompare(b.category);
+    if (catCmp !== 0) return catCmp;
+    return a.name.localeCompare(b.name);
+  });
+  const components = entries.map((e) => ({
+    name: e.name,
+    version: e.version,
+    category: e.category,
+    target: e.target,
+    exports: [...e.exports],
+    dependencies: [...e.dependencies],
+    description: e.description
+  }));
+  return {
+    count: components.length,
+    components
+  };
+}
+async function addComponent(state, input) {
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const renderer = def.renderer.type;
+  const entry = import_core7.COMPONENT_REGISTRY[input.component];
+  if (!entry) {
+    throw new Error(`Unknown component: "${input.component}"`);
+  }
+  const target = RENDERER_TARGET[renderer];
+  if (entry.target !== target) {
+    throw new Error(
+      `Component "${input.component}" has target "${entry.target}" but renderer "${renderer}" requires target "${target}"`
+    );
+  }
+  if (entry.renderers.length > 0 && !entry.renderers.includes(renderer)) {
+    throw new Error(
+      `Component "${input.component}" is not compatible with renderer "${renderer}". Compatible: ${entry.renderers.join(", ")}`
+    );
+  }
+  const existingComponents = {};
+  if (def.components) {
+    for (const [name, value] of Object.entries(def.components)) {
+      if (typeof value === "string") {
+        existingComponents[name] = value;
+      } else if (value.version) {
+        existingComponents[name] = value.version;
+      }
+    }
+  }
+  if (existingComponents[input.component]) {
+    throw new Error(
+      `Component "${input.component}" is already present in sketch "${input.sketchId}"`
+    );
+  }
+  existingComponents[input.component] = input.version ?? "^1.0.0";
+  const resolved = (0, import_core7.resolveComponents)(existingComponents, renderer);
+  const resolvedRecord = {};
+  for (const rc of resolved) {
+    resolvedRecord[rc.name] = {
+      version: rc.version,
+      code: rc.code,
+      exports: [...rc.exports]
+    };
+  }
+  const previousNames = new Set(
+    def.components ? Object.keys(def.components) : []
+  );
+  const added = resolved.map((rc) => rc.name).filter((name) => !previousNames.has(name));
+  const newDef = {
+    ...def,
+    genart: "1.2",
+    modified: (/* @__PURE__ */ new Date()).toISOString(),
+    components: resolvedRecord
+  };
+  state.sketches.set(input.sketchId, {
+    definition: newDef,
+    path: loaded.path
+  });
+  const json = (0, import_core7.serializeGenart)(newDef);
+  if (!state.remoteMode) {
+    await (0, import_promises5.writeFile)(loaded.path, json, "utf-8");
+  }
+  state.emitMutation("sketch:updated", {
+    id: input.sketchId,
+    updated: ["components"]
+  });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    components: resolvedRecord,
+    added,
+    fileContent: json
+  };
+}
+async function removeComponent(state, input) {
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  if (!def.components || !def.components[input.component]) {
+    throw new Error(
+      `Component "${input.component}" is not present in sketch "${input.sketchId}"`
+    );
+  }
+  const remaining = { ...def.components };
+  delete remaining[input.component];
+  for (const [name, value] of Object.entries(remaining)) {
+    const entry = import_core7.COMPONENT_REGISTRY[name];
+    if (entry && entry.dependencies.includes(input.component)) {
+      throw new Error(
+        `Cannot remove "${input.component}": component "${name}" depends on it`
+      );
+    }
+  }
+  let warning;
+  const removedValue = def.components[input.component];
+  const exports2 = typeof removedValue === "string" ? import_core7.COMPONENT_REGISTRY[input.component]?.exports ?? [] : removedValue.exports ?? [];
+  const usedExports = exports2.filter((exp) => def.algorithm.includes(exp));
+  if (usedExports.length > 0) {
+    warning = `Algorithm may reference these exports from "${input.component}": ${usedExports.join(", ")}. Review your algorithm after removal.`;
+  }
+  const removed = [input.component];
+  const neededDeps = /* @__PURE__ */ new Set();
+  for (const name of Object.keys(remaining)) {
+    const entry = import_core7.COMPONENT_REGISTRY[name];
+    if (entry) {
+      collectTransitiveDeps(name, neededDeps);
+    }
+  }
+  for (const name of Object.keys(remaining)) {
+    if (!neededDeps.has(name) && !isDirectComponent(name, remaining)) {
+      delete remaining[name];
+      removed.push(name);
+    }
+  }
+  const hasRemaining = Object.keys(remaining).length > 0;
+  const newDef = {
+    ...def,
+    modified: (/* @__PURE__ */ new Date()).toISOString(),
+    ...hasRemaining ? { components: remaining } : { components: void 0 }
+  };
+  state.sketches.set(input.sketchId, {
+    definition: newDef,
+    path: loaded.path
+  });
+  const json = (0, import_core7.serializeGenart)(newDef);
+  if (!state.remoteMode) {
+    await (0, import_promises5.writeFile)(loaded.path, json, "utf-8");
+  }
+  state.emitMutation("sketch:updated", {
+    id: input.sketchId,
+    updated: ["components"]
+  });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    removed,
+    ...warning ? { warning } : {},
+    fileContent: json
+  };
+}
+function collectTransitiveDeps(name, deps) {
+  const entry = import_core7.COMPONENT_REGISTRY[name];
+  if (!entry) return;
+  deps.add(name);
+  for (const dep of entry.dependencies) {
+    if (!deps.has(dep)) {
+      collectTransitiveDeps(dep, deps);
+    }
+  }
+}
+function isDirectComponent(name, components) {
+  return name in components;
+}
+
+// src/tools/capture.ts
+var import_promises6 = require("fs/promises");
+var import_core8 = require("@genart-dev/core");
 
 // src/capture/headless.ts
 var cachedModule = null;
@@ -2088,7 +2361,7 @@ async function captureHtmlMulti(options) {
 }
 
 // src/tools/capture.ts
-var registry2 = (0, import_core7.createDefaultRegistry)();
+var registry2 = (0, import_core8.createDefaultRegistry)();
 function applyOverrides(sketch, overrides) {
   if (overrides.seed === void 0 && overrides.params === void 0) {
     return sketch;
@@ -2169,7 +2442,7 @@ async function buildScreenshotMetadata(state, multi, info) {
     previewPath: info.previewPath
   };
   if (!state.remoteMode) {
-    await (0, import_promises5.writeFile)(info.previewPath, multi.previewPng);
+    await (0, import_promises6.writeFile)(info.previewPath, multi.previewPng);
     metadata.savedPreviewTo = info.previewPath;
   }
   return metadata;
@@ -2230,15 +2503,15 @@ async function captureBatch(state, input) {
 
 // src/tools/export.ts
 var import_fs = require("fs");
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_path8 = require("path");
 var import_archiver = __toESM(require("archiver"), 1);
-var import_core8 = require("@genart-dev/core");
-var registry3 = (0, import_core8.createDefaultRegistry)();
+var import_core9 = require("@genart-dev/core");
+var registry3 = (0, import_core9.createDefaultRegistry)();
 async function validateOutputPath(outputPath) {
   const parentDir = (0, import_path8.dirname)(outputPath);
   try {
-    const s = await (0, import_promises6.stat)(parentDir);
+    const s = await (0, import_promises7.stat)(parentDir);
     if (!s.isDirectory()) {
       throw new Error(`Parent directory does not exist: ${parentDir}`);
     }
@@ -2247,7 +2520,7 @@ async function validateOutputPath(outputPath) {
     throw new Error(`Parent directory does not exist: ${parentDir}`);
   }
   try {
-    await (0, import_promises6.stat)(outputPath);
+    await (0, import_promises7.stat)(outputPath);
     throw new Error(
       `File already exists at ${outputPath}. Delete it first or use a different path.`
     );
@@ -2302,7 +2575,7 @@ async function exportHtml(sketch, outputPath) {
   const adapter = registry3.resolve(sketch.renderer.type);
   const html = adapter.generateStandaloneHTML(sketch);
   const content = Buffer.from(html, "utf-8");
-  await (0, import_promises6.writeFile)(outputPath, content);
+  await (0, import_promises7.writeFile)(outputPath, content);
   return {
     success: true,
     sketchId: sketch.id,
@@ -2318,7 +2591,7 @@ async function exportPng(sketch, input) {
   const width = input.width ?? sketch.canvas.width;
   const height = input.height ?? sketch.canvas.height;
   const result = await captureHtml({ html, width, height });
-  await (0, import_promises6.writeFile)(input.outputPath, result.bytes);
+  await (0, import_promises7.writeFile)(input.outputPath, result.bytes);
   return {
     success: true,
     sketchId: sketch.id,
@@ -2333,7 +2606,7 @@ async function exportSvg(sketch, input) {
   const height = input.height ?? sketch.canvas.height;
   if (sketch.renderer.type === "svg") {
     const content2 = Buffer.from(sketch.algorithm, "utf-8");
-    await (0, import_promises6.writeFile)(input.outputPath, content2);
+    await (0, import_promises7.writeFile)(input.outputPath, content2);
     return {
       success: true,
       sketchId: sketch.id,
@@ -2355,7 +2628,7 @@ async function exportSvg(sketch, input) {
          href="data:image/png;base64,${b64}"/>
 </svg>`;
   const content = Buffer.from(svg, "utf-8");
-  await (0, import_promises6.writeFile)(input.outputPath, content);
+  await (0, import_promises7.writeFile)(input.outputPath, content);
   return {
     success: true,
     sketchId: sketch.id,
@@ -2368,7 +2641,7 @@ async function exportSvg(sketch, input) {
 }
 async function exportAlgorithm(sketch, outputPath) {
   const content = Buffer.from(sketch.algorithm, "utf-8");
-  await (0, import_promises6.writeFile)(outputPath, content);
+  await (0, import_promises7.writeFile)(outputPath, content);
   return {
     success: true,
     sketchId: sketch.id,
@@ -2383,7 +2656,7 @@ async function exportZip(sketch, input) {
   const width = input.width ?? sketch.canvas.width;
   const height = input.height ?? sketch.canvas.height;
   const html = adapter.generateStandaloneHTML(sketch);
-  const genartJson = (0, import_core8.serializeGenart)(sketch);
+  const genartJson = (0, import_core9.serializeGenart)(sketch);
   const algorithm = sketch.algorithm;
   const algExt = algorithmExtension(sketch.renderer.type);
   const captureResult = await captureHtml({ html, width, height });
@@ -2400,7 +2673,7 @@ async function exportZip(sketch, input) {
   archive.append(genartJson, { name: `${sketch.id}.genart` });
   await archive.finalize();
   await finished;
-  const s = await (0, import_promises6.stat)(input.outputPath);
+  const s = await (0, import_promises7.stat)(input.outputPath);
   return {
     success: true,
     sketchId: sketch.id,
@@ -2418,7 +2691,7 @@ async function exportZip(sketch, input) {
 }
 
 // src/resources/index.ts
-var import_core9 = require("@genart-dev/core");
+var import_core10 = require("@genart-dev/core");
 function registerResources(server, state) {
   registerSkillsResource(server);
   registerCanvasPresetsResource(server);
@@ -2426,7 +2699,7 @@ function registerResources(server, state) {
   registerRenderersResource(server);
 }
 function registerSkillsResource(server) {
-  const skillRegistry = (0, import_core9.createDefaultSkillRegistry)();
+  const skillRegistry = (0, import_core10.createDefaultSkillRegistry)();
   server.resource(
     "skills",
     "genart://skills",
@@ -2477,7 +2750,7 @@ function registerCanvasPresetsResource(server) {
           mimeType: "application/json",
           text: JSON.stringify(
             {
-              presets: import_core9.CANVAS_PRESETS.map((p) => ({
+              presets: import_core10.CANVAS_PRESETS.map((p) => ({
                 id: p.id,
                 label: p.label,
                 category: p.category,
@@ -2534,7 +2807,7 @@ function registerGalleryResource(server, state) {
   );
 }
 function registerRenderersResource(server) {
-  const registry4 = (0, import_core9.createDefaultRegistry)();
+  const registry4 = (0, import_core10.createDefaultRegistry)();
   server.resource(
     "renderers",
     "genart://renderers",
@@ -2916,6 +3189,7 @@ function createServer(state) {
   );
   registerWorkspaceTools(server, state);
   registerSketchTools(server, state);
+  registerComponentTools(server, state);
   registerSelectionTools(server, state);
   registerParameterTools(server, state);
   registerArrangementTools(server, state);
@@ -3019,7 +3293,7 @@ function registerWorkspaceTools(server, state) {
 function registerSketchTools(server, state) {
   server.tool(
     "create_sketch",
-    "Create a new .genart sketch file from metadata, parameters, and algorithm",
+    'Create a new .genart sketch file from metadata, parameters, and algorithm. IMPORTANT: Do not embed common utilities (PRNG, noise, easing, color math, vector ops) inline in the algorithm. Instead, declare them as components: { "prng": "^1.0.0", "noise-2d": "^1.0.0" }. Then use the exported functions directly in your algorithm (e.g., mulberry32, fbm2D). Use list_components to see all available components for the current renderer.',
     {
       id: import_zod2.z.string().describe("URL-safe kebab-case identifier"),
       title: import_zod2.z.string().describe("Human-readable title"),
@@ -3057,6 +3331,16 @@ function registerSketchTools(server, state) {
       algorithm: import_zod2.z.string().optional().describe("Algorithm source code (default: renderer template). For p5: must be `function sketch(p, state) { ... }` in instance mode. State provides: state.WIDTH, state.HEIGHT, state.SEED (number), state.PARAMS (keyed by param key), state.COLORS (keyed by color key, hex strings). Use p5 instance methods (p.createCanvas, p.background, etc)."),
       seed: import_zod2.z.number().optional().describe("Initial random seed (default: random)"),
       skills: import_zod2.z.array(import_zod2.z.string()).optional().describe("Design skill references"),
+      components: import_zod2.z.record(
+        import_zod2.z.union([
+          import_zod2.z.string(),
+          import_zod2.z.object({
+            version: import_zod2.z.string().optional(),
+            code: import_zod2.z.string().optional(),
+            exports: import_zod2.z.array(import_zod2.z.string()).optional()
+          })
+        ])
+      ).optional().describe('Component dependencies. Use list_components to see available. Keys are component names, values are semver ranges (e.g. "^1.0.0") or objects with version/code/exports.'),
       addToWorkspace: import_zod2.z.string().optional().describe("Path to workspace to add sketch to after creation"),
       agent: import_zod2.z.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
       model: import_zod2.z.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
@@ -3136,11 +3420,21 @@ function registerSketchTools(server, state) {
   );
   server.tool(
     "update_algorithm",
-    "Replace the algorithm source code of a sketch",
+    "Replace the algorithm source code of a sketch. If adding/changing components, pass them in the components field alongside the algorithm.",
     {
       sketchId: import_zod2.z.string().describe("ID of the sketch to update"),
       algorithm: import_zod2.z.string().describe("New algorithm source code. For p5: must be `function sketch(p, state) { ... }` in instance mode. State provides: state.WIDTH, state.HEIGHT, state.SEED, state.PARAMS (keyed by param key), state.COLORS (keyed by color key)."),
       validate: import_zod2.z.boolean().optional().describe("Run renderer-specific validation before saving (default: true)"),
+      components: import_zod2.z.record(
+        import_zod2.z.union([
+          import_zod2.z.string(),
+          import_zod2.z.object({
+            version: import_zod2.z.string().optional(),
+            code: import_zod2.z.string().optional(),
+            exports: import_zod2.z.array(import_zod2.z.string()).optional()
+          })
+        ])
+      ).optional().describe("Component dependencies to resolve alongside the algorithm update. Use list_components to see available."),
       agent: import_zod2.z.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
       model: import_zod2.z.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
     },
@@ -3236,6 +3530,76 @@ function registerSketchTools(server, state) {
     }
   );
 }
+function registerComponentTools(server, state) {
+  server.tool(
+    "list_components",
+    "List available reusable components from the registry, filtered by renderer and/or category. Components provide common utilities (PRNG, noise, easing, color math, etc.) that can be declared as dependencies instead of inlining code in the algorithm.",
+    {
+      renderer: import_zod2.z.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Filter by renderer compatibility"),
+      category: import_zod2.z.enum([
+        "randomness",
+        "noise",
+        "math",
+        "easing",
+        "color",
+        "vector",
+        "geometry",
+        "grid",
+        "particle",
+        "physics",
+        "distribution",
+        "pattern",
+        "sdf",
+        "transform",
+        "animation",
+        "string",
+        "data-structure",
+        "imaging"
+      ]).optional().describe("Filter by component category")
+    },
+    async (args) => {
+      try {
+        const result = await listComponents(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "add_component",
+    "Add a component dependency to an existing sketch. Resolves the component and any transitive dependencies from the registry, validates renderer compatibility, and writes the resolved form to the sketch file.",
+    {
+      sketchId: import_zod2.z.string().describe("ID of the sketch to add the component to"),
+      component: import_zod2.z.string().describe("Component name (e.g. 'prng', 'noise-2d', 'glsl-noise')"),
+      version: import_zod2.z.string().optional().describe("Version range (default: '^1.0.0')")
+    },
+    async (args) => {
+      try {
+        const result = await addComponent(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "remove_component",
+    "Remove a component dependency from a sketch. Checks for dependent components and warns if the algorithm references the component's exports.",
+    {
+      sketchId: import_zod2.z.string().describe("ID of the sketch to remove the component from"),
+      component: import_zod2.z.string().describe("Component name to remove")
+    },
+    async (args) => {
+      try {
+        const result = await removeComponent(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
 function registerSelectionTools(server, state) {
   server.tool(
     "get_selection",
@@ -3673,7 +4037,7 @@ function registerKnowledgeTools(server, _state) {
 
 // src/state.ts
 var import_events = require("events");
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_path9 = require("path");
 
 // src/sidecar.ts
@@ -3689,8 +4053,8 @@ function notifyMutation(type, payload) {
 }
 
 // src/state.ts
-var import_core10 = require("@genart-dev/core");
-var import_promises8 = require("fs/promises");
+var import_core11 = require("@genart-dev/core");
+var import_promises9 = require("fs/promises");
 var EditorState = class extends import_events.EventEmitter {
   /** Absolute path to the active .genart-workspace file, or null. */
   workspacePath = null;
@@ -3769,9 +4133,9 @@ var EditorState = class extends import_events.EventEmitter {
     if (this.basePath && !absPath.startsWith(this.basePath)) {
       throw new Error(`Path escapes sandbox: ${absPath}`);
     }
-    const raw = await (0, import_promises7.readFile)(absPath, "utf-8");
+    const raw = await (0, import_promises8.readFile)(absPath, "utf-8");
     const json = JSON.parse(raw);
-    const ws = (0, import_core10.parseWorkspace)(json);
+    const ws = (0, import_core11.parseWorkspace)(json);
     this.workspacePath = absPath;
     this.workspace = ws;
     this.sketches.clear();
@@ -3787,9 +4151,9 @@ var EditorState = class extends import_events.EventEmitter {
     if (this.basePath && !absPath.startsWith(this.basePath)) {
       throw new Error(`Path escapes sandbox: ${absPath}`);
     }
-    const raw = await (0, import_promises7.readFile)(absPath, "utf-8");
+    const raw = await (0, import_promises8.readFile)(absPath, "utf-8");
     const json = JSON.parse(raw);
-    const definition = (0, import_core10.parseGenart)(json);
+    const definition = (0, import_core11.parseGenart)(json);
     this.sketches.set(definition.id, { definition, path: absPath });
     this.emitMutation("sketch:loaded", { id: definition.id, path: absPath });
     return definition;
@@ -3824,18 +4188,18 @@ var EditorState = class extends import_events.EventEmitter {
     if (!this.workspace || !this.workspacePath) {
       throw new Error("No workspace is currently open");
     }
-    const json = (0, import_core10.serializeWorkspace)(this.workspace);
+    const json = (0, import_core11.serializeWorkspace)(this.workspace);
     if (!this.remoteMode) {
-      await (0, import_promises8.writeFile)(this.workspacePath, json, "utf-8");
+      await (0, import_promises9.writeFile)(this.workspacePath, json, "utf-8");
     }
     this.emitMutation("workspace:saved", { path: this.workspacePath });
   }
   /** Save a sketch to disk. */
   async saveSketch(id) {
     const loaded = this.requireSketch(id);
-    const json = (0, import_core10.serializeGenart)(loaded.definition);
+    const json = (0, import_core11.serializeGenart)(loaded.definition);
     if (!this.remoteMode) {
-      await (0, import_promises8.writeFile)(loaded.path, json, "utf-8");
+      await (0, import_promises9.writeFile)(loaded.path, json, "utf-8");
     }
     this.emitMutation("sketch:saved", { id, path: loaded.path });
   }