Zeayii.Vexo.Task.Assembly.Core 0.0.32

Vexo.Task.Assembly.Core

Organization: zeayii
Module Type: Core Orchestration Layer
Target Framework: net10.0

1. Purpose

Vexo.Task.Assembly.Core is the orchestration backbone of assembly flow. It does not parse protocol internals or container bytes. Instead, it coordinates:

1. descriptor input,
2. provider preparation output,
3. manifest extraction output,

into a deterministic incremental stream of TaskWorkUnitSpec.

2. Responsibilities

• Provide unified assembly entry points (single-shot + incremental).
• Drive provider preparation stage and content-key obtain stage.
• Orchestrate DASH/HLS adapters and polling state transitions.
• Execute snapshot validation, stability validation, and delta building.
• Consume immutable AssemblyOptions snapshot consistently.

3. Non-Responsibilities

• No MPD/M3U8 parsing internals (Manifest module owns this).
• No MP4/WebM byte-level parse/remux (Media module owns this).
• No vendor-private business logic (Provider/private modules own this).
• No CLI argument mapping (host application owns this).

4. Layering and Dependency Direction

Vexo / Host
  -> Core (this module)
    -> Manifest
      -> Media
        -> Abstractions

Core exposes orchestration behavior only and keeps protocol internals behind adapters.

5. Public Usage

Use DI registration and resolve ITaskAssembler:

services.AddTaskAssemblyCoreRuntime(assemblyOptions);

var assembler = provider.GetRequiredService<ITaskAssembler>();
await foreach (var result in assembler.AssembleIncrementalAsync(descriptor, context, ct))
{
    // result.Snapshot / result.Delta / result.LifecycleState
}

6. Main Execution Flow

1. CoreTaskAssembler resolves provider (if any).
2. Runs PrepareAsync in streaming mode (no full buffering).
3. For each preparation context, performs one extraction round:
   • format sniffing,
   • DASH/HLS adapter extraction,
   • filter pipeline,
   • TaskWorkUnitSpec build.
4. Applies snapshot/stability validation and delta build.
5. Continues or terminates based on refresh decision.

7. Design Principles

• Streaming-first: preparation is yielded as it arrives.
• One-way dependency: no upward coupling into host/private code.
• State centralization: polling and lifecycle state are managed in Core.
• Extensible-private logic: provider extension points without polluting public pipeline.

8. Performance and AOT

• Explicit types + DI delegates; no runtime reflection dependency.
• Singleton registrations for high-frequency resolvers/adapters.
• Iterative polling flow without unnecessary intermediate materialization.

9. Collaboration with Other Modules

• Abstractions: contracts, models, filters, validators.
• Manifest: protocol extraction, refresh decision, protocol filters.
• Offline: sample provider and default assembly wiring.

10. Commercial Release Checklist

• Freeze and document AssemblyOptions defaults.
• Run incremental assembly regression on real-world vectors.
• Keep private provider logic isolated from core orchestration path.

11. License

This module follows the repository root license.