@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/docs/toolcraft/renderer-technique.md

@@ -27,6 +27,10 @@ Do not write renderer code before the envelope, `rendererTechnique`, pipeline, a
 - Prefer retained resources and stable cache keys. Source-bound resources live outside React render, survive unrelated interactions according to pass lifecycle, and release during cleanup.
 - Separate layers when they have different semantics, invalidation, lifecycle, interaction, or export treatment. A costly layer does not force unrelated output into the same renderer.
 - Preserve selected quality, product boundaries, backing resolution, and source fidelity. A renderer is not accepted by silently reducing them.
+- In infinite mode, custom Canvas 2D, WebGL, and WebGPU previews use `useToolcraftProductSceneFrame()` as their backing and coordinate frame. Do not keep rendering into dormant finite `canvas.size`, derive another bounds wrapper, or measure DOM geometry; runtime already positions the product scene surface from `sceneBoundsProvider`.
+- A preview-only environment that must stay fixed to the complete Infinity
+  viewport uses `infiniteCanvasContent`, not the bounded product renderer. Keep
+  that layer pointer-transparent and exclude it from scene bounds and export.
 
 When assessment requires a benchmark, declare `kernelBenchmarkDecisions`, implement only the named executable candidates in `e2e/app-kernel-benchmarks.ts`, and let protected `pnpm verify:kernel` measure them at the exact combined workload vector. Candidate outputs must be deterministic and equal at full quality. Do not author timing values or add speculative benchmark metadata when generic assessment resolves the choice.
 
@@ -110,7 +114,7 @@ The `mount*` and error functions above stand for product renderer integration on
 
 The presentation lease is keyed by canonical document reference and shares immutable geometry/material/texture GPU resources across preview and export while cloning only scene roots. Replacement, delete/reset, failed creation, release, and provider unmount dispose ownership deterministically. The original uploaded folder/ZIP remains immutable durable source; display fit and camera pose live outside the leased root.
 
-The runtime presents structurally valid analyzing or repairing geometry at `0.4` opacity and committed clean/fixed geometry at `1`. Export is always `1`. Product image export renders its own pixels first, then awaits the `renderModelsToCanvas(exportCanvas)` helper supplied to `onPanelAction`. The public `renderToolcraftModelsToCanvas` API is the host-level implementation behind that helper; product apps should not bypass the action context to assemble their own host. Video export uses the same binding, visible layers, pose, current canvas dimensions, and target pixel ratio for every frame.
+The runtime presents structurally valid analyzing or repairing geometry at `0.4` opacity and committed clean/fixed geometry at `1`. Export is always `1`. Runtime image/video export composites visible committed model layers before awaiting the product's shared `ToolcraftAppComposition.exportRenderer` frame. Runtime owns the presentation binding, pose, scene frame, dimensions, pixel ratio, encoding, and download; product code does not call model compositors or construct a parallel export host.
 
 When `viewInteraction.mode` is `orbit`, schema `orientationGizmo`, direct model drag, preview rendering, hit testing, reset/history, and export share every declared orientation pose target. The product renderer supplies geometry-aware `hitTest`; Toolcraft owns gesture scheduling and history through `useToolcraftModelOrbitInteraction`.
 

package/templates/starter/docs/toolcraft/schema-reference.md

@@ -42,16 +42,16 @@ Custom product output declares bounds on the composition:
 ```tsx
 export const appComposition: ToolcraftAppComposition = {
   canvasContent: <ProductCanvas />,
-  sceneBoundsProvider: ({ state, timeRange }) => [
-    getVisibleProductSceneRect(state, timeRange),
+  sceneBoundsProvider: ({ state }) => [
+    getVisibleProductSceneRect(state),
   ],
   schema: appSchema,
 };
 ```
 
-The provider returns world-space `{ x, y, width, height }` rectangles. Runtime unions them once with visible image/model frames. It is called only for infinite export; video passes the requested time range so the provider can return one complete animation envelope. Product code does not read DOM bounds or the dormant finite size.
+The provider returns world-space `{ x, y, width, height }` rectangles for one exact state. Runtime uses their union for the live infinite product scene, unions them with visible image/model frames for export, and calls the provider for every scheduled video state before forming one stable envelope. Canvas 2D, WebGL, and WebGPU product output calls `useToolcraftProductSceneFrame()` inside `canvasContent` for active backing size and world-to-local translation. Product code does not read DOM bounds, author a time-range envelope, or reuse dormant finite size in infinite mode.
 
-Use `canvas.renderScale: true` only for non-vector raster previews such as Canvas 2D, WebGL, or WebGPU. Do not enable it for DOM/SVG/vector-native previews. Enabling it requires one browser runtime acceptance row targeting `canvas.renderScale` with `renderScaleCoverage.kind: "selected-backing-pixels"` and exact sorted states `["interaction", "steady"]`, plus `"playback"` when timeline is enabled. The fixed `canvas-render-scale-backing` recipe proves actual backing pixels rather than timing.
+Use `canvas.renderScale: true` or `canvas.renderScale: { step }` only for non-vector raster previews such as Canvas 2D, WebGL, or WebGPU. For this field, product code may customize only the slider step; authored schema cannot set `enabled`, `min`, `defaultValue`, or `max`. Runtime resolves enabled render scale to `{ enabled: true, min: 1, defaultValue: 2, max: 2, step }`, using `0.25` when no step is authored. A custom step must be finite, between `0.01` and `1`, and evenly partition the canonical `1..2` range so `2` remains reachable; invalid input fails fast. Do not enable it for DOM/SVG/vector-native previews. Enabling it requires one browser runtime acceptance row targeting `canvas.renderScale` with `renderScaleCoverage.kind: "selected-backing-pixels"` and exact sorted states `["interaction", "steady"]`, plus `"playback"` when timeline is enabled. The fixed `canvas-render-scale-backing` recipe proves actual backing pixels rather than timing.
 
 ## Media Defaults
 
@@ -89,7 +89,7 @@ media: {
 
 `sourceTarget` must match a compatible `fileDrop` control target. Runtime shows the asset as an attached file, users can remove it, and Reset restores it. Model defaults require `assetKind: "model"`, a root `fileName`, and complete local `sourceFiles`; each source uses a serializable `dataUrl` plus its bundle-relative `path`. Runtime restores default models through the same validation, analysis, repair, repository, and rendering pipeline as a user upload. Persisted empty media remains empty until Reset and must not silently resurrect defaults.
 
-For a multi-item `fileDrop`, `recommendedMaxItems` is advisory. `hardMaxItems`, when present, must be a finite nonnegative safe integer and is enforced before decode or storage allocation. Additive imports count current assets with the same `sourceTarget` plus the incoming logical batch; replacement imports count only the incoming batch.
+For a multi-item `fileDrop`, `recommendedMaxItems` is advisory. `hardMaxItems`, when present, must be a finite nonnegative safe integer and is enforced before decode or storage allocation. Additive imports count current assets with the same `sourceTarget` plus the incoming logical batch; replacement imports count only the incoming batch. A `fileDrop` with `assetKind: "file"`, `multiple: true`, and `variant: "collection-actions"` may declare `itemControls`; each entry uses a supported built-in collection item control and declares `defaultValue`. Attached files render these controls directly beneath their upload row, values persist at the parent target as records keyed by `mediaId`, and file bytes remain runtime-owned media.
 
 ## Model FileDrop
 
@@ -158,9 +158,9 @@ Common control fields:
 | `defaultValue`      | Initial value and reset value.                                                                                               |
 | `label`             | Short UI label, `false`, or omitted.                                                                                         |
 | `description`       | Product-specific help text only when it adds meaning beyond the label.                                                       |
-| `visibleWhen`       | Mode/type/source/include/variant/count visibility. Hidden values are preserved.                                              |
+| `applicability`     | Required product claim: `{ mode: "always" }` or `{ mode: "conditional", all: [...] }`. Hidden values are preserved.       |
 | `orderRole`         | Makes section order testable.                                                                                                |
-| `semanticGroup`     | Language-independent product sub-entity/workflow grouping, required on every control in sections larger than seven controls. |
+| `semanticGroup`     | Language-independent product sub-entity/workflow grouping, required on every control in sections with eight to ten controls. |
 | `sliderValueKind`   | `slider` intent: `"continuous"` or `"discrete"`.                                                                             |
 | `textValueKind`     | `text`/`code` intent: `"single-line"`, `"multiline"`, or `"structured"`.                                                     |
 | `curveIntent`       | `curves` composition: `"single-value-map"` or `"color-channels"`.                                                            |
@@ -170,11 +170,9 @@ Common control fields:
 | `keyframeable`      | Timeline/keyframe capability override when structurally needed.                                                              |
 | `variant`           | Component-specific variant.                                                                                                  |
 
-Use `visibleWhen` for product availability. Do not use `disabled`, `disabledWhen`, or inert visible controls for generated product branches.
+Every authored product control declares `applicability`: use `{ mode: "always" }` only when it affects its accepted outcome in every finite sibling-selector branch, or `{ mode: "conditional", all: [...] }` when every predicate must match. Inactive controls are absent while values remain preserved. Do not use `disabled`, `disabledWhen`, or inert visible controls for availability. Legacy control `visibleWhen` remains readable only at the low-level compatibility boundary; product acceptance rejects it and omitted applicability. Section `visibleWhen` remains a separate legacy section-layout feature.
 
-Conditions support `equals`, `notEquals`, `oneOf`, `notOneOf`, `greaterThan`, `greaterThanOrEqual`, `lessThan`, and `lessThanOrEqual`.
-
-Reserved runtime targets include `runtime.settingsTransfer`, `canvas.infinity`, `canvas.aspectRatio`, `canvas.size.width`, `canvas.size.height`, `canvas.renderScale`, and `panels.timeline.extended`. Product sections must not declare those controls.
+Conditions support `equals`, `notEquals`, `oneOf`, `notOneOf`, `greaterThan`, `greaterThanOrEqual`, `lessThan`, and `lessThanOrEqual`. Reserved runtime targets include `runtime.settingsTransfer`, `canvas.infinity`, `canvas.aspectRatio`, `canvas.size.width`, `canvas.size.height`, `canvas.renderScale`, and `panels.timeline.extended`; product sections must not declare them.
 
 ## Built-In Control Types
 
@@ -194,6 +192,7 @@ Reserved runtime targets include `runtime.settingsTransfer`, `canvas.infinity`,
 | `checkbox` | `Checkbox` |
 | `actions` | `Actions` |
 | `collectionActions` | `CollectionActions` |
+| `sourceCollection` | `ControlsPanelCollectionItems` |
 | `panelActions` | `PanelActions` |
 | `colorOpacity` | `ColorOpacity` |
 | `palette` | `Palette` |
@@ -210,7 +209,7 @@ Reserved runtime targets include `runtime.settingsTransfer`, `canvas.infinity`,
 | `settingsTransfer` | `SettingsTransfer` |
 [//]: # (toolcraft-contract:built-in-control-table:end)
 
-Use `component-rules.md` for component-specific fit, labels, variants, units, parser behavior, and exceptions. Use `core/control-selection.md` before deciding a custom control is needed.
+Use `component-rules.md` for component-specific fit, labels, variants, units, parser behavior, and exceptions. `sourceCollection` renders a supported built-in `itemControl` for a source-owned array without add/remove UI; `collectionActions` owns user cardinality and its limits. Use `itemControl` for one homogeneous repeated value. For one logical repeated entity made from two or more built-in fields, use `itemControls`; for example, `{ type: "collectionActions", target: "surface.layers", defaultValue: [{ strength: 0.4, invert: false }], itemControls: { strength: { type: "slider", defaultValue: 0.5 }, invert: { type: "switch", defaultValue: false } } }`. Every field requires `defaultValue`; `itemControl` and `itemDefaultValue` are invalid competing template sources. `+` appends the complete defaults, `−` removes the final record, edits preserve sibling/product keys, and runtime places a line only between compound records without `Item N` headings. Standalone color `itemControl` remains a divider-free two-column grid. Use `core/control-selection.md` before deciding a custom control is needed.
 
 `orientationGizmo` uses a non-degenerate `{ position: [x, y, z], up: [x, y, z] }` default, `label: false`, and `keyframeable: false`. Declare one target for the active/selected model and keep it beside at least one visible product control in the semantic model/view section; runtime renders the handle on the canvas rather than in the controls panel. Multiple declarations require statically provable mutually exclusive combined section/control visibility conditions, because runtime permits at most one active orientation handle.
 
@@ -221,6 +220,7 @@ before schema controls or renderer code:
 
 ```ts
 export const starterProductReadiness: ToolcraftProductReadiness = {
+  exportIntent: { image: { mode: "toolcraft-default" }, video: { mode: "not-requested" } },
   interactionOwnership: [],
   mode: "product",
   productName: "Model Studio",
@@ -290,22 +290,22 @@ exactly match schema `orientationGizmo` targets.
 ## Control Section Inventory
 
 Before writing `panels.controls.sections`, export `starterControlSectionInventory` beside `starterAcceptance`:
-
 ```ts
 export const starterControlSectionInventory = [
   {
     entity: "Text block",
-    groupingReason:
-      "These controls edit the text content, typography, and visible text fill together.",
+    entityId: "text-block",
+    groupingReason: "These controls edit the text content, typography, and visible text fill together.",
+    id: "text",
     targets: ["text.content", "text.font"],
     title: "Text",
   },
 ] as const;
 ```
 
-Every product control target appears exactly once in the inventory. Runtime `Setup`, sticky footer `Export`, settings transfer, and runtime canvas sizing targets do not need entries.
-
-For sections larger than seven controls, each control also declares `semanticGroup`. Controls editing one tightly scoped product sub-entity share the same value; mixed groups make a broad section fail and should be split. This fact is structural and may not be inferred from English labels.
+- Every product control target appears exactly once in the inventory. Runtime-owned `Setup`, sticky footer `Export`, settings transfer, and runtime canvas sizing targets do not need entries. The product targets authored in the standard `Background` source section remain in its `Background` inventory entry after runtime relocates those controls into `Setup`. Stable `entityId` is the primary grouping authority; target namespaces are only secondary diagnostics.
+- Keep one logical entity in one section through ten controls. One to seven controls is the normal size; sections with eight to ten controls require `semanticGroup` on every control. Controls editing one tightly scoped product sub-entity share the same group, and this fact may not be inferred from English labels.
+- When one entity has more than ten controls, split it into balanced workflow sections containing two to ten controls. Every split section keeps the same `entityId` and `entity`, declares a unique `workflowStage`, and provides a concrete `splitReason`. Do not create a one-control tail.
 
 ## Transfer Metadata
 
@@ -313,19 +313,17 @@ Reference and motion metadata lives in `starterTransferMode`.
 
 Use `transferMode: "reference-runtime-clone"` when porting an existing app unless the user explicitly asks for redesign. Reference clones declare `referenceStudy`, `referenceFeatureInventory`, and acceptance mapping; detailed evidence requirements live in `core/reference-study.md`.
 
+Every product readiness declaration includes required `exportIntent`. Its resolved image/video capabilities must correspond exactly to schema actions and settings sections. Use `core/setup-export.md` for the authoritative modes, evidence requirements, and decision sequence.
+
 Video references declare `videoReferenceStudy` before implementation. Animated products declare `animationIntent`, and playback/keyframe timeline apps declare a proven loop duration when known. Detailed animation rules live in `core/timeline-animation.md`.
 
 ## Export And Actions
 
-Product apps expose delivery through sticky `panelActions`, not canvas UI or ordinary body controls. Every product exposes `Export PNG`; products whose requested delivery includes animation also expose `Export Video`. A playback or keyframe timeline may drive interactive preview without inventing video delivery.
-
-Every app with `Export PNG` includes `Image Export` controls with `export.image.format` and `export.image.resolution`. Apps with `Export Video` also include `Video Export` controls with `export.video.format` and `export.video.resolution`.
+Product apps expose enabled artifact delivery through sticky `panelActions`, not canvas UI or ordinary body controls. `productReadiness.exportIntent` is required: image export defaults on and is absent only with explicit removal evidence; video export exists only with explicit user-request evidence. Animation, playback, keyframes, and timeline presence never change that intent.
 
-Use standard helpers:
+Every app with `Export PNG` includes `Image Export` controls with `export.image.format` and `export.image.resolution`. Apps with `Export Video` include `Video Export` controls with `export.video.format` and `export.video.resolution`. Image-only, image-plus-video, video-only, and explicit no-export layouts must match `core/setup-export.md` exactly.
 
-- `createToolcraftPngExportCanvas({ resolution, includeBackground, state, render })`
-- `shouldIncludeToolcraftPreviewBackground(state)`
-- `getToolcraftVideoExportSize({ resolution, state })`
+Use the standard runtime path: declare typed `export-image`/`export-video` panel actions and their settings, provide one `ToolcraftAppComposition.exportRenderer` when product code contributes pixels, and draw one deterministic frame from the supplied state/time in scene coordinates. Call `shouldIncludeToolcraftPreviewBackground(state)` only for bounded live preview; runtime owns artifact composition, sizing, encoding, download, progress, and errors.
 
 Detailed Setup, Background, Image Export, Video Export, sticky action, icon, and progress rules live in `core/setup-export.md`.
 

package/templates/starter/docs/toolcraft/workflow.md

@@ -3,6 +3,7 @@
 <!-- toolcraft-performance-lifecycle: first-delivery=functional; later-delivery=functional-targeted; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->
 <!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->
 <!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->
+<!-- toolcraft-performance-routing: localized=agent-targeted; ambiguous=one-user-facing-choice; broad=offer-targeted-or-full; full=explicit-only -->
 
 This file is the app-local routing layer for Toolcraft work. It does not replace the detailed contracts; it tells an agent which contract to read and which verification path to use before editing.
 
@@ -65,7 +66,7 @@ For product app work, update `docs/toolcraft/agent-worklog.md` before reporting
   - state/output mapping from controls, commands, timeline, layers, media, or renderer to the visible product;
   - one bare-delivery verification narrative;
   - risks or follow-ups.
-- for a performance complaint only, an exact request quote and the canonical affected performance path IDs.
+- for localized performance work, or a post-clarification targeted choice, an exact request quote and the canonical affected performance path IDs; classifier output establishes complaint authority only, and unresolved localization records neither performance-iteration intent nor canonical path authority regardless of classifier result.
 - updated high-level decisions for renderer, view interaction, interaction ownership, timeline, layers, controls, export, and performance when those choices change.
 
 If the folder is still the neutral starter, do not invent product decisions. Once it becomes a product, switch the worklog to product mode and keep it concrete.
@@ -102,9 +103,13 @@ Use the smallest focused unit and browser checks while implementation is changin
 
 1. **First product delivery:** bare `pnpm verify:delivery` proves complete product contracts, performs one production build, runs full functional acceptance, and runs no measured performance.
 2. **Later functional-targeted delivery:** bare `pnpm verify:delivery` compares the immediate previous and current semantic functional proof models. It selects exact changed acceptance contracts, their direct owners and domains, and tests reached through the affected product-unit dependency graph.
-3. **Performance complaint:** record domain authority in the worklog—an exact request quote plus canonical affected path IDs—then run one bare `pnpm verify:delivery`. It executes one targeted iteration against the reachable development fixture, returns the verified app, and waits for user evaluation.
+3. **Localized or clarified targeted work:** only a localized complaint or a post-clarification targeted choice records domain authority in the worklog—an exact request quote plus canonical affected path IDs—and runs one bare `pnpm verify:delivery`. It executes one targeted iteration against the reachable development fixture, returns the verified app, and waits for user evaluation. Classifier output alone never localizes a path; unresolved localization creates neither performance-iteration intent nor canonical path authority, whether classification returned high-confidence `performance-iteration` or `needs-agent-judgment`.
 4. **Full audit:** only an explicit operator request or accepted offer authorizes `pnpm verify:perf`. It performs one fresh build and the complete maximum-fixture performance matrix without advancing the delivery anchor.
 
+Performance authority and localization are separate decisions. Classifier output establishes complaint authority only and never path localization. A localized complaint lets the agent select the affected canonical paths and run one targeted iteration without asking the user. For an ambiguous complaint, ask one user-facing question that names the visible operation and offers targeted diagnosis or a complete performance review; never ask the user to choose internal path IDs, and record no performance-iteration intent or canonical path authority before the answer. For a broad or honestly unlocalizable problem, the agent may recommend the complete performance review in that single targeted/full choice, but the user still chooses. A direct request for the complete performance review runs `pnpm verify:perf` without another clarification.
+
+Store agent-produced browser diagnostics under `.toolcraft/browser-artifacts/`. Browser integrations may instead use their external tool-owned storage; diagnostic files never belong in product source.
+
 The unchanged `sourceHash` fast path does not collect the catalog, dependency graph, or functional proof model and does not execute proof. For a changed source, the current catalog, input roles, ownership inventory, and semantic model are collected once and remain the immutable basis for that delivery plan. `workflow-observation.md` is a post-delivery summary, not execution authority, so it stays outside this hash; `agent-worklog.md` remains included.
 
 After two consecutive compatible targeted iterations, offer the slower full audit if the user remains unsatisfied. A complaint, filename, or touched subsystem never authorizes it. Canonical classification details, failure behavior, and evidence wording live in `core/performance.md` and `performance.md`.

package/templates/starter/e2e/app-browser-control-applicability-requirements.spec.ts

@@ -0,0 +1,163 @@
+import { expect, test } from "@playwright/test";
+import { defineToolcraft } from "@repo/toolcraft-runtime";
+
+import { deriveToolcraftBrowserRuntimeRequirements } from "./browser-runtime-evidence-requirements";
+
+const inventory = [
+  {
+    entity: "Feature",
+    entityId: "feature",
+    groupingReason: "Mode and amount describe one feature.",
+    id: "feature",
+    targets: ["feature.mode", "feature.amount"],
+    title: "Feature",
+  },
+] as const;
+
+test("conditional controls derive case-specific visibility and outcome evidence", () => {
+  const schema = defineToolcraft({
+    canvas: { enabled: true },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: {
+              amount: {
+                applicability: {
+                  all: [{ equals: "advanced", target: "feature.mode" }],
+                  mode: "conditional",
+                },
+                defaultValue: 1,
+                target: "feature.amount",
+                type: "slider",
+              },
+              mode: {
+                applicability: { mode: "always" },
+                defaultValue: "simple",
+                options: [
+                  { label: "Simple", value: "simple" },
+                  { label: "Advanced", value: "advanced" },
+                ],
+                target: "feature.mode",
+                type: "segmented",
+              },
+            },
+            id: "feature",
+            title: "Feature",
+          },
+        ],
+        title: "Controls",
+      },
+    },
+  });
+  const requirements = deriveToolcraftBrowserRuntimeRequirements(
+    [
+      {
+        browser: true,
+        browserTestName: "browser: conditional amount",
+        evidence: "product-output",
+        id: "feature.amount",
+        kind: "control",
+        target: "feature.amount",
+      },
+    ],
+    schema,
+    inventory,
+  );
+
+  expect(requirements.map(({ evidenceType }) => evidenceType)).toEqual(
+    expect.arrayContaining([
+      "control-applicability-hidden",
+      "control-applicability-visible",
+      "product-observable-change",
+    ]),
+  );
+  expect(
+    requirements.some(
+      (requirement) => requirement.requirementId === "feature.amount",
+    ),
+  ).toBe(false);
+});
+
+test("finite siblings expand outcomes even when always-applicability omits the selector", () => {
+  const schema = defineToolcraft({
+    canvas: { enabled: true },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: {
+              amount: {
+                applicability: { mode: "always" },
+                defaultValue: 1,
+                target: "feature.amount",
+                type: "slider",
+              },
+              mode: {
+                applicability: { mode: "always" },
+                defaultValue: "simple",
+                options: [
+                  { label: "Simple", value: "simple" },
+                  { label: "Advanced", value: "advanced" },
+                ],
+                target: "feature.mode",
+                type: "segmented",
+              },
+            },
+            id: "feature",
+            title: "Feature",
+          },
+        ],
+        title: "Controls",
+      },
+    },
+  });
+  const acceptance = {
+    browser: true,
+    browserTestName: "browser: feature amount",
+    evidence: "product-output" as const,
+    id: "feature.amount",
+    kind: "control" as const,
+    target: "feature.amount",
+  };
+  const requirements = deriveToolcraftBrowserRuntimeRequirements(
+    [acceptance],
+    schema,
+    inventory,
+  );
+
+  expect(requirements).toHaveLength(4);
+  expect(
+    requirements.filter(
+      ({ evidenceType }) => evidenceType === "control-applicability-visible",
+    ),
+  ).toHaveLength(2);
+  expect(
+    requirements.filter(
+      ({ evidenceType }) => evidenceType === "product-observable-change",
+    ),
+  ).toHaveLength(2);
+  expect(
+    requirements.every(({ requirementId }) =>
+      requirementId.includes("#applicability:feature.mode="),
+    ),
+  ).toBe(true);
+
+  expect(() =>
+    deriveToolcraftBrowserRuntimeRequirements(
+      [
+        {
+          ...acceptance,
+          renderScaleCoverage: {
+            kind: "selected-backing-pixels",
+            states: [],
+          },
+        },
+      ],
+      schema,
+      inventory,
+    ),
+  ).toThrow(
+    "Visible applicability case for feature.amount has no product outcome requirement",
+  );
+});

package/templates/starter/e2e/app-browser-control-coverage.spec.ts

@@ -1,10 +1,43 @@
 import { expect, test } from "@playwright/test";
 import { expectToolcraftExportedArtifact } from "./browser-acceptance-outcome-helpers";
 import {
+  expectToolcraftDiscreteSliderMarkers,
   expectToolcraftSegmentedControlCellsPreservePadding,
   getToolcraftFieldByLabel,
 } from "./performance-helpers";
 
+test("discrete slider layout accepts one interior marker and rejects none", async ({
+  page,
+}) => {
+  await page.setContent(`
+    <div data-slot="toolcraft-runtime-app">
+      <div data-toolcraft-control-target="canvas.renderScale">
+        <div data-slot="field" style="display:block;width:200px;height:24px;">
+          <div data-slot="slider" data-variant="discrete" style="display:block;width:200px;height:24px;">
+            <span data-slot="slider-marker" style="display:block;width:1px;height:6px;"></span>
+          </div>
+        </div>
+      </div>
+    </div>
+  `);
+
+  await expectToolcraftDiscreteSliderMarkers(page, "canvas.renderScale");
+
+  await page.setContent(`
+    <div data-slot="toolcraft-runtime-app">
+      <div data-toolcraft-control-target="canvas.renderScale">
+        <div data-slot="field" style="display:block;width:200px;height:24px;">
+          <div data-slot="slider" data-variant="discrete" style="display:block;width:200px;height:24px;"></div>
+        </div>
+      </div>
+    </div>
+  `);
+
+  await expect(
+    expectToolcraftDiscreteSliderMarkers(page, "canvas.renderScale"),
+  ).rejects.toThrow(/at least one interior marker/);
+});
+
 test("segmented layout helper catches paddingless or colliding cells", async ({ page }) => {
   await page.setContent(`
     <div data-slot="field">FX Preset

package/templates/starter/e2e/app-browser-infinity-canvas-evidence.spec.ts

@@ -1,4 +1,4 @@
-import { test } from "@playwright/test";
+import { expect, test } from "@playwright/test";
 
 import {
   expectInfiniteCanvasObservation,
@@ -6,6 +6,10 @@ import {
   expectToolcraftInfinityCanvasVideoExportEvidence,
   observeInfinityCanvas,
 } from "./browser-infinity-canvas-evidence";
+import {
+  readToolcraftCanvasViewport,
+  zoomToolcraftCanvasViewport,
+} from "./performance-canvas-helpers";
 
 test("toolcraft Infinity canvas observation reads runtime-owned geometry", async ({
   page,
@@ -13,17 +17,60 @@ test("toolcraft Infinity canvas observation reads runtime-owned geometry", async
   await page.setContent(`
     <div data-toolcraft-canvas-world data-toolcraft-canvas-offset-x="12" data-toolcraft-canvas-offset-y="-8">
       <div data-toolcraft-canvas-mode="infinite" style="overflow: visible">
-        <div data-scene style="position:absolute;left:-320px;top:-200px;width:640px;height:400px"></div>
+        <div data-scene style="position:absolute;left:1px;top:2px;width:3px;height:4px"></div>
+        <div
+          data-toolcraft-product-scene
+          data-toolcraft-product-scene-status="ready"
+          style="position:absolute;left:-320px;top:-200px;width:640px;height:400px"
+        ></div>
       </div>
     </div>
   `);
 
   expectInfiniteCanvasObservation(
-    await observeInfinityCanvas(page, "[data-scene]"),
+    await observeInfinityCanvas(page),
     { height: 400, width: 640, x: -320, y: -200 },
   );
 });
 
+test("toolcraft canvas viewport observation reads the runtime world transform", async ({
+  page,
+}) => {
+  await page.setContent(`
+    <div
+      data-toolcraft-canvas-world
+      data-toolcraft-canvas-offset-x="96"
+      data-toolcraft-canvas-offset-y="-64"
+      data-toolcraft-canvas-zoom="125"
+    ></div>
+  `);
+
+  await expect(readToolcraftCanvasViewport(page)).resolves.toEqual({
+    offsetX: 96,
+    offsetY: -64,
+    zoom: 125,
+  });
+});
+
+test("toolcraft canvas zoom helper performs only the requested direction", async ({
+  page,
+}) => {
+  await page.setContent(`
+    <button aria-label="Zoom in" onclick="document.body.dataset.zoomIn = String(Number(document.body.dataset.zoomIn ?? 0) + 1)"></button>
+    <button aria-label="Zoom out" onclick="document.body.dataset.zoomOut = String(Number(document.body.dataset.zoomOut ?? 0) + 1)"></button>
+  `);
+
+  await zoomToolcraftCanvasViewport(page, {
+    direction: "in",
+    repetitions: 2,
+  });
+  await expect(page.locator("body")).toHaveAttribute("data-zoom-in", "2");
+  await expect(page.locator("body")).not.toHaveAttribute("data-zoom-out");
+
+  await zoomToolcraftCanvasViewport(page, { direction: "out" });
+  await expect(page.locator("body")).toHaveAttribute("data-zoom-out", "1");
+});
+
 test("toolcraft Infinity canvas video evidence compares decoded envelopes", async () => {
   await expectToolcraftInfinityCanvasVideoExportEvidence(
     {