@pixel-point/toolcraft 0.0.13 → 0.0.15

package/templates/starter/src/app/starter-acceptance.worklog.test.ts

@@ -0,0 +1,283 @@
+import { existsSync } from "node:fs";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  agentWorklogPath,
+  createAgentWorklogFixture,
+  getAgentWorklogValidationErrors,
+  isPassedPlaywrightFallbackPerfRunLine,
+  readToolcraftDoc,
+} from "./starter-acceptance.worklog-test-utils";
+
+const performanceCheckpointError =
+  "agent-worklog.md Verification must record `pnpm verify:perf` as the automated Playwright performance checkpoint for first working product delivery.";
+
+describe("starter acceptance worklog contract", () => {
+  it("keeps an implementation worklog available for generated app decisions", () => {
+    expect(
+      existsSync(agentWorklogPath),
+      "Generated apps must include docs/toolcraft/agent-worklog.md so implementation decisions and evidence survive the chat context.",
+    ).toBe(true);
+  });
+
+  it("documents control selection inventory and custom built-in fit checks", () => {
+    const coreControlSelection = readToolcraftDoc("core/control-selection.md");
+    const componentRules = readToolcraftDoc("component-rules.md");
+    const acceptanceTesting = readToolcraftDoc("acceptance-testing.md");
+
+    expect(coreControlSelection).toContain("Control Selection Inventory");
+    expect(coreControlSelection).toContain("Product need:");
+    expect(coreControlSelection).toContain("Candidate built-ins checked:");
+    expect(coreControlSelection).toContain("Best built-in:");
+    expect(coreControlSelection).toContain("Rejected alternatives:");
+    expect(coreControlSelection).toContain("Target:");
+    expect(coreControlSelection).toContain("Custom Control Gate");
+
+    expect(componentRules).toContain("Control Decision Catalog");
+    expect(componentRules).toContain("core/control-selection.md");
+
+    expect(acceptanceTesting).toContain("wrong-substitution");
+    expect(acceptanceTesting).toContain("built-in fit check");
+    expect(acceptanceTesting).toContain("builtInFitCheck");
+  });
+
+  it("requires product worklogs to record storyboard evidence for video references", () => {
+    const worklog = createAgentWorklogFixture({
+      evidenceLines: [
+        "- Source reviewed: user prompt, ref.mp4, src/app/product-renderer.tsx.",
+        "- Contract applied: Toolcraft workflow.",
+      ],
+      trailFields: {
+        "Reference inputs": "/fixtures/reference-motion/ref.mp4 video reference.",
+        "Source/reference checked": "User prompt and /fixtures/reference-motion/ref.mp4 video.",
+      },
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toContain(
+      "agent-worklog.md cites a video reference, screen recording, GIF, extracted frames, or contact sheet; record a Video Reference Study with storyboard frames and frame-to-frame transition analysis.",
+    );
+  });
+
+  it("accepts product worklogs that record video reference storyboard and transition evidence", () => {
+    const worklog = createAgentWorklogFixture({
+      evidenceLines: [
+        "- Source reviewed: user prompt, ref.mp4, extracted frames, contact sheet, src/app/product-renderer.tsx.",
+        "- Contract applied: Toolcraft workflow and video-reference-analysis.",
+      ],
+      extraDecisionSections: [
+        [
+          "### Video Reference Study",
+          "- Decision: Implement from storyboard frames and frame-to-frame transition analysis.",
+          "- Reason: The video reference defines behavior, not only a static visual state.",
+          "- Evidence: extracted frames f000/f012/f024/f036 and transition analysis between adjacent frames.",
+        ].join("\n"),
+      ],
+      trailFields: {
+        "Alternatives rejected": "Single screenshot implementation because the video behavior changes frame to frame.",
+        "Contract rules applied": "video-reference-analysis and acceptance-product-observable.",
+        "Reference inputs": "/fixtures/reference-motion/ref.mp4 video reference, extracted frames, contact sheet.",
+        "Source/reference checked": "User prompt, /fixtures/reference-motion/ref.mp4 video, extracted frames, and contact sheet.",
+      },
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it("does not treat ordinary video export worklog evidence as a video reference", () => {
+    const worklog = createAgentWorklogFixture({
+      decisions: {
+        Export: {
+          decision: "Expose Export PNG and Export Video.",
+          evidence: "src/app/export.ts.",
+          reason: "Animated products need still and video output.",
+        },
+        Renderer: {
+          decision: "Use Canvas 2D.",
+          evidence: "src/app/product-renderer.tsx.",
+          reason: "Product output is simple animated geometry.",
+        },
+        Timeline: {
+          decision: "Use playback.",
+          evidence: "src/app/app-schema.ts.",
+          reason: "Export Video requires runtime timeline time.",
+        },
+      },
+      evidenceLines: [
+        "- Source reviewed: user prompt, app schema, export handler, browser export behavior.",
+        "- Contract applied: Toolcraft workflow.",
+      ],
+      trailFields: {
+        Decision: "Use Toolcraft export helpers.",
+        "Reference inputs": "None.",
+        "Source/reference checked": "User prompt, app schema, export handler, and browser export behavior.",
+        "State/output mapping": "Runtime timeline state drives preview and export frames.",
+        "User-visible result": "The product renders and exports video.",
+      },
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it("rejects stale or incomplete product worklogs", () => {
+    const errors = getAgentWorklogValidationErrors(
+      createAgentWorklogFixture({ mode: "starter" }),
+    );
+
+    expect(errors).toContain(
+      'agent-worklog.md Status must declare "Mode: product" before final delivery.',
+    );
+    expect(errors).toContain(
+      'agent-worklog.md still declares "Mode: starter"; replace the starter template with product decisions.',
+    );
+  });
+
+  it("accepts product worklogs with concrete decisions, evidence, verification, and risk state", () => {
+    expect(getAgentWorklogValidationErrors(createAgentWorklogFixture())).toEqual([]);
+  });
+
+  it("rejects product worklogs that report incomplete required performance gates", () => {
+    const worklog = createAgentWorklogFixture({
+      risksLines: ["- Risk: Required checks are not complete."],
+      trailFields: {
+        Risks: "Product contract tests still need updates before final delivery.",
+        "Skipped checks": "pnpm verify:final and pnpm verify:perf are not complete yet.",
+        Verification: "pnpm test failed; pnpm verify:perf not complete.",
+      },
+      verificationLines: [
+        "- Run: pnpm test failed.",
+        "- Run: pnpm verify:perf not complete.",
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual(
+      expect.arrayContaining([
+        "agent-worklog.md required checks must be passed before final delivery; do not report failed, incomplete, pending, or blocked verification.",
+        "agent-worklog.md must not list required checks as skipped unless they are explicitly not required for a post-first-working non-performance edit.",
+        performanceCheckpointError,
+      ]),
+    );
+  });
+
+  it("requires first working product worklogs to record a browser performance checkpoint", () => {
+    const worklog = createAgentWorklogFixture({
+      trailFields: {
+        Verification: "pnpm verify:quick; pnpm verify:final.",
+      },
+      verificationLines: [
+        "- Run: pnpm verify:quick",
+        "- Run: pnpm verify:final",
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toContain(performanceCheckpointError);
+  });
+
+  it("does not accept agent-browser prose as the final machine performance checkpoint", () => {
+    const worklog = createAgentWorklogFixture({
+      trailFields: {
+        Verification: "pnpm verify:quick; agent-browser performance checkpoint.",
+      },
+      verificationLines: [
+        "- Run: pnpm verify:quick",
+        "- Browser: performance checkpoint runner agent-browser",
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toContain(
+      performanceCheckpointError,
+    );
+  });
+
+  it("recognizes automated Playwright performance checkpoint evidence line formats", () => {
+    expect(
+      isPassedPlaywrightFallbackPerfRunLine(
+        "- Verification: playwright-fallback browser performance checkpoint",
+      ),
+    ).toBe(true);
+    expect(isPassedPlaywrightFallbackPerfRunLine("- Run: pnpm verify:perf")).toBe(true);
+    expect(isPassedPlaywrightFallbackPerfRunLine("- Run: pnpm verify:perf not complete")).toBe(false);
+    expect(isPassedPlaywrightFallbackPerfRunLine("- Run: pnpm verify:perf not run")).toBe(false);
+  });
+
+  it("accepts the automated Playwright checkpoint without a manual fallback reason", () => {
+    const worklog = createAgentWorklogFixture({
+      decisions: {
+        Performance: {
+          decision: "Use the automated Playwright browser performance checkpoint.",
+          evidence: "pnpm verify:perf.",
+          reason: "The protected runner can issue the machine performance receipt.",
+        },
+      },
+      trailFields: {
+        Verification: "pnpm verify:quick; pnpm verify:final; pnpm verify:perf.",
+      },
+      verificationLines: [
+        "- Run: pnpm verify:quick",
+        "- Run: pnpm verify:final",
+        "- Run: pnpm verify:perf",
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it("allows explicit post-first-working non-performance skips of the full performance suite", () => {
+    const skipLine =
+      "full performance checkpoint not required for this post-first-working non-performance feature loop.";
+    const worklog = createAgentWorklogFixture({
+      decisions: {
+        Performance: {
+          decision: "Skip full perf for this post-first-working copy pass.",
+          evidence: "Prior iteration recorded the pnpm verify:perf Playwright checkpoint.",
+          reason: "No renderer, workload, viewport, animation, export, or performance-sensitive control changed.",
+        },
+      },
+      trailFields: {
+        "Alternatives rejected": "Running full perf because this is a post-first-working non-performance edit.",
+        Decision: "Keep renderer, export, and performance matrix unchanged.",
+        "Files changed": "src/app/app-schema.ts.",
+        Request: "Rename two labels in an already delivered app.",
+        Risks: "None; output behavior is unchanged.",
+        "Skipped checks": skipLine,
+        "State/output mapping": "Label text changes do not alter runtime values or renderer state.",
+        "Task type": "Tier 0 copy update after the first working version.",
+        "User-visible result": "The labels are clearer and product output is unchanged.",
+        Verification: "pnpm verify:quick.",
+      },
+      trailHeading: "Iteration 2 - Copy refinement",
+      verificationLines: [
+        "- Run: pnpm verify:quick",
+        `- Skipped checks: ${skipLine}`,
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it("rejects product worklogs without an actionable decision trail", () => {
+    const worklog = createAgentWorklogFixture({
+      omitDecisionTrailFields: [
+        "Alternatives rejected",
+        "Contract rules applied",
+        "Reference inputs",
+        "Skipped checks",
+        "Source/reference checked",
+        "State/output mapping",
+        "User-visible result",
+      ],
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual(
+      expect.arrayContaining([
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "User-visible result:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "Source/reference checked:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "Reference inputs:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "Contract rules applied:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "Alternatives rejected:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "State/output mapping:".',
+        'agent-worklog.md Decision Trail iteration "Iteration 1 - Product build" must include "Skipped checks:".',
+      ]),
+    );
+  });
+});

package/templates/starter/src/app/starter-automated-runtime-evidence.test.ts

@@ -0,0 +1,34 @@
+import { test } from "vitest";
+
+import {
+  TOOLCRAFT_VITEST_RUNTIME_REQUIREMENTS_ANNOTATION_TYPE,
+  TOOLCRAFT_VITEST_RUNTIME_MARKER_TEST_NAME,
+  serializeToolcraftVitestRuntimeRequirements,
+  type ToolcraftVitestRuntimeRequirement,
+} from "../../scripts/toolcraft-vitest-runtime-contract.mjs";
+import { starterAcceptance } from "./starter-acceptance";
+import { starterPerformance } from "./starter-performance";
+
+test(TOOLCRAFT_VITEST_RUNTIME_MARKER_TEST_NAME, async ({ annotate }) => {
+  const requirements: ToolcraftVitestRuntimeRequirement[] = [
+    ...starterAcceptance
+      .filter((entry) => entry.automated)
+      .map((entry) => ({
+        kind: "acceptance" as const,
+        requirementId: entry.id,
+        testName: entry.automatedTestName,
+      })),
+    ...starterPerformance.scenarios
+      .filter((scenario) => scenario.automated)
+      .map((scenario) => ({
+        kind: "performance" as const,
+        requirementId: scenario.id,
+        testName: scenario.automatedTestName,
+      })),
+  ];
+
+  await annotate(
+    serializeToolcraftVitestRuntimeRequirements(requirements),
+    TOOLCRAFT_VITEST_RUNTIME_REQUIREMENTS_ANNOTATION_TYPE,
+  );
+});

package/templates/starter/src/app/starter-composition.tsx

@@ -0,0 +1,7 @@
+import type { ToolcraftAppComposition } from "@repo/toolcraft-runtime/react";
+
+import { starterSchema } from "./starter-schema";
+
+export const starterComposition: ToolcraftAppComposition = {
+  schema: starterSchema,
+};

package/templates/starter/src/app/starter-performance-test-utils.ts

@@ -0,0 +1,275 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import ts from "typescript";
+
+import { collectToolcraftSourceInventorySync } from "../../scripts/toolcraft-source-inventory.mjs";
+
+import { sourceDefinesProductCanvasContent } from "./starter-acceptance.source-test-utils";
+import { starterPerformance } from "./starter-performance";
+import { starterSchema } from "./starter-schema";
+
+export const appDir = dirname(fileURLToPath(import.meta.url));
+export const srcDir = join(appDir, "..");
+export const routesDir = join(appDir, "../routes");
+export const e2eDir = join(appDir, "../../e2e");
+export const projectDir = join(appDir, "../..");
+
+export function playwrightConfigForbidsFocusedTests(): boolean {
+  const sourceFile = ts.createSourceFile(
+    "playwright.config.ts",
+    readFileSync(join(projectDir, "playwright.config.ts"), "utf8"),
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+
+  return sourceFile.statements.some((statement) => {
+    if (
+      !ts.isExportAssignment(statement) ||
+      !ts.isCallExpression(statement.expression)
+    ) {
+      return false;
+    }
+
+    const config = statement.expression.arguments[0];
+    if (!config || !ts.isObjectLiteralExpression(config)) {
+      return false;
+    }
+
+    return config.properties.some(
+      (property) =>
+        ts.isPropertyAssignment(property) &&
+        ((ts.isIdentifier(property.name) && property.name.text === "forbidOnly") ||
+          (ts.isStringLiteralLike(property.name) && property.name.text === "forbidOnly")) &&
+        property.initializer.kind === ts.SyntaxKind.TrueKeyword,
+    );
+  });
+}
+
+export function stripJsComments(source: string): string {
+  const scanner = ts.createScanner(
+    ts.ScriptTarget.Latest,
+    false,
+    ts.LanguageVariant.JSX,
+    source,
+  );
+  const chunks: string[] = [];
+  let token = scanner.scan();
+  while (token !== ts.SyntaxKind.EndOfFileToken) {
+    if (
+      token !== ts.SyntaxKind.SingleLineCommentTrivia &&
+      token !== ts.SyntaxKind.MultiLineCommentTrivia
+    ) {
+      chunks.push(scanner.getTokenText());
+    }
+    token = scanner.scan();
+  }
+  return chunks.join("");
+}
+
+export function readFiles(rootDir: string, matcher: RegExp): string {
+  const inventory = collectToolcraftSourceInventorySync({
+    frameworkPathPrefixes: [],
+    ignoredFilePatterns: [
+      /(?:^|\/)(?:dist|node_modules)(?:\/|$)/u,
+      /^toolcraft(?:\/|$)/u,
+    ],
+    rootDir,
+    sourceRoots: ["."],
+  });
+  if (inventory.filesystemViolations.length > 0) {
+    throw new Error(
+      inventory.filesystemViolations
+        .map((violation) => `${violation.repoPath}: ${violation.reason}`)
+        .join("\n"),
+    );
+  }
+
+  return inventory.entries
+    .filter((entry) => entry.role === "production")
+    .filter((entry) => {
+      const fileName = entry.repoPath.split("/").at(-1) ?? entry.repoPath;
+      if (
+        /^(?:starter-|app-)(?:acceptance|performance)(?:[.-].*)?\.ts$/u.test(
+          fileName,
+        )
+      ) {
+        return false;
+      }
+      matcher.lastIndex = 0;
+      return matcher.test(fileName);
+    })
+    .map((entry) => readFileSync(entry.absolutePath, "utf8"))
+    .join("\n");
+}
+
+export function readMarkdownFiles(rootDir: string): string {
+  if (!existsSync(rootDir)) {
+    return "";
+  }
+
+  const chunks: string[] = [];
+
+  function visit(currentDir: string) {
+    for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+      const filePath = join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!["dist", "node_modules", "toolcraft"].includes(entry.name)) {
+          visit(filePath);
+        }
+        continue;
+      }
+
+      if (entry.isFile() && /\.mdx?$/i.test(entry.name)) {
+        chunks.push(readFileSync(filePath, "utf8"));
+      }
+    }
+  }
+
+  visit(rootDir);
+  return chunks.join("\n");
+}
+
+export function readProjectDecisionSources(): string {
+  return stripJsComments(
+    [
+      readMarkdownFiles(join(projectDir, "docs")),
+      readMarkdownFiles(join(projectDir, "specs")),
+      readMarkdownFiles(join(projectDir, "plans")),
+    ].join("\n"),
+  );
+}
+
+export function sourceUsesCustomRenderer(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+
+  return (
+    sourceDefinesProductCanvasContent() ||
+    /useToolcraft(Value)?\(/.test(appSources) ||
+    /getContext\(["']2d["']\)|webgl|webgpu|OffscreenCanvas|ImageData/.test(appSources)
+  );
+}
+
+export function sourceUsesHardcodedOutputBackgroundColor(
+  source = stripJsComments(readFiles(srcDir, /\.(ts|tsx|css)$/)),
+): boolean {
+  const canvasFillPattern =
+    /(?:ctx|context|canvasContext)\.fillStyle\s*=\s*["']#[0-9a-fA-F]{3,8}["'][\s\S]{0,240}\.fillRect\s*\(/;
+  const outputCssBackgroundPattern =
+    /\.(?:[a-z0-9_-]*(?:canvas|renderer|preview|output|product)[a-z0-9_-]*)\s*{[^}]*background(?:-color)?\s*:\s*#[0-9a-fA-F]{3,8}/i;
+
+  return canvasFillPattern.test(source) || outputCssBackgroundPattern.test(source);
+}
+
+export function schemaHasOutputBackgroundColorControl(): boolean {
+  return (starterSchema.panels.controls?.sections ?? []).some((section) =>
+    Object.values(section.controls).some((control) => {
+      if (control.type !== "color") {
+        return false;
+      }
+
+      const searchText = [
+        section.title,
+        typeof control.label === "string" ? control.label : "",
+        control.target,
+      ].join(" ");
+
+      return /\b(background|backdrop|scene|canvas)\b/i.test(searchText);
+    }),
+  );
+}
+
+export function projectDocsIncludeFixedBackgroundDecision(): boolean {
+  return /fixedBackgroundReason|fixed background|non-editable background|not user-editable background|reference-defined background|product-defined background/i.test(
+    readProjectDecisionSources(),
+  );
+}
+
+export function sourceUsesCpuPixelLoop(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+  const cpuPixelMethodCallPattern =
+    /(?:\.(?:createImageData|getImageData|putImageData)|\[\s*["'](?:createImageData|getImageData|putImageData)["']\s*\])\s*\(/;
+
+  return (
+    /new\s+ImageData\s*\(/.test(appSources) ||
+    cpuPixelMethodCallPattern.test(appSources)
+  );
+}
+
+export function appPerformanceHasRenderPipelinePass(kind: string): boolean {
+  return (starterPerformance.rendererPipeline?.passes ?? []).some(
+    (pass) => pass.kind === kind,
+  );
+}
+
+export function appPerformanceHasInteractionInvalidation(interaction: string): boolean {
+  return (starterPerformance.rendererPipeline?.interactionInvalidation ?? []).some(
+    (entry) => entry.interaction === interaction,
+  );
+}
+
+export function sourceUsesGpuRenderer(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+
+  return /getContext\(["']webgl2?["']\)|navigator\.gpu|GPUCanvasContext/.test(appSources);
+}
+
+export function sourceUsesWebGlLifecycleGuard(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+
+  return (
+    /useEffect\s*\(/.test(appSources) ||
+    /useLayoutEffect\s*\(/.test(appSources) ||
+    /useMemo\s*\(/.test(appSources) ||
+    /useRef\s*\(/.test(appSources) ||
+    /class\s+\w+Renderer/.test(appSources)
+  );
+}
+
+export function sourceCreatesWebGlContextInComponentRender(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+  const componentRenderPattern =
+    /function\s+[A-Z]\w*\s*\([^)]*\)\s*{(?![\s\S]{0,600}use(?:Layout)?Effect\s*\()[\s\S]{0,600}\.getContext\(["']webgl2?["']\)/;
+
+  return componentRenderPattern.test(appSources);
+}
+
+export function sourceMayUploadTextureFromTimelineDrivenEffect(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+  const timelineDrivenTextureUploadPattern =
+    /use(?:Layout)?Effect\s*\(\s*\(\)\s*=>\s*{[\s\S]*?(?:texImage2D\s*\(|\.setImage\s*\()[\s\S]*?}\s*,\s*\[[\s\S]*?(?:settings|state\.timeline|currentTimeSeconds|keyframeGroups)[\s\S]*?\]\s*\)/;
+
+  return timelineDrivenTextureUploadPattern.test(appSources);
+}
+
+export function sourceResyncsTimelineDurationFromRuntimeDuration(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+  const durationResyncPattern =
+    /use(?:Layout)?Effect\s*\(\s*\(\)\s*=>\s*{[\s\S]*?timeline\.setDuration[\s\S]*?}\s*,\s*\[[\s\S]*state\.timeline\.durationSeconds[\s\S]*\]\s*\)/;
+
+  return durationResyncPattern.test(appSources);
+}
+
+export function sourceUsesLowResolutionPreviewUpscale(source = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/))): boolean {
+  const lowResolutionPreviewPattern =
+    /maxPreviewPixels|previewPixelBudget|previewScale|previewRatio|lowRes|lowResolution|downsample/i;
+  const scaledDrawImagePattern =
+    /\.drawImage\s*\([\s\S]{0,240}(?:outputWidth|outputHeight|state\.canvas\.size|canvas\.width|canvas\.height)[\s\S]{0,240}\)/;
+
+  return lowResolutionPreviewPattern.test(source) || scaledDrawImagePattern.test(source);
+}
+
+export function sourceUsesAnimationFrameWithoutCleanup(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+
+  return /requestAnimationFrame\s*\(/.test(appSources) && !/cancelAnimationFrame\s*\(/.test(appSources);
+}
+
+export function sourceUsesDirectStorageApi(): boolean {
+  const appSources = stripJsComments(readFiles(srcDir, /\.(ts|tsx)$/));
+
+  return /\b(?:localStorage|sessionStorage)\s*\./.test(appSources);
+}