illustrator-mcp-server 1.4.0 → 1.5.1

package/dist/bundle.cjs

@@ -3107,6 +3107,9 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3299,27 +3302,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3334,7 +3387,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3348,7 +3401,10 @@ var require_utils = __commonJS({
     module2.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3572,12 +3628,12 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports2, module2) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -3644,19 +3700,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3681,12 +3727,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3721,7 +3767,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3732,6 +3787,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3752,6 +3808,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3790,14 +3851,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3806,7 +3871,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -20581,10 +20668,9 @@ var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
   /**
-   * Time in milliseconds to keep task results available after completion.
-   * If null, the task has unlimited lifetime until manually cleaned up.
+   * Requested duration in milliseconds to retain task from creation.
    */
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   /**
    * Time in milliseconds to wait between task status requests.
    */
@@ -20884,7 +20970,11 @@ var ClientCapabilitiesSchema = object({
   /**
    * Present if the client supports task creation.
    */
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  /**
+   * Extensions that the client supports. Keys are extension identifiers (vendor-prefix/extension-name).
+   */
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
@@ -20945,7 +21035,11 @@ var ServerCapabilitiesSchema = object({
   /**
    * Present if the server supports task creation.
    */
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  /**
+   * Extensions that the server supports. Keys are extension identifiers (vendor-prefix/extension-name).
+   */
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   /**
@@ -21137,6 +21231,12 @@ var ResourceSchema = object({
    * The MIME type of this resource, if known.
    */
   mimeType: optional(string2()),
+  /**
+   * The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known.
+   *
+   * This can be used by Hosts to display file sizes and estimate context window usage.
+   */
+  size: optional(number2()),
   /**
    * Optional annotations for the client.
    */
@@ -27785,6 +27885,10 @@ var Protocol = class {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -27915,7 +28019,9 @@ var Protocol = class {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error48) => this._onerror(new Error(`Failed to send response: ${error48}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -29928,6 +30034,9 @@ var McpServer = class {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
+        if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
+          throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+        }
         annotations = rest.shift();
       }
     }
@@ -30046,6 +30155,9 @@ function getZodSchemaObject(schema) {
   if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
+  if (!isZodSchemaInstance(schema)) {
+    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
+  }
   return schema;
 }
 function promptArgumentsFromSchema(schema) {
@@ -30279,8 +30391,8 @@ function createTempFiles() {
 async function writeParams(paramsPath, params) {
   await fs.writeFile(paramsPath, JSON.stringify(params ?? {}), "utf-8");
 }
-async function writeJsx(scriptPath, jsxCode60) {
-  await fs.writeFile(scriptPath, BOM + jsxCode60, "utf-8");
+async function writeJsx(scriptPath, jsxCode61) {
+  await fs.writeFile(scriptPath, BOM + jsxCode61, "utf-8");
 }
 async function writeAppleScript(scptPath, scriptPath, options) {
   const escaped = scriptPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -30452,11 +30564,11 @@ function getExecFailureMessage(error48, stderr, timeout, transport = "osascript"
   if (transport === "powershell") return parsePowerShellError(stderr || error48.message);
   return parseOsascriptError(stderr || error48.message);
 }
-async function executeViaOsascript(jsxCode60, params, timeout, activate) {
+async function executeViaOsascript(jsxCode61, params, timeout, activate) {
   const files = createTempFiles();
   try {
     await writeParams(files.paramsPath, params);
-    const fullJsx = await buildJsx(jsxCode60, files.paramsPath, files.resultPath);
+    const fullJsx = await buildJsx(jsxCode61, files.paramsPath, files.resultPath);
     await writeJsx(files.scriptPath, fullJsx);
     await writeAppleScript(files.runnerPath, files.scriptPath, { activate, appPath: getAppPath() });
     await new Promise((resolve2, reject) => {
@@ -30473,11 +30585,11 @@ async function executeViaOsascript(jsxCode60, params, timeout, activate) {
     await cleanupTempFiles(files);
   }
 }
-async function executeViaPowerShell(jsxCode60, params, timeout, activate) {
+async function executeViaPowerShell(jsxCode61, params, timeout, activate) {
   const files = createTempFiles();
   try {
     await writeParams(files.paramsPath, params);
-    const fullJsx = await buildJsx(jsxCode60, files.paramsPath, files.resultPath);
+    const fullJsx = await buildJsx(jsxCode61, files.paramsPath, files.resultPath);
     await writeJsx(files.scriptPath, fullJsx);
     await writePowerShellScript(files.runnerPath, files.scriptPath, { activate, appPath: getAppPath() });
     await new Promise((resolve2, reject) => {
@@ -30516,24 +30628,24 @@ async function readAndValidateResult(resultPath) {
   }
   return result;
 }
-async function executeJsxRaw(jsxCode60, params, timeout = TIMEOUT_NORMAL, activate = false) {
+async function executeJsxRaw(jsxCode61, params, timeout = TIMEOUT_NORMAL, activate = false) {
   const transport = getTransport();
   switch (transport) {
     case "osascript":
-      return await executeViaOsascript(jsxCode60, params, timeout, activate);
+      return await executeViaOsascript(jsxCode61, params, timeout, activate);
     case "powershell":
-      return await executeViaPowerShell(jsxCode60, params, timeout, activate);
+      return await executeViaPowerShell(jsxCode61, params, timeout, activate);
     default: {
       const _ = transport;
       throw new Error(`Unknown transport: ${_}`);
     }
   }
 }
-async function executeJsx(jsxCode60, params, options) {
+async function executeJsx(jsxCode61, params, options) {
   pendingCount++;
   try {
     return await jsxLimit(() => executeJsxRaw(
-      jsxCode60,
+      jsxCode61,
       params,
       options?.timeout ?? TIMEOUT_NORMAL,
       options?.activate ?? false
@@ -30545,8 +30657,8 @@ async function executeJsx(jsxCode60, params, options) {
     }
   }
 }
-async function executeJsxHeavy(jsxCode60, params) {
-  return executeJsx(jsxCode60, params, { timeout: TIMEOUT_HEAVY, activate: true });
+async function executeJsxHeavy(jsxCode61, params) {
+  return executeJsx(jsxCode61, params, { timeout: TIMEOUT_HEAVY, activate: true });
 }
 
 // src/tools/session.ts
@@ -30752,10 +30864,10 @@ function ensureToolParams(params) {
 function formatToolResult(result) {
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 }
-async function executeToolJsx(jsxCode60, params, options) {
+async function executeToolJsx(jsxCode61, params, options) {
   const baseParams = ensureToolParams(params);
   const resolvedParams = options?.resolveCoordinate ? { ...baseParams, coordinate_system: await resolveCoordinateSystem(baseParams.coordinate_system) } : baseParams;
-  const result = options?.heavy ? await executeJsxHeavy(jsxCode60, resolvedParams) : await executeJsx(jsxCode60, resolvedParams, { activate: options?.activate ?? false });
+  const result = options?.heavy ? await executeJsxHeavy(jsxCode61, resolvedParams) : await executeJsx(jsxCode61, resolvedParams, { activate: options?.activate ?? false });
   return formatToolResult(result);
 }
 
@@ -36657,11 +36769,26 @@ if (preflight) {
     var imgFile = new File(filePath);
     if (!imgFile.exists) {
       writeResultFile(RESULT_PATH, { error: true, message: "Image file not found: " + filePath });
+    } else if (/\\.svgz?$/i.test(filePath)) {
+      writeResultFile(RESULT_PATH, {
+        error: true,
+        message: "place_image does not support SVG files. SVG placed via PlacedItems becomes a non-editable linked artwork and often leaves broken link items in the document. Use import_svg_as_editable to bring SVG content in as editable Illustrator paths/text."
+      });
     } else {
       var targetLayer = resolveTargetLayer(doc, params.layer_name);
 
       var placed = targetLayer.placedItems.add();
-      placed.file = imgFile;
+      try {
+        placed.file = imgFile;
+      } catch (linkErr) {
+        // Setting .file failed \u2014 remove the orphaned PlacedItem so no broken link remains
+        try { placed.remove(); } catch (rmErr) {}
+        writeResultFile(RESULT_PATH, {
+          error: true,
+          message: "Failed to link image file (likely unsupported or corrupt): " + linkErr.message + ". The empty placed item was removed."
+        });
+        return;
+      }
 
       // Position
       if (typeof params.x === "number" && typeof params.y === "number") {
@@ -36726,7 +36853,7 @@ function register34(server) {
     "place_image",
     {
       title: "Place Image",
-      description: "Place an image file (PNG, JPG, TIFF, PSD, etc.) into the document as a linked or embedded image. Note: Illustrator will be activated (brought to foreground) during execution.",
+      description: "Place a raster or PDF image file (PNG, JPG, TIFF, PSD, PDF, etc.) into the document as a linked or embedded image. SVG is NOT supported here because PlacedItems produces a non-editable linked artwork \u2014 use import_svg_as_editable instead to bring SVG content in as editable paths/text. Note: Illustrator will be activated (brought to foreground) during execution.",
       inputSchema: {
         file_path: external_exports.string().describe("Absolute path to the image file"),
         x: external_exports.number().optional().describe("X position"),
@@ -36744,8 +36871,217 @@ function register34(server) {
   );
 }
 
-// src/tools/modify/resize-for-variation.ts
+// src/tools/modify/import-svg-as-editable.ts
 var jsxCode33 = `
+var srcDoc = null;
+var targetDocRef = null;
+var preflight = preflightChecks();
+if (preflight) {
+  writeResultFile(RESULT_PATH, preflight);
+} else {
+  try {
+    var params = readParamsFile(PARAMS_PATH);
+    var coordSystem = params.coordinate_system || "artboard-web";
+
+    var svgPath = params.file_path;
+    if (!/\\.svgz?$/i.test(svgPath)) {
+      writeResultFile(RESULT_PATH, { error: true, message: "import_svg_as_editable expects an .svg or .svgz file. Got: " + svgPath });
+    } else {
+      var svgFile = new File(svgPath);
+      if (!svgFile.exists) {
+        writeResultFile(RESULT_PATH, { error: true, message: "SVG file not found: " + svgPath });
+      } else {
+        targetDocRef = app.activeDocument;
+        var abRect = (coordSystem === "artboard-web") ? getActiveArtboardRect() : null;
+
+        try {
+          srcDoc = app.open(svgFile);
+        } catch (openErr) {
+          writeResultFile(RESULT_PATH, { error: true, message: "Failed to open SVG: " + openErr.message });
+          srcDoc = null;
+        }
+
+        if (srcDoc) {
+          // \u8907\u88FD\u4E2D\u306B\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u304C\u5909\u52D5\u3059\u308B\u305F\u3081\u4E8B\u524D\u306B\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8
+          var sourceItems = [];
+          for (var i = 0; i < srcDoc.pageItems.length; i++) {
+            sourceItems.push(srcDoc.pageItems[i]);
+          }
+
+          if (sourceItems.length === 0) {
+            try { srcDoc.close(SaveOptions.DONOTSAVECHANGES); } catch (e) {}
+            srcDoc = null;
+            app.activeDocument = targetDocRef;
+            writeResultFile(RESULT_PATH, { error: true, message: "SVG contains no importable items" });
+          } else {
+            var targetLayer = resolveTargetLayer(targetDocRef, params.layer_name);
+            var duplicated = [];
+            var dupErrors = [];
+            for (var j = 0; j < sourceItems.length; j++) {
+              try {
+                duplicated.push(sourceItems[j].duplicate(targetLayer, ElementPlacement.PLACEATEND));
+              } catch (dupErr) {
+                dupErrors.push({ index: j, message: dupErr.message });
+              }
+            }
+
+            try { srcDoc.close(SaveOptions.DONOTSAVECHANGES); } catch (e) {}
+            srcDoc = null;
+            app.activeDocument = targetDocRef;
+
+            if (duplicated.length === 0) {
+              writeResultFile(RESULT_PATH, {
+                error: true,
+                message: "Failed to duplicate any SVG items into target document",
+                details: dupErrors
+              });
+            } else {
+              var rootItem = wrapAsGroup(duplicated, targetLayer, params.group !== false);
+              var movables = rootItem ? [rootItem] : duplicated;
+
+              var bounds = rootItem ? rootItem.geometricBounds : unionBounds(duplicated);
+
+              // \u30D5\u30A3\u30C3\u30C8 \u2192 \u30B5\u30A4\u30BA\u304C\u5909\u308F\u3063\u305F\u3089\u30D0\u30A6\u30F3\u30C7\u30A3\u30F3\u30B0\u3092\u53D6\u308A\u76F4\u3059
+              if (params.fit_to_artboard === true && abRect) {
+                var pad = (typeof params.padding === "number") ? params.padding : 0;
+                fitItemsToArtboard(movables, bounds, abRect, pad);
+                bounds = rootItem ? rootItem.geometricBounds : unionBounds(duplicated);
+              }
+
+              // \u660E\u793A\u7684\u306A x/y \u6307\u5B9A\uFF08fit_to_artboard \u6642\u306F\u4E2D\u592E\u914D\u7F6E\u304C\u512A\u5148\u3055\u308C\u308B\u306E\u3067\u7121\u8996\uFF09
+              if (!(params.fit_to_artboard === true && abRect) &&
+                  typeof params.x === "number" && typeof params.y === "number") {
+                var pos = webToAiPoint(params.x, params.y, coordSystem, abRect);
+                translateItems(movables, pos[0] - bounds[0], pos[1] - bounds[1]);
+                bounds = rootItem ? rootItem.geometricBounds : unionBounds(duplicated);
+              }
+
+              var rootUuid = null;
+              if (rootItem) {
+                if (params.name) rootItem.name = params.name;
+                rootUuid = ensureUUID(rootItem);
+              }
+
+              var itemSummaries = [];
+              for (var u = 0; u < duplicated.length; u++) {
+                itemSummaries.push({
+                  uuid: ensureUUID(duplicated[u]),
+                  type: duplicated[u].typename,
+                  name: duplicated[u].name || ""
+                });
+              }
+
+              writeResultFile(RESULT_PATH, {
+                success: true,
+                sourcePath: svgPath,
+                grouped: !!rootItem && duplicated.length > 1,
+                rootUuid: rootUuid,
+                importedCount: duplicated.length,
+                widthPt: bounds[2] - bounds[0],
+                heightPt: bounds[1] - bounds[3],
+                items: itemSummaries,
+                duplicationErrors: dupErrors.length > 0 ? dupErrors : undefined,
+                verified: rootItem ? verifyItem(rootItem, coordSystem, abRect) : null
+              });
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    writeResultFile(RESULT_PATH, { error: true, message: "import_svg_as_editable failed: " + e.message, line: e.line });
+  } finally {
+    // \u60F3\u5B9A\u5916\u306E\u30D1\u30B9\u3067 srcDoc \u304C\u958B\u3044\u305F\u307E\u307E\u306A\u3089\u9589\u3058\u308B
+    if (srcDoc) {
+      try { srcDoc.close(SaveOptions.DONOTSAVECHANGES); } catch (e) {}
+    }
+    if (targetDocRef) {
+      try { app.activeDocument = targetDocRef; } catch (e) {}
+    }
+  }
+}
+
+// --- \u30ED\u30FC\u30AB\u30EB\u30D8\u30EB\u30D1\u30FC ---
+
+function unionBounds(items) {
+  // [left, top, right, bottom]
+  var b = [items[0].geometricBounds[0], items[0].geometricBounds[1],
+           items[0].geometricBounds[2], items[0].geometricBounds[3]];
+  for (var k = 1; k < items.length; k++) {
+    var g = items[k].geometricBounds;
+    if (g[0] < b[0]) b[0] = g[0];
+    if (g[1] > b[1]) b[1] = g[1];
+    if (g[2] > b[2]) b[2] = g[2];
+    if (g[3] < b[3]) b[3] = g[3];
+  }
+  return b;
+}
+
+function translateItems(items, dx, dy) {
+  if (dx === 0 && dy === 0) return;
+  for (var i = 0; i < items.length; i++) items[i].translate(dx, dy);
+}
+
+function wrapAsGroup(items, parentLayer, shouldGroup) {
+  if (!shouldGroup) return null;
+  if (items.length === 1) return items[0];
+  var group = parentLayer.groupItems.add();
+  // duplicate \u306F PLACEATEND \u3067\u672B\u5C3E\u306B\u7A4D\u307E\u308C\u3066\u3044\u308B\u3002\u30B0\u30EB\u30FC\u30D7\u306B\u79FB\u3059\u3068\u7A4D\u307F\u9806\u304C\u53CD\u8EE2\u3059\u308B\u305F\u3081\u3001
+  // \u9006\u9806\u306B moveToBeginning \u3059\u308B\u3053\u3068\u3067\u5143\u306E z-order \u3092\u4FDD\u3064\u3002
+  for (var i = items.length - 1; i >= 0; i--) {
+    items[i].moveToBeginning(group);
+  }
+  return group;
+}
+
+function fitItemsToArtboard(items, bounds, abRect, pad) {
+  var abW = abRect[2] - abRect[0];
+  var abH = abRect[1] - abRect[3];
+  var availW = abW - pad * 2;
+  var availH = abH - pad * 2;
+  var w = bounds[2] - bounds[0];
+  var h = bounds[1] - bounds[3];
+  if (w <= 0 || h <= 0 || availW <= 0 || availH <= 0) return;
+
+  var scalePct = Math.min(availW / w, availH / h) * 100;
+  for (var i = 0; i < items.length; i++) items[i].resize(scalePct, scalePct);
+
+  // \u30EA\u30B5\u30A4\u30BA\u5F8C\u306B\u30D0\u30A6\u30F3\u30C7\u30A3\u30F3\u30B0\u3092\u53D6\u308A\u76F4\u3057\u3066\u4E2D\u592E\u914D\u7F6E
+  var newB = (items.length === 1) ? items[0].geometricBounds : unionBounds(items);
+  var newW = newB[2] - newB[0];
+  var newH = newB[1] - newB[3];
+  var targetLeft = abRect[0] + (abW - newW) / 2;
+  var targetTop = abRect[1] - (abH - newH) / 2;
+  translateItems(items, targetLeft - newB[0], targetTop - newB[1]);
+}
+`;
+function register35(server) {
+  server.registerTool(
+    "import_svg_as_editable",
+    {
+      title: "Import SVG as Editable",
+      description: "Import an SVG file into the active document as editable Illustrator paths/text/groups (NOT as a linked image). Internally opens the SVG as a temporary document, duplicates its contents into the target document, then closes the source. Use this instead of place_image for SVG. Note: Illustrator will be activated (brought to foreground) during execution.",
+      inputSchema: {
+        file_path: external_exports.string().describe("Absolute path to the .svg or .svgz file"),
+        x: external_exports.number().optional().describe("X position of the imported content (top-left of bounding box). Ignored when fit_to_artboard is true."),
+        y: external_exports.number().optional().describe("Y position of the imported content (top-left of bounding box). Ignored when fit_to_artboard is true."),
+        layer_name: external_exports.string().optional().describe("Target layer name in the active document. Created if missing."),
+        group: external_exports.boolean().optional().default(true).describe("Wrap imported items in a single GroupItem (default: true). Set false to keep items flat in the target layer."),
+        fit_to_artboard: external_exports.boolean().optional().default(false).describe("Scale and center the imported content to fit the active artboard (default: false)."),
+        padding: external_exports.number().optional().describe("Padding in points from the artboard edges when fit_to_artboard is true."),
+        name: external_exports.string().optional().describe("Name to assign to the root group (only when group=true and multiple items are imported)."),
+        coordinate_system: coordinateSystemSchema
+      },
+      annotations: WRITE_ANNOTATIONS
+    },
+    async (params) => {
+      return executeToolJsx(jsxCode33, params, { activate: true, resolveCoordinate: true });
+    }
+  );
+}
+
+// src/tools/modify/resize-for-variation.ts
+var jsxCode34 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -36879,7 +37215,7 @@ if (preflight) {
   }
 }
 `;
-function register35(server) {
+function register36(server) {
   server.registerTool(
     "resize_for_variation",
     {
@@ -36900,13 +37236,13 @@ function register35(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      return executeToolJsx(jsxCode33, params, { heavy: true, resolveCoordinate: true });
+      return executeToolJsx(jsxCode34, params, { heavy: true, resolveCoordinate: true });
     }
   );
 }
 
 // src/tools/modify/align-objects.ts
-var jsxCode34 = `
+var jsxCode35 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -37069,7 +37405,7 @@ if (preflight) {
   }
 }
 `;
-function register36(server) {
+function register37(server) {
   server.registerTool(
     "align_objects",
     {
@@ -37085,13 +37421,13 @@ function register36(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      return executeToolJsx(jsxCode34, params, { resolveCoordinate: true });
+      return executeToolJsx(jsxCode35, params, { resolveCoordinate: true });
     }
   );
 }
 
 // src/tools/modify/replace-color.ts
-var jsxCode35 = `
+var jsxCode36 = `
 ${COLOR_HELPERS_JSX}
 
 var preflight = preflightChecks();
@@ -37187,7 +37523,7 @@ if (preflight) {
   }
 }
 `;
-function register37(server) {
+function register38(server) {
   server.registerTool(
     "replace_color",
     {
@@ -37203,14 +37539,14 @@ function register37(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode35, params);
+      const result = await executeJsx(jsxCode36, params);
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/manage-layers.ts
-var jsxCode36 = `
+var jsxCode37 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -37315,7 +37651,7 @@ if (preflight) {
   }
 }
 `;
-function register38(server) {
+function register39(server) {
   server.registerTool(
     "manage_layers",
     {
@@ -37331,14 +37667,14 @@ function register38(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode36, params);
+      const result = await executeJsx(jsxCode37, params);
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/place-color-chips.ts
-var jsxCode37 = `
+var jsxCode38 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -37513,7 +37849,7 @@ if (preflight) {
   }
 }
 `;
-function register39(server) {
+function register40(server) {
   server.registerTool(
     "place_color_chips",
     {
@@ -37530,13 +37866,13 @@ function register39(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      return executeToolJsx(jsxCode37, params, { heavy: true, resolveCoordinate: true });
+      return executeToolJsx(jsxCode38, params, { heavy: true, resolveCoordinate: true });
     }
   );
 }
 
 // src/tools/modify/place-style-guide.ts
-var jsxCode38 = `
+var jsxCode39 = `
 // \u2500\u2500\u2500 Helper functions (top-level for ES3 compatibility) \u2500\u2500\u2500
 function makeTextColor(isCMYK) {
   if (isCMYK) {
@@ -38321,7 +38657,7 @@ if (preflight) {
   }
 }
 `;
-function register40(server) {
+function register41(server) {
   server.registerTool(
     "place_style_guide",
     {
@@ -38336,13 +38672,13 @@ function register40(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      return executeToolJsx(jsxCode38, params, { heavy: true, resolveCoordinate: true });
+      return executeToolJsx(jsxCode39, params, { heavy: true, resolveCoordinate: true });
     }
   );
 }
 
 // src/tools/modify/create-crop-marks.ts
-var jsxCode39 = `
+var jsxCode40 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -38510,7 +38846,7 @@ if (preflight) {
   }
 }
 `;
-function register41(server) {
+function register42(server) {
   server.registerTool(
     "create_crop_marks",
     {
@@ -38531,7 +38867,7 @@ function register41(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeToolJsx(jsxCode39, params, { activate: true });
+      const result = await executeToolJsx(jsxCode40, params, { activate: true });
       const coordSystem = await resolveCoordinateSystem(void 0);
       const coordNote = coordSystem === "document" ? "document (Y-up, origin at bottom-left)" : "artboard-web (Y-down, origin at top-left)";
       for (const item of result.content) {
@@ -38553,7 +38889,7 @@ function register41(server) {
 }
 
 // src/tools/modify/create-document.ts
-var jsxCode40 = `
+var jsxCode41 = `
 try {
   var verErr = checkIllustratorVersion();
   if (verErr) {
@@ -38583,7 +38919,7 @@ try {
   writeResultFile(RESULT_PATH, { error: true, message: "Failed to create document: " + e.message, line: e.line });
 }
 `;
-function register42(server) {
+function register43(server) {
   server.registerTool(
     "create_document",
     {
@@ -38597,7 +38933,7 @@ function register42(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode40, params, { activate: true });
+      const result = await executeJsx(jsxCode41, params, { activate: true });
       invalidateAutoDetectCache();
       return formatToolResult(result);
     }
@@ -38605,7 +38941,7 @@ function register42(server) {
 }
 
 // src/tools/modify/close-document.ts
-var jsxCode41 = `
+var jsxCode42 = `
 try {
   var verErr = checkIllustratorVersion();
   if (verErr) {
@@ -38626,7 +38962,7 @@ try {
   writeResultFile(RESULT_PATH, { error: true, message: "Failed to close document: " + e.message, line: e.line });
 }
 `;
-function register43(server) {
+function register44(server) {
   server.registerTool(
     "close_document",
     {
@@ -38638,7 +38974,7 @@ function register43(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode41, params, { activate: true });
+      const result = await executeJsx(jsxCode42, params, { activate: true });
       invalidateAutoDetectCache();
       return formatToolResult(result);
     }
@@ -38646,7 +38982,7 @@ function register43(server) {
 }
 
 // src/tools/modify/save-document.ts
-var jsxCode42 = `
+var jsxCode43 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -38694,7 +39030,7 @@ if (preflight) {
   }
 }
 `;
-function register44(server) {
+function register45(server) {
   server.registerTool(
     "save_document",
     {
@@ -38707,14 +39043,14 @@ function register44(server) {
       annotations: WRITE_IDEMPOTENT_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode42, params, { activate: true });
+      const result = await executeJsx(jsxCode43, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/open-document.ts
-var jsxCode43 = `
+var jsxCode44 = `
 try {
   var verErr = checkIllustratorVersion();
   if (verErr) {
@@ -38753,7 +39089,7 @@ try {
   writeResultFile(RESULT_PATH, { error: true, message: "open_document failed: " + e.message, line: e.line });
 }
 `;
-function register45(server) {
+function register46(server) {
   server.registerTool(
     "open_document",
     {
@@ -38766,7 +39102,7 @@ function register45(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode43, params, { activate: true });
+      const result = await executeJsx(jsxCode44, params, { activate: true });
       invalidateAutoDetectCache();
       return formatToolResult(result);
     }
@@ -38774,7 +39110,7 @@ function register45(server) {
 }
 
 // src/tools/modify/group-objects.ts
-var jsxCode44 = `
+var jsxCode45 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -38822,7 +39158,7 @@ if (preflight) {
   }
 }
 `;
-function register46(server) {
+function register47(server) {
   server.registerTool(
     "group_objects",
     {
@@ -38836,14 +39172,14 @@ function register46(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode44, params, { activate: true });
+      const result = await executeJsx(jsxCode45, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/ungroup-objects.ts
-var jsxCode45 = `
+var jsxCode46 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -38886,7 +39222,7 @@ if (preflight) {
   }
 }
 `;
-function register47(server) {
+function register48(server) {
   server.registerTool(
     "ungroup_objects",
     {
@@ -38898,14 +39234,14 @@ function register47(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode45, params, { activate: true });
+      const result = await executeJsx(jsxCode46, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/duplicate-objects.ts
-var jsxCode46 = `
+var jsxCode47 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -38977,7 +39313,7 @@ if (preflight) {
   }
 }
 `;
-function register48(server) {
+function register49(server) {
   server.registerTool(
     "duplicate_objects",
     {
@@ -38995,14 +39331,14 @@ function register48(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode46, params, { activate: true });
+      const result = await executeJsx(jsxCode47, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/read/list-fonts.ts
-var jsxCode47 = `
+var jsxCode48 = `
 try {
   var verErr = checkIllustratorVersion();
   if (verErr) {
@@ -39040,7 +39376,7 @@ try {
   writeResultFile(RESULT_PATH, { error: true, message: "list_fonts failed: " + e.message, line: e.line });
 }
 `;
-function register49(server) {
+function register50(server) {
   server.registerTool(
     "list_fonts",
     {
@@ -39053,14 +39389,14 @@ function register49(server) {
       annotations: READ_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode47, params);
+      const result = await executeJsx(jsxCode48, params);
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/manage-artboards.ts
-var jsxCode48 = `
+var jsxCode49 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -39155,7 +39491,7 @@ if (preflight) {
   }
 }
 `;
-function register50(server) {
+function register51(server) {
   server.registerTool(
     "manage_artboards",
     {
@@ -39178,14 +39514,14 @@ function register50(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode48, params, { activate: true });
+      const result = await executeJsx(jsxCode49, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/set-z-order.ts
-var jsxCode49 = `
+var jsxCode50 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -39217,7 +39553,7 @@ if (preflight) {
   }
 }
 `;
-function register51(server) {
+function register52(server) {
   server.registerTool(
     "set_z_order",
     {
@@ -39230,14 +39566,14 @@ function register51(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode49, params, { activate: true });
+      const result = await executeJsx(jsxCode50, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/move-to-layer.ts
-var jsxCode50 = `
+var jsxCode51 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -39284,7 +39620,7 @@ if (preflight) {
   }
 }
 `;
-function register52(server) {
+function register53(server) {
   server.registerTool(
     "move_to_layer",
     {
@@ -39298,7 +39634,7 @@ function register52(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode50, params, { activate: true });
+      const result = await executeJsx(jsxCode51, params, { activate: true });
       return formatToolResult(result);
     }
   );
@@ -39369,7 +39705,7 @@ if (preflight) {
   }
 }
 `;
-function register53(server) {
+function register54(server) {
   server.registerTool(
     "apply_graphic_style",
     {
@@ -39403,7 +39739,7 @@ function register53(server) {
 }
 
 // src/tools/modify/manage-swatches.ts
-var jsxCode51 = `
+var jsxCode52 = `
 ${COLOR_HELPERS_JSX}
 
 var preflight = preflightChecks();
@@ -39450,7 +39786,7 @@ if (preflight) {
   }
 }
 `;
-function register54(server) {
+function register55(server) {
   server.registerTool(
     "manage_swatches",
     {
@@ -39464,7 +39800,7 @@ function register54(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode51, params, { activate: true });
+      const result = await executeJsx(jsxCode52, params, { activate: true });
       return formatToolResult(result);
     }
   );
@@ -39546,7 +39882,7 @@ if (preflight) {
   }
 }
 `;
-function register55(server) {
+function register56(server) {
   server.registerTool(
     "apply_text_style",
     {
@@ -39581,7 +39917,7 @@ function register55(server) {
 }
 
 // src/tools/modify/create-gradient.ts
-var jsxCode52 = `
+var jsxCode53 = `
 ${COLOR_HELPERS_JSX}
 
 var preflight = preflightChecks();
@@ -39646,7 +39982,7 @@ if (preflight) {
 }
 `;
 var stopColorSchema = external_exports.discriminatedUnion("type", [cmykColorSchema, rgbColorSchema, grayColorSchema]);
-function register56(server) {
+function register57(server) {
   server.registerTool(
     "create_gradient",
     {
@@ -39669,14 +40005,14 @@ function register56(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode52, params, { activate: true });
+      const result = await executeJsx(jsxCode53, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/manage-linked-images.ts
-var jsxCode53 = `
+var jsxCode54 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -39751,7 +40087,7 @@ if (preflight) {
   }
 }
 `;
-function register57(server) {
+function register58(server) {
   server.registerTool(
     "manage_linked_images",
     {
@@ -39765,14 +40101,14 @@ function register57(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode53, params, { activate: true });
+      const result = await executeJsx(jsxCode54, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/undo.ts
-var jsxCode54 = `
+var jsxCode55 = `
 try {
   var verErr = checkIllustratorVersion();
   if (verErr) {
@@ -39800,7 +40136,7 @@ try {
   writeResultFile(RESULT_PATH, { error: true, message: "undo failed: " + e.message, line: e.line });
 }
 `;
-function register58(server) {
+function register59(server) {
   server.registerTool(
     "undo",
     {
@@ -39813,14 +40149,14 @@ function register58(server) {
       annotations: DESTRUCTIVE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode54, params, { activate: true });
+      const result = await executeJsx(jsxCode55, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/manage-datasets.ts
-var jsxCode55 = `
+var jsxCode56 = `
 function parseCsvLine(line) {
   var result = [];
   var current = "";
@@ -40103,7 +40439,7 @@ if (preflight) {
   }
 }
 `;
-function register59(server) {
+function register60(server) {
   server.registerTool(
     "manage_datasets",
     {
@@ -40129,14 +40465,14 @@ function register59(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode55, params, { activate: true });
+      const result = await executeJsx(jsxCode56, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/place-symbol.ts
-var jsxCode56 = `
+var jsxCode57 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -40191,7 +40527,7 @@ if (preflight) {
   }
 }
 `;
-function register60(server) {
+function register61(server) {
   server.registerTool(
     "place_symbol",
     {
@@ -40208,14 +40544,14 @@ function register60(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode56, params, { activate: true });
+      const result = await executeJsx(jsxCode57, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/create-path-text.ts
-var jsxCode57 = `
+var jsxCode58 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -40267,7 +40603,7 @@ if (preflight) {
   }
 }
 `;
-function register61(server) {
+function register62(server) {
   server.registerTool(
     "create_path_text",
     {
@@ -40286,14 +40622,14 @@ function register61(server) {
       annotations: WRITE_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode57, params, { activate: true });
+      const result = await executeJsx(jsxCode58, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/modify/select-objects.ts
-var jsxCode58 = `
+var jsxCode59 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -40343,7 +40679,7 @@ if (preflight) {
   }
 }
 `;
-function register62(server) {
+function register63(server) {
   server.registerTool(
     "select_objects",
     {
@@ -40357,14 +40693,14 @@ function register62(server) {
       annotations: WRITE_IDEMPOTENT_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode58, params, { activate: true });
+      const result = await executeJsx(jsxCode59, params, { activate: true });
       return formatToolResult(result);
     }
   );
 }
 
 // src/tools/read/convert-coordinate.ts
-var jsxCode59 = `
+var jsxCode60 = `
 var preflight = preflightChecks();
 if (preflight) {
   writeResultFile(RESULT_PATH, preflight);
@@ -40401,7 +40737,7 @@ if (preflight) {
   }
 }
 `;
-function register63(server) {
+function register64(server) {
   server.registerTool(
     "convert_coordinate",
     {
@@ -40418,7 +40754,7 @@ function register63(server) {
       annotations: READ_ANNOTATIONS
     },
     async (params) => {
-      const result = await executeJsx(jsxCode59, params);
+      const result = await executeJsx(jsxCode60, params);
       return formatToolResult(result);
     }
   );
@@ -40489,10 +40825,11 @@ function registerAllTools(server) {
   register61(server);
   register62(server);
   register63(server);
+  register64(server);
 }
 
 // src/prompts/quick-layout.ts
-function register64(server) {
+function register65(server) {
   server.registerPrompt(
     "quick-layout",
     {
@@ -40535,7 +40872,7 @@ Always respond in the user's language.`
 }
 
 // src/prompts/print-preflight-workflow.ts
-function register65(server) {
+function register66(server) {
   server.registerPrompt(
     "print-preflight-workflow",
     {
@@ -40588,8 +40925,8 @@ Always respond in the user's language.`
 
 // src/prompts/registry.ts
 function registerAllPrompts(server) {
-  register64(server);
   register65(server);
+  register66(server);
 }
 
 // src/server.ts