redweb 0.16.2 → 0.16.4

package/docs/CLIENT_DEVELOPMENT.md

@@ -1,16 +1,16 @@
 # Developing Redweb with redweb-client
 
 The Live HTML implementation is maintained in published `redweb-client/live-html`
-starting with client 0.2.0. Redweb 0.15.0 requires client `^0.3.0`;
+starting with client 0.2.0. Redweb 0.15.0 requires client `^0.3.0`;
 normal application installation retrieves it automatically. The linking workflow
 below is optional for contributors editing both repositories.
 Redweb serves that module and emits only its import and `mountLivePage()` call.
-DOM reconciliation, reactive updates, delegated actions, form feedback and page
-disposal belong to the client. The root `redweb-client` entry remains socket-only.
-
-Socket-bound TSX command bindings and terminal-response filtering use the published
-client 0.3.0 runtime. No link is needed for applications using Redweb 0.15.0.
-See [socket pages](SOCKET_PAGES.md).
+DOM reconciliation, reactive updates, delegated actions, form feedback and page
+disposal belong to the client. The root `redweb-client` entry remains socket-only.
+
+Socket-bound TSX command bindings and terminal-response filtering use the published
+client 0.3.0 runtime. No link is needed for applications using Redweb 0.15.0.
+See [socket pages](SOCKET_PAGES.md).
 
 ## Link the sibling repositories
 
@@ -111,7 +111,7 @@ For example, from Redweb in PowerShell (use a fresh output directory):
 npm --prefix ../redweb-client run build
 New-Item -ItemType Directory -Path coverage/client-candidate
 npm pack ../redweb-client --pack-destination coverage/client-candidate
-$env:REDWEB_CLIENT_CANDIDATE = (Resolve-Path coverage/client-candidate/redweb-client-0.3.0.tgz).Path
+$env:REDWEB_CLIENT_CANDIDATE = (Resolve-Path coverage/client-candidate/redweb-client-0.3.0.tgz).Path
 npm run verify:live-html:package
 Remove-Item Env:REDWEB_CLIENT_CANDIDATE
 ```
@@ -147,7 +147,7 @@ bundles with the source-tested local build and run the same browser checks.
 A candidate pass is not a registry release pass. `npm run verify:package:tools` includes the fingerprint/containment
 unit regressions; its scoped coverage is not coverage of every browser driver.
 
-Historically, published `redweb-client@0.2.0` supplied both required entry points; version 0.1.0
+Historically, published `redweb-client@0.2.0` supplied both required entry points; version 0.1.0
 does not. The 0.2.0 archive's runtime bundles match the previously source-tested
 build, and the clean registry-installed package gate passes without an override.
 The developer link can remain in place because registry checks own independent

package/docs/CONNECTED_CLIENTS_VERIFICATION.md

@@ -1,65 +1,65 @@
-# Connected-client implementation verification
-
-Date: 2026-09-02. Runtime commit: `e001a58`, branch `codex/connected-clients`.
-This is an unreleased development feature, not the published Redweb 0.15.0 package.
-No client source changes or client publication are required; tests use published
-redweb-client 0.3.0.
-
-## Scope
-
-`connectedClients` composes the existing RoomRegistry, bounded authorization,
-projection work, typed socket handlers and private page ownership. It introduces
-no second membership registry. The tutorial consumes it on the companion site's
-`codex/tutorial-connected-clients` branch.
-
-## Passed gates
-
-- `npm run pretest`: generated examples, protocol types, development documentation
-  and all three TypeScript consumer configurations.
-- 368 unit/integration tests in 25 suites: socket servers/routes, connected clients,
-  room access, multiplayer policies/state, protocol/contracts, socket pages,
-  distribution, inspection, page access and the existing HTML test directory.
-- Coverage: 100% statements, branches, functions and lines in **ConnectedClients.js,
-  RoomRegistry.js, RouteRuntime.js and SocketRoute.js**. Report:
-  `coverage/connected-client-rooms`. This is an affected-module claim, not a claim
-  that every module in the repository was measured by this command.
-- `npm run verify:live-html:package`: actual tarball installed in isolation;
-  counter, chat, reconnect/disconnect, cards, components, JSX, dashboard login,
-  generated starters, rendering and development-refresh browser checks passed.
-  Browser: headed Google Chrome 152.0.7977.64. Existing bundled HTML-runtime and
-  refresh coverage gates also reached 100% in their declared scopes.
-- Production dependency audit: zero reported vulnerabilities.
-
-Packed runtime SHA-256 (before adding this evidence document):
-`818bfeb32683089b883bd88f2cef8ac444a8611365a9fe121b4fe2d6b597e540`.
-Package verification report:
-`coverage/packed-browser/8a79c650-cf59-460b-b024-ad791406147f`.
-The archive retains the development checkout's 0.15.0 manifest version; it is
-**not** the npm release bearing that version and must not be published over it.
-
-## Real-network regressions
-
-Independent tabs receive separate private pages; presence counts unique identities
-and reacts to the last tab disconnecting. Tests also cover capacity before domain
-commit, rejected-join membership rollback, room isolation, authorization revoked
-during validation/projection, stale successful and failed projections, failing
-recipients, page-only groups, raw clients and overlapping commands.
-
-Senior critic findings were fixed and regression-tested:
-
-1. A stale authorization/projection failure cannot disconnect a newer valid view.
-2. Raw command completion is independent of superseded state projections.
-3. Raw rejection adapters are bounded and cancel when the connection closes.
-
-No soak or long fixed-observation-time tests were run. Test timeouts are failure
-deadlines. Application callbacks still must validate before mutating domain state;
-membership rollback is not an arbitrary application/database transaction.
-
-## Release boundary
-
-The implementation above was tested as unreleased. Release preparation now targets
-**0.16.0**, with matching package/lock metadata and a generated immutable release
-catalogue. This preparation does not publish the package or change runtime code.
-After publication, update the site's dependency pins, lockfiles and catalogue;
-remove development-preview notices and retest the archive against registry packages
-before manual deployment. Immutable published documentation snapshots are unchanged.
+# Connected-client implementation verification
+
+Date: 2026-09-02. Runtime commit: `e001a58`, branch `codex/connected-clients`.
+This is an unreleased development feature, not the published Redweb 0.15.0 package.
+No client source changes or client publication are required; tests use published
+redweb-client 0.3.0.
+
+## Scope
+
+`connectedClients` composes the existing RoomRegistry, bounded authorization,
+projection work, typed socket handlers and private page ownership. It introduces
+no second membership registry. The tutorial consumes it on the companion site's
+`codex/tutorial-connected-clients` branch.
+
+## Passed gates
+
+- `npm run pretest`: generated examples, protocol types, development documentation
+  and all three TypeScript consumer configurations.
+- 368 unit/integration tests in 25 suites: socket servers/routes, connected clients,
+  room access, multiplayer policies/state, protocol/contracts, socket pages,
+  distribution, inspection, page access and the existing HTML test directory.
+- Coverage: 100% statements, branches, functions and lines in **ConnectedClients.js,
+  RoomRegistry.js, RouteRuntime.js and SocketRoute.js**. Report:
+  `coverage/connected-client-rooms`. This is an affected-module claim, not a claim
+  that every module in the repository was measured by this command.
+- `npm run verify:live-html:package`: actual tarball installed in isolation;
+  counter, chat, reconnect/disconnect, cards, components, JSX, dashboard login,
+  generated starters, rendering and development-refresh browser checks passed.
+  Browser: headed Google Chrome 152.0.7977.64. Existing bundled HTML-runtime and
+  refresh coverage gates also reached 100% in their declared scopes.
+- Production dependency audit: zero reported vulnerabilities.
+
+Packed runtime SHA-256 (before adding this evidence document):
+`818bfeb32683089b883bd88f2cef8ac444a8611365a9fe121b4fe2d6b597e540`.
+Package verification report:
+`coverage/packed-browser/8a79c650-cf59-460b-b024-ad791406147f`.
+The archive retains the development checkout's 0.15.0 manifest version; it is
+**not** the npm release bearing that version and must not be published over it.
+
+## Real-network regressions
+
+Independent tabs receive separate private pages; presence counts unique identities
+and reacts to the last tab disconnecting. Tests also cover capacity before domain
+commit, rejected-join membership rollback, room isolation, authorization revoked
+during validation/projection, stale successful and failed projections, failing
+recipients, page-only groups, raw clients and overlapping commands.
+
+Senior critic findings were fixed and regression-tested:
+
+1. A stale authorization/projection failure cannot disconnect a newer valid view.
+2. Raw command completion is independent of superseded state projections.
+3. Raw rejection adapters are bounded and cancel when the connection closes.
+
+No soak or long fixed-observation-time tests were run. Test timeouts are failure
+deadlines. Application callbacks still must validate before mutating domain state;
+membership rollback is not an arbitrary application/database transaction.
+
+## Release boundary
+
+The implementation above was tested as unreleased. Release preparation now targets
+**0.16.0**, with matching package/lock metadata and a generated immutable release
+catalogue. This preparation does not publish the package or change runtime code.
+After publication, update the site's dependency pins, lockfiles and catalogue;
+remove development-preview notices and retest the archive against registry packages
+before manual deployment. Immutable published documentation snapshots are unchanged.

package/docs/DEVELOPMENT.md

@@ -1,81 +1,81 @@
-# Development refresh and inspection
-
-This API is available in `redweb@0.16.2`. Use documentation matching the installed package before enabling it.
-
-## Browser refresh
-
-The generated `npm run dev` command enables browser refresh while rebuilding and restarting your application. No extra application code is needed. For an existing Live HTML application, enable it explicitly:
-
-```ts
-const app = defineApp({ pages: [CounterPage], development: { refresh: true } });
-app.run();
-```
-
-Alternatively, set `REDWEB_DEV_REFRESH=1` only for your development process. Explicit `development: { refresh: false }` overrides that environment flag. Setting `NODE_ENV=development` alone enables neither refresh nor inspection. Both features are refused at construction under `NODE_ENV=production`; changing environment variables after construction is not a mode switch. `npm start` does not set the refresh flag. Keep it out of production environments.
-
-On direct loopback access, the initial HTML embeds the serving process's revision. The browser polls the same listener sequentially, with a two-second request deadline and one second between completed attempts. Only a valid, different revision triggers refresh. Failed builds, unavailable listeners, malformed responses and redirects do not cause reload loops. A restart before the external script finishes loading is still detected against the revision embedded in the original document.
-
-Clean pages reload automatically after a new revision appears. The edit guard conservatively keeps the current document if it observes input/change events, sees differing form defaults when it starts, encounters an editable element with focus, or finds contenteditable content. A native, keyboard-operable notice offers **Reload and discard drafts**. Ordinary untouched selects are compared against the browser's actual reset defaults, not simply their `selected` attributes. Once confirmation is required, resetting or submitting a form does not silently permit automatic reload.
-
-This is not autosave or a precise unsaved-change detector. False positives are intentional; custom editors or programmatic changes without input/change events may not be detected. The helper does not persist or transmit form contents, write browser storage, replay actions, or restore files/passwords after reload. It keeps the current DOM while waiting for your decision. Manual navigation, browser termination, and confirmed reload can discard drafts.
-
-The notice uses a shadow root so ordinary reactive root updates preserve it and the application controls' existing focus/draft behavior. Its script, stylesheet and revision fetch are same-origin external resources; your CSP must allow those resources. Navigation away stops polling. History restoration resumes it, including back-forward-cache restoration where the browser supports and chooses it.
-
-### Connections and server state
-
-Keeping the old document does **not** make its old page token/session valid on a replacement process. Existing reconnect rules still apply to a temporary connection outage on the same server. A process restart resets in-memory page/chat/counter state; persistent application data remains the application's responsibility. Actions in flight may have uncertain outcomes. Refresh does not retry them, guarantee completion or migrate state. Reload creates a new page session.
-
-### Access and resource boundaries
-
-Refresh is for direct `localhost`, literal `127.x.x.x`, or `[::1]` URLs at the listener's actual port. It verifies the actual loopback peer, Host, any supplied Origin, and Fetch Metadata. It does not trust forwarding headers or support custom hostnames, tunnels or reverse-proxy origins. Rejected requests receive no refresh bootstrap; this restriction does not make the rest of your application private. An application can still bind publicly unless you separately set `bind`.
-
-Enabled refresh reserves `/__redweb/development`, `/__redweb/development.js` and `/__redweb/development.css`. They reveal only a boot revision, fixed client code and styling—not inspection snapshots, application state or compiler output. Responses and decorated HTML are no-store. There is no extra listener or server timer. Served `live: false` pages support refresh without a live socket client; `exportStatic()` output remains script-free and never enables it from the environment. Raw `SocketServer`/`SecureSocketServer` do not accept the HTML `refresh` option.
-
-The injected `rw-dev-refresh` element and `__redweb_dev` ID belong to this helper; do not reuse them in application markup. The repository's `npm run verify:development:browser` gate runs actual generated watchers and Chromium against real HTTP/WebSocket listeners, including edited-document confirmation and failed-build recovery. CI runs it separately from the production browser regression gate.
-
-## Inspection
-
-Enable inspection explicitly when starting a development application:
-
-```ts
-const app = defineApp({
-    pages: [CounterPage],
-    development: { inspect: true },
-});
-
-// Await startup before reading live metadata (ESM entry point).
-await app.run();
-console.dir(app.inspect(), { depth: null });
-```
-
-`SocketServer` and `SecureSocketServer` accept the same option and expose the same `inspect()` method. Without the option, `inspect()` returns `null`. Merely setting `NODE_ENV=development` does not enable inspection. Explicitly enabling it while `NODE_ENV=production` throws before routes or listeners are attached. The environment check occurs at construction; changing environment variables afterward is not a runtime mode switch.
-
-Inspection itself is an in-process, read-only API. It does not create an HTTP/debugging route, listener, browser script, background timer, or automatic logger; browser refresh is a separate option and never exposes inspection data. Do not expose inspection results through an application endpoint in production. Your existing `redweb doctor --json` command remains the source/configuration checker; it does not inspect a running process.
-
-## What the snapshot means
-
-`inspect()` returns immutable, versioned JSON-compatible data:
-
-- `pages.registrations`: configured route paths, live/shared flags, class names, decorated action/state names, and descriptions of currently available owned components. It never constructs a page to discover its members. Standard decorator metadata and component fields may not exist before first construction, so `instanceMetadata: "unobserved"` means an incomplete inventory, not “this page has no actions.” Static or expired pages can have no current instance even when class metadata was observed previously.
-- `pages.connections`: separate counts for pending HTTP-created sessions, connected sockets, closing transports or disconnect hooks in progress (`detaching`), and disconnected sessions retained for reconnect. An attached socket that is no longer open is not yet a retained/reconnectable session. Shared pages appear once in each registration's instance list even when several visitors use them.
-- `pages.sessions`: bounded per-render descriptions using inspector-local numeric IDs. These are not page tokens, credentials, principal IDs or socket IDs. A reconnect to the same retained page session keeps its renderer ID.
-- `sockets.routes`: registered socket paths and handler names, registered connection counts, draining status, and room/session counts. Runtime-added routes and handlers appear on the next read. `pendingUpgrades` counts currently tracked handshakes. Room names, session identifiers and stored data are omitted. A registered raw connection is not a promise that every transport is currently open; lifecycle cleanup may be in progress.
-- `history`: the latest reactive state invalidations and flush attempts. A state invalidation lists the member/component name and affected render-owner IDs. An empty affected-owner list means no current reactive owner read that member. Several invalidations can be batched into one flush.
-
-Page-session and underlying socket counts describe overlapping resources—do not add them together as independent visitors. Counts remain available independently of truncated detail lists. A description failure yields `available: false` for its section without reflecting exception text.
-
-## Render history is not delivery tracing
-
-`flush-started` reports whether the attempt is a reconnect/attach snapshot and which owners were dirty. `flush-completed`, `flush-superseded`, and `flush-failed` describe that attempt, with elapsed milliseconds. Completion can mean unchanged HTML, no transport write, or a transport write that the peer did not receive. It is **not** a delivery acknowledgement. Supersession means a disconnect, disposal or generation change made the attempt obsolete.
-
-History does not attribute an invalidation to a particular action: timers, services and application code can also assign state. It does not retain action arguments, state values, HTML, request headers, cookies, query parameters, identities, socket contexts, or exception messages. It does not serialize getters or call action/render/lifecycle callbacks to produce a snapshot. Application accessors replacing declaration fields are skipped; standard action metadata excludes replaced accessor methods. This is not a security sandbox against hostile JavaScript Proxies or global monkey-patching.
-
-The history observes the reactive TSX renderer's connected update path, starting with socket attachment. Initial HTTP rendering, static output, changes with no connected reactive renderer, and nonreactive template `redweb:state` transport messages are not traced. `pages.sessions[].reactive` distinguishes those sessions. Existing runtime failure diagnostics and application tests remain necessary.
-
-## Bounds and overhead
-
-History retains at most 256 entries per inspected server and only primitive metadata; each event's owner list retains at most 100 names. Current page/socket description lists retain at most 100 items each and share a separate 1,000-item budget per snapshot. Lists include `total` and `truncated`. Labels are limited to 128 UTF-16 code units. Names and route paths are application-defined declarations: do not put secrets in them. The local history's `total` is its sequence counter, including any contained recording failure; retained entries may therefore have gaps.
-
-Inspection selects a specialized renderer once for the enabled server. Ordinary reactive invalidation, flush, and socket-message paths have no inspector callbacks or added inspection branches. Disabled servers retain the original renderer class. The only ordinary rendering seam is renderer-class selection when a page session is constructed. Enabled inspection deliberately does extra metadata work and allocations; its timings are diagnostic observations, not production benchmarks.
-
-Shutdown removes page sessions and connections through the existing lifecycle. The bounded primitive history remains readable while you retain the server object; it does not keep disposed page instances alive. The inspector's local ID table uses weak keys.
+# Development refresh and inspection
+
+This API is available in `redweb@0.16.4`. Use documentation matching the installed package before enabling it.
+
+## Browser refresh
+
+The generated `npm run dev` command enables browser refresh while rebuilding and restarting your application. No extra application code is needed. For an existing Live HTML application, enable it explicitly:
+
+```ts
+const app = defineApp({ pages: [CounterPage], development: { refresh: true } });
+app.run();
+```
+
+Alternatively, set `REDWEB_DEV_REFRESH=1` only for your development process. Explicit `development: { refresh: false }` overrides that environment flag. Setting `NODE_ENV=development` alone enables neither refresh nor inspection. Both features are refused at construction under `NODE_ENV=production`; changing environment variables after construction is not a mode switch. `npm start` does not set the refresh flag. Keep it out of production environments.
+
+On direct loopback access, the initial HTML embeds the serving process's revision. The browser polls the same listener sequentially, with a two-second request deadline and one second between completed attempts. Only a valid, different revision triggers refresh. Failed builds, unavailable listeners, malformed responses and redirects do not cause reload loops. A restart before the external script finishes loading is still detected against the revision embedded in the original document.
+
+Clean pages reload automatically after a new revision appears. The edit guard conservatively keeps the current document if it observes input/change events, sees differing form defaults when it starts, encounters an editable element with focus, or finds contenteditable content. A native, keyboard-operable notice offers **Reload and discard drafts**. Ordinary untouched selects are compared against the browser's actual reset defaults, not simply their `selected` attributes. Once confirmation is required, resetting or submitting a form does not silently permit automatic reload.
+
+This is not autosave or a precise unsaved-change detector. False positives are intentional; custom editors or programmatic changes without input/change events may not be detected. The helper does not persist or transmit form contents, write browser storage, replay actions, or restore files/passwords after reload. It keeps the current DOM while waiting for your decision. Manual navigation, browser termination, and confirmed reload can discard drafts.
+
+The notice uses a shadow root so ordinary reactive root updates preserve it and the application controls' existing focus/draft behavior. Its script, stylesheet and revision fetch are same-origin external resources; your CSP must allow those resources. Navigation away stops polling. History restoration resumes it, including back-forward-cache restoration where the browser supports and chooses it.
+
+### Connections and server state
+
+Keeping the old document does **not** make its old page token/session valid on a replacement process. Existing reconnect rules still apply to a temporary connection outage on the same server. A process restart resets in-memory page/chat/counter state; persistent application data remains the application's responsibility. Actions in flight may have uncertain outcomes. Refresh does not retry them, guarantee completion or migrate state. Reload creates a new page session.
+
+### Access and resource boundaries
+
+Refresh is for direct `localhost`, literal `127.x.x.x`, or `[::1]` URLs at the listener's actual port. It verifies the actual loopback peer, Host, any supplied Origin, and Fetch Metadata. It does not trust forwarding headers or support custom hostnames, tunnels or reverse-proxy origins. Rejected requests receive no refresh bootstrap; this restriction does not make the rest of your application private. An application can still bind publicly unless you separately set `bind`.
+
+Enabled refresh reserves `/__redweb/development`, `/__redweb/development.js` and `/__redweb/development.css`. They reveal only a boot revision, fixed client code and styling—not inspection snapshots, application state or compiler output. Responses and decorated HTML are no-store. There is no extra listener or server timer. Served `live: false` pages support refresh without a live socket client; `exportStatic()` output remains script-free and never enables it from the environment. Raw `SocketServer`/`SecureSocketServer` do not accept the HTML `refresh` option.
+
+The injected `rw-dev-refresh` element and `__redweb_dev` ID belong to this helper; do not reuse them in application markup. The repository's `npm run verify:development:browser` gate runs actual generated watchers and Chromium against real HTTP/WebSocket listeners, including edited-document confirmation and failed-build recovery. CI runs it separately from the production browser regression gate.
+
+## Inspection
+
+Enable inspection explicitly when starting a development application:
+
+```ts
+const app = defineApp({
+    pages: [CounterPage],
+    development: { inspect: true },
+});
+
+// Await startup before reading live metadata (ESM entry point).
+await app.run();
+console.dir(app.inspect(), { depth: null });
+```
+
+`SocketServer` and `SecureSocketServer` accept the same option and expose the same `inspect()` method. Without the option, `inspect()` returns `null`. Merely setting `NODE_ENV=development` does not enable inspection. Explicitly enabling it while `NODE_ENV=production` throws before routes or listeners are attached. The environment check occurs at construction; changing environment variables afterward is not a runtime mode switch.
+
+Inspection itself is an in-process, read-only API. It does not create an HTTP/debugging route, listener, browser script, background timer, or automatic logger; browser refresh is a separate option and never exposes inspection data. Do not expose inspection results through an application endpoint in production. Your existing `redweb doctor --json` command remains the source/configuration checker; it does not inspect a running process.
+
+## What the snapshot means
+
+`inspect()` returns immutable, versioned JSON-compatible data:
+
+- `pages.registrations`: configured route paths, live/shared flags, class names, decorated action/state names, and descriptions of currently available owned components. It never constructs a page to discover its members. Standard decorator metadata and component fields may not exist before first construction, so `instanceMetadata: "unobserved"` means an incomplete inventory, not “this page has no actions.” Static or expired pages can have no current instance even when class metadata was observed previously.
+- `pages.connections`: separate counts for pending HTTP-created sessions, connected sockets, closing transports or disconnect hooks in progress (`detaching`), and disconnected sessions retained for reconnect. An attached socket that is no longer open is not yet a retained/reconnectable session. Shared pages appear once in each registration's instance list even when several visitors use them.
+- `pages.sessions`: bounded per-render descriptions using inspector-local numeric IDs. These are not page tokens, credentials, principal IDs or socket IDs. A reconnect to the same retained page session keeps its renderer ID.
+- `sockets.routes`: registered socket paths and handler names, registered connection counts, draining status, and room/session counts. Runtime-added routes and handlers appear on the next read. `pendingUpgrades` counts currently tracked handshakes. Room names, session identifiers and stored data are omitted. A registered raw connection is not a promise that every transport is currently open; lifecycle cleanup may be in progress.
+- `history`: the latest reactive state invalidations and flush attempts. A state invalidation lists the member/component name and affected render-owner IDs. An empty affected-owner list means no current reactive owner read that member. Several invalidations can be batched into one flush.
+
+Page-session and underlying socket counts describe overlapping resources—do not add them together as independent visitors. Counts remain available independently of truncated detail lists. A description failure yields `available: false` for its section without reflecting exception text.
+
+## Render history is not delivery tracing
+
+`flush-started` reports whether the attempt is a reconnect/attach snapshot and which owners were dirty. `flush-completed`, `flush-superseded`, and `flush-failed` describe that attempt, with elapsed milliseconds. Completion can mean unchanged HTML, no transport write, or a transport write that the peer did not receive. It is **not** a delivery acknowledgement. Supersession means a disconnect, disposal or generation change made the attempt obsolete.
+
+History does not attribute an invalidation to a particular action: timers, services and application code can also assign state. It does not retain action arguments, state values, HTML, request headers, cookies, query parameters, identities, socket contexts, or exception messages. It does not serialize getters or call action/render/lifecycle callbacks to produce a snapshot. Application accessors replacing declaration fields are skipped; standard action metadata excludes replaced accessor methods. This is not a security sandbox against hostile JavaScript Proxies or global monkey-patching.
+
+The history observes the reactive TSX renderer's connected update path, starting with socket attachment. Initial HTTP rendering, static output, changes with no connected reactive renderer, and nonreactive template `redweb:state` transport messages are not traced. `pages.sessions[].reactive` distinguishes those sessions. Existing runtime failure diagnostics and application tests remain necessary.
+
+## Bounds and overhead
+
+History retains at most 256 entries per inspected server and only primitive metadata; each event's owner list retains at most 100 names. Current page/socket description lists retain at most 100 items each and share a separate 1,000-item budget per snapshot. Lists include `total` and `truncated`. Labels are limited to 128 UTF-16 code units. Names and route paths are application-defined declarations: do not put secrets in them. The local history's `total` is its sequence counter, including any contained recording failure; retained entries may therefore have gaps.
+
+Inspection selects a specialized renderer once for the enabled server. Ordinary reactive invalidation, flush, and socket-message paths have no inspector callbacks or added inspection branches. Disabled servers retain the original renderer class. The only ordinary rendering seam is renderer-class selection when a page session is constructed. Enabled inspection deliberately does extra metadata work and allocations; its timings are diagnostic observations, not production benchmarks.
+
+Shutdown removes page sessions and connections through the existing lifecycle. The bounded primitive history remains readable while you retain the server object; it does not keep disposed page instances alive. The inspector's local ID table uses weak keys.

package/docs/GETTING_STARTED.md

@@ -1,78 +1,78 @@
-# Build a site and its realtime backend together
-
-Redweb renders TypeScript/TSX on Node.js and connects server-owned state and actions to the browser through WebSockets. Use it for live dashboards, chat, collaboration, documentation sites, and socket services. You can use HTTP or WebSockets independently.
-
-It is not React, a browser component framework, a database, an identity provider, or a managed multiplayer platform. Do not use React hooks or import `react/jsx-runtime`. An edge-only host without Node listeners cannot run a live Redweb server; exported static pages need no Node runtime.
-
-## Start a project
-
-Create the same neutral foundation whether you are following a tutorial or starting your own application:
-
-```sh
-npx --yes redweb@0.16.2 init my-app
-cd my-app
-npm install --save-exact redweb@0.16.2
-npm test
-npm run dev
-```
-
-Add capability dependencies without importing example-domain code:
-
-```sh
-npx --yes redweb@0.16.2 init my-game --with auth,multiplayer
-```
-
-The default includes its real tests. `--bare` omits only the test directory, test scripts, and test-only coverage dependency; it retains the runnable application, CSS, compiler configuration, build scripts, and development watcher.
-
-## Explore complete recipes
-
-Choose one of these complete applications:
-
-- [Realtime counter](../recipes/realtime/README.md): the smallest live website, sharing server-owned state between visitors.
-- [Chatroom](../recipes/chat/README.md): reusable stateful components, messages, and live presence.
-- [Site](../recipes/site/README.md): non-live pages with a shared layout and stylesheet.
-- [Socket service](../recipes/socket/README.md): a typed `/match` route with separate join/move/resume handlers.
-- [HTTP and WebSockets](../recipes/http-ws/README.md): one listener, an HTTP health endpoint and a raw `/chat` route with an explicit cleanup owner.
-- [Private dashboard](../recipes/dashboard/README.md): persistent SQLite cards, account sessions and private live updates (Node 22.13+).
-
-Named templates are finished examples rather than the default project structure. Each generated recipe page contains its exact files, commands, limitations, and real HTTP/WebSocket acceptance tests. Follow that recipe's version-specific setup instructions rather than mixing an unreleased example with a published npm version.
-
-Requirements: Node.js satisfying the package's `engines` field and npm. Use a supported Node.js release in production. TypeScript and the development watcher are installed by the starter. No React, frontend bundler or broker is required. Only the dashboard starter uses a database; its native SQLite requirement is recipe-local.
-
-The installation floor is not a security-support promise for old Node releases. See [runtime compatibility, release verification and provenance](RELEASE_TRUST.md) before choosing a production version.
-
-## One development loop
-
-After initialization and installation, `npm test` compiles the project, copies assets, and runs the shipped network tests. `npm run dev` watches source/configuration files, rebuilds, and restarts. Served HTML pages on direct localhost access refresh when the replacement server is ready; detected edits instead produce a confirmation notice that keeps the current document until explicit reload. This is not autosave or browser hot-module replacement; in-memory state and old socket sessions reset on restart. See [development refresh and its guarantees](DEVELOPMENT.md#browser-refresh).
-
-Use `.tsx` for markup and extend `redweb/tsconfig.json`. Colocate CSS with the decorated page/component or declare an explicit asset root. `npm run build` prepares `dist/`; `npm start` runs that compiled application.
-
-When setup fails, run `npx --no-install redweb doctor --json` from the application directory. Fix reported errors and examine unresolved warnings, then rerun the build and real tests. Doctor does not execute application code or prove application correctness. See [diagnostics and boundaries](CLI.md).
-
-## The mental model
-
-- A page is a decorated class. Its `render()` returns server-side TSX.
-- State is server-owned data. An ordinary TSX expression reading `@state()` updates automatically when that property is assigned. Replace arrays/objects rather than mutating them in place.
-- Ordinary live pages expose decorated actions. Socket-bound pages expose their registered typed handlers through TSX controls. Validate and authorize every untrusted input; hiding a button is not access control.
-- A class component owns reusable state/actions and has its own update boundary. Function components are convenient presentation helpers.
-- Pages are connection-scoped by default. `shared: true` intentionally shares one page instance; do not put private visitor data there.
-- Shared in-memory state survives visitors and reloads, not server restarts. Durable cards/history require application-owned persistence. Multiple processes do not automatically share memory.
-- Socket URLs select routes; message `type` selects a handler. Do not add a second `message.action` dispatcher inside a catch-all handler.
-
-See [rendering and lifecycle](LIVE_HTML.md) and [shared socket contracts](SOCKET_CONTRACTS.md) for exact semantics.
-
-For private raw socket subscriptions, see [room authorization and shared request identity](ROOM_AUTHORIZATION.md). Keep authentication, subscription permission, and application-specific write permission explicit.
-
-## Deploy deliberately
-
-Build first. Deploy `dist/`, the package manifest, and the lockfile, then install runtime dependencies with `npm ci --omit=dev`. The starters are tested with `src/` unavailable after compilation. Configure HTTPS/WSS and a proxy that supports WebSocket upgrades when using a reverse proxy.
-
-These deployment commands require a verified release pair. `redweb@0.16.2` installs published `redweb-client@0.3.0` automatically through its dependency. Future unreleased Redweb changes require their matching tested tarball until a release containing them is published. The `npm link` workflow is local development only: a clean production install does not preserve that link.
-
-Before public access, add authentication, authorization, trusted-origin policy, input/rate limits, application persistence where needed, and bounded shutdown. Treat reconnect/session tokens as credentials. Do not promise exactly-once delivery or durable sessions from an in-memory starter. See [operations](MULTIPLAYER_OPERATIONS.md) and [guarantees and limits](PRODUCTION_READINESS.md).
-
-## Evidence and compatibility
-
-Complete recipe files are executable applications; shorter API snippets explain individual methods and may require surrounding application code. Type-check and test a complete recipe before adapting it. The package verifier runs the documented recipe files against an extracted tarball and actual listeners, not mocks.
-
-Coverage reports refer to instrumented library code. They do not prove exhaustive browser behavior, application security, all generated-example branches, or production capacity. Historical [verification evidence](VERIFICATION_EVIDENCE.md) applies only to its recorded revision/environment; consult the [current release checklist](AGENT_READY_ACCEPTANCE.md) for remaining work.
+# Build a site and its realtime backend together
+
+Redweb renders TypeScript/TSX on Node.js and connects server-owned state and actions to the browser through WebSockets. Use it for live dashboards, chat, collaboration, documentation sites, and socket services. You can use HTTP or WebSockets independently.
+
+It is not React, a browser component framework, a database, an identity provider, or a managed multiplayer platform. Do not use React hooks or import `react/jsx-runtime`. An edge-only host without Node listeners cannot run a live Redweb server; exported static pages need no Node runtime.
+
+## Start a project
+
+Create the same neutral foundation whether you are following a tutorial or starting your own application:
+
+```sh
+npx --yes redweb@0.16.4 init my-app
+cd my-app
+npm install --save-exact redweb@0.16.4
+npm test
+npm run dev
+```
+
+Add capability dependencies without importing example-domain code:
+
+```sh
+npx --yes redweb@0.16.4 init my-game --with auth,multiplayer
+```
+
+The default includes its real tests. `--bare` omits only the test directory, test scripts, and test-only coverage dependency; it retains the runnable application, CSS, compiler configuration, build scripts, and development watcher.
+
+## Explore complete recipes
+
+Choose one of these complete applications:
+
+- [Realtime counter](../recipes/realtime/README.md): the smallest live website, sharing server-owned state between visitors.
+- [Chatroom](../recipes/chat/README.md): reusable stateful components, messages, and live presence.
+- [Site](../recipes/site/README.md): non-live pages with a shared layout and stylesheet.
+- [Socket service](../recipes/socket/README.md): a typed `/match` route with separate join/move/resume handlers.
+- [HTTP and WebSockets](../recipes/http-ws/README.md): one listener, an HTTP health endpoint and a raw `/chat` route with an explicit cleanup owner.
+- [Private dashboard](../recipes/dashboard/README.md): persistent SQLite cards, account sessions and private live updates (Node 22.13+).
+
+Named templates are finished examples rather than the default project structure. Each generated recipe page contains its exact files, commands, limitations, and real HTTP/WebSocket acceptance tests. Follow that recipe's version-specific setup instructions rather than mixing an unreleased example with a published npm version.
+
+Requirements: Node.js satisfying the package's `engines` field and npm. Use a supported Node.js release in production. TypeScript and the development watcher are installed by the starter. No React, frontend bundler or broker is required. Only the dashboard starter uses a database; its native SQLite requirement is recipe-local.
+
+The installation floor is not a security-support promise for old Node releases. See [runtime compatibility, release verification and provenance](RELEASE_TRUST.md) before choosing a production version.
+
+## One development loop
+
+After initialization and installation, `npm test` compiles the project, copies assets, and runs the shipped network tests. `npm run dev` watches source/configuration files, rebuilds, and restarts. Served HTML pages on direct localhost access refresh when the replacement server is ready; detected edits instead produce a confirmation notice that keeps the current document until explicit reload. This is not autosave or browser hot-module replacement; in-memory state and old socket sessions reset on restart. See [development refresh and its guarantees](DEVELOPMENT.md#browser-refresh).
+
+Use `.tsx` for markup and extend `redweb/tsconfig.json`. Colocate CSS with the decorated page/component or declare an explicit asset root. `npm run build` prepares `dist/`; `npm start` runs that compiled application.
+
+When setup fails, run `npx --no-install redweb doctor --json` from the application directory. Fix reported errors and examine unresolved warnings, then rerun the build and real tests. Doctor does not execute application code or prove application correctness. See [diagnostics and boundaries](CLI.md).
+
+## The mental model
+
+- A page is a decorated class. Its `render()` returns server-side TSX.
+- State is server-owned data. An ordinary TSX expression reading `@state()` updates automatically when that property is assigned. Replace arrays/objects rather than mutating them in place.
+- Ordinary live pages expose decorated actions. Socket-bound pages expose their registered typed handlers through TSX controls. Validate and authorize every untrusted input; hiding a button is not access control.
+- A class component owns reusable state/actions and has its own update boundary. Function components are convenient presentation helpers.
+- Pages are connection-scoped by default. `shared: true` intentionally shares one page instance; do not put private visitor data there.
+- Shared in-memory state survives visitors and reloads, not server restarts. Durable cards/history require application-owned persistence. Multiple processes do not automatically share memory.
+- Socket URLs select routes; message `type` selects a handler. Do not add a second `message.action` dispatcher inside a catch-all handler.
+
+See [rendering and lifecycle](LIVE_HTML.md) and [shared socket contracts](SOCKET_CONTRACTS.md) for exact semantics.
+
+For private raw socket subscriptions, see [room authorization and shared request identity](ROOM_AUTHORIZATION.md). Keep authentication, subscription permission, and application-specific write permission explicit.
+
+## Deploy deliberately
+
+Build first. Deploy `dist/`, the package manifest, and the lockfile, then install runtime dependencies with `npm ci --omit=dev`. The starters are tested with `src/` unavailable after compilation. Configure HTTPS/WSS and a proxy that supports WebSocket upgrades when using a reverse proxy.
+
+These deployment commands require a verified release pair. `redweb@0.16.4` installs published `redweb-client@0.3.1` automatically through its dependency. Future unreleased Redweb changes require their matching tested tarball until a release containing them is published. The `npm link` workflow is local development only: a clean production install does not preserve that link.
+
+Before public access, add authentication, authorization, trusted-origin policy, input/rate limits, application persistence where needed, and bounded shutdown. Treat reconnect/session tokens as credentials. Do not promise exactly-once delivery or durable sessions from an in-memory starter. See [operations](MULTIPLAYER_OPERATIONS.md) and [guarantees and limits](PRODUCTION_READINESS.md).
+
+## Evidence and compatibility
+
+Complete recipe files are executable applications; shorter API snippets explain individual methods and may require surrounding application code. Type-check and test a complete recipe before adapting it. The package verifier runs the documented recipe files against an extracted tarball and actual listeners, not mocks.
+
+Coverage reports refer to instrumented library code. They do not prove exhaustive browser behavior, application security, all generated-example branches, or production capacity. Historical [verification evidence](VERIFICATION_EVIDENCE.md) applies only to its recorded revision/environment; consult the [current release checklist](AGENT_READY_ACCEPTANCE.md) for remaining work.