Feature Guide

A quick orientation block that answers the essential questions: what this feature does, how it works, why it matters, and the key concepts behind it.

What this does

Submit a task and watch the AI pipeline stages reveal one by one as the cron job processes it.

Reactive Pipeline

Stage-by-stage processing

Submit a task and watch each processing stage reveal itself as background work completes.

Idle

Parse

→

Analyze

→

Generate

→

Format

Submit new task

DemoAiTask stage-by-stage refreshInterval: 2 user-triggered → cron pickup

Verified against Semitexa Ultimate 2026.09.19.1020

Reactive AI Task

Submit a task and watch the AI pipeline stages reveal one by one as the cron job processes it. The page stays SSR-first while background AI stages keep advancing on the server, so the sidebar and the live pipeline share one consistent page shell.

How it works

The user submits text through a form. The handler creates a DemoAiTask record with status pending. A cron job picks up pending tasks and processes them stage by stage, writing stage results into the task record as JSON. A reactive slot with refreshInterval: 2 holds its SSE connection open while the server re-renders the pipeline view every two seconds and pushes it, reading the latest stage results from the task record and showing each completed stage.

The flow

User submits the form — a task record is created with status: pending.
The cron worker picks up the task and starts advancing through stages.
Each stage completion is written to stage_results as JSON.
The reactive slot refreshes every two seconds, reading the updated stage data and rendering the current pipeline state as HTML.
When all stages are complete, the slot shows the finished result.

Key mechanisms

DemoAiTask — the task record that carries status, stages, and stage results.
stage-by-stage — the cron processor advances one stage at a time and writes intermediate results.
refreshInterval: 2 — the server re-renders and pushes every two seconds; the browser never polls.
user-triggered → cron pickup — the form submission creates a task; the cron picks it up without a direct async handoff.

Why this matters

AI pipeline progress is a case where client-side state simulation is especially misleading — AI stage durations are unpredictable, so any client-side estimation is just fabricated progress. Letting the server own the stage results and reflecting them through a live slot gives the user accurate information throughout the processing run.

1<?php23declare(strict_types=1);45use Examples\Rendering\Philosophy\Support\JobService;6use Semitexa\Core\Attribute\InjectAsReadonly;7use Semitexa\Ssr\Attribute\AsSlotHandler;8use Semitexa\Ssr\Attribute\AsSlotResource;9use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;1011#[AsSlotResource(12    handle: 'imports_dashboard',13    slot: 'job_status',14    deferred: true,15    refreshInterval: 3,16)]17final class ImportJobStatusSlot extends HtmlSlotResponse18{19    public function withStatus(string $status): self20    {21        return $this->with('status', $status);22    }2324    public function withProgress(int $progress): self25    {26        return $this->with('progress', $progress);27    }28}2930#[AsSlotHandler(slot: ImportJobStatusSlot::class)]31final class ImportJobStatusSlotHandler32{33    #[InjectAsReadonly]34    protected JobService $jobs;3536    public function handle(ImportJobStatusSlot $slot): ImportJobStatusSlot37    {38        $run = $this->jobs->latestImportRun();3940        return $slot41            ->withStatus($run->status())42            ->withProgress($run->progressPercent());43    }44}4546// The slot keeps re-rendering server truth. No second client-side state machine is required.47

<?php

declare(strict_types=1);

use Examples\Rendering\Philosophy\Support\JobService;
use Semitexa\Core\Attribute\InjectAsReadonly;
use Semitexa\Ssr\Attribute\AsSlotHandler;
use Semitexa\Ssr\Attribute\AsSlotResource;
use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;

#[AsSlotResource(
    handle: 'imports_dashboard',
    slot: 'job_status',
    deferred: true,
    refreshInterval: 3,
)]
final class ImportJobStatusSlot extends HtmlSlotResponse
{
    public function withStatus(string $status): self
    {
        return $this->with('status', $status);
    }

    public function withProgress(int $progress): self
    {
        return $this->with('progress', $progress);
    }
}

#[AsSlotHandler(slot: ImportJobStatusSlot::class)]
final class ImportJobStatusSlotHandler
{
    #[InjectAsReadonly]
    protected JobService $jobs;

    public function handle(ImportJobStatusSlot $slot): ImportJobStatusSlot
    {
        $run = $this->jobs->latestImportRun();

        return $slot
            ->withStatus($run->status())
            ->withProgress($run->progressPercent());
    }
}

// The slot keeps re-rendering server truth. No second client-side state machine is required.

1<?php23declare(strict_types=1);45namespace Examples\Rendering\Philosophy\Support;67final class RecommendationService8{9    public function topForCurrentUser(): array10    {11        return [];12    }13}14

<?php

declare(strict_types=1);

namespace Examples\Rendering\Philosophy\Support;

final class RecommendationService
{
    public function topForCurrentUser(): array
    {
        return [];
    }
}

1<?php23declare(strict_types=1);45namespace App\Application\Handler\Rendering;67use App\Application\Payload\Page\ReactivePanelPayload;8use App\Application\Resource\Page\ReactivePanelResource;9use App\Application\Resource\Slot\ReactivePanelSlot;10use App\Domain\Reports\RealtimeReportBuilderInterface;11use Semitexa\Core\Attribute\AsPayloadHandler;12use Semitexa\Core\Attribute\InjectAsReadonly;13use Semitexa\Core\Contract\TypedHandlerInterface;1415#[AsPayloadHandler(payload: ReactivePanelPayload::class, resource: ReactivePanelResource::class)]16final class ReactiveSlotHandler implements TypedHandlerInterface17{18    #[InjectAsReadonly]19    protected RealtimeReportBuilderInterface $reportBuilder;2021    public function handle(ReactivePanelPayload $payload, ReactivePanelResource $resource): ReactivePanelResource22    {23        return $resource->withReactiveSlot(24            new ReactivePanelSlot($this->reportBuilder->build())25        );26    }27}28

<?php

declare(strict_types=1);

namespace App\Application\Handler\Rendering;

use App\Application\Payload\Page\ReactivePanelPayload;
use App\Application\Resource\Page\ReactivePanelResource;
use App\Application\Resource\Slot\ReactivePanelSlot;
use App\Domain\Reports\RealtimeReportBuilderInterface;
use Semitexa\Core\Attribute\AsPayloadHandler;
use Semitexa\Core\Attribute\InjectAsReadonly;
use Semitexa\Core\Contract\TypedHandlerInterface;

#[AsPayloadHandler(payload: ReactivePanelPayload::class, resource: ReactivePanelResource::class)]
final class ReactiveSlotHandler implements TypedHandlerInterface
{
    #[InjectAsReadonly]
    protected RealtimeReportBuilderInterface $reportBuilder;

    public function handle(ReactivePanelPayload $payload, ReactivePanelResource $resource): ReactivePanelResource
    {
        return $resource->withReactiveSlot(
            new ReactivePanelSlot($this->reportBuilder->build())
        );
    }
}