clanka 0.2.28 → 0.2.29

package/src/ScriptPreprocessing.ts

@@ -1,3 +1,10 @@
+const callTemplateTargets = ["applyPatch", "taskComplete"] as const
+
+const objectPropertyTargets = [
+  { functionName: "writeFile", propertyName: "content" },
+  { functionName: "updateTask", propertyName: "description" },
+] as const
+
 const isIdentifierChar = (char: string | undefined): boolean =>
   char !== undefined && /[A-Za-z0-9_$]/.test(char)
 
@@ -27,11 +34,11 @@ const findNextIdentifier = (
 }
 
 const skipWhitespace = (text: string, start: number): number => {
-  let i = start
-  while (i < text.length && /\s/.test(text[i]!)) {
-    i++
+  let index = start
+  while (index < text.length && /\s/.test(text[index]!)) {
+    index++
   }
-  return i
+  return index
 }
 
 const parseIdentifier = (
@@ -41,10 +48,12 @@ const parseIdentifier = (
   if (!isIdentifierStartChar(text[start])) {
     return undefined
   }
+
   let end = start + 1
   while (end < text.length && isIdentifierChar(text[end])) {
     end++
   }
+
   return {
     name: text.slice(start, end),
     end,
@@ -52,19 +61,134 @@ const parseIdentifier = (
 }
 
 const findPreviousNonWhitespace = (text: string, from: number): number => {
-  let i = from
-  while (i >= 0 && /\s/.test(text[i]!)) {
-    i--
+  let index = from
+  while (index >= 0 && /\s/.test(text[index]!)) {
+    index--
   }
-  return i
+  return index
 }
 
 const findNextNonWhitespace = (text: string, from: number): number => {
-  let i = from
-  while (i < text.length && /\s/.test(text[i]!)) {
-    i++
+  let index = from
+  while (index < text.length && /\s/.test(text[index]!)) {
+    index++
+  }
+  return index
+}
+
+const isEscaped = (text: string, index: number): boolean => {
+  let slashCount = 0
+  let cursor = index - 1
+  while (cursor >= 0 && text[cursor] === "\\") {
+    slashCount++
+    cursor--
+  }
+  return slashCount % 2 === 1
+}
+
+const needsTemplateEscaping = (text: string): boolean => {
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index]!
+    if (char === "`" && !isEscaped(text, index)) {
+      return true
+    }
+    if (char === "$" && text[index + 1] === "{" && !isEscaped(text, index)) {
+      return true
+    }
+  }
+  return false
+}
+
+const findTemplateEnd = (
+  text: string,
+  start: number,
+  isTerminator: (char: string | undefined) => boolean,
+): number => {
+  let end = -1
+  for (let index = start + 1; index < text.length; index++) {
+    if (text[index] !== "`" || isEscaped(text, index)) {
+      continue
+    }
+
+    if (isTerminator(text[index + 1])) {
+      end = index
+      continue
+    }
+
+    const next = skipWhitespace(text, index + 1)
+    if (isTerminator(text[next])) {
+      end = index
+    }
+  }
+  return end
+}
+
+const findTypeAnnotationAssignment = (text: string, start: number): number => {
+  let index = start
+  while (index < text.length) {
+    const char = text[index]!
+    if (char === "=") {
+      return index
+    }
+    if (char === "\n" || char === ";") {
+      return -1
+    }
+    index++
+  }
+  return -1
+}
+
+const findClosingParen = (text: string, openParen: number): number => {
+  let depth = 1
+  for (let index = openParen + 1; index < text.length; index++) {
+    const char = text[index]!
+    if (char === "(") {
+      depth++
+      continue
+    }
+    if (char === ")") {
+      depth--
+      if (depth === 0) {
+        return index
+      }
+    }
+  }
+  return -1
+}
+
+const findClosingBrace = (text: string, openBrace: number): number => {
+  let depth = 1
+  let stringDelimiter: '"' | "'" | "`" | undefined
+
+  for (let index = openBrace + 1; index < text.length; index++) {
+    const char = text[index]!
+
+    if (stringDelimiter !== undefined) {
+      if (char === stringDelimiter && !isEscaped(text, index)) {
+        stringDelimiter = undefined
+      }
+      continue
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      stringDelimiter = char
+      continue
+    }
+
+    if (char === "{") {
+      depth++
+      continue
+    }
+
+    if (char === "}") {
+      depth--
+      if (depth === 0) {
+        return index
+      }
+    }
   }
-  return i
+
+  return -1
 }
 
 const findObjectValueTerminator = (text: string, start: number): number => {
@@ -73,11 +197,11 @@ const findObjectValueTerminator = (text: string, start: number): number => {
   let braceDepth = 0
   let stringDelimiter: '"' | "'" | "`" | undefined
 
-  for (let i = start; i < text.length; i++) {
-    const char = text[i]!
+  for (let index = start; index < text.length; index++) {
+    const char = text[index]!
 
     if (stringDelimiter !== undefined) {
-      if (char === stringDelimiter && !isEscaped(text, i)) {
+      if (char === stringDelimiter && !isEscaped(text, index)) {
         stringDelimiter = undefined
       }
       continue
@@ -114,7 +238,7 @@ const findObjectValueTerminator = (text: string, start: number): number => {
     }
     if (char === "}") {
       if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
-        return i
+        return index
       }
       if (braceDepth > 0) {
         braceDepth--
@@ -128,7 +252,7 @@ const findObjectValueTerminator = (text: string, start: number): number => {
       bracketDepth === 0 &&
       braceDepth === 0
     ) {
-      return i
+      return index
     }
   }
 
@@ -140,7 +264,7 @@ const collectExpressionIdentifiers = (
   start: number,
   end: number,
 ): ReadonlySet<string> => {
-  const out = new Set<string>()
+  const identifiers = new Set<string>()
   let cursor = start
 
   while (cursor < end) {
@@ -150,43 +274,16 @@ const collectExpressionIdentifiers = (
       continue
     }
 
-    const previousNonWhitespace = findPreviousNonWhitespace(text, cursor - 1)
-    const nextNonWhitespace = findNextNonWhitespace(text, identifier.end)
-    if (
-      text[previousNonWhitespace] !== "." &&
-      text[nextNonWhitespace] !== "." &&
-      text[nextNonWhitespace] !== "("
-    ) {
-      out.add(identifier.name)
+    const previous = findPreviousNonWhitespace(text, cursor - 1)
+    const next = findNextNonWhitespace(text, identifier.end)
+    if (text[previous] !== "." && text[next] !== "." && text[next] !== "(") {
+      identifiers.add(identifier.name)
     }
 
     cursor = identifier.end
   }
 
-  return out
-}
-
-const isEscaped = (text: string, index: number): boolean => {
-  let slashCount = 0
-  let i = index - 1
-  while (i >= 0 && text[i] === "\\") {
-    slashCount++
-    i--
-  }
-  return slashCount % 2 === 1
-}
-
-const needsTemplateEscaping = (text: string): boolean => {
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i]!
-    if (char === "`" && !isEscaped(text, i)) {
-      return true
-    }
-    if (char === "$" && text[i + 1] === "{" && !isEscaped(text, i)) {
-      return true
-    }
-  }
-  return false
+  return identifiers
 }
 
 const normalizePatchEscapedQuotes = (text: string): string =>
@@ -217,26 +314,29 @@ const normalizeNonPatchEscapedTemplateMarkers = (text: string): string =>
     .replace(/(^|\s)\\+(?=\.[A-Za-z0-9_-]+\/)/g, "$1")
 
 const escapeTemplateLiteralContent = (text: string): string => {
-  const normalizedPatchQuotes = normalizePatchEscapedQuotes(text)
-  const isPatchContent = normalizedPatchQuotes.includes("*** Begin Patch")
+  const patchNormalized = normalizePatchEscapedQuotes(text)
+  const isPatchContent = patchNormalized.includes("*** Begin Patch")
   const normalized = isPatchContent
-    ? normalizedPatchQuotes
-    : normalizeNonPatchEscapedTemplateMarkers(normalizedPatchQuotes)
+    ? patchNormalized
+    : normalizeNonPatchEscapedTemplateMarkers(patchNormalized)
+
   if (
     !needsTemplateEscaping(normalized) &&
-    !(isPatchContent && normalized.includes("\\"))
+    !(isPatchContent && normalized.includes('\\"'))
   ) {
     return normalized
   }
 
   let out = ""
-  for (let i = 0; i < normalized.length; i++) {
-    const char = normalized[i]!
+  for (let index = 0; index < normalized.length; index++) {
+    const char = normalized[index]!
+
     if (char === "\\") {
       if (
-        !isPatchContent &&
-        (normalized[i + 1] === "`" ||
-          (normalized[i + 1] === "$" && normalized[i + 2] === "{"))
+        (normalized[index + 1] === "`" && isEscaped(normalized, index + 1)) ||
+        (normalized[index + 1] === "$" &&
+          normalized[index + 2] === "{" &&
+          isEscaped(normalized, index + 1))
       ) {
         out += "\\"
         continue
@@ -244,303 +344,196 @@ const escapeTemplateLiteralContent = (text: string): string => {
       out += "\\\\"
       continue
     }
-    if (char === "`" && !isEscaped(normalized, i)) {
+
+    if (char === "`" && !isEscaped(normalized, index)) {
       out += "\\`"
       continue
     }
+
     if (
       char === "$" &&
-      normalized[i + 1] === "{" &&
-      !isEscaped(normalized, i)
+      normalized[index + 1] === "{" &&
+      !isEscaped(normalized, index)
     ) {
       out += "\\$"
       continue
     }
+
     out += char
   }
+
   return out
 }
 
-const findTemplateEnd = (
+const normalizeObjectLiteralTemplateMarkers = (text: string): string =>
+  text.replace(/\\{2,}(?=`|\$\{)/g, "\\")
+
+const replaceSlice = (
   text: string,
   start: number,
-  isTerminator: (char: string | undefined) => boolean,
-): number => {
-  let end = -1
-  for (let i = start + 1; i < text.length; i++) {
-    if (text[i] !== "`" || isEscaped(text, i)) {
-      continue
-    }
-    if (isTerminator(text[i + 1])) {
-      end = i
-      continue
-    }
-    const next = skipWhitespace(text, i + 1)
-    if (isTerminator(text[next])) {
-      end = i
-    }
-  }
-  return end
-}
-
-const findTypeAnnotationAssignment = (text: string, start: number): number => {
-  let i = start
-  while (i < text.length) {
-    const char = text[i]!
-    if (char === "=") {
-      return i
-    }
-    if (char === "\n" || char === ";") {
-      return -1
-    }
-    i++
-  }
-  return -1
-}
-
-const findClosingParen = (text: string, openParen: number): number => {
-  let depth = 1
-  for (let i = openParen + 1; i < text.length; i++) {
-    const char = text[i]!
-    if (char === "(") {
-      depth++
-      continue
-    }
-    if (char === ")") {
-      depth--
-      if (depth === 0) {
-        return i
-      }
-    }
-  }
-  return -1
-}
-
-const findClosingBrace = (text: string, openBrace: number): number => {
-  let depth = 1
-  let stringDelimiter: '"' | "'" | "`" | undefined
-
-  for (let i = openBrace + 1; i < text.length; i++) {
-    const char = text[i]!
-
-    if (stringDelimiter !== undefined) {
-      if (char === stringDelimiter && !isEscaped(text, i)) {
-        stringDelimiter = undefined
-      }
-      continue
-    }
-
-    if (char === '"' || char === "'" || char === "`") {
-      stringDelimiter = char
-      continue
-    }
-
-    if (char === "{") {
-      depth++
-      continue
-    }
-
-    if (char === "}") {
-      depth--
-      if (depth === 0) {
-        return i
-      }
-    }
-  }
-
-  return -1
-}
-
-const fixObjectLiteralTemplateValues = (text: string): string =>
-  text.replace(/\\{2,}(?=`|\$\{)/g, "\\")
+  end: number,
+  replacement: string,
+): string => `${text.slice(0, start)}${replacement}${text.slice(end)}`
 
-const fixAssignedObjectTemplateValues = (
+const rewriteTemplateContents = (
   script: string,
-  variableName: string,
+  findNext: (
+    text: string,
+    from: number,
+  ) =>
+    | {
+        readonly contentStart: number
+        readonly contentEnd: number
+        readonly nextCursor: number
+      }
+    | undefined,
+  rewrite: (content: string) => string,
 ): string => {
   let out = script
   let cursor = 0
 
   while (cursor < out.length) {
-    const variableStart = findNextIdentifier(out, variableName, cursor)
-    if (variableStart === -1) {
+    const range = findNext(out, cursor)
+    if (range === undefined) {
       break
     }
 
-    let assignmentStart = skipWhitespace(
-      out,
-      variableStart + variableName.length,
-    )
-    if (out[assignmentStart] === ":") {
-      assignmentStart = findTypeAnnotationAssignment(out, assignmentStart + 1)
-      if (assignmentStart === -1) {
-        cursor = variableStart + variableName.length
-        continue
-      }
-    }
-
-    if (
-      out[assignmentStart] !== "=" ||
-      out[assignmentStart + 1] === "=" ||
-      out[assignmentStart + 1] === ">"
-    ) {
-      cursor = variableStart + variableName.length
-      continue
-    }
-
-    const objectStart = skipWhitespace(out, assignmentStart + 1)
-    if (out[objectStart] !== "{") {
-      cursor = objectStart + 1
-      continue
-    }
-
-    const objectEnd = findClosingBrace(out, objectStart)
-    if (objectEnd === -1) {
-      cursor = objectStart + 1
+    const original = out.slice(range.contentStart, range.contentEnd)
+    const updated = rewrite(original)
+    if (updated !== original) {
+      out = replaceSlice(out, range.contentStart, range.contentEnd, updated)
+      cursor = range.nextCursor + (updated.length - original.length)
       continue
     }
 
-    const original = out.slice(objectStart, objectEnd + 1)
-    const escaped = fixObjectLiteralTemplateValues(original)
-    if (escaped !== original) {
-      out = `${out.slice(0, objectStart)}${escaped}${out.slice(objectEnd + 1)}`
-      cursor = objectEnd + (escaped.length - original.length) + 1
-      continue
-    }
-
-    cursor = objectEnd + 1
+    cursor = range.nextCursor
   }
 
   return out
 }
 
-const escapeRegExp = (text: string): string =>
-  text.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")
-
-const collectObjectEntryMapSources = (
-  script: string,
-  valueIdentifier: string,
-): ReadonlySet<string> => {
-  const out = new Set<string>()
-  const pattern = new RegExp(
-    `Object\\.entries\\(\\s*([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\)\\s*\\.map\\(\\s*(?:async\\s*)?\\(\\s*\\[\\s*[A-Za-z_$][A-Za-z0-9_$]*\\s*,\\s*${escapeRegExp(valueIdentifier)}\\s*\\]\\s*\\)\\s*=>`,
-    "g",
-  )
-
-  for (const match of script.matchAll(pattern)) {
-    const sourceIdentifier = match[1]
-    if (sourceIdentifier !== undefined) {
-      out.add(sourceIdentifier)
-    }
-  }
-
-  return out
-}
-
-const findCallTemplateEnd = (
+const findDirectCallTemplate = (
   text: string,
-  templateStart: number,
-  openParen: number,
-): number => {
-  const closeParen = findClosingParen(text, openParen)
-  if (closeParen === -1) {
-    return -1
-  }
-
-  for (let i = closeParen - 1; i > templateStart; i--) {
-    if (text[i] === "`" && !isEscaped(text, i)) {
-      return i
-    }
-  }
-
-  return -1
-}
-
-const fixCallTemplateArgument = (
-  script: string,
   functionName: string,
-): string => {
-  let out = script
-  let cursor = 0
+  from: number,
+):
+  | {
+      readonly contentStart: number
+      readonly contentEnd: number
+      readonly nextCursor: number
+    }
+  | undefined => {
+  let cursor = from
 
-  while (cursor < out.length) {
-    const callStart = findNextIdentifier(out, functionName, cursor)
+  while (cursor < text.length) {
+    const callStart = findNextIdentifier(text, functionName, cursor)
     if (callStart === -1) {
-      break
+      return undefined
     }
 
-    const openParen = skipWhitespace(out, callStart + functionName.length)
-    if (out[openParen] !== "(") {
+    const openParen = skipWhitespace(text, callStart + functionName.length)
+    if (text[openParen] !== "(") {
       cursor = callStart + functionName.length
       continue
     }
 
-    const templateStart = skipWhitespace(out, openParen + 1)
-    if (out[templateStart] !== "`") {
+    const templateStart = skipWhitespace(text, openParen + 1)
+    if (text[templateStart] !== "`") {
       cursor = openParen + 1
       continue
     }
 
-    const templateEnd = findCallTemplateEnd(out, templateStart, openParen)
+    const closeParen = findClosingParen(text, openParen)
+    let templateEnd = -1
+    if (closeParen !== -1) {
+      for (let index = closeParen - 1; index > templateStart; index--) {
+        if (text[index] === "`" && !isEscaped(text, index)) {
+          templateEnd = index
+          break
+        }
+      }
+    } else {
+      const patchEnd = text.indexOf("*** End Patch", templateStart)
+      const searchStart = patchEnd === -1 ? templateStart + 1 : patchEnd + 1
+      for (let index = searchStart; index < text.length; index++) {
+        if (text[index] !== "`" || isEscaped(text, index)) {
+          continue
+        }
+        const candidate = skipWhitespace(text, index + 1)
+        if (text[candidate] === ")") {
+          templateEnd = index
+          break
+        }
+      }
+    }
+
     if (templateEnd === -1) {
       cursor = templateStart + 1
       continue
     }
 
-    const original = out.slice(templateStart + 1, templateEnd)
-    const escaped = escapeTemplateLiteralContent(original)
-    if (escaped !== original) {
-      out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`
-      cursor = templateEnd + (escaped.length - original.length) + 1
-      continue
+    return {
+      contentStart: templateStart + 1,
+      contentEnd: templateEnd,
+      nextCursor: templateEnd + 1,
     }
-
-    cursor = templateEnd + 1
   }
 
-  return out
+  return undefined
 }
 
-const fixCallObjectPropertyTemplate = (
-  script: string,
-  functionName: string,
-  propertyName: string,
-): string => {
-  let out = script
-  let cursor = 0
+const findObjectPropertyTemplate = (
+  text: string,
+  target: (typeof objectPropertyTargets)[number],
+  from: number,
+):
+  | {
+      readonly contentStart: number
+      readonly contentEnd: number
+      readonly nextCursor: number
+    }
+  | undefined => {
+  let cursor = from
 
-  while (cursor < out.length) {
-    const callStart = findNextIdentifier(out, functionName, cursor)
+  while (cursor < text.length) {
+    const callStart = findNextIdentifier(text, target.functionName, cursor)
     if (callStart === -1) {
-      break
+      return undefined
     }
 
-    const openParen = skipWhitespace(out, callStart + functionName.length)
-    if (out[openParen] !== "(") {
-      cursor = callStart + functionName.length
+    const openParen = skipWhitespace(
+      text,
+      callStart + target.functionName.length,
+    )
+    if (text[openParen] !== "(") {
+      cursor = callStart + target.functionName.length
       continue
     }
 
-    const propertyKey = findNextIdentifier(out, propertyName, openParen + 1)
+    const propertyKey = findNextIdentifier(
+      text,
+      target.propertyName,
+      openParen + 1,
+    )
     if (propertyKey === -1) {
       cursor = openParen + 1
       continue
     }
 
-    const colon = skipWhitespace(out, propertyKey + propertyName.length)
-    if (out[colon] !== ":") {
-      cursor = propertyKey + propertyName.length
+    const colon = skipWhitespace(text, propertyKey + target.propertyName.length)
+    if (text[colon] !== ":") {
+      cursor = propertyKey + target.propertyName.length
       continue
     }
 
-    const templateStart = skipWhitespace(out, colon + 1)
-    if (out[templateStart] !== "`") {
+    const templateStart = skipWhitespace(text, colon + 1)
+    if (text[templateStart] !== "`") {
       cursor = templateStart + 1
       continue
     }
 
     const templateEnd = findTemplateEnd(
-      out,
+      text,
       templateStart,
       (char) => char === "}" || char === ",",
     )
@@ -549,25 +542,21 @@ const fixCallObjectPropertyTemplate = (
       continue
     }
 
-    const original = out.slice(templateStart + 1, templateEnd)
-    const escaped = escapeTemplateLiteralContent(original)
-    if (escaped !== original) {
-      out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`
-      cursor = templateEnd + (escaped.length - original.length) + 1
-      continue
+    return {
+      contentStart: templateStart + 1,
+      contentEnd: templateEnd,
+      nextCursor: templateEnd + 1,
     }
-
-    cursor = templateEnd + 1
   }
 
-  return out
+  return undefined
 }
 
 const collectCallArgumentIdentifiers = (
   script: string,
   functionName: string,
 ): ReadonlySet<string> => {
-  const out = new Set<string>()
+  const identifiers = new Set<string>()
   let cursor = 0
 
   while (cursor < script.length) {
@@ -591,36 +580,42 @@ const collectCallArgumentIdentifiers = (
 
     const argumentEnd = skipWhitespace(script, identifier.end)
     if (script[argumentEnd] === ")" || script[argumentEnd] === ",") {
-      out.add(identifier.name)
+      identifiers.add(identifier.name)
     }
 
     cursor = identifier.end
   }
 
-  return out
+  return identifiers
 }
 
-const collectCallObjectPropertyIdentifiers = (
+const collectObjectPropertyIdentifiers = (
   script: string,
-  functionName: string,
-  propertyName: string,
+  target: (typeof objectPropertyTargets)[number],
 ): ReadonlySet<string> => {
-  const out = new Set<string>()
+  const identifiers = new Set<string>()
   let cursor = 0
 
   while (cursor < script.length) {
-    const callStart = findNextIdentifier(script, functionName, cursor)
+    const callStart = findNextIdentifier(script, target.functionName, cursor)
     if (callStart === -1) {
       break
     }
 
-    const openParen = skipWhitespace(script, callStart + functionName.length)
+    const openParen = skipWhitespace(
+      script,
+      callStart + target.functionName.length,
+    )
     if (script[openParen] !== "(") {
-      cursor = callStart + functionName.length
+      cursor = callStart + target.functionName.length
       continue
     }
 
-    const propertyKey = findNextIdentifier(script, propertyName, openParen + 1)
+    const propertyKey = findNextIdentifier(
+      script,
+      target.propertyName,
+      openParen + 1,
+    )
     if (propertyKey === -1) {
       cursor = openParen + 1
       continue
@@ -628,7 +623,7 @@ const collectCallObjectPropertyIdentifiers = (
 
     const afterProperty = skipWhitespace(
       script,
-      propertyKey + propertyName.length,
+      propertyKey + target.propertyName.length,
     )
     if (script[afterProperty] === ":") {
       const valueStart = skipWhitespace(script, afterProperty + 1)
@@ -639,7 +634,7 @@ const collectCallObjectPropertyIdentifiers = (
           valueStart,
           valueEnd,
         )) {
-          out.add(identifier)
+          identifiers.add(identifier)
         }
       }
       cursor = valueStart + 1
@@ -647,7 +642,7 @@ const collectCallObjectPropertyIdentifiers = (
     }
 
     if (script[afterProperty] === "}" || script[afterProperty] === ",") {
-      out.add(propertyName)
+      identifiers.add(target.propertyName)
       cursor = afterProperty + 1
       continue
     }
@@ -655,22 +650,88 @@ const collectCallObjectPropertyIdentifiers = (
     cursor = afterProperty + 1
   }
 
-  return out
+  return identifiers
 }
 
-const callObjectPropertyTargets = [
-  ["writeFile", "content"],
-  ["updateTask", "description"],
-] as const
-
-const fixTargetCallObjectPropertyTemplates = (script: string): string =>
-  callObjectPropertyTargets.reduce(
-    (current, [functionName, propertyName]) =>
-      fixCallObjectPropertyTemplate(current, functionName, propertyName),
+const rewriteAssignedTemplate = (
+  script: string,
+  variableName: string,
+): string =>
+  rewriteTemplateContents(
     script,
+    (text, from) => {
+      let cursor = from
+
+      while (cursor < text.length) {
+        const variableStart = findNextIdentifier(text, variableName, cursor)
+        if (variableStart === -1) {
+          return undefined
+        }
+
+        let assignmentStart = skipWhitespace(
+          text,
+          variableStart + variableName.length,
+        )
+        if (text[assignmentStart] === ":") {
+          assignmentStart = findTypeAnnotationAssignment(
+            text,
+            assignmentStart + 1,
+          )
+          if (assignmentStart === -1) {
+            cursor = variableStart + variableName.length
+            continue
+          }
+        }
+
+        if (
+          text[assignmentStart] !== "=" ||
+          text[assignmentStart + 1] === "=" ||
+          text[assignmentStart + 1] === ">"
+        ) {
+          cursor = variableStart + variableName.length
+          continue
+        }
+
+        const templateStart = skipWhitespace(text, assignmentStart + 1)
+        if (text[templateStart] !== "`") {
+          cursor = templateStart + 1
+          continue
+        }
+
+        const templateEnd = findTemplateEnd(
+          text,
+          templateStart,
+          (char) =>
+            char === undefined ||
+            char === "\n" ||
+            char === "\r" ||
+            char === ";" ||
+            char === "," ||
+            char === ")" ||
+            char === "}" ||
+            char === "]",
+        )
+        if (templateEnd === -1) {
+          cursor = templateStart + 1
+          continue
+        }
+
+        return {
+          contentStart: templateStart + 1,
+          contentEnd: templateEnd,
+          nextCursor: templateEnd + 1,
+        }
+      }
+
+      return undefined
+    },
+    escapeTemplateLiteralContent,
   )
 
-const fixAssignedTemplate = (script: string, variableName: string): string => {
+const rewriteAssignedObjectLiteral = (
+  script: string,
+  variableName: string,
+): string => {
   let out = script
   let cursor = 0
 
@@ -701,91 +762,129 @@ const fixAssignedTemplate = (script: string, variableName: string): string => {
       continue
     }
 
-    const templateStart = skipWhitespace(out, assignmentStart + 1)
-    if (out[templateStart] !== "`") {
-      cursor = templateStart + 1
+    const objectStart = skipWhitespace(out, assignmentStart + 1)
+    if (out[objectStart] !== "{") {
+      cursor = objectStart + 1
       continue
     }
 
-    const templateEnd = findTemplateEnd(
-      out,
-      templateStart,
-      (char) =>
-        char === undefined ||
-        char === "\n" ||
-        char === "\r" ||
-        char === ";" ||
-        char === "," ||
-        char === ")" ||
-        char === "}" ||
-        char === "]",
-    )
-    if (templateEnd === -1) {
-      cursor = templateStart + 1
+    const objectEnd = findClosingBrace(out, objectStart)
+    if (objectEnd === -1) {
+      cursor = objectStart + 1
       continue
     }
 
-    const original = out.slice(templateStart + 1, templateEnd)
-    const escaped = escapeTemplateLiteralContent(original)
-    if (escaped !== original) {
-      out = `${out.slice(0, templateStart + 1)}${escaped}${out.slice(templateEnd)}`
-      cursor = templateEnd + (escaped.length - original.length) + 1
+    const original = out.slice(objectStart, objectEnd + 1)
+    const updated = normalizeObjectLiteralTemplateMarkers(original)
+    if (updated !== original) {
+      out = replaceSlice(out, objectStart, objectEnd + 1, updated)
+      cursor = objectEnd + 1 + (updated.length - original.length)
       continue
     }
 
-    cursor = templateEnd + 1
+    cursor = objectEnd + 1
   }
 
   return out
 }
 
-const fixAssignedTemplatesForToolCalls = (script: string): string => {
+const escapeRegExp = (text: string): string =>
+  text.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")
+
+const collectObjectEntryMapSources = (
+  script: string,
+  valueIdentifier: string,
+): ReadonlySet<string> => {
   const identifiers = new Set<string>()
-  for (const functionName of ["applyPatch", "taskComplete"] as const) {
+  const pattern = new RegExp(
+    `Object\\.entries\\(\\s*([A-Za-z_$][A-Za-z0-9_$]*)\\s*\\)\\s*\\.map\\(\\s*(?:async\\s*)?\\(\\s*\\[\\s*[A-Za-z_$][A-Za-z0-9_$]*\\s*,\\s*${escapeRegExp(valueIdentifier)}\\s*\\]\\s*\\)\\s*=>`,
+    "g",
+  )
+
+  for (const match of script.matchAll(pattern)) {
+    if (match[1] !== undefined) {
+      identifiers.add(match[1])
+    }
+  }
+
+  return identifiers
+}
+
+const rewriteDirectTemplates = (script: string): string => {
+  let out = script
+
+  for (const target of objectPropertyTargets) {
+    out = rewriteTemplateContents(
+      out,
+      (text, from) => findObjectPropertyTemplate(text, target, from),
+      escapeTemplateLiteralContent,
+    )
+  }
+
+  for (const functionName of callTemplateTargets) {
+    out = rewriteTemplateContents(
+      out,
+      (text, from) => findDirectCallTemplate(text, functionName, from),
+      escapeTemplateLiteralContent,
+    )
+  }
+
+  return out
+}
+
+const collectReferencedTemplateIdentifiers = (
+  script: string,
+): {
+  readonly templateIdentifiers: ReadonlySet<string>
+  readonly objectIdentifiers: ReadonlySet<string>
+} => {
+  const templateIdentifiers = new Set<string>()
+
+  for (const functionName of callTemplateTargets) {
     for (const identifier of collectCallArgumentIdentifiers(
       script,
       functionName,
     )) {
-      identifiers.add(identifier)
+      templateIdentifiers.add(identifier)
     }
   }
-  for (const [functionName, propertyName] of callObjectPropertyTargets) {
-    for (const identifier of collectCallObjectPropertyIdentifiers(
-      script,
-      functionName,
-      propertyName,
-    )) {
-      identifiers.add(identifier)
+
+  for (const target of objectPropertyTargets) {
+    for (const identifier of collectObjectPropertyIdentifiers(script, target)) {
+      templateIdentifiers.add(identifier)
     }
   }
+
   if (script.includes("*** Begin Patch")) {
-    identifiers.add("patch")
+    templateIdentifiers.add("patch")
   }
 
-  const objectTemplateIdentifiers = new Set<string>()
-  for (const identifier of identifiers) {
-    for (const sourceIdentifier of collectObjectEntryMapSources(
-      script,
-      identifier,
-    )) {
-      objectTemplateIdentifiers.add(sourceIdentifier)
+  const objectIdentifiers = new Set<string>()
+  for (const identifier of templateIdentifiers) {
+    for (const source of collectObjectEntryMapSources(script, identifier)) {
+      objectIdentifiers.add(source)
     }
   }
 
+  return {
+    templateIdentifiers,
+    objectIdentifiers,
+  }
+}
+
+const rewriteAssignedTargets = (script: string): string => {
+  const { templateIdentifiers, objectIdentifiers } =
+    collectReferencedTemplateIdentifiers(script)
+
   let out = script
-  for (const identifier of identifiers) {
-    out = fixAssignedTemplate(out, identifier)
+  for (const identifier of templateIdentifiers) {
+    out = rewriteAssignedTemplate(out, identifier)
   }
-  for (const identifier of objectTemplateIdentifiers) {
-    out = fixAssignedObjectTemplateValues(out, identifier)
+  for (const identifier of objectIdentifiers) {
+    out = rewriteAssignedObjectLiteral(out, identifier)
   }
+
   return out
 }
-
 export const preprocessScript = (script: string): string =>
-  fixAssignedTemplatesForToolCalls(
-    ["applyPatch", "taskComplete"].reduce(
-      (current, functionName) => fixCallTemplateArgument(current, functionName),
-      fixTargetCallObjectPropertyTemplates(script),
-    ),
-  )
+  rewriteAssignedTargets(rewriteDirectTemplates(script))