@plitzi/sdk-server 0.38.9 → 0.38.10

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # @plitzi/sdk-server
 
+## 0.38.10
+
+### Patch Changes
+
+- 200da2f: - **`focus-on-field-box`** (`@plitzi/sdk-authoring`): a warning for a `focus` or `focus-visible` state on a text
+  field's or a select's `input` slot. That slot is the box the field is drawn in, a `<div>` that never takes focus, so
+  the rule was never seen and a keyboard user tabbing to the field found no ring. The fix it names: `'focus-within'` on
+  the same class, or the state on the `field` slot.
+  - **`modalContainer` says how it is laid out** (`@plitzi/sdk-elements`): its description now names its slots and how
+    they sit — the dim layer and the dialog side by side, not one inside the other; the dialog centred by `top`/`left`
+    50% and a `translate`. A space styled the dim layer as a flex container to place the dialog, which moved nothing.
+  - **A field shows where the keyboard is** (`@plitzi/plitzi-sdk`, `@plitzi/sdk-elements`): a text field's or a select's
+    box is ringed (`2px solid currentColor`) while the field inside has keyboard focus, and a textarea while it has. No
+    text field or select showed any focus at all: the box had `outline: none`, and the field inherited it. One class of
+    specificity, so whatever a space writes about the outline wins; never in the builder's canvas, where the selection is
+    the ring. The field no longer inherits the box's outline — the box draws it.
+  - **The dim layer of a modal and a dialog is `rgb(0 0 0 / 50%)`** (`@plitzi/plitzi-sdk`, `@plitzi/sdk-elements`), not
+    black at `opacity: 0.5`: the default looks the same, and a colour a space gives the layer is drawn as it is — it was
+    halved. A space that set its own colour sees it darker: the one it wrote.
+  - **`required-message-unused`** (`@plitzi/sdk-authoring`): a warning for a `requiredMessage` on a field nothing requires —
+    since 0.38.9 a field is optional unless `required: true`, so the message is never shown and an empty answer is sent.
+    The formControl's description, the cheat sheet and the forms recipe say the default.
+  - **A page's title can say its record** (`@plitzi/sdk-shared`, `@plitzi/sdk-server`, `@plitzi/sdk-elements`,
+    `@plitzi/sdk-authoring`): `seoTitle` and `seoDescription` may be templates over the page's `runtime: 'server'`
+    providers (its layouts' too) and `navigation` — `'{{ apiContainer_post.title }} — Blog'`. The server evaluates them
+    as it writes the head, from the answers it already has; the browser evaluates the same over `rsc.data`, so the tab
+    follows a navigation from record to record. One that reads anything else — a browser provider, `state` — is refused
+    (`page-template`): it was written into the head as it was, braces included. A declaration's `serverTemplates` names
+    the attributes the page server evaluates against a context of its own (a page's title and description, a provider's
+    `notFound`): the element runtime leaves them as written — interpolated where the page renders, a `|default(…)`
+    resolved to its fallback before the head could read the providers — and the authoring lint reads the same list.
+  - **A page says when its address shows nothing** (`@plitzi/sdk-server`, `@plitzi/sdk-authoring`): `notFound` on the
+    page, one expression over the same answers its title reads — `"{{ not (apiContainer_feed.topics|find('slug',
+navigation.routeParams.slug)) }}"` — sends it with status 404, rendered as written. A provider's own `notFound` reads
+    only its answer, and one in a layout is every page's: a record read from the layout had no way to say it was not
+    there, and the page answered 200.
+  - **The Export keeps the flows of a plugin hosted by `custom`** (`@plitzi/sdk-authoring`): `specFromSpace` judged such
+    an element by `custom`'s own triggers and callbacks, and dropped a flow on the component's event (`onChange` on an
+    editor) as one "a custom never fires" — the space read back was not the space written.
+  - **`page check` reads every word on the page, in the colour the browser paints it** (`@plitzi/sdk-authoring`): what a
+    plugin draws inside an element of the space is measured too, named by the element and a selector; the measure is
+    WCAG's contrast (under 2:1 is unreadable), not "nearly the same colour"; and a colour the browser answers as
+    `oklch()`, `oklab()` or `color(srgb …)` — every token and every `color-mix()` — is read as that, where it was read as
+    `rgb()` numbers and came out near black. A plugin's dark-on-dark status line passed as "nothing wrong".
+  - **`verify` checks every theme the space can be painted in** (`@plitzi/cli`): light and dark, unless the space says
+    light only — "48 checks at 1440 and 390 px, light and dark". A page unreadable in the dark theme passed in the light
+    one; a failure names the theme it was found in.
+  - **`plitzi upgrade` says where fields became optional** (`@plitzi/cli`): for a project last upgraded before 0.38.9,
+    each `formControl(…)` with no `required`, at its file and line — said, never written. And a `.gitkeep` is asked for
+    only in a folder with nothing else in it: `upgrade` wrote one beside code, and `doctor` called it missing once deleted
+    as AGENTS.md asks ("nothing unused") — the three now say the same.
+  - **`devMode` and `devReload` are the project's** (`@plitzi/sdk-server`): `src/config/serverOptions.ts` may set them,
+    over `NODE_ENV`, which they still follow when left out. A deployment started without `NODE_ENV` (a container's `CMD`)
+    says `devMode: false`, and a public action answers with its output alone.
+  - **`page shot --from load`** (`@plitzi/cli`): `--frames` start as soon as the page's HTML is in, not once it settles —
+    an entrance that plays while the page loads had ended before the first picture.
+  - **`heavy-animation` says where each animation is** (`@plitzi/sdk-authoring`): the class and its variant, state or
+    slot — or the `customCss` rule — and writes the fix against that selector. It said "in `customCss`" for an animation
+    declared on a class's variant, and offered `.glow`, a class no space has.
+  - **`page shot --steps`** (`@plitzi/cli`): an interaction played step by step — `click`, `type`, `press`, `wait`,
+    `wait-for`, `shot [label]`, `frames <n> [ms]`, separated by `;` or written in a file (`@file`) — each picture labelled
+    with its step and the time since the first, and said when nothing changed since the one before. A queue filling, a
+    restart, an opening frame by frame took a Playwright script of the project's own. Targets take Playwright's selectors
+    too (`text=Saved`).
+  - **A space's task may take a `number` param** (`@plitzi/sdk-server`): saved functions refused it ("a type the builder
+    cannot draw") while a project's server ran it, so code that worked self-hosted failed on the platform — and the
+    builder draws one, a callback's. A step's params now arrive as the types the task declares, on every server: a
+    `number` written as text is the number, a `boolean` written `'true'` is `true`, as the browser reads a callback's.
+  - **`page shot --as <username>`** (`@plitzi/cli`): signs in first, as `page check --as` does, the password from
+    `PLITZI_CHECK_PASSWORD` in `.env`. A page for signed-in visitors was pictured as the sign-in page it sent the browser
+    to, without a word; `page shot` now says when the page sent it elsewhere, and that the picture is of that page.
+  - **A capture is of the page at rest** (`@plitzi/sdk-mcp`): the local screenshot client takes every picture with
+    `prefers-reduced-motion: reduce`, as the browser pod now does — the declared motion and a space's own keyframes that
+    honour the query are shown finished. A splash still covering its page, or an arrival caught halfway, was what a
+    thumbnail or a `plitzi_look` showed of a page that animates as it loads.
+  - **The server renders in the visitor's theme, not only the class** (`@plitzi/sdk-shared`): `ThemeProvider` set the
+    starting theme from a layout effect, which never runs on a server, so a page was drawn from the theme store's own
+    start — `{{ theme.resolved }}` was `light` under a `<html class="dark">`, and whatever named the scheme (a picture's
+    address, a `when` rule) was swapped for the other one as the page hydrated. The theme a host supplies (the cookie) is
+    now the server's snapshot of the store, and the hydration's; the shared store is never written on the server.
+- Updated dependencies [200da2f]
+  - @plitzi/plitzi-sdk@0.38.10
+  - @plitzi/sdk-shared@0.38.10
+
 ## 0.38.9
 
 ### Patch Changes

package/dist/modules/actions/runtime/runAction.js

@@ -148,8 +148,22 @@ var stepOf = (node, { status, phase, startTime, endTime, error, logs = [] }) =>
 /** What one step may log: enough to debug with, bounded so a loop that logs cannot fill a run's record. */
 var MAX_LOG_LINES = 100;
 var MAX_LOG_LINE = 1e3;
+/**
+* A value written as text, read as the type its task declares: a `number` param written `5` — or bound to text that says
+* it — arrives as 5, a `boolean` one written `'true'` as `true`, an empty number as nothing (so the default applies). The
+* browser reads a callback's params the same way (`coerceDeclaredParams`): a task's author never writes `Number(…)`.
+*/
+var asDeclared = (type, value) => {
+	if (typeof value !== "string") return value;
+	if (type === "number") {
+		const parsed = Number(value.trim());
+		return value.trim() === "" ? void 0 : Number.isFinite(parsed) ? parsed : value;
+	}
+	return type === "boolean" && (value === "true" || value === "false") ? value === "true" : value;
+};
 var withDefaults = (task, params) => Object.entries(task.params).reduce((acum, [key, param]) => {
-	if (acum[key] === void 0 || acum[key] === "") acum[key] = param.defaultValue ?? "";
+	const value = asDeclared(typeof param.type === "function" ? param.type(acum) : param.type, acum[key]);
+	acum[key] = value === void 0 || value === "" ? param.defaultValue ?? "" : value;
 	return acum;
 }, { ...params });
 var runNode = async (node, scope, registry, buildContext) => {

package/dist/modules/functions/manifest.js

@@ -57,6 +57,11 @@ var paramOf = (value) => {
 			type: value.type,
 			...typeof defaultValue === "string" || typeof defaultValue === "number" ? { defaultValue } : {}
 		};
+		case "number": return {
+			...base,
+			type: "number",
+			...typeof defaultValue === "number" ? { defaultValue } : {}
+		};
 		case "codemirror-text":
 		case "codemirror-json": return {
 			...base,
@@ -84,7 +89,7 @@ var paramOf = (value) => {
 				...typeof defaultValue === "string" ? { defaultValue } : {}
 			};
 		}
-		default: return `has a type the builder cannot draw ("${String(value.type)}"): text, textarea, codemirror-text, codemirror-json, boolean, elements or select`;
+		default: return `has a type the builder cannot draw ("${String(value.type)}"): text, number, textarea, codemirror-text, codemirror-json, boolean, elements or select`;
 	}
 };
 /** What each asked limit is, in words a problem is written in. */

package/dist/modules/project/serveProject.d.ts

@@ -3,11 +3,14 @@ import { ServerConfig } from '../../core/createServer';
 import { ConnectorManifest } from '../connectors';
 import { ActionEntry, SSRServer } from '@plitzi/sdk-shared';
 /** What `serveProject` sets itself, from the project's layout — so never the project's options'. */
-type SetByProject = 'port' | 'devMode' | 'devReload' | 'health' | 'adapters' | 'plugins' | 'publicDir' | 'dataDir' | 'functions' | 'action';
+type SetByProject = 'port' | 'health' | 'adapters' | 'plugins' | 'publicDir' | 'dataDir' | 'functions' | 'action';
 /**
  * What a project's server does besides serving its space — its `src/config/serverOptions.ts`: what `createServer`
  * takes, but for what `serveProject` wires from the project's layout, and an action's `lookups`, which are the
- * project's `src/actions/`. `logLevel` and `logger` are the project's to change; `action.kv` too.
+ * project's `src/actions/`. `logLevel` and `logger` are the project's to change; `action.kv` too. So are `devMode` and
+ * `devReload`, which follow `NODE_ENV` when left out — on unless it is `production`. A deployment started without it (a
+ * container's `CMD`, a process manager with no environment) says `devMode: false` here, and a public action answers
+ * with its output alone, never the trace of every step.
  */
 export type ProjectServerOptions = Partial<Omit<ServerConfig, SetByProject>> & {
     action?: Omit<NonNullable<ServerConfig['action']>, 'lookups'>;

package/dist/modules/project/serveProject.js

@@ -142,8 +142,8 @@ var startProject = async (options) => {
 		logger: consoleLogger,
 		...serverOptions,
 		port,
-		devMode: developing,
-		devReload: developing,
+		devMode: serverOptions.devMode ?? developing,
+		devReload: serverOptions.devReload ?? serverOptions.devMode ?? developing,
 		health: { name },
 		adapters,
 		plugins: plugins.sources,

package/dist/modules/ssr/prepareRender.js

@@ -20,7 +20,7 @@ import { sdkAssetVersion } from "../../core/sdkAssets.js";
 import { buildServerInfo } from "../../helpers/buildServerInfo.js";
 import { resolveDebugMode } from "../../helpers/resolveDebugMode.js";
 import { flagUserFromSSR, flagValues, resolveFlags } from "@plitzi/sdk-shared/flags";
-import { collectServerElements, notFoundProvider } from "@plitzi/sdk-shared/schema/serverElements";
+import { collectServerElements, notFoundProvider, pageNotFound, pageServerContext } from "@plitzi/sdk-shared/schema/serverElements";
 import { debugCookieName } from "@plitzi/sdk-shared/devTools";
 import { themeFromCookies } from "@plitzi/sdk-shared/theme";
 import { paintedKeys, paintedStateFor } from "@plitzi/sdk-shared/state/paintedState";
@@ -84,11 +84,13 @@ var prepareRender = async (req, config, spaceId, environment, revision, pluginMa
 		loadOfflineData,
 		flagOverrides
 	})) : rscPath ? { serverData: {} } : void 0;
-	const pageSeo = resolvePageSeo(schema, pageMatch?.pageId);
-	const notFound = pageMatch !== void 0 && rscData?.serverData !== void 0 ? notFoundProvider(serverElements, rscData.serverData, {
-		routeParams: pageMatch.routeParams,
+	const navigation = {
+		routeParams: pageMatch?.routeParams ?? {},
 		queryParams: req.query
-	}) !== void 0 : false;
+	};
+	const pageContext = pageServerContext(serverElements, rscData?.serverData ?? {}, navigation);
+	const pageSeo = resolvePageSeo(schema, pageMatch?.pageId, pageContext);
+	const notFound = pageMatch !== void 0 && rscData?.serverData !== void 0 ? notFoundProvider(serverElements, rscData.serverData, navigation) !== void 0 || pageNotFound(schema?.flat[pageMatch.pageId]?.attributes.notFound, pageContext) : false;
 	const server = buildServerInfo(req, config, {
 		rscPath,
 		rscData,

package/dist/modules/ssr/resolvePageSeo.d.ts

@@ -14,5 +14,8 @@ export type PageSeo = {
  * `seoEnabled: false` returns nothing rather than a default, so the deployment's own title stays in charge of a
  * page that opted out. Blank strings are treated as absent for the same reason — the builder writes one for a
  * field the author cleared, and an empty <title> is worse than a generic one.
+ *
+ * Either may be a template over the page's server providers and the address (`pageServerContext`): a detail page says
+ * the title of the record it shows, in the HTML a crawler reads. One that does not evaluate is nothing, as a blank is.
  */
-export declare const resolvePageSeo: (schema: Schema | undefined, pageId: string | undefined) => PageSeo;
+export declare const resolvePageSeo: (schema: Schema | undefined, pageId: string | undefined, context?: Record<string, unknown>) => PageSeo;

package/dist/modules/ssr/resolvePageSeo.js

@@ -1,3 +1,4 @@
+import { pageSeoText } from "@plitzi/sdk-shared/schema/serverElements";
 //#region src/modules/ssr/resolvePageSeo.ts
 /**
 * The title and description the addressed page declares for itself.
@@ -10,13 +11,16 @@
 * `seoEnabled: false` returns nothing rather than a default, so the deployment's own title stays in charge of a
 * page that opted out. Blank strings are treated as absent for the same reason — the builder writes one for a
 * field the author cleared, and an empty <title> is worse than a generic one.
+*
+* Either may be a template over the page's server providers and the address (`pageServerContext`): a detail page says
+* the title of the record it shows, in the HTML a crawler reads. One that does not evaluate is nothing, as a blank is.
 */
-var resolvePageSeo = (schema, pageId) => {
+var resolvePageSeo = (schema, pageId, context = {}) => {
 	if (!schema || !pageId) return {};
 	const page = schema.flat[pageId];
 	if (!page?.attributes.seoEnabled) return {};
-	const title = page.attributes.seoPageTitle?.trim();
-	const description = page.attributes.seoPageDescription?.trim();
+	const title = pageSeoText(page.attributes.seoPageTitle, context);
+	const description = pageSeoText(page.attributes.seoPageDescription, context);
 	return {
 		...title ? { title } : {},
 		...description ? { description } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.38.9",
+  "version": "0.38.10",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -96,8 +96,8 @@
     "./dist/env.js"
   ],
   "dependencies": {
-    "@plitzi/plitzi-sdk": "0.38.9",
-    "@plitzi/sdk-shared": "0.38.9",
+    "@plitzi/plitzi-sdk": "0.38.10",
+    "@plitzi/sdk-shared": "0.38.10",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
     "jsonwebtoken": "^9.0.3",

package/skills/plitzi-authoring/CHEATSHEET.md

@@ -50,7 +50,7 @@ apiContainer({ id: 'p', query: '/data/x.json', runtime: 'server', children }) //
 apiContainer({ id: 'p', action: 'report', runtime: 'server', children })     // the action's output at p's root: p.rows
                                                // loadingSlot: 'p-skeleton' — a child shown until it answers
 form({ id, managedByInteractions: true, flows, children })
-formControl({ name: 'email', label: 'Email', subType: 'email' })          // select: options: [{ label, value }]
+formControl({ name: 'email', label: 'Email', subType: 'email', required: true })   // optional without required; select: options: [{ label, value }]
 modalContainer({ id, visible: false, title, children })
 component('card', { props: { title }, children: { body: [ … ] } })
 custom({ renderType: 'myPlugin' }); defineElement<Props>(declaration)      // a plugin

package/skills/plitzi-authoring/recipes/filter-a-list.ts

@@ -31,8 +31,6 @@ export const recipe: SpaceSpec = {
             { label: 'Graphics cards', value: 'gpu' }
           ],
           defaultValue: 'all',
-          // A filter always has an answer: the select is not a question that must be filled in.
-          required: false,
           flows: [
             [named('picked', on('onChange')), setState({ key: 'category', type: 'text', value: '{{ picked.value }}' })]
           ]

package/skills/plitzi-authoring/recipes/forms-and-modals.ts

@@ -38,7 +38,8 @@ export const recipe: SpaceSpec = {
             [named('sent', onSubmit()), setState({ key: 'email', type: 'text', value: '{{ sent.values.email }}' })]
           ],
           children: [
-            formControl({ name: 'email', label: 'Email', subType: 'email' }),
+            // Optional unless it says so, as an HTML field is: a sign-up without an address is no sign-up.
+            formControl({ name: 'email', label: 'Email', subType: 'email', required: true }),
             button({ content: 'Sign up', subType: 'submit' })
           ]
         }),

package/skills/plitzi-authoring/reference/authoring-errors.md

@@ -102,7 +102,7 @@ The space is not written until these are fixed.
 | `motion-no-tag` | a `motion` on an element with no tag of its own — nothing to move | the motion on what it wraps, or a `subType` on it |
 | `no-pages` | a space with no pages | `pages: [{ id: 'home', name: 'Home', slug: '', body: [] }]` |
 | `not-found-in-browser` | `notFound` on a provider asked from the browser — its answer arrives after the page was sent with its status | `runtime: 'server'` on the provider, or `visible` on the page's "not found" part instead |
-| `not-found-not-a-template` | `notFound` that is not one `{{ expression }}` against the answer — never `true`, so never a 404 | `notFound: '{{ source.found == false }}'` |
+| `not-found-not-a-template` | `notFound`, a provider's or a page's, that is not one `{{ expression }}` — never `true`, so never a 404 | `notFound: '{{ source.found == false }}'` |
 | `notifications-shape` | `notifications` with a field it does not have, or a value that is not one CSS value | the field it suggests, or one it lists; one CSS value, like 'var(--card)', '12px' or '500' |
 | `outside-ancestor` | an element that reads the state of an element it is not inside | nest it in the element the message names |
 | `page-access-level` | an `accessLevel` that is not one the router reads | one of the values the message lists |
@@ -110,6 +110,7 @@ The space is not written until these are fixed.
 | `page-route-taken` | two pages at one address for the same visitors | another slug — or `accessLevel` `'public'` on one and `'authenticated'` on the other |
 | `page-target-unknown` | a link or `navigate` to a page id that does not exist | an existing page id, or a path with its slash (`'/about'`) |
 | `page-target-url` | a URL, `mailto:` or `tel:` in a link left in page mode | `mode: 'external'` |
+| `page-template` | a template in a page's `seoTitle`, `seoDescription` or `notFound` that reads what is not there when the server answers — anything but the page's `runtime: 'server'` providers and `navigation` — or cannot be read | read the record from a provider with `runtime: 'server'` on the page or its layout — `'{{ apiContainer_post.title }} — Blog'` — or words of its own |
 | `page-without-slug` | a page with no `slug` | `slug: ''` for the home page, its path for any other: `'about'`, `'blog/:slug'` |
 | `part-missing` | a compound element — a carousel, a tab container, a dropdown — without a part it renders through | the part the message names, inside it (`carousel()` writes its own track) |
 | `prop-missing` | an instance without a prop its component requires | `component('card', { props: { name: … } })`, or bind it |
@@ -185,6 +186,7 @@ The space renders, and renders something you probably did not mean. Fix every on
 | `embed-without-title` | an `embed` with no `title` — a frame a screen reader cannot describe | say what it shows in `title` |
 | `flag-rule-empty` | a flag rule with no conditions — skipped, never read as "always" | give it a condition, or set the flag's `value` instead |
 | `flag-unused` | a declared flag nothing gates on and no template reads | gate what it switches (`flag: 'x'`), or remove it once the feature has shipped |
+| `focus-on-field-box` | a `focus` or `focus-visible` state on a text field's or a select's `input` slot — the box the field is drawn in, which never takes focus, so no ring is ever shown | `'focus-within'` on the same class, or the state on the `field` slot |
 | `FORM_SUBMIT_UNMANAGED` | a form the browser would submit itself, reloading the page | `managedByInteractions: true` |
 | `form-control-name-taken` | two controls in one form with one name — one overwrites the other | a name each |
 | `form-control-unnamed` | a control in a form with no `name` — its value never reaches `values` | `formControl({ name: 'email', … })` |
@@ -202,6 +204,7 @@ The space renders, and renders something you probably did not mean. Fix every on
 | `path-not-in-data` | a binding onto a provider whose answer the author could read (`data`), through a path that answer does not have | the path the message lists the keys for — `p.data.plans`, not `p.data.landing.plans` |
 | `plugin-attribute-reserved` | a plugin attribute named as one of the element’s own fields — a factory never hands it to the plugin | rename it in the plugin (`variant` → `kind`) |
 | `provider-without-source` | an `apiContainer` that asks nothing | a `query` (or `action`, `connector`, `resource`) |
+| `required-message-unused` | a `requiredMessage` on a field nothing requires — fields are optional unless `required: true`, so it is never shown and an empty answer is sent | `required: true` on the field, or no message |
 | `route-param-undeclared` | `navigation.routeParams.x` read on a page whose slug has no `:x` — always empty | add `:x` to the slug, or read `navigation.queryParams.x` |
 | `server-data-without-rsc` | a `runtime: 'server'` provider — `connector`, `action` or `query` — in a space that turns server data off (`rsc: { enabled: false }`) | drop `rsc: { enabled: false }`: server data is on unless a space turns it off |
 | `span-holds-block` | a `container` with `subType: 'span'` or `'p'` holding a heading, a paragraph, a list, a form or prose | a `div` (leave `subType` out), or words and inline elements: a `text`, a `link` |

package/skills/plitzi-authoring/reference/layouts.md

@@ -139,8 +139,10 @@ Every page is now its content and nothing else, and every page is guaranteed the
   suggests writing your own (`not-found-page`): say it in the space's words.
 - **A page that exists but finds nothing** — `/products/:slug` for a slug no product has — is sent with 404 too when
   its server provider says so: `notFound: "{{ not (source.data.products|find('slug', navigation.routeParams.slug)) }}"`,
-  one expression against its answer, on a `runtime: 'server'` provider of the page (not of its layout, which every
-  page shares). The page renders as written: show its "not found" part with `visible`.
+  one expression against its answer, on a `runtime: 'server'` provider of the page. When the record comes from a
+  provider of its layout, which every page shares, the page says it: `notFound` on the page reads its server providers
+  by name — `"{{ not (apiContainer_feed.products|find('slug', navigation.routeParams.slug)) }}"`. The page renders as
+  written: show its "not found" part with `visible`.
 
 ## Styles follow the same rule
 

package/skills/plitzi-authoring/reference/structure.md

@@ -93,7 +93,9 @@ pages: [
 
 Adding a page is adding an entry; two entries of one id or slug are refused as any two pages are. For one shape over
 records a visitor browses — a product, a post — a single page with a route param (`slug: 'posts/:postId'`) reading
-the record is the answer instead: one page, as many addresses as records.
+the record is the answer instead: one page, as many addresses as records. Its `seoTitle` can say the record —
+`'{{ apiContainer_post.title }} — Blog'` — read from a provider on the page with `runtime: 'server'`, or from
+`navigation`: the server writes the head with it, so a link preview shows it. Anything else is refused (`page-template`).
 
 ## Names