AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Invoke the generated renderer with bounded, deterministic sample settings.
$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
Show-Constellation -Width 30 -Height 8 -FrameCount 3 -Seed 17

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Render a small deterministic constellation storyboard as plain text.
# The function uses only in-memory coordinates, so it is safe to run in an
# isolated validation environment and easy to adapt for a terminal UI later.
function Show-Constellation {
    [CmdletBinding()]
    param(
        # Number of columns inside the border.
        [ValidateRange(12,120)]
        [int]$Width = 42,
        # Number of rows inside the border.
        [ValidateRange(5,40)]
        [int]$Height = 12,
        # Number of still frames to print.
        [ValidateRange(1,12)]
        [int]$FrameCount = 3,
        # Seed keeps the artwork repeatable for tests and demos.
        [int]$Seed = 42
    )

    # Create a repeatable collection of stars with a small horizontal drift.
    $random = [System.Random]::new($Seed)
    $stars = for ($index = 0; $index -lt [Math]::Max(8, [int]($Width * $Height / 18)); $index++) {
        [pscustomobject]@{
            X = $random.Next(0, $Width)
            Y = $random.Next(0, $Height)
            Drift = $random.Next(0, 4)
            Glyph = @('.', '·', '✦', '★')[$random.Next(0, 4)]
        }
    }

    for ($frame = 0; $frame -lt $FrameCount; $frame++) {
        "Frame $($frame + 1)/$FrameCount"
        '┌' + ('─' * $Width) + '┐'

        for ($row = 0; $row -lt $Height; $row++) {
            $cells = [char[]](' ' * $Width)
            foreach ($star in $stars) {
                $x = ($star.X + ($frame * $star.Drift)) % $Width
                if ($star.Y -eq $row) {
                    $cells[$x] = [char]$star.Glyph
                }
            }
            '│' + (-join $cells) + '│'
        }

        '└' + ('─' * $Width) + '┘'
    }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Prepare fictional milestones and run the generated workbook solution.
$ErrorActionPreference = 'Stop'
Import-Module ImportExcel -ErrorAction Stop
. (Join-Path $PSScriptRoot 'solution.ps1')
$path = Join-Path $PSScriptRoot 'milestone-risk.xlsx'
$milestones = @(
    [pscustomobject]@{ Milestone = 'Design freeze'; Owner = 'Mira'; DueDate = '2026-09-22'; Status = 'In progress'; PercentComplete = 80 }
    [pscustomobject]@{ Milestone = 'Pilot rehearsal'; Owner = 'Jon'; DueDate = '2026-09-25'; Status = 'In progress'; PercentComplete = 35 }
    [pscustomobject]@{ Milestone = 'Launch notes'; Owner = 'Ari'; DueDate = '2026-09-18'; Status = 'In progress'; PercentComplete = 60 }
    [pscustomobject]@{ Milestone = 'Welcome email'; Owner = 'Nia'; DueDate = '2026-09-21'; Status = 'Complete'; PercentComplete = 100 }
)
Export-MilestoneRiskWorkbook -Milestones $milestones -AsOfDate ([datetime]'2026-09-21') -Path $path
$package = Open-ExcelPackage -Path $path
$sheet = $package.Workbook.Worksheets['Milestones']
[pscustomobject]@{ Worksheet = 'Milestones'; Rows = $sheet.Dimension.Rows; Columns = $sheet.Dimension.Columns; Tables = $sheet.Tables.Count }
Close-ExcelPackage $package

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Export milestone records as a small, review-ready Excel workbook.
# ImportExcel is the only external module used; all records are supplied by
# the caller and the workbook is written to the requested output path.
function Export-MilestoneRiskWorkbook {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [object[]]$Milestones,
        [Parameter(Mandatory)]
        [datetime]$AsOfDate,
        [Parameter(Mandatory)]
        [string]$Path
    )

    # Convert each input object to a consistent calculated record.
    $rows = foreach ($milestone in $Milestones) {
        $due = [datetime]$milestone.DueDate
        $daysToDue = ($due.Date - $AsOfDate.Date).Days
        $risk = if ($milestone.Status -eq 'Complete') { 'On Track' }
                elseif ($daysToDue -lt 0) { 'Late' }
                elseif ($daysToDue -le 3 -or $milestone.PercentComplete -lt 50) { 'At Risk' }
                else { 'On Track' }
        [pscustomobject]@{
            Milestone = [string]$milestone.Milestone
            Owner = [string]$milestone.Owner
            DueDate = $due.Date
            Status = [string]$milestone.Status
            PercentComplete = [int]$milestone.PercentComplete
            DaysToDue = $daysToDue
            Risk = $risk
        }
    }

    # Ensure the destination folder exists without touching any other files.
    $parent = Split-Path -Parent $Path
    if ($parent -and -not (Test-Path -LiteralPath $parent)) {
        New-Item -ItemType Directory -Path $parent -Force | Out-Null
    }

    # Export the detailed table and a compact summary sheet.
    $rows | Export-Excel -Path $Path -WorksheetName 'Milestones' -TableName 'Milestones' -AutoSize -FreezeTopRow -BoldTopRow -ClearSheet
    $summary = $rows | Group-Object Risk | ForEach-Object {
        [pscustomobject]@{ Risk = $_.Name; Count = $_.Count }
    }
    $summary | Export-Excel -Path $Path -WorksheetName 'Summary' -TableName 'RiskSummary' -AutoSize -BoldTopRow -Append

    # Apply simple, portable visual cues to make review faster.
    $package = Open-ExcelPackage -Path $Path
    $sheet = $package.Workbook.Worksheets['Milestones']
    Add-ConditionalFormatting -Worksheet $sheet -Address 'E2:E200' -DataBarColor '4F81BD' | Out-Null
    Add-ConditionalFormatting -Worksheet $sheet -Address 'G2:G200' -RuleType Equal -ConditionValue '"Late"' -BackgroundColor 'F4CCCC' -ForegroundColor '9C0006' | Out-Null
    Add-ConditionalFormatting -Worksheet $sheet -Address 'G2:G200' -RuleType Equal -ConditionValue '"At Risk"' -BackgroundColor 'FFF2CC' -ForegroundColor '7F6000' | Out-Null
    Close-ExcelPackage $package

    [pscustomobject]@{
        Path = (Resolve-Path -LiteralPath $Path).Path
        MilestoneCount = $rows.Count
        RiskSummary = (($summary | ForEach-Object { "$($_.Risk)=$($_.Count)" }) -join ', ')
    }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Scale a fictional soup recipe from four portions to ten.
$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$ingredients = @(
    [pscustomobject]@{ Quantity = 2; Unit = 'cups'; Ingredient = 'tomatoes' }
    [pscustomobject]@{ Quantity = 1.5; Unit = 'cups'; Ingredient = 'stock' }
    [pscustomobject]@{ Quantity = 0.5; Unit = 'cup'; Ingredient = 'lentils' }
    [pscustomobject]@{ Quantity = 2; Unit = 'tbsp'; Ingredient = 'herbs' }
)
Convert-RecipeBatch -OriginalServings 4 -TargetServings 10 -Ingredients $ingredients | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Scale ingredient quantities while retaining the original units and names.
function Convert-RecipeBatch {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidateRange(1,10000)]
        [int]$OriginalServings,
        [Parameter(Mandatory)]
        [ValidateRange(1,10000)]
        [int]$TargetServings,
        [Parameter(Mandatory)]
        [object[]]$Ingredients
    )

    # One multiplier applies to every ingredient in the batch.
    $multiplier = [decimal]$TargetServings / $OriginalServings
    foreach ($ingredient in $Ingredients) {
        # Round display quantities to three decimal places but keep decimals.
        $quantity = [Math]::Round(([decimal]$ingredient.Quantity * $multiplier), 3)
        [pscustomobject]@{
            Quantity = $quantity
            Unit = [string]$ingredient.Unit
            Ingredient = [string]$ingredient.Ingredient
        }
    }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Build a fictional launch board for three distributed teams.
$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$events = @(
    [pscustomobject]@{ Event = 'Preview stream'; UtcTime = '2026-10-03T15:00:00Z' }
    [pscustomobject]@{ Event = 'Feedback room'; UtcTime = '2026-10-04T09:30:00Z' }
)
Get-GlobalLaunchBoard -Events $events -TimeZoneIds @('America/New_York', 'Europe/London', 'Asia/Tokyo') | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Convert UTC launch events into a compact multi-zone schedule.
function Get-GlobalLaunchBoard {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [object[]]$Events,
        [Parameter(Mandatory)]
        [string[]]$TimeZoneIds
    )

    foreach ($event in $Events) {
        # Parse as an offset-aware instant so the conversion is unambiguous.
        $utc = [datetimeoffset]$event.UtcTime
        foreach ($zoneId in $TimeZoneIds) {
            $zone = [TimeZoneInfo]::FindSystemTimeZoneById($zoneId)
            $local = [TimeZoneInfo]::ConvertTime($utc, $zone)
            [pscustomobject]@{
                Event = [string]$event.Event
                Zone = $zone.Id
                LocalTime = $local.ToString('yyyy-MM-dd HH:mm zzz')
                LocalDate = $local.ToString('dddd, MMM d')
            }
        }
    }
}

AI created run.ps1 to prepare sample data, pass parameters, and invoke the generated PowerShell.

# Solve a compact, deterministic puzzle with a fictional dictionary.
$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot 'solution.ps1')
$dictionary = 'cold','cord','card','ward','warm','bold','bald','bard','word'
$result = Find-WordLadder -StartWord 'cold' -EndWord 'warm' -WordList $dictionary
$result | Format-List
"Path: $($result.Path -join ' -> ')"

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

# Find the shortest one-letter-at-a-time transformation between two words.
function Find-WordLadder {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)] [string]$StartWord,
        [Parameter(Mandatory)] [string]$EndWord,
        [Parameter(Mandatory)] [string[]]$WordList
    )

    $start = $StartWord.ToLowerInvariant()
    $end = $EndWord.ToLowerInvariant()
    if ($start.Length -ne $end.Length) { throw 'Start and end words must have the same length.' }

    # Keep only same-length words and use sets for constant-time membership.
    $dictionary = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    $WordList | Where-Object { $_.Length -eq $start.Length } | ForEach-Object { [void]$dictionary.Add($_.ToLowerInvariant()) }
    [void]$dictionary.Add($start)
    [void]$dictionary.Add($end)

    # Queue words breadth-first and remember each predecessor for reconstruction.
    $queue = [System.Collections.Generic.Queue[string]]::new()
    $visited = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)
    $parent = @{}
    $queue.Enqueue($start)
    [void]$visited.Add($start)
    $alphabet = 'abcdefghijklmnopqrstuvwxyz'.ToCharArray()
    while ($queue.Count -gt 0) {
        $current = $queue.Dequeue()
        if ($current -eq $end) { break }
        for ($position = 0; $position -lt $current.Length; $position++) {
            foreach ($letter in $alphabet) {
                if ($letter -eq $current[$position]) { continue }
                $candidateChars = $current.ToCharArray()
                $candidateChars[$position] = $letter
                $candidate = -join $candidateChars
                if ($dictionary.Contains($candidate) -and $visited.Add($candidate)) {
                    $parent[$candidate] = $current
                    $queue.Enqueue($candidate)
                }
            }
        }
    }

    if (-not $visited.Contains($end)) {
        return [pscustomobject]@{ Start = $start; End = $end; Found = $false; Steps = 0; Path = @() }
    }
    $path = [System.Collections.Generic.List[string]]::new()
    $cursor = $end
    while ($null -ne $cursor) {
        $path.Insert(0, $cursor)
        $cursor = if ($parent.ContainsKey($cursor)) { $parent[$cursor] } else { $null }
    }
    [pscustomobject]@{ Start = $start; End = $end; Found = $true; Steps = $path.Count - 1; Path = $path.ToArray() }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

$ErrorActionPreference = 'Stop'

# Load the AI-generated function from the same lab folder.
. "$PSScriptRoot/solution.ps1"

# Create deterministic fictional workloads entirely in memory.
$workloads = @(
    [pscustomobject]@{ Name = 'Build Artifacts'; StartingGB = 420; MonthlyGrowthPct = 8; Months = 6 }
    [pscustomobject]@{ Name = 'Support Archive'; StartingGB = 850; MonthlyGrowthPct = 3.5; Months = 12 }
    [pscustomobject]@{ Name = 'Design Assets'; StartingGB = 275; MonthlyGrowthPct = 12; Months = 4 }
)

# Generate the forecast and show the highest final capacity first.
Get-StorageGrowthForecast -Workload $workloads |
    Sort-Object FinalGB -Descending |
    Select-Object Workload, StartingGB,
        @{ Name = 'GrowthPct'; Expression = { $_.MonthlyGrowthPercent } },
        Months, FinalGB, AddedGB,
        @{ Name = 'AvgAddedGB'; Expression = { $_.AverageAddedGB } } |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

function Get-StorageGrowthForecast {
    [CmdletBinding()]
    param(
        # Each input object describes one fictional workload and its growth assumptions.
        [Parameter(Mandatory, ValueFromPipeline)]
        [psobject[]]$Workload
    )

    process {
        foreach ($item in $Workload) {
            # Convert each numeric field once so calculations use predictable decimal values.
            $startingGB = [double]$item.StartingGB
            $growthPct = [double]$item.MonthlyGrowthPct
            $months = [int]$item.Months

            # Reject values that would make the forecast misleading or mathematically invalid.
            if ([string]::IsNullOrWhiteSpace([string]$item.Name)) {
                throw 'Each workload must have a name.'
            }
            if ($startingGB -lt 0 -or $growthPct -lt 0 -or $months -lt 1) {
                throw "Workload '$($item.Name)' contains an invalid numeric value."
            }

            # Convert the percentage to a multiplier and compound it for the requested months.
            $monthlyMultiplier = 1 + ($growthPct / 100)
            $finalGB = $startingGB * [math]::Pow($monthlyMultiplier, $months)
            $addedGB = $finalGB - $startingGB

            # Return a clean object that downstream commands can sort, export, or format.
            [pscustomobject]@{
                Workload             = [string]$item.Name
                StartingGB           = [math]::Round($startingGB, 2)
                MonthlyGrowthPercent = [math]::Round($growthPct, 2)
                Months               = $months
                FinalGB              = [math]::Round($finalGB, 2)
                AddedGB              = [math]::Round($addedGB, 2)
                AverageAddedGB       = [math]::Round($addedGB / $months, 2)
            }
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

$ErrorActionPreference = 'Stop'

# Suppress the module's optional AutoSize dependency warning; this lab sets widths explicitly.
$WarningPreference = 'SilentlyContinue'

# Load the AI-generated workbook function.
. "$PSScriptRoot/solution.ps1"

# Use fixed fictional records so every run produces the same status counts.
$renewals = @(
    [pscustomobject]@{ Service = 'Diagram Cloud'; Owner = 'Design'; RenewalDate = '2026-09-12'; AnnualCost = 1440 }
    [pscustomobject]@{ Service = 'Build Cache'; Owner = 'Engineering'; RenewalDate = '2026-09-28'; AnnualCost = 3600 }
    [pscustomobject]@{ Service = 'Survey Desk'; Owner = 'Research'; RenewalDate = '2026-10-14'; AnnualCost = 960 }
    [pscustomobject]@{ Service = 'Status Board'; Owner = 'Operations'; RenewalDate = '2027-01-10'; AnnualCost = 2280 }
)

# Create a new workbook in the process temp directory without overwriting prior runs.
$runId = [guid]::NewGuid().ToString('N').Substring(0, 8)
$workbookPath = Join-Path ([System.IO.Path]::GetTempPath()) "service-renewal-workbook-$runId.xlsx"
$summary = Export-ServiceRenewalWorkbook -Renewal $renewals -AsOfDate '2026-09-20' -Path $workbookPath

# Show both the summary and workbook structure used by validation.
$summary | Format-List
$package = Open-ExcelPackage -Path $workbookPath
$sheet = $package.Workbook.Worksheets['Renewals']
[pscustomobject]@{
    Worksheet = $sheet.Name
    Rows = $sheet.Dimension.Rows
    Columns = $sheet.Dimension.Columns
    Tables = $sheet.Tables.Count
    ConditionalFormats = $sheet.ConditionalFormatting.Count
} | Format-List
Close-ExcelPackage -ExcelPackage $package -NoSave

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

function Export-ServiceRenewalWorkbook {
    [CmdletBinding()]
    param(
        # Renewal records must include Service, Owner, RenewalDate, and AnnualCost.
        [Parameter(Mandatory)]
        [psobject[]]$Renewal,

        # A fixed as-of date keeps the calculation deterministic and easy to test.
        [Parameter(Mandatory)]
        [datetime]$AsOfDate,

        # The caller chooses the single workbook file this function creates.
        [Parameter(Mandatory)]
        [string]$Path
    )

    # Fail clearly when the lab's only external module is unavailable.
    if (-not (Get-Module -ListAvailable -Name ImportExcel)) {
        throw 'The ImportExcel module is required.'
    }
    Import-Module ImportExcel -ErrorAction Stop -WarningAction SilentlyContinue

    # Enrich each fictional renewal with deterministic scheduling fields.
    $report = foreach ($item in $Renewal) {
        $renewalDate = [datetime]$item.RenewalDate
        $daysRemaining = [int][math]::Floor(($renewalDate.Date - $AsOfDate.Date).TotalDays)

        # Assign a small set of statuses that work well for filtering and formatting.
        $status = if ($daysRemaining -lt 0) {
            'Expired'
        }
        elseif ($daysRemaining -le 30) {
            'Due Soon'
        }
        else {
            'Scheduled'
        }

        # Emit only the columns intended for the finished workbook.
        [pscustomobject]@{
            Service       = [string]$item.Service
            Owner         = [string]$item.Owner
            RenewalDate   = $renewalDate.Date
            DaysRemaining = $daysRemaining
            AnnualCost    = [decimal]$item.AnnualCost
            Status        = $status
        }
    }

    # Export the records as a named table and retain the package for final styling.
    $excel = $report |
        Sort-Object RenewalDate |
        Export-Excel -Path $Path -WorksheetName 'Renewals' -TableName 'RenewalTable' `
            -TableStyle Medium2 -FreezeTopRow -BoldTopRow -PassThru

    # Apply readable formats to the date and currency columns.
    $worksheet = $excel.Workbook.Worksheets['Renewals']
    Set-ExcelRange -Worksheet $worksheet -Range 'C:C' -NumberFormat 'yyyy-mm-dd'
    Set-ExcelRange -Worksheet $worksheet -Range 'E:E' -NumberFormat '$#,##0.00'

    # Set practical widths explicitly so the workbook is portable across cloud hosts.
    Set-ExcelRange -Worksheet $worksheet -Range 'A:A' -Width 22
    Set-ExcelRange -Worksheet $worksheet -Range 'B:B' -Width 16
    Set-ExcelRange -Worksheet $worksheet -Range 'C:F' -Width 18

    # Color the status column so urgent items are visible at a glance.
    Add-ConditionalFormatting -Worksheet $worksheet -Range 'F2:F1048576' `
        -RuleType ContainsText -ConditionValue 'Expired' -BackgroundColor 'LightPink' -Bold
    Add-ConditionalFormatting -Worksheet $worksheet -Range 'F2:F1048576' `
        -RuleType ContainsText -ConditionValue 'Due Soon' -BackgroundColor 'LightYellow' -Bold
    Add-ConditionalFormatting -Worksheet $worksheet -Range 'F2:F1048576' `
        -RuleType ContainsText -ConditionValue 'Scheduled' -BackgroundColor 'LightGreen'

    # Save and close the package before returning a concise execution summary.
    Close-ExcelPackage -ExcelPackage $excel

    [pscustomobject]@{
        Path          = $Path
        RecordCount   = $report.Count
        ExpiredCount  = @($report | Where-Object Status -eq 'Expired').Count
        DueSoonCount  = @($report | Where-Object Status -eq 'Due Soon').Count
        ScheduledCount = @($report | Where-Object Status -eq 'Scheduled').Count
        TotalAnnualCost = [math]::Round(($report | Measure-Object AnnualCost -Sum).Sum, 2)
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

$ErrorActionPreference = 'Stop'

# Load the AI-generated scale function.
. "$PSScriptRoot/solution.ps1"

# Exercise different sizes, signs, and decimal precisions.
$examples = @(
    [pscustomobject]@{ Name = 'Queue depth'; Minimum = 18; Maximum = 93; Target = 6; IncludeZero = $true }
    [pscustomobject]@{ Name = 'Temperature drift'; Minimum = -2.8; Maximum = 7.4; Target = 7; IncludeZero = $false }
    [pscustomobject]@{ Name = 'Error rate'; Minimum = 0.012; Maximum = 0.087; Target = 5; IncludeZero = $true }
)

foreach ($example in $examples) {
    $scale = Get-FriendlyAxisScale -Minimum $example.Minimum -Maximum $example.Maximum `
        -TargetTickCount $example.Target -IncludeZero:$example.IncludeZero

    [pscustomobject]@{
        Metric = $example.Name
        Bounds = "$($scale.AxisMinimum) to $($scale.AxisMaximum)"
        Interval = $scale.Interval
        TickCount = $scale.TickCount
        Labels = $scale.Labels -join ', '
    } | Format-List
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

function Get-FriendlyAxisScale {
    [CmdletBinding()]
    param(
        # The smallest and largest values that must fit on the axis.
        [Parameter(Mandatory)]
        [double]$Minimum,
        [Parameter(Mandatory)]
        [double]$Maximum,

        # This is a target, because clean intervals matter more than an exact count.
        [ValidateRange(2, 20)]
        [int]$TargetTickCount = 6,

        # This switch is useful for charts where distance from zero has meaning.
        [switch]$IncludeZero
    )

    # Reject an empty or reversed numeric range before calculating an interval.
    if ($Maximum -le $Minimum) {
        throw 'Maximum must be greater than Minimum.'
    }

    # Expand the source range to zero when the caller requests that visual baseline.
    $workingMinimum = if ($IncludeZero -and $Minimum -gt 0) { 0 } else { $Minimum }
    $workingMaximum = if ($IncludeZero -and $Maximum -lt 0) { 0 } else { $Maximum }

    # Estimate an interval, then split it into a power of ten and a small fraction.
    $rawInterval = ($workingMaximum - $workingMinimum) / ($TargetTickCount - 1)
    $magnitude = [math]::Pow(10, [math]::Floor([math]::Log10($rawInterval)))
    $fraction = $rawInterval / $magnitude

    # Choose the next familiar interval so labels stay readable and cover the range.
    $niceFraction = if ($fraction -le 1) {
        1
    }
    elseif ($fraction -le 2) {
        2
    }
    elseif ($fraction -le 5) {
        5
    }
    else {
        10
    }
    $interval = $niceFraction * $magnitude

    # Round outward so the original minimum and maximum always remain visible.
    $axisMinimum = [math]::Floor($workingMinimum / $interval) * $interval
    $axisMaximum = [math]::Ceiling($workingMaximum / $interval) * $interval

    # Derive an appropriate label precision for intervals smaller than one.
    $decimals = if ($interval -lt 1) {
        [math]::Max(0, [int](-[math]::Floor([math]::Log10($interval))))
    }
    else {
        0
    }

    # Build both numeric tick values and ready-to-display invariant labels.
    $ticks = [System.Collections.Generic.List[double]]::new()
    $labels = [System.Collections.Generic.List[string]]::new()
    for ($value = $axisMinimum; $value -le ($axisMaximum + ($interval / 1000)); $value += $interval) {
        $rounded = [math]::Round($value, $decimals)
        $ticks.Add($rounded)
        $labels.Add($rounded.ToString("F$decimals", [cultureinfo]::InvariantCulture))
    }

    # Return one object that a charting layer can consume without reparsing text.
    [pscustomobject]@{
        SourceMinimum = $Minimum
        SourceMaximum = $Maximum
        AxisMinimum   = $axisMinimum
        AxisMaximum   = $axisMaximum
        Interval      = $interval
        TickCount     = $ticks.Count
        Ticks         = $ticks.ToArray()
        Labels        = $labels.ToArray()
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

$ErrorActionPreference = 'Stop'

# Load the AI-generated matrix functions.
. "$PSScriptRoot/solution.ps1"

# Describe the four corners of a fictional layout panel.
$points = @(
    [pscustomobject]@{ Name = 'TopLeft'; X = 0; Y = 0 }
    [pscustomobject]@{ Name = 'TopRight'; X = 4; Y = 0 }
    [pscustomobject]@{ Name = 'BottomRight'; X = 4; Y = 2 }
    [pscustomobject]@{ Name = 'BottomLeft'; X = 0; Y = 2 }
)

# Scale first, rotate second, and translate the finished shape last.
$operations = @(
    [pscustomobject]@{ Type = 'Scale'; X = 1.5; Y = 2 }
    [pscustomobject]@{ Type = 'Rotate'; Degrees = 30 }
    [pscustomobject]@{ Type = 'Translate'; X = 10; Y = 5 }
)

$result = Invoke-PointTransform -Point $points -Operation $operations
'Combined matrix'
$result.Matrix | Format-List
'Transformed points'
$result.Points | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

function New-AffineMatrix {
    # Create a compact matrix object using the common six-value 2D representation.
    param(
        [double]$A = 1,
        [double]$B = 0,
        [double]$C = 0,
        [double]$D = 1,
        [double]$Tx = 0,
        [double]$Ty = 0
    )

    [pscustomobject]@{ A = $A; B = $B; C = $C; D = $D; Tx = $Tx; Ty = $Ty }
}

function Join-AffineMatrix {
    # Multiply two matrices so Right is applied first and Left is applied second.
    param(
        [Parameter(Mandatory)][psobject]$Left,
        [Parameter(Mandatory)][psobject]$Right
    )

    New-AffineMatrix `
        -A (($Left.A * $Right.A) + ($Left.C * $Right.B)) `
        -B (($Left.B * $Right.A) + ($Left.D * $Right.B)) `
        -C (($Left.A * $Right.C) + ($Left.C * $Right.D)) `
        -D (($Left.B * $Right.C) + ($Left.D * $Right.D)) `
        -Tx (($Left.A * $Right.Tx) + ($Left.C * $Right.Ty) + $Left.Tx) `
        -Ty (($Left.B * $Right.Tx) + ($Left.D * $Right.Ty) + $Left.Ty)
}

function Invoke-PointTransform {
    [CmdletBinding()]
    param(
        # Named input points make the output easier to compare with the source shape.
        [Parameter(Mandatory)]
        [psobject[]]$Point,

        # Operations are applied in the exact order supplied by the caller.
        [Parameter(Mandatory)]
        [psobject[]]$Operation
    )

    # Start with an identity matrix that leaves every coordinate unchanged.
    $combined = New-AffineMatrix

    foreach ($item in $Operation) {
        # Build the matrix for this operation without changing the input objects.
        $operationMatrix = switch ([string]$item.Type) {
            'Scale' {
                New-AffineMatrix -A ([double]$item.X) -D ([double]$item.Y)
                break
            }
            'Rotate' {
                $radians = [double]$item.Degrees * [math]::PI / 180
                $cosine = [math]::Cos($radians)
                $sine = [math]::Sin($radians)
                New-AffineMatrix -A $cosine -B $sine -C (-$sine) -D $cosine
                break
            }
            'Translate' {
                New-AffineMatrix -Tx ([double]$item.X) -Ty ([double]$item.Y)
                break
            }
            default {
                throw "Unsupported transform type '$($item.Type)'."
            }
        }

        # Pre-multiply so the operations retain the caller's left-to-right order.
        $combined = Join-AffineMatrix -Left $operationMatrix -Right $combined
    }

    # Apply the one combined matrix to every point and round only the public result.
    $transformed = foreach ($item in $Point) {
        $x = [double]$item.X
        $y = [double]$item.Y
        [pscustomobject]@{
            Name = [string]$item.Name
            SourceX = $x
            SourceY = $y
            ResultX = [math]::Round(($combined.A * $x) + ($combined.C * $y) + $combined.Tx, 3)
            ResultY = [math]::Round(($combined.B * $x) + ($combined.D * $y) + $combined.Ty, 3)
        }
    }

    # Return the reusable matrix and transformed points together as one result.
    [pscustomobject]@{
        Matrix = [pscustomobject]@{
            A = [math]::Round($combined.A, 6)
            B = [math]::Round($combined.B, 6)
            C = [math]::Round($combined.C, 6)
            D = [math]::Round($combined.D, 6)
            Tx = [math]::Round($combined.Tx, 6)
            Ty = [math]::Round($combined.Ty, 6)
        }
        Points = @($transformed)
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

$ErrorActionPreference = 'Stop'

# Load the AI-generated compatibility function.
. "$PSScriptRoot/solution.ps1"

# Define a fictional runtime inventory instead of probing the current machine.
$availableRuntimes = [version[]]@('7.2.24', '7.4.13', '7.6.6')

# Give each sample job a different minimum runtime expectation.
$jobs = @(
    [pscustomobject]@{ Name = 'Archive Indexer'; MinimumVersion = '7.2.0' }
    [pscustomobject]@{ Name = 'Report Composer'; MinimumVersion = '7.4.2' }
    [pscustomobject]@{ Name = 'Parallel Analyzer'; MinimumVersion = '7.6.0' }
    [pscustomobject]@{ Name = 'Future Syntax Check'; MinimumVersion = '7.7.0' }
)

# Put unresolved jobs first, then render each decision without clipped columns.
$report = Get-RuntimeCompatibilityReport -Job $jobs -AvailableRuntime $availableRuntimes |
    Sort-Object @{ Expression = { $_.Status -eq 'Ready' } }, Job

foreach ($item in $report) {
    $item | Format-List Job, MinimumVersion, SelectedRuntime, Status, Reason
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

function Get-RuntimeCompatibilityReport {
    [CmdletBinding()]
    param(
        # Each job supplies a name and the minimum PowerShell version it requires.
        [Parameter(Mandatory)]
        [psobject[]]$Job,

        # The inventory is passed in explicitly so the function never inspects the host.
        [Parameter(Mandatory)]
        [version[]]$AvailableRuntime
    )

    # Normalize and sort the inventory once so selection is deterministic.
    $runtimeInventory = @($AvailableRuntime | Sort-Object -Unique)
    if ($runtimeInventory.Count -eq 0) {
        throw 'At least one available runtime is required.'
    }

    foreach ($item in $Job) {
        if ([string]::IsNullOrWhiteSpace([string]$item.Name)) {
            throw 'Every job must have a name.'
        }

        # Convert the declared requirement to a real version for safe comparisons.
        $minimumVersion = [version]$item.MinimumVersion

        # Choose the oldest sufficient runtime to avoid demanding unnecessary upgrades.
        $selected = $runtimeInventory |
            Where-Object { $_ -ge $minimumVersion } |
            Select-Object -First 1

        # Explain both successful matches and gaps in plain language.
        if ($null -ne $selected) {
            $status = 'Ready'
            $reason = "PowerShell $selected meets minimum $minimumVersion."
        }
        else {
            $status = 'Upgrade Required'
            $reason = "No available runtime meets minimum $minimumVersion."
        }

        # Emit structured output suitable for sorting, exporting, or CI policy checks.
        [pscustomobject]@{
            Job             = [string]$item.Name
            MinimumVersion  = $minimumVersion.ToString()
            SelectedRuntime = if ($selected) { $selected.ToString() } else { $null }
            Status          = $status
            Reason          = $reason
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated estimator from the neighboring solution file.
. "$PSScriptRoot/solution.ps1"

# Create fictional transfer requests entirely in memory.
$transfers = @(
    [pscustomobject]@{ Name = 'Training archive'; SizeGB = 12.5 }
    [pscustomobject]@{ Name = 'Photo library'; SizeGB = 48.0 }
    [pscustomobject]@{ Name = 'Daily snapshot'; SizeGB = 3.25 }
)

# Estimate durations on a 200 Mbps link operating at 85 percent efficiency.
$transfers |
    Get-DataTransferEstimate -BandwidthMbps 200 -EfficiencyPercent 85 |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Get-DataTransferEstimate {
    <#
    .SYNOPSIS
    Estimates transfer durations from data size and usable network throughput.
    #>
    [CmdletBinding()]
    param(
        # Objects must expose Name and SizeGB properties.
        [Parameter(Mandatory, ValueFromPipeline)]
        [object[]] $Transfer,

        # Nominal link speed in megabits per second.
        [Parameter(Mandatory)]
        [ValidateRange(0.01, 1000000)]
        [decimal] $BandwidthMbps,

        # Percentage of nominal bandwidth expected to carry payload data.
        [ValidateRange(1, 100)]
        [decimal] $EfficiencyPercent = 85
    )

    begin {
        # Convert the efficiency percentage into a multiplier once.
        $efficiency = $EfficiencyPercent / 100
        $effectiveMbps = $BandwidthMbps * $efficiency
    }

    process {
        foreach ($item in $Transfer) {
            # Validate each transfer independently so invalid sizes are identified clearly.
            $sizeGB = [decimal]$item.SizeGB
            if ($sizeGB -lt 0) {
                throw "Transfer '$($item.Name)' has a negative SizeGB value."
            }

            # Decimal gigabytes contain eight billion bits; Mbps is one million bits per second.
            $totalBits = $sizeGB * 8000000000
            $bitsPerSecond = $effectiveMbps * 1000000
            $seconds = if ($sizeGB -eq 0) { [decimal]0 } else { $totalBits / $bitsPerSecond }

            # Convert the rounded seconds to a TimeSpan for a compact readable duration.
            $roundedSeconds = [math]::Round([double]$seconds, 2)
            $duration = [timespan]::FromSeconds([math]::Round([double]$seconds))

            # Emit structured data so callers can format or export it as needed.
            [pscustomobject][ordered]@{
                Name                 = [string]$item.Name
                SizeGB               = $sizeGB
                EffectiveMbps        = [math]::Round([double]$effectiveMbps, 2)
                EstimatedSeconds     = $roundedSeconds
                EstimatedDuration    = $duration.ToString('hh\:mm\:ss')
            }
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated workbook function.
. "$PSScriptRoot/solution.ps1"

# Prepare fictional work logs with several teams and work categories.
$workLogs = @(
    [pscustomobject]@{ Date = '2026-09-14'; Team = 'Atlas'; WorkType = 'Build'; Hours = 6.5 }
    [pscustomobject]@{ Date = '2026-09-14'; Team = 'Atlas'; WorkType = 'Support'; Hours = 2.0 }
    [pscustomobject]@{ Date = '2026-09-15'; Team = 'Beacon'; WorkType = 'Build'; Hours = 5.0 }
    [pscustomobject]@{ Date = '2026-09-15'; Team = 'Beacon'; WorkType = 'Research'; Hours = 3.5 }
    [pscustomobject]@{ Date = '2026-09-16'; Team = 'Cygnus'; WorkType = 'Support'; Hours = 4.0 }
    [pscustomobject]@{ Date = '2026-09-16'; Team = 'Cygnus'; WorkType = 'Research'; Hours = 4.5 }
)

# Use a unique temporary path so the run never overwrites another workbook.
$workbookPath = Join-Path ([System.IO.Path]::GetTempPath()) "team-hours-$([guid]::NewGuid().ToString('N')).xlsx"

# Build the workbook and independently read the source rows back from disk.
$summary = New-TeamHoursPivotWorkbook -WorkLog $workLogs -Path $workbookPath
$readBack = Import-Excel -Path $workbookPath -WorksheetName 'Work Log'

# Display both the workbook metadata and read-back team totals.
$summary | Format-List
$readBack | Group-Object Team | Sort-Object Name | Select-Object Name, Count | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function New-TeamHoursPivotWorkbook {
    <#
    .SYNOPSIS
    Builds a work-log workbook with a pivot summary and chart.
    #>
    [CmdletBinding()]
    param(
        # Work-log rows must expose Date, Team, WorkType, and Hours.
        [Parameter(Mandatory)]
        [object[]] $WorkLog,

        # Destination for the generated workbook.
        [Parameter(Mandatory)]
        [ValidatePattern('\.xlsx$')]
        [string] $Path
    )

    # Load ImportExcel while suppressing only its platform-specific autosize warning.
    $savedWarningPreference = $global:WarningPreference
    try {
        $global:WarningPreference = 'SilentlyContinue'
        Import-Module ImportExcel -ErrorAction Stop
    }
    finally {
        $global:WarningPreference = $savedWarningPreference
    }

    # Normalize the supplied records into a stable shape for Excel and the pivot cache.
    $rows = foreach ($item in $WorkLog) {
        $hours = [double]$item.Hours
        if ($hours -lt 0) {
            throw 'Hours cannot be negative.'
        }
        [pscustomobject][ordered]@{
            Date     = [datetime]$item.Date
            Team     = [string]$item.Team
            WorkType = [string]$item.WorkType
            Hours    = $hours
        }
    }

    # Export the source table and create a pivot table with a clustered-column chart.
    $package = $rows | Export-Excel -Path $Path -WorksheetName 'Work Log' `
        -TableName 'TeamWorkLog' -TableStyle Medium6 -FreezeTopRow `
        -IncludePivotTable -PivotTableName 'TeamHoursPivot' `
        -PivotRows 'Team' -PivotColumns 'WorkType' -PivotData @{ Hours = 'Sum' } `
        -IncludePivotChart -PivotChartType ColumnClustered -PassThru

    # Apply predictable source-column widths without platform drawing dependencies.
    $sourceSheet = $package.Workbook.Worksheets['Work Log']
    $sourceSheet.Column(1).Width = 14
    $sourceSheet.Column(2).Width = 18
    $sourceSheet.Column(3).Width = 18
    $sourceSheet.Column(4).Width = 12

    # Collect metadata before closing and saving the package.
    $pivotCount = @($package.Workbook.Worksheets | ForEach-Object { $_.PivotTables.Count } | Measure-Object -Sum).Sum
    $chartCount = @($package.Workbook.Worksheets | ForEach-Object { $_.Drawings.Count } | Measure-Object -Sum).Sum
    $worksheetCount = $package.Workbook.Worksheets.Count
    Close-ExcelPackage -ExcelPackage $package

    # Return a concise summary for logging and validation.
    [pscustomobject][ordered]@{
        Workbook  = $Path
        Rows      = $rows.Count
        Teams     = @($rows.Team | Sort-Object -Unique).Count
        Worksheets = $worksheetCount
        PivotTables = $pivotCount
        Charts    = $chartCount
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated session builder.
. "$PSScriptRoot/solution.ps1"

# Supply fictional events in deliberately mixed order.
$activities = @(
    [pscustomobject]@{ Event = 'Export report'; Timestamp = '2026-09-18T10:05:00' }
    [pscustomobject]@{ Event = 'Open dashboard'; Timestamp = '2026-09-18T09:00:00' }
    [pscustomobject]@{ Event = 'Filter region'; Timestamp = '2026-09-18T09:08:00' }
    [pscustomobject]@{ Event = 'Review alert'; Timestamp = '2026-09-18T11:15:00' }
    [pscustomobject]@{ Event = 'Acknowledge alert'; Timestamp = '2026-09-18T11:22:00' }
)

# A gap greater than 30 minutes starts a new activity session.
Group-ActivitySession -Activity $activities -IdleMinutes 30 |
    Format-Table Event, Timestamp, Session, MinutesSincePrior -AutoSize |
    Out-String -Width 160

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Group-ActivitySession {
    <#
    .SYNOPSIS
    Assigns chronological activity records to idle-gap sessions.
    #>
    [CmdletBinding()]
    param(
        # Activity objects must expose Event and Timestamp properties.
        [Parameter(Mandatory)]
        [object[]] $Activity,

        # A larger gap starts a new session.
        [ValidateRange(1, 1440)]
        [int] $IdleMinutes = 30
    )

    # Normalize and sort the events so out-of-order input is handled consistently.
    $ordered = @($Activity | ForEach-Object {
        [pscustomobject][ordered]@{
            Event     = [string]$_.Event
            Timestamp = [datetime]$_.Timestamp
        }
    } | Sort-Object Timestamp)

    # Start numbering at one when the first event is encountered.
    $session = 0
    $previousTimestamp = $null

    foreach ($item in $ordered) {
        # The first event has no gap; later events measure from the previous timestamp.
        $gapMinutes = if ($null -eq $previousTimestamp) {
            $null
        }
        else {
            [math]::Round(($item.Timestamp - $previousTimestamp).TotalMinutes, 2)
        }

        # Begin a session for the first event or after a gap beyond the threshold.
        if ($session -eq 0 -or $gapMinutes -gt $IdleMinutes) {
            $session++
        }

        # Emit one structured row for each activity.
        [pscustomobject][ordered]@{
            Event              = $item.Event
            Timestamp          = $item.Timestamp
            Session            = $session
            MinutesSincePrior  = $gapMinutes
        }

        $previousTimestamp = $item.Timestamp
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated configuration resolver.
. "$PSScriptRoot/solution.ps1"

# Define fictional settings at three precedence levels.
$defaults = [ordered]@{
    Theme = 'Light'
    PageSize = 25
    RetryCount = 2
}
$environment = [ordered]@{
    PageSize = 50
    Region = 'East'
}
$user = [ordered]@{
    Theme = 'Dark'
    RetryCount = 4
}

# Resolve the final values and retain their winning source.
Resolve-ConfigurationPrecedence -Defaults $defaults -Environment $environment -User $user |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Resolve-ConfigurationPrecedence {
    <#
    .SYNOPSIS
    Resolves layered configuration and reports the source of each winning value.
    #>
    [CmdletBinding()]
    param(
        # Baseline values used when no higher layer supplies the key.
        [Parameter(Mandatory)]
        [System.Collections.IDictionary] $Defaults,

        # Environment-specific overrides.
        [Parameter(Mandatory)]
        [System.Collections.IDictionary] $Environment,

        # Highest-precedence user overrides.
        [Parameter(Mandatory)]
        [System.Collections.IDictionary] $User
    )

    # Capture keys in first-seen order while preventing duplicates.
    $keys = [System.Collections.Generic.List[string]]::new()
    $seen = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
    foreach ($layer in @($Defaults, $Environment, $User)) {
        foreach ($key in $layer.Keys) {
            if ($seen.Add([string]$key)) {
                $keys.Add([string]$key)
            }
        }
    }

    foreach ($key in $keys) {
        # Check layers from highest to lowest precedence.
        if ($User.Contains($key)) {
            $value = $User[$key]
            $source = 'User'
        }
        elseif ($Environment.Contains($key)) {
            $value = $Environment[$key]
            $source = 'Environment'
        }
        else {
            $value = $Defaults[$key]
            $source = 'Defaults'
        }

        # Emit provenance with each resolved setting.
        [pscustomobject][ordered]@{
            Key    = $key
            Value  = $value
            Source = $source
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated allocator.
. "$PSScriptRoot/solution.ps1"

# Create fictional work items with varied effort estimates.
$items = @(
    [pscustomobject]@{ Name = 'Prepare demo'; EstimatedMinutes = 80 }
    [pscustomobject]@{ Name = 'Review notes'; EstimatedMinutes = 25 }
    [pscustomobject]@{ Name = 'Build sample'; EstimatedMinutes = 65 }
    [pscustomobject]@{ Name = 'Check output'; EstimatedMinutes = 35 }
    [pscustomobject]@{ Name = 'Write summary'; EstimatedMinutes = 45 }
    [pscustomobject]@{ Name = 'Package files'; EstimatedMinutes = 20 }
)

# Allocate the queue across three fictional workers.
Get-BalancedWorkAllocation -WorkItem $items -Worker @('Avery', 'Blake', 'Casey') |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Get-BalancedWorkAllocation {
    <#
    .SYNOPSIS
    Assigns estimated work to the currently least-loaded worker.
    #>
    [CmdletBinding()]
    param(
        # Work items must expose Name and EstimatedMinutes properties.
        [Parameter(Mandatory)]
        [object[]] $WorkItem,

        # Worker names are used in the supplied order to resolve load ties.
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [string[]] $Worker
    )

    # Worker names must be unique so assignments remain unambiguous.
    if (($Worker | Sort-Object -Unique).Count -ne $Worker.Count) {
        throw 'Worker names must be unique.'
    }

    # Track each worker's running load and original tie-break position.
    $loads = for ($index = 0; $index -lt $Worker.Count; $index++) {
        [pscustomobject]@{
            Worker       = $Worker[$index]
            TotalMinutes = 0
            Order        = $index
        }
    }

    # Normalize estimates and process the longest items first for better balance.
    $orderedItems = @($WorkItem | ForEach-Object {
        $minutes = [int]$_.EstimatedMinutes
        if ($minutes -lt 0) {
            throw "Work item '$($_.Name)' has a negative estimate."
        }
        [pscustomobject]@{
            Name             = [string]$_.Name
            EstimatedMinutes = $minutes
        }
    } | Sort-Object @{ Expression = 'EstimatedMinutes'; Descending = $true }, Name)

    foreach ($item in $orderedItems) {
        # Choose the lightest worker, using original worker order for ties.
        $target = $loads | Sort-Object TotalMinutes, Order | Select-Object -First 1
        $target.TotalMinutes += $item.EstimatedMinutes

        # Emit the decision and the worker's new running total.
        [pscustomobject][ordered]@{
            WorkItem           = $item.Name
            EstimatedMinutes   = $item.EstimatedMinutes
            Worker             = $target.Worker
            WorkerTotalMinutes = $target.TotalMinutes
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated function from the neighboring solution file.
. "$PSScriptRoot/solution.ps1"

# Create a fictional nested service profile entirely in memory.
$serviceProfile = [pscustomobject][ordered]@{
    Name = 'Northwind Alerts'
    Enabled = $true
    Owners = @('Mina', 'Luis')
    Routing = [pscustomobject][ordered]@{
        Region = 'East'
        Channels = @(
            [pscustomobject]@{ Name = 'Email'; Priority = 1 }
            [pscustomobject]@{ Name = 'Chat'; Priority = 2 }
        )
    }
}

# Pass the object and depth boundary into the generated solution.
Get-ObjectPropertyMap -InputObject $serviceProfile -MaxDepth 5 |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Get-ObjectPropertyMap {
    <#
    .SYNOPSIS
    Flattens a nested object into inspectable path, type, and value rows.
    #>
    [CmdletBinding()]
    param(
        # The object whose properties will be inspected.
        [Parameter(Mandatory, ValueFromPipeline)]
        [AllowNull()]
        [object] $InputObject,

        # The deepest level that will be expanded.
        [ValidateRange(0, 20)]
        [int] $MaxDepth = 4
    )

    begin {
        # Keep a reference-based set so a circular object graph cannot recurse forever.
        $visited = [System.Collections.Generic.HashSet[int]]::new()

        # Recursively inspect a value and emit one row for each leaf or boundary.
        function Expand-Value {
            param(
                [AllowNull()][object] $Value,
                [string] $Path,
                [int] $Depth
            )

            # Represent null explicitly because it has no runtime type.
            if ($null -eq $Value) {
                [pscustomobject]@{ Path = $Path; Type = 'null'; Value = '<null>' }
                return
            }

            # Treat common scalar types as leaves rather than expanding their properties.
            $isScalar = $Value -is [string] -or
                $Value -is [ValueType] -or
                $Value -is [datetime]

            if ($isScalar) {
                [pscustomobject]@{ Path = $Path; Type = $Value.GetType().Name; Value = [string]$Value }
                return
            }

            # Stop expansion at the requested boundary and clearly label the row.
            if ($Depth -ge $MaxDepth) {
                [pscustomobject]@{ Path = $Path; Type = $Value.GetType().Name; Value = '<max depth>' }
                return
            }

            # Use the runtime identity hash to detect repeated reference objects.
            $identity = [System.Runtime.CompilerServices.RuntimeHelpers]::GetHashCode($Value)
            if (-not $visited.Add($identity)) {
                [pscustomobject]@{ Path = $Path; Type = $Value.GetType().Name; Value = '<already visited>' }
                return
            }

            # Expand enumerable values by their zero-based positions.
            if ($Value -is [System.Collections.IEnumerable] -and $Value -isnot [System.Collections.IDictionary]) {
                $index = 0
                foreach ($item in $Value) {
                    Expand-Value -Value $item -Path "$Path[$index]" -Depth ($Depth + 1)
                    $index++
                }
                return
            }

            # Expand dictionary keys in their enumeration order.
            if ($Value -is [System.Collections.IDictionary]) {
                foreach ($key in $Value.Keys) {
                    Expand-Value -Value $Value[$key] -Path "$Path.$key" -Depth ($Depth + 1)
                }
                return
            }

            # Expand PowerShell object properties in the order exposed by PSObject.
            foreach ($property in $Value.PSObject.Properties) {
                Expand-Value -Value $property.Value -Path "$Path.$($property.Name)" -Depth ($Depth + 1)
            }
        }
    }

    process {
        # Begin every input object at a stable root path.
        Expand-Value -Value $InputObject -Path '$' -Depth 0
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated workbook function.
. "$PSScriptRoot/solution.ps1"

# Prepare fictional ticket data with both healthy and breached examples.
$tickets = @(
    [pscustomobject]@{ Ticket = 'SR-1042'; Team = 'Identity'; Priority = 'High'; AgeHours = 5; SlaHours = 8 }
    [pscustomobject]@{ Ticket = 'SR-1043'; Team = 'Network'; Priority = 'Medium'; AgeHours = 29; SlaHours = 24 }
    [pscustomobject]@{ Ticket = 'SR-1044'; Team = 'Apps'; Priority = 'Low'; AgeHours = 16; SlaHours = 48 }
    [pscustomobject]@{ Ticket = 'SR-1045'; Team = 'Identity'; Priority = 'High'; AgeHours = 11; SlaHours = 8 }
)

# Use a unique temporary path so the run never overwrites another workbook.
$workbookPath = Join-Path ([System.IO.Path]::GetTempPath()) "sla-review-$([guid]::NewGuid().ToString('N')).xlsx"

# Create the workbook, then independently read it back to verify the contents.
$summary = New-SlaBreachWorkbook -Ticket $tickets -Path $workbookPath
$importedRows = Import-Excel -Path $workbookPath -WorksheetName 'SLA Review'

# Show the generated summary and a read-back status count.
$summary | Format-List
$importedRows | Group-Object Status | Sort-Object Name | Select-Object Name, Count | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function New-SlaBreachWorkbook {
    <#
    .SYNOPSIS
    Creates a formatted SLA review workbook from supplied ticket records.
    #>
    [CmdletBinding()]
    param(
        # Fictional ticket records containing Ticket, Team, Priority, AgeHours, and SlaHours.
        [Parameter(Mandatory)]
        [object[]] $Ticket,

        # Destination for the generated .xlsx workbook.
        [Parameter(Mandatory)]
        [ValidatePattern('\.xlsx$')]
        [string] $Path
    )

    # Stop immediately if the required module cannot be loaded.
    $savedWarningPreference = $global:WarningPreference
    try {
        $global:WarningPreference = 'SilentlyContinue'
        Import-Module ImportExcel -ErrorAction Stop -WarningAction SilentlyContinue
    }
    finally {
        $global:WarningPreference = $savedWarningPreference
    }

    # Transform the source records into a stable, workbook-friendly shape.
    $rows = foreach ($item in $Ticket) {
        $remaining = [double]$item.SlaHours - [double]$item.AgeHours
        [pscustomobject][ordered]@{
            Ticket        = [string]$item.Ticket
            Team          = [string]$item.Team
            Priority      = [string]$item.Priority
            AgeHours      = [double]$item.AgeHours
            SlaHours      = [double]$item.SlaHours
            RemainingHours = $remaining
            Status        = if ($remaining -lt 0) { 'Breached' } else { 'Within SLA' }
        }
    }

    # Export the rows and retain the package so worksheet styling can be applied.
    $package = $rows | Export-Excel -Path $Path -WorksheetName 'SLA Review' `
        -TableName 'SlaReview' -TableStyle Medium2 -FreezeTopRow -PassThru

    # Retrieve the newly created worksheet from the in-memory package.
    $worksheet = $package.Workbook.Worksheets['SLA Review']

    # Apply predictable column widths without relying on platform drawing libraries.
    foreach ($columnNumber in 1..7) {
        $worksheet.Column($columnNumber).Width = if ($columnNumber -eq 2) { 18 } else { 14 }
    }

    # Highlight breached status cells so urgent rows are easy to spot.
    if ($rows.Count -gt 0) {
        Add-ConditionalFormatting -Worksheet $worksheet -Address "G2:G$($rows.Count + 1)" `
            -RuleType Equal -ConditionValue '"Breached"' -BackgroundColor LightPink -ForegroundColor DarkRed
    }

    # Save and close the workbook package cleanly.
    Close-ExcelPackage -ExcelPackage $package

    # Return a concise object that is convenient for logging and validation.
    [pscustomobject][ordered]@{
        Workbook = $Path
        Tickets  = $rows.Count
        Breached = @($rows | Where-Object Status -eq 'Breached').Count
        WithinSla = @($rows | Where-Object Status -eq 'Within SLA').Count
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated schedule function.
. "$PSScriptRoot/solution.ps1"

# Preview six retries with a short initial delay and a five-second cap.
Get-RetryBackoffSchedule -Attempts 6 -InitialDelaySeconds 0.5 -Multiplier 2 -MaximumDelaySeconds 5 |
    Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Get-RetryBackoffSchedule {
    <#
    .SYNOPSIS
    Calculates a capped exponential retry schedule without waiting.
    #>
    [CmdletBinding()]
    param(
        # Number of retry attempts to include.
        [Parameter(Mandatory)]
        [ValidateRange(1, 100)]
        [int] $Attempts,

        # Delay before the first retry, in seconds.
        [ValidateRange(0.001, 86400)]
        [double] $InitialDelaySeconds = 1,

        # Factor applied to the delay after each attempt.
        [ValidateRange(1, 10)]
        [double] $Multiplier = 2,

        # Upper boundary for any single delay.
        [ValidateRange(0.001, 86400)]
        [double] $MaximumDelaySeconds = 30
    )

    # The cap must not be smaller than the first requested delay.
    if ($MaximumDelaySeconds -lt $InitialDelaySeconds) {
        throw 'MaximumDelaySeconds must be greater than or equal to InitialDelaySeconds.'
    }

    # Track cumulative time so callers can assess the complete retry budget.
    $elapsed = 0.0

    foreach ($attempt in 1..$Attempts) {
        # Grow exponentially, then enforce the configured maximum.
        $uncapped = $InitialDelaySeconds * [math]::Pow($Multiplier, $attempt - 1)
        $delay = [math]::Min($uncapped, $MaximumDelaySeconds)
        $elapsed += $delay

        # Emit numeric values rounded for stable display and downstream use.
        [pscustomobject][ordered]@{
            Attempt              = $attempt
            DelaySeconds         = [math]::Round($delay, 3)
            TotalElapsedSeconds  = [math]::Round($elapsed, 3)
            Capped               = $uncapped -gt $MaximumDelaySeconds
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated dependency planner.
. "$PSScriptRoot/solution.ps1"

# Describe a fictional release process with parallel-friendly dependencies.
$tasks = @(
    [pscustomobject]@{ Name = 'Package'; DependsOn = @('Test') }
    [pscustomobject]@{ Name = 'Lint'; DependsOn = @() }
    [pscustomobject]@{ Name = 'Publish docs'; DependsOn = @('Test') }
    [pscustomobject]@{ Name = 'Test'; DependsOn = @('Lint', 'Compile') }
    [pscustomobject]@{ Name = 'Compile'; DependsOn = @() }
    [pscustomobject]@{ Name = 'Release'; DependsOn = @('Package', 'Publish docs') }
)

# Plan the waves and display the parameters represented by the sample tasks.
Get-DependencyWave -Task $tasks | Format-Table -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Get-DependencyWave {
    <#
    .SYNOPSIS
    Groups dependency-linked tasks into safe execution waves.
    #>
    [CmdletBinding()]
    param(
        # Task objects must expose Name and DependsOn properties.
        [Parameter(Mandatory)]
        [object[]] $Task
    )

    # Build an ordered lookup while detecting duplicate task names.
    $byName = [ordered]@{}
    foreach ($item in $Task) {
        $name = [string]$item.Name
        if ([string]::IsNullOrWhiteSpace($name)) {
            throw 'Every task must have a non-empty Name.'
        }
        if ($byName.Contains($name)) {
            throw "Duplicate task name: $name"
        }
        $byName[$name] = $item
    }

    # Validate every dependency before planning any waves.
    foreach ($item in $Task) {
        foreach ($dependency in @($item.DependsOn)) {
            if (-not $byName.Contains([string]$dependency)) {
                throw "Task '$($item.Name)' references missing dependency '$dependency'."
            }
        }
    }

    # Track completed names and unresolved tasks separately.
    $completed = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
    $remaining = [System.Collections.Generic.List[object]]::new()
    foreach ($item in $Task) { $remaining.Add($item) }
    $waveNumber = 1

    while ($remaining.Count -gt 0) {
        # A task is ready only when all of its dependencies are complete.
        $ready = @($remaining | Where-Object {
            $dependencies = @($_.DependsOn)
            @($dependencies | Where-Object { -not $completed.Contains([string]$_) }).Count -eq 0
        })

        # No ready tasks means the unresolved portion contains a cycle.
        if ($ready.Count -eq 0) {
            $blocked = ($remaining.Name -join ', ')
            throw "Dependency cycle detected among: $blocked"
        }

        # Emit tasks in their original order with useful planning metadata.
        foreach ($item in $ready) {
            [pscustomobject][ordered]@{
                Wave      = $waveNumber
                Task      = [string]$item.Name
                DependsOn = (@($item.DependsOn) -join ', ')
            }
            [void]$completed.Add([string]$item.Name)
            [void]$remaining.Remove($item)
        }

        $waveNumber++
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

#Requires -Version 7.0

# Load the AI-generated overlap finder.
. "$PSScriptRoot/solution.ps1"

# Create deterministic fictional windows in one local time zone.
$windows = @(
    [pscustomobject]@{ Name = 'Database patch'; Start = [datetime]'2026-10-03T22:00:00'; End = [datetime]'2026-10-03T23:30:00' }
    [pscustomobject]@{ Name = 'Network upgrade'; Start = [datetime]'2026-10-03T23:00:00'; End = [datetime]'2026-10-04T00:00:00' }
    [pscustomobject]@{ Name = 'Cache refresh'; Start = [datetime]'2026-10-03T22:45:00'; End = [datetime]'2026-10-03T23:10:00' }
    [pscustomobject]@{ Name = 'Search reindex'; Start = [datetime]'2026-10-04T00:00:00'; End = [datetime]'2026-10-04T01:00:00' }
)

# Find and display every conflicting pair.
Find-MaintenanceWindowOverlap -Window $windows |
    Format-Table First, Second, OverlapStart, OverlapEnd, OverlapMinutes -AutoSize |
    Out-String -Width 180

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

#Requires -Version 7.0

function Find-MaintenanceWindowOverlap {
    <#
    .SYNOPSIS
    Reports every overlapping pair of supplied maintenance windows.
    #>
    [CmdletBinding()]
    param(
        # Window objects must expose Name, Start, and End properties.
        [Parameter(Mandatory)]
        [object[]] $Window
    )

    # Normalize and validate every supplied range before comparison.
    $normalized = foreach ($item in $Window) {
        $start = [datetime]$item.Start
        $end = [datetime]$item.End
        if ($end -le $start) {
            throw "Window '$($item.Name)' must end after it starts."
        }
        [pscustomobject][ordered]@{
            Name  = [string]$item.Name
            Start = $start
            End   = $end
        }
    }

    # Compare each unique pair exactly once.
    for ($leftIndex = 0; $leftIndex -lt $normalized.Count; $leftIndex++) {
        for ($rightIndex = $leftIndex + 1; $rightIndex -lt $normalized.Count; $rightIndex++) {
            $left = $normalized[$leftIndex]
            $right = $normalized[$rightIndex]

            # The intersection starts later and ends earlier than its inputs.
            $overlapStart = if ($left.Start -gt $right.Start) { $left.Start } else { $right.Start }
            $overlapEnd = if ($left.End -lt $right.End) { $left.End } else { $right.End }

            # Strict comparison makes touching boundaries non-overlapping.
            if ($overlapStart -lt $overlapEnd) {
                [pscustomobject][ordered]@{
                    First          = $left.Name
                    Second         = $right.Name
                    OverlapStart   = $overlapStart
                    OverlapEnd     = $overlapEnd
                    OverlapMinutes = [math]::Round(($overlapEnd - $overlapStart).TotalMinutes, 1)
                }
            }
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Build fictional monthly budget records for a repeatable demonstration.
$sample = @(
    [pscustomobject]@{ Category = 'Cloud'; Plan = 1200; Actual = 1345.50 }
    [pscustomobject]@{ Category = 'Training'; Plan = 800; Actual = 640 }
    [pscustomobject]@{ Category = 'Travel'; Plan = 500; Actual = 500 }
)

# Invoke the generated solution with the sample records.
& "$PSScriptRoot/solution.ps1" -Category $sample |
    Format-Table Category, Plan, Actual, Variance, VariancePct, Direction -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept budget records from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Category
)

begin {
    # Collect records so the report and totals can be emitted together.
    $records = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add each incoming record to the in-memory collection.
    foreach ($item in $Category) {
        $records.Add($item)
    }
}

end {
    # Calculate one variance row for every category.
    $rows = foreach ($item in $records) {
        # Convert numeric values to decimal for predictable currency arithmetic.
        $plan = [decimal]$item.Plan
        $actual = [decimal]$item.Actual
        $variance = $actual - $plan

        # Avoid division by zero when a category has no planned amount.
        $percent = if ($plan -eq 0) { $null } else { [math]::Round(($variance / $plan) * 100, 2) }

        # Label the direction so the report is easy to scan.
        $direction = if ($variance -gt 0) { 'Over plan' } elseif ($variance -lt 0) { 'Under plan' } else { 'On plan' }

        # Return a structured object rather than a formatted string.
        [pscustomobject]@{
            Category    = [string]$item.Category
            Plan        = $plan
            Actual      = $actual
            Variance    = $variance
            VariancePct = $percent
            Direction   = $direction
        }
    }

    # Emit detail rows in a stable category order.
    $rows | Sort-Object Category

    # Emit a separate total row for the complete sample.
    $totalPlan = ($rows | Measure-Object -Property Plan -Sum).Sum
    $totalActual = ($rows | Measure-Object -Property Actual -Sum).Sum
    [pscustomobject]@{
        Category    = 'TOTAL'
        Plan        = [decimal]$totalPlan
        Actual      = [decimal]$totalActual
        Variance    = [decimal]($totalActual - $totalPlan)
        VariancePct = if ($totalPlan -eq 0) { $null } else { [math]::Round((($totalActual - $totalPlan) / $totalPlan) * 100, 2) }
        Direction   = if ($totalActual -gt $totalPlan) { 'Over plan' } elseif ($totalActual -lt $totalPlan) { 'Under plan' } else { 'On plan' }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Supply fictional tickets and a fixed reporting date.
$sample = @(
    [pscustomobject]@{ Id = 'SUP-104'; Priority = 'High';   Opened = '2026-09-16' }
    [pscustomobject]@{ Id = 'SUP-105'; Priority = 'Low';    Opened = '2026-09-12' }
    [pscustomobject]@{ Id = 'SUP-106'; Priority = 'Medium'; Opened = '2026-09-01' }
    [pscustomobject]@{ Id = 'SUP-107'; Priority = 'High';   Opened = '2026-09-15' }
)

# Run the aging report without touching a real ticketing system.
$result = @(& "$PSScriptRoot/solution.ps1" -Ticket $sample -AsOfDate ([datetime]'2026-09-17'))

# Display ticket details and bucket counts as two readable tables.
$result | Where-Object Kind -eq 'Detail' |
    Format-Table Id, Priority, Opened, DaysOpen, Bucket -AutoSize
$result | Where-Object Kind -eq 'BucketSummary' |
    Format-Table Bucket, Count -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept support records from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Ticket,

    # Use an explicit date so the report is deterministic.
    [Parameter(Mandatory)]
    [datetime]$AsOfDate
)

begin {
    # Buffer records before calculating detail and summary output.
    $tickets = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Store each incoming ticket in memory.
    foreach ($item in $Ticket) {
        $tickets.Add($item)
    }
}

end {
    # Calculate age and a readable bucket for every ticket.
    $rows = foreach ($item in $tickets) {
        # Parse the supplied ISO date without contacting any external system.
        $opened = [datetime]::ParseExact([string]$item.Opened, 'yyyy-MM-dd', $null)
        $daysOpen = [math]::Max(0, ($AsOfDate.Date - $opened.Date).Days)

        # Use short, mutually exclusive age ranges.
        $bucket = if ($daysOpen -le 2) { '0-2 days' } elseif ($daysOpen -le 7) { '3-7 days' } else { '8+ days' }

        # Return a structured row for downstream formatting or export.
        [pscustomobject]@{
            Kind     = 'Detail'
            Id       = [string]$item.Id
            Priority = [string]$item.Priority
            Opened   = $opened.ToString('yyyy-MM-dd')
            DaysOpen = $daysOpen
            Bucket   = $bucket
        }
    }

    # Emit details in oldest-first order, then a compact bucket summary.
    $rows | Sort-Object -Property DaysOpen, Priority, Id -Descending
    $rows | Group-Object Bucket | Sort-Object Name | ForEach-Object {
        [pscustomobject]@{
            Kind   = 'BucketSummary'
            Bucket = $_.Name
            Count  = $_.Count
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Use a temporary workbook path so the example does not touch a project file.
$workbook = Join-Path ([System.IO.Path]::GetTempPath()) 'idea-lab-expense-summary.xlsx'

# Provide fictional expenses across a few categories.
$sample = @(
    [pscustomobject]@{ Date = '2026-09-01'; Category = 'Travel';   Amount = 425.00; Note = 'Rail' }
    [pscustomobject]@{ Date = '2026-09-03'; Category = 'Training'; Amount = 180.00; Note = 'Workshop' }
    [pscustomobject]@{ Date = '2026-09-08'; Category = 'Travel';   Amount = 95.50;  Note = 'Taxi' }
    [pscustomobject]@{ Date = '2026-09-10'; Category = 'Supplies'; Amount = 72.25;  Note = 'Adapters' }
)

# Run the workbook round trip and display the returned summaries.
& "$PSScriptRoot/solution.ps1" -Expense $sample -OutputPath $workbook |
    Format-Table Category, Rows, Total, WorkbookPath, Verified -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept expense rows from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Expense,

    # Write only to the path supplied by the caller.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$OutputPath
)

begin {
    # Buffer the input so one workbook and one summary are produced.
    $expenses = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add each fictional row to the in-memory collection.
    foreach ($item in $Expense) {
        $expenses.Add($item)
    }
}

end {
    # Load the cross-platform workbook cmdlets supplied by ImportExcel.
    Import-Module ImportExcel -ErrorAction Stop -WarningAction SilentlyContinue
    # Suppress the optional graphics dependency warning in a headless runtime.
    $WarningPreference = 'SilentlyContinue'

    # Export a simple, filterable table with readable headers.
    $expenses | Export-Excel -Path $OutputPath -WorksheetName 'Expenses' -TableName 'ExpenseTable' -AutoFilter -FreezeTopRow -BoldTopRow -WarningAction SilentlyContinue 3>$null

    # Read the workbook back to prove that the round trip preserved the rows.
    $roundTrip = @(Import-Excel -Path $OutputPath -WorksheetName 'Expenses')

    # Group the imported rows and calculate deterministic totals.
    $byCategory = $roundTrip | Group-Object Category | Sort-Object Name | ForEach-Object {
        [pscustomobject]@{
            Category = $_.Name
            Rows     = $_.Count
            Total    = [decimal](($_.Group | Measure-Object Amount -Sum).Sum)
        }
    }

    # Emit category summaries followed by a verification row.
    $byCategory
    [pscustomobject]@{
        Category     = 'TOTAL'
        Rows         = $roundTrip.Count
        Total        = [decimal](($roundTrip | Measure-Object Amount -Sum).Sum)
        WorkbookPath = $OutputPath
        Verified     = $roundTrip.Count -eq $expenses.Count
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Supply deterministic fictional duration samples in milliseconds.
$sample = @(
    [pscustomobject]@{ Command = 'Import';  Milliseconds = 42 }
    [pscustomobject]@{ Command = 'Import';  Milliseconds = 55 }
    [pscustomobject]@{ Command = 'Import';  Milliseconds = 61 }
    [pscustomobject]@{ Command = 'Import';  Milliseconds = 88 }
    [pscustomobject]@{ Command = 'Export';  Milliseconds = 18 }
    [pscustomobject]@{ Command = 'Export';  Milliseconds = 22 }
    [pscustomobject]@{ Command = 'Export';  Milliseconds = 25 }
    [pscustomobject]@{ Command = 'Export';  Milliseconds = 49 }
)

# Generate the percentile scorecard from the in-memory samples.
& "$PSScriptRoot/solution.ps1" -Sample $sample |
    Format-Table Command, Count, Minimum, Average, Median, P95 -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept duration samples with a command name and integer milliseconds.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Sample
)

begin {
    # Buffer samples before grouping them into a scorecard.
    $samples = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Keep every supplied sample in memory.
    foreach ($item in $Sample) {
        $samples.Add($item)
    }
}

end {
    # Build one percentile summary for each command.
    foreach ($group in ($samples | Group-Object Command | Sort-Object Name)) {
        # Sort numeric durations once so all statistics use the same order.
        $values = @($group.Group | ForEach-Object { [int]$_.Milliseconds } | Sort-Object)
        $count = $values.Count

        # Select nearest-rank positions for median and p95.
        $medianIndex = [math]::Max(0, [math]::Ceiling($count * 0.50) - 1)
        $p95Index = [math]::Max(0, [math]::Ceiling($count * 0.95) - 1)

        # Emit a compact, structured scorecard row.
        [pscustomobject]@{
            Command = $group.Name
            Count   = $count
            Minimum = $values[0]
            Average = [math]::Round((($values | Measure-Object -Average).Average), 2)
            Median  = $values[$medianIndex]
            P95     = $values[$p95Index]
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Use fictional model usage records for a deterministic planning example.
$sample = @(
    [pscustomobject]@{ Model = 'Model-A'; Requests = 120; AverageTokens = 320 }
    [pscustomobject]@{ Model = 'Model-B'; Requests = 80;  AverageTokens = 540 }
    [pscustomobject]@{ Model = 'Model-C'; Requests = 40;  AverageTokens = 250 }
)

# Estimate usage against a 100,000-token sample budget.
& "$PSScriptRoot/solution.ps1" -Model $sample -BudgetTokens 100000 |
    Format-Table Model, Requests, EstimatedTokens, SharePct, BudgetStatus -AutoSize

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept model usage records from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Model,

    # Set a simple fictional budget in token units for the sample.
    [ValidateRange(1, 1000000000)]
    [long]$BudgetTokens = 100000
)

begin {
    # Buffer records so shares and totals use one consistent denominator.
    $models = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add every fictional model row to memory.
    foreach ($item in $Model) {
        $models.Add($item)
    }
}

end {
    # Calculate estimated usage for each model.
    $rows = foreach ($item in $models) {
        # Multiply request volume by average tokens per request.
        $estimated = [long]$item.Requests * [long]$item.AverageTokens
        [pscustomobject]@{
            Model           = [string]$item.Model
            Requests        = [long]$item.Requests
            AverageTokens   = [long]$item.AverageTokens
            EstimatedTokens = $estimated
        }
    }

    # Compute a total before calculating each model's share.
    $total = ($rows | Measure-Object EstimatedTokens -Sum).Sum
    foreach ($row in ($rows | Sort-Object Model)) {
        # Avoid division by zero for an empty workload.
        $share = if ($total -eq 0) { 0 } else { [math]::Round(($row.EstimatedTokens / $total) * 100, 2) }
        [pscustomobject]@{
            Model           = $row.Model
            Requests        = $row.Requests
            EstimatedTokens = $row.EstimatedTokens
            SharePct        = $share
            BudgetStatus    = if ($total -le $BudgetTokens) { 'Within budget' } else { 'Over budget' }
        }
    }

    # Emit one total row so the budget decision is visible at a glance.
    [pscustomobject]@{
        Model           = 'TOTAL'
        Requests        = [long](($rows | Measure-Object Requests -Sum).Sum)
        EstimatedTokens = [long]$total
        SharePct        = 100
        BudgetStatus    = if ($total -le $BudgetTokens) { 'Within budget' } else { 'Over budget' }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Keep the runner independent from the caller's machine and PowerShell installation.
$ErrorActionPreference = 'Stop'

# Supply a small fictional feature catalog with both available and future entries.
$features = @(
    [pscustomobject]@{ Name = 'Structured error views'; IntroducedIn = '7.6'; Notes = 'Use the richer error display.' }
    [pscustomobject]@{ Name = 'Preview pipeline insight'; IntroducedIn = '7.7'; Notes = 'Evaluate this preview feature first.' }
    [pscustomobject]@{ Name = 'Cross-platform remoting'; IntroducedIn = '7.4'; Notes = 'Available in the current baseline.' }
)

# Run the solution against a fixed version so the output is repeatable.
& (Join-Path $PSScriptRoot 'solution.ps1') -Feature $features -CurrentVersion '7.6'

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept feature records from the caller so the report works with any in-memory catalog.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [object[]] $Feature,

    # Compare every feature with this explicit PowerShell version.
    [version] $CurrentVersion = [version]'7.6'
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

function Get-FeatureReadiness {
    [CmdletBinding()]
    param(
        # Keep the input strongly typed and require at least one record.
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [object[]] $InputFeature,

        # Pass the version into the function so the comparison is explicit and testable.
        [Parameter(Mandatory)]
        [version] $TargetVersion
    )

    foreach ($item in $InputFeature) {
        # Validate the fields needed to produce a useful report row.
        if ([string]::IsNullOrWhiteSpace([string]$item.Name)) {
            throw 'Every feature must have a non-empty Name.'
        }

        if ($null -eq $item.IntroducedIn) {
            throw "Feature '$($item.Name)' must specify IntroducedIn."
        }

        # Parse the version text once so malformed input fails with a clear message.
        try {
            $introducedVersion = [version]$item.IntroducedIn
        }
        catch {
            throw "Feature '$($item.Name)' has an invalid IntroducedIn value: $($item.IntroducedIn)."
        }

        # Emit structured data rather than strings so the result remains reusable.
        [pscustomobject]@{
            Name          = [string]$item.Name
            IntroducedIn  = $introducedVersion.ToString()
            Available     = $introducedVersion -le $TargetVersion
            Recommendation = if ($introducedVersion -le $TargetVersion) {
                'Ready to use'
            }
            else {
                "Wait for PowerShell $introducedVersion"
            }
            Notes         = [string]$item.Notes
        }
    }
}

# Build the report against the requested version.
$report = @(Get-FeatureReadiness -InputFeature $Feature -TargetVersion $CurrentVersion)

# Print a compact table that is easy to read in a terminal.
$report | Format-Table -AutoSize

# Print a summary so callers can see the overall readiness at a glance.
[pscustomobject]@{
    CurrentVersion = $CurrentVersion.ToString()
    FeatureCount   = $report.Count
    ReadyCount     = @($report | Where-Object Available).Count
    WaitingCount   = @($report | Where-Object { -not $_.Available }).Count
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop on the first error so the captured exit status reflects the real result.
$ErrorActionPreference = 'Stop'

# Use the runtime temporary directory so the repository stays focused on source and evidence.
$outputPath = Join-Path ([System.IO.Path]::GetTempPath()) "idea-lab-regional-sales-$PID.xlsx"

# Supply deterministic fictional sales records.
$sales = @(
    [pscustomobject]@{ Region = 'North'; Product = 'Atlas'; Units = 12; Amount = 1440.00 }
    [pscustomobject]@{ Region = 'South'; Product = 'Beacon'; Units = 9; Amount = 990.00 }
    [pscustomobject]@{ Region = 'West'; Product = 'Cedar'; Units = 15; Amount = 2025.00 }
    [pscustomobject]@{ Region = 'North'; Product = 'Drift'; Units = 7; Amount = 840.00 }
)

# Invoke the ImportExcel-backed solution and print its verification object.
& (Join-Path $PSScriptRoot 'solution.ps1') -SalesRecord $sales -OutputPath $outputPath | Format-List

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept fictional sales rows from the caller.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [object[]] $SalesRecord,

    # Write the generated workbook only to the caller's chosen path.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string] $OutputPath
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

# Load the module that provides cross-platform Excel file operations.
Import-Module ImportExcel -ErrorAction Stop -WarningAction SilentlyContinue 3>$null

# Validate the output location without creating or changing any parent directory.
$parentPath = Split-Path -Parent $OutputPath
if (-not [string]::IsNullOrWhiteSpace($parentPath) -and -not (Test-Path -LiteralPath $parentPath -PathType Container)) {
    throw "The output directory does not exist: $parentPath"
}

# Validate each record before writing a workbook so bad input is reported early.
foreach ($record in $SalesRecord) {
    if ([string]::IsNullOrWhiteSpace([string]$record.Region)) {
        throw 'Every sales record must have a Region.'
    }

    if ($null -eq $record.Amount) {
        throw "Sales record '$($record.Region)' must have an Amount."
    }
}

# Export the in-memory records with a table and presentation-friendly options.
$SalesRecord | Export-Excel -Path $OutputPath -WorksheetName 'Sales' -TableName 'RegionalSales' -AutoFilter -FreezeTopRow -BoldTopRow

# Read the workbook back to prove that the generated artifact can be consumed.
$roundTrip = @(Import-Excel -Path $OutputPath -WorksheetName 'Sales')

# Return structured verification details instead of requiring callers to parse text.
[pscustomobject]@{
    WorkbookPath = $OutputPath
    RowsWritten   = $SalesRecord.Count
    RowsRead      = $roundTrip.Count
    TotalAmount   = [math]::Round((@($roundTrip | Measure-Object -Property Amount -Sum).Sum), 2)
    Verified      = $roundTrip.Count -eq $SalesRecord.Count
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop on the first error so the captured exit status is meaningful.
$ErrorActionPreference = 'Stop'

# Use a modest deterministic workload suitable for an isolated cloud runtime.
& (Join-Path $PSScriptRoot 'solution.ps1') -ItemCount 5000 -Repetitions 10

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Control the size of the fictional in-memory workload.
    [ValidateRange(100, 100000)]
    [int] $ItemCount = 5000,

    # Repeat each implementation so a small workload still produces measurable timing.
    [ValidateRange(1, 100)]
    [int] $Repetitions = 10
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

# Build one deterministic input array that both implementations will consume.
$items = 1..$ItemCount

# Measure a direct foreach loop over the same values.
$foreachMeasurement = Measure-Command {
    $foreachSum = 0L
    for ($repeat = 0; $repeat -lt $Repetitions; $repeat++) {
        foreach ($item in $items) {
            $foreachSum += $item
        }
    }
}

# Measure a pipeline-based implementation over the same values.
$pipelineMeasurement = Measure-Command {
    $pipelineSum = 0L
    for ($repeat = 0; $repeat -lt $Repetitions; $repeat++) {
        $pipelineSum += ($items | ForEach-Object { $_ } | Measure-Object -Sum).Sum
    }
}

# Emit structured results so the comparison can be consumed without parsing display text.
$scorecard = @(
    [pscustomobject]@{
        Implementation = 'foreach loop'
        ElapsedMs      = [math]::Round($foreachMeasurement.TotalMilliseconds, 3)
        Checksum       = $foreachSum
    }
    [pscustomobject]@{
        Implementation = 'pipeline loop'
        ElapsedMs      = [math]::Round($pipelineMeasurement.TotalMilliseconds, 3)
        Checksum       = $pipelineSum
    }
)

# Display the scorecard and an explicit agreement check.
$scorecard | Format-Table -AutoSize
[pscustomobject]@{
    ItemCount       = $ItemCount
    Repetitions     = $Repetitions
    ChecksumsAgree  = $scorecard[0].Checksum -eq $scorecard[1].Checksum
    FasterPath      = ($scorecard | Sort-Object ElapsedMs | Select-Object -First 1).Implementation
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop on the first error so the captured exit status reflects the real result.
$ErrorActionPreference = 'Stop'

# Supply fictional paths only; no real directories are inspected.
$paths = @(
    'reports/2026/january/sales.csv'
    'reports/2026/february/sales.csv'
    'reports/2026/february/archive/notes.txt'
    'exports/daily/status.json'
    'exports/monthly/status.json'
    '  '
    'reports//2026//march//sales.csv'
)

# Run the in-memory path summarizer.
& (Join-Path $PSScriptRoot 'solution.ps1') -Path $paths

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept sample paths from the caller rather than reading the local filesystem.
    [Parameter(Mandatory)]
    [ValidateNotNull()]
    [string[]] $Path
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

# Hold normalized path records in memory for grouping.
$records = foreach ($value in $Path) {
    if ([string]::IsNullOrWhiteSpace($value)) {
        continue
    }

    # Normalize separators and trim the edges before splitting into segments.
    $normalized = ($value -replace '/+', '/').Trim('/')
    if ([string]::IsNullOrWhiteSpace($normalized)) {
        continue
    }

    # Count non-empty segments to calculate path depth.
    $segments = @($normalized -split '/' | Where-Object { $_ })
    [pscustomobject]@{
        Path      = $normalized
        TopLevel  = $segments[0]
        Depth     = $segments.Count
    }
}

# Group records and sort the groups for repeatable output.
$summary = foreach ($group in ($records | Group-Object TopLevel | Sort-Object Name)) {
    # Sort paths by depth and then name so the deepest sample is deterministic.
    $deepest = $group.Group | Sort-Object Depth, Path | Select-Object -Last 1
    [pscustomobject]@{
        TopLevel       = $group.Name
        PathCount      = $group.Count
        MaximumDepth   = ($group.Group | Measure-Object -Property Depth -Maximum).Maximum
        DeepestExample = $deepest.Path
    }
}

# Print structured summary rows followed by an overall count.
$summary | Format-Table -AutoSize
[pscustomobject]@{
    InputCount      = @($Path).Count
    NormalizedCount = @($records).Count
    GroupCount      = @($summary).Count
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop on the first error so the captured exit status reflects the real result.
$ErrorActionPreference = 'Stop'

# Supply deterministic examples using different delimiter characters.
$values = @(
    'alpha, beta,, gamma'
    'north | south | east'
)

# Run each example with its matching explicit delimiter character array.
& (Join-Path $PSScriptRoot 'solution.ps1') -Value $values[0] -Delimiter ([char[]]',') | Format-List
& (Join-Path $PSScriptRoot 'solution.ps1') -Value $values[1] -Delimiter ([char[]]'|') | Format-List

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept one or more delimited values from the caller.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string[]] $Value,

    # Make the delimiter characters explicit for predictable PowerShell 7 behavior.
    [char[]] $Delimiter = [char[]]','
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

foreach ($text in $Value) {
    if ([string]::IsNullOrWhiteSpace($text)) {
        throw 'Value entries cannot be blank.'
    }

    # Split using the explicit character array and remove empty tokens.
    $tokens = @(
        $text.Split($Delimiter, [System.StringSplitOptions]::RemoveEmptyEntries) |
            ForEach-Object { $_.Trim() } |
            Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
    )

    # Return a structured object so callers can use the tokens directly.
    [pscustomobject]@{
        Original  = $text
        TokenCount = $tokens.Count
        Tokens    = $tokens -join ' | '
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop on unexpected errors so validation records a meaningful exit status.
$ErrorActionPreference = 'Stop'

# Use fictional inventory records so the report is safe to run anywhere.
$inventory = @(
    [pscustomobject]@{ Device = 'Northstar-01'; OperatingSystem = 'Windows 11'; MemoryGB = 32; FreeDiskGB = 120 }
    [pscustomobject]@{ Device = 'Northstar-02'; OperatingSystem = 'Windows 10'; MemoryGB = 16; FreeDiskGB = 80 }
    [pscustomobject]@{ Device = 'Northstar-03'; OperatingSystem = 'Windows 11'; MemoryGB = 8; FreeDiskGB = 35 }
)

# Evaluate the sample inventory against the default baseline.
$results = & "$PSScriptRoot/solution.ps1" -Device $inventory

# Print a readable one-line summary per device.
$results | ForEach-Object {
    Write-Output ("{0}: {1}; gaps: {2}" -f $_.Device, $(if ($_.Ready) { 'Ready' } else { 'Review' }), $_.Gaps)
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept fictional inventory records from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Device,

    # Define the minimum baseline that a device should satisfy.
    [string]$RequiredOs = 'Windows 11',
    [ValidateRange(1, 1024)]
    [int]$MinimumMemoryGB = 16,
    [ValidateRange(1, 4096)]
    [int]$MinimumFreeDiskGB = 50
)

begin {
    # Hold input records until the pipeline completes so the function can emit one report.
    $devicesToReview = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add each incoming device to the in-memory inventory.
    foreach ($item in $Device) {
        $devicesToReview.Add($item)
    }
}

end {
    # Evaluate each device against the same explicit baseline.
    foreach ($item in $devicesToReview) {
        # Start an empty list of human-readable gaps for this device.
        $gaps = [System.Collections.Generic.List[string]]::new()

        # Record an operating-system gap when the device is outside the baseline.
        if ($item.OperatingSystem -ne $RequiredOs) {
            $gaps.Add("OS is $($item.OperatingSystem); required $RequiredOs")
        }

        # Record a memory gap when the installed amount is too small.
        if ([int]$item.MemoryGB -lt $MinimumMemoryGB) {
            $gaps.Add("Memory is $($item.MemoryGB) GB; required $MinimumMemoryGB GB")
        }

        # Record a storage gap when the free space is below the baseline.
        if ([int]$item.FreeDiskGB -lt $MinimumFreeDiskGB) {
            $gaps.Add("Free disk is $($item.FreeDiskGB) GB; required $MinimumFreeDiskGB GB")
        }

        # Emit one concise report object for the device.
        [pscustomobject]@{
            Device = $item.Device
            Ready  = $gaps.Count -eq 0
            Gaps   = if ($gaps.Count -eq 0) { 'None' } else { $gaps -join '; ' }
        }
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Treat any unexpected PowerShell error as a failed validation.
$ErrorActionPreference = 'Stop'

# Define independent, fictional checks that can safely run in parallel.
$checks = @(
    [pscustomobject]@{ Check = 'Config schema'; Expected = 'v3'; Observed = 'v3' }
    [pscustomobject]@{ Check = 'Cache freshness'; Expected = 'Fresh'; Observed = 'Stale' }
    [pscustomobject]@{ Check = 'Worker capacity'; Expected = 'Available'; Observed = 'Available' }
    [pscustomobject]@{ Check = 'Feature flags'; Expected = 'Loaded'; Observed = 'Loaded' }
)

# Invoke the solution with a small throttle limit suitable for a demo machine.
$results = & "$PSScriptRoot/solution.ps1" -Check $checks -ThrottleLimit 3

# Print one stable line per result for easy review and validation.
$results | ForEach-Object {
    Write-Output ("{0}: {1} (expected {2}, observed {3})" -f $_.Check, $_.State, $_.Expected, $_.Observed)
}

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept independent check definitions from the pipeline or as an array.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$Check,

    # Limit concurrent workers so the pattern remains predictable on small machines.
    [ValidateRange(1, 32)]
    [int]$ThrottleLimit = 3
)

begin {
    # Collect all checks before starting workers so the input boundary is explicit.
    $checksToRun = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add each check record to the in-memory work list.
    foreach ($item in $Check) {
        $checksToRun.Add($item)
    }
}

end {
    # Run each independent check in its own parallel runspace.
    $results = $checksToRun | ForEach-Object -Parallel {
        # Keep worker logic self-contained because a parallel runspace does not inherit local functions.
        $isMatch = $_.Observed -eq $_.Expected

        # Return a plain object that is easy to sort, display, or export.
        [pscustomobject]@{
            Check    = $_.Check
            Expected = $_.Expected
            Observed = $_.Observed
            State    = if ($isMatch) { 'Pass' } else { 'Review' }
        }
    } -ThrottleLimit $ThrottleLimit

    # Sort after the workers finish so output order is stable across runs.
    $results | Sort-Object Check
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

# Stop immediately if the solution reports a terminating error.
$ErrorActionPreference = 'Stop'

# Build fictional records in memory so this demonstration needs no network or external files.
$records = @(
    [pscustomobject]@{ Device = 'Atlas-01'; Owner = 'Zoë'; State = 'Ready' }
    [pscustomobject]@{ Device = 'Borealis-02'; Owner = 'Miyuki'; State = 'Review' }
    [pscustomobject]@{ Device = 'Cedar-03'; Owner = 'José'; State = 'Ready' }
)

# Invoke the reusable solution with the sample records.
$result = & "$PSScriptRoot/solution.ps1" -InputObject $records

# Print deterministic metadata followed by the portable CSV payload.
Write-Output "Encoding: $($result.Encoding)"
Write-Output "Byte count: $($result.ByteCount)"
Write-Output "Line count: $($result.LineCount)"
Write-Output "Has BOM: $($result.HasBom)"
Write-Output 'CSV payload:'
Write-Output $result.CsvText

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept the objects that should become rows in the export.
    [Parameter(Mandatory, ValueFromPipeline)]
    [psobject[]]$InputObject,

    # Allow callers to choose another delimiter while keeping comma as the default.
    [char]$Delimiter = ','
)

begin {
    # Collect pipeline input so one complete CSV document can be produced at the end.
    $rows = [System.Collections.Generic.List[psobject]]::new()
}

process {
    # Add each incoming object to the in-memory collection.
    foreach ($item in $InputObject) {
        $rows.Add($item)
    }
}

end {
    # Convert the objects to normal CSV lines without the PowerShell type header.
    $csvLines = @($rows | ConvertTo-Csv -NoTypeInformation -Delimiter $Delimiter)

    # Use an explicit UTF-8 encoder that does not add a byte-order mark.
    $utf8NoBom = [System.Text.UTF8Encoding]::new($false)

    # Join the lines with the platform newline and encode the complete document.
    $csvText = $csvLines -join [Environment]::NewLine
    $bytes = $utf8NoBom.GetBytes($csvText)

    # Decode the bytes again to prove that the generated payload is self-consistent.
    $roundTripText = $utf8NoBom.GetString($bytes)

    # Return useful metadata plus the text that a caller could save or transmit.
    [pscustomobject]@{
        Encoding   = 'UTF-8 without BOM'
        ByteCount  = $bytes.Length
        LineCount  = $csvLines.Count
        HasBom     = $bytes.Length -ge 3 -and $bytes[0] -eq 0xEF -and $bytes[1] -eq 0xBB -and $bytes[2] -eq 0xBF
        CsvText    = $roundTripText
    }
}

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

[CmdletBinding()]
param()

# Keep the runner independent from files, services, and user-specific configuration.
Set-StrictMode -Version Latest

# Fictional text keeps the example deterministic and safe to run anywhere.
$sampleText = 'The morning handoff is ready. Review the queued work, confirm the owner for each item, and record the next action before the afternoon check-in.'

$solutionPath = Join-Path -Path $PSScriptRoot -ChildPath 'solution.ps1'

# A small limit forces several blocks so the ordering and final-short-block behavior are visible.
& $solutionPath -Text $sampleText -MaxCharacters 48

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # The complete text to divide into blocks.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string] $Text,

    # The largest number of .NET string characters allowed in one block.
    [Parameter(Mandatory)]
    [ValidateRange(1, 1000000)]
    [int] $MaxCharacters
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

function Split-TextIntoBlocks {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [string] $InputText,

        [Parameter(Mandatory)]
        [ValidateRange(1, 1000000)]
        [int] $BlockSize
    )

    $blocks = [System.Collections.Generic.List[object]]::new()

    # Advance by one block at a time so no character is skipped or repeated.
    for ($start = 0; $start -lt $InputText.Length; $start += $BlockSize) {
        # The final block may be shorter than the requested maximum.
        $remaining = $InputText.Length - $start
        $length = [Math]::Min($BlockSize, $remaining)
        $blockText = $InputText.Substring($start, $length)

        # Store structured data instead of requiring callers to parse display text.
        [void] $blocks.Add([pscustomobject]@{
            BlockNumber   = $blocks.Count + 1
            CharacterCount = $length
            Text           = $blockText
        })
    }

    [object[]] $blocks
}

$blocks = Split-TextIntoBlocks -InputText $Text -BlockSize $MaxCharacters

Write-Output 'Blocks:'
foreach ($block in $blocks) {
    # Escape line breaks in the display only; the Text property itself remains unchanged.
    $displayText = $block.Text.Replace("`r", '<CR>').Replace("`n", '<LF>')
    # Angle brackets make leading or trailing spaces visible in captured output.
    Write-Output ("{0}. ({1} chars) <{2}>" -f $block.BlockNumber, $block.CharacterCount, $displayText)
}

Write-Output ''
Write-Output 'Summary:'
[pscustomobject]@{
    InputCharacters = $Text.Length
    MaxCharacters   = $MaxCharacters
    BlockCount      = $blocks.Count
    LargestBlock    = ($blocks | Measure-Object -Property CharacterCount -Maximum).Maximum
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

[CmdletBinding()]
param()

# Keep the runner independent from files, services, and user-specific configuration.
Set-StrictMode -Version Latest

# Fictional records deliberately include one malformed date to exercise per-item recovery.
$sampleSchedules = @(
    [pscustomobject]@{
        Name    = 'Morning handoff'
        DueDate = '2026-09-18'
    }
    [pscustomobject]@{
        Name    = 'Afternoon review'
        DueDate = 'not-a-date'
    }
    [pscustomobject]@{
        Name    = 'Weekend summary'
        DueDate = '2026-09-20'
    }
)

$solutionPath = Join-Path -Path $PSScriptRoot -ChildPath 'solution.ps1'

# Every record is handled in memory; the malformed value should not stop later records.
& $solutionPath -Schedules $sampleSchedules

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept the schedule records from the caller so the validator can be reused.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [object[]] $Schedules
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

function Test-ScheduleDates {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [object[]] $InputSchedule
    )

    $results = [System.Collections.Generic.List[object]]::new()

    foreach ($schedule in $InputSchedule) {
        $name = [string] $schedule.Name
        $rawDueDate = [string] $schedule.DueDate

        if ([string]::IsNullOrWhiteSpace($name)) {
            throw 'Every schedule record must have a non-empty Name.'
        }

        try {
            # ErrorAction Stop promotes a conversion error so the catch block can capture it.
            $parsedDate = Get-Date -Date $rawDueDate -ErrorAction Stop

            [void] $results.Add([pscustomobject]@{
                Name       = $name
                DueDate    = $parsedDate.ToString('yyyy-MM-dd')
                Status     = 'Valid'
                Error      = $null
            })
        }
        catch {
            # Keep the failure attached to this record and continue with the next one.
            [void] $results.Add([pscustomobject]@{
                Name       = $name
                DueDate    = $rawDueDate
                Status     = 'Invalid'
                Error      = $_.Exception.Message
            })
        }
    }

    [object[]] $results
}

$results = @(Test-ScheduleDates -InputSchedule $Schedules)

# Keep the main table compact and print error details separately so they are never truncated.
$table = $results |
    Select-Object -Property Name, DueDate, Status |
    Format-Table -AutoSize |
    Out-String -Width 200
Write-Output $table.TrimEnd()

$invalidResults = @($results | Where-Object Status -eq 'Invalid')
if ($invalidResults.Count -gt 0) {
    Write-Output ''
    Write-Output 'Errors:'
    foreach ($invalidResult in $invalidResults) {
        Write-Output ("{0}: {1}" -f $invalidResult.Name, $invalidResult.Error)
    }
}

Write-Output ''
Write-Output 'Summary:'
[pscustomobject]@{
    TotalRecords = $results.Count
    ValidRecords = @($results | Where-Object Status -eq 'Valid').Count
    InvalidRecords = @($results | Where-Object Status -eq 'Invalid').Count
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

[CmdletBinding()]
param()

# Keep the runner independent from files, services, and user-specific configuration.
Set-StrictMode -Version Latest

# Fictional labels exercise case differences, duplicate values, and surrounding whitespace.
$sampleLabels = @(
    'PowerShell'
    'powershell'
    ' Automation '
    'Automation'
    'Cloud'
    'cloud'
    'DevOps'
)

$solutionPath = Join-Path -Path $PSScriptRoot -ChildPath 'solution.ps1'

# The implementation only receives the in-memory sample array and performs no external actions.
& $solutionPath -Labels $sampleLabels

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding()]
param(
    # Accept the labels from the caller so the function can be reused with any in-memory input.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string[]] $Labels
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

function Get-UniqueLabelReport {
    [CmdletBinding()]
    param(
        # Require at least one label and keep the input strongly typed.
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [string[]] $InputLabel
    )

    # HashSet provides fast membership checks. The comparer makes only the comparison
    # case-insensitive; the first spelling is still retained in the ordered collection.
    $seen = [System.Collections.Generic.HashSet[string]]::new(
        [System.StringComparer]::OrdinalIgnoreCase
    )

    # List preserves the order in which each unique label is first encountered.
    $orderedLabels = [System.Collections.Generic.List[string]]::new()

    # Track repeated values separately so the report can explain what was removed.
    $duplicateLabels = [System.Collections.Generic.List[string]]::new()

    foreach ($label in $InputLabel) {
        if ($null -eq $label) {
            throw 'Labels cannot contain null values.'
        }

        # Normalization happens before both the membership test and the retained value.
        $normalizedLabel = $label.Trim()
        if ([string]::IsNullOrWhiteSpace($normalizedLabel)) {
            throw 'Labels cannot be blank or whitespace-only.'
        }

        # Add returns true only when this normalized value was not already present.
        if ($seen.Add($normalizedLabel)) {
            [void] $orderedLabels.Add($normalizedLabel)
        }
        else {
            [void] $duplicateLabels.Add($normalizedLabel)
        }
    }

    # Return structured data so callers can consume the result without parsing display text.
    [pscustomobject]@{
        InputCount     = $InputLabel.Count
        UniqueCount    = $orderedLabels.Count
        DuplicateCount = $duplicateLabels.Count
        UniqueLabels   = [string[]] $orderedLabels
        Duplicates     = [string[]] $duplicateLabels
    }
}

# Build the report from the caller's labels.
$report = Get-UniqueLabelReport -InputLabel $Labels

# Display the ordered unique values first so the main result is easy to scan.
Write-Output 'Unique labels (first-seen order):'
for ($index = 0; $index -lt $report.UniqueLabels.Count; $index++) {
    Write-Output ("{0}. {1}" -f ($index + 1), $report.UniqueLabels[$index])
}

Write-Output ''
Write-Output 'Summary:'
[pscustomobject]@{
    InputCount     = $report.InputCount
    UniqueCount    = $report.UniqueCount
    DuplicateCount = $report.DuplicateCount
    Duplicates     = if ($report.Duplicates.Count -gt 0) {
        $report.Duplicates -join ', '
    }
    else {
        '(none)'
    }
} | Format-List

AI also created run.ps1. It prepares the sample data, passes the parameters, and invokes the generated PowerShell.

[CmdletBinding()]
param()

# Keep the runner independent from external files and services.
Set-StrictMode -Version Latest

# Use fictional objects so the preview can be run safely anywhere.
$sampleItems = @(
    [pscustomobject]@{
        Name          = 'Alpha'
        CurrentStatus = 'Queued'
        TargetStatus  = 'Ready'
    }
    [pscustomobject]@{
        Name          = 'Bravo'
        CurrentStatus = 'Ready'
        TargetStatus  = 'Ready'
    }
    [pscustomobject]@{
        Name          = 'Charlie'
        CurrentStatus = 'Queued'
        TargetStatus  = 'Blocked'
    }
)

$solutionPath = Join-Path -Path $PSScriptRoot -ChildPath 'solution.ps1'

# -WhatIf is intentional: it previews the plan and does not apply changes.
& $solutionPath -Items $sampleItems -WhatIf

solution.ps1 is the runnable PowerShell produced from the AI-created prompt.

[CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'Medium')]
param(
    # Accept the work items from the caller so the example is easy to reuse.
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [object[]] $Items
)

# Make uninitialized variables and common scripting mistakes fail early.
Set-StrictMode -Version Latest

function Invoke-StatusPlan {
    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'Medium')]
    param(
        # Each item must expose Name, CurrentStatus, and TargetStatus properties.
        [Parameter(Mandatory)]
        [ValidateNotNullOrEmpty()]
        [object[]] $InputObject
    )

    foreach ($item in $InputObject) {
        # Read the properties once so the proposed action is easy to inspect.
        $name = [string]$item.Name
        $currentStatus = [string]$item.CurrentStatus
        $targetStatus = [string]$item.TargetStatus

        if ([string]::IsNullOrWhiteSpace($name)) {
            throw 'Every item must have a non-empty Name.'
        }

        if ([string]::IsNullOrWhiteSpace($targetStatus)) {
            throw "Item '$name' must have a non-empty TargetStatus."
        }

        if ($currentStatus -eq $targetStatus) {
            [pscustomobject]@{
                Name          = $name
                CurrentStatus = $currentStatus
                TargetStatus  = $targetStatus
                Action        = 'No change'
            }

            continue
        }

        # ShouldProcess honors -WhatIf and -Confirm for the caller.
        $description = "Change status from '$currentStatus' to '$targetStatus'"
        if ($PSCmdlet.ShouldProcess($name, $description)) {
            # This example changes only the in-memory object supplied by the caller.
            $item.CurrentStatus = $targetStatus

            [pscustomobject]@{
                Name          = $name
                CurrentStatus = $currentStatus
                TargetStatus  = $targetStatus
                Action        = 'Applied'
            }
        }
        else {
            # In WhatIf mode, describe the proposed change without applying it.
            [pscustomobject]@{
                Name          = $name
                CurrentStatus = $currentStatus
                TargetStatus  = $targetStatus
                Action        = 'Would change'
            }
        }
    }
}

# Invoke-StatusPlan inherits the script-level -WhatIf and -Confirm settings.
$results = Invoke-StatusPlan -InputObject $Items

$results | Format-Table -AutoSize

[pscustomobject]@{
    TotalItems  = @($results).Count
    Changes     = @($results | Where-Object Action -in @('Applied', 'Would change')).Count
    Applied     = @($results | Where-Object Action -eq 'Applied').Count
    PreviewOnly = @($results | Where-Object Action -eq 'Would change').Count
}