@pixel-point/toolcraft 0.0.17 → 0.0.18

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

@@ -42,14 +42,14 @@ 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` 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.
 
@@ -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,13 +313,15 @@ 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.
+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.
 
-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`.
+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.
 
 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.
 

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-infinity-canvas-evidence.spec.ts

@@ -17,13 +17,18 @@ 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 },
   );
 });

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

@@ -14,6 +14,81 @@ import {
   setProofState,
 } from "./browser-semantic-evidence-test-helpers";
 
+const orientationBaseline: ToolcraftOrientationBrowserObservation = {
+  outputSignature: "model-front",
+  pixelSignature: "pixels-front",
+  pose: { position: [0, 0, 5], up: [0, 1, 0] },
+  poseTarget: "view.orbit",
+  presentationCacheKey: "appearance:document-model:v2",
+  presentationDocumentId: "document-model",
+  viewportOffsetX: 0,
+  viewportOffsetY: 0,
+};
+
+const orientationDragged: ToolcraftOrientationBrowserObservation = {
+  ...orientationBaseline,
+  outputSignature: "model-dragged",
+  pixelSignature: "pixels-dragged",
+  pose: { position: [1, 1, 4.8], up: [0, 1, 0] },
+};
+
+const orientationOptions = {
+  requirementId: "model.orientation",
+  stabilityIntervalMs: 0,
+  target: "view.orbit",
+} as const;
+
+type OrientationProofUiState = Readonly<{
+  playbackActions?: readonly ("pause" | "play")[];
+  renderScales?: readonly Readonly<{
+    maximum: string;
+    value: string;
+  }>[];
+}>;
+
+async function installOrientationProofUiState(
+  page: Page,
+  state: OrientationProofUiState,
+): Promise<void> {
+  await page.locator('[data-slot="toolcraft-runtime-app"]').evaluate(
+    (root, proofState) => {
+      root.querySelector('[data-orientation-proof-state]')?.remove();
+      const fixture = document.createElement("div");
+      fixture.dataset.orientationProofState = "";
+
+      for (const action of proofState.playbackActions ?? []) {
+        const button = document.createElement("button");
+        const label = action === "play" ? "Play playback" : "Pause playback";
+        button.type = "button";
+        button.textContent = label;
+        button.setAttribute("aria-label", label);
+        fixture.append(button);
+      }
+
+      for (const [index, renderScale] of (
+        proofState.renderScales ?? []
+      ).entries()) {
+        const field = document.createElement("div");
+        field.dataset.toolcraftControlTarget = "canvas.renderScale";
+        field.dataset.orientationProofRenderScale = String(index);
+        const slider = document.createElement("div");
+        slider.dataset.slot = "slider";
+        slider.setAttribute("aria-valuemax", renderScale.maximum);
+        slider.setAttribute("aria-valuemin", "1");
+        slider.setAttribute("aria-valuenow", renderScale.value);
+        slider.setAttribute("role", "slider");
+        Object.assign(slider.style, { height: "20px", width: "120px" });
+        slider.textContent = "Render scale";
+        field.append(slider);
+        fixture.append(field);
+      }
+
+      root.append(fixture);
+    },
+    state,
+  );
+}
+
 async function installOrientationGizmoPointerProbe(
   page: Page,
   initial: ToolcraftOrientationBrowserObservation,
@@ -123,33 +198,107 @@ async function installModelOrbitPointerProbe(
   );
 }
 
+test("orientation axis drag validates paused maximum-quality proof state", async ({
+  page,
+}, testInfo) => {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  const attachmentCount = testInfo.attachments.length;
+  const observation = session.observe((root) =>
+    JSON.parse(root.getAttribute("data-proof-orientation") ?? "null"),
+  );
+  const invalidStateCases: readonly Readonly<{
+    expectedError: RegExp;
+    state: OrientationProofUiState;
+  }>[] = [
+    {
+      expectedError: /must be paused.*Play playback/iu,
+      state: {
+        playbackActions: ["pause"],
+        renderScales: [{ maximum: "2", value: "2" }],
+      },
+    },
+    {
+      expectedError: /exactly one standard playback action/iu,
+      state: { playbackActions: ["play", "pause"] },
+    },
+    {
+      expectedError: /canvas\.renderScale.*maximum/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "2", value: "1" }],
+      },
+    },
+    {
+      expectedError: /exactly one canvas\.renderScale owner/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [
+          { maximum: "2", value: "2" },
+          { maximum: "2", value: "2" },
+        ],
+      },
+    },
+    {
+      expectedError: /finite aria-valuenow/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "2", value: "" }],
+      },
+    },
+    {
+      expectedError: /finite aria-valuemax/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "invalid", value: "2" }],
+      },
+    },
+  ];
+
+  for (const { expectedError, state } of invalidStateCases) {
+    await setProofState(page, "orientation", orientationBaseline);
+    await installOrientationGizmoPointerProbe(page, orientationBaseline, {
+      outcomes: { drag: orientationDragged },
+    });
+    await installOrientationProofUiState(page, state);
+    await expect(
+      expectToolcraftOrientationAxisDrag(observation, session, {
+        ...orientationOptions,
+        dragDelta: { x: 18, y: 12 },
+      }),
+    ).rejects.toThrow(expectedError);
+    expect(testInfo.attachments).toHaveLength(attachmentCount);
+  }
+});
+
+test("orientation axis drag retains proof for products without optional playback or render scale", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  await setProofState(page, "orientation", orientationBaseline);
+  const observation = session.observe((root) =>
+    JSON.parse(root.getAttribute("data-proof-orientation") ?? "null"),
+  );
+  await installOrientationGizmoPointerProbe(page, orientationBaseline, {
+    outcomes: { drag: orientationDragged },
+  });
+
+  await expectToolcraftOrientationAxisDrag(observation, session, {
+    ...orientationOptions,
+    dragDelta: { x: 18, y: 12 },
+  });
+});
+
 test("orientation recipes require shared pose/output changes and correct canvas ownership", async ({
   page,
 }, testInfo) => {
   await page.goto("/");
   const session = await createToolcraftBrowserProofSession(page);
   const attachmentCount = testInfo.attachments.length;
-  const baseline: ToolcraftOrientationBrowserObservation = {
-    outputSignature: "model-front",
-    pixelSignature: "pixels-front",
-    pose: { position: [0, 0, 5], up: [0, 1, 0] },
-    poseTarget: "view.orbit",
-    presentationCacheKey: "appearance:document-model:v2",
-    presentationDocumentId: "document-model",
-    viewportOffsetX: 0,
-    viewportOffsetY: 0,
-  };
-  const dragged: ToolcraftOrientationBrowserObservation = {
-    ...baseline,
-    outputSignature: "model-dragged",
-    pixelSignature: "pixels-dragged",
-    pose: { position: [1, 1, 4.8], up: [0, 1, 0] },
-  };
-  const options = {
-    requirementId: "model.orientation",
-    stabilityIntervalMs: 0,
-    target: "view.orbit",
-  } as const;
+  const baseline = orientationBaseline;
+  const dragged = orientationDragged;
+  const options = orientationOptions;
 
   await setProofState(page, "orientation", baseline);
   const observation = session.observe((root) =>
@@ -175,6 +324,10 @@ test("orientation recipes require shared pose/output changes and correct canvas
   expect(testInfo.attachments).toHaveLength(attachmentCount);
 
   await setProofState(page, "orientation", baseline);
+  await installOrientationProofUiState(page, {
+    playbackActions: ["play"],
+    renderScales: [{ maximum: "2", value: "2" }],
+  });
   await installOrientationGizmoPointerProbe(page, baseline, {
     dragCommit: "pointerup",
     outcomes: { drag: dragged },

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

@@ -133,7 +133,7 @@ test("control schema derives segmented and discrete runtime evidence", () => {
   );
 });
 
-test("typed visibility and background coverage derive dedicated semantic evidence", () => {
+test("typed background coverage derives dedicated semantic evidence", () => {
   const schema = defineToolcraft({
     canvas: { enabled: true },
     panels: {
@@ -141,19 +141,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
         sections: [
           {
             controls: {
-              conditional: {
-                defaultValue: 1,
-                label: "Conditional",
-                target: "feature.conditional",
-                type: "slider",
-                visibleWhen: { equals: true, target: "feature.enabled" },
-              },
-              enabled: {
-                defaultValue: false,
-                label: "Enabled",
-                target: "feature.enabled",
-                type: "switch",
-              },
               includeBackground: {
                 defaultValue: true,
                 label: "Include",
@@ -181,14 +168,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
   });
   const requirements = deriveToolcraftBrowserRuntimeRequirements(
     [
-      {
-        browser: true,
-        browserTestName: "browser: conditional visibility",
-        evidence: "product-output",
-        id: "feature.conditional",
-        target: "feature.conditional",
-        visibilityCoverage: ["hidden", "visible"],
-      },
       {
         backgroundOutputCoverage: [
           "preview-hidden-when-excluded",
@@ -205,17 +184,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
     ],
     schema,
   );
-
-  expect(
-    requirements
-      .filter((requirement) => requirement.requirementId === "feature.conditional")
-      .map((requirement) => requirement.evidenceType),
-  ).toEqual(
-    expect.arrayContaining([
-      "conditional-control-hidden",
-      "conditional-control-visible",
-    ]),
-  );
   expect(
     requirements
       .filter((requirement) => requirement.requirementId === "export.includeBackground")