A Unified Actor Architecture for Clef

// Alloy.Actors - Core abstraction shared across targets
namespace Alloy.Actors

/// Marker for actor message types
type IActorMessage = interface end

/// Actor reference - opaque handle for message sending
[<Struct>]
type ActorRef<'Message when 'Message :> IActorMessage> = {
    Id: ActorId
    // Target-specific routing info is internal
}

/// Core actor behavior definition
type ActorBehavior<'State, 'Message when 'Message :> IActorMessage> = {
    /// Initial state factory
    Init: unit -> 'State
    
    /// Message handler - returns new state
    Receive: 'State -> 'Message -> ActorEffect<'State>
    
    /// Optional: handle actor lifecycle events
    Lifecycle: 'State -> LifecycleEvent -> ActorEffect<'State>
}

/// Effects an actor can produce (interpreted by runtime)
and ActorEffect<'State> =
    | Continue of 'State
    | ContinueWith of 'State * SideEffect list
    | Stop of reason: string
    | Restart of 'State
    | Escalate of exn

and SideEffect =
    | Tell of target: ActorId * message: obj
    | Spawn of spec: ActorSpec * replyTo: ActorId option
    | Schedule of delay: TimeSpan * message: obj
    | Log of level: LogLevel * message: string

/// Supervision strategy (same semantics, different implementations)
type SupervisionStrategy =
    | OneForOne of maxRestarts: int * window: TimeSpan
    | AllForOne of maxRestarts: int * window: TimeSpan
    | RestForOne of maxRestarts: int * window: TimeSpan

/// Actor specification for spawning
type ActorSpec = {
    Behavior: obj  // Type-erased ActorBehavior
    Supervision: SupervisionStrategy option
    Capabilities: Set<Capability>
    Name: string option
}

module Alloy.Actors.Builder

type ActorBuilder() =
    member _.Yield(_) = Continue Unchecked.defaultof<_>
    
    member _.Bind(effect: ActorEffect<'a>, f: 'a -> ActorEffect<'b>) =
        match effect with
        | Continue state -> f state
        | ContinueWith(state, effects) -> 
            match f state with
            | Continue s' -> ContinueWith(s', effects)
            | ContinueWith(s', effects') -> ContinueWith(s', effects @ effects')
            | other -> other
        | Stop reason -> Stop reason
        | Restart state -> Restart state
        | Escalate exn -> Escalate exn
    
    member _.Return(state) = Continue state
    
    member _.ReturnFrom(effect) = effect
    
    [<CustomOperation("tell")>]
    member _.Tell(state, target: ActorRef<'M>, message: 'M) =
        ContinueWith(state, [Tell(target.Id, box message)])
    
    [<CustomOperation("spawn")>]
    member _.Spawn(state, spec: ActorSpec) =
        ContinueWith(state, [Spawn(spec, None)])
    
    [<CustomOperation("scheduleOnce")>]
    member _.ScheduleOnce(state, delay: TimeSpan, message: 'M) =
        ContinueWith(state, [Schedule(delay, box message)])
    
    [<CustomOperation("stop")>]
    member _.Stop(_, reason: string) = Stop reason

let actor = ActorBuilder()

// Works identically in Fidelity (native) and Conclave (Cloudflare)
type CounterMessage =
    | Increment
    | Decrement
    | GetCount of replyTo: ActorRef<CountResponse>
    interface IActorMessage

type CountResponse =
    | Count of int
    interface IActorMessage

let counterBehavior = {
    Init = fun () -> 0
    
    Receive = fun count msg -> actor {
        match msg with
        | Increment -> 
            return count + 1
            
        | Decrement -> 
            return count - 1
            
        | GetCount replyTo ->
            tell replyTo (Count count)
            return count
    }
    
    Lifecycle = fun count event -> actor {
        match event with
        | PreStart -> 
            return count
        | PostStop ->
            return count
        | PreRestart reason ->
            return count
    }
}

// Olivier.Runtime - Native compilation target
namespace Olivier.Runtime

open Alloy.Actors

/// Native actor instance with memory arena
type OlivierActor<'State, 'Message when 'Message :> IActorMessage>
    (behavior: ActorBehavior<'State, 'Message>, arena: MemoryArena) =
    
    let mutable state = behavior.Init()
    let mailbox = MailboxProcessor<'Message>.Start(fun inbox ->
        let rec loop () = async {
            let! msg = inbox.Receive()
            let effect = behavior.Receive state msg
            state <- interpretEffect effect
            return! loop()
        }
        loop()
    )
    
    interface IDisposable with
        member _.Dispose() =
            arena.Release()
    
    member _.Tell(msg: 'Message) = mailbox.Post(msg)
    member _.State = state

/// Prospero supervisor for native actors
type Prospero(strategy: SupervisionStrategy) =
    let children = ConcurrentDictionary<ActorId, IDisposable>()
    
    member _.Supervise(id: ActorId, actor: IDisposable) =
        children.TryAdd(id, actor) |> ignore
    
    member _.HandleFailure(id: ActorId, exn: exn) =
        match strategy with
        | OneForOne(max, window) ->
            restartActor id
        | AllForOne(max, window) ->
            children.Keys |> Seq.iter restartActor
        | RestForOne(max, window) ->
            restartFrom id

// Conclave.Runtime - WebSocket-based actor
namespace Conclave.Runtime

open Alloy.Actors
open Fable.Core

[<AttachMembers>]
type ConclaveActor<'State, 'Message when 'Message :> IActorMessage>
    (behavior: ActorBehavior<'State, 'Message>) =
    inherit DurableObject()
    
    let mutable state: 'State option = None
    let connections = Dictionary<ActorId, WebSocket>()
    
    /// Accept WebSocket upgrade for actor-to-actor communication
    member this.fetch(request: Request) = promise {
        let upgradeHeader = request.headers.get("Upgrade")
        
        if upgradeHeader = Some "websocket" then
            let pair = WebSocketPair.Create()
            let client = pair.Client
            let server = pair.Server
            
            this.ctx.acceptWebSocket(server)
            
            return Response.create(
                null,
                {| status = 101; webSocket = client |}
            )
        else
            return Response.json({| status = "healthy" |})
    }
    
    /// Handle incoming WebSocket messages
    member this.webSocketMessage(ws: WebSocket, message: string) = promise {
        // Hydrate state if needed (after hibernation)
        if state.IsNone then
            let! stored = this.ctx.storage.get<'State>("state")
            state <- stored |> Option.orElseWith (fun () -> Some (behavior.Init()))
        
        let actorMessage = deserialize<'Message> message
        
        let effect = behavior.Receive state.Value actorMessage
        let (newState, sideEffects) = interpretEffect effect
        
        do! this.ctx.storage.put("state", newState)
        state <- Some newState
        
        for effect in sideEffects do
            do! this.executeSideEffect(effect)
    }
    
    /// Handle WebSocket close
    member this.webSocketClose(ws: WebSocket, code: int, reason: string) =
        let actorId = findActorBySocket ws
        connections.Remove(actorId) |> ignore
    
    /// Execute side effects over WebSocket connections
    member private this.executeSideEffect(effect: SideEffect) = promise {
        match effect with
        | Tell(targetId, msg) ->
            match connections.TryGetValue(targetId) with
            | true, ws ->
                ws.send(serialize msg)
            | false, _ ->
                let! ws = this.connectToActor(targetId)
                connections.[targetId] <- ws
                ws.send(serialize msg)
                
        | Spawn(spec, replyTo) ->
            let! actorRef = this.spawnChild(spec)
            match replyTo with
            | Some ref -> 
                do! this.executeSideEffect(Tell(ref.Id, box (Spawned actorRef)))
            | None -> ()
            
        | Schedule(delay, msg) ->
            do! this.ctx.storage.setAlarm(DateTime.UtcNow + delay)
            do! this.ctx.storage.put("scheduled", msg)
            
        | Log(level, message) ->
            console.log($"[{level}] {message}")
    }
    
    /// Establish WebSocket connection to another actor
    member private this.connectToActor(targetId: ActorId) = promise {
        let targetStub = this.env.ACTORS.[targetId]
        let targetUrl = $"wss://{targetId}/ws"
        
        let! response = targetStub.fetch(
            Request.create(targetUrl, {| 
                headers = {| Upgrade = "websocket" |} 
            |})
        )
        
        return response.webSocket
    }
    
    /// Handle scheduled alarms
    member this.alarm() = promise {
        let! scheduled = this.ctx.storage.get<obj>("scheduled")
        match scheduled with
        | Some msg ->
            do! this.ctx.storage.delete("scheduled")
            do! this.webSocketMessage(null, serialize msg)
        | None -> ()
    }

// Alloy.Actors.Channels - Transport abstraction
namespace Alloy.Actors

/// Bidirectional persistent channel between actors
/// Carries BAREWire-encoded frames over transport
type IActorChannel =
    abstract member Send: byte[] -> Async<unit>
    abstract member Receive: unit -> Async<byte[]>
    abstract member Close: unit -> Async<unit>
    abstract member IsOpen: bool

// Fidelity implementation: IPC transport
type IPCChannel(endpoint: IPC.Endpoint) =
    interface IActorChannel with
        member _.Send(data) = async {
            do! endpoint.WriteAsync(data)
        }
        member _.Receive() = async {
            return! endpoint.ReadAsync()
        }
        member _.Close() = async {
            endpoint.Dispose()
        }
        member _.IsOpen = endpoint.IsConnected

// Conclave implementation: WebSocket transport
type WebSocketChannel(ws: WebSocket) =
    let receiveQueue = Queue<byte[]>()
    let mutable pendingReceive: AsyncReplyChannel<byte[]> option = None
    
    do ws.addEventListener("message", fun e ->
        let data = e.data :?> ArrayBuffer |> toByteArray
        match pendingReceive with
        | Some reply ->
            reply.Reply(data)
            pendingReceive <- None
        | None ->
            receiveQueue.Enqueue(data)
    )
    
    interface IActorChannel with
        member _.Send(data) = async {
            ws.send(ofByteArray data)
        }
        member _.Receive() = async {
            if receiveQueue.Count > 0 then
                return receiveQueue.Dequeue()
            else
                return! Async.FromContinuations(fun (resolve, _, _) ->
                    pendingReceive <- Some { new AsyncReplyChannel<_> with
                        member _.Reply(v) = resolve v
                    }
                )
        }
        member _.Close() = async {
            ws.close()
        }
        member _.IsOpen = ws.readyState = WebSocketState.Open

type ActorRef<'Message when 'Message :> IActorMessage> with
    
    member this.Ask<'Response>(message: 'Message, timeout: TimeSpan) : Async<'Response> =
        async {
            let correlationId = Guid.NewGuid()
            let! channel = ChannelFactory.Connect(this.Id)
            
            let envelope = {| 
                correlationId = correlationId
                payload = message 
                expectsReply = true
            |}
            do! channel.Send(serialize envelope)
            
            let! response = 
                channel.Receive()
                |> Async.withTimeout timeout
            
            let responseEnvelope = deserialize<ResponseEnvelope<'Response>> response
            
            if responseEnvelope.correlationId = correlationId then
                return responseEnvelope.payload
            else
                return! failwith "Correlation mismatch"
        }

type ConclaveSupervisor(strategy: SupervisionStrategy) =
    inherit DurableObject()
    
    let children = Dictionary<ActorId, WebSocket * ActorSpec>()
    
    member this.spawnChild(spec: ActorSpec) = promise {
        let! actor = this.env.loader.loadWorker {
            script = spec.implementation
            bindings = {|
                SUPERVISOR = this.env.SELF
            |}
            props = spec.Capabilities
        }
        
        let! ws = this.connectToActor(actor.id)
        children.[actor.id] <- (ws, spec)
        
        ws.addEventListener("close", fun _ ->
            this.handleChildDisconnect(actor.id)
        )
        ws.addEventListener("error", fun e ->
            this.handleChildError(actor.id, e)
        )
        
        return ActorRef(actor.id)
    }
    
    member private this.handleChildDisconnect(childId: ActorId) =
        match strategy with
        | OneForOne(maxRestarts, window) ->
            let (_, spec) = children.[childId]
            this.spawnChild(spec) |> ignore
            
        | AllForOne(maxRestarts, window) ->
            let specs = children.Values |> Seq.map snd |> List.ofSeq
            children.Clear()
            for spec in specs do
                this.spawnChild(spec) |> ignore
                
        | RestForOne(maxRestarts, window) ->
            ()

// Alloy.Actors.Protocol - BAREWire message framing
namespace Alloy.Actors

/// Actor message envelope (BAREWire-encoded on all targets)
type MessageEnvelope = {
    sourceId: ActorId
    targetId: ActorId
    correlationId: Guid option
    messageType: string
    payload: byte[]
    timestamp: int64
}

module ActorProtocol =
    let encode (envelope: MessageEnvelope) : byte[] =
        BAREWire.Codec.encode envelope
    
    let decode (data: byte[]) : MessageEnvelope =
        BAREWire.Codec.decode<MessageEnvelope> data

// Alloy.Actors.State - Abstraction over state persistence
namespace Alloy.Actors

type IActorState<'State> =
    abstract member Load: unit -> Async<'State option>
    abstract member Save: 'State -> Async<unit>
    abstract member Transaction: ('State -> 'State * 'Result) -> Async<'Result>

// Fidelity implementation: synchronous, in-memory
type OlivierState<'State>(arena: MemoryArena) =
    let mutable state: 'State option = None
    
    interface IActorState<'State> with
        member _.Load() = async { return state }
        member _.Save(s) = async { state <- Some s }
        member _.Transaction(f) = async {
            let (newState, result) = f state.Value
            state <- Some newState
            return result
        }

// Conclave implementation: async, persistent
type DurableObjectState<'State>(storage: DurableObjectStorage) =
    interface IActorState<'State> with
        member _.Load() = async {
            let! stored = storage.get<'State>("state") |> Async.AwaitPromise
            return stored
        }
        member _.Save(s) = async {
            do! storage.put("state", s) |> Async.AwaitPromise
        }
        member _.Transaction(f) = async {
            return! storage.transaction(fun txn ->
                let current = txn.get<'State>("state")
                let (newState, result) = f current
                txn.put("state", newState)
                result
            ) |> Async.AwaitPromise
        }

// Standalone .NET actor implementation
namespace FSharp.Actors

open System.Collections.Concurrent

/// MailboxProcessor-backed actor with full scaffolding
type DotNetActor<'State, 'Message when 'Message :> IActorMessage>
    (behavior: ActorBehavior<'State, 'Message>,
     config: ActorConfig,
     metrics: ActorMetrics option,
     supervisor: ISupervisor option) =
    
    let mutable state = behavior.Init()
    let mutable restartCount = 0
    let resources = ConcurrentDictionary<ResourceId, IDisposable>()
    let children = ConcurrentDictionary<ActorId, DotNetActorRef>()
    
    let errorHandler = 
        config.ErrorPolicy 
        |> Option.defaultValue ErrorPolicy.defaultPolicy
    
    let mailbox = MailboxProcessor<ActorMessage<'Message>>.Start(fun inbox ->
        let rec loop () = async {
            let! envelope = inbox.Receive()
            
            match envelope with
            | UserMessage msg ->
                do! processMessage msg
                return! loop()
                
            | SystemMessage sysMsg ->
                match sysMsg with
                | Terminate reason ->
                    do! cleanup reason
                | Restart ->
                    do! restart()
                    return! loop()
                | ChildFailed(childId, exn) ->
                    do! handleChildFailure childId exn
                    return! loop()
        }
        and processMessage msg = async {
            let sw = Stopwatch.StartNew()
            try
                // Pre-receive hook for metrics
                metrics |> Option.iter (fun m -> m.MessagesReceived.Increment())
                
                // Apply behavior
                let effect = behavior.Receive state msg
                
                // Interpret effect
                let! newState = interpretEffect effect
                state <- newState
                
                // Post-receive metrics
                metrics |> Option.iter (fun m -> 
                    m.MessagesProcessed.Increment()
                    m.ProcessingTime.Record(sw.ElapsedMilliseconds))
                    
            with exn ->
                metrics |> Option.iter (fun m -> m.ErrorCount.Increment())
                do! handleError exn
        }
        and interpretEffect effect = async {
            match effect with
            | Continue newState -> 
                return newState
                
            | ContinueWith(newState, sideEffects) ->
                for effect in sideEffects do
                    do! executeSideEffect effect
                return newState
                
            | Stop reason ->
                do! cleanup reason
                return state
                
            | Restart newState ->
                restartCount <- restartCount + 1
                metrics |> Option.iter (fun m -> m.RestartCount.Increment())
                return newState
                
            | Escalate exn ->
                match supervisor with
                | Some sup -> sup.HandleFailure(selfId, exn)
                | None -> raise exn
                return state
        }
        and executeSideEffect effect = async {
            match effect with
            | Tell(targetId, msg) ->
                // Route through actor registry
                match ActorRegistry.tryFind targetId with
                | Some target -> target.Post(msg)
                | None -> 
                    // Remote actor - use transport
                    do! Transport.send targetId (BAREWire.encode msg)
                    
            | Spawn(spec, replyTo) ->
                let! childRef = spawnChild spec
                children.TryAdd(childRef.Id, childRef) |> ignore
                match replyTo with
                | Some ref -> 
                    do! executeSideEffect (Tell(ref.Id, box (Spawned childRef)))
                | None -> ()
                
            | Schedule(delay, msg) ->
                do! Async.Sleep(int delay.TotalMilliseconds)
                mailbox.Post(UserMessage (msg :?> 'Message))
                
            | Log(level, message) ->
                Logger.log level message
        }
        and handleError exn = async {
            match errorHandler exn state with
            | Resume -> ()
            | RestartWith newState ->
                state <- newState
                restartCount <- restartCount + 1
            | Escalate ->
                match supervisor with
                | Some sup -> sup.HandleFailure(selfId, exn)
                | None -> raise exn
            | ErrorPolicy.Stop reason ->
                do! cleanup reason
        }
        and cleanup reason = async {
            // Run cleanup hooks
            for KeyValue(_, resource) in resources do
                try resource.Dispose() with _ -> ()
            resources.Clear()
            
            // Terminate children
            for KeyValue(id, child) in children do
                child.Post(SystemMessage (Terminate reason))
            children.Clear()
        }
        and restart () = async {
            do! cleanup "restart"
            state <- behavior.Init()
        }
        and handleChildFailure childId exn = async {
            match config.Supervision with
            | Some (OneForOne(maxRestarts, window)) ->
                match children.TryGetValue(childId) with
                | true, child -> child.Post(SystemMessage Restart)
                | false, _ -> ()
                
            | Some (AllForOne(maxRestarts, window)) ->
                for KeyValue(_, child) in children do
                    child.Post(SystemMessage Restart)
                    
            | Some (RestForOne(maxRestarts, window)) ->
                // Restart from failed child onward
                let childList = children |> Seq.toList
                let idx = childList |> List.findIndex (fun kv -> kv.Key = childId)
                for kv in childList |> List.skip idx do
                    kv.Value.Post(SystemMessage Restart)
                    
            | None ->
                // No supervision strategy - escalate
                match supervisor with
                | Some sup -> sup.HandleFailure(selfId, exn)
                | None -> raise exn
        }
        
        loop()
    )
    
    let selfId = ActorId.generate()
    
    member _.Id = selfId
    member _.Tell(msg: 'Message) = mailbox.Post(UserMessage msg)
    member _.State = state
    
    /// Acquire a tracked resource
    member _.AcquireResource<'R when 'R :> IDisposable>(factory: unit -> 'R) =
        let resource = factory()
        let id = ResourceId.generate()
        resources.TryAdd(id, resource :> IDisposable) |> ignore
        resource
    
    interface IDisposable with
        member _.Dispose() =
            mailbox.Post(SystemMessage (Terminate "disposed"))

and ActorMessage<'T> =
    | UserMessage of 'T
    | SystemMessage of SystemMessage

and SystemMessage =
    | Terminate of reason: string
    | Restart
    | ChildFailed of ActorId * exn

/// .NET Supervisor implementation
type DotNetSupervisor(strategy: SupervisionStrategy) =
    let children = ConcurrentDictionary<ActorId, DotNetActorRef * ActorSpec>()
    let restartCounts = ConcurrentDictionary<ActorId, int * DateTime>()
    
    interface ISupervisor with
        member this.HandleFailure(childId: ActorId, exn: exn) =
            let (maxRestarts, window) = 
                match strategy with
                | OneForOne(m, w) -> (m, w)
                | AllForOne(m, w) -> (m, w)
                | RestForOne(m, w) -> (m, w)
            
            // Check restart limits
            let (count, windowStart) = 
                restartCounts.GetOrAdd(childId, fun _ -> (0, DateTime.UtcNow))
            
            if DateTime.UtcNow - windowStart > window then
                // Reset window
                restartCounts.[childId] <- (1, DateTime.UtcNow)
                this.ApplyStrategy(childId, exn)
            elif count < maxRestarts then
                restartCounts.[childId] <- (count + 1, windowStart)
                this.ApplyStrategy(childId, exn)
            else
                // Max restarts exceeded - terminate
                match children.TryGetValue(childId) with
                | true, (actor, _) -> 
                    actor.Post(SystemMessage (Terminate "max restarts exceeded"))
                | false, _ -> ()
        
        member _.Supervise(id: ActorId, actor: DotNetActorRef, spec: ActorSpec) =
            children.TryAdd(id, (actor, spec)) |> ignore
    
    member private this.ApplyStrategy(failedId: ActorId, exn: exn) =
        match strategy with
        | OneForOne _ ->
            match children.TryGetValue(failedId) with
            | true, (actor, _) -> actor.Post(SystemMessage Restart)
            | false, _ -> ()
            
        | AllForOne _ ->
            for KeyValue(_, (actor, _)) in children do
                actor.Post(SystemMessage Restart)
                
        | RestForOne _ ->
            let childList = children |> Seq.toList
            let idx = 
                childList 
                |> List.tryFindIndex (fun kv -> kv.Key = failedId)
                |> Option.defaultValue 0
            for kv in childList |> List.skip idx do
                let (actor, _) = kv.Value
                actor.Post(SystemMessage Restart)
    
    /// Spawn a child actor under this supervisor
    member this.Spawn<'State, 'Message when 'Message :> IActorMessage>
        (behavior: ActorBehavior<'State, 'Message>, ?config: ActorConfig) =
        
        let cfg = config |> Option.defaultValue ActorConfig.defaults
        let actor = new DotNetActor<'State, 'Message>(
            behavior, cfg, None, Some (this :> ISupervisor))
        
        children.TryAdd(actor.Id, (actor :> DotNetActorRef, { 
            Behavior = box behavior
            Supervision = cfg.Supervision
            Capabilities = Set.empty
            Name = None
        })) |> ignore
        
        actor

/// Transport abstraction for .NET actors
type ITransport =
    abstract member Send: ActorId -> byte[] -> Async<unit>
    abstract member Receive: ActorId -> Async<byte[]>
    abstract member Connect: ActorId -> Async<IActorChannel>

/// In-process transport (same AppDomain)
type InProcessTransport() =
    let channels = ConcurrentDictionary<ActorId * ActorId, BlockingCollection<byte[]>>()
    
    interface ITransport with
        member _.Send targetId data = async {
            let selfId = ActorContext.currentId()
            let key = (selfId, targetId)
            let channel = channels.GetOrAdd(key, fun _ -> BlockingCollection<byte[]>())
            channel.Add(data)
        }
        member _.Receive sourceId = async {
            let selfId = ActorContext.currentId()
            let key = (sourceId, selfId)
            let channel = channels.GetOrAdd(key, fun _ -> BlockingCollection<byte[]>())
            return channel.Take()
        }
        member _.Connect targetId = async {
            return InProcessChannel(targetId) :> IActorChannel
        }

/// TCP transport for distributed .NET actors
type TcpTransport(bindAddress: IPEndPoint) =
    let listener = TcpListener(bindAddress)
    let connections = ConcurrentDictionary<ActorId, TcpClient>()
    
    interface ITransport with
        member _.Send targetId data = async {
            let! client = getOrConnect targetId
            let stream = client.GetStream()
            // BAREWire length-prefixed frame
            let length = BitConverter.GetBytes(data.Length)
            do! stream.AsyncWrite(length, 0, 4)
            do! stream.AsyncWrite(data, 0, data.Length)
        }
        member _.Receive sourceId = async {
            let! client = getOrConnect sourceId
            let stream = client.GetStream()
            let lengthBuf = Array.zeroCreate 4
            let! _ = stream.AsyncRead(lengthBuf, 0, 4)
            let length = BitConverter.ToInt32(lengthBuf, 0)
            let data = Array.zeroCreate length
            let! _ = stream.AsyncRead(data, 0, length)
            return data
        }
        member _.Connect targetId = async {
            let! client = getOrConnect targetId
            return TcpChannel(client) :> IActorChannel
        }

/// Named pipe transport for local IPC
type NamedPipeTransport(pipeName: string) =
    interface ITransport with
        // Similar pattern using NamedPipeServerStream/NamedPipeClientStream
        member _.Send targetId data = async { (* ... *) }
        member _.Receive sourceId = async { (* ... *) }
        member _.Connect targetId = async { (* ... *) }

/// Build complete actor systems with scaffolding
type ActorSystemBuilder() =
    let mutable transport: ITransport = InProcessTransport() :> ITransport
    let mutable metrics: IMetricsProvider option = None
    let mutable defaultSupervision = OneForOne(3, TimeSpan.FromMinutes(1.0))
    
    member this.WithTransport(t: ITransport) =
        transport <- t
        this
    
    member this.WithMetrics(m: IMetricsProvider) =
        metrics <- Some m
        this
    
    member this.WithDefaultSupervision(s: SupervisionStrategy) =
        defaultSupervision <- s
        this
    
    member this.Build() =
        ActorSystem(transport, metrics, defaultSupervision)

and ActorSystem(transport, metrics, defaultSupervision) =
    let registry = ConcurrentDictionary<ActorId, obj>()
    let rootSupervisor = DotNetSupervisor(defaultSupervision)
    
    /// Spawn a top-level actor
    member this.Spawn<'State, 'Message when 'Message :> IActorMessage>
        (behavior: ActorBehavior<'State, 'Message>, ?config: ActorConfig) =
        
        let cfg = config |> Option.defaultValue ActorConfig.defaults
        let actorMetrics = 
            metrics |> Option.map (fun m -> m.CreateActorMetrics(typeof<'Message>.Name))
        
        let actor = new DotNetActor<'State, 'Message>(
            behavior, cfg, actorMetrics, Some (rootSupervisor :> ISupervisor))
        
        registry.TryAdd(actor.Id, actor) |> ignore
        rootSupervisor.Supervise(actor.Id, actor, cfg)
        
        ActorRef<'Message>(actor.Id)
    
    /// Create a supervisor for a subtree
    member this.CreateSupervisor(?strategy: SupervisionStrategy) =
        let strat = strategy |> Option.defaultValue defaultSupervision
        DotNetSupervisor(strat)

/// Convenience functions
module ActorSystem =
    let create() = ActorSystemBuilder()
    
    let spawn behavior (system: ActorSystem) =
        system.Spawn(behavior)
    
    let spawnWith behavior config (system: ActorSystem) =
        system.Spawn(behavior, config)

open FSharp.Actors

// Define messages
type CounterMsg =
    | Increment
    | Decrement
    | GetCount of AsyncReplyChannel<int>

// Define behavior
let counterBehavior = {
    Init = fun () -> 0
    Receive = fun count msg -> actor {
        match msg with
        | Increment -> return count + 1
        | Decrement -> return count - 1
        | GetCount reply ->
            reply.Reply(count)
            return count
    }
    Lifecycle = fun count _ -> actor { return count }
}

// Build system with full scaffolding
let system = 
    ActorSystem.create()
        .WithTransport(InProcessTransport())
        .WithMetrics(PrometheusMetrics())
        .WithDefaultSupervision(OneForOne(5, TimeSpan.FromMinutes(1.0)))
        .Build()

// Spawn actors
let counter1 = system.Spawn(counterBehavior)
let counter2 = system.Spawn(counterBehavior, { 
    ActorConfig.defaults with
        ErrorPolicy = Some (RestartWith 0)
        BackpressurePolicy = Some (DropOldest 1000)
})

// Use actors
counter1.Tell(Increment)
counter1.Tell(Increment)

// Ask pattern
let! count = counter1.Ask(GetCount, TimeSpan.FromSeconds(5.0))
printfn "Count: %d" count

// Supervision example
let supervisor = system.CreateSupervisor(AllForOne(3, TimeSpan.FromMinutes(1.0)))

let worker1 = supervisor.Spawn(workerBehavior)
let worker2 = supervisor.Spawn(workerBehavior)
// If worker1 fails, both restart

// Before: Raw MailboxProcessor with manual error handling
let oldActor = MailboxProcessor.Start(fun inbox ->
    let rec loop state = async {
        try
            let! msg = inbox.Receive()
            match msg with
            | Increment -> return! loop (state + 1)
            | Decrement -> return! loop (state - 1)
        with exn ->
            // Manual error handling scattered everywhere
            printfn "Error: %A" exn
            return! loop state
    }
    loop 0
)

// After: Scaffolded actor with declarative policies
let newActor = 
    system.Spawn(counterBehavior, {
        ActorConfig.defaults with
            ErrorPolicy = Some Resume
            BackpressurePolicy = Some (DropOldest 1000)
    })

// Alloy.Actors.Transport.MoQ
namespace Alloy.Actors.Transport

/// MoQ track corresponds to an actor's message stream
type MoQActorTrack = {
    Namespace: string      // System identifier: "fidelity", "conclave", "dotnet"
    ActorId: ActorId       // Target actor
    TrackName: string      // Derived from actor address
}

/// MoQ transport implementation
type MoQTransport(relayUrl: string) =
    let session = MoQSession(relayUrl)
    let subscriptions = ConcurrentDictionary<ActorId, MoQSubscription>()
    
    interface ITransport with
        member _.Send(targetId: ActorId) (data: byte[]) = async {
            let track = deriveTrack targetId
            
            // Publish BAREWire frame to actor's track
            let! publisher = session.GetOrCreatePublisher(track)
            do! publisher.PublishObject {
                GroupId = nextGroupId()
                ObjectId = nextObjectId()
                Payload = data  // BAREWire-encoded message
                Priority = Priority.Normal
            }
        }
        
        member _.Subscribe(sourceId: ActorId) (handler: byte[] -> Async<unit>) = async {
            let track = deriveTrack sourceId
            
            let! subscription = session.Subscribe(track)
            subscriptions.TryAdd(sourceId, subscription) |> ignore
            
            // Receive loop
            subscription.OnObject.Add(fun obj ->
                handler obj.Payload |> Async.Start
            )
        }
        
        member _.Connect(targetId: ActorId) = async {
            let track = deriveTrack targetId
            return MoQChannel(session, track) :> IActorChannel
        }

/// Derive MoQ track from actor address
let deriveTrack (actorId: ActorId) : MoQActorTrack =
    let parts = actorId.ToString().Split('/')
    {
        Namespace = parts.[0]      // System: fidelity/conclave/dotnet
        ActorId = actorId
        TrackName = $"actor/{parts.[1]}/{parts.[2]}"  // actor/supervisor/instance
    }

/// Supervisor using MoQ for high-throughput child monitoring
type MoQSupervisor(strategy: SupervisionStrategy, transport: MoQTransport) =
    let children = ConcurrentDictionary<ActorId, MoQSubscription>()
    
    member this.SuperviseChild(childId: ActorId) = async {
        // Each child gets its own MoQ track subscription
        // No head-of-line blocking between children
        do! transport.Subscribe childId (fun heartbeat ->
            async {
                let msg = BAREWire.decode<HeartbeatMessage> heartbeat
                match msg with
                | Alive timestamp -> 
                    this.RecordHeartbeat(childId, timestamp)
                | Failed exn ->
                    this.HandleFailure(childId, exn)
            }
        )
    }
    
    member this.BroadcastToChildren(msg: byte[]) = async {
        // Parallel publish to all child tracks
        // MoQ relay handles fanout efficiently
        let! _ = 
            children.Keys
            |> Seq.map (fun childId -> transport.Send childId msg)
            |> Async.Parallel
        ()
    }

type ActorPriority =
    | Supervision    // Highest: supervisor commands, failure notifications
    | Control        // High: lifecycle events, configuration
    | Normal         // Standard: business messages
    | Bulk           // Low: batch data, logs
    | Background     // Lowest: metrics, telemetry

/// Priority-aware message sending
let sendWithPriority (transport: MoQTransport) priority targetId msg = async {
    let moqPriority = 
        match priority with
        | Supervision -> Priority.Urgent
        | Control -> Priority.High
        | Normal -> Priority.Normal
        | Bulk -> Priority.Low
        | Background -> Priority.Lowest
    
    do! transport.SendWithPriority targetId msg moqPriority
}

// Supervision messages preempt normal traffic
do! sendWithPriority transport Supervision childId (Terminate "shutdown")

type TransportSelector = {
    /// Within same system
    IntraSystem: ITransport
    /// Cross-system, low throughput
    InterSystemLight: ITransport
    /// Cross-system, high throughput
    InterSystemHeavy: ITransport
}

let defaultSelector = {
    IntraSystem = 
        match currentSystem with
        | Fidelity -> IPCTransport()
        | Conclave -> WebSocketTransport()
        | DotNet -> InProcessTransport()
    
    InterSystemLight = WebSocketTransport()  // Simple cases
    InterSystemHeavy = MoQTransport(moqRelayUrl)  // Dense streams
}

/// Route based on message pattern
let selectTransport (pattern: MessagePattern) (selector: TransportSelector) =
    match pattern with
    | IntraSystem -> selector.IntraSystem
    | CrossSystem Low -> selector.InterSystemLight
    | CrossSystem High -> selector.InterSystemHeavy
    | CrossSystem (Streaming _) -> selector.InterSystemHeavy