prisma-php 0.0.5 → 0.0.6

package/dist/docs/components.md

@@ -69,13 +69,89 @@ This is the right mental model for:
 - componentized partials that PulsePoint should hydrate later
 - keeping PHP templating ergonomics while still producing component-aware markup
 
-For `ImportComponent`, think in terms of a React-style single-root component: one parent element defines the island boundary, Prisma PHP serializes props onto that root, and the framework injects a stable `pp-component` attribute there. Do not design imported partials as loose sibling markup.
+For `ImportComponent`, think in terms of a single-root component boundary: one parent element defines the island boundary, Prisma PHP serializes props onto that root, and the framework injects a stable `pp-component` attribute there. Do not design imported partials as loose sibling markup.
 
 AI must not collapse these two models into one.
 
 - **PHPX** is for class-based component authoring.
 - **`ImportComponent`** is for importing PHP partial files as single-root component islands.
 
+## Important distinction: route files vs imported partials
+
+This is the route/component distinction AI must keep straight.
+
+### Normal route files
+
+For a normal route file such as `src/app/index.php` or nested `layout.php`, use this structure:
+
+1. PHP
+2. one parent HTML element for the route content
+3. one `<script>` block after that parent element
+
+Example route-file pattern:
+
+```php filename="src/app/dashboard/index.php"
+<?php
+
+$title = 'Dashboard';
+?>
+
+<section class="dashboard-page">
+    <h1><?= htmlspecialchars($title) ?></h1>
+    <p>Count: {count}</p>
+</section>
+
+<script>
+    const [count, setCount] = pp.state(0);
+</script>
+```
+
+That is the correct route-page pattern. It is documented in `layouts-and-pages.md`, not in `ImportComponent`.
+
+### Imported partials rendered with `ImportComponent`
+
+For an imported partial, the file itself must emit exactly **one root element**. If the partial needs client script, place that script **inside** the parent root element.
+
+Correct imported-partial pattern:
+
+```php filename="src/app/inc/SearchBox.php"
+<?php
+
+$title = 'Search';
+?>
+
+<div class="rounded-lg border bg-card p-4" pp-component="search-box">
+    <h2 class="font-medium"><?= htmlspecialchars($title) ?></h2>
+    <input value="{query}" oninput="{(e) => setQuery(e.target.value)}" />
+    <script>
+        console.log('Search component ready');
+    </script>
+</div>
+```
+
+Incorrect imported-partial pattern:
+
+```php filename="src/app/inc/SearchBox.php"
+<?php
+
+$title = 'Search';
+?>
+
+<section class="rounded-lg border bg-card p-4">
+    <h2 class="font-medium"><?= htmlspecialchars($title) ?></h2>
+</section>
+
+<script>
+    console.log('This script is a second root element');
+</script>
+```
+
+Why this is invalid:
+
+- the `<section>` is one root element
+- the sibling `<script>` is a second root element
+- `ImportComponent` requires the file to resolve to **exactly one root element**
+
 ## Important AI rules for Prisma PHP components
 
 - treat the official Prisma PHP component docs as the source of truth
@@ -91,6 +167,8 @@ AI must not collapse these two models into one.
 - when using `ImportComponent`, always ensure the imported file renders **exactly one root element**
 - treat the `ImportComponent` root as the real component boundary because Prisma PHP serializes props onto it and injects `pp-component`
 - do not manually add `pp-component` inside imported partial source; let Prisma PHP inject it
+- do not apply the imported-partial rule to normal route files
+- do not apply the normal route-file pattern to imported partials
 
 ## Component file placement and naming
 

package/dist/docs/index.md

@@ -8,7 +8,7 @@ related:
     - /docs/get-started
 ---
 
-{/_AI agent hint: Prisma PHP uses local installed docs as the source of truth for the active project version. Before generating framework-specific code, read `prisma-php.json` first, then read the relevant docs from `node_modules/prisma-php/dist/docs`. For authentication, read `authentication.md` first, then verify the official auth docs: `auth-get-started`, `credentials`, and `state-manager-auth`. For file uploads, `multipart/form-data`, `$_FILES`, `PP\FileManager\UploadFile`, rename/delete flows, or file manager screens, read `file-manager.md` first, then verify the official File Manager docs: `get-started-file`. For ORM work, read `prisma-php-orm.md` before choosing schema, migration, or generation commands. For PulsePoint runtime behavior specifically, read `pulsepoint.md` before generating reactive UI code. For normal interactive full-stack page work, default to PulsePoint plus `pp.fetchFunction(...)` unless the user explicitly asks for a PHP-only interaction style. When building PulsePoint-aware `index.php` or `layout.php`, keep PHP first, HTML second, and one `<script>` block last, with the rendered route content inside a single parent HTML element that acts as the route-view boundary. For imported partial components, keep exactly one root element because Prisma PHP uses that root as the component boundary where serialized props and `pp-component` attach. For backend validation, sanitization, `Validator`, `Rule`, `pp.fetchFunction(...)` validation flows, or request validation in `route.php`, read `validator.md` first, then use `fetching-data.md`, `error-handling.md`, and `route-handlers.md` for context-specific patterns, then consult the official Validator docs. `PP\Validator` is a Prisma PHP core class located in `vendor/tsnc/prisma-php/src/Validator.php`. Route creation is file-based from `src/app`; Prisma PHP auto-generates route listings such as `files-list.json`, so AI agents must not create, edit, or maintain that file manually._/}
+{/_AI agent hint: Prisma PHP uses local installed docs as the source of truth for the active project version. Before generating framework-specific code, read `prisma-php.json` first, then read the relevant docs from `node_modules/prisma-php/dist/docs`. For authentication, read `authentication.md` first, then verify the official auth docs: `auth-get-started`, `credentials`, and `state-manager-auth`. For file uploads, `multipart/form-data`, `$_FILES`, `PP\FileManager\UploadFile`, rename/delete flows, or file manager screens, read `file-manager.md` first, then verify the official File Manager docs: `get-started-file`. For ORM work, read `prisma-php-orm.md` before choosing schema, migration, or generation commands. For PulsePoint runtime behavior specifically, read `pulsepoint.md` before generating reactive UI code. For normal interactive full-stack page work, default to PulsePoint plus `pp.fetchFunction(...)` unless the user explicitly asks for a PHP-only interaction style. For normal PulsePoint-aware route files such as `index.php` and nested `layout.php`, keep PHP first, HTML second, and one `<script>` block last, with the rendered route content inside a single parent HTML element that acts as the route-view boundary. For imported partial components rendered with `ImportComponent::render(...)`, keep exactly one root element and place any component-local `<script>` inside that root because Prisma PHP uses that root as the component boundary where serialized props and `pp-component` attach. Do not confuse the route-file pattern with the imported-partial pattern. For backend validation, sanitization, `Validator`, `Rule`, `pp.fetchFunction(...)` validation flows, or request validation in `route.php`, read `validator.md` first, then use `fetching-data.md`, `error-handling.md`, and `route-handlers.md` for context-specific patterns, then consult the official Validator docs. `PP\Validator` is a Prisma PHP core class located in `vendor/tsnc/prisma-php/src/Validator.php`. Route creation is file-based from `src/app`; Prisma PHP auto-generates route listings such as `files-list.json`, so AI agents must not create, edit, or maintain that file manually._/}
 
 Welcome to the Prisma PHP documentation!
 
@@ -45,6 +45,69 @@ For typical full-stack Prisma PHP work, AI should assume this default:
 
 Do **not** default to PHP-only interaction flows for normal reactive UI work unless the user explicitly asks for that style.
 
+### Important structure rule
+
+There are **two different valid structures** that AI must not mix up.
+
+#### 1. Normal route files
+
+For a normal route file such as `src/app/index.php` or nested `layout.php`, use:
+
+1. PHP
+2. one parent HTML element
+3. one `<script>` block after that parent element
+
+Example:
+
+```php filename="src/app/index.php"
+<?php
+
+use PP\MainLayout;
+
+MainLayout::$title = 'Todos';
+MainLayout::$description = 'Track tasks and view the current item count.';
+?>
+
+<section>
+    <h1>Todos</h1>
+    <p>Count: {count}</p>
+</section>
+
+<script>
+    const [count, setCount] = pp.state(0);
+</script>
+```
+
+For SEO metadata, prefer `MainLayout::$title` and `MainLayout::$description` instead of relying on a local heading variable alone.
+
+#### 2. Imported partials rendered with `ImportComponent`
+
+For an imported partial component, use:
+
+1. PHP
+2. exactly one parent root element containing the component markup
+3. any component-local `<script>` **inside** that root element
+
+Example:
+
+```php filename="src/app/inc/SearchBox.php"
+<?php
+
+// PHP Code
+
+?>
+
+<div class="rounded-lg border p-4" pp-component="search-box">
+    <h2>Search</h2>
+    <input value="{query}" />
+    <script>
+        console.log('Search component ready');
+    </script>
+</div>
+```
+
+Do not confuse the route-file pattern with the `ImportComponent` partial pattern.
+
 ### Read this doc when you need
 
 - **project setup or file placement** → `project-structure.md`
@@ -72,7 +135,8 @@ Do **not** default to PHP-only interaction flows for normal reactive UI work unl
 - do not create, edit, or maintain `files-list.json`; Prisma PHP generates route listings automatically
 - when building interactive frontend behavior, prefer the documented PulsePoint pattern with browser-side reactive state and `pp.fetchFunction(...)` for server calls; treat this as the default unless the user explicitly asks for a PHP-only interaction pattern
 - when building PulsePoint inside `index.php` or `layout.php`, read `layouts-and-pages.md` together with `pulsepoint.md`, use PHP then HTML then one `<script>` block, keep route content inside a single parent HTML element, and treat that root as the route-view boundary
-- when importing a PHP partial with `ImportComponent`, require exactly one root element because Prisma PHP attaches serialized props and a stable `pp-component` attribute to that root; do not manually sprinkle `pp-component` across normal route markup
+- when importing a PHP partial with `ImportComponent`, require exactly one root element and keep any partial-local `<script>` inside that root because Prisma PHP attaches serialized props and a stable `pp-component` attribute to that root
+- do not manually sprinkle `pp-component` across normal route markup
 - when building backend validation logic, read `validator.md` first, then use the route-specific docs for the request entry point
 - when using `pp.fetchFunction(...)`, expose the PHP function explicitly with `#[Exposed]`
 - when changing feature flags, update `prisma-php.json` first, then follow the documented update workflow

package/dist/docs/layouts-and-pages.md

@@ -15,7 +15,7 @@ related:
     - /docs/route-php
 ---
 
-Prisma PHP uses **file-system based routing**, meaning you can use folders and files to define routes. This page will guide you through how to create layouts and pages, and organize them using Prisma PHP conventions.
+Prisma PHP uses **file-system based routing**, meaning you can use folders and files to define routes. This page explains how to create pages and layouts, how to choose the correct route file, and how to keep PulsePoint-aware route files structurally consistent.
 
 ## Important route generation note
 
@@ -30,7 +30,7 @@ When adding a page or nested route, create the correct folder and add the proper
 Prisma PHP has two important route entry files, and they serve different purposes.
 
 - `index.php` is the **UI entry point** for a route. Use it when the route should render HTML or a normal full-stack page. In full-stack projects, this is also the default home for route-local PulsePoint-driven interactivity.
-- `route.php` is the **direct handler entry point** for a route. Use it when the route should behave like an API endpoint, JSON endpoint, AJAX handler, form-processing endpoint, or other no-view server handler.
+- `route.php` is the **direct handler entry point** for a route. Use it when the route should behave like an API endpoint, JSON endpoint, AJAX handler, form-processing endpoint, webhook, or other no-view server handler.
 
 A helpful project-level rule comes from `prisma-php.json`:
 
@@ -70,24 +70,38 @@ In practice, that means:
 - render the route markup after the PHP block
 - place one PulsePoint `<script>` block at the bottom of the file
 
-For the HTML portion, keep a **single parent HTML tag** around the route content, similar to React's single-root component rule. Treat that root as the page or layout boundary instead of as a throwaway wrapper.
+For the HTML portion, keep a **single parent HTML tag** around the route content. Treat that root as the page or layout boundary instead of as a throwaway wrapper.
 
-- In `index.php`, wrap the page UI in one parent element such as `<main>`, `<section>`, or `<article>`, and treat that root as the route view's component-style boundary.
+- In `index.php`, wrap the page UI in one parent element such as `<main>`, `<section>`, or `<article>`, and treat that root as the route-view boundary.
 - In nested `layout.php`, wrap the shared layout UI and `<?= MainLayout::$children; ?>` in one parent element so the layout still behaves like one boundary.
-- If that markup is later extracted into an `ImportComponent` partial, preserve the same single-root structure so Prisma PHP can attach the stable `pp-component` attribute to that root element.
 - The root `layout.php` is the document shell and is the only layout that should contain `<html>` and `<body>`. Inside `<body>`, keep one clear wrapper around `<?= MainLayout::$children; ?>` when PulsePoint behavior is present.
 
-Example PulsePoint page structure:
+### Important distinction: route files vs imported partials
 
-```php filename="src/app/dashboard/index.php"
+Do **not** confuse the structure of a normal route file with the structure of an imported partial component.
+
+For **normal route files** such as `src/app/index.php` and nested `layout.php`, use this shape:
+
+1. PHP
+2. one parent HTML element for the rendered route UI
+3. one `<script>` block after that parent element
+
+Correct route-file pattern:
+
+```php filename="src/app/index.php"
 <?php
 
-$title = 'Dashboard';
+use PP\Attributes\Exposed;
+use PP\MainLayout;
+use PP\Validator;
+
+MainLayout::$title = 'Todos';
+MainLayout::$description = 'Track tasks and view the current item count.';
 ?>
-<section class="dashboard-page">
-        <h1><?= htmlspecialchars($title); ?></h1>
-        <p>Count: {count}</p>
-        <button onclick="setCount(count + 1)">Increment</button>
+
+<section class="space-y-4">
+    <h1>Todos</h1>
+    <p>Count: {count}</p>
 </section>
 
 <script>
@@ -95,7 +109,10 @@ $title = 'Dashboard';
 </script>
 ```
 
-This order keeps server logic, rendered markup, and client reactivity easy to scan for both humans and AI tools.
+That is the default structure for a PulsePoint-aware route page.
+Use `MainLayout::$title` and `MainLayout::$description` for page metadata, and keep a separate heading variable only when the visible heading text needs to differ.
+
+By contrast, **imported partials rendered with `ImportComponent::render(...)` follow a different rule**: the imported file must emit exactly **one root element**, and if it contains a `<script>`, that script must live **inside** that root element. Read `components.md` for that pattern.
 
 ## Creating a page
 
@@ -106,7 +123,15 @@ For example, to create an index page (`/`):
 ```php filename="src/app/index.php"
 <?php
 
-echo "<h1>Hello Prisma PHP!</h1>";
+use PP\MainLayout;
+
+MainLayout::$title = 'Hello Prisma PHP!';
+MainLayout::$description = 'Welcome to your Prisma PHP application.';
+?>
+
+<section pp-component="home-page">
+    <h1>Hello Prisma PHP!</h1>
+</section>
 ```
 
 A route is created from the folder structure, and `index.php` is the default file used for route UI.
@@ -120,15 +145,18 @@ You can define a layout by creating a `layout.php` file. The root layout is requ
 For example, to create a root layout:
 
 ```php filename="src/app/layout.php"
+<?php
 
-<?php use PP\MainLayout; ?>
+use PP\MainLayout;
+?>
 
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>My Prisma PHP App</title>
+    <title><?= htmlspecialchars(MainLayout::$title ?: 'My Prisma PHP App') ?></title>
+    <meta name="description" content="<?= htmlspecialchars(MainLayout::$description ?: 'Default application description') ?>">
 </head>
 <body>
     <main>
@@ -157,7 +185,15 @@ src/app/
 ```php filename="src/app/blog/index.php"
 <?php
 
-echo "<h1>Blog</h1>";
+use PP\MainLayout;
+
+MainLayout::$title = 'Blog';
+MainLayout::$description = 'Read the latest articles and updates.';
+?>
+
+<section pp-component="blog-page">
+    <h1>Blog</h1>
+</section>
 ```
 
 You can continue nesting folders to create deeper routes. For example, to create a route for a specific blog post:
@@ -172,11 +208,18 @@ src/app/
 ```php filename="src/app/blog/[slug]/index.php"
 <?php
 
+use PP\MainLayout;
 use PP\Request;
 
 $slug = Request::$dynamicParams['slug'] ?? null;
 
-echo "<h1>Blog post: " . htmlspecialchars((string) $slug) . "</h1>";
+MainLayout::$title = 'Blog post: ' . ucfirst(str_replace('-', ' ', (string) $slug));
+MainLayout::$description = 'Read the full article for ' . ucfirst(str_replace('-', ' ', (string) $slug)) . '.';
+?>
+
+<section pp-component="blog-post-page">
+    <h1>Blog post: <?= htmlspecialchars((string) $slug) ?></h1>
+</section>
 ```
 
 Wrapping a folder name in square brackets creates a **dynamic route segment** that can be filled from the incoming URL.
@@ -198,10 +241,12 @@ src/app/
 ```
 
 ```php filename="src/app/blog/layout.php"
+<?php
 
-<?php use PP\MainLayout; ?>
+use PP\MainLayout;
+?>
 
-<section>
+<section pp-component="blog-layout">
     <header>
         <h1>Blog Section</h1>
     </header>
@@ -211,7 +256,8 @@ src/app/
 ```
 
 If you combine both layouts, the root layout wraps the blog layout, and the blog layout wraps both `src/app/blog/index.php` and `src/app/blog/[slug]/index.php`.
-Nested layouts should behave like single-root route views: one parent element should wrap the shared layout UI and `MainLayout::$children;`. Keep thinking in terms of one component-style boundary, not multiple sibling roots.
+Nested layouts should behave like single-root route views: one parent element should wrap the shared layout UI and `MainLayout::$children;`.
+Keep thinking in terms of one component-style boundary, not multiple sibling roots.
 
 ## Creating a dynamic segment
 
@@ -320,9 +366,12 @@ Example:
 ```php filename="src/app/users/route.php"
 <?php
 
-echo json_encode([
-    'success' => true,
-]);
+use Lib\Prisma\Classes\Prisma;
+
+$prisma = Prisma::getInstance();
+$users = $prisma->user->findMany();
+
+echo json_encode($users);
 ```
 
 ## Good to know
@@ -342,3 +391,4 @@ echo json_encode([
 - Dynamic route parameters are available through `Request::$dynamicParams`.
 - Route groups let you organize routes and assign different layouts without affecting the URL.
 - Private folders help you colocate implementation files without making them routable.
+- Imported partials rendered through `ImportComponent` follow a different structural rule: one root element containing any component-local `<script>`.

package/dist/docs/metadata-and-og-images.md

@@ -13,6 +13,8 @@ related:
 
 This page explains how to manage metadata in Prisma PHP and how icon file conventions such as `favicon`, `icon`, and `apple-icon` work.
 
+For better SEO, treat `MainLayout::$title` and `MainLayout::$description` as the primary way to set page metadata. A local `$title` variable only affects rendered page content unless you also assign the document metadata through `MainLayout`.
+
 Prisma PHP’s metadata system is centered on the `MainLayout` class rather than Next.js exports like `metadata`, `generateMetadata`, or generated `opengraph-image.tsx`. The provided Prisma PHP docs describe dynamic page metadata and icon file conventions, but they do **not** document a dedicated Next.js-style generated Open Graph image pipeline on these pages. citeturn0view0turn1view0
 
 ## Metadata in Prisma PHP
@@ -40,6 +42,28 @@ In this model:
 - `MainLayout::$description` sets the page description
 - `MainLayout::addCustomMetaData(...)` adds additional metadata such as `author` or other `<meta>` values citeturn0view0
 
+## Heading text vs document metadata
+
+If your page has a visible heading, keep it separate from the document metadata when needed.
+
+This is a better pattern than relying on a local `$title` variable alone:
+
+```php filename="src/app/dashboard/index.php"
+<?php
+
+use Lib\MainLayout;
+
+MainLayout::$title = "Dashboard";
+MainLayout::$description = "View account stats, recent activity, and important actions.";
+?>
+
+<section>
+    <h1>Dashboard</h1>
+</section>
+```
+
+Use this pattern when the browser title, search-engine title, and page heading should stay aligned. If the visible heading needs to differ from the SEO title, keep the heading in its own variable and continue setting metadata through `MainLayout`.
+
 ## Dynamic metadata
 
 Prisma PHP also supports dynamic metadata based on request data or other runtime conditions.
@@ -83,6 +107,34 @@ MainLayout::$description = "Learn more about our company.";
 </section>
 ```
 
+## Rendering metadata in the root layout
+
+Your root `layout.php` can read from `MainLayout` so page-level metadata set in `index.php` or nested `layout.php` is reflected in the document head.
+
+```php filename="src/app/layout.php"
+<?php
+
+use Lib\MainLayout;
+?>
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= htmlspecialchars(MainLayout::$title ?: "My Prisma PHP App") ?></title>
+    <meta name="description" content="<?= htmlspecialchars(MainLayout::$description ?: "Default application description") ?>">
+</head>
+<body>
+    <main>
+        <?= MainLayout::$children; ?>
+    </main>
+</body>
+</html>
+```
+
+This lets route files control SEO metadata while the root layout stays responsible for the actual `<head>` output.
+
 ## Adding custom metadata
 
 You can attach additional custom metadata through `MainLayout::addCustomMetaData(...)`.
@@ -219,7 +271,7 @@ Because those pages do not document a dedicated Prisma PHP Open Graph image gene
 ## Good to know
 
 - Prisma PHP uses `MainLayout` for dynamic metadata management. citeturn0view0
-- `MainLayout::$title` and `MainLayout::$description` are the main documented page metadata properties. citeturn0view0
+- `MainLayout::$title` and `MainLayout::$description` are the main documented page metadata properties.
 - `MainLayout::addCustomMetaData(...)` adds custom metadata such as `author`. citeturn0view0
 - Metadata should be set before any HTML output. citeturn0view0
 - `MainLayout::addHeadScript(...)` and `MainLayout::addFooterScript(...)` can inject scripts into the page shell. citeturn0view0

package/dist/docs/project-structure.md

@@ -75,15 +75,15 @@ For AI-assisted generation, the default full-stack route pattern should be:
 
 Only prefer a more PHP-only interaction pattern when the user explicitly asks for it.
 
-### Framework-managed generated files
+## Framework-managed generated files
 
 Some files in a Prisma PHP project are framework-managed and should not be manually maintained as part of normal route work.
 
-#### `files-list.json`
+### `files-list.json`
 
 Prisma PHP automatically generates the route list in `files-list.json`.
 
-Do **not** create routes by editing this file. Do **not** manually add, remove, reorder, or “sync” entries in it.
+Do **not** create routes by editing this file. Do **not** manually add, remove, reorder, or sync entries in it.
 
 Instead, create or update the correct folders and route files in `src/app`, then let Prisma PHP regenerate `files-list.json` automatically.
 
@@ -104,6 +104,67 @@ Routes are defined by the route tree under `src/app`. Prisma PHP then derives ro
 | `not-found.php` | Not found UI                                                         |
 | `error.php`     | Error handling UI                                                    |
 
+## Route file shape rules
+
+The route tree tells Prisma PHP **where** a route lives. The file shape tells AI **how** the route file should be structured.
+
+### `index.php` and nested `layout.php`
+
+For normal PulsePoint-aware route files, use:
+
+1. PHP
+2. one parent HTML element
+3. one `<script>` block after that parent element
+
+Example:
+
+```php filename="src/app/dashboard/index.php"
+<?php
+
+use PP\MainLayout;
+
+MainLayout::$title = 'Dashboard';
+MainLayout::$description = 'View dashboard metrics and current activity.';
+?>
+
+<section class="dashboard-page">
+    <h1>Dashboard</h1>
+    <p>Count: {count}</p>
+</section>
+
+<script>
+    const [count, setCount] = pp.state(0);
+</script>
+```
+
+That is the default route-file structure for a full-stack page.
+For document metadata, set `MainLayout::$title` and `MainLayout::$description` instead of assuming a local `$title` variable will populate the `<head>`.
+
+### `ImportComponent` partials are different
+
+An imported partial rendered through `ImportComponent::render(...)` is **not** a normal route file.
+
+For imported partials, the file must emit exactly **one root element**, and if the partial contains a `<script>`, that script must live **inside** that root element.
+
+Example:
+
+```php filename="src/app/inc/SearchBox.php"
+<?php
+
+$title = 'Search';
+?>
+
+<div class="rounded-lg border p-4" pp-component="search-box">
+    <h2><?= htmlspecialchars($title) ?></h2>
+    <input value="{query}" />
+    <script>
+        console.log('Search component ready');
+    </script>
+</div>
+```
+
+Do not confuse the normal route-file pattern with the imported-partial pattern.
+
 ## Nested routes
 
 Folders define URL segments. Nesting folders nests segments. A route becomes publicly accessible when an `index.php` file exists inside that route folder.
@@ -198,6 +259,8 @@ prisma-php-project/
 │   │   │   │   └── route.php
 │   │   │   └── _components/
 │   │   │       └── StatsCard.php
+│   │   ├── inc/
+│   │   │   └── SearchBox.php
 │   │   └── blog/
 │   │       ├── index.php
 │   │       └── [slug]/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-php",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Prisma PHP tooling",
   "main": "index.js",
   "scripts": {