#if canImport(Darwin)
import Darwin
#else
import Glibc
#endif
import Foundation
import TeaQLCore
import TeaQLSQLite
import GeneratedTeaQL

enum OrderError: Error { case invalidQuantity, invalidState(String) }
let seedReason = "Seed the Order workflow fixture"
let editReason = "Edit draft Order quantity and totals atomically"
func required<T>(_ value: T?) throws -> T { guard let value else { throw OrderError.invalidState("Required loaded value") }; return value }
func require(_ value: Bool, _ message: String) throws { if !value { throw OrderError.invalidState(message) } }
func report(_ name: String, _ value: Any) throws {
    let data = try JSONSerialization.data(withJSONObject: ["case": name, "value": value], options: [.sortedKeys])
    print("ORDER_CASE " + String(decoding: data, as: UTF8.self))
}
func nullable(_ value: String?) -> Any { if let value { return value }; return NSNull() }
func missing<T>(_ call: () throws -> T) throws -> [String: String] {
    do { _ = try call() } catch { return ["type": String(reflecting: type(of: error)), "message": String(describing: error)] }
    throw OrderError.invalidState("NotLoaded unexpectedly succeeded")
}
struct Fixture: Decodable {
    let orders: [Order]
    struct Order: Decodable {
        let orderStatus: String, orderNumber: String, buyerReference: String, currencyCode: String, totalMinor: Int64, orderNote: String?
        let items: [Item]
    }
    struct Item: Decodable { let skuCode: String, productName: String, quantity: Int64, unitPriceMinor: Int64, lineTotalMinor: Int64 }
}
func graph(_ context: UserContext) async throws -> [[String: Any]] {
    let rows = try await Q.customerOrders().orderByOrderNumberAscending().orderByIdAscending()
        .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(101)).limit(10)
        .comment("Read bounded full Order graphs").purpose("Verify persisted Order workflow results").executeForList(context)
    return try rows.map { order in
        let children: [[String: Any]] = try order.orderItemList.map { item in
            ["sku": try required(E.orderItem(item).skuCode().eval()), "productName": try required(E.orderItem(item).productName().eval()),
             "quantity": try required(E.orderItem(item).quantity().eval()), "unitPriceMinor": try required(E.orderItem(item).unitPriceMinor().eval()),
             "lineTotalMinor": try required(E.orderItem(item).lineTotalMinor().eval()), "version": try required(E.orderItem(item).version().eval())]
        }
        return ["orderNumber": try required(E.customerOrder(order).orderNumber().eval()), "totalMinor": try required(E.customerOrder(order).totalMinor().eval()),
                "note": nullable(try E.customerOrder(order).orderNote().eval()), "version": try required(E.customerOrder(order).version().eval()), "items": children]
    }
}
func edit(_ context: UserContext, _ quantity: Double, _ rollback: Bool) async throws {
    guard quantity.isFinite && quantity.rounded(.towardZero) == quantity && (1...100).contains(quantity) else { throw OrderError.invalidQuantity }
    let rows = try await Q.customerOrders().withOrderNumberIs("ORD-2026-1001")
        .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(101)).limit(2)
        .comment("Load full draft and bounded full items").purpose("Validate and edit one draft order").executeForList(context)
    try require(rows.count == 1, "Expected one order"); var order = rows[0]
    try require(E.customerOrder(order).orderStatusId().eval() == 1001, "Only DRAFT orders can be edited")
    try require(E.customerOrder(order).currencyCode().eval() == "USD", "Unsupported currency")
    try require(order.orderItemList.count <= 100, "Order item limit exceeded")
    var selected: Int? = nil; var total: Int64 = 0
    for index in order.orderItemList.indices {
        let item = order.orderItemList[index]
        let price = try required(E.orderItem(item).unitPriceMinor().eval()); var units = try required(E.orderItem(item).quantity().eval())
        try require((0...100000).contains(price) && (1...100).contains(units), "Invalid persisted price or quantity")
        try require(E.orderItem(item).lineTotalMinor().eval() == price * units, "Invalid persisted line total")
        if try E.orderItem(item).skuCode().eval() == "SKU-NOTEBOOK" {
            try require(selected == nil, "Duplicate SKU"); selected = index; units = Int64(quantity)
        }
        let line = price.multipliedReportingOverflow(by: units); let sum = total.addingReportingOverflow(line.partialValue)
        try require(!line.overflow && !sum.overflow, "Money overflow"); total = sum.partialValue
    }
    let index = try required(selected); try require(total <= 1000000000, "Invalid total")
    if rollback {
        var winner = try required(try await Q.orderItems().withIdIs(required(E.orderItem(order.orderItemList[index]).id().eval())).limit(2)
            .comment("Load independent item revision").purpose("Probe atomic rollback on stale child").executeForList(context).first)
        winner.updateProductName("Notebook (concurrent winner)")
        _ = try await winner.auditAs("Advance Order item before stale graph probe").save(context)
    }
    let price = try required(E.orderItem(order.orderItemList[index]).unitPriceMinor().eval())
    order.orderItemList[index].updateQuantity(Int64(quantity)); order.orderItemList[index].updateLineTotalMinor(Int64(quantity) * price)
    order.updateTotalMinor(total); print("ORDER_GRAPH_ATTEMPT")
    _ = try await order.auditAs(editReason).save(context)
}
func completeRead(_ context: UserContext) async throws -> [String:Any] {
    let orders=try await Q.customerOrders().orderByOrderNumberAscending().orderByIdAscending().limit(10)
        .comment("Read authoritative Order states").purpose("Verify transition persistence after restart").executeForList(context)
    let deleted=try await Q.orderItems().deletedRowsOnly().withSkuCodeIs("SKU-PEN").limit(10)
        .comment("Read retained deleted Order lines").purpose("Verify explicit soft deletion after restart").executeForList(context)
    let states:[[String:Any]]=try orders.map { o in try ["orderNumber":required(E.customerOrder(o).orderNumber().eval()),"statusId":required(E.customerOrder(o).orderStatusId().eval()),"version":required(E.customerOrder(o).version().eval())] }
    let tombstones:[[String:Any]]=try deleted.map { i in try ["sku":required(E.orderItem(i).skuCode().eval()),"version":required(E.orderItem(i).version().eval())] }
    return try await ["graph":graph(context),"states":states,"deleted":tombstones]
}
func omitPreview(_ context: UserContext) async throws {
    let rows=try await Q.customerOrders().withOrderNumberIs("ORD-2026-1001")
        .selectOrderItemListWith(Q.orderItems().withSkuCodeIs("SKU-NOTEBOOK").limit(2)).limit(2)
        .comment("Load complete scalars with a filtered item preview").purpose("Prove omitted items are not deletion commands").executeForList(context)
    try require(rows.count==1 && rows[0].orderItemList.count==1,"Expected one preview line");var order=rows[0]
    order.updateOrderNote("Edited through an item preview");_ = try await order.auditAs("Edit Order note without replacing its item collection").save(context)
}
func removeLine(_ context: UserContext, _ rollback: Bool) async throws {
    let rows=try await Q.customerOrders().withOrderNumberIs("ORD-2026-1001")
        .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(101)).limit(2)
        .comment("Load complete Order for explicit line removal").purpose("Recompute total from all retained items").executeForList(context)
    try require(rows.count==1,"Expected one order");var order=rows[0]
    try require(E.customerOrder(order).orderStatusId().eval()==1001,"Only DRAFT orders can be edited")
    try require(order.orderItemList.count>1 && order.orderItemList.count<=100,"Invalid full item count")
    var selected:Int?=nil;var total:Int64=0
    for index in order.orderItemList.indices {
        let item=order.orderItemList[index], e=E.orderItem(item)
        let price=try required(e.unitPriceMinor().eval()), units=try required(e.quantity().eval())
        try require((0...100000).contains(price) && (1...100).contains(units),"Invalid persisted item amount")
        let line=price.multipliedReportingOverflow(by:units)
        try require(!line.overflow && e.lineTotalMinor().eval()==line.partialValue,"Invalid persisted total")
        if try e.skuCode().eval()=="SKU-PEN" {try require(selected==nil,"Duplicate target");selected=index}
        else {let sum=total.addingReportingOverflow(line.partialValue);try require(!sum.overflow,"Money overflow");total=sum.partialValue}
    }
    let index=try required(selected);try require(total<=1000000000,"Total overflow")
    if rollback {
        var winner=try required(try await Q.orderItems().withIdIs(required(E.orderItem(order.orderItemList[index]).id().eval())).limit(2)
            .comment("Load independent deletion competitor").purpose("Test rollback when explicit deletion is stale").executeForList(context).first)
        winner.updateProductName("Pen (concurrent winner)");_ = try await winner.auditAs("Advance Order item before stale deletion probe").save(context)
    }
    order.orderItemList[index].markForDeletion();order.updateTotalMinor(total);print("ORDER_REMOVAL_ATTEMPT")
    _ = try await order.auditAs("Remove Order line and recompute total atomically").save(context)
}
func transition(_ context: UserContext) async throws -> [String:Any] {
    let target=try required(ProcessInfo.processInfo.environment["ORDER_TARGET"])
    let next=try required(Int64(required(ProcessInfo.processInfo.environment["ORDER_NEXT_STATUS"])))
    let rows=try await Q.customerOrders().withOrderNumberIs(target).limit(2)
        .comment("Load full Order before state transition").purpose("Apply the Order lifecycle policy with original version").executeForList(context)
    try require(rows.count==1,"Expected one target");var order=rows[0]
    let current=try required(E.customerOrder(order).orderStatusId().eval())
    var result:[String:Any]=try ["target":target,"from":current,"to":next,"observedVersion":required(E.customerOrder(order).version().eval())]
    guard (current==1001 && (next==1002 || next==1003)) || (current==1002 && next==1003) else {result["outcome"]="rejected";result["reason"]="Transition not allowed";return result}
    if next==1002 {order.updateOrderStatusToConfirmed()} else {order.updateOrderStatusToCancelled()}
    _ = try await order.auditAs("Apply an allowed Order status transition").save(context);result["outcome"]="committed";result["reason"]="";return result
}

func pageRows(_ orders: [CustomerOrder], _ preview: Bool) throws -> [[String:Any]] {
    return try orders.map { o in
        var row:[String:Any]=try ["id":required(E.customerOrder(o).id().eval()),"orderNumber":required(E.customerOrder(o).orderNumber().eval()),"buyer":required(E.customerOrder(o).buyerReference().eval()),"totalMinor":required(E.customerOrder(o).totalMinor().eval()),"version":required(E.customerOrder(o).version().eval())]
        if preview {row["items"]=try o.orderItemList.map { i in try ["id":required(E.orderItem(i).id().eval()),"sku":required(E.orderItem(i).skuCode().eval()),"lineTotalMinor":required(E.orderItem(i).lineTotalMinor().eval()),"version":required(E.orderItem(i).version().eval())] as [String:Any] }}
        return row
    }
}
func boundedPage(_ context:UserContext) async throws -> [String:Any] {
    let env=ProcessInfo.processInfo.environment
    let offset=try required(Int(required(env["ORDER_PAGE_OFFSET"]))),limit=try required(Int(required(env["ORDER_PAGE_LIMIT"]))),buyer=try required(env["ORDER_PAGE_BUYER"])
    print("ORDER_PAGES_BEGIN")
    guard offset>=0 && (1...3).contains(limit) else {return ["rejected":true,"reason":"Page bounds must be offset >= 0 and limit in [1, 3]"]}
    let page=try await Q.customerOrders().withBuyerReferenceIs(buyer).orderByTotalMinorAscending().orderByIdAscending()
        .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(1)).offset(offset).limit(limit).count()
        .comment("Read bounded Order pages").purpose("Compare filtered totals and per-order item previews").executeForList(context)
    return try ["offset":offset,"limit":limit,"buyer":buyer,"rows":pageRows(Array(page),true),"total":required(page.totalCount)]
}
func exportPages(_ context:UserContext) async throws -> [String:Any] {
    let mode=try required(ProcessInfo.processInfo.environment["ORDER_EXPORT_MODE"]),complete:Bool
    complete=mode=="asc" || mode=="desc";try require(["asc","desc","miss","composite","predicate"].contains(mode),"Unknown export mode")
    var pages:[[String:Any]]=[];var fallback=0,seek=0;var ended=false;print("ORDER_PAGES_BEGIN")
    for index in 0..<(complete ? 10 : 2) {
        let offset=(index+(mode=="miss" ? 1 : 0))*3,buyer=mode=="predicate" && index==1 ? "BUYER-CONTROL" : "BUYER-EXPORT"
        var query=Q.customerOrders().withBuyerReferenceIs(buyer)
        if mode=="composite" {query=query.orderByTotalMinorAscending().orderByIdAscending()}
        else if mode=="desc" {query=query.orderByIdDescending()} else {query=query.orderByIdAscending()}
        print("ORDER_EXPORT_PAGE \(index)")
        let page=try await query.offset(offset).limit(3).optimizeForContinuousPageFetch(namespace:"order-export-"+mode,ttlSeconds:300).count()
            .comment("Export Order pages").purpose("Export complete bounded Order identities through one trusted context").executeForList(context)
        let plan=await context.continuousPageObservation().plan
        if plan=="CURSOR_SEEK" {seek+=1} else if plan.hasPrefix("OFFSET_FALLBACK:") {fallback+=1}
        pages.append(try ["offset":offset,"buyer":buyer,"rows":pageRows(Array(page),false),"total":required(page.totalCount),"plan":plan])
        if complete && page.isEmpty {ended=true;break}
    }
    try require(!complete || ended,"Export page budget exhausted");return ["mode":mode,"pages":pages,"fallbackCount":fallback,"seekCount":seek]
}

func worker(_ context: UserContext) async throws {
    let env=ProcessInfo.processInfo.environment
    let name=try required(env["ORDER_WORKER"]), target=try required(env["ORDER_TARGET"]), note=try required(env["ORDER_NOTE"])
    let rows=try await Q.customerOrders().withOrderNumberIs(target).limit(2)
        .comment("Load complete Order before write barrier").purpose("Retain original version for concurrent note update").executeForList(context)
    try require(rows.count == 1,"Expected one worker order"); var order=rows[0]
    var result: [String:Any] = try ["worker":name,"target":target,"note":note,"pid":ProcessInfo.processInfo.processIdentifier,
        "observedVersion":required(E.customerOrder(order).version().eval()),"observedNote":nullable(E.customerOrder(order).orderNote().eval())]
    let barrier=URL(fileURLWithPath:try required(env["ORDER_BARRIER"]))
    // Publish readiness only after the full JSON has been written and closed.
    // The parent may read immediately when the .ready path first appears.
    let ready=barrier.appendingPathComponent(name+".ready")
    let temporary=barrier.appendingPathComponent(name+".ready.tmp")
    try JSONSerialization.data(withJSONObject:result).write(to:temporary)
    try require(rename(temporary.path,ready.path)==0,"Cannot publish worker readiness")
    let release=barrier.appendingPathComponent(try required(env["ORDER_RELEASE"])).path
    let deadline=Date().addingTimeInterval(45)
    while !FileManager.default.fileExists(atPath:release) {
        try require(Date()<deadline,"Worker barrier timeout");try await Task.sleep(nanoseconds:10_000_000)
    }
    order.updateOrderNote(note);var outcome="committed",reason=""
    do { _ = try await order.auditAs("Revise Order note with optimistic version").save(context) }
    catch { outcome="conflict";reason=String(describing:error) }
    result["outcome"]=outcome;result["conflictReason"]=reason
    print("ORDER_WORKER "+String(decoding:try JSONSerialization.data(withJSONObject:result,options:[.sortedKeys]),as:UTF8.self))
}

// Swift's store protocol exposes obtain only. This adapter owns explicit per-key
// invalidation while delegating retention, TTL and construction to native stores.
actor ObservedIds: IdSetStore {
    var stores:[String:InMemoryIdSetStore]=[:];var events:[[String:AnySendableJSON]]=[];var lastKey:String?
    func obtain(key:String,build:@escaping @Sendable () async throws -> RetainedIdSet) async throws -> (RetainedIdSet,Bool){
        lastKey=key;events.append(["op":.text("obtain-start"),"key":.text(key)]);let store=stores[key] ?? InMemoryIdSetStore();stores[key]=store
        let (value,built)=try await store.obtain(key:key,build:build)
        events.append(["op":.text("obtain"),"key":.text(key),"hit":.flag(!built)])
        if built{events.append(["op":.text("put"),"key":.text(key),"ids":.ids(value.ids)])};return(value,built)
    }
    func invalidateLast() throws {guard let key=lastKey else{throw OrderError.invalidState("No retained key")};stores.removeValue(forKey:key);events.append(["op":.text("invalidate"),"key":.text(key)])}
    func recordWait(_ elapsed:Int64){events.append(["op":.text("wait"),"elapsedMs":.integer(elapsed)])}
    func snapshot()->[[String:AnySendableJSON]]{events}
}
enum AnySendableJSON:Sendable {case text(String),flag(Bool),ids([Int64]),integer(Int64)
    var value:Any {switch self{case .text(let v):return v;case .flag(let v):return v;case .ids(let v):return v;case .integer(let v):return v}}
}
func retainedPages(_ context:UserContext,_ store:ObservedIds) async throws -> [String:Any] {
    let mode=try required(ProcessInfo.processInfo.environment["ORDER_RETAINED_MODE"])
    let offsets=try required(["jumps":[6,0,3,9,0],"empty":[0,3],"overflow":[3,0],"isolation":[0,0,3],"expiry":[0,3],"invalidate":[0,3,6]][mode]);var pages:[[String:Any]]=[];print("ORDER_INSIGHTS_BEGIN")
    for (index,offset) in offsets.enumerated(){
        if mode=="expiry" && index==1{let start=Date();try await Task.sleep(nanoseconds:1_300_000_000);await store.recordWait(Int64(Date().timeIntervalSince(start)*1000))}
        if mode=="invalidate" && index==2{try await store.invalidateLast()}
        let buyer=mode=="empty" ? "BUYER-MISSING" : mode=="isolation" && index==1 ? "BUYER-CONTROL" : "BUYER-EXPORT";print("ORDER_RETAINED_PAGE \(index)")
        let page=try await Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs("USD").orderByTotalMinorAscending().orderByIdAscending()
            .offset(offset).limit(3).optimizePaginationWithIdSet(namespace:"order-retained-"+mode,ttlSeconds:mode=="expiry" ? 1 : 300,maxIds:mode=="overflow" ? 4 : 20).count()
            .comment("Read retained Order IDs").purpose("Verify random jumps and retained-set lifecycle").executeForList(context)
        let observed=await context.idSetPaginationObservation()
        pages.append(["offset":offset,"buyer":buyer,"currency":"USD","rows":try pageRows(Array(page),false),"total":try required(page.totalCount),"plan":observed.plan,"observedCount":observed.count])
    }
    let events=await store.snapshot();return ["mode":mode,"pages":pages,"events":events.map{$0.mapValues{$0.value}}]
}
func aggregateNumber(_ row:TeaQLRecord,_ field:String) throws -> Double {NSDecimalNumber(decimal:try required(row[field]?.decimalValue)).doubleValue}
func orderSummary(_ context:UserContext) async throws -> [String:Any]{
    let buyer=try required(ProcessInfo.processInfo.environment["ORDER_SUMMARY_BUYER"]),currency=try required(ProcessInfo.processInfo.environment["ORDER_SUMMARY_CURRENCY"])
    let minimum=Int64(try required(ProcessInfo.processInfo.environment["ORDER_SUMMARY_MINIMUM"]))!;print("ORDER_INSIGHTS_BEGIN")
    let groups=try await Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
        .groupByOrderStatus().countAs("count").sumTotalMinorAs("totalMinor").limit(4)
        .comment("Summarize filtered Order amounts by status").purpose("Compute same-currency Order summaries in the provider").executeForRows(context)
    let summary=try await Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
        .countAs("count").sumTotalMinorAs("totalMinor").limit(1)
        .comment("Summarize the complete filtered Order set").purpose("Compare exact counts and money independent of page size").executeForRows(context)
    var sets:[[String:Double]]=[];var rows:[[String:Any]]=[];var total:Int64=0
    for all in [true,false]{
        let page=try await Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
            .facetByOrderStatusAs("statuses",Q.orderStatusesWithMinimalFields().selectCode().countCustomerOrdersAs("count").limit(4),includeAllFacets:all)
            .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(1)).orderByIdAscending().limit(3).count()
            .comment("Read Order status buckets and bounded item previews").purpose("Keep rows facets and counts on the same filtered set").executeForList(context)
        sets.append(try Dictionary(uniqueKeysWithValues:required(page.facet("statuses")).map{(try required($0["code"]?.stringValue),try aggregateNumber($0,"count"))}))
        if all{rows=try pageRows(Array(page),true);total=Int64(try required(page.totalCount))}
    }
    let summaryRows:[[String:Any]]=try summary.map{r in ["count":try aggregateNumber(r,"count"),"totalMinor":r["totalMinor"]?.decimalValue.map{NSDecimalNumber(decimal:$0).doubleValue as Any} ?? NSNull()]}
    return ["buyer":buyer,"currency":currency,"minimum":minimum,"groups":try groups.map{["statusId":try aggregateNumber($0,"orderStatus"),"count":try aggregateNumber($0,"count"),"totalMinor":try aggregateNumber($0,"totalMinor")]},
        "summary":summaryRows,"allBuckets":sets[0],"matchedBuckets":sets[1],"rows":rows,"total":total]
}

let phase = try required(CommandLine.arguments.dropFirst().first)
let provider = try SQLiteDataService(path: required(ProcessInfo.processInfo.environment["ORDER_DATABASE"]))
var runtime = TeaQLRuntime(); try runtime.install(GeneratedRuntimeModule.module)
let retainedStore=ObservedIds()
let context = UserContext(runtime: runtime, actor: "order-example", trustedTenant: "order-example",
    queryExecutor: provider, mutationExecutor: provider, requestPolicy: RequestPolicy { $0 },idSetStore:retainedStore)
if phase != "worker" { try await context.ensureSchema(GeneratedRuntimeModule.module) }
switch phase {
case "insights-retained": try report(phase,await retainedPages(context,retainedStore))
case "insights-summary": try report(phase,await orderSummary(context))
case "pages-bounded": try report(phase,await boundedPage(context))
case "pages-export": try report(phase,await exportPages(context))
case "complete-read": try report(phase,await completeRead(context))
case "omission-probe": try await omitPreview(context);try report(phase,["previewCount":1])
case "remove-line": try await removeLine(context,false);try report(phase,["removed":"SKU-PEN"])
case "remove-conflict":
    var failure:Error?=nil;do {try await removeLine(context,true)} catch {failure=error}
    try report(phase,["rejected":true,"reason":String(describing:required(failure))])
case "transition": try report(phase,await transition(context))
case "guard-edit":
    var reason="";do {try await edit(context,3,false)} catch OrderError.invalidState(let message) {reason=message}
    try require(reason=="Only DRAFT orders can be edited","Expected state policy rejection");try report(phase,["rejected":true,"reason":reason])

case "worker": try await worker(context)
case "bootstrap": break
case "seed":
    let decoder = JSONDecoder(); decoder.keyDecodingStrategy = .convertFromSnakeCase
    let fixture = try decoder.decode(Fixture.self, from: Data(contentsOf: URL(fileURLWithPath: required(ProcessInfo.processInfo.environment["ORDER_FIXTURE"]))))
    for input in fixture.orders {
        var order = try Q.customerOrders().comment("Create fixture order").purpose("Seed Order workflow").newEntity(context)
        order.updateCommercePlatform(1);switch input.orderStatus{case "DRAFT":order.updateOrderStatusToDraft();case "CONFIRMED":order.updateOrderStatusToConfirmed();case "CANCELLED":order.updateOrderStatusToCancelled();default:throw OrderError.invalidState("Unknown fixture status")}; order.updateOrderNumber(input.orderNumber); order.updateBuyerReference(input.buyerReference)
        order.updateCurrencyCode(input.currencyCode); order.updateTotalMinor(input.totalMinor); order.updateOrderNote(input.orderNote)
        _ = try await order.auditAs(seedReason).save(context)
        let savedRows = try await Q.customerOrders().withOrderNumberIs(input.orderNumber).limit(2)
            .comment("Reload persisted order identity").purpose("Attach items to the authoritative saved order").executeForList(context)
        try require(savedRows.count == 1, "Expected one saved order")
        let id = try required(E.customerOrder(savedRows[0]).id().eval())
        for line in input.items {
            var item = try Q.orderItems().comment("Create fixture item").purpose("Seed Order workflow").newEntity(context)
            item.updateCustomerOrder(id); item.updateSkuCode(line.skuCode); item.updateProductName(line.productName); item.updateQuantity(line.quantity)
            item.updateUnitPriceMinor(line.unitPriceMinor); item.updateLineTotalMinor(line.lineTotalMinor); _ = try await item.auditAs(seedReason).save(context)
        }
    }
// scenario: draft-graph, restart-readback
case "p1-read", "draft-graph", "restart-readback": try report(phase, await graph(context))
// scenario: note-value, note-null, note-empty
case "note-value", "note-null", "note-empty":
    let number = phase == "note-null" ? "ORD-2026-1002" : phase == "note-empty" ? "ORD-2026-1003" : "ORD-2026-1001"
    let order = try required(try await Q.customerOrdersWithMinimalFields().selectOrderNote().withOrderNumberIs(number).limit(2)
        .comment("Select nullable order note").purpose("Verify loaded note and null-only default").executeForList(context).first)
    try report(phase, ["value": nullable(E.customerOrder(order).orderNote().eval()), "fallback": E.customerOrder(order).orderNote().orElse("No note")])
// scenario: note-not-loaded
case "note-not-loaded":
    let order = try required(try await Q.customerOrdersWithMinimalFields().selectOrderNumber().withOrderNumberIs("ORD-2026-1001").limit(2)
        .comment("Omit order note from projection").purpose("Expose missing-field errors").executeForList(context).first)
    try report(phase, ["eval": missing { try E.customerOrder(order).orderNote().eval() }, "fallback": missing { try E.customerOrder(order).orderNote().orElse("No note") }])
// scenario: invalid-quantity
case "invalid-quantity":
    var results: [[String: Any]] = []
    for quantity in [0.0, -1.0, 1.5, 101.0] {
        do { try await edit(context, quantity, false); throw OrderError.invalidState("Invalid quantity accepted") }
        catch OrderError.invalidQuantity { results.append(["quantity": quantity, "rejected": true, "reason": "Quantity must be an integer in [1, 100]"]) }
    }; try report(phase, results)
// scenario: draft-edit
case "draft-edit": try await edit(context, 3, false); try report(phase, await graph(context))
case "rollback-probe":
    var conflict: Error? = nil
    do { try await edit(context, 3, true) } catch { conflict = error }
    try report(phase, ["rejected": true, "reason": String(describing: required(conflict))])
default: throw OrderError.invalidState("Unknown phase")
}
print("ORDER_OK phase=" + phase)
