@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/runtime/testing/performance-test-fixtures/scenarios.ts

@@ -1,172 +0,0 @@
-import { defineToolcraftPerformance } from "../performance";
-import {
-  createAnimatedVectorRendererPipeline,
-  createTextRendererPipeline,
-} from "./renderer-pipelines";
-import {
-  createCombinedRendererStressFixture,
-  createCustomStressFixture,
-  createLargeTextStressFixture,
-  createSchemaMaxValueStressFixture,
-} from "./stress-fixtures";
-import { testSchema } from "./schemas";
-
-export function createViewportZoomStressScenario() {
-  return {
-    automated: true,
-    automatedTestName: "perf: detailed canvas zoom stays smooth",
-    browser: true,
-    browserTestName: "browser perf: detailed canvas zoom stays smooth",
-    budget: { maxFrameGapMs: 80, maxInteractionMs: 500, maxLongTaskMs: 80 },
-    expectedObservable:
-      "Zooming detailed product output does not shake the canvas or block frames.",
-    fixture: "detailed renderer zoom fixture",
-    id: "viewport-zoom-stress",
-    interaction: "viewport-zoom-stress" as const,
-    stress: true,
-    stressFixture: createCombinedRendererStressFixture(),
-    target: "canvas.viewport",
-    workload: false,
-  };
-}
-
-export function createTextRendererScenarios(
-  options: { includeStressPreview?: boolean; includeViewportZoomStress?: boolean } = {},
-) {
-  const includeStressPreview = options.includeStressPreview ?? true;
-  const includeViewportZoomStress = options.includeViewportZoomStress ?? true;
-
-  return [
-    {
-      automated: true,
-      automatedTestName: "perf: text preview render stays under budget",
-      browser: true,
-      browserTestName: "browser perf: text preview render stays under budget",
-      budget: { maxLongTaskMs: 80, maxPreviewMs: 1000 },
-      expectedObservable: "Text preview renders crisply without freezing.",
-      fixture: "native-resolution glyph output fixture",
-      id: "text-preview-render",
-      interaction: "preview-render" as const,
-      stress: includeStressPreview,
-      ...(includeStressPreview
-        ? { stressFixture: createCombinedRendererStressFixture() }
-        : {}),
-      workload: false,
-    },
-    {
-      automated: true,
-      automatedTestName: "perf: density drag stays responsive",
-      browser: true,
-      browserTestName: "browser perf: density drag stays responsive",
-      budget: { maxFrameGapMs: 80, maxInteractionMs: 500 },
-      controlLabel: "Density",
-      expectedObservable: "Dragging Density updates text output without blocking the UI.",
-      fixture: "runtime density fixture",
-      id: "density-drag",
-      interaction: "control-drag" as const,
-      stressFixture: createSchemaMaxValueStressFixture(
-        testSchema,
-        "render.density",
-        "Density max is the heaviest glyph output fixture.",
-      ),
-      target: "render.density",
-      workloadFixture: createLargeTextStressFixture(),
-      workload: true,
-    },
-    {
-      automated: true,
-      automatedTestName: "perf: mode change stays responsive",
-      browser: true,
-      browserTestName: "browser perf: mode change stays responsive",
-      budget: { maxFrameGapMs: 80, maxInteractionMs: 500 },
-      controlLabel: "Mode",
-      expectedObservable: "Changing Mode updates text output without blocking the UI.",
-      fixture: "runtime mode fixture",
-      id: "mode-change",
-      interaction: "control-change" as const,
-      target: "render.mode",
-      values: { default: "soft", max: "sharp", min: "soft" },
-      workload: false,
-    },
-    {
-      automated: true,
-      automatedTestName: "perf: viewport stays stable",
-      browser: true,
-      browserTestName: "browser perf: viewport stays stable",
-      budget: { maxFrameGapMs: 80 },
-      expectedObservable: "Viewport remains stable.",
-      fixture: "native-resolution glyph output fixture",
-      id: "viewport-stability",
-      interaction: "viewport-stability" as const,
-      workload: false,
-    },
-    ...(includeViewportZoomStress ? [createViewportZoomStressScenario()] : []),
-  ];
-}
-
-export function createAnimationFrameScenario() {
-  return {
-    automated: true,
-    automatedTestName: "perf: animation frame loop stays smooth",
-    browser: true,
-    browserTestName: "browser perf: animation frame loop stays smooth",
-    budget: { maxFrameGapMs: 80, maxLongTaskMs: 80 },
-    expectedObservable: "Animated renderer advances without long frame gaps.",
-    fixture: "animated renderer fixture",
-    id: "animation-frame-loop",
-    interaction: "animation-frame" as const,
-    stress: true,
-    stressFixture: createCustomStressFixture(
-      { animation: "fastest", density: 12 },
-      "Animation stress must sample the heaviest animated output.",
-    ),
-    workload: false,
-  };
-}
-
-export function createAnimationViewportDragScenario() {
-  return {
-    automated: true,
-    automatedTestName: "perf: animated canvas drag stays smooth",
-    browser: true,
-    browserTestName: "browser perf: animated canvas drag stays smooth",
-    budget: { maxFrameGapMs: 80, maxInteractionMs: 500, maxLongTaskMs: 80 },
-    expectedObservable: "Animated renderer stays smooth while the canvas viewport is dragged.",
-    fixture: "animated renderer canvas drag fixture",
-    id: "animation-viewport-drag",
-    interaction: "animation-viewport-drag" as const,
-    stress: true,
-    stressFixture: createCustomStressFixture(
-      { animation: "fastest", density: 12 },
-      "Animated viewport drag must run while the heaviest animated output is visible.",
-    ),
-    target: "canvas.viewport",
-    workload: false,
-  };
-}
-
-export function createAnimatedVectorRendererConfig(options: { includeViewportDrag: boolean }) {
-  return defineToolcraftPerformance({
-    rendererStrategy: "svg",
-    rendererTechnique: {
-      exportRenderer: "svg",
-      fidelityRisks: ["animated vector output must stay crisp while panning"],
-      performanceRisks: ["dense vector animation can jank while the viewport moves"],
-      previewRenderer: "svg",
-      productRepresentation: "vector",
-      rendererStrategy: "svg",
-      rendererWorkload: "vector-output",
-      sourceRepresentation: "procedural-data",
-      whyNotAlternativeStrategies: ["svg preserves semantic vector output for this fixture"],
-    },
-    rendererWorkload: "vector-output",
-    rendererPipeline: createAnimatedVectorRendererPipeline(),
-    scenarios: [
-      ...createTextRendererScenarios(),
-      createAnimationFrameScenario(),
-      ...(options.includeViewportDrag ? [createAnimationViewportDragScenario()] : []),
-    ],
-    usesCustomRenderer: true,
-    workloadTargets: ["render.density"],
-  });
-}

package/templates/runtime/testing/performance-test-fixtures/stress-fixtures.ts

@@ -1,133 +0,0 @@
-import type { ResolvedToolcraftAppSchema } from "../../schema/types";
-import { requireToolcraftSchemaPerformanceValues } from "../performance-schema-queries";
-
-export function createMaxValueStressFixture(value: unknown, reason = "Maximum workload value.") {
-  return {
-    kind: "max-value" as const,
-    loadProfile: {
-      hardLimit: value,
-      metric: "numeric-max" as const,
-      smoothTarget: value,
-      smoothTargetRatio: 1,
-      target: "render.density",
-      userFacingRange: "fully-guaranteed" as const,
-    },
-    reason,
-    value,
-  };
-}
-
-export function createSchemaMaxValueStressFixture(
-  schema: ResolvedToolcraftAppSchema,
-  target: string,
-  reason = "Schema-derived maximum workload value.",
-) {
-  const values = requireToolcraftSchemaPerformanceValues(schema, target);
-  const value = values.max;
-
-  return {
-    kind: "max-value" as const,
-    loadProfile: {
-      hardLimit: value,
-      metric: typeof value === "number" ? ("numeric-max" as const) : ("custom" as const),
-      smoothTarget: value,
-      smoothTargetRatio: 1,
-      target,
-      userFacingRange: "fully-guaranteed" as const,
-    },
-    reason,
-    value,
-  };
-}
-
-export function createCustomStressFixture(
-  value: unknown = { density: 12 },
-  reason = "Combined renderer stress state.",
-) {
-  return {
-    kind: "custom" as const,
-    loadProfile: {
-      hardLimit: value,
-      metric: "custom" as const,
-      smoothTarget: value,
-      smoothTargetRatio: 1,
-      target: "renderer.output",
-      userFacingRange: "fully-guaranteed" as const,
-    },
-    reason,
-    value,
-  };
-}
-
-export function createCombinedRendererStressFixture() {
-  return createCustomStressFixture(
-    { density: 12, zoom: "toolbar" },
-    "Stress checks must run with the densest product output visible.",
-  );
-}
-
-export function createLargeTextStressValue(): string {
-  return Array.from(
-    { length: 1_000 },
-    (_, index) =>
-      `Line ${String(index + 1).padStart(4, "0")} performance stress text with enough glyphs to exercise layout.`,
-  ).join("\n");
-}
-
-export function createLargeTextStressFixture() {
-  return {
-    kind: "large-text" as const,
-    minChars: 50_000,
-    minLines: 1_000,
-    reason: "Long multiline content is the heaviest realistic text workload.",
-    value: createLargeTextStressValue(),
-  };
-}
-
-export function createMediaStressFixture(
-  value: { height: number; width: number } = { height: 1080, width: 1920 },
-  reason = "Large uploaded source media is the heaviest realistic import fixture.",
-) {
-  return {
-    kind: "media" as const,
-    loadProfile: {
-      hardLimit: value,
-      metric: "media-area" as const,
-      smoothTarget: value,
-      smoothTargetRatio: 1,
-      target: "source.image",
-      userFacingRange: "fully-guaranteed" as const,
-    },
-    reason,
-    value,
-  };
-}
-
-export function createDegradedMaxValueStressFixture() {
-  return {
-    kind: "max-value" as const,
-    loadProfile: {
-      degradationStepPercent: 10 as const,
-      evidence: [
-        {
-          attemptedRatio: 1,
-          attemptedTarget: 12,
-          decision: "Keep 12 available as high density while guaranteeing smooth drag through 11.",
-          measuredResult: "At density 12, maxFrameGapMs 148 exceeded the 80ms budget.",
-          optimizationAttempted: "Cached glyph atlas and coalesced preview work to requestAnimationFrame.",
-          result: "failed" as const,
-          scenarioId: "density-drag",
-          target: "render.density",
-        },
-      ],
-      hardLimit: 12,
-      metric: "numeric-max" as const,
-      smoothTarget: 11,
-      smoothTargetRatio: 0.9,
-      target: "render.density",
-      userFacingRange: "experimental-above-smooth" as const,
-    },
-    reason: "Density 11 is the measured smooth target after hard-limit testing.",
-    value: 11,
-  };
-}

package/templates/starter/e2e/performance-render-scale-helpers.ts

@@ -1,55 +0,0 @@
-import { expect, type Page } from "@playwright/test";
-
-import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
-
-export async function expectToolcraftCanvasBackingPixelsForRenderScale(
-  page: Page,
-  canvasSelector: string,
-  renderScale: number,
-  options: { scenarioId?: string } = {},
-): Promise<void> {
-  if (!Number.isFinite(renderScale) || renderScale <= 1) {
-    throw new Error(
-      `Toolcraft render scale backing-pixel checks require a numeric renderScale greater than 1, received ${renderScale}.`,
-    );
-  }
-
-  const canvas = page.locator(canvasSelector).first();
-  await expect(
-    canvas,
-    `Toolcraft render scale check expected a visible canvas matching "${canvasSelector}".`,
-  ).toBeVisible();
-
-  const metrics = await canvas.evaluate((element) => {
-    if (!(element instanceof HTMLCanvasElement)) {
-      throw new Error("Render scale backing-pixel checks must target an HTMLCanvasElement.");
-    }
-
-    const rect = element.getBoundingClientRect();
-    return {
-      backingHeight: element.height,
-      backingWidth: element.width,
-      cssHeight: element.clientHeight || rect.height,
-      cssWidth: element.clientWidth || rect.width,
-      devicePixelRatio: window.devicePixelRatio || 1,
-    };
-  });
-
-  const expectedWidth = metrics.cssWidth * metrics.devicePixelRatio * renderScale;
-  const expectedHeight = metrics.cssHeight * metrics.devicePixelRatio * renderScale;
-
-  expect(
-    metrics.backingWidth,
-    `Expected canvas backing width to honor Resolution scale ${renderScale}.`,
-  ).toBeGreaterThanOrEqual(Math.floor(expectedWidth - 1));
-  expect(
-    metrics.backingHeight,
-    `Expected canvas backing height to honor Resolution scale ${renderScale}.`,
-  ).toBeGreaterThanOrEqual(Math.floor(expectedHeight - 1));
-  if (options.scenarioId) {
-    await attachToolcraftBrowserRuntimeEvidence({
-      evidenceType: "performance-render-scale",
-      requirementId: options.scenarioId,
-    });
-  }
-}

package/templates/starter/scripts/check-ai-skills.mjs

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const codexHome = process.env.CODEX_HOME
-  ? path.resolve(process.env.CODEX_HOME)
-  : path.join(os.homedir(), ".codex");
-const claudeHome = process.env.CLAUDE_HOME
-  ? path.resolve(process.env.CLAUDE_HOME)
-  : path.join(os.homedir(), ".claude");
-const cursorHome = path.join(os.homedir(), ".cursor");
-const configHome = process.env.XDG_CONFIG_HOME
-  ? path.resolve(process.env.XDG_CONFIG_HOME)
-  : path.join(os.homedir(), ".config");
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.resolve(scriptDir, "..");
-
-const skillRoots = [
-  path.join(projectRoot, ".agents/skills"),
-  path.join(projectRoot, ".claude/skills"),
-  path.join(codexHome, "skills"),
-  path.join(claudeHome, "skills"),
-  path.join(cursorHome, "skills"),
-  path.join(configHome, "opencode/skills"),
-  path.join(configHome, "agents/skills"),
-];
-
-function skillPaths(name) {
-  return skillRoots.map((root) => path.join(root, name, "SKILL.md"));
-}
-
-const requiredSkills = [
-  {
-    name: "brainstorming",
-    purpose: "shape the app behavior, panels, controls, canvas, media, export, and ambiguity before code",
-    paths: skillPaths("brainstorming"),
-  },
-  {
-    name: "writing-plans",
-    purpose: "turn the approved app spec into a deterministic Toolcraft implementation plan",
-    paths: skillPaths("writing-plans"),
-  },
-  {
-    name: "systematic-debugging",
-    purpose: "investigate root cause before fixing broken controls, tests, builds, visual regressions, or runtime bugs",
-    paths: skillPaths("systematic-debugging"),
-  },
-  {
-    name: "figma",
-    purpose: "inspect actual Figma structure before implementing Figma-referenced Toolcraft apps",
-    paths: skillPaths("figma"),
-  },
-  {
-    name: "figma-implement-design",
-    purpose: "translate inspected Figma structure into Toolcraft schema, renderer, and verification coverage",
-    paths: skillPaths("figma-implement-design"),
-  },
-  {
-    name: "browser",
-    purpose: "verify the generated UI in a running local browser after implementation",
-    paths: [
-      ...skillPaths("browser"),
-      path.join(codexHome, "skills/browser/SKILL.md"),
-      path.join(codexHome, "skills/browser/browser/SKILL.md"),
-      path.join(codexHome, "plugins/cache/openai-bundled/browser/0.1.0-alpha2/skills/browser/SKILL.md"),
-      path.join(codexHome, "plugins/cache/openai-bundled/browser/*/skills/browser/SKILL.md"),
-      path.join(codexHome, "plugins/cache/openai-bundled/browser/*/skills/control-in-app-browser/SKILL.md"),
-    ],
-  },
-];
-
-function pathPatternExists(candidatePath) {
-  if (!candidatePath.includes("*")) {
-    return fs.existsSync(candidatePath);
-  }
-
-  const { root } = path.parse(candidatePath);
-  const segments = candidatePath.slice(root.length).split(path.sep).filter(Boolean);
-
-  function walk(index, currentPath) {
-    if (index >= segments.length) {
-      return fs.existsSync(currentPath);
-    }
-
-    const segment = segments[index];
-
-    if (segment !== "*") {
-      return walk(index + 1, path.join(currentPath, segment));
-    }
-
-    if (!fs.existsSync(currentPath)) {
-      return false;
-    }
-
-    return fs
-      .readdirSync(currentPath, { withFileTypes: true })
-      .some((entry) => entry.isDirectory() && walk(index + 1, path.join(currentPath, entry.name)));
-  }
-
-  return walk(0, root);
-}
-
-function hasAnyPath(paths) {
-  return paths.some((candidatePath) => pathPatternExists(candidatePath));
-}
-
-const missingSkills = requiredSkills.filter((skill) => !hasAnyPath(skill.paths));
-
-if (missingSkills.length === 0) {
-  console.log("AI workflow skills are installed:");
-  for (const skill of requiredSkills) {
-    console.log(`- ${skill.name}: ${skill.purpose}`);
-  }
-  process.exit(0);
-}
-
-console.warn("Optional AI workflow skills are not installed:");
-for (const skill of missingSkills) {
-  console.warn(`- ${skill.name}: ${skill.purpose}`);
-}
-
-console.warn("");
-console.warn(
-  "Signed local AGENTS.md and docs/toolcraft contracts remain the mandatory workflow authority.",
-);
-console.warn(
-  "Continue with the local Toolcraft workflow; install available external skills when the environment supports them.",
-);
-console.warn(
-  "Checked project and global skill locations for Codex, Claude Code, Cursor, and OpenCode-compatible agents.",
-);
-
-process.exit(0);

package/templates/starter/scripts/check-ai-skills.test.mjs

@@ -1,64 +0,0 @@
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-const scriptPath = fileURLToPath(new URL("./check-ai-skills.mjs", import.meta.url));
-const skillNames = [
-  "brainstorming",
-  "writing-plans",
-  "systematic-debugging",
-  "figma",
-  "figma-implement-design",
-  "browser",
-];
-
-async function withCleanHome(callback) {
-  const home = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-skills-"));
-  const env = {
-    ...process.env,
-    CLAUDE_HOME: path.join(home, ".claude"),
-    CODEX_HOME: path.join(home, ".codex"),
-    HOME: home,
-    XDG_CONFIG_HOME: path.join(home, ".config"),
-  };
-
-  try {
-    await callback({ env, home });
-  } finally {
-    await fs.rm(home, { force: true, recursive: true });
-  }
-}
-
-test("missing external skills use the signed local contract fallback", async () => {
-  await withCleanHome(async ({ env }) => {
-    const result = await execFileAsync(process.execPath, [scriptPath], { env });
-
-    assert.match(result.stderr, /Optional AI workflow skills are not installed/);
-    assert.match(result.stderr, /Signed local AGENTS\.md and docs\/toolcraft/);
-    assert.match(result.stderr, /continue with the local Toolcraft workflow/i);
-  });
-});
-
-test("installed external skills are still discovered and reported", async () => {
-  await withCleanHome(async ({ env, home }) => {
-    for (const skillName of skillNames) {
-      const skillPath = path.join(home, ".codex", "skills", skillName, "SKILL.md");
-      await fs.mkdir(path.dirname(skillPath), { recursive: true });
-      await fs.writeFile(skillPath, `# ${skillName}\n`);
-    }
-
-    const result = await execFileAsync(process.execPath, [scriptPath], { env });
-
-    assert.match(result.stdout, /AI workflow skills are installed/);
-    for (const skillName of skillNames) {
-      assert.match(result.stdout, new RegExp(`- ${skillName}:`));
-    }
-    assert.equal(result.stderr, "");
-  });
-});

package/templates/starter/scripts/toolcraft-product-boundary-ast-utils.mjs

@@ -1,23 +0,0 @@
-import ts from "typescript";
-
-function getScriptKind(filePath) {
-  if (/\.tsx$/iu.test(filePath)) return ts.ScriptKind.TSX;
-  if (/\.jsx$/iu.test(filePath)) return ts.ScriptKind.JSX;
-  if (/\.[cm]?js$/iu.test(filePath)) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}
-
-export function createSourceFile(absolutePath, rawSource) {
-  return ts.createSourceFile(
-    absolutePath,
-    rawSource,
-    ts.ScriptTarget.Latest,
-    true,
-    getScriptKind(absolutePath),
-  );
-}
-
-export function getNodeLocation(sourceFile, node) {
-  const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  return { column: location.character + 1, line: location.line + 1 };
-}