documents {
    from dataset "dataset-name"
    where <field> <operator> <value>
    limit <number>
}

documents {
    from dataset "invoices"

    "dbl-comment"># Type filter with array membership
    where document.file_type in ["pdf", "png"]

    "dbl-comment"># Size range
    where document.file_size > 100kb
    where document.file_size < 10mb

    "dbl-comment"># File name substring match
    where document.file_name contains "invoice"

    "dbl-comment"># Regex pattern
    where document.file_name matches "^INV-[0-9]{4}"

    "dbl-comment"># Exact status match
    where document.status == "ready"

    "dbl-comment"># Page count range
    where document.page_count >= 1
    where document.page_count <= 20

    limit 50
}

engines {
    engine "ProviderName" {
        model "model-id"
        mode "text" | "vision" | "default"
    }
}

engines {
    engine "openai" {
        model "gpt-4o"
        mode "vision"
    }
    engine "anthropic" {
        model "claude-sonnet-4-5"
        mode "text"
    }
    engine "docdigitizer" {
        mode "default"
    }
}

execution {
    runs <number>            "dbl-comment"># default: 1
    mode parallel | sequential   "dbl-comment"># default: sequential
    max_concurrent <number>  "dbl-comment"># default: 1 (parallel only)
    max_per_engine <number>  "dbl-comment"># default: unbounded
}

execution {
    runs 5
    mode parallel
    max_concurrent 10
    max_per_engine 3
}

analysis {
    compute accuracy

    compute timing {
        percentiles [50, 90, 95, 99]
        group_by engine, model
    }

    compute cost {
        group_by engine
    }
}

output {
    graph <type> {
        title "Chart Title"
        <axis>: <domain.property>
    }
}

throttle {
    bandwidth 5mb
}

"dbl-comment"># Simulate a slow broadband connection (5 MB/s)
throttle {
    bandwidth 5mb
}

"dbl-comment"># Simulate a constrained mobile connection (512 KB/s)
throttle {
    bandwidth 512kb
}

"dbl-comment"># Use raw bytes/sec for precise control
throttle {
    bandwidth 1048576   "dbl-comment"># 1 MB/s
}

"dbl-comment"># Syntax
sweep <variable> [<value>, <value>, ...]

"dbl-comment"># Find the right bandwidth throttle for realistic testing
sweep bandwidth [1mb, 5mb, 10mb, 50mb]

"dbl-comment"># Measure how result quality changes with more repetitions
sweep runs [1, 3, 5, 10]

"dbl-comment"># Find the optimal concurrency level
sweep max_concurrent [1, 2, 4, 8, 16]

"dbl-comment"># Tune per-engine limits
sweep max_per_engine [1, 2, 3]

run "run-name" {
    labels ["label1", "label2"]

    engine "provider" {
        model "model-id"
        mode "text" | "vision" | "default"
    }

    pass 1 "first-pass" {
        prompts { labels ["categorization"] }
    }

    pass 2 "second-pass" {
        when pass.1.category not empty
        prompts { labels ["schema_bounded"] }
    }
}

run "explicit_engine" {
    engine "openai" { model "gpt-4o" mode "vision" }
    engine "anthropic" { model "claude-sonnet-4-20250514" }
}

run "label_based" {
    "dbl-comment"># Resolves to all active models with ALL listed labels
    engines { labels ["fast", "vision"] }
}

pass <number> ["optional-name"] {
    [when <boolean-expression>]
    [prompts { ... }]
    [schemas { ... }]
    [post_extraction { ... }]
}

"dbl-comment"># Pass 1 — no condition, always runs
pass 1 "categorize" {
    prompts { labels ["categorization"] }
}

"dbl-comment"># Pass 2 — runs only when pass 1 returned a category
pass 2 "extract" {
    when pass.1.category not empty and pass.1.confidence > 0.5
    prompts { labels ["schema_bounded"] }
    schemas { labels ["invoices"] expand true }
}

"dbl-comment"># Pass 3 — fallback when categorization produced no category
pass 3 "fallback" {
    when pass.1.category empty
    prompts { labels ["freewheel"] }
}

"dbl-comment"># Compound condition
when pass.1.category not empty and pass.1.confidence > 0.5

"dbl-comment"># Type-based branching
when pass.1.type == "invoice" or pass.1.type == "receipt"

"dbl-comment"># Parenthesised override
when pass.1.category not empty and (pass.1.confidence > 0.8 or pass.1.manual_review == true)

"dbl-comment"># Fallback
when pass.1.category empty

include "snippet-name"

benchmark "Multi-pass Test" {
    include "standard_analysis_output"     "dbl-comment"># injects analysis{} and output{} blocks

    documents { from dataset "Dataset1" }

    run "llm" {
        engine "openai" { model "gpt-4o" }
        include "two_pass_categorize"       "dbl-comment"># injects pass 1 and pass 2 definitions
    }

    analysis { compute accuracy }           "dbl-comment"># explicit block wins over the snippet's
}

benchmark "Invoice Pipeline" {
    labels ["experiment_q1", "invoices"]    "dbl-comment"># benchmark-level labels

    documents { from dataset "Dataset1" limit 100 }

    run "idp_baseline" {
        labels ["idp"]                      "dbl-comment"># run-level labels
        engine "docdigitizer" { mode "default" }
    }

    run "llm_two_pass" {
        labels ["llm", "multi_pass"]        "dbl-comment"># run-level labels
        engine "openai" { model "gpt-4o" mode "vision" }

        pass 1 "categorize" {
            prompts { labels ["categorization"] }
        }
    }
}

run "fast_run" {
    "dbl-comment"># Selects all active models labelled "fast" AND "vision"
    engines { labels ["fast", "vision"] }

    pass 1 {
        prompts { labels ["categorization"] }
    }
}

benchmark "Invoice Pipeline — LLM vs IDP" {
    labels ["experiment_q1", "invoices"]

    documents {
        from dataset "Dataset1"
        where document.file_type in ["pdf"]
        limit 100
    }

    "dbl-comment"># Run 1: DocDigitizer IDP baseline (single pass)
    run "idp_baseline" {
        labels ["idp"]
        engine "docdigitizer" { mode "default" }
    }

    "dbl-comment"># Run 2: Two-pass LLM pipeline
    run "llm_two_pass" {
        labels ["llm", "multi_pass"]
        engine "openai" { model "gpt-4o" mode "vision" }
        engine "anthropic" { model "claude-sonnet-4-20250514" }

        pass 1 "categorize" {
            prompts { labels ["categorization"] }
        }

        pass 2 "extract" {
            when pass.1.category not empty and pass.1.confidence > 0.5
            prompts { labels ["schema_bounded"] }
            schemas { labels ["invoices"] expand true }
        }

        pass 3 "fallback" {
            when pass.1.category empty
            prompts { labels ["freewheel"] }
        }
    }

    execution {
        runs 2
        mode parallel
        max_concurrent 6
    }

    schemas {
        labels ["invoices"]
        expand true
    }

    analysis {
        compute accuracy
        compute timing { percentiles [50, 90, 95] group_by engine }
        compute cost { group_by engine }
    }

    output {
        graph bar { title "Accuracy by Engine" x: engine.name y: accuracy.score }
        graph pie { title "Cost Distribution" value: cost.total label: engine.name }
    }

    compare many_to_many { }
}