@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-FMTLP5ZX.js

@@ -0,0 +1,1397 @@
+import {
+  JSDOC_BLOCK_REGEX,
+  ORPHAN_PORT_LINE_REGEX,
+  PORT_TAG_REGEX,
+  RESERVED_PARAMS,
+  SCOPE_TAG_REGEX,
+  buildCallbackType,
+  callbackHasAllPorts,
+  findBalancedClose,
+  parseCallbackType,
+  parseFunctionSignature,
+  parseInputTypeFields,
+  parseReturnBodyFieldsWithTypes,
+  parseReturnFields,
+  parseReturnTypeFields,
+  parseReturnTypeFieldsWithTypes,
+  portTypeToTsType,
+  rawParamListText,
+  splitParams,
+  tsTypeToPortType
+} from "./chunk-NQNLUAPO.js";
+import {
+  generateJSDocPortTag
+} from "./chunk-VP2P3BPA.js";
+import {
+  inferDataTypeFromTS
+} from "./chunk-E5WN7IGO.js";
+import {
+  isValidPortLine,
+  parsePortLine,
+  parsePortsFromJSDoc
+} from "./chunk-QYPORSLO.js";
+import {
+  SCOPED_PORT_NAMES,
+  isExecutePort,
+  isFailurePort,
+  isReservedPortName,
+  isScopedMandatoryPort,
+  isSuccessPort
+} from "./chunk-R4QGNK34.js";
+
+// src/jsdoc-port-sync/incomplete-lines.ts
+function partialPortTag(line) {
+  const partialMatch = line.match(/\*\s*@(input|output|step)\s+\[?(\w+)/);
+  if (!partialMatch) return null;
+  return { tagType: partialMatch[1], portName: partialMatch[2] };
+}
+function hasOrphanPortLines(functionText) {
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (!jsdocMatch) return { inputs: false, outputs: false };
+  const lines = jsdocMatch[0].split("\n");
+  let hasOrphanInputs = false;
+  let hasOrphanOutputs = false;
+  for (const line of lines) {
+    const orphanMatch = line.match(ORPHAN_PORT_LINE_REGEX);
+    if (orphanMatch) {
+      const [, tagType] = orphanMatch;
+      if (tagType === "input") hasOrphanInputs = true;
+      else hasOrphanOutputs = true;
+    }
+  }
+  return { inputs: hasOrphanInputs, outputs: hasOrphanOutputs };
+}
+function getIncompletePortNames(functionText) {
+  const inputs = /* @__PURE__ */ new Set();
+  const outputs = /* @__PURE__ */ new Set();
+  const steps = /* @__PURE__ */ new Set();
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (!jsdocMatch) return { inputs, outputs, steps };
+  const lines = jsdocMatch[0].split("\n");
+  for (const line of lines) {
+    if (!PORT_TAG_REGEX.test(line)) continue;
+    if (isValidPortLine(line)) continue;
+    const partial = partialPortTag(line);
+    if (partial) {
+      const { tagType, portName } = partial;
+      if (tagType === "input") {
+        inputs.add(portName);
+      } else if (tagType === "output") {
+        outputs.add(portName);
+      } else if (tagType === "step") {
+        steps.add(portName);
+      }
+    }
+  }
+  return { inputs, outputs, steps };
+}
+function isIncompletePortLine(line) {
+  if (!PORT_TAG_REGEX.test(line)) return false;
+  if (!isValidPortLine(line)) return true;
+  const cleanLine = line.replace(/^\s*\*\s*/, "").trim();
+  if (/\s-\s*$/.test(cleanLine)) return true;
+  return false;
+}
+
+// src/jsdoc-port-sync/port-tag-placement.ts
+function tagLine(name, port, direction) {
+  return ` * ${generateJSDocPortTag(name, port, direction)}`;
+}
+function markInputLine(scan, name, index) {
+  scan.seenInputs.add(name);
+  scan.lastInputLineIndex = index;
+}
+function markOutputLine(scan, name, index) {
+  scan.seenOutputs.add(name);
+  scan.lastOutputLineIndex = index;
+}
+function keepOrphanLine(scan, line, tagType) {
+  const lineIndex = scan.preservedLines.length;
+  scan.preservedLines.push(line);
+  if (tagType === "input") {
+    scan.orphanInputLines.push({ index: lineIndex, type: "ANY" });
+    scan.lastInputLineIndex = lineIndex;
+  } else if (tagType === "output" || tagType === "step") {
+    scan.orphanOutputLines.push({ index: lineIndex, type: "ANY" });
+    scan.lastOutputLineIndex = lineIndex;
+  }
+}
+function keepIncompleteLine(scan, line) {
+  const lineIndex = scan.preservedLines.length;
+  scan.preservedLines.push(line);
+  const partial = partialPortTag(line);
+  if (!partial) return;
+  const { tagType, portName } = partial;
+  if (tagType === "input") {
+    markInputLine(scan, portName, lineIndex);
+  } else if (tagType === "output") {
+    markOutputLine(scan, portName, lineIndex);
+  } else if (tagType === "step") {
+    scan.seenInputs.add(portName);
+    scan.seenOutputs.add(portName);
+  }
+}
+function keepParsedLine(scan, line, parsed, inputs, outputs) {
+  const lineIndex = scan.preservedLines.length;
+  if (parsed.type === "input") {
+    if (!inputs[parsed.name]) return;
+    scan.preservedLines.push(line.trimEnd());
+    markInputLine(scan, parsed.name, lineIndex);
+  } else if (parsed.type === "output") {
+    if (!outputs[parsed.name]) return;
+    scan.preservedLines.push(line.trimEnd());
+    markOutputLine(scan, parsed.name, lineIndex);
+  } else if (parsed.type === "step") {
+    const isInput = inputs[parsed.name] !== void 0;
+    const isOutput = outputs[parsed.name] !== void 0;
+    if (!isInput && !isOutput) return;
+    scan.preservedLines.push(line.trimEnd());
+    if (isInput) markInputLine(scan, parsed.name, lineIndex);
+    if (isOutput) markOutputLine(scan, parsed.name, lineIndex);
+  }
+}
+function scanPortLine(scan, line, inputs, outputs) {
+  const orphanMatch = line.match(ORPHAN_PORT_LINE_REGEX);
+  if (orphanMatch) {
+    keepOrphanLine(scan, line, orphanMatch[1]);
+    return;
+  }
+  if (isIncompletePortLine(line)) {
+    keepIncompleteLine(scan, line);
+    return;
+  }
+  const cleanLine = line.replace(/^\s*\*\s*/, "").trim();
+  const parsed = parsePortLine(cleanLine, []);
+  if (parsed) {
+    keepParsedLine(scan, line, parsed, inputs, outputs);
+    return;
+  }
+  scan.preservedLines.push(line);
+}
+function scanPortLines(lines, inputs, outputs) {
+  const scan = {
+    preservedLines: [],
+    hasFlowWeaverTag: false,
+    seenInputs: /* @__PURE__ */ new Set(),
+    seenOutputs: /* @__PURE__ */ new Set(),
+    orphanInputLines: [],
+    orphanOutputLines: [],
+    lastInputLineIndex: -1,
+    lastOutputLineIndex: -1
+  };
+  for (const line of lines) {
+    if (line.trim() === "/**" || line.trim() === "*/") {
+      scan.preservedLines.push(line);
+      continue;
+    }
+    if (PORT_TAG_REGEX.test(line)) {
+      scanPortLine(scan, line, inputs, outputs);
+      continue;
+    }
+    if (line.includes("@flowWeaver")) {
+      scan.hasFlowWeaverTag = true;
+    }
+    scan.preservedLines.push(line);
+  }
+  return scan;
+}
+function fillOrphanLines(newLines, portsToAdd, orphanLines, direction) {
+  const remaining = [];
+  for (const [name, port] of portsToAdd) {
+    const orphanIndex = orphanLines.findIndex((o) => o.type === port.dataType);
+    if (orphanIndex !== -1) {
+      const orphan = orphanLines[orphanIndex];
+      newLines[orphan.index] = tagLine(name, port, direction);
+      orphanLines.splice(orphanIndex, 1);
+    } else if (orphanLines.length > 0) {
+      const orphan = orphanLines.shift();
+      newLines[orphan.index] = tagLine(name, port, direction);
+    } else {
+      remaining.push([name, port]);
+    }
+  }
+  return remaining;
+}
+function insertOutputTags(newLines, outputsToAdd, scan) {
+  const newOutputTags = outputsToAdd.map(([name, port]) => tagLine(name, port, "output"));
+  const closingIndex = newLines.findIndex((l) => l.trim() === "*/");
+  if (newOutputTags.length === 0) return;
+  const outputInsertIndex = scan.lastOutputLineIndex >= 0 ? scan.lastOutputLineIndex + 1 : scan.lastInputLineIndex >= 0 ? scan.lastInputLineIndex + 1 : closingIndex;
+  newLines.splice(outputInsertIndex, 0, ...newOutputTags);
+}
+function insertInputsInSignatureOrder(newLines, inputsToAdd, signatureInputOrder2, flowWeaverIndex) {
+  const existingInputLineIndices = {};
+  for (let i = 0; i < newLines.length; i++) {
+    const cleanLine = newLines[i].replace(/^\s*\*\s*/, "").trim();
+    const parsed = parsePortLine(cleanLine, []);
+    if (parsed && parsed.type === "input") {
+      existingInputLineIndices[parsed.name] = i;
+    }
+  }
+  const sortedInputsToAdd = inputsToAdd.map(([name, port]) => ({ name, port, sigIndex: signatureInputOrder2.indexOf(name) })).filter((item) => item.sigIndex !== -1).sort((a, b) => b.sigIndex - a.sigIndex);
+  for (const { name, port, sigIndex } of sortedInputsToAdd) {
+    const newTag = tagLine(name, port, "input");
+    let insertIndex = -1;
+    for (let i = sigIndex + 1; i < signatureInputOrder2.length; i++) {
+      const nextName = signatureInputOrder2[i];
+      if (existingInputLineIndices[nextName] !== void 0) {
+        insertIndex = existingInputLineIndices[nextName];
+        break;
+      }
+    }
+    if (insertIndex === -1) {
+      for (let i = sigIndex - 1; i >= 0; i--) {
+        const prevName = signatureInputOrder2[i];
+        if (existingInputLineIndices[prevName] !== void 0) {
+          insertIndex = existingInputLineIndices[prevName] + 1;
+          break;
+        }
+      }
+      if (insertIndex === -1) {
+        insertIndex = flowWeaverIndex >= 0 ? flowWeaverIndex + 1 : 1;
+      }
+    }
+    newLines.splice(insertIndex, 0, newTag);
+    for (const [portName, idx] of Object.entries(existingInputLineIndices)) {
+      if (idx >= insertIndex) {
+        existingInputLineIndices[portName] = idx + 1;
+      }
+    }
+    existingInputLineIndices[name] = insertIndex;
+  }
+}
+function insertInputTags(newLines, inputsToAdd, scan, signatureInputOrder2) {
+  const flowWeaverIndex = newLines.findIndex((l) => l.includes("@flowWeaver"));
+  const scopedInputsToAdd = inputsToAdd.filter(([_, port]) => port.scope);
+  const nonScopedInputsToAdd = inputsToAdd.filter(([_, port]) => !port.scope);
+  if (signatureInputOrder2 && signatureInputOrder2.length > 0 && nonScopedInputsToAdd.length > 0) {
+    insertInputsInSignatureOrder(newLines, nonScopedInputsToAdd, signatureInputOrder2, flowWeaverIndex);
+  } else if (nonScopedInputsToAdd.length > 0) {
+    const nonScopedInputTags = nonScopedInputsToAdd.map(([name, port]) => tagLine(name, port, "input"));
+    const inputInsertIndex = scan.lastInputLineIndex >= 0 ? scan.lastInputLineIndex + 1 : flowWeaverIndex >= 0 ? flowWeaverIndex + 1 : 1;
+    newLines.splice(inputInsertIndex, 0, ...nonScopedInputTags);
+  }
+  if (scopedInputsToAdd.length > 0) {
+    const scopedInputTags = scopedInputsToAdd.map(([name, port]) => tagLine(name, port, "input"));
+    const closingIdx = newLines.findIndex((l) => l.trim() === "*/");
+    const insertIdx = scan.lastOutputLineIndex >= 0 ? scan.lastOutputLineIndex + 1 : closingIdx >= 0 ? closingIdx : newLines.length - 1;
+    newLines.splice(insertIdx, 0, ...scopedInputTags);
+  }
+}
+
+// src/jsdoc-port-sync/port-parser.ts
+var SCOPE_TAG_REGEX2 = /\*\s*@scope\s+(\w+)/g;
+function hasScopes(functionText) {
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (!jsdocMatch) return false;
+  SCOPE_TAG_REGEX2.lastIndex = 0;
+  return SCOPE_TAG_REGEX2.test(jsdocMatch[0]);
+}
+function getScopeNames(functionText) {
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (!jsdocMatch) return [];
+  const scopes = [];
+  SCOPE_TAG_REGEX2.lastIndex = 0;
+  let match;
+  while ((match = SCOPE_TAG_REGEX2.exec(jsdocMatch[0])) != null) {
+    scopes.push(match[1]);
+  }
+  return scopes;
+}
+function readSignatureLookup(functionText) {
+  const { params } = parseFunctionSignature(functionText);
+  const returnFields = parseReturnTypeFieldsWithTypes(functionText);
+  const paramTypeMap = /* @__PURE__ */ new Map();
+  const paramOptionalMap = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    if (param.tsType) {
+      paramTypeMap.set(param.name, param.tsType);
+    }
+    if (param.optional) {
+      paramOptionalMap.set(param.name, true);
+    }
+  }
+  const returnTypeMap = /* @__PURE__ */ new Map();
+  for (const field of returnFields) {
+    returnTypeMap.set(field.name, field.tsType);
+  }
+  const callbackParamNames = new Set(params.filter((p) => p.tsType?.includes("=>")).map((p) => p.name));
+  return { paramTypeMap, paramOptionalMap, returnTypeMap, callbackParamNames };
+}
+function portMetadata(port) {
+  const metadata = {};
+  if (port.order !== void 0) metadata.order = port.order;
+  if (port.placement) metadata.placement = port.placement;
+  return Object.keys(metadata).length > 0 ? { metadata } : void 0;
+}
+function portType(isStepPort, tsTypeOf) {
+  if (isStepPort) return { dataType: "STEP" };
+  const tsType = tsTypeOf();
+  return { dataType: tsType ? inferDataTypeFromTS(tsType) : "ANY", tsType };
+}
+function inputPortDefinition(port, lookup, validatedScope) {
+  const { name, description, defaultValue, isOptional } = port;
+  const isStepPort = isExecutePort(name) || !!(validatedScope && isScopedMandatoryPort(name));
+  const { dataType, tsType } = portType(isStepPort, () => lookup.paramTypeMap.get(name));
+  const signatureOptional = lookup.paramOptionalMap.get(name) || false;
+  const portOptional = isOptional || signatureOptional;
+  return {
+    dataType,
+    ...tsType && { tsType },
+    ...portOptional && { optional: true },
+    ...defaultValue === void 0 ? {} : { default: parseDefaultValue(defaultValue) },
+    ...validatedScope && { scope: validatedScope },
+    ...description && { label: description },
+    ...portMetadata(port)
+  };
+}
+function outputPortDefinition(port, lookup, validatedScope) {
+  const { name, description } = port;
+  const isStepPort = isSuccessPort(name) || isFailurePort(name) || !!(validatedScope && isScopedMandatoryPort(name));
+  const { dataType, tsType } = portType(isStepPort, () => lookup.returnTypeMap.get(name));
+  return {
+    dataType,
+    ...tsType && { tsType },
+    ...validatedScope && { scope: validatedScope },
+    ...description && { label: description },
+    ...portMetadata(port)
+  };
+}
+function parsePortsFromFunctionText(functionText) {
+  const inputs = {};
+  const outputs = {};
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (!jsdocMatch) {
+    return { inputs, outputs };
+  }
+  const lookup = readSignatureLookup(functionText);
+  const hasAnyScope = getScopeNames(functionText).length > 0 || lookup.callbackParamNames.size > 0;
+  const validateScope = (scope) => scope && hasAnyScope ? scope : void 0;
+  for (const port of parsePortsFromJSDoc(jsdocMatch[0])) {
+    const { type, name, description } = port;
+    if (type === "step") {
+      const portDef = {
+        dataType: "STEP",
+        ...description && { label: description }
+      };
+      if (lookup.paramTypeMap.has(name)) {
+        inputs[name] = portDef;
+      } else {
+        outputs[name] = portDef;
+      }
+      continue;
+    }
+    if (type === "input" && !inputs[name]) {
+      inputs[name] = inputPortDefinition(port, lookup, validateScope(port.scope));
+    }
+    if (type === "output" && !outputs[name]) {
+      outputs[name] = outputPortDefinition(port, lookup, validateScope(port.scope));
+    }
+  }
+  return { inputs, outputs };
+}
+function updatePortsInFunctionText(functionText, inputs, outputs, signatureInputOrder2) {
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  const incompletePortNames = getIncompletePortNames(functionText);
+  const inputTags = Object.entries(inputs).filter(([name]) => !incompletePortNames.inputs.has(name)).map(([name, port]) => ` * ${generateJSDocPortTag(name, port, "input")}`);
+  const outputTags = Object.entries(outputs).filter(([name]) => !incompletePortNames.outputs.has(name)).map(([name, port]) => ` * ${generateJSDocPortTag(name, port, "output")}`);
+  if (!jsdocMatch) {
+    const newJsDoc2 = ["/**", " * @flowWeaver nodeType", ...inputTags, ...outputTags, " */"].join(
+      "\n"
+    );
+    return newJsDoc2 + "\n" + functionText;
+  }
+  const scan = scanPortLines(jsdocMatch[0].split("\n"), inputs, outputs);
+  const newLines = [...scan.preservedLines];
+  if (!scan.hasFlowWeaverTag) {
+    newLines.splice(1, 0, " * @flowWeaver nodeType");
+  }
+  const inputsToAdd = Object.entries(inputs).filter(
+    ([name]) => !scan.seenInputs.has(name) && !incompletePortNames.inputs.has(name)
+  );
+  const outputsToAdd = Object.entries(outputs).filter(
+    ([name]) => !scan.seenOutputs.has(name) && !incompletePortNames.outputs.has(name)
+  );
+  const remainingInputsToAdd = fillOrphanLines(newLines, inputsToAdd, scan.orphanInputLines, "input");
+  const remainingOutputsToAdd = fillOrphanLines(newLines, outputsToAdd, scan.orphanOutputLines, "output");
+  insertOutputTags(newLines, remainingOutputsToAdd, scan);
+  if (remainingInputsToAdd.length > 0) {
+    insertInputTags(newLines, remainingInputsToAdd, scan, signatureInputOrder2);
+  }
+  const newJsDoc = newLines.join("\n");
+  return functionText.replace(JSDOC_BLOCK_REGEX, newJsDoc);
+}
+function parseDefaultValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/jsdoc-port-sync/callback-signature.ts
+function syncScopeCallbacks(functionText, scopedInputs, scopedOutputs, functionType) {
+  const scopeNames = /* @__PURE__ */ new Set([
+    ...scopedInputs.map(([_, port]) => port.scope),
+    ...scopedOutputs.map(([_, port]) => port.scope)
+  ]);
+  let result = functionText;
+  for (const scopeName of scopeNames) {
+    const callbackParams = scopedOutputs.filter(
+      ([name, port]) => port.scope === scopeName && port.dataType !== "FUNCTION" && name !== scopeName
+    );
+    const callbackReturns = scopedInputs.filter(([_, port]) => port.scope === scopeName);
+    if (callbackParams.length > 0 || callbackReturns.length > 0) {
+      result = updateCallbackInSignature(result, scopeName, callbackParams, callbackReturns, functionType);
+    }
+  }
+  return result;
+}
+function locateParamListSite(text, functionType) {
+  if (functionType === "declaration") {
+    const funcMatch = text.match(/((?:async\s+)?function\s+)(\w+)\s*\(/);
+    if (!funcMatch || funcMatch.index === void 0) return null;
+    const openParenIndex = funcMatch.index + funcMatch[0].length - 1;
+    const closeParenIndex = findBalancedClose(text, openParenIndex);
+    if (closeParenIndex === -1) return null;
+    return {
+      head: `${text.substring(0, funcMatch.index)}${funcMatch[1]}${funcMatch[2]}`,
+      paramsStr: text.substring(openParenIndex + 1, closeParenIndex),
+      tail: `)${text.substring(closeParenIndex + 1)}`
+    };
+  }
+  if (functionType === "arrow") {
+    const arrowMatch = text.match(/((?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?)\(/);
+    if (!arrowMatch || arrowMatch.index === void 0) return null;
+    const openParenIndex = arrowMatch.index + arrowMatch[0].length - 1;
+    const closeParenIndex = findBalancedClose(text, openParenIndex);
+    if (closeParenIndex === -1) return null;
+    const afterParams = text.substring(closeParenIndex + 1);
+    const arrowIndex = afterParams.indexOf("=>");
+    return {
+      head: `${text.substring(0, arrowMatch.index)}${arrowMatch[1]}`,
+      paramsStr: text.substring(openParenIndex + 1, closeParenIndex),
+      tail: arrowIndex === -1 ? null : `) ${afterParams.substring(arrowIndex)}`
+    };
+  }
+  return null;
+}
+function splitParamToken(token) {
+  const callbackParam = token.trim();
+  const colonIndex = callbackParam.indexOf(":");
+  return {
+    paramName: callbackParam.substring(0, colonIndex).trim(),
+    existingType: callbackParam.substring(colonIndex + 1).trim()
+  };
+}
+function updateCallbackInSignature(functionText, scopeName, callbackParams, callbackReturns, functionType) {
+  const site = locateParamListSite(functionText, functionType);
+  if (!site) return functionText;
+  const { paramsStr } = site;
+  const paramTokens = splitParams(paramsStr);
+  const callbackIndex = paramTokens.findIndex((p) => p.includes("=>"));
+  if (callbackIndex >= 0) {
+    const { existingType } = splitParamToken(paramTokens[callbackIndex]);
+    if (callbackHasAllPorts(existingType, callbackParams, callbackReturns)) {
+      return functionText;
+    }
+  }
+  const { head, tail } = site;
+  if (tail === null) return functionText;
+  if (callbackIndex >= 0) {
+    const { paramName, existingType } = splitParamToken(paramTokens[callbackIndex]);
+    const callbackType = buildCallbackType(callbackParams, callbackReturns, existingType);
+    paramTokens[callbackIndex] = `${paramName}: ${callbackType}`;
+  } else {
+    const callbackType = buildCallbackType(callbackParams, callbackReturns);
+    paramTokens.push(`${scopeName}: ${callbackType}`);
+  }
+  if (paramsStr.includes("\n")) {
+    let result = paramsStr;
+    const callbackToken = paramTokens[callbackIndex];
+    const callbackStartRegex = new RegExp(`(${scopeName}\\s*:\\s*)\\([^)]*\\)\\s*=>\\s*\\{[^}]*\\}`, "s");
+    const match = result.match(callbackStartRegex);
+    if (match) {
+      result = result.replace(callbackStartRegex, callbackToken);
+    }
+    return `${head}(${result}${tail}`;
+  }
+  const trimmedTokens = paramTokens.map((p) => p.trim());
+  return `${head}(${trimmedTokens.join(", ")}${tail}`;
+}
+
+// src/jsdoc-port-sync/jsdoc-to-signature.ts
+function resolveSyncPorts(functionText, authoritativePorts) {
+  const { inputs: parsedInputs, outputs: parsedOutputs } = parsePortsFromFunctionText(functionText);
+  const returnBodyFieldTypes = parseReturnBodyFieldsWithTypes(functionText);
+  const inputs = {};
+  for (const [name, port] of Object.entries(parsedInputs)) {
+    inputs[name] = authoritativePorts?.inputs?.[name] ?? port;
+  }
+  const outputs = {};
+  for (const [name, port] of Object.entries(parsedOutputs)) {
+    const authoritative = authoritativePorts?.outputs?.[name];
+    if (authoritative) {
+      outputs[name] = authoritative;
+    } else {
+      const inferredTsType = returnBodyFieldTypes.get(name);
+      if (inferredTsType && !port.tsType) {
+        outputs[name] = { ...port, tsType: inferredTsType };
+      } else {
+        outputs[name] = port;
+      }
+    }
+  }
+  return { inputs, outputs };
+}
+var MANDATORY_RETURN_FIELDS = /* @__PURE__ */ new Set(["onSuccess", "onFailure"]);
+function portOrder(port) {
+  const order = port.metadata?.order;
+  return typeof order === "number" ? order : Infinity;
+}
+function planSignatureSync(functionText, inputs, outputs) {
+  const { params, functionType } = parseFunctionSignature(functionText);
+  const orderedInputs = Object.entries(inputs).filter(([_, port]) => !port.scope).map(([name, port]) => ({ name, port, order: portOrder(port) })).sort((a, b) => a.order - b.order);
+  const existingParamNames = new Set(params.map((p) => p.name));
+  for (const match of rawParamListText(functionText).matchAll(/\b(\w+)\s*[?:]/g)) {
+    existingParamNames.add(match[1]);
+  }
+  const paramsToAdd = orderedInputs.filter(
+    ({ name }) => !existingParamNames.has(name) && !RESERVED_PARAMS.includes(name)
+  );
+  const nonScopedOutputs = Object.fromEntries(
+    Object.entries(outputs).filter(([_, port]) => !port.scope)
+  );
+  const scopedInputs = Object.entries(inputs).filter(([_, port]) => port.scope);
+  const scopedOutputs = Object.entries(outputs).filter(([_, port]) => port.scope);
+  const hasScopedPorts = scopedInputs.length > 0 || scopedOutputs.length > 0;
+  const hasSyncableOutputs = Object.keys(nonScopedOutputs).length > 0;
+  const hasExecuteParam = existingParamNames.has("execute");
+  const jsDocOutputNames = new Set(Object.keys(nonScopedOutputs));
+  const hasOutputsToRemove = parseReturnTypeFields(functionText).some(
+    (field) => !jsDocOutputNames.has(field) && !MANDATORY_RETURN_FIELDS.has(field)
+  );
+  return {
+    functionType,
+    hasExecuteParam,
+    paramsToAdd,
+    nonScopedOutputs,
+    scopedInputs,
+    scopedOutputs,
+    upToDate: paramsToAdd.length === 0 && !hasScopedPorts && !hasSyncableOutputs && !hasOutputsToRemove && hasExecuteParam
+  };
+}
+function locateParamList(text, functionType) {
+  let match = null;
+  if (functionType === "declaration") {
+    match = text.match(/function\s+\w+\s*\(/);
+  } else if (functionType === "arrow") {
+    match = text.match(/(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\(/);
+  }
+  if (!match || match.index === void 0) return null;
+  const open = match.index + match[0].length - 1;
+  const close = findBalancedClose(text, open);
+  return close === -1 ? null : { open, close };
+}
+function ensureExecuteParam(text, functionType) {
+  const list = locateParamList(text, functionType);
+  if (!list) return text;
+  const existingParams = text.substring(list.open + 1, list.close).trim();
+  const sep = existingParams ? ", " : "";
+  return text.substring(0, list.open + 1) + "execute: boolean" + sep + text.substring(list.open + 1);
+}
+function formatParam({ name, port }) {
+  const tsType = portTypeToTsType(port.dataType);
+  if (port.optional && port.default !== void 0) {
+    return `${name}: ${tsType} = ${JSON.stringify(port.default)}`;
+  } else if (port.optional) {
+    return `${name}?: ${tsType}`;
+  }
+  return `${name}: ${tsType}`;
+}
+function appendParams(text, functionType, paramsToAdd) {
+  const newParamStrings = paramsToAdd.map(formatParam);
+  const list = locateParamList(text, functionType);
+  if (!list) return text;
+  let existingParams = text.substring(list.open + 1, list.close);
+  const endsWithComma = /,\s*$/.test(existingParams);
+  const isMultiline = existingParams.includes("\n");
+  let sep;
+  if (!existingParams.trim()) {
+    sep = "";
+  } else if (endsWithComma) {
+    existingParams = existingParams.replace(/,\s*$/, ",");
+    sep = "\n  ";
+  } else if (isMultiline) {
+    existingParams = existingParams.trimEnd();
+    sep = ",\n  ";
+  } else {
+    sep = ", ";
+  }
+  return text.substring(0, list.open + 1) + existingParams + sep + newParamStrings.join(", ") + "\n" + text.substring(list.close);
+}
+function returnTypeFieldList(text, nonScopedOutputs) {
+  const existingFields = /* @__PURE__ */ new Map();
+  const existingReturnTypeMatch = text.match(/\)\s*:\s*\{([^}]*)\}/);
+  if (existingReturnTypeMatch) {
+    for (const match of existingReturnTypeMatch[1].matchAll(/(\w+)\s*:\s*([^;}\s][^;}]*)?/g)) {
+      existingFields.set(match[1], match[2]?.trim() || "");
+    }
+  }
+  if (!existingFields.has("onSuccess")) {
+    existingFields.set("onSuccess", "boolean");
+  }
+  if (!existingFields.has("onFailure")) {
+    existingFields.set("onFailure", "boolean");
+  }
+  for (const [name, port] of Object.entries(nonScopedOutputs)) {
+    if (name === "onSuccess" || name === "onFailure") continue;
+    if (!existingFields.get(name)) {
+      existingFields.set(name, port.tsType || portTypeToTsType(port.dataType));
+    }
+  }
+  const allFields = [];
+  allFields.push(`onSuccess: ${existingFields.get("onSuccess")}`);
+  allFields.push(`onFailure: ${existingFields.get("onFailure")}`);
+  for (const [name, type] of existingFields) {
+    if (name === "onSuccess" || name === "onFailure") continue;
+    allFields.push(type ? `${name}: ${type}` : `${name}:`);
+  }
+  return allFields;
+}
+function syncReturnType(text, functionType, nonScopedOutputs) {
+  const returnType = `{ ${returnTypeFieldList(text, nonScopedOutputs).join("; ")} }`;
+  const list = locateParamList(text, functionType);
+  if (!list) return text;
+  const afterParen = text.substring(list.close + 1);
+  const existingReturnMatch = afterParen.match(/^\s*:\s*\{[^}]*\}/);
+  if (existingReturnMatch) {
+    return text.substring(0, list.close + 1) + ": " + returnType + afterParen.substring(existingReturnMatch[0].length);
+  }
+  const leading = afterParen.match(/^\s*/);
+  const whitespace = leading ? leading[0] : " ";
+  return text.substring(0, list.close + 1) + ": " + returnType + whitespace + afterParen.substring(whitespace.length);
+}
+
+// src/jsdoc-port-sync/scoped-ports.ts
+function collectDeclaredScopes(functionText, inputs, outputs, callbackNames) {
+  const declaredScopes = /* @__PURE__ */ new Set();
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  if (jsdocMatch) {
+    const jsdoc = jsdocMatch[0];
+    SCOPE_TAG_REGEX.lastIndex = 0;
+    let scopeMatch;
+    while ((scopeMatch = SCOPE_TAG_REGEX.exec(jsdoc)) != null) {
+      declaredScopes.add(scopeMatch[1]);
+    }
+  }
+  for (const port of Object.values(inputs)) {
+    if (port.scope && callbackNames.has(port.scope)) declaredScopes.add(port.scope);
+  }
+  for (const port of Object.values(outputs)) {
+    if (port.scope && callbackNames.has(port.scope)) declaredScopes.add(port.scope);
+  }
+  return declaredScopes;
+}
+function hasPortForScope(ports, portName, scope) {
+  return Object.entries(ports).some(
+    ([name, port]) => (name === portName || port._realName === portName) && port.scope === scope
+  );
+}
+function addMandatoryPort(ports, portName, scope, extra) {
+  if (hasPortForScope(ports, portName, scope)) return;
+  const key = !ports[portName] || ports[portName].scope === scope ? portName : `${portName}\0${scope}`;
+  ports[key] = {
+    dataType: "STEP",
+    scope,
+    ...key !== portName && { _realName: portName },
+    ...extra
+  };
+}
+function addMandatoryScopedPorts(inputs, outputs, scopes) {
+  for (const scopeName of scopes) {
+    addMandatoryPort(outputs, SCOPED_PORT_NAMES.START, scopeName);
+    addMandatoryPort(inputs, SCOPED_PORT_NAMES.SUCCESS, scopeName);
+    addMandatoryPort(inputs, SCOPED_PORT_NAMES.FAILURE, scopeName, { failure: true });
+  }
+}
+
+// src/jsdoc-port-sync/signature-to-jsdoc.ts
+var isCallbackParam = (param) => param.tsType?.includes("=>") ?? false;
+function readSignatureShape(functionText) {
+  const { params } = parseFunctionSignature(functionText);
+  const hasReturnTypeAnnotation = /\)\s*:\s*\{[^}]+\}\s*(?:\{|=>)/.test(functionText);
+  const returnFields = hasReturnTypeAnnotation ? parseReturnTypeFields(functionText) : parseReturnFields(functionText);
+  const signatureParamNames = new Set(
+    params.filter((p) => !RESERVED_PARAMS.includes(p.name) && !isCallbackParam(p)).map((p) => p.name)
+  );
+  const inputTypeFields = parseInputTypeFields(functionText);
+  for (const field of inputTypeFields) {
+    signatureParamNames.add(field.name);
+  }
+  const callbacks = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    if (param.tsType?.includes("=>")) {
+      const parsed = parseCallbackType(param.tsType);
+      const fieldNames = new Set(parsed.returnFields.map((f) => f.name));
+      callbacks.set(param.name, { hasReturnFields: fieldNames.size > 0, returnFieldNames: fieldNames });
+    }
+  }
+  return {
+    params,
+    returnFields,
+    returnBodyFieldTypes: parseReturnBodyFieldsWithTypes(functionText),
+    inputTypeFields,
+    incompletePortNames: getIncompletePortNames(functionText),
+    signatureParamNames,
+    rawSigText: rawParamListText(functionText),
+    callbacks
+  };
+}
+function mergeSignatureInputs(existingInputs, shape) {
+  const { params, inputTypeFields, incompletePortNames } = shape;
+  const mergedInputs = { ...existingInputs };
+  for (const param of params) {
+    if (RESERVED_PARAMS.includes(param.name)) continue;
+    if (incompletePortNames.inputs.has(param.name)) continue;
+    const signatureType = tsTypeToPortType(param.tsType);
+    if (!mergedInputs[param.name]) {
+      mergedInputs[param.name] = {
+        dataType: signatureType,
+        ...param.optional && { optional: true },
+        ...param.defaultValue === void 0 ? {} : { default: parseDefaultValue(param.defaultValue) }
+      };
+    } else if (signatureType !== "ANY" && mergedInputs[param.name].dataType !== signatureType) {
+      const existingType = mergedInputs[param.name].dataType;
+      if (!(existingType === "STEP" && signatureType === "BOOLEAN")) {
+        mergedInputs[param.name] = {
+          ...mergedInputs[param.name],
+          dataType: signatureType
+        };
+      }
+    }
+  }
+  for (const field of inputTypeFields) {
+    if (!mergedInputs[field.name] && !incompletePortNames.inputs.has(field.name)) {
+      mergedInputs[field.name] = { dataType: tsTypeToPortType(field.tsType) };
+    }
+  }
+  return mergedInputs;
+}
+function mergeSignatureOutputs(existingOutputs, shape) {
+  const { returnFields, returnBodyFieldTypes, incompletePortNames } = shape;
+  const mergedOutputs = { ...existingOutputs };
+  for (const field of returnFields) {
+    if (!mergedOutputs[field] && !incompletePortNames.outputs.has(field)) {
+      const inferredType = returnBodyFieldTypes.get(field);
+      const dataType = inferredType ? tsTypeToPortType(inferredType) : "ANY";
+      mergedOutputs[field] = { dataType, ...inferredType && { tsType: inferredType } };
+    }
+  }
+  return mergedOutputs;
+}
+function scopedInputIsLive(name, port, callbacks) {
+  if (!port.scope) return false;
+  const scopeCallback = callbacks.get(port.scope);
+  if (!scopeCallback) return false;
+  return scopeCallback.hasReturnFields ? scopeCallback.returnFieldNames.has(name) : true;
+}
+function keepLiveInputs(mergedInputs, shape) {
+  const { signatureParamNames, incompletePortNames, rawSigText, callbacks } = shape;
+  const finalInputs = {};
+  for (const [name, port] of Object.entries(mergedInputs)) {
+    const hasUserMetadata = port.metadata?.order !== void 0 || port.label !== void 0;
+    const existsInRawSig = new RegExp(`\\b${name}\\b`).test(rawSigText);
+    if (signatureParamNames.has(name) || scopedInputIsLive(name, port, callbacks) || incompletePortNames.inputs.has(name) || hasUserMetadata && existsInRawSig) {
+      finalInputs[name] = port;
+    }
+  }
+  return finalInputs;
+}
+function keepLiveOutputs(mergedOutputs, shape) {
+  const { incompletePortNames } = shape;
+  const returnFieldNames = new Set(shape.returnFields);
+  const finalOutputs = {};
+  for (const [name, port] of Object.entries(mergedOutputs)) {
+    if (returnFieldNames.has(name) || port.scope || isReservedPortName(name) || incompletePortNames.outputs.has(name)) {
+      finalOutputs[name] = port;
+    }
+  }
+  return finalOutputs;
+}
+function signatureInputOrder(shape) {
+  const { params, rawSigText } = shape;
+  const rawParamMatches = rawSigText.matchAll(/^\s*(\w+)\s*[?:]|,\s*(\w+)\s*[?:]/gm);
+  const rawParamOrder = [];
+  for (const match of rawParamMatches) {
+    const name = match[1] || match[2];
+    if (name && !RESERVED_PARAMS.includes(name) && !rawParamOrder.includes(name)) {
+      const afterName = rawSigText.substring(rawSigText.indexOf(name + ":") + name.length + 1);
+      if (!afterName.trim().startsWith("(")) {
+        rawParamOrder.push(name);
+      }
+    }
+  }
+  const parsedOrder = params.filter((p) => !RESERVED_PARAMS.includes(p.name) && !isCallbackParam(p)).map((p) => p.name);
+  return rawParamOrder.length >= parsedOrder.length ? rawParamOrder : parsedOrder;
+}
+
+// src/jsdoc-port-sync/sync.ts
+function syncSignatureToJSDoc(functionText) {
+  const orphanLines = hasOrphanPortLines(functionText);
+  if (orphanLines.inputs || orphanLines.outputs) {
+    return functionText;
+  }
+  const { inputs: existingInputs, outputs: existingOutputs } = parsePortsFromFunctionText(functionText);
+  const shape = readSignatureShape(functionText);
+  const inputs = keepLiveInputs(mergeSignatureInputs(existingInputs, shape), shape);
+  const outputs = keepLiveOutputs(mergeSignatureOutputs(existingOutputs, shape), shape);
+  const inputOrder = signatureInputOrder(shape);
+  const scopes = collectDeclaredScopes(functionText, inputs, outputs, shape.callbacks);
+  addMandatoryScopedPorts(inputs, outputs, scopes);
+  return updatePortsInFunctionText(functionText, inputs, outputs, inputOrder);
+}
+function syncJSDocToSignature(functionText, authoritativePorts) {
+  const { inputs, outputs } = resolveSyncPorts(functionText, authoritativePorts);
+  const plan = planSignatureSync(functionText, inputs, outputs);
+  if (plan.upToDate) {
+    return functionText;
+  }
+  let result = functionText;
+  if (!plan.hasExecuteParam) {
+    result = ensureExecuteParam(result, plan.functionType);
+  }
+  if (plan.paramsToAdd.length > 0) {
+    result = appendParams(result, plan.functionType, plan.paramsToAdd);
+  }
+  if (plan.scopedInputs.length > 0 || plan.scopedOutputs.length > 0) {
+    result = syncScopeCallbacks(result, plan.scopedInputs, plan.scopedOutputs, plan.functionType);
+  }
+  return syncReturnType(result, plan.functionType, plan.nonScopedOutputs);
+}
+
+// src/jsdoc-port-sync/rename.ts
+function renamePortInCode(code, oldPortName, newPortName, portType2) {
+  const reservedNames = ["execute", "onSuccess", "onFailure"];
+  if (reservedNames.includes(oldPortName) || reservedNames.includes(newPortName)) {
+    return code;
+  }
+  const { inputs, outputs } = parsePortsFromFunctionText(code);
+  const allPorts = { ...inputs, ...outputs };
+  const ports = portType2 === "input" ? inputs : outputs;
+  if (!ports[oldPortName]) {
+    return code;
+  }
+  if (allPorts[newPortName]) {
+    return code;
+  }
+  let result = code;
+  const portDef = ports[oldPortName];
+  const isScoped = !!portDef.scope;
+  const tagType = portType2 === "input" ? "@input" : "@output";
+  const jsDocPattern = new RegExp(
+    `(${tagType}\\s+)(\\[?)${oldPortName}(\\]?)`,
+    "g"
+  );
+  result = result.replace(jsDocPattern, `$1$2${newPortName}$3`);
+  if (portType2 === "input") {
+    if (isScoped) {
+      result = renameFieldInReturnType(result, oldPortName, newPortName, true);
+    } else {
+      result = renameParameterInSignature(result, oldPortName, newPortName);
+    }
+  } else {
+    if (isScoped) {
+      result = renameCallbackParameter(result, oldPortName, newPortName);
+    } else {
+      result = renameFieldInReturnType(result, oldPortName, newPortName, false);
+    }
+  }
+  return result;
+}
+function renameParameterInSignature(code, oldName, newName) {
+  const paramPattern = new RegExp(
+    `([(,]\\s*)${oldName}(\\s*[?:]|\\s*=)`,
+    "g"
+  );
+  return code.replace(paramPattern, `$1${newName}$2`);
+}
+function removeParameterFromSignature(code, paramName) {
+  const middleOrLastPattern = new RegExp(
+    `,\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+`,
+    "g"
+  );
+  let result = code.replace(middleOrLastPattern, "");
+  const firstWithCommaPattern = new RegExp(
+    `([(])\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+,\\s*`,
+    "g"
+  );
+  result = result.replace(firstWithCommaPattern, "$1");
+  const onlyParamPattern = new RegExp(
+    `([(])\\s*${paramName}\\s*[?]?\\s*:\\s*[^,)]+\\s*([)])`,
+    "g"
+  );
+  result = result.replace(onlyParamPattern, "$1$2");
+  return result;
+}
+function removeFieldFromReturnType(code, fieldName) {
+  const middleOrLastPattern = new RegExp(
+    `[;,]\\s*${fieldName}\\s*:\\s*[^;,}]+`,
+    "g"
+  );
+  let result = code.replace(middleOrLastPattern, "");
+  const firstWithSemiPattern = new RegExp(
+    `(\\{\\s*)${fieldName}\\s*:\\s*[^;,}]+[;,]\\s*`,
+    "g"
+  );
+  result = result.replace(firstWithSemiPattern, "$1");
+  const onlyFieldPattern = new RegExp(
+    `(\\{\\s*)${fieldName}\\s*:\\s*[^;,}]+\\s*(\\})`,
+    "g"
+  );
+  result = result.replace(onlyFieldPattern, "$1$2");
+  return result;
+}
+function renameFieldInReturnType(code, oldName, newName, isCallback) {
+  if (isCallback) {
+    const callbackPattern = new RegExp(
+      `(=>\\s*\\{[^}]*?)\\b${oldName}(\\s*:)`,
+      "g"
+    );
+    return code.replace(callbackPattern, `$1${newName}$2`);
+  } else {
+    const returnPattern = new RegExp(
+      `(\\)\\s*:\\s*\\{[^}]*?)\\b${oldName}(\\s*:)`,
+      "g"
+    );
+    return code.replace(returnPattern, `$1${newName}$2`);
+  }
+}
+function renameCallbackParameter(code, oldName, newName) {
+  const callbackParamPattern = new RegExp(
+    `(:\\s*\\([^)]*?)\\b${oldName}(\\s*:)`,
+    "g"
+  );
+  return code.replace(callbackParamPattern, `$1${newName}$2`);
+}
+function getSyncableInputNames(code) {
+  const { inputs } = parsePortsFromFunctionText(code);
+  return Object.entries(inputs).filter(([name, port]) => !port.scope && !isReservedPortName(name)).map(([name]) => name);
+}
+function getSyncableOutputNames(code) {
+  const { outputs } = parsePortsFromFunctionText(code);
+  return Object.entries(outputs).filter(([name, port]) => !port.scope && !isReservedPortName(name)).map(([name]) => name);
+}
+function getSyncableParamNames(code) {
+  const { params } = parseFunctionSignature(code);
+  return params.filter((p) => !isReservedPortName(p.name) && !p.tsType?.includes("=>")).map((p) => p.name);
+}
+function getSyncableReturnFieldNames(code) {
+  const returnTypeFields = parseReturnTypeFields(code);
+  return returnTypeFields.filter((f) => !isReservedPortName(f));
+}
+function renamePortInJSDoc(code, oldName, newName, type) {
+  const tag = type === "input" ? "@input" : "@output";
+  const pattern = new RegExp(
+    `(${tag}\\s+)${oldName}(\\b)`,
+    "g"
+  );
+  return code.replace(pattern, `$1${newName}$2`);
+}
+function syncCodeRenames(previousCode, currentCode) {
+  if (!previousCode.trim()) {
+    return currentCode;
+  }
+  const prevOrphanLines = hasOrphanPortLines(previousCode);
+  const currOrphanLines = hasOrphanPortLines(currentCode);
+  let result = currentCode;
+  if (currOrphanLines.inputs) {
+    result = removeParamsOfClearedInputs(previousCode, currentCode, result);
+  } else if (!prevOrphanLines.inputs) {
+    result = syncInputRenames(previousCode, currentCode, result);
+  }
+  if (currOrphanLines.outputs) {
+    result = removeFieldsOfClearedOutputs(previousCode, currentCode, result);
+  } else if (!prevOrphanLines.outputs) {
+    result = syncOutputRenames(previousCode, currentCode, result);
+  }
+  return result;
+}
+function removeParamsOfClearedInputs(previousCode, currentCode, result) {
+  const prevJSDocInputs = getSyncableInputNames(previousCode);
+  const currJSDocInputs = getSyncableInputNames(currentCode);
+  const currSigParams = getSyncableParamNames(currentCode);
+  for (const prevName of prevJSDocInputs) {
+    if (!currJSDocInputs.includes(prevName) && currSigParams.includes(prevName)) {
+      result = removeParameterFromSignature(result, prevName);
+    }
+  }
+  return result;
+}
+function syncInputRenames(previousCode, currentCode, result) {
+  const prevJSDocInputs = getSyncableInputNames(previousCode);
+  const currJSDocInputs = getSyncableInputNames(currentCode);
+  const prevSigParams = getSyncableParamNames(previousCode);
+  const currSigParams = getSyncableParamNames(currentCode);
+  const prevJSDocSet = new Set(prevJSDocInputs);
+  const currJSDocSet = new Set(currJSDocInputs);
+  const prevSigSet = new Set(prevSigParams);
+  const currSigSet = new Set(currSigParams);
+  const rawSigText = rawParamListText(currentCode);
+  const jsDocPortsInRawButNotParsed = currJSDocInputs.some(
+    (name) => new RegExp(`\\b${name}\\b`).test(rawSigText) && !currSigSet.has(name)
+  );
+  if (jsDocPortsInRawButNotParsed) return result;
+  for (let i = 0; i < Math.min(currJSDocInputs.length, currSigParams.length); i++) {
+    const currJSDoc = currJSDocInputs[i];
+    const currSig = currSigParams[i];
+    if (currJSDoc === currSig) continue;
+    const jsDocChanged = prevJSDocInputs[i] !== currJSDoc;
+    const sigChanged = prevSigParams[i] !== currSig;
+    if (jsDocChanged && !sigChanged) {
+      const oldJSDoc = prevJSDocInputs[i];
+      if (oldJSDoc && !currJSDocSet.has(oldJSDoc) && !prevJSDocSet.has(currJSDoc)) {
+        result = renameParameterInSignature(result, currSig, currJSDoc);
+      }
+    } else if (sigChanged && !jsDocChanged) {
+      const oldSig = prevSigParams[i];
+      const oldNameInRawSig = new RegExp(`\\b${oldSig}\\b`).test(rawSigText);
+      if (oldSig && !currSigSet.has(oldSig) && !prevSigSet.has(currSig) && !oldNameInRawSig) {
+        result = renamePortInJSDoc(result, currJSDoc, currSig, "input");
+      }
+    }
+  }
+  return result;
+}
+function removeFieldsOfClearedOutputs(previousCode, currentCode, result) {
+  const prevJSDocOutputs = getSyncableOutputNames(previousCode);
+  const currJSDocOutputs = getSyncableOutputNames(currentCode);
+  const currReturnFields = getSyncableReturnFieldNames(currentCode);
+  for (const prevName of prevJSDocOutputs) {
+    if (!currJSDocOutputs.includes(prevName) && currReturnFields.includes(prevName)) {
+      result = removeFieldFromReturnType(result, prevName);
+    }
+  }
+  return result;
+}
+function syncOutputRenames(previousCode, currentCode, result) {
+  const prevJSDocOutputs = getSyncableOutputNames(previousCode);
+  const currJSDocOutputs = getSyncableOutputNames(currentCode);
+  const prevReturnFields = getSyncableReturnFieldNames(previousCode);
+  const currReturnFields = getSyncableReturnFieldNames(currentCode);
+  const prevJSDocSet = new Set(prevJSDocOutputs);
+  const currJSDocSet = new Set(currJSDocOutputs);
+  const prevReturnSet = new Set(prevReturnFields);
+  const currReturnSet = new Set(currReturnFields);
+  for (let i = 0; i < Math.min(currJSDocOutputs.length, currReturnFields.length); i++) {
+    const currJSDoc = currJSDocOutputs[i];
+    const currReturn = currReturnFields[i];
+    if (currJSDoc === currReturn) continue;
+    const jsDocChanged = prevJSDocOutputs[i] !== currJSDoc;
+    const returnChanged = prevReturnFields[i] !== currReturn;
+    if (jsDocChanged && !returnChanged) {
+      const oldJSDoc = prevJSDocOutputs[i];
+      if (oldJSDoc && !currJSDocSet.has(oldJSDoc) && !prevJSDocSet.has(currJSDoc)) {
+        result = renameFieldInReturnType(result, currReturn, currJSDoc, false);
+      }
+    } else if (returnChanged && !jsDocChanged) {
+      const oldReturn = prevReturnFields[i];
+      if (oldReturn && !currReturnSet.has(oldReturn) && !prevReturnSet.has(currReturn)) {
+        result = renamePortInJSDoc(result, currJSDoc, currReturn, "output");
+      }
+    }
+  }
+  return result;
+}
+
+// src/jsdoc-port-sync/apply-diff.ts
+function tagFor(direction) {
+  return direction === "INPUT" ? "@input" : "@output";
+}
+function removePortLines(code, removed) {
+  let result = code;
+  for (const { name, direction } of removed) {
+    const tag = tagFor(direction);
+    const lineRegex = new RegExp(`^\\s*\\*\\s*${tag}\\s+\\[?${name}\\]?(?:[^\\S\\n]+|[^\\S\\n]*-|[^\\S\\n]*\\[order|$).*$\\n?`, "gm");
+    result = result.replace(lineRegex, "");
+  }
+  return result;
+}
+function renamePortTags(code, renamed) {
+  let result = code;
+  for (const { from, to, direction } of renamed) {
+    const tag = tagFor(direction);
+    const renameRegex = new RegExp(`(${tag}\\s+)(\\[?)${from}(\\]?\\b)`, "g");
+    result = result.replace(renameRegex, `$1$2${to}$3`);
+  }
+  return result;
+}
+function updatePortLabels(code, labelChanged) {
+  let result = code;
+  for (const { name, label, direction, scope } of labelChanged) {
+    const tag = tagFor(direction);
+    const labelRegex = new RegExp(
+      `(\\*\\s*${tag}\\s+\\[?${name}\\]?)(?:\\s+scope:\\w+)?(?:\\s+\\[order:\\s*\\d+\\])?(?:\\s+-\\s+[^\\n]*)?`,
+      "g"
+    );
+    const beforeReplace = result;
+    result = result.replace(labelRegex, `$1${scope ? ` scope:${scope}` : ""} - ${label}`);
+    if (result === beforeReplace) {
+      const scopePart = scope ? ` scope:${scope}` : "";
+      const labelPart = ` - ${label}`;
+      const newLine = ` * ${tag} ${name}${scopePart}${labelPart}`;
+      result = insertBeforeClose(result, newLine);
+    }
+  }
+  return result;
+}
+var SIMPLE_TYPE_PATTERN = `[\\w\\[\\]\\?]+`;
+var STANDARD_FUNCTION_PATTERN = `\\(\\.\\.\\.args:\\s*any\\[\\]\\)\\s*=>\\s*any`;
+function updateParamType(code, name, tsType) {
+  const simpleParamRegex = new RegExp(
+    `(\\b${name}\\??\\s*):\\s*(${SIMPLE_TYPE_PATTERN})\\s*([,)])`,
+    "g"
+  );
+  const result = code.replace(simpleParamRegex, `$1: ${tsType}$3`);
+  if (result !== code) return result;
+  const funcParamRegex = new RegExp(
+    `(\\b${name}\\??\\s*):\\s*(${STANDARD_FUNCTION_PATTERN})\\s*([,)])`,
+    "g"
+  );
+  return code.replace(funcParamRegex, `$1: ${tsType}$3`);
+}
+function updateReturnFieldType(code, name, tsType) {
+  const returnTypeMatch = code.match(/(\)\s*:\s*)(\{[^}]+\})(\s*(?:\{|=>))/);
+  if (!returnTypeMatch) return code;
+  const beforeReturnType = code.substring(0, returnTypeMatch.index + returnTypeMatch[1].length);
+  const returnTypeContent = returnTypeMatch[2];
+  const afterReturnType = code.substring(returnTypeMatch.index + returnTypeMatch[1].length + returnTypeContent.length);
+  const simpleReturnRegex = new RegExp(
+    `(\\b${name}\\s*):\\s*(${SIMPLE_TYPE_PATTERN})\\s*([,;}])`,
+    "g"
+  );
+  let newReturnType = returnTypeContent.replace(simpleReturnRegex, `$1: ${tsType}$3`);
+  if (newReturnType === returnTypeContent) {
+    const funcReturnRegex = new RegExp(
+      `(\\b${name}\\s*):\\s*(${STANDARD_FUNCTION_PATTERN})\\s*([,;}])`,
+      "g"
+    );
+    newReturnType = returnTypeContent.replace(funcReturnRegex, `$1: ${tsType}$3`);
+  }
+  return beforeReturnType + newReturnType + afterReturnType;
+}
+function updateSignatureTypes(code, typeChanged) {
+  let result = code;
+  for (const { name, type, direction } of typeChanged) {
+    const tsType = portTypeToTsType(type);
+    result = direction === "INPUT" ? updateParamType(result, name, tsType) : updateReturnFieldType(result, name, tsType);
+  }
+  return result;
+}
+function insertBeforeClose(result, newLine) {
+  return result.replace(/(\n)(\s*\*\/)/, `$1${newLine}
+$2`);
+}
+function insertBeforeFirstLine(result, newLine, predicates) {
+  const lines = result.split("\n");
+  for (const matches of predicates) {
+    const insertIndex = lines.findIndex(matches);
+    if (insertIndex !== -1) {
+      lines.splice(insertIndex, 0, newLine);
+      return lines.join("\n");
+    }
+  }
+  return insertBeforeClose(result, newLine);
+}
+var UNSCOPED_INPUT_ANCHORS = [
+  /(\n)(\s*\*\s*@output\s+\w+\s+scope:)/,
+  /(\n)(\s*\*\s*@input\s+\w+\s+scope:)/,
+  /(\n)(\s*\*\s*@output\s+)/
+];
+var isScopedInputLine = (line) => /@input\s+\w+/.test(line) && line.includes("scope:");
+var isUnscopedOutputLine = (line) => /@output\s+\w+/.test(line) && !line.includes("scope:");
+function insertPortLine(code, newLine, direction, scope) {
+  if (direction === "INPUT" && !scope) {
+    const anchor = UNSCOPED_INPUT_ANCHORS.find((regex) => regex.test(code));
+    return anchor ? code.replace(anchor, `$1${newLine}
+$2`) : insertBeforeClose(code, newLine);
+  }
+  if (direction === "OUTPUT" && scope) {
+    return insertBeforeFirstLine(code, newLine, [isScopedInputLine, isUnscopedOutputLine]);
+  }
+  if (direction === "INPUT" && scope) {
+    return insertBeforeFirstLine(code, newLine, [isUnscopedOutputLine]);
+  }
+  return insertBeforeClose(code, newLine);
+}
+function addPortLines(code, added) {
+  let result = code;
+  for (const { name, direction, label, scope, placement } of added) {
+    const tag = tagFor(direction);
+    const existsRegex = new RegExp(`@${tag === "@input" ? "input" : "output"}\\s+\\[?${name}[\\]\\s\\[\\-]?`, "i");
+    if (existsRegex.test(result)) {
+      continue;
+    }
+    const scopePart = scope ? ` scope:${scope}` : "";
+    const placementPart = placement ? ` [placement:${placement}]` : "";
+    const labelPart = label ? ` - ${label}` : "";
+    const newLine = ` * ${tag} ${name}${scopePart}${placementPart}${labelPart}`;
+    result = insertPortLine(result, newLine, direction, scope);
+  }
+  return result;
+}
+function applyPortsDiffToCode(code, diff) {
+  let result = removePortLines(code, diff.removed);
+  result = renamePortTags(result, diff.renamed);
+  result = updatePortLabels(result, diff.labelChanged);
+  result = updateSignatureTypes(result, diff.typeChanged);
+  return addPortLines(result, diff.added);
+}
+
+// src/jsdoc-port-sync/diff.ts
+function computePortsDiff(before, after) {
+  const diff = { added: [], removed: [], renamed: [], labelChanged: [], typeChanged: [] };
+  const beforeMap = new Map(before.map((p) => [p.name, p]));
+  const afterMap = new Map(after.map((p) => [p.name, p]));
+  for (const [name, port] of beforeMap) {
+    if (!afterMap.has(name)) {
+      diff.removed.push({ name, direction: port.direction });
+    }
+  }
+  for (const [name, port] of afterMap) {
+    if (!beforeMap.has(name)) {
+      diff.added.push({
+        name,
+        type: port.type,
+        direction: port.direction,
+        label: port.label,
+        scope: port.scope,
+        placement: port.placement
+      });
+    } else {
+      const beforePort = beforeMap.get(name);
+      if (beforePort.label !== port.label && port.label) {
+        diff.labelChanged.push({
+          name,
+          label: port.label,
+          direction: port.direction,
+          type: port.type,
+          scope: port.scope
+        });
+      }
+      if (beforePort.type !== port.type) {
+        diff.typeChanged.push({
+          name,
+          type: port.type,
+          direction: port.direction
+        });
+      }
+    }
+  }
+  if (diff.removed.length === 1 && diff.added.length === 1) {
+    const removed = diff.removed[0];
+    const added = diff.added[0];
+    const removedPort = before.find((p) => p.name === removed.name);
+    if (removedPort && removedPort.type === added.type && removedPort.direction === added.direction) {
+      diff.renamed.push({ from: removed.name, to: added.name, direction: added.direction });
+      diff.removed = [];
+      diff.added = [];
+    }
+  }
+  return diff;
+}
+function portOrder2(port) {
+  const order = port.metadata?.order;
+  return typeof order === "number" ? order : Infinity;
+}
+function orderedPortTags(inputs, outputs) {
+  const sortedInputs = Object.entries(inputs).sort((a, b) => portOrder2(a[1]) - portOrder2(b[1]));
+  const sortedOutputs = Object.entries(outputs).sort((a, b) => portOrder2(a[1]) - portOrder2(b[1]));
+  const externalInputs = sortedInputs.filter(([_, p]) => !p.scope);
+  const scopedInputs = sortedInputs.filter(([_, p]) => p.scope);
+  const externalOutputs = sortedOutputs.filter(([_, p]) => !p.scope);
+  const scopedOutputs = sortedOutputs.filter(([_, p]) => p.scope);
+  const externalInputTags = externalInputs.map(
+    ([name, port]) => ` * ${generateJSDocPortTag(name, port, "input")}`
+  );
+  const scopedOutputTags = scopedOutputs.map(
+    ([name, port]) => ` * ${generateJSDocPortTag(name, port, "output")}`
+  );
+  const scopedInputTags = scopedInputs.map(
+    ([name, port]) => ` * ${generateJSDocPortTag(name, port, "input")}`
+  );
+  const externalOutputTags = externalOutputs.map(
+    ([name, port]) => ` * ${generateJSDocPortTag(name, port, "output")}`
+  );
+  return [...externalInputTags, ...scopedOutputTags, ...scopedInputTags, ...externalOutputTags];
+}
+function jsdocLinesWithoutPorts(existingJsDoc) {
+  const preservedLines = [];
+  let hasFlowWeaverTag = false;
+  for (const line of existingJsDoc.split("\n")) {
+    if (line.trim() === "/**" || line.trim() === "*/") {
+      preservedLines.push(line);
+      continue;
+    }
+    if (PORT_TAG_REGEX.test(line)) {
+      continue;
+    }
+    if (line.includes("@flowWeaver")) {
+      hasFlowWeaverTag = true;
+    }
+    preservedLines.push(line);
+  }
+  if (!hasFlowWeaverTag) {
+    preservedLines.splice(1, 0, " * @flowWeaver nodeType");
+  }
+  return preservedLines;
+}
+function dropTrailingEmptyLines(lines) {
+  let closingIdx = lines.findIndex((l) => l.trim() === "*/");
+  while (closingIdx > 1) {
+    const prevLine = lines[closingIdx - 1];
+    const isEmptyJsDocLine = /^\s*\*\s*$/.test(prevLine);
+    const isBlankLine = prevLine.trim() === "";
+    if (isEmptyJsDocLine || isBlankLine) {
+      lines.splice(closingIdx - 1, 1);
+      closingIdx--;
+    } else {
+      break;
+    }
+  }
+}
+function formatPortsInFunctionText(functionText, inputs, outputs) {
+  const jsdocMatch = functionText.match(JSDOC_BLOCK_REGEX);
+  const allPortTags = orderedPortTags(inputs, outputs);
+  if (!jsdocMatch) {
+    const newJsDoc2 = [
+      "/**",
+      " * @flowWeaver nodeType",
+      ...allPortTags,
+      " */"
+    ].join("\n");
+    return newJsDoc2 + "\n" + functionText;
+  }
+  const newLines = jsdocLinesWithoutPorts(jsdocMatch[0]);
+  dropTrailingEmptyLines(newLines);
+  const insertIndex = newLines.findIndex((l) => l.trim() === "*/");
+  newLines.splice(insertIndex, 0, ...allPortTags);
+  const newJsDoc = newLines.join("\n");
+  return functionText.replace(JSDOC_BLOCK_REGEX, newJsDoc);
+}
+
+export {
+  hasOrphanPortLines,
+  getIncompletePortNames,
+  hasScopes,
+  getScopeNames,
+  parsePortsFromFunctionText,
+  updatePortsInFunctionText,
+  syncSignatureToJSDoc,
+  syncJSDocToSignature,
+  renamePortInCode,
+  syncCodeRenames,
+  applyPortsDiffToCode,
+  computePortsDiff,
+  formatPortsInFunctionText
+};