@pixel-point/toolcraft 0.0.2

package/templates/runtime/contracts/decision-contracts.test.ts

@@ -0,0 +1,206 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  getToolcraftDecisionRule,
+  getToolcraftDecisionRulesByArea,
+  TOOLCRAFT_DECISION_CONTRACT,
+} from "./decision-contracts";
+
+const contractsDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(contractsDir, "../../../..");
+
+function readRepoFile(pathFromRoot: string): string {
+  return readFileSync(resolve(repoRoot, pathFromRoot), "utf8");
+}
+
+describe("Toolcraft template decision contract", () => {
+  it("classifies every rule by level, verdict, and enforcement", () => {
+    expect(TOOLCRAFT_DECISION_CONTRACT.length).toBeGreaterThanOrEqual(12);
+
+    for (const rule of TOOLCRAFT_DECISION_CONTRACT) {
+      expect(rule.id).toMatch(/^[a-z0-9-]+$/);
+      expect(rule.area).toMatch(
+        /^(runtime-shell|canvas|panels|layers|timeline|controls|renderer|reference-clone|acceptance|performance|persistence|workflow)$/,
+      );
+      expect(rule.title.trim().length).toBeGreaterThan(0);
+      expect(rule.currentConstraint.trim().length).toBeGreaterThan(0);
+      expect(rule.desiredBehavior.trim().length).toBeGreaterThan(0);
+      expect(rule.enforcement.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("keeps canvas app UI out of canvasContent as an invariant", () => {
+    const rule = getToolcraftDecisionRule("canvas-no-app-ui");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.verdict).toBe("move-to-validator");
+    expect(rule?.enforcement).toContain("browser-helper");
+    expect(rule?.desiredBehavior).toMatch(/product result/i);
+  });
+
+  it("keeps runtime shell bypass prevention in validators, not only docs", () => {
+    const rule = getToolcraftDecisionRule("runtime-shell-required");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/schema controls/i);
+    expect(rule?.desiredBehavior).toMatch(/canvasContent/i);
+    expect(rule?.desiredBehavior).toMatch(/controlRenderers/i);
+    expect(rule?.desiredBehavior).toMatch(/onPanelAction/i);
+    expect(rule?.desiredBehavior).toMatch(/low-level runtime surfaces/i);
+    expect(rule?.desiredBehavior).toMatch(/built-in control components directly/i);
+    expect(rule?.enforcement).toContain("cli-integrity-check");
+    expect(rule?.enforcement).toContain("acceptance-validator");
+  });
+
+  it("keeps layers and timeline as heuristics until enabled", () => {
+    expect(getToolcraftDecisionRule("layers-enable-only-when-needed")?.level).toBe(
+      "heuristic",
+    );
+    expect(getToolcraftDecisionRule("layers-enabled-behavior")?.level).toBe(
+      "invariant",
+    );
+    expect(getToolcraftDecisionRule("timeline-mode-choice")?.level).toBe("heuristic");
+    expect(getToolcraftDecisionRule("timeline-mode-choice")?.desiredBehavior).toMatch(
+      /Animation Intent Inventory/,
+    );
+    expect(getToolcraftDecisionRule("timeline-enabled-behavior")?.level).toBe(
+      "invariant",
+    );
+  });
+
+  it("makes renderer technology a default with escape hatches", () => {
+    const rule = getToolcraftDecisionRule("renderer-technique-inventory");
+
+    expect(rule?.level).toBe("default");
+    expect(rule?.desiredBehavior).toMatch(/product output semantics/i);
+    expect(rule?.enforcement).toContain("performance-validator");
+  });
+
+  it("splits performance into workload and lightweight responsiveness coverage", () => {
+    const rule = getToolcraftDecisionRule("performance-coverage-levels");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/workload/i);
+    expect(rule?.desiredBehavior).toMatch(/responsiveness/i);
+    expect(rule?.desiredBehavior).toMatch(/canvas drag, pan, pinch, zoom, and radar\/center/i);
+    expect(rule?.desiredBehavior).toMatch(/playback state/i);
+    expect(rule?.desiredBehavior).toMatch(/first working version/i);
+    expect(rule?.desiredBehavior).toMatch(/renderer\/canvas\/animation\/export\/timeline\/layers/i);
+    expect(rule?.desiredBehavior).toMatch(/bug that previously broke functionality/i);
+    expect(rule?.desiredBehavior).toMatch(/optimize performance/i);
+    expect(rule?.desiredBehavior).toMatch(/full performance checkpoint/i);
+  });
+
+  it("requires persistence reload coverage when localStorage is enabled", () => {
+    const rule = getToolcraftDecisionRule("persistence-policy-explicit");
+
+    expect(rule?.desiredBehavior).toMatch(/localStorage persistence/i);
+    expect(rule?.desiredBehavior).toMatch(/reloading the page/i);
+    expect(rule?.desiredBehavior).toMatch(/settings import\/export is not a substitute/i);
+    expect(rule?.enforcement).toContain("acceptance-validator");
+    expect(rule?.enforcement).toContain("browser-helper");
+  });
+
+  it("groups rules by area", () => {
+    expect(getToolcraftDecisionRulesByArea("canvas").map((rule) => rule.id)).toContain(
+      "canvas-no-app-ui",
+    );
+  });
+
+  it("uses neutral workflow rule ids in public contract data", () => {
+    const legacyWorkflowRuleId = ["ai", "workflow", "required"].join("-");
+
+    expect(getToolcraftDecisionRule("workflow-required")?.area).toBe("workflow");
+    expect(getToolcraftDecisionRule(legacyWorkflowRuleId)).toBeUndefined();
+  });
+
+  it("keeps public docs, local docs, and app assembly instructions synced with rule ids", () => {
+    const docsSource = readRepoFile(
+      "apps/website/src/content/docs/toolcraft-decision-contract.md",
+    );
+    const rootAgentsSource = readRepoFile("AGENTS.md");
+    const starterAgentsSource = readRepoFile("starter/AGENTS.md");
+    const starterDecisionSource = readRepoFile("starter/docs/toolcraft/decision-contract.md");
+    const starterDocsCheckSource = readRepoFile("starter/scripts/check-toolcraft-docs.mjs");
+
+    for (const rule of TOOLCRAFT_DECISION_CONTRACT) {
+      expect(docsSource, `Docs page must list decision rule "${rule.id}".`).toContain(rule.id);
+      expect(rootAgentsSource, `Root AGENTS.md must list decision rule "${rule.id}".`).toContain(
+        rule.id,
+      );
+      expect(
+        starterAgentsSource,
+        `Starter AGENTS.md must list decision rule "${rule.id}" for generated apps.`,
+      ).toContain(rule.id);
+      expect(
+        starterDecisionSource,
+        `Starter local decision docs must list decision rule "${rule.id}".`,
+      ).toContain(rule.id);
+      expect(
+        starterDocsCheckSource,
+        `Starter docs check must enforce decision rule "${rule.id}".`,
+      ).toContain(rule.id);
+    }
+  });
+
+  it("keeps root AGENTS.md as a concise entry map instead of duplicated rule prose", () => {
+    const rootAgentsSource = readRepoFile("AGENTS.md");
+    const rootAgentsLines = rootAgentsSource.trim().split(/\r?\n/);
+    const forbiddenDuplicatedSectionHeadings = [
+      "Reference Runtime Clone Mode",
+      "Always-On Canvas Capabilities",
+      "Optional Surfaces",
+      "Panel Rules",
+      "Control Rules",
+      "App Completion Bar",
+    ];
+    const requiredEntryMapRefs = [
+      "starter/docs/toolcraft/assembly-workflow.md",
+      "starter/docs/toolcraft/decision-contract.md",
+      "starter/docs/toolcraft/schema-reference.md",
+      "starter/docs/toolcraft/component-rules.md",
+      "starter/docs/toolcraft/acceptance-testing.md",
+      "starter/docs/toolcraft/performance.md",
+      "starter/docs/toolcraft/renderer-technique.md",
+      "starter/docs/toolcraft/custom-controls.md",
+      "packages/toolcraft-runtime/src/contracts/decision-contracts.ts",
+      "packages/toolcraft-runtime/src/contracts/component-contracts.ts",
+    ];
+
+    expect(rootAgentsLines.length).toBeLessThanOrEqual(180);
+    expect(rootAgentsSource).toContain("## Quick Entry Contract");
+    expect(rootAgentsSource).toContain("## Detailed References");
+
+    for (const heading of forbiddenDuplicatedSectionHeadings) {
+      expect(rootAgentsSource, `Root AGENTS.md should link out instead of duplicating "${heading}".`).not.toContain(
+        `## ${heading}`,
+      );
+    }
+
+    for (const ref of requiredEntryMapRefs) {
+      expect(rootAgentsSource, `Root AGENTS.md should link to "${ref}".`).toContain(ref);
+    }
+  });
+
+  it("keeps required local Toolcraft docs available for generated apps", () => {
+    const requiredLocalDocs = [
+      "README.md",
+      "assembly-workflow.md",
+      "decision-contract.md",
+      "schema-reference.md",
+      "acceptance-testing.md",
+      "performance.md",
+      "renderer-technique.md",
+      "custom-controls.md",
+      "component-rules.md",
+    ];
+
+    for (const docName of requiredLocalDocs) {
+      expect(() => readRepoFile(`starter/docs/toolcraft/${docName}`)).not.toThrow();
+    }
+  });
+});

package/templates/runtime/contracts/decision-contracts.ts

@@ -0,0 +1,283 @@
+export type ToolcraftDecisionArea =
+  | "acceptance"
+  | "canvas"
+  | "controls"
+  | "layers"
+  | "panels"
+  | "performance"
+  | "persistence"
+  | "reference-clone"
+  | "renderer"
+  | "runtime-shell"
+  | "timeline"
+  | "workflow";
+
+export type ToolcraftDecisionRuleLevel =
+  | "default"
+  | "escape-hatch"
+  | "heuristic"
+  | "invariant"
+  | "recommendation";
+
+export type ToolcraftDecisionVerdict =
+  | "keep-hard"
+  | "keep-but-clarify"
+  | "move-to-validator"
+  | "relax-to-heuristic"
+  | "remove-duplicate";
+
+export type ToolcraftDecisionEnforcement =
+  | "acceptance-validator"
+  | "browser-helper"
+  | "cli-integrity-check"
+  | "docs"
+  | "performance-validator"
+  | "runtime"
+  | "schema-normalization"
+  | "spec-checklist"
+  | "starter-agents";
+
+export type ToolcraftDecisionRule = {
+  area: ToolcraftDecisionArea;
+  currentConstraint: string;
+  desiredBehavior: string;
+  enforcement: readonly ToolcraftDecisionEnforcement[];
+  id: string;
+  level: ToolcraftDecisionRuleLevel;
+  title: string;
+  verdict: ToolcraftDecisionVerdict;
+};
+
+export const TOOLCRAFT_DECISION_CONTRACT = [
+  {
+    area: "runtime-shell",
+    currentConstraint: "Apps must assemble through defineToolcraft and ToolcraftApp.",
+    desiredBehavior:
+      "Generated apps use the Toolcraft runtime shell and keep product-specific rendering inside supported extension points: schema controls, canvasContent product output, controlRenderers for true custom controls, ToolcraftApp onPanelAction, and runtime commands. App-specific code must not import or render low-level runtime surfaces or built-in control components directly.",
+    enforcement: [
+      "cli-integrity-check",
+      "acceptance-validator",
+      "starter-agents",
+      "spec-checklist",
+    ],
+    id: "runtime-shell-required",
+    level: "invariant",
+    title: "Toolcraft runtime shell is required",
+    verdict: "keep-hard",
+  },
+  {
+    area: "canvas",
+    currentConstraint:
+      "canvasContent must not contain buttons, forms, CTAs, helper text, upload prompts, menus, or settings UI.",
+    desiredBehavior:
+      "Canvas renders only product result, source material, renderer output, and valid product editing handles.",
+    enforcement: ["browser-helper", "starter-agents", "spec-checklist"],
+    id: "canvas-no-app-ui",
+    level: "invariant",
+    title: "Canvas contains product output, not app UI",
+    verdict: "move-to-validator",
+  },
+  {
+    area: "canvas",
+    currentConstraint:
+      "The Toolcraft canvas shell owns the visible workspace backing behind product output.",
+    desiredBehavior:
+      "Generated apps preserve the runtime canvas surface and do not replace, hide, or make the shell backing transparent when product renderers customize their own background.",
+    enforcement: ["browser-helper", "starter-agents", "spec-checklist"],
+    id: "canvas-surface-preserved",
+    level: "invariant",
+    title: "Canvas backing stays runtime-owned",
+    verdict: "move-to-validator",
+  },
+  {
+    area: "canvas",
+    currentConstraint:
+      "Product editing handles may live on the canvas when they manipulate visible product geometry.",
+    desiredBehavior:
+      "AI chooses canvas handles only for direct geometry or parameter manipulation and keeps handles tokenized, textless, export-excluded, and runtime-bound.",
+    enforcement: ["browser-helper", "acceptance-validator", "spec-checklist"],
+    id: "canvas-handle-placement",
+    level: "heuristic",
+    title: "Canvas handle placement is product-dependent",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "panels",
+    currentConstraint: "PanelHost owns drag, snap, and double-click reset behavior.",
+    desiredBehavior:
+      "Any rendered application panel preserves runtime panel mechanics and does not recreate panel dragging locally.",
+    enforcement: ["runtime", "browser-helper", "starter-agents"],
+    id: "panel-host-behavior",
+    level: "invariant",
+    title: "Panel mechanics stay runtime-owned",
+    verdict: "keep-hard",
+  },
+  {
+    area: "layers",
+    currentConstraint:
+      "Layers are optional and should appear only for multiple editable entities, grouping, visibility, selection, or reorder workflows.",
+    desiredBehavior:
+      "AI decides whether the product needs layers; single-layer apps do not render a layers panel.",
+    enforcement: ["starter-agents", "spec-checklist"],
+    id: "layers-enable-only-when-needed",
+    level: "heuristic",
+    title: "Layer enablement is product-dependent",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "layers",
+    currentConstraint:
+      "Once layers are enabled, selection, visibility, reorder, grouping, media lifecycle, and selected-layer controls must work through the real LayersPanel UI.",
+    desiredBehavior:
+      "Layer-enabled apps prove real layer interactions and product output changes instead of dispatching layer commands directly in browser tests.",
+    enforcement: ["acceptance-validator", "browser-helper", "performance-validator"],
+    id: "layers-enabled-behavior",
+    level: "invariant",
+    title: "Enabled layers must fully work",
+    verdict: "keep-hard",
+  },
+  {
+    area: "timeline",
+    currentConstraint:
+      "Timeline is optional, but animated products must first classify animation intent as product transport, editable keyframes, custom reference timeline, or autonomous decorative output.",
+    desiredBehavior:
+      "AI writes an Animation Intent Inventory before choosing no timeline, playback, keyframes, or custom reference timeline; user-requested product animation defaults to playback unless explicitly justified as autonomous output.",
+    enforcement: ["starter-agents", "spec-checklist"],
+    id: "timeline-mode-choice",
+    level: "heuristic",
+    title: "Timeline mode is chosen from behavior",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "timeline",
+    currentConstraint:
+      "Enabled timeline modes must control renderer time, pause, scrub, duration, loop, and keyframe evaluation where relevant.",
+    desiredBehavior:
+      "Playback and keyframe apps prove runtime timeline state controls visible and exported output, and renderer cycle duration follows state.timeline.durationSeconds.",
+    enforcement: ["acceptance-validator", "browser-helper", "performance-validator"],
+    id: "timeline-enabled-behavior",
+    level: "invariant",
+    title: "Enabled timelines must drive output",
+    verdict: "keep-hard",
+  },
+  {
+    area: "controls",
+    currentConstraint:
+      "Every visible schema control must bind to runtime state, reset from schema defaults, and have acceptance and browser coverage.",
+    desiredBehavior:
+      "Controls are not decorative; each visible control proves its product responsibility through runtime and output observables.",
+    enforcement: ["acceptance-validator", "browser-helper"],
+    id: "controls-product-coverage",
+    level: "invariant",
+    title: "Visible controls must affect the product",
+    verdict: "keep-hard",
+  },
+  {
+    area: "controls",
+    currentConstraint:
+      "Product-output apps expose final output delivery through sticky footer panelActions.",
+    desiredBehavior:
+      "Static products include Export PNG; animated products include Export Video and Export PNG. Copy can be secondary, but it does not replace export. Product apps expose Background and Include background controls; standard export helpers own runtime PNG transparency and retina dimensions, while live preview, workspace canvas backing, and video keep the background.",
+    enforcement: ["acceptance-validator", "performance-validator", "browser-helper", "starter-agents"],
+    id: "output-export-required",
+    level: "invariant",
+    title: "Product output always has export",
+    verdict: "move-to-validator",
+  },
+  {
+    area: "controls",
+    currentConstraint:
+      "Labels, color placement, section grouping, selector order, and inline density need product-aware decisions.",
+    desiredBehavior:
+      "Apps define a Control Section Inventory before schema authoring: every controls section has a product entity or workflow stage, related targets stay together, and sections are not named after UI component types.",
+    enforcement: ["acceptance-validator", "schema-normalization", "docs", "starter-agents"],
+    id: "controls-layout-heuristics",
+    level: "heuristic",
+    title: "Control layout remains product-aware",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "renderer",
+    currentConstraint:
+      "Custom renderers must declare rendererTechnique and rendererTechnique.layers when product output uses semantic layers or mixed rendering.",
+    desiredBehavior:
+      "AI chooses rendering technology from product output semantics, fidelity, reference behavior, and performance, then proves that choice in typed config and browser tests.",
+    enforcement: ["performance-validator", "browser-helper", "spec-checklist"],
+    id: "renderer-technique-inventory",
+    level: "default",
+    title: "Renderer technique is a typed decision",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "reference-clone",
+    currentConstraint:
+      "Reference-runtime-clone mode preserves the reference runtime as source of truth unless a redesign is explicit.",
+    desiredBehavior:
+      "Ported apps keep reference loops, mutable state, transport semantics, media lifecycle, and export behavior before Toolcraft refinements.",
+    enforcement: ["acceptance-validator", "browser-helper", "starter-agents"],
+    id: "reference-clone-source-of-truth",
+    level: "invariant",
+    title: "Reference clone preserves behavior",
+    verdict: "keep-hard",
+  },
+  {
+    area: "acceptance",
+    currentConstraint:
+      "Acceptance coverage must prove product responsibility, not only typecheck, component existence, runtime mutation, or shader uniform presence.",
+    desiredBehavior:
+      "Generated apps fail when a visible entity is disconnected from runtime state, product output, export output, or command side effects.",
+    enforcement: ["acceptance-validator", "browser-helper"],
+    id: "acceptance-product-observable",
+    level: "invariant",
+    title: "Acceptance needs product observables",
+    verdict: "keep-hard",
+  },
+  {
+    area: "performance",
+    currentConstraint:
+      "Performance coverage currently asks every visible non-action control for a performance scenario.",
+    desiredBehavior:
+      "Heavy workload controls get min/default/max workload coverage; ordinary controls get lightweight responsiveness coverage so they cannot hang or break input. Animated previews suspend or coalesce non-essential animation work during canvas drag, pan, pinch, zoom, and radar/center interactions without changing user playback state. A full performance checkpoint is required when the first working version of an app exists, when renderer/canvas/animation/export/timeline/layers change, after fixing a bug that previously broke functionality, after any performance optimization, and whenever the user asks to optimize performance, fix lag, remove jank, speed up animation, or stabilize drag/zoom. Browser performance tests read budgets from typed performance config and run sequentially for stable measurements.",
+    enforcement: ["performance-validator", "browser-helper", "starter-agents"],
+    id: "performance-coverage-levels",
+    level: "invariant",
+    title: "Performance coverage has workload and responsiveness levels",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "persistence",
+    currentConstraint:
+      "Persistence policy must be deliberate; generated apps should not write runtime state to localStorage directly.",
+    desiredBehavior:
+      "AI states whether persistence exists, what is persisted, and how reset, import, clear, and new media affect stored state. Apps with localStorage persistence must include browser acceptance for changing a user setting, reloading the page, and observing the restored value or product output; settings import/export is not a substitute for persistence.",
+    enforcement: ["starter-agents", "spec-checklist", "acceptance-validator", "browser-helper"],
+    id: "persistence-policy-explicit",
+    level: "default",
+    title: "Persistence is explicit app policy",
+    verdict: "keep-but-clarify",
+  },
+  {
+    area: "workflow",
+    currentConstraint:
+      "Template app work must use brainstorming, writing-plans, systematic-debugging, and browser verification when the environment supports those skills.",
+    desiredBehavior:
+      "Workflow skills guide the generation process, while product implementation plans stay focused on app files, tests, build, and browser verification.",
+    enforcement: ["starter-agents", "docs"],
+    id: "workflow-required",
+    level: "invariant",
+    title: "Required workflow stays part of the contract",
+    verdict: "remove-duplicate",
+  },
+] as const satisfies readonly ToolcraftDecisionRule[];
+
+export function getToolcraftDecisionRule(
+  id: string,
+): ToolcraftDecisionRule | undefined {
+  return TOOLCRAFT_DECISION_CONTRACT.find((rule) => rule.id === id);
+}
+
+export function getToolcraftDecisionRulesByArea(
+  area: ToolcraftDecisionArea,
+): ToolcraftDecisionRule[] {
+  return TOOLCRAFT_DECISION_CONTRACT.filter((rule) => rule.area === area);
+}

package/templates/runtime/contracts/index.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  getToolcraftComponentContract,
+  getToolcraftDecisionRule,
+} from "./index";
+
+describe("Toolcraft template contracts barrel", () => {
+  it("exports component and decision contracts together", () => {
+    expect(getToolcraftComponentContract("slider")?.visualComponent).toBe("Slider");
+    expect(getToolcraftDecisionRule("canvas-no-app-ui")?.level).toBe("invariant");
+    expect(getToolcraftDecisionRule("workflow-required")?.area).toBe("workflow");
+  });
+});

package/templates/runtime/contracts/index.ts

@@ -0,0 +1,3 @@
+export * from "./component-contracts";
+export * from "./decision-contracts";
+export * from "./types";

package/templates/runtime/contracts/types.ts

@@ -0,0 +1,56 @@
+export type ToolcraftContractKind =
+  | "canvas"
+  | "command"
+  | "composition"
+  | "control"
+  | "panel"
+  | "persistence"
+  | "settings"
+  | "toolbar";
+
+export type ToolcraftStateMode = "command-only" | "controlled" | "runtime-owned";
+
+export type ToolcraftSectionLayout = "grouped" | "standalone";
+
+export type ToolcraftControlLayoutGroupColumns = 2;
+
+export type ToolcraftControlLayoutGroupLayout = "inline";
+
+export type ToolcraftLabelPolicy = "component-owned" | "hidden" | "optional" | "required";
+
+export type ToolcraftPanelPlacement = "bottom" | "left" | "right" | "top";
+
+export type ToolcraftPanelSnapEdge = "bottom" | "left" | "right" | "top";
+
+export type ToolcraftControlDecisionStrictness =
+  | "best-fit"
+  | "custom-escape-hatch"
+  | "exact-owner";
+
+export type ToolcraftControlDecisionCatalog = {
+  acceptableAlternatives?: readonly string[];
+  doNotReplaceWith?: readonly string[];
+  layoutConstraints?: readonly string[];
+  ownsValueModel: readonly string[];
+  requiredAcceptance: readonly string[];
+  strictness: ToolcraftControlDecisionStrictness;
+  useWhen: readonly string[];
+};
+
+export type ToolcraftComponentContract = {
+  aiUsageRules?: readonly string[];
+  capabilities?: readonly string[];
+  commands?: readonly string[];
+  decisionCatalog?: ToolcraftControlDecisionCatalog;
+  defaultPlacement?: ToolcraftPanelPlacement;
+  defaultSectionLayout?: ToolcraftSectionLayout;
+  historyPolicy?: "never" | "optional" | "patch";
+  id: string;
+  kind: ToolcraftContractKind;
+  labelPolicy?: ToolcraftLabelPolicy;
+  requiredWrapper?: "PanelHost";
+  schemaType?: string;
+  snapEdges?: readonly ToolcraftPanelSnapEdge[];
+  stateMode: ToolcraftStateMode;
+  visualComponent: string;
+};