<llm id="chunked-llm">
  <prompt>Processing chunk: {({chunk}) => chunk.data}</prompt>
</llm>
<onchunk for="chunked-llm">
  <log expr={({chunk}) => `Processing chunk: ${chunk.data}`} />
</onchunk>

<onchunk>
  <log expr={({chunk}) => `Processing chunk: ${chunk.data}`} />
  <script>
    processChunk(chunk);
  </script>
</onchunk>

<onchunk>
  <if condition={({chunk}) => chunk.type === "data"}>
    <script>
      accumulateData(chunk.data);
      updateProgress(chunk.progress);
    </script>
  </if>
  <elseif condition={({chunk}) => chunk.type === "metadata"}>
    <script>
      updateMetadata(chunk.metadata);
    </script>
  </elseif>
</onchunk>

<onchunk>
  <script>
    const analysis = analyzeChunk(chunk);
    if (analysis.needsAction) {
      triggerAction(analysis.action);
    }
  </script>
  <log expr={({analysis}) => `
    Chunk Analysis:
    Size: ${analysis.size}
    Type: ${analysis.type}
    Action: ${analysis.action}
  `} />
</onchunk>

<onchunk>
  <script>
    const buffer = getBuffer();
    buffer.append(chunk.data);
    
    if (buffer.isComplete()) {
      processCompleteData(buffer.getData());
      buffer.clear();
    }
  </script>
  
  <log expr={({buffer}) => `
    Buffer Status:
    Size: ${buffer.size}
    Complete: ${buffer.isComplete()}
  `} />
</onchunk>

<onchunk>
  <datamodel>
    <data 
      id="metrics"
      type="JSON"
      value={{
        chunks: 0,
        totalSize: 0,
        patterns: {}
      }}
    />
  </datamodel>
  
  <script>
    updateMetrics(chunk);
    analyzePatterns(chunk);
    detectAnomalies(chunk);
  </script>
  
  <if condition={({metrics}) => metrics.anomalies.length > 0}>
    <raise event="anomalyDetected" />
  </if>
</onchunk>

<onchunk>
  <assign 
    location="state.progress"
    expr={({chunk, state}) => ({
      processed: state.progress.processed + 1,
      total: chunk.total,
      percentage: ((state.progress.processed + 1) / chunk.total) * 100
    })}
  />
  
  <if condition={({state}) => state.progress.percentage % 10 === 0}>
    <log expr={({state}) => `
      Progress Update:
      ${state.progress.percentage}% complete
      (${state.progress.processed}/${state.progress.total})
    `} />
  </if>
</onchunk>

<onchunk>
  <script>
    const transformed = transformChunk(chunk, {
      format: state.outputFormat,
      encoding: state.encoding,
      compression: state.compression
    });
    
    processTransformedChunk(transformed);
  </script>
  
  <if condition={({transformed}) => transformed.needsValidation}>
    <script>
      validateChunk(transformed);
    </script>
  </if>
</onchunk>

<parallel id="chunkProcessing">
  <onchunk>
    <state id="analysis">
      <script>
        analyzeChunkContent(chunk);
      </script>
    </state>
    
    <state id="storage">
      <script>
        storeChunkData(chunk);
      </script>
    </state>
    
    <state id="monitoring">
      <script>
        updateMetrics(chunk);
      </script>
    </state>
  </onchunk>
</parallel>

<onchunk>
  <script>
    const strategy = selectProcessingStrategy(chunk, {
      size: chunk.size,
      type: chunk.type,
      complexity: analyzeComplexity(chunk),
      systemLoad: getSystemLoad()
    });
    
    applyProcessingStrategy(chunk, strategy);
  </script>
  
  <log expr={({strategy}) => `
    Selected Strategy:
    Type: ${strategy.type}
    Priority: ${strategy.priority}
    Resources: ${strategy.resources}
  `} />
  
  <if condition={({strategy}) => strategy.needsScaling}>
    <raise event="scaleResources" />
  </if>
</onchunk>