@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/runtime/schema/define-toolcraft.file-drop-normalization.test.ts

@@ -90,6 +90,33 @@ describe("defineToolcraft fileDrop normalization", () => {
     expect(getSourceControl(app)?.hardMaxItems).toBe(0);
   });
 
+  it("accepts collection actions for a multiple file-kind fileDrop", () => {
+    const app = defineToolcraft(
+      createFileDropSchema({
+        assetKind: "file",
+        multiple: true,
+        variant: "collection-actions",
+      }),
+    );
+
+    expect(getSourceControl(app)?.variant).toBe("collection-actions");
+  });
+
+  it.each([
+    ["a single fileDrop", { assetKind: "file" }],
+    ["an image fileDrop", { assetKind: "image", multiple: true }],
+    ["a model fileDrop", { assetKind: "model", multiple: false }],
+  ])("rejects collection actions on %s", (_label, fields) => {
+    expect(() =>
+      defineToolcraft(
+        createFileDropSchema({
+          ...fields,
+          variant: "collection-actions",
+        }),
+      ),
+    ).toThrow(/\[filedrop-collection-actions\].*assetKind: "file".*multiple: true/u);
+  });
+
   it("accepts model fileDrops", () => {
     const createModelApp = () =>
       defineToolcraft(createFileDropSchema({ assetKind: "model" }));

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-background.test.ts

@@ -118,7 +118,7 @@ describe("defineToolcraft runtime setup background controls", () => {
 
   it("keeps the normalized background pair when a resolved schema is defined again", () => {
     const first = defineToolcraft(createBackgroundSchema());
-    const second = defineToolcraft(first);
+    const second = defineToolcraft(first as unknown as ToolcraftAppSchema);
     const setupSection = second.panels.controls?.sections[0];
 
     expect(second.panels.controls?.sections.map((section) => section.title)).toEqual([

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.setup-render-scale-timeline.test.ts

@@ -1,6 +1,40 @@
 import { describe, expect, it } from "vitest";
 
 import { defineToolcraft } from "./define-toolcraft";
+import type { ToolcraftCanvasRenderScaleSchema } from "./types";
+
+const authoredRenderScaleStep: ToolcraftCanvasRenderScaleSchema = { step: 0.5 };
+const authoredRenderScaleDefaultValue = { defaultValue: 1, step: 0.5 };
+const authoredRenderScaleEnabled = { enabled: true, step: 0.5 };
+const authoredRenderScaleMax = { max: 1, step: 0.5 };
+const authoredRenderScaleMin = { min: 1, step: 0.5 };
+
+// @ts-expect-error Authored render scale cannot select its resolved default value.
+const authoredRenderScaleDefaultValueAssignment: ToolcraftCanvasRenderScaleSchema =
+  authoredRenderScaleDefaultValue;
+
+// @ts-expect-error Authored render scale is always enabled when provided.
+const authoredRenderScaleEnabledAssignment: ToolcraftCanvasRenderScaleSchema = {
+  ...authoredRenderScaleEnabled,
+};
+
+// @ts-expect-error Authored render scale cannot change the canonical maximum.
+const authoredRenderScaleMaxAssignment: ToolcraftCanvasRenderScaleSchema = authoredRenderScaleMax;
+
+// @ts-expect-error Authored render scale cannot change the canonical minimum.
+const authoredRenderScaleMinAssignment: ToolcraftCanvasRenderScaleSchema = {
+  ...authoredRenderScaleMin,
+};
+
+void authoredRenderScaleStep;
+void authoredRenderScaleDefaultValue;
+void authoredRenderScaleEnabled;
+void authoredRenderScaleMax;
+void authoredRenderScaleMin;
+void authoredRenderScaleDefaultValueAssignment;
+void authoredRenderScaleEnabledAssignment;
+void authoredRenderScaleMaxAssignment;
+void authoredRenderScaleMinAssignment;
 
 describe("defineToolcraft runtime setup render scale and timeline controls", () => {
   it("appends raster render scale to the technical setup controls when enabled", () => {
@@ -95,11 +129,11 @@ describe("defineToolcraft runtime setup render scale and timeline controls", ()
     ]);
   });
 
-  it("keeps timeline standalone with render scale for fixed output sizing", () => {
+  it("uses the canonical authored raster scale with a custom step", () => {
     const app = defineToolcraft({
       canvas: {
         enabled: true,
-        renderScale: { defaultValue: 1.5 },
+        renderScale: { step: 0.5 },
         size: { height: 900, unit: "px", width: 1440 },
         sizing: { mode: "fixed-output" },
       },
@@ -120,10 +154,20 @@ describe("defineToolcraft runtime setup render scale and timeline controls", ()
       "timelineExtended",
     ]);
     expect(setupSection?.controls.canvasRenderScale).toMatchObject({
-      defaultValue: 1.5,
+      defaultValue: 2,
+      max: 2,
+      min: 1,
+      step: 0.5,
       target: "canvas.renderScale",
       type: "slider",
     });
+    expect(app.canvas.renderScale).toEqual({
+      defaultValue: 2,
+      enabled: true,
+      max: 2,
+      min: 1,
+      step: 0.5,
+    });
     expect(setupSection?.controls.timelineExtended).toMatchObject({
       defaultValue: false,
       label: "Timeline",
@@ -133,4 +177,28 @@ describe("defineToolcraft runtime setup render scale and timeline controls", ()
     expect(setupSection?.controls.timelineExtended).not.toHaveProperty("description");
     expect(setupSection?.layoutGroups ?? []).toEqual([]);
   });
+
+  it("rejects an authored step that cannot reach the canonical maximum", () => {
+    expect(() =>
+      defineToolcraft({
+        canvas: {
+          enabled: true,
+          renderScale: { step: 0.3 },
+        },
+        panels: {},
+      }),
+    ).toThrow("Canvas render scale step must divide the canonical range exactly.");
+  });
+
+  it.each([0, Number.NaN])("rejects invalid authored step %s", (step) => {
+    expect(() =>
+      defineToolcraft({
+        canvas: {
+          enabled: true,
+          renderScale: { step },
+        },
+        panels: {},
+      }),
+    ).toThrow("Canvas render scale step must be a finite value between 0.01 and 1.");
+  });
 });

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/define-toolcraft.ts

@@ -1,12 +1,12 @@
 import { createToolcraftAssemblyContract } from "./assembly-contract";
 import { resolveToolcraftAppCapabilities } from "./app-capabilities";
 import { resolveToolcraftAppIdentity } from "./app-identity";
+import { resolveToolcraftCanvasRenderScale } from "./canvas-render-scale";
 import { normalizeToolcraftPanels } from "./panels-schema-normalization";
 import { resolveToolcraftPersistencePlan } from "./persistence-plan";
 import { resolveToolcraftSettingsTransfer } from "./runtime-setup-section";
 import {
   defaultToolcraftCanvasSize,
-  resolveToolcraftCanvasRenderScale,
   resolveToolcraftCanvasSizing,
   resolveToolcraftExport,
   resolveToolcraftMedia,

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/schema-resolvers.ts

@@ -18,14 +18,6 @@ export const defaultToolcraftCanvasSize = {
   width: 1920,
 } satisfies ToolcraftCanvasSize;
 
-const defaultCanvasRenderScale = {
-  defaultValue: 2,
-  enabled: false,
-  max: 2,
-  min: 1,
-  step: 0.25,
-} satisfies ResolvedToolcraftAppSchema["canvas"]["renderScale"];
-
 export function resolveToolcraftCanvasSizing(
   canvas: ToolcraftAppSchema["canvas"],
 ): ToolcraftCanvasSizingSchema {
@@ -44,54 +36,6 @@ export function resolveToolcraftCanvasSizing(
   return { mode: "intrinsic-media" };
 }
 
-function clampCanvasRenderScale(value: number | undefined, fallback: number): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return fallback;
-  }
-
-  return Math.max(1, Math.min(2, value));
-}
-
-export function resolveToolcraftCanvasRenderScale(
-  renderScale: ToolcraftAppSchema["canvas"]["renderScale"],
-): ResolvedToolcraftAppSchema["canvas"]["renderScale"] {
-  if (renderScale === true) {
-    return {
-      ...defaultCanvasRenderScale,
-      enabled: true,
-    };
-  }
-
-  if (!renderScale) {
-    return defaultCanvasRenderScale;
-  }
-
-  const min = clampCanvasRenderScale(renderScale.min, defaultCanvasRenderScale.min);
-  const max = Math.max(
-    min,
-    clampCanvasRenderScale(renderScale.max, defaultCanvasRenderScale.max),
-  );
-  const step =
-    typeof renderScale.step === "number" && Number.isFinite(renderScale.step)
-      ? Math.max(0.01, Math.min(1, renderScale.step))
-      : defaultCanvasRenderScale.step;
-  const defaultValue = Math.max(
-    min,
-    Math.min(
-      max,
-      clampCanvasRenderScale(renderScale.defaultValue, defaultCanvasRenderScale.defaultValue),
-    ),
-  );
-
-  return {
-    defaultValue,
-    enabled: renderScale.enabled ?? true,
-    max,
-    min,
-    step,
-  };
-}
-
 export function resolveToolcraftExport(
   exportSchema: ToolcraftAppSchema["export"],
 ): ResolvedToolcraftAppSchema["export"] {

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;
@@ -40,10 +41,10 @@ export type ToolcraftCanvasSizingSchema =
 export type ToolcraftCanvasRenderScaleSchema =
   | boolean
   | {
-      defaultValue?: number;
-      enabled?: boolean;
-      max?: number;
-      min?: number;
+      defaultValue?: never;
+      enabled?: never;
+      max?: never;
+      min?: never;
       step?: 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 = {