App

The one App for this request, built and booted on the first call.

Converts an absolute filesystem path to an app-relative URI.

The page index behind find(), opened on first use.

The file manager: uploads, metadata, public mirrors and image variants.

The git history of `pages/`: commits, revisions and sync.

A named key-value cache in `data/cache/`.

A Mailer for the named transport in config `mail`.

Enabled addons as alias => root path, in config-declaration order.

The slug of the site page that mounts an addon: the first page, by path, whose view is exactly `@alias`.

Whether an addon is served at /@alias from its own pages/ instead of being mounted on a site page.

An addon's own setting, namespaced under its `addons.{id}` config entry - the only place addon settings live.

An enabled addon's handle, to emit its own `@alias/event`s from code that has no page.

The root an `@alias` names - `phlat` the core, any other an enabled addon - or null.

All view refs a page can take - the site's own views, then the core's as `@phlat/name`.

All user role names available - site roles/ merged with phlat's built-ins (admin, guest).

The view a ref names; every page of a view shares one, so a long list doesn't read the same _index.json once per page.

The folder a ref names under {kind}/: a bare `name` only in $root (the root that owns the file the ref was written in), an `@alias/name` in that alias's root - either one taking the site's override at site/{kind}/@alias/name first. '' when there is none.

$ref as the site names it: a bare name written in an addon's or the core's file becomes `@alias/name`; a site name or an `@` ref stays as it is.

The root that owns $path, against which a bare ref written in it resolves: a site override (site/{kind}/@alias/...) stands in for that alias's own file, so it is owned by that alias's root.

The global field definition $ref names, as seen from $root (see locate()), with its `extends` chain applied and every sub-field it declares resolved inline.

$def is a fieldDefs() tuple (type, label, options, render), empty for a key no template declares, whose value is wrapped by its shape alone; $context is where the field lives (path, uuid, page, view, url).

Path of a fieldtype's edit or preview template, or null; a missing preview falls back to FieldType::preview().

A fieldtype's own optional _index.json (its `search` defaults). $type is named as the site names it, like every type a FieldValue carries.

A file's declared metadata fields: files/_index.json merged with files/{type}/_index.json, whether or not any page field references them.

The shared FieldType a site-named type ref names; an empty $type is inferred from the shape of $value, so undeclared data is still safely wrapped.

The class governing the {base}/ folder a site-named ref locates (see locate()): requires {name}.php if present and returns its bound subclass, else $baseClass.

Pages across the whole site matching a query: `$app->find('view=article,sort=-created,limit=4')`.

Signed in with `admin.access`, or the CLI: sees unpublished and gated pages and autosaves. isLoggedIn() first so an anonymous visitor never starts a session.

The folder that holds every user, as a record.

The page at $uri, or the current request's page when $uri is null.

A page() that also finds a source page's virtual child: when $uri is not a stored page, its direct parent is asked through child() if that page's view says `"children": {"source": true}`.

Returns all users sorted by username, through the registry like every other enumeration.

The collection stored under a field name, shared for the request.

Every collection that exists, by field name: a database in data/collections.

Every SQLite database the site keeps, as [name => path]: those under data/storage by their path there, and each collection's as collections/{field}.db.

The user with this username, or null.

The Latte engine, with PhlatPage's tags, filters and template loader.

Render a template (or just one of its named {block}s) and send the response.

Renders a template wrapped in fragment.latte : full shell on direct navigation, bare partial on an HTMX request.

Render the current (or given) page and send the response.

HTMX requests get HX-Redirect: a plain Location would be followed by the XHR and swapped into the boosted target.

HX-Location for HTMX requests (no full reload); a direct request gets a real redirect.

HX-Refresh for HTMX requests; a direct request redirects to its own URL for a fresh load.

Sets HX-Trigger on the response the route sends next; does not exit.

Handles the current request: resolves the page, runs its router and sends the response.

A GET/HEAD from an anonymous visitor with no option cookie, outside debug: a logged-in response can carry drafts and flash messages, and a cached debug page replays a stale X-Clockwork-Id.

Registers a shared service under $name; a second bind of the same name throws.

The service bound under $name, or null.

Runs $fn under the named lock (re-entrant, single host); a wait past $timeout seconds throws a 503.

Listens for an event: `$app->on('page.save:after', fn(Page $page) => ...)`.

Registers an observer notified after every hook listener runs, with (event, source, duration in ms).

Core's emit: site code and addons use `$page->emit()` or `$app->addon()->emit()`, so they can't spell a core or another addon's event.

Emit app.shutdown exactly once per request.