stylegallery 0.1.4 → 0.1.7

package/design-engineering/state-management/patterns/single-owner.md

@@ -0,0 +1,89 @@
+---
+type: Domain Guide
+title: Single Owner And Controlled Inputs
+description: Keep one authoritative value when several controls edit the same setting.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# Single Owner And Controlled Inputs
+
+## Repository Boundary
+
+Keep one authoritative value when several controls edit the same setting. This pattern belongs to Design Engineering and adds no Layout CSS or shared store implementation.
+
+## Reusable Method
+
+Use when sibling or nested controls must agree immediately. Keep a private disclosure local when no other surface needs its value. Choose the nearest owner that survives every participating control.
+
+### State Model And Ownership
+
+The owner stores `value`; controls receive it and emit an intent. Temporary text composition may stay local, but must have an explicit commit/reset boundary. Owner validation can reject an intent without creating a second accepted value.
+
+### Transitions
+
+| Event and precondition | Next state | Effect or invariant |
+| --- | --- | --- |
+| Control proposes an allowed value | Owner replaces value | All readers observe the same accepted value |
+| Control proposes an invalid value | Unchanged | Return rejection; do not pretend the value committed |
+| Owner resets externally | New owner value | Every controlled reader reflects reset |
+
+### Minimal Executable Example
+
+Run this standalone JavaScript block with Node.js 22 or newer, or run all pattern examples from a repository checkout with `npm run test:state-management`. The assertions exercise the local model, not a browser or backend.
+
+```js
+import assert from "node:assert/strict";
+let value = "compact";
+function propose(next) {
+  if (!["compact", "comfortable"].includes(next)) return false;
+  value = next;
+  return true;
+}
+const toolbar = { read: () => value, change: propose };
+const settings = { read: () => value, change: propose };
+assert.equal(toolbar.change("comfortable"), true);
+assert.equal(settings.read(), "comfortable");
+assert.equal(settings.change("invalid"), false);
+assert.equal(toolbar.read(), "comfortable");
+value = "compact";
+assert.equal(settings.read(), "compact");
+```
+
+### What Breaks If Removed
+
+If each control copies the initial value into its own accepted state, changing the toolbar leaves settings stale. Synchronizing both copies with reciprocal callbacks introduces a second ordering problem.
+
+### Composition And Substitution
+
+Compose with [derived state](derived-state.md) for summaries and [identity reset](identity-reset.md) for account changes. A framework context or store can transport this owner; it does not decide who owns the value.
+
+## Opinionated Guidance
+
+Name the write API as an intent when the owner may reject or normalize it. Distinguish a local editing buffer from the accepted value in component inputs.
+
+## Platform-Specific Guidance
+
+Native controls still need accessible names and correct value semantics. Preserve IME composition when adapting text inputs; do not normalize every keystroke without an input contract.
+
+## Unsupported Absolutes
+
+A shared owner does not require an application-wide store or prove efficient subscriptions.
+
+## Verification Contract
+
+- Edit from either control, then reset from the parent; both readers must agree.
+- Reject an invalid intent and verify the UI exposes the rejection.
+- Remove and recreate one reader; it must receive the current value.
+
+Record actual outcomes separately using the [verification matrix](../verification.md).
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../recipes/index.md).

package/design-engineering/state-management/patterns/submitted-snapshot.md

@@ -0,0 +1,107 @@
+---
+type: Domain Guide
+title: Submitted Snapshot And Save Acknowledgement
+description: Keep later edits dirty when an earlier submitted snapshot finishes saving.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# Submitted Snapshot And Save Acknowledgement
+
+## Repository Boundary
+
+Keep later edits dirty when an earlier submitted snapshot finishes saving. This pattern belongs to Design Engineering and adds no Layout CSS or shared store implementation.
+
+## Reusable Method
+
+Use whenever editing can continue during a save. If the UI locks editing, document that constraint but still correlate completions to the active operation.
+
+### State Model And Ownership
+
+The form owns draft and baseline; an active operation owns a copied snapshot and request ID. This string example allows one write in flight and assumes the server returns the same accepted value. Real adapters must define normalization and revision conflicts.
+
+### Transitions
+
+| Event and precondition | Next state | Effect or invariant |
+| --- | --- | --- |
+| Submit while idle | Active snapshot and request ID | Persist exactly that snapshot |
+| Edit while saving | New draft, same active operation | Do not mutate submitted data |
+| Matching success | Baseline becomes acknowledged snapshot | Dirty compares current draft to new baseline |
+| Matching failure | Active cleared, error retained | Keep current draft |
+| Stale completion | Unchanged | Never commit another operation's result |
+
+### Minimal Executable Example
+
+Run this standalone JavaScript block with Node.js 22 or newer, or run all pattern examples from a repository checkout with `npm run test:state-management`. The assertions exercise the local model, not a browser or backend.
+
+```js
+import assert from "node:assert/strict";
+let draft = "A", baseline = "Original", active = null, serial = 0, error = null;
+function submit() {
+  if (active) return null;
+  error = null;
+  active = { id: ++serial, snapshot: draft };
+  return { ...active };
+}
+function settle(id, ok, message = "Save failed") {
+  if (active?.id !== id) return;
+  if (ok) baseline = active.snapshot;
+  else error = message;
+  active = null;
+}
+const first = submit();
+draft = "B";
+assert.equal(submit(), null);
+settle(first.id, true);
+assert.equal(baseline, "A");
+assert.equal(draft, "B");
+assert.equal(draft !== baseline, true);
+const second = submit();
+settle(first.id, true);
+assert.equal(active.id, second.id);
+settle(second.id, false);
+assert.equal(draft, "B");
+assert.equal(error, "Save failed");
+const retry = submit();
+assert.equal(error, null);
+settle(retry.id, true);
+assert.equal(draft, baseline);
+```
+
+### What Breaks If Removed
+
+If success assigns the current draft to baseline, saving A then editing B marks unsent B as saved. If the request holds a mutable object reference, editing B can also mutate the supposed A snapshot.
+
+### Composition And Substitution
+
+Combines [draft/baseline](draft-and-baseline.md) and [single flight](single-flight.md). This is the reusable core of the existing [save contract](../../component-contract.md#worked-contract-save-action).
+
+## Opinionated Guidance
+
+For objects, capture an appropriate immutable copy. Adopt a server-normalized result into the draft only if no later edit would be overwritten; otherwise reconcile visibly.
+
+## Platform-Specific Guidance
+
+Client request abort does not roll back a remote write. On transport uncertainty, reconcile with the server before claiming a retry is safe.
+
+## Unsupported Absolutes
+
+Client request IDs are not server idempotency keys or optimistic concurrency revisions.
+
+## Verification Contract
+
+- Submit A, edit B, acknowledge A; baseline A and dirty B must remain.
+- Fail then retry; inputs survive and the new operation has its own identity.
+- Deliver the old completion during a new save; it must not clear the new request.
+
+Record actual outcomes separately using the [verification matrix](../verification.md).
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../recipes/index.md).

package/design-engineering/state-management/patterns/unsaved-navigation.md

@@ -0,0 +1,100 @@
+---
+type: Domain Guide
+title: Unsaved Changes And Navigation
+description: Make leaving an edited screen an explicit decision without losing the current draft.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# Unsaved Changes And Navigation
+
+## Repository Boundary
+
+Make leaving an edited screen an explicit decision without losing the current draft. This pattern belongs to Design Engineering and adds no Layout CSS or shared store implementation.
+
+## Reusable Method
+
+Use when route changes can discard meaningful user work. Do not interrupt navigation for harmless transient selection or derived values.
+
+### State Model And Ownership
+
+The form owns dirty; the router integration owns a pending destination and guard status. The confirmation owns a decision, not a second copy of form data. Save-and-leave must recheck dirty after acknowledgement.
+
+### Transitions
+
+| Event and precondition | Next state | Effect or invariant |
+| --- | --- | --- |
+| Navigate while clean | Destination committed | Leave normally |
+| Navigate while dirty | Decision pending | Retain current screen and destination |
+| Cancel decision | Pending cleared | Stay and return focus |
+| Discard decision | Destination committed | Explicitly abandon draft |
+| Save fails or later edits remain | Stay | Preserve draft and offer recovery |
+
+### Minimal Executable Example
+
+Run this standalone JavaScript block with Node.js 22 or newer, or run all pattern examples from a repository checkout with `npm run test:state-management`. The assertions exercise the local model, not a browser or backend.
+
+```js
+import assert from "node:assert/strict";
+let dirty = true, pending = null, location = "editor";
+function navigate(to) {
+  if (dirty) pending = to;
+  else location = to;
+}
+function decide(choice) {
+  if (choice === "cancel") pending = null;
+  if (choice === "discard" && pending !== null) {
+    dirty = false;
+    location = pending;
+    pending = null;
+  }
+}
+navigate("list");
+decide("cancel");
+assert.equal(location, "editor");
+assert.equal(dirty, true);
+navigate("list");
+decide("discard");
+assert.equal(location, "list");
+assert.equal(pending, null);
+```
+
+### What Breaks If Removed
+
+If route mutation happens before the guard, the form may already be destroyed when Cancel runs. If any save success releases navigation, later unsaved edits can still be lost.
+
+### Composition And Substitution
+
+Use [submitted snapshot](submitted-snapshot.md) for Save-and-leave and [URL state](url-state.md) for committed destinations. A pending destination is not a committed URL.
+
+## Opinionated Guidance
+
+Declare what a second navigation attempt does while confirmation is open: this model replaces the destination with the latest attempt. Verify the displayed decision matches it.
+
+## Platform-Specific Guidance
+
+In-app routing and document unload have different capabilities. Browser unload prompts are constrained and unreliable as a sole recovery strategy; use optional draft persistence when needed. Verify keyboard focus entry/return for the confirmation.
+
+Platform reference: [MDN API documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event), checked 2026-09-16. This supports the named browser boundary; the model and product policy remain local synthesis.
+
+## Unsupported Absolutes
+
+An in-memory guard cannot guarantee preservation after process termination or device failure.
+
+## Verification Contract
+
+- Cancel a guarded route change; values and focus return to the editor.
+- Attempt another destination while the decision is open; apply the declared policy.
+- Save A, edit B, then acknowledge A; do not leave with dirty B.
+
+Record actual outcomes separately using the [verification matrix](../verification.md).
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../recipes/index.md).

package/design-engineering/state-management/patterns/url-state.md

@@ -0,0 +1,96 @@
+---
+type: Domain Guide
+title: URL State And History
+description: Keep shareable screen state consistent across links, refresh, and browser history.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# URL State And History
+
+## Repository Boundary
+
+Keep shareable screen state consistent across links, refresh, and browser history. This pattern belongs to Design Engineering and adds no Layout CSS or shared store implementation.
+
+## Reusable Method
+
+Use for committed search, filters, pagination, and selected IDs that should be shareable. Keep secrets, sensitive drafts, and hover state out of URLs.
+
+### State Model And Ownership
+
+The route owns committed query state; a text field may own an uncommitted buffer. Parsing supplies validated defaults. User commits write URL parameters; history navigation reads them without writing a new entry.
+
+### Transitions
+
+| Event and precondition | Next state | Effect or invariant |
+| --- | --- | --- |
+| Open or history traversal | Parsed route state | Render without another push |
+| Commit filter | New route; page reset | Push a meaningful navigation entry |
+| Normalize invalid input | Validated defaults | Replace only under declared canonicalization policy |
+
+### Minimal Executable Example
+
+Run this standalone JavaScript block with Node.js 22 or newer, or run all pattern examples from a repository checkout with `npm run test:state-management`. The assertions exercise the local model, not a browser or backend.
+
+```js
+import assert from "node:assert/strict";
+function readRoute(href) {
+  const u = new URL(href);
+  const raw = u.searchParams.get("page") ?? "1";
+  const n = /^\d+$/.test(raw) ? Number(raw) : NaN;
+  return { q: u.searchParams.get("q") ?? "", page: Number.isSafeInteger(n) && n > 0 ? n : 1 };
+}
+function commitQuery(href, q) {
+  const u = new URL(href);
+  if (q) u.searchParams.set("q", q); else u.searchParams.delete("q");
+  u.searchParams.delete("page");
+  return u.href;
+}
+const original = "https://example.test/items?q=A&page=3&view=grid#results";
+const changed = commitQuery(original, "B & C");
+assert.deepEqual(readRoute(changed), { q: "B & C", page: 1 });
+assert.equal(new URL(changed).searchParams.get("view"), "grid");
+assert.equal(new URL(changed).hash, "#results");
+assert.deepEqual(readRoute(original), { q: "A", page: 3 }); // Back reads old URL.
+assert.equal(readRoute("https://example.test/?page=Infinity").page, 1);
+```
+
+### What Breaks If Removed
+
+Writing a new history entry in response to a history event creates a loop. Keeping the old page after changing the filter can display an apparently empty collection. Rebuilding the URL from scratch can drop unrelated parameters or fragments.
+
+### Composition And Substitution
+
+Use [latest request wins](latest-request-wins.md) for data reads and [unsaved navigation](unsaved-navigation.md) before committing a destructive route change. Reset local input from history only under the declared editing policy.
+
+## Opinionated Guidance
+
+Decide push versus replace from meaningful navigation steps. Do not make every keystroke a Back-button stop by accident.
+
+## Platform-Specific Guidance
+
+Browser adapters must handle popstate and their router's navigation API; the pure URL functions do not install listeners. SSR and client must use the same parser and defaults.
+
+Platform reference: [MDN API documentation](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState), checked 2026-09-16. This supports the named browser boundary; the model and product policy remain local synthesis.
+
+## Unsupported Absolutes
+
+A URL is not a safe persistence medium for private data, nor does parsing prove authorization to access a selected entity.
+
+## Verification Contract
+
+- Commit query B from page 3; reset to page 1 and preserve unrelated parameters.
+- Back, Forward, reload, and paste a deep link; displayed controls agree with the URL.
+- Reject malformed page values; avoid URL-to-state-to-URL loops.
+
+Record actual outcomes separately using the [verification matrix](../verification.md).
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../recipes/index.md).

package/design-engineering/state-management/patterns/versioned-restore.md

@@ -0,0 +1,95 @@
+---
+type: Domain Guide
+title: Versioned And Scoped State Restore
+description: Restore persisted preferences only when their schema and ownership scope are valid.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# Versioned And Scoped State Restore
+
+## Repository Boundary
+
+Restore persisted preferences only when their schema and ownership scope are valid. This pattern belongs to Design Engineering and adds no Layout CSS or shared store implementation.
+
+## Reusable Method
+
+Use for intentional persistence of non-sensitive preferences or drafts with a declared retention policy. Keep state in memory if cross-session recovery has no user value.
+
+### State Model And Ownership
+
+The persistence adapter owns a versioned envelope and scope key. Decoding validates shape and allowed values before applying. This example rejects old versions; migration is a separate explicit function. Current user edits outrank a late restore.
+
+### Transitions
+
+| Event and precondition | Next state | Effect or invariant |
+| --- | --- | --- |
+| Read valid current-scope record | Restored values | Apply only before later local edits |
+| Malformed, old, or wrong-scope record | Defaults | Preserve current usable state |
+| Write fails | In-memory state retained | Expose persistence failure where recovery matters |
+| Logout or scope change | New scoped state | Do not reuse another account's envelope |
+
+### Minimal Executable Example
+
+Run this standalone JavaScript block with Node.js 22 or newer, or run all pattern examples from a repository checkout with `npm run test:state-management`. The assertions exercise the local model, not a browser or backend.
+
+```js
+import assert from "node:assert/strict";
+function restore(raw, scope) {
+  try {
+    const record = JSON.parse(raw);
+    if (!record || record.version !== 1 || record.scope !== scope) return "compact";
+    return ["compact", "comfortable"].includes(record.density) ? record.density : "compact";
+  } catch { return "compact"; }
+}
+const raw = JSON.stringify({ version: 1, scope: "account:A", density: "comfortable" });
+assert.equal(restore(raw, "account:A"), "comfortable");
+assert.equal(restore(raw, "account:B"), "compact");
+assert.equal(restore("{broken", "account:A"), "compact");
+assert.equal(restore(JSON.stringify({ version: 0 }), "account:A"), "compact");
+let editRevision = 0, density = "compact";
+const restoreStartedAt = editRevision;
+density = "comfortable"; editRevision++;
+if (editRevision === restoreStartedAt) density = restore(null, "account:A");
+assert.equal(density, "comfortable");
+```
+
+### What Breaks If Removed
+
+Blind JSON parsing can crash startup. An unscoped storage key leaks settings across accounts. Applying a delayed restore unconditionally overwrites edits made while storage was loading.
+
+### Composition And Substitution
+
+Use [identity reset](identity-reset.md) for account changes. Persist only source values from [derived state](derived-state.md); do not restore loading flags, request IDs, or obsolete cached errors.
+
+## Opinionated Guidance
+
+Choose migration, expiry, and multi-tab conflict policies before persisting. A version field without a decoder or migration rule is not a compatibility strategy.
+
+## Platform-Specific Guidance
+
+Browser storage access and writes can throw or be unavailable; guard the adapter as well as parsing. Server rendering cannot read browser storage. Define hydration fallback and cross-tab event handling separately.
+
+Platform reference: [MDN API documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage), checked 2026-09-16. This supports the named browser boundary; the model and product policy remain local synthesis.
+
+## Unsupported Absolutes
+
+Persistence does not guarantee availability, confidentiality, or synchronization across devices.
+
+## Verification Contract
+
+- Decode corrupt, missing, old-version, and wrong-account records; use valid defaults.
+- Edit before an asynchronous restore finishes; preserve the edit.
+- Simulate unavailable storage and quota failure; keep the screen usable.
+
+Record actual outcomes separately using the [verification matrix](../verification.md).
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../recipes/index.md).

package/design-engineering/state-management/recipes/delete-undo.md

@@ -0,0 +1,65 @@
+---
+type: Domain Guide
+title: Deletion And Supported Undo
+description: Remove the intended entity and provide recovery that matches actual backend capabilities.
+domain: design-engineering
+lifecycle: experimental
+provenance_kind: local
+---
+
+# Deletion And Supported Undo
+
+## Repository Boundary
+
+Remove the intended entity and provide recovery that matches actual backend capabilities. This is a consumer interaction composition in Design Engineering. Spatial structure comes from [List Detail](../../../recipes/list-detail.md); this recipe adds no reusable Layout behavior.
+
+## Reusable Method
+
+### Selected Pattern Stack
+
+[ID selection](../patterns/id-selection.md), [single flight](../patterns/single-flight.md), optionally [optimistic overlay](../patterns/optimistic-overlay.md).
+
+### Ownership And Event Flow
+
+The collection owner tracks entities by ID. A per-entity deletion operation owns request identity and outcome. Confirmation owns a decision; an undo operation owns a real restore token or an explicitly cancellable pre-commit deletion.
+
+Activate → confirm if required → submit deletion → reconcile acknowledgement → recover focus. Offer Undo only when a backend restore or a declared delayed-commit cancellation exists. A UI-only inverse patch cannot undo a committed deletion.
+
+### Composition And Substitution
+
+Use pending-until-confirmed deletion by default in this recipe. An optimistic overlay is substitutable only with a recovery contract. Confirmation and Undo solve different product decisions and are not interchangeable by appearance.
+
+### Acceptance Sequences
+
+| Sequence | Expected outcome |
+| --- | --- |
+| Cancel confirmation | No deletion effect; return focus to invoker |
+| Fail definitively while filters change | Keep or restore the intended ID without reverting unrelated data |
+| Lose response after submission | Mark outcome uncertain and reconcile before repeating |
+| Delete the last row | Show empty state and move focus to a logical heading |
+| Undo expires or restoration fails | Explain failure and reconcile actual collection state |
+
+## Opinionated Guidance
+
+Keep the ownership boundaries visible when composing the patterns. One screen can combine these mechanisms without making every value global. Record the rejected alternative and its user-visible cost in the [state brief](../state-brief.md).
+
+## Platform-Specific Guidance
+
+Restore focus after confirmation and after removal of the invoker. Announce the affected entity and the real undo availability; animation completion must not authorize deletion.
+
+## Unsupported Absolutes
+
+These acceptance sequences are proposed integration checks, not captured product evidence. Pattern model tests do not prove this entire screen, its backend, or its focus behavior.
+
+## Verification Contract
+
+Adapt every acceptance row to the consumer and record actual results with the [verification matrix](../verification.md). Include the ordinary successful task and at least one interrupted task. The initial handoff is `consumer_reference: not_applicable` because this fictional recipe selects no consumer profile or conformance record.
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](index.md).
+Next: [Continue the state management route](../verification.md).

package/design-engineering/state-management/recipes/index.md

@@ -0,0 +1,64 @@
+# State Management Recipes
+
+Domain classification: design-engineering. Lifecycle: `experimental`.
+
+## Repository Boundary
+
+These are Design Engineering behavior recipes. The root `recipes/` directory remains the Layout corpus. A behavior recipe may reference a Layout recipe but cannot import state logic into its reusable CSS.
+
+## Reusable Method
+
+Choose a task, then review its owner map, event flow, substitution rules, and acceptance sequences.
+
+- [Settings with explicit save](settings-save.md): draft, submission, acknowledgement, and guarded departure.
+- [Search filters and detail](search-detail.md): route state, out-of-order reads, and stable selection.
+- [Multi-step form](multi-step-form.md): retained fields, validation, branching, and final submit.
+- [Deletion and supported undo](delete-undo.md): identity, duplicate policy, recovery, and actual reversibility.
+
+### Composition Matrix
+
+`E` means essential to this recipe's declared behavior; `S` means substitutable when the stated requirement changes; `O` is optional with its own contract; `—` means not required. Pattern names link to their standalone contracts.
+
+| Pattern | Settings | Search/detail | Multi-step form | Delete/undo |
+| --- | --- | --- | --- | --- |
+| [Single owner](../patterns/single-owner.md) | E | E | E | E |
+| [Derived state](../patterns/derived-state.md) | E | E | E | O |
+| [ID selection](../patterns/id-selection.md) | — | E | — | E |
+| [Draft/baseline](../patterns/draft-and-baseline.md) | E | — | E | — |
+| [Submitted snapshot](../patterns/submitted-snapshot.md) | E | — | E | — |
+| [Unsaved navigation](../patterns/unsaved-navigation.md) | E | — | E | — |
+| [Latest request wins](../patterns/latest-request-wins.md) | O | E | O | — |
+| [Single flight](../patterns/single-flight.md) | E | — | E | E |
+| [Optimistic overlay](../patterns/optimistic-overlay.md) | O | — | — | S |
+| [URL state](../patterns/url-state.md) | O | S | O | O |
+| [Identity reset](../patterns/identity-reset.md) | E | E | E | E |
+| [Versioned restore](../patterns/versioned-restore.md) | O | — | O | — |
+
+Single owner and identity reset are lifecycle foundations in these recipes even where the short stack emphasizes task-specific mechanisms. For a fixed identity, reset may be implemented simply by disposal; reused screens must invalidate their old generation.
+
+Substitution risks: replacing URL state loses history/deep-link recovery unless another navigation owner provides it. Replacing a pending deletion with an optimistic overlay requires definitive rejection versus uncertain-outcome handling. Replacing explicit save with autosave changes the recipe and needs a separate write ordering contract.
+
+## Opinionated Guidance
+
+Keep compositions smaller than the complete catalog. Optional restore and optimistic display should solve a named user need. Do not create a new primitive merely because a screen combines several existing ones.
+
+## Platform-Specific Guidance
+
+Keep native form behavior, router transitions, and focus restoration in the consuming UI. Model examples have no rendered geometry; use the linked Layout recipes to name scroll and source-order ownership.
+
+## Unsupported Absolutes
+
+The matrix describes proposed compositions, not universal requirements for every settings or search screen. It does not claim that all combinations have executed browser evidence.
+
+## Verification Contract
+
+Each recipe must expose a unique ownership map, a failure interleaving, and the consequence of replacing an essential choice. Execute consumer integration sequences separately from the 12 pattern model examples.
+
+## Source, License, And Attribution
+
+Locally authored synthesis and examples. No upstream implementation is copied. These experimental contracts describe consumer-owned behavior; review when a failure, ownership change, or platform change invalidates an assumption.
+
+## IA Navigation
+
+Parent: [State Management](../index.md).
+Next: [Continue the state management route](../verification.md).