Text Replacement Strategy Prompt

// Scan all text nodes to understand structure
const textNodes = await scan_text_nodes({ nodeId: selectedNodeId });

// Get node context
const nodeInfo = await get_node_info({ nodeId: selectedNodeId });

// Step 1: Clone the node for safe editing
const cloned = await clone_node({ 
  nodeId: selectedNodeId, 
  x: newX, 
  y: newY 
});

// Step 2: Replace text in chunks
for (const chunk of textChunks) {
  // Replace text in this chunk
  await set_multiple_text_contents({
    nodeId: cloned.id,
    text: chunk.map(item => ({
      nodeId: item.nodeId,
      text: item.newText
    }))
  });
  
  // Step 3: Verify chunk with image export
  const verification = await export_node_as_image({
    nodeId: chunk.parentNodeId,
    format: "PNG",
    scale: determineScale(chunk.size)
  });
  
  // Check for issues before proceeding
  // Fix any problems found before continuing
}

// Process one row at a time
const tableRows = groupTextNodesByRow(textNodes);

for (const row of tableRows) {
  await set_multiple_text_contents({
    nodeId: tableNodeId,
    text: row.cells.map(cell => ({
      nodeId: cell.nodeId,
      text: cell.newText
    }))
  });
  
  // Verify row alignment and spacing
  await export_node_as_image({ 
    nodeId: row.nodeId, 
    format: "PNG", 
    scale: 0.7 
  });
}

function determineScale(elementCount: number): number {
  if (elementCount <= 5) return 1.0;      // Small chunks
  if (elementCount <= 20) return 0.7;     // Medium chunks
  if (elementCount <= 50) return 0.5;     // Large chunks
  if (elementCount > 50) return 0.3;      // Very large chunks
  return 0.2;                              // Full design
}

// Export entire design at reduced scale
const finalVerification = await export_node_as_image({
  nodeId: clonedNodeId,
  format: "PNG",
  scale: 0.2
});

// Check for:
// - Cross-chunk consistency
// - Proper text flow between sections
// - Design harmony across full composition

// Group table text nodes by row (5-10 rows per chunk)
const rows = groupByRow(textNodes, { rowsPerChunk: 7 });

for (const rowChunk of rows) {
  await set_multiple_text_contents({
    nodeId: tableId,
    text: rowChunk.map(row => row.cells.map(cell => ({
      nodeId: cell.nodeId,
      text: cell.newText
    }))).flat()
  });
}

// Group 3-5 similar cards per chunk
const cardChunks = chunk(cardNodes, 4);

for (const cards of cardChunks) {
  await set_multiple_text_contents({
    nodeId: listContainerId,
    text: cards.map(card => card.textFields.map(field => ({
      nodeId: field.nodeId,
      text: field.newText
    }))).flat()
  });
  
  // Verify text-to-image ratio within cards
  await export_node_as_image({ 
    nodeId: cards[0].parentId, 
    format: "PNG", 
    scale: 0.7 
  });
}

// Process form sections (Personal Info, Payment, etc.)
const formSections = [
  { name: "Personal Information", fields: [...] },
  { name: "Payment Details", fields: [...] },
  { name: "Shipping Address", fields: [...] }
];

for (const section of formSections) {
  // Process labels and input fields together
  await set_multiple_text_contents({
    nodeId: formId,
    text: section.fields.map(field => ({
      nodeId: field.labelNodeId,
      text: field.labelText
    }))
  });
  
  // Ensure validation messages and hints are updated
}

// Process main menu, then submenu items
const navLevels = [
  { level: "main", items: [...] },
  { level: "submenu", items: [...] }
];

for (const level of navLevels) {
  await set_multiple_text_contents({
    nodeId: navContainerId,
    text: level.items.map(item => ({
      nodeId: item.nodeId,
      text: item.newText
    }))
  });
  
  // Verify menu fit and alignment
}