$data
        );

        if (fwrite(self::$logFileHandles[$this->logFile], $message . LF) === false) {
            throw new \RuntimeException('Could not write log record to log file', 1345036335);
        }

        return $this;
    }

    protected function writeLog(LogRecord $record)
    {
        /** @var WriterInterface $writer */
        foreach ($this->writers[$record->getLevel()] ?? [] as $writer) {
            $writer->writeLog($record);
        }
    }
}

            return;
        }
        $record = GeneralUtility::makeInstance(LogRecord::class, $this->name, LogLevel::getInternalName($level), $message, $data, $this->requestId);
        $record = $this->callProcessors($record);
        $this->writeLog($record);
    }

    /**
     * Calls all processors and returns log record

     * Normal but significant events.
     */
    public function notice(string|\Stringable $message, array $context = []): void
    {
        $this->log(LogLevel::NOTICE, $message, $context);
    }

    /**
     * Interesting events.

        $message = $this->getFormattedLogMessage($message);

        if ($errorLevel === E_USER_DEPRECATED || $errorLevel === E_DEPRECATED) {
            $logger = GeneralUtility::makeInstance(LogManager::class)->getLogger('TYPO3.CMS.deprecations');
            $logger->notice($message);
            return self::ERROR_HANDLED;
        }

        switch ($errorLevel) {

     * @deprecated since v12, will be removed in v13. Use executeQuery() and executeStatement() instead.
     */
    public function execute()
    {
        trigger_error('QueryBuilder::execute() will be removed in TYPO3 v13.0. Use executeQuery() or executeStatement() directly.', E_USER_DEPRECATED);
        if ($this->getType() !== \Doctrine\DBAL\Query\QueryBuilder::SELECT) {
            return $this->executeStatement();
        }

                    $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)),
                    $queryBuilder->expr()->eq('hidden', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT))
                )
                ->orderBy('sorting', 'ASC')
                ->execute()
                ->fetchAll();
        } catch (TableNotFoundException $exception) {
            $typeRecords = [];
        }

    {
        if (empty(static::$types)) {
            /** @var RecordBasedContentTypeDefinitionRepository $definitionRepository */
            $definitionRepository = GeneralUtility::makeInstance(RecordBasedContentTypeDefinitionRepository::class);
            static::$types = $definitionRepository->fetchContentTypeDefinitions();
        }
        return static::$types;
    }

     * @codeCoverageIgnore
     */
    protected function fetchRecordBasedContentTypes(): array
    {
        return (array) RecordBasedContentTypeDefinition::fetchContentTypes();
    }
}

            if (!$types) {
                $types = array_replace(
                    $this->fetchDropInContentTypes(),
                    $this->fetchFileBasedContentTypes(),
                    $this->fetchRecordBasedContentTypes()
                );
                $this->cacheService->setInCaches($types, true, self::CACHE_IDENTIFIER);
            }
            $this->typeNames = array_merge($this->typeNames, array_keys($types));

    {
        // Initialize the TCA needed by "template as CType" integrations
        $this->spoolQueuedContentTypeTableConfigurations(Core::getQueuedContentTypeRegistrations());

        foreach ($this->contentTypeManager->fetchContentTypes() as $contentType) {
            if (!$contentType instanceof FluidRenderingContentTypeDefinitionInterface) {
                continue;
            }
            Core::registerTemplateAsContentType(

    public function spoolQueuedTcaOperations(BootCompletedEvent $event): void
    {
        /** @var SpooledConfigurationApplicator $applicator */
        $applicator = GeneralUtility::makeInstance(SpooledConfigurationApplicator::class);
        $applicator->processData();
    }
}

        if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
            return $event;
        }
        foreach ($this->listenerProvider->getListenersForEvent($event) as $listener) {
            $listener($event);
            if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
                break;
            }
        }

    public function dispatch(object $event): object
    {
        $this->dispatchedEvents[] = $event;
        return parent::dispatch($event);
    }
}

        static::unsetReservedGlobalVariables();
        static::loadBaseTca(true, $coreCache);
        static::checkEncryptionKey();
        $bootState->complete = true;
        $eventDispatcher->dispatch(new BootCompletedEvent(true));

        return $container;
    }

// Set up the application for the frontend
call_user_func(static function () {
    $classLoader = require dirname(__DIR__).'/vendor/autoload.php';
    \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::run(0, \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::REQUESTTYPE_FE);
    \TYPO3\CMS\Core\Core\Bootstrap::init($classLoader)->get(\TYPO3\CMS\Frontend\Http\Application::class)->run();
});

call_user_func(static function () {
    $classLoader = require dirname(__DIR__).'/vendor/autoload.php';
    \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::run(0, \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::REQUESTTYPE_FE);
    \TYPO3\CMS\Core\Core\Bootstrap::init($classLoader)->get(\TYPO3\CMS\Frontend\Http\Application::class)->run();
});