{
  "segments": [
    {
      "start": "1.234",
      "end": "5.432",
      "text": "Hello and welcome to AWS Bites",
      "speaker": "SPEAKER_00"
    },
    {
      "start": "7.734",
      "end": "14.322",
      "text": "Here's Luciano",
      "speaker": "SPEAKER_00"
    },
    {
      "start": "15.934",
      "end": "19.322",
      "text": "...and here's Eoin",
      "speaker": "SPEAKER_01"
    }
  ]
}

{
  "segments": [
    {
      "start": "1.234",
      "end": "5.432",
      "text": "Hello and welcome to AWS Bites",
      "speaker": "SPEAKER_00",
      "words": [
        {
          "start": "1.234",
          "end": "2.015",
          "word": "Hello"
        },
        {
          "start": "2.432",
          "end": "3.012",
          "word": "and"
        },
        {
          "start": "3.343",
          "end": "4.432",
          "word": "welcome"
        },
        {
          "start": "4.598",
          "end": "4.732",
          "word": "to"
        },
        {
          "start": "4.812",
          "end": "4.955",
          "word": "AWS"
        },
        {
          "start": "5.011",
          "end": "5.432",
          "word": "Bites"
        }
      ]
    }
  ]
}

import { DurableContext, withDurableExecution } from '@aws/durable-execution-sdk-js'
import { EventBridgeEvent } from 'aws-lambda'

type S3ObjectCreatedDetail = {
  bucket: { name: string }
  object: { key: string; size: number; etag: string }
}

type S3EventBridgeEvent = EventBridgeEvent<'Object Created',S3ObjectCreatedDetail>

// INIT: here is where you want to initialize clients, read secrets, etc!

const handler = async (event: S3EventBridgeEvent, context: DurableContext) => {
  // ... biz logic here!
}

export const lambdaHandler = withDurableExecution(handler)

const handler = async (event: S3EventBridgeEvent, context: DurableContext) => {
  const key = decodeURIComponent(event.detail.object.key.replace(/\+/g, ' '))
  const rawResult = await context.waitForCallback( // FIRST STEP!
    `transcribe-${key}`,
    async (callback_id, innerCtx) => {
      innerCtx.logger.debug('Sending message to SQS with callback')
      const message = { s3_key: key, callback_id }
      const sqs = new SQSClient()
      await sqs.send(
        new SendMessageCommand({
          QueueUrl: QUEUE_URL,
          MessageBody: JSON.stringify(message),
        }),
      )
      innerCtx.logger.info('Message sent successfully to SQS')
    },
    { timeout: { minutes: 60 } },
  )
  
  // You'll never reach this line in this invocation
  console.log('🫠')
}

const handler = async (event: S3EventBridgeEvent, context: DurableContext) => {
  // ... wait for callback stuff
  
  // Fill timing gaps — fills missing word timestamps before any other processing
  await context.step('fill-timing-gaps', async () => {
    // ...
  })
  
  // Replacement rules
  await context.step('replacement-rules', async () => {
    // ...
  })
  
  // LLM-based refinement
  await context.step('llm-refinement', async () => {
    // ...
  })
  
  // Segments Normalization
  await context.step('segments-normalization', async () => {
    // ...
  })
  
  // Generate VTT, SRT, and JSON caption files in parallel
  const { captionKeys, pipelineCompletedAt } = await context.step(
    'generate-captions',
    async () => {
      // ...
    }
  )
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    
    // ...
    
    // Allow AWS to manage your EC2 instances
    // ...and run ECS containers on them
    const instanceProfileRole = new iam.Role(
      this,
      'ManagedInstancesInstanceProfileRole',
      {
        assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
      },
    )
    instanceProfileRole.addManagedPolicy(
      iam.ManagedPolicy.fromAwsManagedPolicyName(
        'AmazonECSInstanceRolePolicyForManagedInstances',
      ),
    )

    const infrastructureRole = new iam.Role(
      this,
      'ManagedInstancesInfrastructureRole',
      {
        assumedBy: new iam.ServicePrincipal('ecs.amazonaws.com'),
        managedPolicies: [
          iam.ManagedPolicy.fromAwsManagedPolicyName(
            'AmazonECSInfrastructureRolePolicyForManagedInstances',
          ),
        ],
      },
    )

    infrastructureRole.addToPolicy(
      new iam.PolicyStatement({
        actions: ['iam:PassRole'],
        resources: [instanceProfileRole.roleArn],
      }),
    )

    const instanceProfile = new iam.InstanceProfile(
      this,
      'ManagedInstancesInstanceProfile',
      {
        role: instanceProfileRole,
      },
    )
    // ...
  }
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    
    // ...
    
    // Create the cluster
    const cluster = new ecs.Cluster(this, 'MyEcsMiCluster', {
      clusterName: 'MyEcsMiCluster'
    })
    
    // ...
  }
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    
    // ...
    
    // Create capacity provider
    const capacityProvider = new ecs.ManagedInstancesCapacityProvider(
      this,
      'PodwhispererCapacityProvider',
      {
        subnets: cluster.vpc.privateSubnets,
        infrastructureRole,
        ec2InstanceProfile: instanceProfile,
        securityGroups: [allowOutboundSg],
        instanceRequirements: {
          vCpuCountMin: 4,
          vCpuCountMax: 16, // Allow various GPU instance types from 4 to 16 vCPUs
          memoryMin: cdk.Size.gibibytes(16), // Minimum 16 GB (8 GB task + ~8 GB OS overhead)
          cpuManufacturers: [
            ec2.CpuManufacturer.INTEL,
            ec2.CpuManufacturer.AMD,
          ],
          instanceGenerations: [ec2.InstanceGeneration.CURRENT],
          burstablePerformance: ec2.BurstablePerformance.EXCLUDED,
          bareMetal: ec2.BareMetal.EXCLUDED,

          // GPU requirement: single NVIDIA GPU
          // Allows: g4dn.xlarge, g4dn.2xlarge, g5.xlarge, g5.2xlarge, p3.2xlarge, etc.
          acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
          acceleratorTypes: [ec2.AcceleratorType.GPU],
          acceleratorCountMin: 1,
          acceleratorCountMax: 1, // No multi-GPU instances
        },
      },
    )
    
    // Adds the capacity provider to our cluster
    cluster.addManagedInstancesCapacityProvider(capacityProvider)
    
    // ...
  }
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    // ...
    
    // Create task definition
    const ecsTaskDefinition = new ecs.TaskDefinition(
      this,
      'PodwhispererTaskDef',
      {
        compatibility: ecs.Compatibility.MANAGED_INSTANCES,
        cpu: '4096',
        memoryMiB: '8192',
        runtimePlatform: { cpuArchitecture: ecs.CpuArchitecture.X86_64 },
        networkMode: ecs.NetworkMode.AWS_VPC,
      },
    )
    ecsTaskDefinition.addContainer('worker', {
      image,
      gpuCount: 1, // <- IMPORTANT TO EXPOSE GPU TO THE CONTAINER
    })
    
    // ...
  }
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    // ...
    
    // Create service
    const service = new ecs.FargateService(this, 'PodwhispererService', {
      cluster,
      taskDefinition: ecsTaskDefinition,
      desiredCount: 0, // Start at 0, scale up based on queue depth
      minHealthyPercent: 0, // Allow tasks to be stopped during deployments
      enableExecuteCommand: true,
      capacityProviderStrategies: [
        {
          capacityProvider: capacityProvider.capacityProviderName,
          weight: 1,
        },
      ],
    })
    
    // ...
  }
}

export class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: MyStackProps) {
    super(scope, id, props)
    // ...
    
    // Auto-scaling: scale to zero when queue is empty, scale to 1 when messages arrive
    // Simple binary scaling: 0 messages = 0 tasks, 1+ messages = 1 task
    const scaling = service.autoScaleTaskCount({
      minCapacity: 0, // Scale to zero when idle = no cost
      maxCapacity: 1, // Only allow 1 concurrent task
    })

    scaling.scaleOnMetric('QueueDepthScaling', {
      metric: queue.metricApproximateNumberOfMessagesVisible(),
      scalingSteps: [
        { upper: 0, change: -1 }, // Scale down to 0 when queue is empty
        { lower: 1, change: +1 }, // 1+ messages: scale up to 1 task
      ],
      adjustmentType: appscaling.AdjustmentType.CHANGE_IN_CAPACITY,
      cooldown: cdk.Duration.seconds(60),
    })
    
    // ...
  }
}

const REFINEMENT_PROMPT_TEMPLATE = `
You are a transcript editor. Your task is to fix ONLY obvious transcription errors - words that were clearly misheard or misspelled by the speech-to-text system.

## STRICT RULES - Read carefully

**DO correct:**
- Technical terms and proper nouns that were phonetically misheard (e.g., "aye phone" → "iPhone", "doctor smith" → "Dr. Smith")
- Words split incorrectly by the transcriber (e.g., "face book" → "Facebook", "new york" → "New York")
- Obvious homophones that are wrong in context (e.g., "there" vs "their" when clearly wrong)
- Duplicated words from transcription errors (e.g., "the the" → "the")

**DO NOT:**
- Rephrase or reword sentences
- Change sentence structure
- Add words that weren't spoken
- Remove words unless they are duplicated transcription errors
- "Improve" grammar or style
- Change filler words (um, uh, like) - leave them as-is
- Make subjective changes

**When in doubt, leave it unchanged.** The goal is to fix machine transcription errors, not to edit the speakers' words.

## Examples of GOOD vs BAD corrections

**GOOD corrections** (these ARE transcription errors - make these fixes):
- "sage maker" → "SageMaker" (split technical term)
- "lamb da" → "Lambda" (split word)
- "the the function" → "the function" (duplicate word)
- "new york" → "New York" (proper noun)
- "aye phone" → "iPhone" (phonetically misheard)

**BAD corrections** (do NOT make these changes):
- "So default in Lambda, that would be..." → "So you can have up to..." (complete rewrite - WRONG)
- "I think we should probably consider" → "We should consider" (removing hedging - WRONG)
- "um so basically what happens" → "what happens" (removing fillers - WRONG)
- "it's like really fast" → "it's very fast" (style improvement - WRONG)
- "I think this approach pushes you" → "This approach pushes you" (removing speaker's voice - WRONG)

**Rule of thumb:** If more than 2-3 words need changing, it's probably NOT a transcription error. Leave it unchanged.

{{ADDITIONAL_CONTEXT}}

## Speaker Identification
If additional context is provided above, use any information about speakers (names, roles, or speaking patterns) to identify them. Otherwise, keep the original SPEAKER_XX labels for unknown speakers.

## Input format
Plain text lines with index and speaker prefix:
\`\`\`
[0] [SPEAKER_00] Hello and welcome to the show.
[1] [SPEAKER_01] Thanks for having me.
\`\`\`

## Output format
\`\`\`json
{
  "identifiedSpeakers": {
    "SPEAKER_00": "Name or SPEAKER_00 if unknown",
    "SPEAKER_01": "Name or SPEAKER_01 if unknown"
  },
  "updates": [
    { "idx": 1, "text": "Corrected text here." }
  ]
}
\`\`\`

Only include updates for lines with genuine transcription errors. Most lines should NOT need changes. Do not report lines with no changes.

## Transcript to analyze

{{TRANSCRIPT}}
`