prisma-php 0.0.10 → 0.0.11

package/dist/docs/mcp.md

@@ -5,6 +5,7 @@ related:
   title: Related docs
   description: Read the official Prisma PHP MCP docs before generating or editing MCP server code.
   links:
+    - /docs/env
     - /docs/prisma-php-ai-mcp
     - /docs/ai-tools
     - /docs/project-structure
@@ -33,6 +34,7 @@ Do not assume another framework's agent or tool abstractions apply directly.
 ## Read this doc when you need
 
 - **MCP server bootstrap, `PhpMcp\Server\Server`, `StreamableHttpServerTransport`, `MCP_HOST`, `MCP_PORT`, or endpoint URL construction** -> official `prisma-php-ai-mcp`
+- **typed environment access for `MCP_*` values or `.env` loading boundaries** -> `env.md` plus `mcp.md`
 - **authoring tool classes with `#[McpTool]` and typed input validation with `#[Schema]`** -> official `ai-tools` plus `mcp.md`
 - **where MCP files belong in a Prisma PHP project** -> `project-structure.md` plus `mcp.md`
 - **feature flags and scaffolding for MCP support** -> `upgrading.md` plus `mcp.md`
@@ -46,7 +48,7 @@ Prisma PHP documents MCP around a dedicated PHP server entry point that auto-dis
 That means AI should preserve this model by default:
 
 - a PHP server built with `PhpMcp\Server\Server`
-- server metadata from environment variables
+- server metadata from environment variables resolved through `PP\Env`
 - attribute-based discovery of tool classes annotated with `#[McpTool]`
 - `StreamableHttpServerTransport` for the HTTP endpoint
 - domain-specific tool classes under `src/Lib/MCP`
@@ -114,6 +116,7 @@ AI should preserve these settings:
 Behavior notes:
 
 - `.env` loading is optional and happens from `DOCUMENT_PATH/.env`
+- typed runtime reads happen through `PP\Env`, whose implementation lives in `vendor/tsnc/prisma-php/src/Env.php`
 - the path prefix is trimmed with `trim(..., '/')`, so the effective route becomes `/<prefix>`
 - the final endpoint URL resolves to `http://{host}:{port}/{prefix}`
 - enabling `MCP_JSON_RESPONSE` can help with browser-based debugging and the Inspector

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

@@ -1,6 +1,6 @@
 ---
 title: Metadata and Icons
-description: Learn how to manage page metadata and application icons in Prisma PHP.
+description: Learn how AI agents should manage page metadata and application icons in Prisma PHP with `MainLayout` and the documented icon file conventions.
 related:
   title: API Reference
   description: Learn more about metadata and icon file conventions in Prisma PHP.
@@ -15,13 +15,25 @@ This page explains how to manage metadata in Prisma PHP and how icon file conven
 
 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
+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.
+
+If a task involves page titles, descriptions, custom meta tags, favicon files, icon files, or SEO metadata, AI agents should read this page first and keep metadata aligned with `MainLayout` and the documented icon conventions.
+
+## AI rule: read the metadata docs first
+
+Before generating Prisma PHP metadata code, use this order:
+
+1. Use `MainLayout::$title` and `MainLayout::$description` for document metadata.
+2. Use `MainLayout::addCustomMetaData(...)` for extra meta tags.
+3. Keep visible headings separate from document metadata when the UI text needs to differ.
+4. Use the documented `favicon`, `icon`, and `apple-icon` file conventions instead of inventing generated metadata modules.
+5. Read `layouts-and-pages.md` when the task also changes route or layout structure.
 
 ## Metadata in Prisma PHP
 
 Prisma PHP lets you update metadata dynamically through the `MainLayout` class.
 
-The docs say this is used to manage head scripts, footer scripts, and custom metadata for each page. citeturn0view0
+Prisma PHP uses this to manage head scripts, footer scripts, and custom metadata for each page.
 
 ### Basic metadata example
 
@@ -40,7 +52,7 @@ In this model:
 
 - `MainLayout::$title` sets the page title
 - `MainLayout::$description` sets the page description
-- `MainLayout::addCustomMetaData(...)` adds additional metadata such as `author` or other `<meta>` values citeturn0view0
+- `MainLayout::addCustomMetaData(...)` adds additional metadata such as `author` or other `<meta>` values
 
 ## Heading text vs document metadata
 
@@ -84,11 +96,11 @@ MainLayout::$description = $productDescription;
 ?>
 ```
 
-This is the closest Prisma PHP equivalent to route-aware or dynamic metadata generation. citeturn0view0
+This is the closest Prisma PHP equivalent to route-aware or dynamic metadata generation.
 
 ## Important placement rule
 
-The Prisma PHP docs explicitly note that metadata should be set **at the top of the PHP file before any HTML output** so it can render correctly inside the document `<head>`. citeturn0view0
+The Prisma PHP docs explicitly note that metadata should be set **at the top of the PHP file before any HTML output** so it can render correctly inside the document `<head>`.
 
 That means this pattern is correct:
 
@@ -165,7 +177,7 @@ The docs also describe metadata-related layout hooks for scripts.
 You can inject scripts into the document head or footer with:
 
 - `MainLayout::addHeadScript(...)`
-- `MainLayout::addFooterScript(...)` citeturn0view0
+- `MainLayout::addFooterScript(...)`
 
 Example:
 
@@ -189,7 +201,7 @@ The docs say that `favicon`, `icon`, and `apple-icon` files let you define icons
 
 - browser tabs
 - phone home screens
-- search engine results citeturn1view0
+- search engine results
 
 ### Supported icon files
 
@@ -197,15 +209,15 @@ The provided Prisma PHP icon docs mention image-file based usage such as:
 
 - `.ico`
 - `.jpg`
-- `.png` citeturn1view0
+- `.png`
 
 ### Where to place them
 
-The docs say to place a `favicon`, `icon`, or `apple-icon` file within your `/app` directory, and specifically state that the favicon image must be located at the **top level** of `/app`. citeturn1view0
+The docs say to place a `favicon`, `icon`, or `apple-icon` file within your `/app` directory, and specifically state that the favicon image must be located at the **top level** of `/app`.
 
 ## `favicon.ico`
 
-For the favicon, the docs say to add a `favicon.ico` image file to the root `/app` route segment. They also note that the favicon link tag is already included in the `<head>` of `layout.php`, so the normal step is simply to replace the existing `favicon.ico` file with your own. citeturn1view0
+For the favicon, the docs say to add a `favicon.ico` image file to the root `/app` route segment. They also note that the favicon link tag is already included in the `<head>` of `layout.php`, so the normal step is simply to replace the existing `favicon.ico` file with your own.
 
 The documented link tag is:
 
@@ -213,11 +225,11 @@ The documented link tag is:
 <link rel="icon" href="<?= Request::baseUrl?>/favicon.ico" type="image/x-icon" sizes="16x16">
 ```
 
-This means Prisma PHP already expects the favicon in the standard project location and wires it into the layout automatically. citeturn1view0
+This means Prisma PHP already expects the favicon in the standard project location and wires it into the layout automatically.
 
 ## Automatic head integration
 
-The icon docs say Prisma PHP evaluates these icon files and **automatically adds the appropriate tags to your app’s `<head>` element**. citeturn1view0
+The icon docs say Prisma PHP evaluates these icon files and **automatically adds the appropriate tags to your app’s `<head>` element**.
 
 That is the Prisma PHP equivalent of file-convention-based icon metadata.
 
@@ -257,24 +269,24 @@ If you are coming from Next.js, the closest mapping is:
 | file-based icon conventions       | Prisma PHP `favicon`, `icon`, `apple-icon` file conventions                            |
 | generated OG image files          | not documented on the provided Prisma PHP metadata pages                               |
 
-The main difference is that Prisma PHP’s documented system is **layout-class driven** for metadata and **file-convention driven** for icons, rather than based on exported metadata objects or generated route modules. citeturn0view0turn1view0
+The main difference is that Prisma PHP’s documented system is **layout-class driven** for metadata and **file-convention driven** for icons, rather than based on exported metadata objects or generated route modules.
 
 ## About Open Graph images
 
 The Next.js page title includes OG images, but the provided Prisma PHP docs you linked focus on:
 
 - dynamic page metadata through `MainLayout`
-- icon file conventions such as `favicon`, `icon`, and `apple-icon` citeturn0view0turn1view0
+- icon file conventions such as `favicon`, `icon`, and `apple-icon`
 
 Because those pages do not document a dedicated Prisma PHP Open Graph image generation system, this page does **not** invent one. If your framework later adds a specific OG image convention, that would belong here.
 
 ## Good to know
 
-- Prisma PHP uses `MainLayout` for dynamic metadata management. citeturn0view0
+- Prisma PHP uses `MainLayout` for dynamic metadata management.
 - `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
-- Prisma PHP supports `favicon`, `icon`, and `apple-icon` file conventions. citeturn1view0
-- `favicon.ico` belongs at the top level of the app directory. citeturn1view0
-- Prisma PHP automatically adds the appropriate icon tags to the document head. citeturn1view0
+- `MainLayout::addCustomMetaData(...)` adds custom metadata such as `author`.
+- Metadata should be set before any HTML output.
+- `MainLayout::addHeadScript(...)` and `MainLayout::addFooterScript(...)` can inject scripts into the page shell.
+- Prisma PHP supports `favicon`, `icon`, and `apple-icon` file conventions.
+- `favicon.ico` belongs at the top level of the app directory.
+- Prisma PHP automatically adds the appropriate icon tags to the document head.

package/dist/docs/prisma-php-orm.md

@@ -1,6 +1,6 @@
 ---
 title: Prisma PHP ORM
-description: Learn how Prisma PHP ORM works, how to configure it, how to migrate your database, and how to generate the PHP ORM classes correctly.
+description: Learn how Prisma PHP ORM works so AI agents can choose the correct configuration, migration, and PHP class generation workflow.
 related:
   title: Related docs
   description: Read the official Prisma PHP ORM docs before generating code or running ORM commands.

package/dist/docs/project-structure.md

@@ -1,11 +1,21 @@
 ---
 title: Project structure and organization
 nav_title: Project Structure
-description: Learn the folder and file conventions in Prisma PHP, and how to organize your project.
----
+description: Learn the folder and file conventions in Prisma PHP so AI agents can place features in the right files and folders.
 
 This page provides an overview of the folder and file conventions in **Prisma PHP**, and recommendations for organizing your project. It follows the Prisma PHP routing model and mirrors the mental model of a Next.js App Router style project structure, adapted to how Prisma PHP actually works.
 
+If a task involves file placement, feature flags, route creation, or overall Prisma PHP app organization, AI agents should read this page first and use it as the directory-level source of truth before generating files.
+
+## AI rule: read the structure docs first
+
+Before generating Prisma PHP files or folders, use this order:
+
+1. Read `prisma-php.json`.
+2. Decide whether the task belongs in `src/app`, `src/Lib`, `prisma`, `public`, or `settings`.
+3. Create routes from the route tree instead of editing `files-list.json`.
+4. Use `layouts-and-pages.md`, `route-handlers.md`, or `components.md` once the file location is known.
+
 ## Folder and file conventions
 
 ### Top-level folders
@@ -55,6 +65,10 @@ Typical values include:
 
 If an AI agent is working on the project, it should inspect `prisma-php.json` before deciding whether Tailwind CSS, TypeScript, Prisma ORM, Swagger docs, MCP, or websocket-related code should be generated.
 
+For backend-only API projects, read `backend-only.md`.
+
+For Swagger and OpenAPI generation, read `swagger-docs.md`.
+
 ### Full-stack vs backend-only routing decision
 
 One of the most important capability flags is `backendOnly`.

package/dist/docs/pulsepoint.md

@@ -1,3 +1,8 @@
+---
+title: PulsePoint Runtime Guide
+description: Learn how AI agents should use the current PulsePoint runtime contract, component script rules, and supported directives in Prisma PHP.
+---
+
 # PulsePoint Runtime Guide
 
 ## Purpose

package/dist/docs/route-handlers.md

@@ -1,7 +1,7 @@
 ---
 title: Route Handlers
 nav_title: Route Handlers
-description: Learn how to use route handlers in Prisma PHP with `route.php`.
+description: Learn how AI agents should use route handlers in Prisma PHP with `route.php` for API-style and no-view routes.
 related:
   title: API Reference
   description: Learn more about route handlers in Prisma PHP.
@@ -18,6 +18,18 @@ Route Handlers in Prisma PHP let you create custom request handlers for a given
 
 A `route.php` file bypasses the standard view rendering flow and acts as a direct entry point for a specific URL path. This makes it useful for APIs, form submissions, AJAX endpoints, JSON responses, and route-specific server logic.
 
+If a task involves API-style endpoints, JSON responses, form-processing handlers, webhooks, or machine-facing routes, AI agents should read this page first and keep `route.php` separate from normal page routes.
+
+## AI rule: read the route-handler docs first
+
+Before generating Prisma PHP `route.php` files, use this order:
+
+1. Read `prisma-php.json` and confirm whether the project is backend-only.
+2. Use `route.php` only for direct handler or no-view routes.
+3. Read from `Request::$params` and validate with `PP\Validator`.
+4. Return structured JSON or `Boom` responses for expected failures.
+5. Use `index.php` plus `pp.fetchFunction(...)` instead when the behavior belongs to a rendered page.
+
 ## `route.php` vs `index.php`
 
 Prisma PHP has a clear separation between page routes and direct handlers:
@@ -25,7 +37,7 @@ Prisma PHP has a clear separation between page routes and direct handlers:
 - `index.php` is the UI entry point for a route segment and should be used for rendered HTML routes.
 - `route.php` is the direct handler entry point for a route segment and should be used for API-style or no-view routes.
 
-The official `index.php` doc explicitly states that `index.php` is for rendering UI and that if you need to return JSON data, like an API, or handle form processing without a view, you should use `route.php` instead. The `route.php` doc describes it as bypassing standard view rendering to build APIs, handle form submissions, or manage complex logic. citeturn1view0turn0view0
+The official `index.php` doc explicitly states that `index.php` is for rendering UI and that if you need to return JSON data, like an API, or handle form processing without a view, you should use `route.php` instead. The `route.php` doc describes it as bypassing standard view rendering to build APIs, handle form submissions, or manage complex logic.
 
 In practice, that leads to this rule:
 
@@ -35,6 +47,10 @@ In practice, that leads to this rule:
 - if the user asks for an API route, use `route.php`
 - if the user asks for a normal page route, use `index.php`
 
+For project-level backend-only guidance, separate frontend consumption, and CORS setup, read `backend-only.md`.
+
+For Prisma PHP OpenAPI generation and Swagger workflow details, read `swagger-docs.md`.
+
 For the provided project config:
 
 ```json

package/dist/docs/swagger-docs.md

@@ -0,0 +1,189 @@
+---
+title: Swagger docs for APIs
+nav_title: Swagger Docs
+description: Learn when Prisma PHP Swagger docs are worth enabling so AI agents can keep OpenAPI generation aligned with backendOnly and schema-driven workflows.
+related:
+  title: API Reference
+  description: Read the official Swagger and API docs together with the local Prisma PHP guidance.
+  links:
+    - /docs/swagger-docs-api
+    - /docs/api-get-started
+    - /docs/route-php
+    - /docs/orm-get-started
+---
+
+## Swagger docs in Prisma PHP
+
+Prisma PHP can generate Swagger-friendly OpenAPI documentation for API workflows.
+
+This is most useful when the project exposes endpoints for:
+
+- a separate frontend
+- mobile clients
+- public or partner APIs
+- SDK generation
+- API testing and contract review
+
+If the application is mainly a server-rendered Prisma PHP app that uses PulsePoint and `pp.fetchFunction(...)` for route-local interactions, Swagger docs may not be necessary.
+
+If a task involves OpenAPI generation, backend-only APIs, external client contracts, or schema-driven endpoint docs, AI agents should read this page first and keep the Swagger workflow aligned with `prisma-php.json`.
+
+## AI rule: read the Swagger docs first
+
+Before enabling or regenerating Swagger docs, use this order:
+
+1. Inspect `prisma-php.json` for `swaggerDocs` and `backendOnly`.
+2. Read `backend-only.md`, `route-handlers.md`, and `prisma-php-orm.md` as needed for the surrounding API workflow.
+3. Use `npm run create-swagger-docs` for the documented generation flow.
+4. Inspect `settings/prisma-schema-config.json` before changing output paths or generation modes.
+5. Do not treat Swagger generation as a substitute for ORM migrations or route implementation.
+
+## When Swagger docs are worth enabling
+
+Enable Swagger docs when you need a stable machine-readable contract for the API.
+
+Typical reasons include:
+
+- generating typed frontend clients
+- sharing endpoint definitions with other teams
+- reviewing request and response shapes outside the codebase
+- keeping backend-only or API-heavy projects documented as they evolve
+
+In Prisma PHP, the project-level feature flag is `swaggerDocs` in `prisma-php.json`.
+
+```json filename="prisma-php.json"
+{
+  "backendOnly": true,
+  "swaggerDocs": true
+}
+```
+
+If you enable the flag in an existing application, follow the documented project update flow from `upgrading.md`.
+
+## Generated OpenAPI JSON
+
+When Prisma PHP generates Swagger docs, the OpenAPI JSON file is created or updated at:
+
+```txt
+src/app/swagger-docs/apis/pphp-swagger.json
+```
+
+That JSON file is the handoff point for tools such as:
+
+- Swagger UI
+- OpenAPI Generator
+- `openapi-zod-client`
+- `openapi-typescript`
+- `orval`
+
+## Generation command
+
+Prisma PHP's Swagger workflow supports generating documentation for models from `schema.prisma`.
+
+```bash package="npm"
+npm run create-swagger-docs
+npm run create-swagger-docs Order
+npm run create-swagger-docs Order User Client
+```
+
+During generation, Prisma PHP prompts for three decisions:
+
+- whether to generate Swagger docs only
+- whether to generate endpoints
+- whether to generate PHP classes
+
+That makes the workflow flexible enough for:
+
+- docs-only regeneration
+- endpoint scaffolding together with docs
+- PHP class generation when the project needs it
+
+## Configuration file
+
+Swagger generation can be customized from:
+
+```txt
+settings/prisma-schema-config.json
+```
+
+Example configuration:
+
+```json filename="settings/prisma-schema-config.json"
+{
+  "swaggerDocsDir": "src/app/swagger-docs/apis",
+  "skipDefaultName": ["autoincrement", "cuid", "uuid", "now"],
+  "skipByPropertyValue": {
+    "isUpdatedAt": true
+  },
+  "skipFields": [],
+  "generateSwaggerDocsOnly": false,
+  "generateEndpoints": true,
+  "generatePhpClasses": true
+}
+```
+
+This file is where the Prisma PHP Swagger workflow decides:
+
+- where the JSON should be written
+- which schema defaults should be omitted from docs output
+- which fields should be skipped entirely
+- whether generation should include only docs, endpoints, PHP classes, or a combination
+
+## Recommended workflow
+
+For API-oriented Prisma PHP work, a practical Swagger workflow is:
+
+1. update `schema.prisma`
+2. run the normal ORM workflow when the schema changed
+3. regenerate Swagger docs
+4. inspect `src/app/swagger-docs/apis/pphp-swagger.json`
+5. regenerate external clients if the contract changed
+
+This keeps the API description aligned with the current schema and route generation output.
+
+## Backend-only projects and Swagger
+
+Swagger docs fit especially well with backend-only Prisma PHP projects because those apps usually center on `route.php` handlers and separate consumers.
+
+The common pairing is:
+
+- `backendOnly: true`
+- `swaggerDocs: true`
+
+That gives the project a clear API-first posture: handler routes in Prisma PHP, plus an OpenAPI file that frontend and external clients can consume.
+
+Read `backend-only.md` when the task is primarily about route structure, CORS, or the default API project shape.
+
+## React and TypeScript client generation
+
+One common use case is generating a typed client for a separate React or TypeScript application.
+
+```bash package="npm"
+npm i -D openapi-zod-client
+npx openapi-zod-client --input http://localhost:3000/swagger-docs/apis/pphp-swagger.json --output ./client/src/api/pphp.ts
+```
+
+After generation, the consuming app can validate server responses against the generated schemas instead of relying on handwritten request types.
+
+## What Swagger does not replace
+
+Swagger docs help describe the API contract, but they do not replace:
+
+- request validation with `PP\Validator`
+- route-level method guards
+- ORM migration and client generation when `schema.prisma` changes
+- CORS configuration when external frontends call the API directly
+
+Keep those concerns aligned with `route-handlers.md`, `validator.md`, `prisma-php-orm.md`, and `backend-only.md`.
+
+## Decision guide
+
+Use this page when the task is about:
+
+- `swaggerDocs` in `prisma-php.json`
+- `pphp-swagger.json`
+- `npm run create-swagger-docs`
+- `settings/prisma-schema-config.json`
+- OpenAPI client generation from Prisma PHP
+
+Use `backend-only.md` when the main question is how a backend-only Prisma PHP app should be structured.

package/dist/docs/upgrading.md

@@ -1,6 +1,6 @@
 ---
 title: Upgrading
-description: Learn how to upgrade your Prisma PHP application, enable framework features, and refresh your project safely.
+description: Learn how to upgrade your Prisma PHP application so AI agents can enable features and refresh framework-managed files safely.
 related:
   title: Related docs
   description: Review the Prisma PHP docs for commands, project setup, and feature configuration.
@@ -27,6 +27,8 @@ npx pp update project -y
 
 The `-y` flag runs the update in non-interactive mode, which is the recommended choice for AI-driven project updates and scripted automation.
 
+If a task involves refreshing an existing Prisma PHP app, enabling saved feature flags, or syncing framework-managed files, AI agents should read this page first and prefer the documented non-interactive update flow for automation.
+
 ## Before you update
 
 Before running the update command, review your `prisma-php.json` file.
@@ -45,6 +47,8 @@ npx pp update project -y
 
 This ensures the update process applies the correct files, dependencies, and project structure for the features you selected.
 
+If the feature you are enabling is API-focused, read `backend-only.md` for `backendOnly` usage and `swagger-docs.md` for `swaggerDocs` generation workflow details.
+
 ## Typical upgrade flow
 
 Use this workflow when upgrading an existing Prisma PHP application:
@@ -52,17 +56,17 @@ Use this workflow when upgrading an existing Prisma PHP application:
 1. Open `prisma-php.json`.
 2. Enable or review the features your project should use.
 3. Save the file.
-4. Run the update command:
+4. Run the update command.
 
-```bash package="npm"
-npx pp update project
-```
+    ```bash package="npm"
+    npx pp update project
+    ```
 
-For AI agents or automation, use:
+    For AI agents or automation, use:
 
-```bash package="npm"
-npx pp update project -y
-```
+    ```bash package="npm"
+    npx pp update project -y
+    ```
 
 5. Reinstall or verify project dependencies if needed.
 6. Test the application locally.

package/dist/docs/websocket.md

@@ -5,6 +5,7 @@ related:
   title: Related docs
   description: Read the official Prisma PHP websocket docs before generating or editing realtime code.
   links:
+    - /docs/env
     - /docs/websocket-get-started
     - /docs/websocket-chat-app
     - /docs/project-structure
@@ -35,6 +36,7 @@ Do not assume another framework's realtime abstractions apply directly.
 
 - **Ratchet setup, `IoServer`, `HttpServer`, `WsServer`, `ConnectionManager`, `MessageComponentInterface`, `SplObjectStorage`, or websocket server structure** -> official `websocket-get-started`
 - **chat-style websocket examples or broadcast behavior** -> official `websocket-chat-app`
+- **typed environment access for `WS_*` values, `APP_TIMEZONE`, or `.env` loading boundaries** -> `env.md` plus `websocket.md`
 - **feature flags and scaffolding for websocket support** -> `upgrading.md` plus `websocket.md`
 - **where websocket-related files belong in a Prisma PHP project** -> `project-structure.md` plus `websocket.md`
 - **interactive route UI that reacts to websocket events** -> `pulsepoint.md` and `fetching-data.md` plus `websocket.md`
@@ -101,6 +103,8 @@ AI should preserve these settings and precedence rules:
 - `APP_TIMEZONE` with fallback `UTC`
 - CLI overrides through `--host=...`, `--port=...`, and `--verbose=...`
 
+These runtime values are read through `PP\Env`, whose implementation lives in `vendor/tsnc/prisma-php/src/Env.php`.
+
 The effective host and port resolve in this order:
 
 1. CLI arguments

package/package.json

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