@pixel-point/toolcraft 0.0.17 → 0.0.18

package/templates/runtime/schema/define-toolcraft.segmented-control-fit.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 
+import type { ToolcraftCollectionItemControlType } from "./collection-item-controls";
 import { defineToolcraft } from "./define-toolcraft";
 import type { ToolcraftControlSchema } from "./types";
 
@@ -39,8 +40,9 @@ function createModeControl(
 }
 
 function createCollectionModeControl(
-  type: string,
+  type: ToolcraftCollectionItemControlType,
   labels: readonly string[],
+  parentType = "collectionActions",
 ): ToolcraftControlSchema {
   return {
     defaultValue: ["default"],
@@ -57,7 +59,7 @@ function createCollectionModeControl(
     label: "Modes",
     minItems: 1,
     target: "appearance.modes",
-    type: "collectionActions",
+    type: parentType,
   };
 }
 
@@ -138,6 +140,22 @@ describe("defineToolcraft segmented control fit", () => {
     expect(control).toEqual(inputSnapshot);
   });
 
+  it("applies segmented item fit validation to sourceCollection", () => {
+    expect(() =>
+      defineToolcraft(
+        createAppSchema(
+          createCollectionModeControl(
+            "segmented",
+            SCREENSHOT_LABELS,
+            "sourceCollection",
+          ),
+        ),
+      ),
+    ).toThrow(
+      /Toolcraft control validation \[segmented-control-fit\] for target "appearance\.modes" itemControl: .*select dropdown/u,
+    );
+  });
+
   it.each(["type", "target"] as const)(
     "preserves required %s validation ownership",
     (fieldName) => {

package/templates/runtime/schema/define-toolcraft.setup-canvas.test.ts

@@ -32,6 +32,7 @@ describe("defineToolcraft runtime setup canvas controls", () => {
 
     expect(canvasSection?.title).toBe("Setup");
     expect(canvasSection?.controls.infinityCanvas).toMatchObject({
+      applicability: { mode: "always", origin: "explicit" },
       defaultValue: false,
       label: "Infinity canvas",
       target: "canvas.infinity",
@@ -52,7 +53,11 @@ describe("defineToolcraft runtime setup canvas controls", () => {
       performanceRole: "workload",
       target: "canvas.aspectRatio",
       type: "aspectRatio",
-      visibleWhen: { equals: false, target: "canvas.infinity" },
+      applicability: {
+        all: [{ equals: false, target: "canvas.infinity" }],
+        mode: "conditional",
+        origin: "explicit",
+      },
     });
     expect(canvasSection?.controls.canvasWidth).toMatchObject({
       defaultValue: 1440,
@@ -60,7 +65,11 @@ describe("defineToolcraft runtime setup canvas controls", () => {
       performanceRole: "workload",
       target: "canvas.size.width",
       type: "text",
-      visibleWhen: { equals: false, target: "canvas.infinity" },
+      applicability: {
+        all: [{ equals: false, target: "canvas.infinity" }],
+        mode: "conditional",
+        origin: "explicit",
+      },
     });
     expect(canvasSection?.controls.canvasHeight).toMatchObject({
       defaultValue: 900,
@@ -68,7 +77,11 @@ describe("defineToolcraft runtime setup canvas controls", () => {
       performanceRole: "workload",
       target: "canvas.size.height",
       type: "text",
-      visibleWhen: { equals: false, target: "canvas.infinity" },
+      applicability: {
+        all: [{ equals: false, target: "canvas.infinity" }],
+        mode: "conditional",
+        origin: "explicit",
+      },
     });
     expect(canvasSection?.layoutGroups).toEqual([
       {

package/templates/runtime/schema/define-toolcraft.source-collection.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+
+import { defineToolcraft } from "./define-toolcraft";
+import type { ToolcraftControlSchema } from "./types";
+
+function createAppSchema(control: ToolcraftControlSchema) {
+  return {
+    canvas: { enabled: false },
+    panels: {
+      controls: {
+        sections: [
+          {
+            controls: { sections: control },
+            title: "Fill Sections",
+          },
+        ],
+        title: "Controls",
+      },
+    },
+  };
+}
+
+function createSourceCollection(
+  overrides: Record<string, unknown> = {},
+): ToolcraftControlSchema {
+  return {
+    defaultValue: [{ hex: "#DFFF1A" }],
+    itemControl: { label: false, type: "color" },
+    itemLabel: "Section",
+    label: "Sections",
+    target: "fills.sections",
+    type: "sourceCollection",
+    ...overrides,
+  } as ToolcraftControlSchema;
+}
+
+describe("defineToolcraft source collection", () => {
+  it("accepts a source-owned collection of built-in item controls", () => {
+    const app = defineToolcraft(createAppSchema(createSourceCollection()));
+    const control = app.panels.controls?.sections.find(
+      (section) => section.title === "Fill Sections",
+    )?.controls.sections;
+
+    expect(control?.type).toBe("sourceCollection");
+    expect(control?.itemControl?.type).toBe("color");
+  });
+
+  it("requires source collections to declare their built-in item control", () => {
+    expect(() =>
+      defineToolcraft(
+        createAppSchema(createSourceCollection({ itemControl: undefined })),
+      ),
+    ).toThrow(
+      /Toolcraft control validation \[source-collection-item-control\] for target "fills\.sections": itemControl is required/u,
+    );
+  });
+
+  it("rejects unsupported collection item controls", () => {
+    const control = createSourceCollection({
+      itemControl: { type: "imaginary" },
+    });
+
+    expect(() => defineToolcraft(createAppSchema(control))).toThrow(
+      /Toolcraft control validation \[collection-item-control\] for target "fills\.sections": unsupported collection item control "imaginary"/u,
+    );
+  });
+
+  it("rejects unsupported collectionActions item controls instead of falling back to text", () => {
+    const control = {
+      ...createSourceCollection(),
+      itemControl: { type: "imaginary" },
+      type: "collectionActions",
+    } as unknown as ToolcraftControlSchema;
+
+    expect(() => defineToolcraft(createAppSchema(control))).toThrow(
+      /Toolcraft control validation \[collection-item-control\] for target "fills\.sections": unsupported collection item control "imaginary"/u,
+    );
+  });
+});

package/templates/runtime/schema/runtime-setup-section.ts

@@ -38,6 +38,11 @@ const finiteCanvasCondition = Object.freeze({
   equals: false,
   target: toolcraftCanvasInfinityTarget,
 });
+const alwaysApplicable = Object.freeze({ mode: "always" as const });
+const finiteCanvasApplicability = Object.freeze({
+  all: [finiteCanvasCondition],
+  mode: "conditional" as const,
+});
 
 type RuntimeSetupControlGroup = {
   controls: ToolcraftControlSectionSchema["controls"];
@@ -146,6 +151,7 @@ function createRenderScaleControl(
   }
 
   return {
+    applicability: alwaysApplicable,
     defaultValue: canvas.renderScale.defaultValue,
     description:
       "Increases raster canvas backing resolution without changing the visible output size.",
@@ -175,6 +181,7 @@ function createInfinityCanvasControl(
   }
 
   return {
+    applicability: alwaysApplicable,
     defaultValue: getToolcraftDefaultCanvasMode(canvas) === "infinite",
     ...(background
       ? {
@@ -199,6 +206,7 @@ function createTimelineExtendedControl(
   }
 
   return {
+    applicability: alwaysApplicable,
     defaultValue: false,
     label: "Timeline",
     target: toolcraftTimelinePanelExtendedTarget,
@@ -230,13 +238,23 @@ function createRuntimeSetupBackgroundControls({
   return {
     controls: {
       ...(includeBackgroundControl
-        ? { includeBackground: includeBackgroundControl }
+        ? {
+            includeBackground: {
+              ...includeBackgroundControl,
+              applicability: alwaysApplicable,
+            },
+          }
         : {}),
       ...(infinityCanvasControl
         ? { infinityCanvas: infinityCanvasControl }
         : {}),
       ...(backgroundColorControl
-        ? { background: backgroundColorControl }
+        ? {
+            background: {
+              ...backgroundColorControl,
+              applicability: alwaysApplicable,
+            },
+          }
         : {}),
     },
     layoutGroups:
@@ -262,6 +280,7 @@ function createFiniteCanvasControls(
   return {
     controls: {
       canvasAspectRatio: {
+        applicability: finiteCanvasApplicability,
         defaultValue: getCanvasAspectRatioDefaultValue(canvas.size),
         label: "Aspect ratio",
         orderRole: "input",
@@ -269,9 +288,9 @@ function createFiniteCanvasControls(
         performanceRole: "workload",
         target: canvasAspectRatioTarget,
         type: "aspectRatio",
-        visibleWhen: finiteCanvasCondition,
       },
       canvasWidth: {
+        applicability: finiteCanvasApplicability,
         defaultValue: canvas.size.width,
         label: "Canvas width",
         orderRole: "input",
@@ -279,9 +298,9 @@ function createFiniteCanvasControls(
         performanceRole: "workload",
         target: canvasSizeControlTargets.width,
         type: "text",
-        visibleWhen: finiteCanvasCondition,
       },
       canvasHeight: {
+        applicability: finiteCanvasApplicability,
         defaultValue: canvas.size.height,
         label: "Canvas height",
         orderRole: "input",
@@ -289,7 +308,6 @@ function createFiniteCanvasControls(
         performanceRole: "workload",
         target: canvasSizeControlTargets.height,
         type: "text",
-        visibleWhen: finiteCanvasCondition,
       },
     },
     layoutGroups: [
@@ -325,6 +343,7 @@ export function createToolcraftRuntimeSetupSection({
   const section: ToolcraftControlSectionSchema & { id: string } = {
     controls: {
       settingsTransfer: {
+        applicability: alwaysApplicable,
         label: false,
         target: settingsTransferTarget,
         type: "settingsTransfer",

package/templates/runtime/schema/types.ts

@@ -3,6 +3,7 @@ import type {
   ToolcraftControlLayoutGroupLayout,
   ToolcraftSectionLayout,
 } from "../contracts/types";
+import type { ToolcraftCollectionItemControlType } from "./collection-item-controls";
 
 export type ToolcraftCanvasSize = {
   height: number;
@@ -412,7 +413,7 @@ export type ResolvedToolcraftMediaSchema = {
   defaultAssets: readonly ToolcraftDefaultMediaAssetSchema[];
 };
 
-export type ToolcraftControlConditionSchema = {
+export type ToolcraftControlPredicateSchema = Readonly<{
   equals?: unknown;
   greaterThan?: number;
   greaterThanOrEqual?: number;
@@ -422,7 +423,28 @@ export type ToolcraftControlConditionSchema = {
   notEquals?: unknown;
   oneOf?: readonly unknown[];
   target: string;
-};
+}>;
+
+export type ToolcraftControlConditionSchema =
+  ToolcraftControlPredicateSchema;
+
+export type ToolcraftControlApplicabilitySchema =
+  | Readonly<{ mode: "always" }>
+  | Readonly<{
+      all: readonly ToolcraftControlPredicateSchema[];
+      mode: "conditional";
+    }>;
+
+export type ToolcraftResolvedControlApplicabilitySchema =
+  | Readonly<{
+      mode: "always";
+      origin: "explicit" | "implicit";
+    }>
+  | Readonly<{
+      all: readonly ToolcraftControlPredicateSchema[];
+      mode: "conditional";
+      origin: "explicit" | "legacy";
+    }>;
 
 export type ToolcraftControlDisabledConditionSchema =
   ToolcraftControlConditionSchema;
@@ -434,18 +456,29 @@ export type ToolcraftColorOpacityValueSchema = {
 
 export type ToolcraftCollectionItemControlSchema = {
   commitMode?: "content" | "setting";
+  coordinateMode?: ToolcraftVectorCoordinateMode;
   defaultValue?: unknown;
+  description?: string;
   label?: boolean | string;
   markerCount?: number;
   max?: number;
   min?: number;
   options?: readonly { label: string; value: string }[];
+  performanceReason?: string;
+  performanceRole?: ToolcraftControlPerformanceRole;
+  sliderValueKind?: ToolcraftSliderValueKind;
   step?: number;
-  type: string;
+  type: ToolcraftCollectionItemControlType;
   unit?: string;
   variant?: string;
+  xLabel?: string;
+  yLabel?: string;
 };
 
+export type ToolcraftCollectionItemControlsSchema = Readonly<
+  Record<string, ToolcraftCollectionItemControlSchema>
+>;
+
 export type ToolcraftFontPickerValueSchema = {
   color?: string;
   fontId: string;
@@ -461,7 +494,7 @@ export type ToolcraftCurveInterpolation = "monotone" | "smooth";
 
 export type ToolcraftVectorCoordinateMode = "cartesian" | "screen";
 
-export type ToolcraftControlSchemaBase = {
+type ToolcraftControlSchemaFields = {
   accept?: string;
   actions?: readonly (ToolcraftActionSchema | string)[];
   addLabel?: string;
@@ -476,6 +509,7 @@ export type ToolcraftControlSchemaBase = {
   interpolation?: ToolcraftCurveInterpolation;
   items?: readonly ToolcraftImagePickerItemSchema[];
   itemControl?: ToolcraftCollectionItemControlSchema;
+  itemControls?: ToolcraftCollectionItemControlsSchema;
   itemDefaultValue?: unknown;
   itemLabel?: string;
   keyframeable?: boolean;
@@ -498,11 +532,16 @@ export type ToolcraftControlSchemaBase = {
   unit?: string;
   valueLabel?: string;
   variant?: string;
-  visibleWhen?: ToolcraftControlConditionSchema;
   xLabel?: string;
   yLabel?: string;
 };
 
+export type ToolcraftControlSchemaBase = ToolcraftControlSchemaFields & {
+  applicability?: ToolcraftControlApplicabilitySchema;
+  /** @deprecated Product controls use conditional applicability. */
+  visibleWhen?: ToolcraftControlPredicateSchema;
+};
+
 export type ToolcraftNonModelControlSchema = ToolcraftControlSchemaBase & {
   assetKind?: ToolcraftMediaAssetKind;
   modelFormats?: never;
@@ -525,18 +564,34 @@ export type ToolcraftControlSchema =
   | ToolcraftNonModelControlSchema
   | ToolcraftModelFileDropSchema;
 
+type ToolcraftResolvedControlApplicabilityFields = Readonly<{
+  applicability: ToolcraftResolvedControlApplicabilitySchema;
+}>;
+
+export type ResolvedToolcraftNonModelControlSchema = Omit<
+  ToolcraftNonModelControlSchema,
+  "applicability" | "visibleWhen"
+> &
+  ToolcraftResolvedControlApplicabilityFields;
+
 export type ResolvedToolcraftModelFileDropSchema = Omit<
   ToolcraftModelFileDropSchema,
-  "modelFormats" | "modelLimits" | "multiple" | "topologyProfile"
-> & {
-  modelFormats: readonly ToolcraftModelFormat[];
-  modelLimits: ToolcraftModelImportLimits;
-  multiple: false;
-  topologyProfile: ToolcraftModelTopologyProfile;
-};
+  | "applicability"
+  | "modelFormats"
+  | "modelLimits"
+  | "multiple"
+  | "topologyProfile"
+  | "visibleWhen"
+> &
+  ToolcraftResolvedControlApplicabilityFields & {
+    modelFormats: readonly ToolcraftModelFormat[];
+    modelLimits: ToolcraftModelImportLimits;
+    multiple: false;
+    topologyProfile: ToolcraftModelTopologyProfile;
+  };
 
 export type ResolvedToolcraftControlSchema =
-  | ToolcraftNonModelControlSchema
+  | ResolvedToolcraftNonModelControlSchema
   | ResolvedToolcraftModelFileDropSchema;
 
 export type ToolcraftControlLayoutGroupSchema = {

package/templates/starter/AGENTS.md

@@ -20,10 +20,10 @@ Process matching routes sequentially within the current phase and skip repeated
 
 1. Build through `defineToolcraft` and `ToolcraftApp`.
 2. Keep app state in Toolcraft runtime schema and commands.
-3. Keep product output in `canvasContent`; never render app UI there. The signed host owns `ToolcraftApp`, bootstrap, routes, and global runtime styles; product code supplies only `ToolcraftAppComposition`. Model upload preserves supported authored appearance from standalone files, folders, and bounded ZIP packages; declare typed `modelPresentation`, using runtime presentation by default and checked consumers for custom presentation. `renderDefaultCanvasMedia={false}` never hides runtime model layers. If upload/import is part of the source-material flow, do not invent canvas placeholder artwork, CTA copy, helper text, fake sample output, or preset source designs before real content exists.
-4. Use built-in Toolcraft controls before custom controls. Before controls or canvas interactions, declare typed `interactionOwnership`: user request, inspected reference, or product usability selects one primary surface for each operation; complementary operations may share related state, but canvas and panel must not mirror the same operation. Every product also declares typed `viewInteraction` before renderer code; a visible editable spatial scene defaults to `orbit` and uses schema `orientationGizmo` plus runtime model-orbit interaction. Fixed or timeline-owned cameras require an explicit user request or inspected-reference evidence.
-5. Do not hand-compose runtime surfaces or render built-in control components directly in app code; use `ToolcraftApp`, schema controls, `canvasContent`, `controlRenderers`, `onPanelAction`, and runtime commands.
-6. Before writing controls, make and export `starterControlSectionInventory`: each product controls section declares its title, product entity or workflow stage, targets, and grouping reason. Group by product meaning, not UI component type.
+3. Keep product output in `canvasContent`; never render app UI there. The signed host owns `ToolcraftApp`, bootstrap, routes, global runtime styles, and the finite/infinite product scene surface; product code supplies only `ToolcraftAppComposition`. Infinite custom raster/WebGL output declares `sceneBoundsProvider` and consumes `useToolcraftProductSceneFrame` instead of dormant finite `canvas.size`. A preview-only environment that must fill the complete Infinity viewport uses `infiniteCanvasContent`; it remains pointer-transparent and outside world transforms, scene bounds, and export. Model upload preserves supported authored appearance from standalone files, folders, and bounded ZIP packages; declare typed `modelPresentation`, using runtime presentation by default and checked consumers for custom presentation. `renderDefaultCanvasMedia={false}` never hides runtime model layers. If upload/import is part of the source-material flow, do not invent canvas placeholder artwork, CTA copy, helper text, fake sample output, or preset source designs before real content exists.
+4. Use built-in Toolcraft controls before custom controls. Use `sourceCollection` when a source/runtime workflow owns array cardinality and users edit existing built-in item values; use `collectionActions` when users own add/remove cardinality. Before controls or canvas interactions, declare typed `interactionOwnership`: user request, inspected reference, or product usability selects one primary surface for each operation; complementary operations may share related state, but canvas and panel must not mirror the same operation. Every product also declares typed `viewInteraction` before renderer code; a visible editable spatial scene defaults to `orbit` and uses schema `orientationGizmo` plus runtime model-orbit interaction. Fixed or timeline-owned cameras require an explicit user request or inspected-reference evidence.
+5. Do not hand-compose runtime surfaces or render built-in control components directly in app code; use `ToolcraftApp`, schema controls, `canvasContent`, `controlRenderers`, `onPanelAction`, and runtime commands. Product code never imports modules below `src/toolcraft/ui/components/controls/**` or substitutes native `color`, `range`, `file`, `checkbox`, `radio`, `select`, or `textarea` value models for schema controls. Product artifact surfaces must correspond exactly to required `productReadiness.exportIntent`; use `docs/toolcraft/core/setup-export.md` for the canonical export decision sequence.
+6. Before writing controls, export `starterControlSectionInventory`. Every product section declares stable `entityId`, human-readable `entity`, exact targets, and `groupingReason`. Every product control explicitly declares `applicability` as `always` or `conditional`; inactive branches are absent, and every visible finite sibling branch must prove the control's accepted product outcome. Keep one entity in one section through ten controls; sections with eight to ten controls declare `semanticGroup` on every control. Entities above ten controls split into balanced two-to-ten-control workflow stages that keep the same entity identity and declare unique `workflowStage` plus `splitReason`. Group by product meaning, never by UI component type or target namespace.
 7. Keep control `label` short but semantically sufficient with the nearest visible section/group context, and put product-specific behavior help in schema `description`; runtime renders the label help tooltip only when that description adds meaning beyond the label.
 8. Enable layers and timeline only when product behavior requires them, then test the real UI. Product animation loops are seamless forward-only by default: first and last frames stitch, direction does not reverse, and mirror/yoyo/ping-pong behavior requires explicit user intent.
 9. Animated preview renderers suspend or coalesce non-essential animation work during canvas drag, pan, pinch, zoom, and radar/center interactions, then resume without changing user playback state.
@@ -33,7 +33,7 @@ Process matching routes sequentially within the current phase and skip repeated
 13. Generated apps follow the mandatory runtime Setup, Infinity canvas/finite canvas sizing, render scale, Timeline switch, Background, Image Export, Video Export, and sticky action rules in `docs/toolcraft/core/setup-export.md`. Do not duplicate or reinterpret those controls in app-authored sections.
 14. Media uploads, image/file mode, source images, multi-upload sorting, default assets, and image transform actions follow `docs/toolcraft/core/media-upload.md`.
 15. Keep `docs/toolcraft/agent-worklog.md` current with a decision trail, product decisions, explicit reference inputs, evidence, verification, and risks. Reference-runtime-clone apps also declare `referenceStudy` plus `referenceFeatureInventory` so every inspected reference feature has feature-level behavior evidence and maps to Toolcraft implementation and acceptance coverage.
-16. Prove every visible entity through acceptance, browser, and performance coverage. Browser acceptance and performance pass only when protected helpers emit matching runtime evidence after successful assertions; source-code spelling and acceptance prose are not outcome authority. Declare typed conditional-visibility and background-output coverage, then use their fixed protected browser recipes. Raster products with `canvas.renderScale` declare `renderScaleCoverage` for interaction and steady state, plus playback when timeline is enabled, and prove real backing pixels with `canvas-render-scale-backing`; clamping quality is a functional failure without measured performance. Every measured path in a render-scale-enabled raster product proves actual CSS × devicePixelRatio × 2 backing after each measured phase. Generic acceptance outcomes prove command side effects only; use the fixed media, persistence, viewport, compound-control, layer, and timeline semantic recipes for specialized evidence.
+16. Prove every visible entity through acceptance, browser, and performance coverage. Browser acceptance and performance pass only when protected helpers emit matching runtime evidence after successful assertions; source-code spelling and acceptance prose are not outcome authority. Control applicability derives case-scoped presence/absence and product-outcome evidence from semantic section peers; background output keeps its fixed typed recipe. Raster products with `canvas.renderScale` declare `renderScaleCoverage` for interaction and steady state, plus playback when timeline is enabled, and prove real backing pixels with `canvas-render-scale-backing`; clamping quality is a functional failure without measured performance. Every measured path in a render-scale-enabled raster product proves actual CSS × devicePixelRatio × 2 backing after each measured phase. Generic acceptance outcomes prove command side effects only; use the fixed media, persistence, viewport, compound-control, layer, and timeline semantic recipes for specialized evidence.
 17. Performance planning follows one sequence: reachable controls and inputs; workload dimensions and enforced boundaries; pass cost, frequency, lifecycle, and invalidation; render-plan assessment and protected kernel benchmark when required; derived paths and combined fixtures; targeted functional/browser development checks; lifecycle-appropriate delivery proof. Keep `src/app/app-verification-impact.json` complete so later functional changes derive exact verification scope. Only exact request authority may create a measured targeted performance iteration. Details live in `docs/toolcraft/core/performance.md` and `docs/toolcraft/performance.md`.
 18. Custom renderer apps compile one canonical `rendererPipelineRegistration`, supply it through `ToolcraftAppComposition`, reuse that registration as `rendererPipeline` in performance assessment, and derive paths and fixtures from it. The neutral starter has no registration, runtime provider, or fixture adapters.
 19. Classify each coherent user-visible delivery batch with a verification tier before editing. Steering and fixes inside the same request stay in that batch. Use targeted checks for development feedback, then run the protected delivery gate once when the batch is ready.
@@ -42,7 +42,7 @@ Process matching routes sequentially within the current phase and skip repeated
 
 The generated folder starts as a neutral Toolcraft shell: canvas upload plus toolbar. It intentionally does not include demo controls, prompt fields, layers, or timeline. Do not treat test fixtures or documentation examples as product requirements. Add controls, timeline, layers, sticky actions, and custom renderers only after the requested product or reference app requires them; base workspace persistence already exists.
 
-When the folder becomes a real product, update `src/app/app-acceptance-data.ts` from `appProductReadiness.mode: "starter"` to `mode: "product"` and fill `productName`, `productSummary`, `requestedBehavior`, typed `interactionOwnership`, and typed `viewInteraction`. Compare canvas and panel for each operation that could plausibly live on either surface. A visible editable 3D scene uses `orbit`; `fixed-camera` and `timeline-camera` require explicit request/reference evidence. Renamed product folders are not allowed to keep neutral starter readiness.
+When the folder becomes a real product, update `src/app/app-acceptance-data.ts` from `appProductReadiness.mode: "starter"` to `mode: "product"` and fill `productName`, `productSummary`, `requestedBehavior`, required typed `exportIntent`, typed `interactionOwnership`, and typed `viewInteraction`. Compare canvas and panel for each operation that could plausibly live on either surface. A visible editable 3D scene uses `orbit`; `fixed-camera` and `timeline-camera` require explicit request/reference evidence. Renamed product folders are not allowed to keep neutral starter readiness.
 
 ## License
 
@@ -119,9 +119,10 @@ These ids mirror `TOOLCRAFT_DECISION_CONTRACT` in `@/toolcraft/runtime`. Keep th
 
 - Use `defineToolcraft` from `@/toolcraft/runtime`.
 - Export an `appComposition` satisfying `ToolcraftAppComposition` from `src/app/app-composition.tsx`.
-- Keep product composition limited to `schema`, `canvasContent`, `controlRenderers`, `exportRenderer`, `modelPresentation`, `onPanelAction`, `renderDefaultCanvasMedia`, and optional `rendererPipelineRegistration`; host `className` and `style` are not product extension points.
+- Keep product composition limited to `schema`, `canvasContent`, `infiniteCanvasContent`, `controlRenderers`, `exportRenderer`, `sceneBoundsProvider`, `modelPresentation`, `onPanelAction`, `renderDefaultCanvasMedia`, and optional `rendererPipelineRegistration`; host `className` and `style` are not product extension points.
+- Infinite product output fills the runtime-owned scene surface derived from `sceneBoundsProvider`. Raster/WebGL renderers call `useToolcraftProductSceneFrame` for backing size and coordinate translation; they never position a second bounds wrapper or use dormant finite `canvas.size` while infinite.
 - Custom renderers use one compiled `rendererPipelineRegistration` as the canonical declaration for runtime execution and new-envelope performance assessment. Product code receives only the disposal-free pipeline client through hooks and panel action context.
-- Do not import `ToolcraftApp`, low-level runtime surfaces, or built-in controls into product modules. The signed host renders the shell; product modules use schema controls and supported composition fields.
+- Do not import `ToolcraftApp`, low-level runtime surfaces, built-in controls, or modules below `src/toolcraft/ui/components/controls/**` into product modules. Do not recreate schema control value models with native form elements. The signed host renders the shell; product modules use schema controls and supported composition fields.
 - Use `renderDefaultCanvasMedia={false}` when a custom renderer replaces generic image/file preview. This flag does not suppress runtime model layers; use typed `modelPresentation` custom mode with checked consumers for declared model targets.
 - Use `ToolcraftApp onPanelAction` for non-export sticky footer product actions such as Generate, Apply, Copy, or Download. Typed `export-image` and `export-video` actions are executed by the runtime from the shared `ToolcraftAppComposition.exportRenderer`.
 - Product export renderers draw one deterministic scene-coordinate frame and return/await their real work. Product modules never allocate export canvases, choose encoders, encode blobs, create download URLs, or duplicate image/video composition.
@@ -203,10 +204,11 @@ The app is complete only when:
 - the Toolcraft runtime shell is present;
 - `canvasContent` contains product output only;
 - the runtime canvas backing remains visible behind product output;
-- every visible control affects runtime state and product output or a command side effect;
+- infinite product output uses the runtime-owned product scene surface, exact provider bounds, and real edge-pixel proof without clipping to dormant finite `canvas.size`;
+- every product control declares explicit applicability, every non-matching finite branch hides it, and every visible finite branch proves product output or the accepted command side effect;
 - reset returns schema controls to `defaultValue`;
 - sticky footer export actions operate on final product output at `state.canvas.size`;
-- every product exposes Export PNG; products whose requested delivery includes animation also expose Export Video;
+- artifact actions and settings correspond exactly to `productReadiness.exportIntent`; image export is the product default, video requires explicit user-request evidence, and image removal requires explicit user-removal evidence;
 - PNG export uses the background controls normalized into runtime Setup: `Background` beside `Infinity canvas`, then `Background color`; live preview hides product background when Background is off, and video keeps background;
 - every PNG export includes `Image Export` format/resolution `select` controls; runtime resolves the selected settings and exact output size;
 - products with both PNG and video export place `Image Export` immediately before `Video Export`;