@pixel-point/toolcraft 0.0.17 → 0.0.19

package/src/generate-test-product-fixture.test.mjs

@@ -20,10 +20,44 @@ const generatedProductFixtureRoot = new URL(
   import.meta.url,
 );
 
+const starterPackageJsonUrl = new URL("../../starter/package.json", import.meta.url);
+
+it("keeps generated product fixtures reference-free and motion preprocessing demand-only", async () => {
+  const fixtureSources = await Promise.all([
+    generatedProductFixtureRoot,
+    new URL("../fixtures/generated-product-material-iteration/", import.meta.url),
+  ].map((root) => fs.readFile(
+    new URL("src/app/app-acceptance-data.ts", root),
+    "utf8",
+  )));
+  const packageJson = JSON.parse(await fs.readFile(starterPackageJsonUrl, "utf8"));
+
+  for (const fixtureSource of fixtureSources) {
+    assert.match(fixtureSource, /mode:\s*"new-toolcraft-app",\s*referenceInputs:\s*\[\],/u);
+  }
+  assert.equal(
+    packageJson.scripts["reference:study"],
+    "node scripts/create-toolcraft-motion-reference-study.mjs",
+  );
+  for (const scriptName of [
+    "build",
+    "docs:check",
+    "test",
+    "test:generated",
+    "typecheck",
+    "verify:delivery",
+  ]) {
+    assert.doesNotMatch(
+      packageJson.scripts[scriptName],
+      /reference:study|create-toolcraft-motion-reference-study/u,
+      `${scriptName} must not invoke motion-reference preprocessing implicitly.`,
+    );
+  }
+});
+
 it("rejects unknown and missing product fixture paths", () => {
   assert.deepEqual(generatedProductAuthorityFixturePaths, [
     "docs/toolcraft/agent-worklog.md",
-    "src/app/app-verification-impact.json",
   ]);
   assert.equal(
     generatedProductPresentationResourcePath,
@@ -254,12 +288,6 @@ it("applies only product-owned fixture files and preserves generated infrastruct
       path.join(targetDir, generatedProductPerformanceOwnerPath),
       "utf8",
     );
-    const verificationImpact = JSON.parse(
-      await fs.readFile(
-        path.join(targetDir, "src/app/app-verification-impact.json"),
-        "utf8",
-      ),
-    );
     const worklog = await fs.readFile(
       path.join(targetDir, "docs/toolcraft/agent-worklog.md"),
       "utf8",
@@ -271,37 +299,6 @@ it("applies only product-owned fixture files and preserves generated infrastruct
       /export const productPulseResourcePath = "\/product-pulse\.svg";/u,
     );
     assert.match(productOutput, /src=\{productPulseResourcePath\}/u);
-    assert.deepEqual(
-      verificationImpact.owners.find(
-        ({ path: ownerPath }) =>
-          ownerPath === generatedProductPresentationResourcePath,
-      ),
-      {
-        acceptanceIds: ["animation.speed"],
-        kind: "presentation",
-        path: generatedProductPresentationResourcePath,
-      },
-    );
-    assert.equal(verificationImpact.version, 3);
-    assert.equal(
-      verificationImpact.owners.some(
-        ({ path: ownerPath }) =>
-          ownerPath === "src/app/app-export-performance-workload.ts",
-      ),
-      false,
-    );
-    assert.deepEqual(
-      verificationImpact.owners.map(({ path: ownerPath }) => ownerPath),
-      [
-        "public/product-pulse.svg",
-        "src/app/app-composition.tsx",
-        "src/app/app-renderer-pipeline.ts",
-        "src/app/app-schema.ts",
-        "src/app/material-output.tsx",
-        "src/app/material-schema.ts",
-        "src/app/product-output.tsx",
-      ],
-    );
     const verificationLines = worklog.match(/^- Verification:.*$/gmu) ?? [];
     assert.ok(verificationLines.length > 0);
     assert.ok(

package/src/generate-test-product-iteration.mjs

@@ -20,7 +20,6 @@ export const generatedProductMaterialIterationFixturePaths = Object.freeze([
   "public/material-frosting.svg",
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
-  "src/app/app-verification-impact.json",
   "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",

package/src/generate-test-product-iteration.test.mjs

@@ -11,13 +11,17 @@ import {
   generatedProductMaterialIterationFixturePaths,
 } from "./generate-test-product-iteration.mjs";
 
+const materialIterationFixtureRoot = new URL(
+  "../fixtures/generated-product-material-iteration/",
+  import.meta.url,
+);
+
 const expectedPaths = [
   "e2e/product-material.spec.ts",
   "public/material-chocolate.svg",
   "public/material-frosting.svg",
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
-  "src/app/app-verification-impact.json",
   "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",
@@ -83,6 +87,18 @@ it("keeps the material iteration overlay exact and immutable", () => {
   );
 });
 
+it("keeps the material iteration video request explicit", async () => {
+  const acceptanceSource = await fs.readFile(
+    new URL("src/app/app-acceptance-data.ts", materialIterationFixtureRoot),
+    "utf8",
+  );
+
+  assert.match(
+    acceptanceSource,
+    /video:\s*\{\s*evidence:\s*"The generated export validation fixture explicitly requests one-second video export coverage\.",\s*mode: "user-requested",\s*\}/u,
+  );
+});
+
 it("atomically applies only the material product overlay", async () => {
   const targetDir = await fs.mkdtemp(
     path.join(os.tmpdir(), "toolcraft-material-iteration-target-"),

package/src/generate-test-runtime-boundary-assertions.mjs

@@ -0,0 +1,178 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { listRelativeFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+
+const productSafeRuntimeExportIndex = [
+  'export {',
+  '  toolcraftImageExportFormatTarget,',
+  '  toolcraftImageExportResolutionTarget,',
+  '  toolcraftVideoExportFormatTarget,',
+  '  toolcraftVideoExportResolutionTarget,',
+  '} from "./artifact-export-settings";',
+  'export type {',
+  '  ToolcraftImageExportFormat,',
+  '  ToolcraftImageExportPresetResolution,',
+  '  ToolcraftResolvedImageExportSettings,',
+  '  ToolcraftResolvedVideoExportSettings,',
+  '  ToolcraftVideoExportFormat,',
+  '  ToolcraftVideoExportPresetResolution,',
+  '} from "./artifact-export-settings";',
+  'export { shouldIncludeToolcraftPreviewBackground } from "./export-background";',
+  'export type { ToolcraftPreviewBackgroundOptions } from "./export-background";',
+  'export {',
+  '  TOOLCRAFT_MAX_EXPORT_EDGE_PX,',
+  '  TOOLCRAFT_MAX_EXPORT_PIXELS,',
+  '  validateToolcraftArtifactSize,',
+  '} from "./export-frame";',
+  'export type {',
+  '  ToolcraftArtifactSize,',
+  '  ToolcraftExportFrame,',
+  '} from "./export-frame";',
+  'export {',
+  '  getToolcraftImageExportSize,',
+  '  getToolcraftRetinaExportPixelRatio,',
+  '  getToolcraftRetinaExportSize,',
+  '  getToolcraftVideoExportSize,',
+  '} from "./export-sizing";',
+  'export type {',
+  '  ToolcraftExportSizeOptions,',
+  '  ToolcraftImageExportResolution,',
+  '  ToolcraftImageExportSizeOptions,',
+  '  ToolcraftRetinaExportSize,',
+  '  ToolcraftVideoExportResolution,',
+  '  ToolcraftVideoExportSizeOptions,',
+  '} from "./export-sizing";',
+  'export type {',
+  '  ToolcraftProductExportFrameContext,',
+  '  ToolcraftProductExportFrameRenderer,',
+  '  ToolcraftProductExportRenderer,',
+  '} from "./product-export-renderer";',
+  'export type {',
+  '  ToolcraftProductSvgExportFrameContext,',
+  '  ToolcraftProductSvgExportFrameRenderer,',
+  '  ToolcraftProductSvgExportRenderer,',
+  '} from "./product-svg-export-renderer";',
+  'export {',
+  '  TOOLCRAFT_FORBIDDEN_SVG_ELEMENTS,',
+  '  TOOLCRAFT_SVG_BACKGROUND_ATTRIBUTE,',
+  '  TOOLCRAFT_SVG_NAMESPACE,',
+  '  TOOLCRAFT_SVG_NON_RENDERING_CONTAINERS,',
+  '  TOOLCRAFT_SVG_PRODUCT_SCENE_ATTRIBUTE,',
+  '  TOOLCRAFT_SVG_VECTOR_PRIMITIVES,',
+  '} from "./svg-policy";',
+  '',
+].join("\n");
+
+const requiredRuntimeExportImplementationPaths = [
+  "runtime/export/artifact-export-settings.ts",
+  "runtime/export/artifact-export-request.ts",
+  "runtime/export/artifact-frame-renderer.ts",
+  "runtime/export/artifact-frame-state.ts",
+  "runtime/export/artifact-scene-frame.ts",
+  "runtime/export/image-artifact-export.ts",
+  "runtime/export/product-export-renderer.ts",
+  "runtime/export/product-svg-export-renderer.ts",
+  "runtime/export/svg-artifact-export.ts",
+  "runtime/export/svg-document.ts",
+  "runtime/export/svg-policy.ts",
+  "runtime/export/video-artifact-export.ts",
+  "runtime/export/video-encoding-backend.ts",
+  "runtime/export/video-frame-schedule.ts",
+];
+
+const generatedMediaExportEvidencePaths = [
+  "e2e/browser-infinity-canvas-svg-evidence.ts",
+  "e2e/browser-media-export-evidence.ts",
+  "e2e/decoded-pixel-observation.ts",
+  "e2e/image-artifact-inspection.ts",
+  "e2e/browser-svg-export-evidence.ts",
+  "e2e/svg-artifact-inspection.ts",
+  "e2e/video-artifact-inspection.ts",
+];
+
+const removedRuntimeTestHelperPaths = [
+  "runtime/react/canvas/canvas-shell-test-utils.tsx",
+  "runtime/react/controls-panel/testing/controls-panel-test-utils.tsx",
+  "runtime/react/layers/layers-panel-test-utils.tsx",
+  "runtime/react/timeline/timeline-panel-test-utils.tsx",
+];
+
+export async function assertGeneratedRuntimePublicBoundary(targetDir) {
+  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/ui/index.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/runtime/react/index.ts")));
+
+  const generatedRuntimeRootSource = await fs.readFile(
+    path.join(targetDir, "src/toolcraft/runtime/index.ts"),
+    "utf8",
+  );
+  assert.match(generatedRuntimeRootSource, /export \* from "\.\/export";/u);
+  assert.doesNotMatch(
+    generatedRuntimeRootSource,
+    /exportToolcraft(?:Image|Video)Artifact|createToolcraftVideoEncoderBackend/u,
+  );
+
+  const generatedRuntimeExportIndexSource = await fs.readFile(
+    path.join(targetDir, "src/toolcraft/runtime/export/index.ts"),
+    "utf8",
+  );
+  assert.equal(
+    generatedRuntimeExportIndexSource,
+    productSafeRuntimeExportIndex,
+    "Generated runtime export index must expose the exact product-safe allowlist.",
+  );
+
+  assert.ok(
+    await fs.stat(
+      path.join(
+        targetDir,
+        "src/toolcraft/runtime/model-import/worker/model-import.worker.bundle.js",
+      ),
+    ),
+  );
+
+  const generatedToolcraftFiles = await listRelativeFiles(
+    path.join(targetDir, "src/toolcraft"),
+  );
+  const expectedRuntimeFiles = (await listRelativeFiles(
+    path.join(repoRoot, "packages/toolcraft-runtime/src"),
+  ))
+    .filter((relativePath) => !isGeneratedTestSupportPath(relativePath))
+    .map((relativePath) => `runtime/${relativePath}`);
+  assert.deepEqual(
+    generatedToolcraftFiles.filter((relativePath) => relativePath.startsWith("runtime/")),
+    expectedRuntimeFiles,
+    "Generated standalone runtime must contain every production runtime module.",
+  );
+
+  for (const relativePath of requiredRuntimeExportImplementationPaths) {
+    assert.ok(
+      generatedToolcraftFiles.includes(relativePath),
+      `Generated runtime must contain ${relativePath}.`,
+    );
+  }
+  assert.equal(
+    generatedToolcraftFiles.includes("runtime/export/export.ts"),
+    false,
+    "Generated runtime must not copy the removed legacy export helper.",
+  );
+
+  for (const relativePath of generatedMediaExportEvidencePaths) {
+    assert.ok(
+      await fs.stat(path.join(targetDir, relativePath)),
+      `Generated output must contain ${relativePath}.`,
+    );
+  }
+  for (const relativePath of generatedToolcraftFiles) {
+    assert.equal(
+      isGeneratedTestSupportPath(relativePath),
+      false,
+      `Generated runtime contains test support: ${relativePath}`,
+    );
+  }
+  for (const relativePath of removedRuntimeTestHelperPaths) {
+    assert.equal(generatedToolcraftFiles.includes(relativePath), false);
+  }
+}

package/src/generate-test-standalone-assertions.mjs

@@ -87,21 +87,15 @@ export async function assertGeneratedProductStandalone({ execFileAsync, targetDi
   await writeGeneratedProductFixture(targetDir);
   await assertGeneratedProductWorklog(targetDir);
 
-  const verificationImpact = JSON.parse(
-    await fs.readFile(
-      path.join(targetDir, "src/app/app-verification-impact.json"),
-      "utf8",
-    ),
+  const appSchemaSource = await fs.readFile(
+    path.join(targetDir, "src/app/app-schema.ts"),
+    "utf8",
   );
-  assert.equal(verificationImpact.version, 3);
-  assert.ok(
-    verificationImpact.owners.every(
-      (owner) =>
-        owner.acceptanceIds.length > 0 &&
-        (owner.kind !== "performance" || owner.passIds.length > 0),
-    ),
-    "Generated fixture verification ownership must name acceptance IDs and exact performance pass IDs.",
+  assert.match(
+    appSchemaSource,
+    /applicability:\s*\{\s*mode:\s*"always"\s*\}/u,
   );
+  assert.doesNotMatch(appSchemaSource, /visibleWhen\s*:/u);
 
   const performanceSource = await fs.readFile(
     path.join(targetDir, "src/app/app-performance.ts"),

package/src/generate-test-standalone-delivery-stages.mjs

@@ -66,8 +66,8 @@ export async function assertGeneratedInitialFunctionalDelivery({
   assert.equal(checkpoint.version, 1);
   assert.equal(checkpoint.delivery.kind, "delivery-verification");
   assert.equal(checkpoint.delivery.runner, "protected-delivery");
-  assert.equal(checkpoint.delivery.version, 7);
-  assert.equal(checkpoint.delivery.planVersion, 4);
+  assert.equal(checkpoint.delivery.version, 8);
+  assert.equal(checkpoint.delivery.planVersion, 6);
   assert.equal(checkpoint.delivery.plan.kind, "functional");
   assert.deepEqual(checkpoint.delivery.plan.basis, { kind: "initial" });
   assert.deepEqual(
@@ -108,87 +108,3 @@ export async function assertGeneratedInitialFunctionalDelivery({
     /ENOENT/u,
   );
 }
-
-export async function assertGeneratedLaterFunctionalDelivery({
-  acceptanceCatalog,
-  browserEnv,
-  checkpointPath,
-  execFileAsync,
-  expectedAcceptanceIds,
-  expectedBrowserTestNames,
-  expectedChangedFiles,
-  expectedProductTestFiles,
-  targetDir,
-}) {
-  const { tests } = await runGeneratedDeliveryWithLedger({
-    env: browserEnv,
-    execFileAsync,
-    targetDir,
-  });
-  const expectedRows = acceptanceCatalog.filter(({ acceptanceId }) =>
-    expectedAcceptanceIds.includes(acceptanceId),
-  );
-  assert.equal(
-    expectedRows.length,
-    expectedAcceptanceIds.length,
-  );
-  const checkpoint = JSON.parse(await fs.readFile(checkpointPath, "utf8"));
-  const receipt = checkpoint.delivery;
-  assert.equal(receipt.version, 7);
-  assert.equal(receipt.planVersion, 4);
-  assert.equal(receipt.plan.kind, "functional");
-  assert.equal(Object.hasOwn(receipt, "verificationTier"), false);
-  assert.deepEqual(receipt.plan.basis.changedFiles, expectedChangedFiles);
-  assert.deepEqual(
-    receipt.plan.steps.map(({ kind }) => kind),
-    [
-      "code-health",
-      "product-tests",
-      "build",
-      "browser-functional",
-    ],
-  );
-  assert.deepEqual(
-    receipt.plan.steps.find(({ kind }) => kind === "product-tests"),
-    {
-      files: expectedProductTestFiles,
-      kind: "product-tests",
-    },
-  );
-  assert.deepEqual(
-    receipt.plan.steps.find(
-      ({ kind }) => kind === "browser-functional",
-    ),
-    {
-      kind: "browser-functional",
-      testNames: expectedBrowserTestNames,
-    },
-  );
-  assert.deepEqual(
-    receipt.evidence.find(
-      ({ kind }) => kind === "browser-functional",
-    ),
-    {
-      kind: "browser-functional",
-      testNames: expectedBrowserTestNames,
-    },
-  );
-  assert.ok(
-    receipt.plan.steps.some(({ kind }) => kind === "browser-functional"),
-  );
-  assert.equal(
-    receipt.plan.steps.some(({ kind }) => kind === "browser-performance"),
-    false,
-  );
-  assert.equal(checkpoint.performanceBaseline, null);
-  assert.equal(checkpoint.currentPerformance, null);
-  assert.equal(
-    receipt.evidence.some(({ kind }) => kind === "browser-performance"),
-    false,
-  );
-  assertGeneratedExecutionLedger({
-    expectedFunctionalRows: expectedRows,
-    expectedPerformanceEvidence: [],
-    tests,
-  });
-}

package/src/generate.test.mjs

@@ -387,6 +387,10 @@ describe("generateToolcraft", () => {
       packageJson.scripts["verify:delivery"],
       "node scripts/run-delivery-verification.mjs",
     );
+    assert.equal(
+      packageJson.scripts["test:feature"],
+      "node scripts/run-feature-verification.mjs",
+    );
     assert.equal(packageJson.scripts["verify:quick"], undefined);
     assert.equal(packageJson.scripts["verify:ui"], undefined);
     assert.equal(

package/src/generated-integrity-manifest.test.mjs

@@ -46,7 +46,6 @@ const independentlyProductOwnedPaths = new Set([
   "e2e/app-performance-path-adapters.ts",
   "src/app/app-acceptance-data.ts",
   "src/app/app-composition.tsx",
-  "src/app/app-verification-impact.json",
   "src/app/app-performance.ts",
   "src/app/app-schema.test.ts",
   "src/app/app-schema.ts",
@@ -117,13 +116,17 @@ describe("collectFrameworkOwnedGeneratedFiles", () => {
       "e2e/browser-execution-ledger.ts",
       "e2e/browser-render-scale-evidence.ts",
       "e2e/toolcraft-delivery-catalog-reporter.ts",
+      "e2e/toolcraft-feature-verification-reporter.ts",
       "src/app/acceptance/types.ts",
       "src/app/app-acceptance.render-scale.test.ts",
       "scripts/toolcraft-delivery-anchor.mjs",
       "scripts/toolcraft-delivery-executor.mjs",
+      "scripts/toolcraft-delivery-lifecycle.mjs",
       "scripts/toolcraft-delivery-plan.mjs",
       "scripts/toolcraft-proof-process.mjs",
-      "scripts/toolcraft-verification-impact.mjs",
+      "scripts/run-feature-verification.mjs",
+      "scripts/toolcraft-feature-verification-plan.mjs",
+      "src/app/acceptance/feature-verification-selection.ts",
     ]) {
       assert.ok(protectedFiles.includes(relativePath));
     }

package/src/generated-source-policy.test.mjs

@@ -17,10 +17,6 @@ describe("isGeneratedTestSupportPath", () => {
       "scripts/toolcraft-functional-proof-primitives.d.mts",
       "scripts/toolcraft-functional-proof-model.mjs",
       "scripts/toolcraft-functional-proof-model.d.mts",
-      "scripts/toolcraft-verification-input-roles.mjs",
-      "scripts/toolcraft-verification-input-roles.d.mts",
-      "scripts/toolcraft-verification-impact-inventory.mjs",
-      "scripts/toolcraft-verification-impact-inventory.d.mts",
       "scripts/toolcraft-delivery-functional-context.mjs",
       "scripts/toolcraft-delivery-functional-context.d.mts",
     ];

package/src/package-json.mjs

@@ -72,6 +72,11 @@ export function createGeneratedPackageJson({
       "starterPackageJson.scripts.verify:perf is required to create a generated package manifest.",
     );
   }
+  if (!starterScripts["test:feature"]) {
+    throw new Error(
+      "starterPackageJson.scripts.test:feature is required to create a generated package manifest.",
+    );
+  }
 
   const packageJson = {
     name: sanitizePackageName(name),

package/src/package-json.test.mjs

@@ -36,6 +36,7 @@ describe("createGeneratedPackageJson", () => {
           dev: "vite dev",
           test: "vitest run",
           "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+          "test:feature": "node scripts/run-feature-verification.mjs",
           typecheck: "tsc -p tsconfig.json --noEmit",
           "verify:delivery": "node scripts/run-delivery-verification.mjs",
           "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -64,6 +65,7 @@ describe("createGeneratedPackageJson", () => {
         build: "tsc -p tsconfig.json --noEmit && vite build",
         dev: "vite dev",
         test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+        "test:feature": "node scripts/run-feature-verification.mjs",
         typecheck: "tsc -p tsconfig.json --noEmit",
         "verify:delivery": "node scripts/run-delivery-verification.mjs",
         "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -130,6 +132,23 @@ describe("createGeneratedPackageJson", () => {
     );
   });
 
+  it("rejects starter manifests without the focused feature verifier", () => {
+    assert.throws(
+      () =>
+        createGeneratedPackageJson({
+          name: "Generated App",
+          starterPackageJson: {
+            scripts: {
+              "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+              "verify:delivery": "node scripts/run-delivery-verification.mjs",
+              "verify:perf": "node scripts/run-browser-performance.mjs",
+            },
+          },
+        }),
+      /scripts\.test:feature is required/,
+    );
+  });
+
   for (const packageManager of ["npm", "pnpm"]) {
     it(`preserves direct protected entry points without synthesizing aliases for ${packageManager}`, () => {
       const packageJson = createGeneratedPackageJson({
@@ -141,6 +160,7 @@ describe("createGeneratedPackageJson", () => {
             dev: "vite dev",
             test: "vitest run",
             "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+            "test:feature": "node scripts/run-feature-verification.mjs",
             typecheck: "tsc -p tsconfig.json --noEmit",
             "verify:delivery": "node scripts/run-delivery-verification.mjs",
             "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -152,6 +172,7 @@ describe("createGeneratedPackageJson", () => {
         build: "vite build",
         dev: "vite dev",
         test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+        "test:feature": "node scripts/run-feature-verification.mjs",
         typecheck: "tsc -p tsconfig.json --noEmit",
         "verify:delivery": "node scripts/run-delivery-verification.mjs",
         "verify:perf": "node scripts/run-browser-performance.mjs",

package/src/package-manager.mjs

@@ -33,7 +33,9 @@ const COMMAND_REFERENCE_DELIMITER_PATTERN =
 export const GENERATED_SCRIPT_COMMANDS = [
   "build",
   "dev",
+  "reference:study",
   "test",
+  "test:feature",
   "typecheck",
   "verify:delivery",
   "verify:perf",

package/src/package-manager.test.mjs

@@ -68,7 +68,9 @@ describe("package manager commands", () => {
     assert.deepEqual(GENERATED_SCRIPT_COMMANDS, [
       "build",
       "dev",
+      "reference:study",
       "test",
+      "test:feature",
       "typecheck",
       "verify:delivery",
       "verify:perf",
@@ -96,8 +98,10 @@ describe("package manager commands", () => {
       "pnpm verify:perf",
       "pnpm typecheck",
       "pnpm test",
+      "pnpm test:feature -- material.layer",
       "pnpm build",
       "pnpm dev",
+      "pnpm reference:study -- --source /absolute/reference.mp4",
       "pnpm verify:quick",
       "pnpm exec vite dev --host 127.0.0.1",
     ].join("\n");
@@ -110,8 +114,10 @@ describe("package manager commands", () => {
         "npm run verify:perf",
         "npm run typecheck",
         "npm run test",
+        "npm run test:feature -- material.layer",
         "npm run build",
         "npm run dev",
+        "npm run reference:study -- --source /absolute/reference.mp4",
         "pnpm verify:quick",
         "npm exec -- vite dev --host 127.0.0.1",
       ].join("\n"),
@@ -129,6 +135,7 @@ describe("package manager commands", () => {
       "pnpm test:browser",
       "pnpm test:delivery",
       "pnpm dev:restart",
+      "pnpm reference:study:legacy",
       "pnpm verify:perf:record-iteration",
       "pnpm verify:delivery:legacy",
       "pnpm testing",
@@ -147,6 +154,7 @@ describe("package manager commands", () => {
         "pnpm test:browser",
         "pnpm test:delivery",
         "pnpm dev:restart",
+        "pnpm reference:study:legacy",
         "pnpm verify:perf:record-iteration",
         "pnpm verify:delivery:legacy",
         "pnpm testing",