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

Each page region is its own resource pipeline with the same template system as the main page — no scattered partial glue, no mystery wiring.

Composable Page Regions

Slot resources give every region a real pipeline

This is one of the strongest Semitexa rendering ideas: the page is not one monolith and its regions are not string fragments. Nav, sidebar, widgets, and live panels can all be first-class resources with the same template engine as the main page.

Why this matters

Traditional page composition often leaves nav, sidebar, widgets, and footers as special-case includes with hidden data dependencies.
Frontend and backend fragments drift apart because each region gets wired by a different mechanism.
When regions are not first-class resources, no one can tell where their data really comes from or how they are refreshed.

2 live slot resources in this shell

1 shared Twig system for page and slots

0 mystery data glue between regions

Fragment Sprawl

Includes and ad hoc context passing

Page regions are stitched together manually, and each fragment quietly depends on whatever data happened to be pushed into the template.

The composition works, but nobody can see one explicit pipeline for each region.

First-Class Page Regions

Slot resource pipeline

Each region is a resource with its own handler flow, render context, asset collection, and optional deferred/live lifecycle.

The same template system renders the page, the sidebar, the nav, and reactive slots. One mental model, everywhere.

Slot name	Resource class	Why it exists	Layout call
`demo_nav`	`DemoNavSlot`	Top navigation as a standalone resource	`{{ layout_slot('demo_nav') }}`
`demo_sidebar`	`DemoSidebarSlot`	Feature tree with its own handler pipeline	`{{ layout_slot('demo_sidebar') }}`

#[AsSlotResource] HtmlSlotResponse layout_slot() SlotHandlerPipeline shared Twig

Verified against Semitexa Ultimate 2026.09.19.1020

Slot Resources

A slot is not a fragment hack. It is a real resource with its own handler pipeline, template, and lifecycle. Slot resources turn page regions into first-class response pipelines instead of informal partial includes.

The problem

Traditional page composition often leaves nav, sidebar, widgets, and footers as special-case includes with hidden data dependencies. Frontend and backend fragments drift apart because each region gets wired by a different mechanism. When regions are not first-class resources, no one can tell where their data really comes from or how they are refreshed.

How it works

Each region is a resource with its own handler flow, render context, asset collection, and optional deferred or live lifecycle. The same template system renders the page, the sidebar, the nav, and reactive slots.

layout_slot() composes the shell declaratively while the data flow stays explicit and reviewable.

The rules

A slot is a real response object, not a string include or a magical template fragment.
Slots use the same Twig system and rendering model as the page itself, so frontend and backend stop speaking different dialects.
Each region can evolve independently: own handler, own template, own assets, own deferred or reactive lifecycle.
layout_slot() composes the shell declaratively while the data flow stays explicit and reviewable.

Key mechanisms

#[AsSlotResource] — registers a named page region as a first-class resource for one layout handle.
SlotHandlerPipeline — runs the region through typed slot handlers before it renders.
Shared Twig — the page template and the slot template use the same rendering engine and conventions.

1<aside class="dashboard-sidebar">2  {% include 'partials/sidebar-nav.html.twig' with { items: nav_items } %}34  {% if user is defined %}5    {% include 'partials/sidebar-user-card.html.twig' with {6      user: user,7      permissions: permissions,8      team: current_team9    } %}10  {% endif %}1112  {% include 'partials/sidebar-metrics.html.twig' with {13    stats: stats,14    alerts: alerts,15    recommendations: recommendations16  } %}17</aside>18

<aside class="dashboard-sidebar">
  {% include 'partials/sidebar-nav.html.twig' with { items: nav_items } %}

  {% if user is defined %}
    {% include 'partials/sidebar-user-card.html.twig' with {
      user: user,
      permissions: permissions,
      team: current_team
    } %}
  {% endif %}

  {% include 'partials/sidebar-metrics.html.twig' with {
    stats: stats,
    alerts: alerts,
    recommendations: recommendations
  } %}
</aside>

1<?php23declare(strict_types=1);45use Semitexa\Ssr\Attribute\AsSlotResource;6use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;78#[AsSlotResource(9    handle: 'dashboard',10    slot: 'sidebar',11    template: '@project/dashboard/sidebar.html.twig',12)]13final class DashboardSidebarSlot extends HtmlSlotResponse14{15    public function withNavigation(array $navigation): static16    {17        return $this->with('navigation', $navigation);18    }1920    public function withUserCard(array $userCard): static21    {22        return $this->with('userCard', $userCard);23    }2425    public function withMetrics(array $metrics): static26    {27        return $this->with('metrics', $metrics);28    }29}30

<?php

declare(strict_types=1);

use Semitexa\Ssr\Attribute\AsSlotResource;
use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;

#[AsSlotResource(
    handle: 'dashboard',
    slot: 'sidebar',
    template: '@project/dashboard/sidebar.html.twig',
)]
final class DashboardSidebarSlot extends HtmlSlotResponse
{
    public function withNavigation(array $navigation): static
    {
        return $this->with('navigation', $navigation);
    }

    public function withUserCard(array $userCard): static
    {
        return $this->with('userCard', $userCard);
    }

    public function withMetrics(array $metrics): static
    {
        return $this->with('metrics', $metrics);
    }
}

1<?php23declare(strict_types=1);45namespace Semitexa\Ssr\Application\Service\Layout;67use Semitexa\Core\Log\StaticLoggerBridge;89/**10 * Shared slot rendering service.11 *12 * Resolves slot resources for (handle, slotName), creates instances,13 * runs slot handlers, collects client modules, and renders templates.14 * Results are concatenated in priority order.15 */16final class SlotRenderer17{18    /**19     * Render a single slot resource registry entry that carries a resourceClass.20     *21     * @param array{resourceClass: string, template: string, context: array, priority: int, clientModules: array} $entry22     */23    public static function renderEntry(array $entry, array $context = []): string24    {25        $resourceClass = $entry['resourceClass'];2627        try {28            $slot = SlotResourceFactory::create($resourceClass);29            if ($context !== []) {30                $slot = $slot->withRenderContext($context);31            }32            if (($entry['clientModules'] ?? []) !== []) {33                $slot = $slot->withClientModules($entry['clientModules']);34            }35            $slot = SlotHandlerPipeline::execute($slot);36            SlotAssetCollector::collectFromSlot($slot);37            $template = ($entry['template'] ?? '') !== '' ? $entry['template'] : null;3839            return $slot->renderTemplate($template);40        } catch (\Throwable $e) {41            StaticLoggerBridge::debug('ssr', 'SlotRenderer::renderEntry failed', [42                'resourceClass' => $resourceClass,43                'exception' => $e::class,44                'message' => $e->getMessage(),45            ]);4647            return '';48        }49    }50}51

<?php

declare(strict_types=1);

namespace Semitexa\Ssr\Application\Service\Layout;

use Semitexa\Core\Log\StaticLoggerBridge;

/**
 * Shared slot rendering service.
 *
 * Resolves slot resources for (handle, slotName), creates instances,
 * runs slot handlers, collects client modules, and renders templates.
 * Results are concatenated in priority order.
 */
final class SlotRenderer
{
    /**
     * Render a single slot resource registry entry that carries a resourceClass.
     *
     * @param array{resourceClass: string, template: string, context: array, priority: int, clientModules: array} $entry
     */
    public static function renderEntry(array $entry, array $context = []): string
    {
        $resourceClass = $entry['resourceClass'];

        try {
            $slot = SlotResourceFactory::create($resourceClass);
            if ($context !== []) {
                $slot = $slot->withRenderContext($context);
            }
            if (($entry['clientModules'] ?? []) !== []) {
                $slot = $slot->withClientModules($entry['clientModules']);
            }
            $slot = SlotHandlerPipeline::execute($slot);
            SlotAssetCollector::collectFromSlot($slot);
            $template = ($entry['template'] ?? '') !== '' ? $entry['template'] : null;

            return $slot->renderTemplate($template);
        } catch (\Throwable $e) {
            StaticLoggerBridge::debug('ssr', 'SlotRenderer::renderEntry failed', [
                'resourceClass' => $resourceClass,
                'exception' => $e::class,
                'message' => $e->getMessage(),
            ]);

            return '';
        }
    }
}

1<?php23declare(strict_types=1);45namespace Semitexa\Ssr\Application\Service\Layout;67use ReflectionClass;8use ReflectionException;9use Semitexa\Core\Attribute\AsService;10use Semitexa\Core\Attribute\ExecutionScoped;11use Semitexa\Core\Attribute\InjectAsFactory;12use Semitexa\Core\Attribute\InjectAsMutable;13use Semitexa\Core\Attribute\InjectAsReadonly;14use Semitexa\Core\Container\ContainerFactory;15use Semitexa\Core\Log\StaticLoggerBridge;16use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;17use Semitexa\Ssr\Domain\Contract\TypedSlotHandlerInterface;1819/**20 * Executes all registered slot handlers for a slot resource in priority order.21 *22 * A handler that fails does not stop the others: one broken region must not cost23 * the page every other region. But it is reported at **error** level, because a24 * slot that failed and a slot that legitimately had nothing to render produce25 * the identical empty output, and the only difference a reader can see is the26 * log line.27 */28final class SlotHandlerPipeline29{30    /**31     * Property attributes whose collaborators arrive AFTER construction.32     *33     * A handler declaring any of these cannot be built with `new`: the typed34     * properties stay uninitialised, so it either fatals on first access or35     * quietly returns nothing. This is the provable case, and the only one worth36     * refusing outright.37     */38    private const INJECTED_PROPERTY_ATTRIBUTES = [39        InjectAsReadonly::class,40        InjectAsMutable::class,41        InjectAsFactory::class,42    ];4344    /**45     * Class attributes that mean "the container was meant to build this".46     *47     * Weaker evidence than an injected property: a service with a parameterless48     * constructor and nothing injected constructs perfectly well with `new`.49     * Refusing on this alone would break setups that work today, so an50     * unresolved one is reported and then built directly.51     */52    private const CONTAINER_BUILT_ATTRIBUTES = [53        AsService::class,54        ExecutionScoped::class,55    ];5657    /**58     * Execute the handler pipeline for the given slot resource.59     * Handlers are resolved from the DI container when available.60     */61    public static function execute(HtmlSlotResponse $slot): HtmlSlotResponse62    {63        $slotClass = $slot::class;64        $handlerClasses = SlotHandlerRegistry::getHandlerClasses($slotClass);6566        foreach ($handlerClasses as $handlerClass) {67            try {68                $handler = self::resolveHandler($handlerClass);69                $result = $handler->handle($slot);70                if (!$result instanceof HtmlSlotResponse) {71                    throw new \RuntimeException(72                        "Slot handler '{$handlerClass}' must return an HtmlSlotResponse instance."73                    );74                }75                $slot = $result;76            } catch (\Throwable $e) {77                // Error, not debug. A failed slot renders as an empty region, so78                // at any normal log level this used to be indistinguishable from79                // a slot that had nothing to show — the failure was only findable80                // by abandoning the render path entirely.81                StaticLoggerBridge::error('ssr', 'Slot handler failed; region rendered empty', [82                    'handler' => $handlerClass,83                    'slot' => $slotClass,84                    'exception' => $e::class,85                    'message' => $e->getMessage(),86                ]);87            }88        }8990        return $slot;91    }9293    /**94     * Resolve a handler, preferring the container.95     *96     * Three outcomes, deliberately distinct:97     *  - the container knows the class → use it, and a failure there is a real98     *    failure, not a reason to try something weaker;99     *  - the container does not know it but the class declares container-managed100     *    dependencies → refuse, because `new` would hand back an object with101     *    uninitialised collaborators and the symptom would surface far away;102     *  - a plain class with nothing injected → `new` is legitimate.103     *104     * The previous version collapsed all three into "try the container, fall105     * through to `new` on any problem", which is what turned a missing binding106     * into an empty region with no explanation.107     */108    private static function resolveHandler(string $handlerClass): TypedSlotHandlerInterface109    {110        $container = null;111        $containerError = null;112        try {113            $container = ContainerFactory::get();114        } catch (\Throwable $e) {115            // No container at all (CLI, early boot). Plain classes still work.116            $containerError = $e;117        }118119        if ($container !== null && $container->has($handlerClass)) {120            $instance = $container->get($handlerClass);121            if (!$instance instanceof TypedSlotHandlerInterface) {122                throw new \RuntimeException(123                    "Slot handler '{$handlerClass}' resolved from the container but does not implement "124                    . TypedSlotHandlerInterface::class . '.'125                );126            }127128            return $instance;129        }130131        $injected = self::injectedProperties($handlerClass);132        if ($injected !== []) {133            throw new \RuntimeException(134                "Slot handler '{$handlerClass}' declares injected propert"135                . (count($injected) === 1 ? 'y' : 'ies') . ' (' . implode(', ', $injected) . ') '136                . 'but the container did not resolve it'137                . ($containerError !== null ? ' (no container available: ' . $containerError->getMessage() . ')' : '')138                . '. Constructing it directly would leave those uninitialised, so the handler is refused '139                . 'rather than run half-built.'140            );141        }142143        // Only worth warning when a container EXISTS and does not know the class:144        // that is a probable missing binding. With no container at all (CLI, early145        // boot) direct construction is the expected path, and warning there would146        // be noise on a route that is working as designed.147        if ($container !== null && self::isContainerBuilt($handlerClass)) {148            // Not fatal: nothing is injected, so `new` produces a usable object.149            StaticLoggerBridge::warning('ssr', 'Slot handler is container-declared but was not resolved', [150                'handler' => $handlerClass,151                'note' => 'constructed directly; nothing is injected so this is safe, but the binding is likely missing',152            ]);153        }154155        $instance = new $handlerClass();156        if (!$instance instanceof TypedSlotHandlerInterface) {157            throw new \RuntimeException(158                "Slot handler '{$handlerClass}' must implement TypedSlotHandlerInterface."159            );160        }161162        return $instance;163    }164165    /**166     * Names of properties the container was supposed to fill.167     *168     * A class we cannot reflect yields none, so an unloadable handler still169     * reaches `new` and fails with its own error rather than a misleading one170     * about dependency injection.171     *172     * @return list<string>173     */174    private static function injectedProperties(string $handlerClass): array175    {176        try {177            $reflection = new ReflectionClass($handlerClass);178        } catch (ReflectionException) {179            return [];180        }181182        $names = [];183        foreach ($reflection->getProperties() as $property) {184            foreach (self::INJECTED_PROPERTY_ATTRIBUTES as $attribute) {185                if ($property->getAttributes($attribute) !== []) {186                    $names[] = '$' . $property->getName();187                    continue 2;188                }189            }190        }191192        return $names;193    }194195    private static function isContainerBuilt(string $handlerClass): bool196    {197        try {198            $reflection = new ReflectionClass($handlerClass);199        } catch (ReflectionException) {200            return false;201        }202203        foreach (self::CONTAINER_BUILT_ATTRIBUTES as $attribute) {204            if ($reflection->getAttributes($attribute) !== []) {205                return true;206            }207        }208209        return false;210    }211}212

<?php

declare(strict_types=1);

namespace Semitexa\Ssr\Application\Service\Layout;

use ReflectionClass;
use ReflectionException;
use Semitexa\Core\Attribute\AsService;
use Semitexa\Core\Attribute\ExecutionScoped;
use Semitexa\Core\Attribute\InjectAsFactory;
use Semitexa\Core\Attribute\InjectAsMutable;
use Semitexa\Core\Attribute\InjectAsReadonly;
use Semitexa\Core\Container\ContainerFactory;
use Semitexa\Core\Log\StaticLoggerBridge;
use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;
use Semitexa\Ssr\Domain\Contract\TypedSlotHandlerInterface;

/**
 * Executes all registered slot handlers for a slot resource in priority order.
 *
 * A handler that fails does not stop the others: one broken region must not cost
 * the page every other region. But it is reported at **error** level, because a
 * slot that failed and a slot that legitimately had nothing to render produce
 * the identical empty output, and the only difference a reader can see is the
 * log line.
 */
final class SlotHandlerPipeline
{
    /**
     * Property attributes whose collaborators arrive AFTER construction.
     *
     * A handler declaring any of these cannot be built with `new`: the typed
     * properties stay uninitialised, so it either fatals on first access or
     * quietly returns nothing. This is the provable case, and the only one worth
     * refusing outright.
     */
    private const INJECTED_PROPERTY_ATTRIBUTES = [
        InjectAsReadonly::class,
        InjectAsMutable::class,
        InjectAsFactory::class,
    ];

    /**
     * Class attributes that mean "the container was meant to build this".
     *
     * Weaker evidence than an injected property: a service with a parameterless
     * constructor and nothing injected constructs perfectly well with `new`.
     * Refusing on this alone would break setups that work today, so an
     * unresolved one is reported and then built directly.
     */
    private const CONTAINER_BUILT_ATTRIBUTES = [
        AsService::class,
        ExecutionScoped::class,
    ];

    /**
     * Execute the handler pipeline for the given slot resource.
     * Handlers are resolved from the DI container when available.
     */
    public static function execute(HtmlSlotResponse $slot): HtmlSlotResponse
    {
        $slotClass = $slot::class;
        $handlerClasses = SlotHandlerRegistry::getHandlerClasses($slotClass);

        foreach ($handlerClasses as $handlerClass) {
            try {
                $handler = self::resolveHandler($handlerClass);
                $result = $handler->handle($slot);
                if (!$result instanceof HtmlSlotResponse) {
                    throw new \RuntimeException(
                        "Slot handler '{$handlerClass}' must return an HtmlSlotResponse instance."
                    );
                }
                $slot = $result;
            } catch (\Throwable $e) {
                // Error, not debug. A failed slot renders as an empty region, so
                // at any normal log level this used to be indistinguishable from
                // a slot that had nothing to show — the failure was only findable
                // by abandoning the render path entirely.
                StaticLoggerBridge::error('ssr', 'Slot handler failed; region rendered empty', [
                    'handler' => $handlerClass,
                    'slot' => $slotClass,
                    'exception' => $e::class,
                    'message' => $e->getMessage(),
                ]);
            }
        }

        return $slot;
    }

    /**
     * Resolve a handler, preferring the container.
     *
     * Three outcomes, deliberately distinct:
     *  - the container knows the class → use it, and a failure there is a real
     *    failure, not a reason to try something weaker;
     *  - the container does not know it but the class declares container-managed
     *    dependencies → refuse, because `new` would hand back an object with
     *    uninitialised collaborators and the symptom would surface far away;
     *  - a plain class with nothing injected → `new` is legitimate.
     *
     * The previous version collapsed all three into "try the container, fall
     * through to `new` on any problem", which is what turned a missing binding
     * into an empty region with no explanation.
     */
    private static function resolveHandler(string $handlerClass): TypedSlotHandlerInterface
    {
        $container = null;
        $containerError = null;
        try {
            $container = ContainerFactory::get();
        } catch (\Throwable $e) {
            // No container at all (CLI, early boot). Plain classes still work.
            $containerError = $e;
        }

        if ($container !== null && $container->has($handlerClass)) {
            $instance = $container->get($handlerClass);
            if (!$instance instanceof TypedSlotHandlerInterface) {
                throw new \RuntimeException(
                    "Slot handler '{$handlerClass}' resolved from the container but does not implement "
                    . TypedSlotHandlerInterface::class . '.'
                );
            }

            return $instance;
        }

        $injected = self::injectedProperties($handlerClass);
        if ($injected !== []) {
            throw new \RuntimeException(
                "Slot handler '{$handlerClass}' declares injected propert"
                . (count($injected) === 1 ? 'y' : 'ies') . ' (' . implode(', ', $injected) . ') '
                . 'but the container did not resolve it'
                . ($containerError !== null ? ' (no container available: ' . $containerError->getMessage() . ')' : '')
                . '. Constructing it directly would leave those uninitialised, so the handler is refused '
                . 'rather than run half-built.'
            );
        }

        // Only worth warning when a container EXISTS and does not know the class:
        // that is a probable missing binding. With no container at all (CLI, early
        // boot) direct construction is the expected path, and warning there would
        // be noise on a route that is working as designed.
        if ($container !== null && self::isContainerBuilt($handlerClass)) {
            // Not fatal: nothing is injected, so `new` produces a usable object.
            StaticLoggerBridge::warning('ssr', 'Slot handler is container-declared but was not resolved', [
                'handler' => $handlerClass,
                'note' => 'constructed directly; nothing is injected so this is safe, but the binding is likely missing',
            ]);
        }

        $instance = new $handlerClass();
        if (!$instance instanceof TypedSlotHandlerInterface) {
            throw new \RuntimeException(
                "Slot handler '{$handlerClass}' must implement TypedSlotHandlerInterface."
            );
        }

        return $instance;
    }

    /**
     * Names of properties the container was supposed to fill.
     *
     * A class we cannot reflect yields none, so an unloadable handler still
     * reaches `new` and fails with its own error rather than a misleading one
     * about dependency injection.
     *
     * @return list<string>
     */
    private static function injectedProperties(string $handlerClass): array
    {
        try {
            $reflection = new ReflectionClass($handlerClass);
        } catch (ReflectionException) {
            return [];
        }

        $names = [];
        foreach ($reflection->getProperties() as $property) {
            foreach (self::INJECTED_PROPERTY_ATTRIBUTES as $attribute) {
                if ($property->getAttributes($attribute) !== []) {
                    $names[] = '$' . $property->getName();
                    continue 2;
                }
            }
        }

        return $names;
    }

    private static function isContainerBuilt(string $handlerClass): bool
    {
        try {
            $reflection = new ReflectionClass($handlerClass);
        } catch (ReflectionException) {
            return false;
        }

        foreach (self::CONTAINER_BUILT_ATTRIBUTES as $attribute) {
            if ($reflection->getAttributes($attribute) !== []) {
                return true;
            }
        }

        return false;
    }
}

1<?php23declare(strict_types=1);45use Semitexa\Ssr\Attribute\AsSlotResource;6use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;78#[AsSlotResource(9    handle: 'dashboard',10    slot: 'sidebar',11    template: '@project/dashboard/sidebar.html.twig',12)]13final class DashboardSidebarSlot extends HtmlSlotResponse14{15    public function withNavigation(array $navigation): static16    {17        return $this->with('navigation', $navigation);18    }1920    public function withUserCard(array $userCard): static21    {22        return $this->with('userCard', $userCard);23    }2425    public function withMetrics(array $metrics): static26    {27        return $this->with('metrics', $metrics);28    }29}30

<?php

declare(strict_types=1);

use Semitexa\Ssr\Attribute\AsSlotResource;
use Semitexa\Ssr\Application\Service\Http\Response\HtmlSlotResponse;

#[AsSlotResource(
    handle: 'dashboard',
    slot: 'sidebar',
    template: '@project/dashboard/sidebar.html.twig',
)]
final class DashboardSidebarSlot extends HtmlSlotResponse
{
    public function withNavigation(array $navigation): static
    {
        return $this->with('navigation', $navigation);
    }

    public function withUserCard(array $userCard): static
    {
        return $this->with('userCard', $userCard);
    }

    public function withMetrics(array $metrics): static
    {
        return $this->with('metrics', $metrics);
    }
}

1<aside class="dashboard-sidebar">2  {{ layout_slot('sidebar') }}3</aside>45<main class="dashboard-main">6  {{ page_content|raw }}7</main>89<aside class="dashboard-rail">10  {{ layout_slot('activity_rail') }}11</aside>12

<aside class="dashboard-sidebar">
  {{ layout_slot('sidebar') }}
</aside>

<main class="dashboard-main">
  {{ page_content|raw }}
</main>

<aside class="dashboard-rail">
  {{ layout_slot('activity_rail') }}
</aside>

1<?php23declare(strict_types=1);45namespace App\Application\Handler\Rendering;67use App\Application\Payload\Page\DashboardPayload;8use App\Application\Resource\Layout\DashboardLayoutResource;9use App\Application\Resource\Slot\DashboardSidebarSlot;10use App\Domain\Navigation\DashboardNavigationBuilderInterface;11use Semitexa\Core\Attribute\AsPayloadHandler;12use Semitexa\Core\Attribute\InjectAsReadonly;13use Semitexa\Core\Contract\TypedHandlerInterface;1415#[AsPayloadHandler(payload: DashboardPayload::class, resource: DashboardLayoutResource::class)]16final class LayoutSlotHandler implements TypedHandlerInterface17{18    #[InjectAsReadonly]19    protected DashboardNavigationBuilderInterface $navigationBuilder;2021    public function handle(DashboardPayload $payload, DashboardLayoutResource $resource): DashboardLayoutResource22    {23        return $resource->withSidebar(24            new DashboardSidebarSlot($this->navigationBuilder->items())25        );26    }27}28

<?php

declare(strict_types=1);

namespace App\Application\Handler\Rendering;

use App\Application\Payload\Page\DashboardPayload;
use App\Application\Resource\Layout\DashboardLayoutResource;
use App\Application\Resource\Slot\DashboardSidebarSlot;
use App\Domain\Navigation\DashboardNavigationBuilderInterface;
use Semitexa\Core\Attribute\AsPayloadHandler;
use Semitexa\Core\Attribute\InjectAsReadonly;
use Semitexa\Core\Contract\TypedHandlerInterface;

#[AsPayloadHandler(payload: DashboardPayload::class, resource: DashboardLayoutResource::class)]
final class LayoutSlotHandler implements TypedHandlerInterface
{
    #[InjectAsReadonly]
    protected DashboardNavigationBuilderInterface $navigationBuilder;

    public function handle(DashboardPayload $payload, DashboardLayoutResource $resource): DashboardLayoutResource
    {
        return $resource->withSidebar(
            new DashboardSidebarSlot($this->navigationBuilder->items())
        );
    }
}

Unified Template System

One rendering model for the whole shell

The power here is not only composition. It is consistency. The same mental model drives the page resource, the slot resources, deferred regions, and live updates. No extra fragment system, no special frontend dialect.

A slot is a real response object, not a string include or a magical template fragment.

Slots use the same Twig system and rendering model as the page itself, so frontend and backend stop speaking different dialects.

Each region can evolve independently: own handler, own template, own assets, own deferred or reactive lifecycle.

layout_slot() composes the shell declaratively while the data flow stays explicit and reviewable.

Slot concern	What Semitexa makes explicit
#[AsSlotResource]	Registers a named page region as a first-class resource for one layout handle.
SlotHandlerPipeline	Runs the region through typed slot handlers before it renders.
Shared Twig	The page template and the slot template use the same rendering engine and conventions.