hyperframes 0.7.77 → 0.7.78

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.7.77" : "0.0.0-dev";
+    VERSION = true ? "0.7.78" : "0.0.0-dev";
   }
 });
 
@@ -62886,6 +62886,15 @@ function memoryAdaptiveCacheBytesMb() {
   if (total <= LOW_MEMORY_TOTAL_MB_THRESHOLD) return 256;
   return DEFAULT_CONFIG2.frameDataUriCacheBytesLimitMb;
 }
+function isDrawElementPlatform(platform10) {
+  return platform10 === "darwin" || platform10 === "win32";
+}
+function resolveDefaultDrawElement(args) {
+  if (!args.useDrawElement) return false;
+  if (args.explicitOptIn) return true;
+  if (!isDrawElementPlatform(args.platform) || args.browserGpuMode === "software") return false;
+  return args.workerEncode;
+}
 function resolveConfig(overrides) {
   const env = (key2) => process.env[key2];
   const envNum = (key2, fallback) => {
@@ -63014,12 +63023,13 @@ function resolveConfig(overrides) {
     ...overrides
   };
   const explicitDrawElementOptIn = env("PRODUCER_EXPERIMENTAL_FAST_CAPTURE") === "true" || overrides?.useDrawElement === true;
-  if (merged.useDrawElement && !explicitDrawElementOptIn && !(process.platform === "darwin" && merged.browserGpuMode !== "software")) {
-    merged.useDrawElement = false;
-  }
-  if (merged.useDrawElement && !explicitDrawElementOptIn && !merged.enableDrawElementWorkerEncode) {
-    merged.useDrawElement = false;
-  }
+  merged.useDrawElement = resolveDefaultDrawElement({
+    useDrawElement: merged.useDrawElement,
+    explicitOptIn: explicitDrawElementOptIn,
+    platform: process.platform,
+    browserGpuMode: merged.browserGpuMode,
+    workerEncode: merged.enableDrawElementWorkerEncode
+  });
   const explicitForceScreenshotOptOut = env("PRODUCER_FORCE_SCREENSHOT") === "false" || overrides?.forceScreenshot === false;
   if (explicitForceScreenshotOptOut) {
     merged.forceScreenshotExplicitlyOptedOut = true;
@@ -64510,15 +64520,22 @@ function instrumentAcceleratedCanvases() {
     return ctx;
   };
 }
-async function detectSwiftShader(page) {
+function classifyGpuRenderer(renderer) {
+  if (!renderer) return void 0;
+  const r2 = renderer.toLowerCase();
+  const backend = r2.includes("swiftshader") ? "swiftshader" : r2.includes("metal") ? "metal" : r2.includes("direct3d11") || r2.includes("d3d11") ? "d3d11" : r2.includes("direct3d9") || r2.includes("d3d9") ? "d3d9" : r2.includes("vulkan") ? "vulkan" : r2.includes("opengl") || r2.includes("angle") ? "opengl" : "other";
+  const vendor = r2.includes("apple") ? "apple" : r2.includes("nvidia") ? "nvidia" : r2.includes("amd") || r2.includes("radeon") ? "amd" : r2.includes("intel") ? "intel" : r2.includes("microsoft") ? "microsoft" : "other";
+  return `${backend}/${vendor}`;
+}
+async function detectGpuBackend(page) {
   return page.evaluate(() => {
     const canvas = document.createElement("canvas");
     const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
-    if (!gl) return false;
+    if (!gl) return { isSwiftShader: false, renderer: null };
     const ext = gl.getExtension("WEBGL_debug_renderer_info");
-    if (!ext) return false;
+    if (!ext) return { isSwiftShader: false, renderer: null };
     const renderer = gl.getParameter(ext.UNMASKED_RENDERER_WEBGL);
-    return renderer.toLowerCase().includes("swiftshader");
+    return { isSwiftShader: renderer.toLowerCase().includes("swiftshader"), renderer };
   });
 }
 async function injectDrawElementCanvas(page, width, height) {
@@ -66248,7 +66265,9 @@ async function initDrawElementOrTransparentBackground(session, page, logInitPhas
     );
   }
   if (useDrawElement) {
-    session.isSwiftShader = await detectSwiftShader(page);
+    const gpuBackend = await detectGpuBackend(page);
+    session.isSwiftShader = gpuBackend.isSwiftShader;
+    session.gpuRenderer = classifyGpuRenderer(gpuBackend.renderer);
     const transparent = session.options.format === "png";
     async function routeToFallback() {
       session.captureMode = session.launchCaptureMode;
@@ -67960,6 +67979,7 @@ function getCapturePerfSummary(session) {
     beginFrameNoDamage: session.beginFrameNoDamageCount,
     beginFrameHasDamage: session.beginFrameHasDamageCount,
     captureMode: session.captureMode,
+    gpuRenderer: session.gpuRenderer,
     deGateReason: session.deGateReason,
     deFallbackTrigger: session.deFallbackTrigger,
     deWorkerEncode: session.workerEncodeEnabled ?? false,
@@ -88550,8 +88570,10 @@ __export(system_exports, {
   bytesToMb: () => bytesToMb,
   getAvailableMemoryMb: () => getAvailableMemoryMb,
   getFreeDiskMb: () => getFreeDiskMb,
+  getPowerState: () => getPowerState,
   getShmSizeMb: () => getShmSizeMb,
-  getSystemMeta: () => getSystemMeta
+  getSystemMeta: () => getSystemMeta,
+  parsePmsetPowerSource: () => parsePmsetPowerSource
 });
 import { cpus as cpus2, freemem as freemem2, platform as platform3, release as release3 } from "os";
 import { existsSync as existsSync20, readFileSync as readFileSync10, statfsSync } from "fs";
@@ -88626,6 +88648,31 @@ function getFreeDiskMb(path2 = ".") {
     return null;
   }
 }
+function parsePmsetPowerSource(raw) {
+  const m2 = raw.match(/Now drawing from '([^']+)'/);
+  if (!m2) return null;
+  return m2[1] === "Battery Power";
+}
+function getPowerState() {
+  if (platform3() !== "darwin") {
+    return { on_battery: null, low_power_mode: null };
+  }
+  let on_battery = null;
+  let low_power_mode = null;
+  try {
+    on_battery = parsePmsetPowerSource(
+      execSync2("pmset -g batt", { encoding: "utf-8", timeout: 2e3 })
+    );
+  } catch {
+  }
+  try {
+    const raw = execSync2("pmset -g", { encoding: "utf-8", timeout: 2e3 });
+    const m2 = raw.match(/lowpowermode\s+(\d)/);
+    if (m2) low_power_mode = m2[1] === "1";
+  } catch {
+  }
+  return { on_battery, low_power_mode };
+}
 function getAvailableMemoryMb() {
   const fallback = bytesToMb(freemem2());
   if (platform3() === "darwin") {
@@ -88855,6 +88902,14 @@ __export(events_exports, {
   trackSkillsInstallSkipped: () => trackSkillsInstallSkipped,
   trackTranscribeUnavailable: () => trackTranscribeUnavailable
 });
+function powerStateFields() {
+  if (!shouldTrack()) return {};
+  const power = getPowerState();
+  return {
+    on_battery: power.on_battery ?? void 0,
+    low_power_mode: power.low_power_mode ?? void 0
+  };
+}
 function runIdField(runId3) {
   return runId3 !== void 0 ? { run_id: runId3 } : {};
 }
@@ -88892,6 +88947,7 @@ function renderObservabilityEventProperties(props) {
     de_worker_inversion: props.captureDeWorkerInversion,
     de_pre_inversion_workers: props.captureDePreInversionWorkers,
     de_parallel_router: props.captureDeParallelRouter,
+    gpu_renderer: props.captureDeGpuRenderer,
     de_pre_router_workers: props.captureDePreRouterWorkers,
     de_self_verify_fallback: props.captureDeSelfVerifyFallback,
     de_fallback_reason: props.captureDeFallbackReason,
@@ -88960,6 +89016,7 @@ function trackRenderComplete(props) {
       de_parallel_router: props.deParallelRouter,
       de_pre_router_workers: props.dePreRouterWorkers,
       de_gate_reason: props.deGateReason,
+      gpu_renderer: props.gpuRenderer,
       de_worker_encode: props.deWorkerEncode,
       de_verify_armed: props.deVerifyArmed,
       de_verify_checked: props.deVerifyChecked,
@@ -88975,6 +89032,7 @@ function trackRenderComplete(props) {
       de_blank_recaptures: props.deBlankRecaptures,
       de_boundary_frames: props.deBoundaryFrames,
       de_ncpr_fallbacks: props.deNcprFallbacks,
+      ...powerStateFields(),
       source: props.source ?? "cli",
       composition_duration_ms: props.compositionDurationMs,
       composition_width: props.compositionWidth,
@@ -89027,6 +89085,11 @@ function trackRenderError(props) {
       elapsed_ms: props.elapsedMs,
       peak_memory_mb: props.peakMemoryMb,
       memory_free_mb: props.memoryFreeMb,
+      ...powerStateFields(),
+      // gpu_renderer arrives via renderObservabilityEventProperties below:
+      // on the failure path perfSummary is never built, so live capture
+      // observability is the only source. Backend attribution matters MOST
+      // here — a win32 D3D11 crash is what the rollout is watching for.
       ...renderObservabilityEventProperties(props)
     },
     props.distinctId
@@ -89193,6 +89256,7 @@ var init_events = __esm({
     init_feedbackRating();
     init_client();
     init_config();
+    init_system();
   }
 });
 
@@ -93071,6 +93135,25 @@ var init_normalize = __esm({
   }
 });
 
+// src/telemetry/skill.ts
+var skill_exports = {};
+__export(skill_exports, {
+  SKILL_SLUG: () => SKILL_SLUG,
+  normalizeSkillSlug: () => normalizeSkillSlug
+});
+function normalizeSkillSlug(raw) {
+  if (typeof raw !== "string") return void 0;
+  const slug = raw.trim();
+  return SKILL_SLUG.test(slug) ? slug : void 0;
+}
+var SKILL_SLUG;
+var init_skill = __esm({
+  "src/telemetry/skill.ts"() {
+    "use strict";
+    SKILL_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+  }
+});
+
 // src/utils/projectConfig.ts
 var projectConfig_exports = {};
 __export(projectConfig_exports, {
@@ -93081,6 +93164,7 @@ __export(projectConfig_exports, {
   projectConfigPath: () => projectConfigPath,
   readProjectConfig: () => readProjectConfig,
   resolveAutoProxy: () => resolveAutoProxy,
+  seedProjectAuthoringSkill: () => seedProjectAuthoringSkill,
   writeProjectConfig: () => writeProjectConfig
 });
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
@@ -93108,7 +93192,10 @@ function normalizeConfig(partial) {
     },
     media: {
       autoProxy: typeof partial.media?.autoProxy === "boolean" ? partial.media.autoProxy : DEFAULT_PROJECT_CONFIG.media?.autoProxy
-    }
+    },
+    // Slug-gate on read so a hand-edited or corrupt value never reaches the
+    // telemetry stream; an invalid slug simply drops the attribution.
+    authoringSkill: normalizeSkillSlug(partial.authoringSkill)
   };
 }
 function writeProjectConfig(projectDir, config = DEFAULT_PROJECT_CONFIG) {
@@ -93124,11 +93211,44 @@ function resolveAutoProxy(projectDir, flagValue) {
   }
   return loadProjectConfig(projectDir).media?.autoProxy ?? true;
 }
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function seedProjectAuthoringSkill(projectDir, rawSkill) {
+  const skill = normalizeSkillSlug(rawSkill);
+  if (!skill) return;
+  const path2 = projectConfigPath(projectDir);
+  let text2;
+  try {
+    text2 = readFileSync16(path2, "utf-8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      try {
+        writeProjectConfig(projectDir, { ...DEFAULT_PROJECT_CONFIG, authoringSkill: skill });
+      } catch {
+      }
+    }
+    return;
+  }
+  try {
+    const parsed = JSON.parse(text2);
+    if (!isJsonObject(parsed)) return;
+    if (normalizeSkillSlug(parsed.authoringSkill)) return;
+    parsed.authoringSkill = skill;
+    const indent = /\n([ \t]+)"/.exec(text2)?.[1] ?? "  ";
+    writeFileSync10(path2, JSON.stringify(parsed, null, indent) + "\n", "utf-8");
+  } catch {
+  }
+}
 var PROJECT_CONFIG_FILENAME, PROJECT_CONFIG_SCHEMA_URL, DEFAULT_PROJECT_CONFIG;
 var init_projectConfig = __esm({
   "src/utils/projectConfig.ts"() {
     "use strict";
     init_registry2();
+    init_skill();
     PROJECT_CONFIG_FILENAME = "hyperframes.json";
     PROJECT_CONFIG_SCHEMA_URL = "https://hyperframes.heygen.com/schema/hyperframes.json";
     DEFAULT_PROJECT_CONFIG = {
@@ -95870,6 +95990,7 @@ function renderObservabilityTelemetryPayload(observability) {
     captureDeWorkerInversion: capture2.deWorkerInversion,
     captureDePreInversionWorkers: capture2.dePreInversionWorkers,
     captureDeParallelRouter: capture2.deParallelRouter,
+    captureDeGpuRenderer: capture2.deGpuRenderer,
     captureDePreRouterWorkers: capture2.dePreRouterWorkers,
     captureDeSelfVerifyFallback: capture2.deSelfVerifyFallback,
     captureDeFallbackReason: capture2.deFallbackReason,
@@ -110227,6 +110348,9 @@ function aggregateDrawElement(perfs, de2) {
   const gateReasons = [
     ...new Set(perfs.map((p2) => p2.deGateReason).filter((r2) => !!r2))
   ].sort();
+  const gpuRenderers = [
+    ...new Set(perfs.map((p2) => p2.gpuRenderer).filter((r2) => !!r2))
+  ].sort();
   const drain = de2.drainStats;
   return {
     mode: modes.join("|") || "unknown",
@@ -110237,6 +110361,7 @@ function aggregateDrawElement(perfs, de2) {
     parallelRouter: de2.parallelRouter ?? "none",
     preRouterWorkers: de2.preRouterWorkers,
     gateReason: gateReasons.length > 0 ? gateReasons.join("|") : void 0,
+    gpuRenderer: gpuRenderers.length > 0 ? gpuRenderers.join("|") : void 0,
     workerEncode: perfs.some((p2) => p2.deWorkerEncode),
     verifyArmed: perfs.reduce((sum, p2) => sum + (p2.deVerifyArmed ?? 0), 0),
     verifyChecked: drain?.verifyChecked ?? 0,
@@ -117423,6 +117548,10 @@ function resolveVideoExtractionPolicy(env = process.env) {
   const maxTransientRetries = failureMode !== "off" && env.HF_VIDEO_EXTRACTION_MAX_RETRIES?.trim() === "1" ? 1 : 0;
   return { failureMode, maxTransientRetries };
 }
+function assertVideoExtractionSucceeded(result) {
+  const error = buildVideoExtractionStageError(result);
+  if (error) throw error;
+}
 function buildVideoExtractionStageError(result) {
   if (result.success && result.errors.length === 0) return null;
   const counts = /* @__PURE__ */ new Map();
@@ -121335,7 +121464,7 @@ function resolveInversionRetryPlan(args) {
   };
 }
 function shouldPreferParallelDrawElement(args) {
-  return args.routerEnabled && args.workerCount > 1 && typeof args.requestedWorkers !== "number" && args.useDrawElement && !args.deCompileGate && !args.forceScreenshot && args.outputFormat === "mp4" && args.minFrames > 0 && args.totalFrames >= args.minFrames && !args.layeredOrEffectRoute && !args.supersampling && !args.probeDeGated && !args.experimentalParallelDeOptIn && // RAM floor: routed parallel DE runs 3 concurrent hardware-GPU Chrome
+  return args.routerEnabled && args.parallelStreamingAvailable && args.workerCount > 1 && typeof args.requestedWorkers !== "number" && args.useDrawElement && !args.deCompileGate && !args.forceScreenshot && args.outputFormat === "mp4" && args.minFrames > 0 && args.totalFrames >= args.minFrames && !args.layeredOrEffectRoute && !args.supersampling && !args.probeDeGated && !args.experimentalParallelDeOptIn && // RAM floor: routed parallel DE runs 3 concurrent hardware-GPU Chrome
   // instances. On a 16 GB machine that produced vertical black slabs in the
   // final MP4 (wild report, CLI 0.7.52) — compositor tiles evicted under
   // GPU/memory pressure, and sampled self-verify can miss partial-frame
@@ -121929,8 +122058,8 @@ async function executeRenderPipeline(input2) {
     });
     const deParallelRouterEnabled = process.env.HF_DE_PARALLEL_ROUTER === "true";
     const deParallelMinFramesRaw = process.env.HF_DE_PARALLEL_MIN_FRAMES;
-    const deParallelMinFramesNum = deParallelMinFramesRaw === void 0 || deParallelMinFramesRaw.trim() === "" ? 2e3 : Number(deParallelMinFramesRaw);
-    const deParallelMinFrames = Number.isFinite(deParallelMinFramesNum) ? deParallelMinFramesNum : 2e3;
+    const deParallelMinFramesNum = deParallelMinFramesRaw === void 0 || deParallelMinFramesRaw.trim() === "" ? 700 : Number(deParallelMinFramesRaw);
+    const deParallelMinFrames = Number.isFinite(deParallelMinFramesNum) ? deParallelMinFramesNum : 700;
     const deParallelMinMemRaw = process.env.HF_DE_PARALLEL_MIN_MEM_MB;
     const deParallelMinMemNum = deParallelMinMemRaw === void 0 || deParallelMinMemRaw.trim() === "" ? 24576 : Number(deParallelMinMemRaw);
     const deParallelMinMemoryMb = Number.isFinite(deParallelMinMemNum) ? deParallelMinMemNum : 24576;
@@ -121948,6 +122077,15 @@ async function executeRenderPipeline(input2) {
       probeDeGated: probeSession !== null && probeSession.captureMode !== "drawelement" && !probeSession.deInitDeferred,
       experimentalParallelDeOptIn: process.env.PRODUCER_EXPERIMENTAL_FAST_CAPTURE === "true" || process.env.HF_DE_PARALLEL_STREAM === "true",
       routerEnabled: deParallelRouterEnabled,
+      // Router pins 3 workers for the streaming path; don't pin when the
+      // duration cap (or any other streaming gate) would turn that path off.
+      parallelStreamingAvailable: shouldUseStreamingEncode(
+        cfg,
+        outputFormat,
+        3,
+        job.duration,
+        true
+      ),
       totalMemoryMb: Math.round(totalmem2() / (1024 * 1024)),
       minMemoryMb: deParallelMinMemoryMb
     });
@@ -122071,7 +122209,12 @@ async function executeRenderPipeline(input2) {
       // to 3 workers regardless of calibration is the leading suspect for
       // any resource-pressure failure unique to this cohort.
       dePreInversionWorkers: deWorkerInversion ? preRoutingWorkerCount : void 0,
-      dePreRouterWorkers: deParallelRouter ? preRoutingWorkerCount : void 0
+      dePreRouterWorkers: deParallelRouter ? preRoutingWorkerCount : void 0,
+      // Same rationale as the counters above: carried on live capture
+      // observability, not only the success-path perfSummary, so a crash /
+      // OOM / timeout still reports which GPU backend it happened on. That
+      // is the cohort the win32 D3D11 rollout most needs to attribute.
+      deGpuRenderer: probeSession?.gpuRenderer
     });
     observability.checkpoint("worker_resolution", "resolved", {
       workerCount,
@@ -124194,6 +124337,7 @@ var init_server = __esm({
     init_renderRequest();
     DEFAULT_SERVER_FPS = { num: 30, den: 1 };
     SAFE_RENDER_ERROR_CODES = /* @__PURE__ */ new Set([
+      "INVALID_VIDEO_METADATA",
       "VIDEO_SOURCE_UNRENDERABLE",
       "VIDEO_EXTRACTION_FAILED"
     ]);
@@ -124578,6 +124722,154 @@ import { dirname as dirname28, join as join63 } from "path";
 import { existsSync as existsSync56, readFileSync as readFileSync33 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { promisify as promisify4 } from "util";
+function metadataError(field, expectation) {
+  throw new PlanVideosMetadataError(`${field} ${expectation}`);
+}
+function readRecord(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    metadataError(field, "must be an object");
+  }
+  return value;
+}
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    metadataError(field, "must be a non-empty string");
+  }
+  return value;
+}
+function readString(value, field) {
+  if (typeof value !== "string") {
+    metadataError(field, "must be a string");
+  }
+  return value;
+}
+function readFiniteNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    metadataError(field, "must be a finite number");
+  }
+  return value;
+}
+function readBoolean(value, field) {
+  if (typeof value !== "boolean") {
+    metadataError(field, "must be boolean");
+  }
+  return value;
+}
+function readPositiveInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    metadataError(field, "must be a positive integer");
+  }
+  return value;
+}
+function readNonNegativeInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    metadataError(field, "must be a non-negative integer");
+  }
+  return value;
+}
+function readVideoMetadata(value, field) {
+  const record = readRecord(value, field);
+  let colorSpace = null;
+  if (record.colorSpace !== null) {
+    const color = readRecord(record.colorSpace, `${field}.colorSpace`);
+    colorSpace = {
+      colorTransfer: readString(color.colorTransfer, `${field}.colorSpace.colorTransfer`),
+      colorPrimaries: readString(color.colorPrimaries, `${field}.colorSpace.colorPrimaries`),
+      colorSpace: readString(color.colorSpace, `${field}.colorSpace.colorSpace`)
+    };
+  }
+  return {
+    durationSeconds: readFiniteNumber(record.durationSeconds, `${field}.durationSeconds`),
+    videoStreamDurationSeconds: readFiniteNumber(
+      record.videoStreamDurationSeconds,
+      `${field}.videoStreamDurationSeconds`
+    ),
+    width: readPositiveInteger(record.width, `${field}.width`),
+    height: readPositiveInteger(record.height, `${field}.height`),
+    fps: readFiniteNumber(record.fps, `${field}.fps`),
+    videoCodec: readNonEmptyString(record.videoCodec, `${field}.videoCodec`),
+    hasAudio: readBoolean(record.hasAudio, `${field}.hasAudio`),
+    isVFR: readBoolean(record.isVFR, `${field}.isVFR`),
+    hasAlpha: readBoolean(record.hasAlpha, `${field}.hasAlpha`),
+    colorSpace
+  };
+}
+function parsePlanVideosJson(value) {
+  const record = readRecord(value, "meta/videos.json");
+  if (!Array.isArray(record.videos) || !Array.isArray(record.extracted)) {
+    metadataError("meta/videos.json", "must contain videos and extracted arrays");
+  }
+  const videos = record.videos.map((value2, index) => {
+    const field = `meta/videos.json.videos[${index}]`;
+    const video = readRecord(value2, field);
+    return {
+      id: readNonEmptyString(video.id, `${field}.id`),
+      src: readNonEmptyString(video.src, `${field}.src`),
+      start: readFiniteNumber(video.start, `${field}.start`),
+      end: readFiniteNumber(video.end, `${field}.end`),
+      mediaStart: readFiniteNumber(video.mediaStart, `${field}.mediaStart`),
+      loop: readBoolean(video.loop, `${field}.loop`),
+      hasAudio: readBoolean(video.hasAudio, `${field}.hasAudio`)
+    };
+  });
+  const extracted = record.extracted.map((value2, index) => {
+    const field = `meta/videos.json.extracted[${index}]`;
+    const entry = readRecord(value2, field);
+    return {
+      videoId: readNonEmptyString(entry.videoId, `${field}.videoId`),
+      srcPath: readNonEmptyString(entry.srcPath, `${field}.srcPath`),
+      framePattern: readNonEmptyString(entry.framePattern, `${field}.framePattern`),
+      fps: readFiniteNumber(entry.fps, `${field}.fps`),
+      totalFrames: readNonNegativeInteger(entry.totalFrames, `${field}.totalFrames`),
+      metadata: readVideoMetadata(entry.metadata, `${field}.metadata`)
+    };
+  });
+  const videoIds = /* @__PURE__ */ new Set();
+  for (const video of videos) {
+    if (videoIds.has(video.id)) {
+      metadataError("meta/videos.json.videos", `contains duplicate id ${JSON.stringify(video.id)}`);
+    }
+    videoIds.add(video.id);
+  }
+  const extractedIds = /* @__PURE__ */ new Set();
+  for (const entry of extracted) {
+    if (extractedIds.has(entry.videoId)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `contains duplicate videoId ${JSON.stringify(entry.videoId)}`
+      );
+    }
+    extractedIds.add(entry.videoId);
+    if (!videoIds.has(entry.videoId)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `references undeclared video ${JSON.stringify(entry.videoId)}`
+      );
+    }
+  }
+  for (const video of videos) {
+    if (!extractedIds.has(video.id)) {
+      metadataError(
+        "meta/videos.json.extracted",
+        `is missing declared video ${JSON.stringify(video.id)}`
+      );
+    }
+  }
+  return { videos, extracted };
+}
+function buildPlanVideosJson(input2) {
+  const videos = input2.videos.map((video, index) => {
+    if (Number.isFinite(video.end)) return { ...video };
+    if (!Number.isFinite(input2.compositionEnd) || input2.compositionEnd <= 0 || input2.compositionEnd <= video.start) {
+      metadataError(
+        `meta/videos.json.videos[${index}].end`,
+        "cannot be resolved without a finite composition end after its start"
+      );
+    }
+    return { ...video, end: input2.compositionEnd };
+  });
+  return parsePlanVideosJson({ videos, extracted: input2.extracted });
+}
 async function readFfmpegVersion() {
   if (cachedFfmpegVersion !== null) return cachedFfmpegVersion;
   const { stdout: stdout2 } = await execFile6("ffmpeg", ["-version"], { maxBuffer: 1024 * 1024 });
@@ -124634,7 +124926,7 @@ function readProducerVersion() {
   cachedProducerVersion = "0.0.0-unknown";
   return cachedProducerVersion;
 }
-var PLAN_VIDEOS_META_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, execFile6, cachedFfmpegVersion, cachedProducerVersion;
+var PLAN_VIDEOS_META_RELATIVE_PATH, PLAN_AUDIO_RELATIVE_PATH, INVALID_VIDEO_METADATA, PlanVideosMetadataError, execFile6, cachedFfmpegVersion, cachedProducerVersion;
 var init_shared2 = __esm({
   "../producer/src/services/distributed/shared.ts"() {
     "use strict";
@@ -124642,6 +124934,16 @@ var init_shared2 = __esm({
     init_logger();
     PLAN_VIDEOS_META_RELATIVE_PATH = "meta/videos.json";
     PLAN_AUDIO_RELATIVE_PATH = "audio.aac";
+    INVALID_VIDEO_METADATA = "INVALID_VIDEO_METADATA";
+    PlanVideosMetadataError = class extends Error {
+      // Read by cloud adapters across the package boundary to classify retries.
+      // fallow-ignore-next-line unused-class-member
+      code = INVALID_VIDEO_METADATA;
+      constructor(message) {
+        super(message);
+        this.name = "PlanVideosMetadataError";
+      }
+    };
     execFile6 = promisify4(execFileCallback);
     cachedFfmpegVersion = null;
     cachedProducerVersion = null;
@@ -125117,6 +125419,9 @@ async function plan(projectDir, config, planDir) {
     materializeSymlinks: true
   });
   if (extractResult.failureToEnforce) throw extractResult.failureToEnforce;
+  if (extractResult.extractionResult) {
+    assertVideoExtractionSucceeded(extractResult.extractionResult);
+  }
   const audioResult = await runAudioStage({
     projectDir,
     workDir,
@@ -125139,8 +125444,9 @@ async function plan(projectDir, config, planDir) {
   }
   if (existsSync57(finalCompiledDir)) rmSync18(finalCompiledDir, { recursive: true, force: true });
   renameSync12(compiledDir, finalCompiledDir);
-  const planVideosJson = {
+  const planVideosJson = buildPlanVideosJson({
     videos: composition.videos,
+    compositionEnd: job.duration ?? Number.NaN,
     extracted: (extractResult.extractionResult?.extracted ?? []).map((ext) => ({
       videoId: ext.videoId,
       srcPath: ext.srcPath,
@@ -125149,7 +125455,7 @@ async function plan(projectDir, config, planDir) {
       totalFrames: ext.totalFrames,
       metadata: ext.metadata
     }))
-  };
+  });
   mkdirSync29(join65(planDir, "meta"), { recursive: true });
   writeFileSync20(
     join65(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
@@ -125635,90 +125941,20 @@ function listVideoFramePaths(planV1Dir, videos) {
     };
   });
 }
-function readFiniteNumber(value, field) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new PlanV2IntegrityError(`${field} must be a finite number`);
-  }
-  return value;
-}
-function readBoolean(value, field) {
-  if (typeof value !== "boolean") {
-    throw new PlanV2IntegrityError(`${field} must be boolean`);
-  }
-  return value;
-}
-function readVideoMetadata(value, field) {
-  if (!isRecord7(value)) {
-    throw new PlanV2IntegrityError(`${field} must be an object`);
-  }
-  let colorSpace = null;
-  if (value.colorSpace !== null) {
-    if (!isRecord7(value.colorSpace)) {
-      throw new PlanV2IntegrityError(`${field}.colorSpace must be an object or null`);
+function parsePlanVideosJson2(value) {
+  try {
+    return parsePlanVideosJson(value);
+  } catch (err) {
+    if (err instanceof PlanVideosMetadataError) {
+      throw new PlanV2IntegrityError(err.message);
     }
-    colorSpace = {
-      colorTransfer: readColorComponent(
-        value.colorSpace.colorTransfer,
-        `${field}.colorSpace.colorTransfer`
-      ),
-      colorPrimaries: readColorComponent(
-        value.colorSpace.colorPrimaries,
-        `${field}.colorSpace.colorPrimaries`
-      ),
-      colorSpace: readColorComponent(value.colorSpace.colorSpace, `${field}.colorSpace.colorSpace`)
-    };
-  }
-  return {
-    durationSeconds: readFiniteNumber(value.durationSeconds, `${field}.durationSeconds`),
-    videoStreamDurationSeconds: readFiniteNumber(
-      value.videoStreamDurationSeconds,
-      `${field}.videoStreamDurationSeconds`
-    ),
-    width: readPositiveInteger(value.width, `${field}.width`),
-    height: readPositiveInteger(value.height, `${field}.height`),
-    fps: readFiniteNumber(value.fps, `${field}.fps`),
-    videoCodec: readString(value.videoCodec, `${field}.videoCodec`),
-    hasAudio: readBoolean(value.hasAudio, `${field}.hasAudio`),
-    isVFR: readBoolean(value.isVFR, `${field}.isVFR`),
-    hasAlpha: readBoolean(value.hasAlpha, `${field}.hasAlpha`),
-    colorSpace
-  };
-}
-function parsePlanVideosJson(value) {
-  if (!isRecord7(value) || !Array.isArray(value.videos) || !Array.isArray(value.extracted)) {
-    throw new PlanV2IntegrityError("meta/videos.json must contain videos and extracted arrays");
+    throw err;
   }
-  const videos = value.videos.map((video, index) => {
-    const field = `meta/videos.json.videos[${index}]`;
-    if (!isRecord7(video)) throw new PlanV2IntegrityError(`${field} must be an object`);
-    return {
-      id: readString(video.id, `${field}.id`),
-      src: readString(video.src, `${field}.src`),
-      start: readFiniteNumber(video.start, `${field}.start`),
-      end: readFiniteNumber(video.end, `${field}.end`),
-      mediaStart: readFiniteNumber(video.mediaStart, `${field}.mediaStart`),
-      loop: readBoolean(video.loop, `${field}.loop`),
-      hasAudio: readBoolean(video.hasAudio, `${field}.hasAudio`)
-    };
-  });
-  const extracted = value.extracted.map((entry, index) => {
-    const field = `meta/videos.json.extracted[${index}]`;
-    if (!isRecord7(entry)) throw new PlanV2IntegrityError(`${field} must be an object`);
-    return {
-      videoId: readString(entry.videoId, `${field}.videoId`),
-      srcPath: readString(entry.srcPath, `${field}.srcPath`),
-      framePattern: readString(entry.framePattern, `${field}.framePattern`),
-      fps: readFiniteNumber(entry.fps, `${field}.fps`),
-      totalFrames: readNonNegativeInteger(entry.totalFrames, `${field}.totalFrames`),
-      metadata: readVideoMetadata(entry.metadata, `${field}.metadata`)
-    };
-  });
-  return { videos, extracted };
 }
 function materializeExtractedVideoDirectories(planDir) {
   const videosPath = join68(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync59(videosPath)) return;
-  const videos = parsePlanVideosJson(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
+  const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
     mkdirSync31(resolveExtractedVideoOutputDir(planDir, video.videoId), { recursive: true });
   }
@@ -125731,9 +125967,9 @@ function parseChunkSlices(value) {
   return value.map((chunk, position) => {
     const field = `meta/chunks.json[${position}]`;
     if (!isRecord7(chunk)) throw new PlanV2IntegrityError(`${field} must be an object`);
-    const index = readNonNegativeInteger(chunk.index, `${field}.index`);
-    const startFrame = readNonNegativeInteger(chunk.startFrame, `${field}.startFrame`);
-    const endFrame = readPositiveInteger(chunk.endFrame, `${field}.endFrame`);
+    const index = readNonNegativeInteger2(chunk.index, `${field}.index`);
+    const startFrame = readNonNegativeInteger2(chunk.startFrame, `${field}.startFrame`);
+    const endFrame = readPositiveInteger2(chunk.endFrame, `${field}.endFrame`);
     if (endFrame <= startFrame) {
       throw new PlanV2IntegrityError(`${field}.endFrame must be greater than startFrame`);
     }
@@ -125754,12 +125990,12 @@ function buildVideoChunkDependencies(planV1Dir, dimensions) {
   const chunksPath = join68(planV1Dir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
-  const parsedVideos = parsePlanVideosJson(videos);
+  const parsedVideos = parsePlanVideosJson2(videos);
   const parsedChunks = parseChunkSlices(chunks);
   const extracted = listVideoFramePaths(planV1Dir, parsedVideos);
   const table = createFrameLookupTable(parsedVideos.videos, extracted);
-  const fpsNum = readPositiveInteger(dimensions.fpsNum, "dimensions.fpsNum");
-  const fpsDen = readPositiveInteger(dimensions.fpsDen, "dimensions.fpsDen");
+  const fpsNum = readPositiveInteger2(dimensions.fpsNum, "dimensions.fpsNum");
+  const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
   const mutable = /* @__PURE__ */ new Map();
   for (const chunk of parsedChunks) {
     for (let frame = chunk.startFrame; frame < chunk.endFrame; frame++) {
@@ -125848,14 +126084,14 @@ function buildPlanV2Publication(planV1Dir) {
   const base2 = {
     protocol: PLAN_PROTOCOL_V2,
     sourcePlanV1Hash,
-    chunkCount: readPositiveInteger(v1Plan.chunkCount, "chunkCount"),
-    totalFrames: readPositiveInteger(v1Plan.totalFrames, "totalFrames"),
+    chunkCount: readPositiveInteger2(v1Plan.chunkCount, "chunkCount"),
+    totalFrames: readPositiveInteger2(v1Plan.totalFrames, "totalFrames"),
     fps: readV1PlanFps(dimensions),
-    width: readPositiveInteger(dimensions.width, "dimensions.width"),
-    height: readPositiveInteger(dimensions.height, "dimensions.height"),
+    width: readPositiveInteger2(dimensions.width, "dimensions.width"),
+    height: readPositiveInteger2(dimensions.height, "dimensions.height"),
     format: readDistributedFormat(dimensions.format),
-    ffmpegVersion: readString(v1Plan.ffmpegVersion, "ffmpegVersion"),
-    producerVersion: readString(v1Plan.producerVersion, "producerVersion"),
+    ffmpegVersion: readString2(v1Plan.ffmpegVersion, "ffmpegVersion"),
+    producerVersion: readString2(v1Plan.producerVersion, "producerVersion"),
     limitations: { videoDependencyMode: videoDependencyPlan.mode },
     artifacts
   };
@@ -125958,25 +126194,19 @@ function resultFromManifest(planV2Dir, manifest) {
     limitations: manifest.limitations
   };
 }
-function readString(value, field) {
+function readString2(value, field) {
   if (typeof value !== "string" || value.length === 0) {
     throw new PlanV2IntegrityError(`${field} must be a non-empty string`);
   }
   return value;
 }
-function readColorComponent(value, field) {
-  if (typeof value !== "string") {
-    throw new PlanV2IntegrityError(`${field} must be a string`);
-  }
-  return value;
-}
-function readPositiveInteger(value, field) {
+function readPositiveInteger2(value, field) {
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
     throw new PlanV2IntegrityError(`${field} must be a positive integer`);
   }
   return value;
 }
-function readNonNegativeInteger(value, field) {
+function readNonNegativeInteger2(value, field) {
   if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
     throw new PlanV2IntegrityError(`${field} must be a non-negative integer`);
   }
@@ -125989,7 +126219,7 @@ function readSupportedFps(value) {
   return value;
 }
 function readV1PlanFps(dimensions) {
-  const fpsDen = readPositiveInteger(dimensions.fpsDen, "dimensions.fpsDen");
+  const fpsDen = readPositiveInteger2(dimensions.fpsDen, "dimensions.fpsDen");
   if (fpsDen !== 1) {
     throw new PlanV2IntegrityError("dimensions.fpsDen must be 1 for plan v2");
   }
@@ -126003,7 +126233,7 @@ function readDistributedFormat(value) {
 }
 function parseArtifact(value, index) {
   if (!isRecord7(value)) throw new PlanV2IntegrityError(`artifacts[${index}] must be an object`);
-  const path2 = readString(value.path, `artifacts[${index}].path`);
+  const path2 = readString2(value.path, `artifacts[${index}].path`);
   assertSafeRelativePath(path2);
   if (!isSha256(value.sha256)) {
     throw new PlanV2IntegrityError(`artifacts[${index}].sha256 must be a lowercase sha256`);
@@ -126056,14 +126286,14 @@ function parsePlanV2Manifest(value) {
     protocol: PLAN_PROTOCOL_V2,
     planHash: value.planHash,
     sourcePlanV1Hash: value.sourcePlanV1Hash,
-    chunkCount: readPositiveInteger(value.chunkCount, "chunkCount"),
-    totalFrames: readPositiveInteger(value.totalFrames, "totalFrames"),
+    chunkCount: readPositiveInteger2(value.chunkCount, "chunkCount"),
+    totalFrames: readPositiveInteger2(value.totalFrames, "totalFrames"),
     fps: readSupportedFps(value.fps),
-    width: readPositiveInteger(value.width, "width"),
-    height: readPositiveInteger(value.height, "height"),
+    width: readPositiveInteger2(value.width, "width"),
+    height: readPositiveInteger2(value.height, "height"),
     format: readDistributedFormat(value.format),
-    ffmpegVersion: readString(value.ffmpegVersion, "ffmpegVersion"),
-    producerVersion: readString(value.producerVersion, "producerVersion"),
+    ffmpegVersion: readString2(value.ffmpegVersion, "ffmpegVersion"),
+    producerVersion: readString2(value.producerVersion, "producerVersion"),
     limitations: { videoDependencyMode: value.limitations.videoDependencyMode },
     artifacts
   };
@@ -126465,6 +126695,16 @@ var init_assemble = __esm({
 import { randomBytes as randomBytes2 } from "crypto";
 import { existsSync as existsSync61, mkdirSync as mkdirSync34, readFileSync as readFileSync36, readdirSync as readdirSync21, rmSync as rmSync23, writeFileSync as writeFileSync25 } from "fs";
 import { extname as extname15, join as join70 } from "path";
+function validatePlanVideosForChunk(value) {
+  try {
+    return parsePlanVideosJson(value);
+  } catch (err) {
+    throw new RenderChunkValidationError(
+      INVALID_VIDEO_METADATA,
+      `[renderChunk] invalid meta/videos.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 async function createVerifiedDistributedCaptureSession(serverUrl, framesDir, captureOptions, cfg, dependencies = distributedCaptureSessionDependencies) {
   const session = await dependencies.createCaptureSession(
     serverUrl,
@@ -126599,10 +126839,11 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath) {
   let planVideos = null;
   if (existsSync61(videosJsonPath)) {
     try {
-      planVideos = JSON.parse(readFileSync36(videosJsonPath, "utf-8"));
+      planVideos = validatePlanVideosForChunk(JSON.parse(readFileSync36(videosJsonPath, "utf-8")));
     } catch (err) {
+      if (err instanceof RenderChunkValidationError) throw err;
       throw new RenderChunkValidationError(
-        MISSING_PLAN_ARTIFACT,
+        INVALID_VIDEO_METADATA,
         `[renderChunk] failed to parse ${videosJsonPath}: ${err instanceof Error ? err.message : String(err)}`
       );
     }
@@ -127097,6 +127338,7 @@ var init_distributed = __esm({
     init_renderConfigValidation();
     init_projectHash();
     init_planProtocol();
+    init_shared2();
     init_planValidation();
   }
 });
@@ -130123,7 +130365,7 @@ function applyResolutionPreset(destDir, resolution) {
     if (changed) writeFileSync27(file, html, "utf-8");
   }
 }
-async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds, tailwind = false, resolution) {
+async function scaffoldProject(destDir, name, templateId, localVideoName, durationSeconds, tailwind = false, resolution, authoringSkill) {
   mkdirSync38(destDir, { recursive: true });
   const templateDir = getStaticTemplateDir(templateId);
   if (existsSync67(join78(templateDir, "index.html"))) {
@@ -130149,7 +130391,12 @@ async function scaffoldProject(destDir, name, templateId, localVideoName, durati
   );
   if (!existsSync67(resolve39(destDir, "hyperframes.json"))) {
     const { writeProjectConfig: writeProjectConfig2, DEFAULT_PROJECT_CONFIG: DEFAULT_PROJECT_CONFIG2 } = await Promise.resolve().then(() => (init_projectConfig(), projectConfig_exports));
-    writeProjectConfig2(destDir, DEFAULT_PROJECT_CONFIG2);
+    const { normalizeSkillSlug: normalizeSkillSlug2 } = await Promise.resolve().then(() => (init_skill(), skill_exports));
+    const skill = normalizeSkillSlug2(authoringSkill);
+    writeProjectConfig2(
+      destDir,
+      skill ? { ...DEFAULT_PROJECT_CONFIG2, authoringSkill: skill } : DEFAULT_PROJECT_CONFIG2
+    );
   }
   writeDefaultPackageJson(destDir, name);
   const sharedDir = getSharedTemplateDir();
@@ -130298,6 +130545,10 @@ var init_init = __esm({
         resolution: {
           type: "string",
           description: "Canvas resolution preset: landscape (1920x1080), portrait (1080x1920), landscape-4k (3840x2160), portrait-4k (2160x3840), square (1080x1080), square-4k (2160x2160). Aliases: 1080p, 4k, uhd, 1080p-square, square-1080p, 4k-square. Default: keep template dimensions (typically 1920x1080)."
+        },
+        skill: {
+          type: "string",
+          description: "Owning authoring workflow slug (e.g. product-launch-video). Stamped into hyperframes.json so every render of this project is attributed to it on anonymous telemetry, without re-passing --skill on each render. Ignored unless it is a slug."
         }
       },
       async run({ args }) {
@@ -130432,7 +130683,8 @@ var init_init = __esm({
               localVideoName2,
               videoDuration2,
               tailwind,
-              resolutionPreset
+              resolutionPreset,
+              args.skill
             );
           } catch (err) {
             console.error(
@@ -130620,7 +130872,8 @@ var init_init = __esm({
             localVideoName,
             videoDuration,
             tailwind,
-            resolutionPreset
+            resolutionPreset,
+            args.skill
           );
           if (!isBundled) {
             spin.stop(c.success(`Downloaded ${templateId}`));
@@ -133822,20 +134075,6 @@ var init_renderArgs = __esm({
   }
 });
 
-// src/telemetry/skill.ts
-function normalizeSkillSlug(raw) {
-  if (typeof raw !== "string") return void 0;
-  const slug = raw.trim();
-  return SKILL_SLUG.test(slug) ? slug : void 0;
-}
-var SKILL_SLUG;
-var init_skill = __esm({
-  "src/telemetry/skill.ts"() {
-    "use strict";
-    SKILL_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
-  }
-});
-
 // src/commands/render/plan.ts
 import { statSync as statSync27 } from "fs";
 import { dirname as dirname39, join as join85, resolve as resolve51 } from "path";
@@ -133885,8 +134124,9 @@ function createRenderPlan(args, now = /* @__PURE__ */ new Date()) {
     failUsage();
   }
   const quality = qualityRaw;
-  const authoringSkill = normalizeSkillSlug(args.skill);
-  const invalidAuthoringSkill = typeof args.skill === "string" && args.skill.trim() !== "" && !authoringSkill ? args.skill : void 0;
+  const flagSkill = normalizeSkillSlug(args.skill);
+  const authoringSkill = flagSkill ?? loadProjectConfig(project.dir).authoringSkill;
+  const invalidAuthoringSkill = typeof args.skill === "string" && args.skill.trim() !== "" && !flagSkill ? args.skill : void 0;
   const formatRaw = args.format ?? "mp4";
   const format = parseRenderFormat(formatRaw);
   if (!format) {
@@ -134122,6 +134362,7 @@ var init_plan2 = __esm({
     init_project();
     init_renderArgs();
     init_skill();
+    init_projectConfig();
     VALID_QUALITY = /* @__PURE__ */ new Set(["draft", "standard", "high"]);
     RENDER_FORMATS = ["mp4", "webm", "mov", "png-sequence", "gif"];
     VALID_FORMAT = new Set(RENDER_FORMATS);
@@ -135479,7 +135720,7 @@ __export(render_exports, {
   renderLocal: () => renderLocal,
   resolveBrowserGpuForCli: () => resolveBrowserGpuForCli
 });
-import { mkdirSync as mkdirSync43, readdirSync as readdirSync27, readFileSync as readFileSync53, statSync as statSync28, writeFileSync as writeFileSync30, rmSync as rmSync26 } from "fs";
+import { mkdtempSync as mkdtempSync11, readdirSync as readdirSync27, readFileSync as readFileSync53, statSync as statSync28, writeFileSync as writeFileSync30, rmSync as rmSync26 } from "fs";
 import { freemem as freemem5, tmpdir as tmpdir12 } from "os";
 import { resolve as resolve54, dirname as dirname41, join as join87, basename as basename16 } from "path";
 import { execFileSync as execFileSync11, spawn as spawn14 } from "child_process";
@@ -135547,8 +135788,7 @@ function ensureDockerImage(version2, platform10, quiet) {
   }
   if (!quiet) console.log(c.dim(`  Building Docker image: ${tag} (${platform10})...`));
   const dockerfilePath = resolveDockerfilePath();
-  const tmpDir = join87(tmpdir12(), `hyperframes-docker-${Date.now()}`);
-  mkdirSync43(tmpDir, { recursive: true });
+  const tmpDir = mkdtempSync11(join87(tmpdir12(), "hyperframes-docker-"));
   writeFileSync30(join87(tmpDir, "Dockerfile"), readFileSync53(dockerfilePath));
   const targetArch = platform10 === "linux/arm64" ? "arm64" : "amd64";
   try {
@@ -136098,6 +136338,7 @@ function trackRenderMetrics(job, elapsedMs, options, docker) {
     deParallelRouter: perf?.drawElement?.parallelRouter,
     dePreRouterWorkers: perf?.drawElement?.preRouterWorkers,
     deGateReason: perf?.drawElement?.gateReason,
+    gpuRenderer: perf?.drawElement?.gpuRenderer,
     deWorkerEncode: perf?.drawElement?.workerEncode,
     deVerifyArmed: perf?.drawElement?.verifyArmed,
     deVerifyChecked: perf?.drawElement?.verifyChecked,
@@ -136185,6 +136426,7 @@ var init_render = __esm({
     init_commandResult();
     init_dist();
     init_plan2();
+    init_projectConfig();
     init_present2();
     init_execute();
     init_producer();
@@ -136440,6 +136682,7 @@ var init_render = __esm({
       // Keep the transport adapter thin: each phase has one ownership boundary.
       async run({ args }) {
         const plan2 = createRenderPlan(args);
+        seedProjectAuthoringSkill(plan2.project.dir, args.skill);
         await presentRenderPlan(plan2);
         await executeRenderPlan(plan2, {
           renderDocker,
@@ -138123,7 +138366,7 @@ __export(validate_exports, {
   resolveNavigationTimeoutMs: () => resolveNavigationTimeoutMs,
   shouldIgnoreRequestFailure: () => shouldIgnoreRequestFailure
 });
-import { existsSync as existsSync80, mkdtempSync as mkdtempSync11, readFileSync as readFileSync56, rmSync as rmSync27 } from "fs";
+import { existsSync as existsSync80, mkdtempSync as mkdtempSync12, readFileSync as readFileSync56, rmSync as rmSync27 } from "fs";
 import { tmpdir as tmpdir13 } from "os";
 import { join as join90, dirname as dirname43 } from "path";
 import { fileURLToPath as fileURLToPath12 } from "url";
@@ -138290,7 +138533,7 @@ async function localizeRemoteAssets(html) {
   try {
     const { loadProducer: loadProducer2 } = await Promise.resolve().then(() => (init_producer(), producer_exports));
     const { localizeRemoteMediaSources: localizeRemoteMediaSources2, localizeRemoteImageSources: localizeRemoteImageSources2, localizeRemoteFontFaces: localizeRemoteFontFaces2 } = await loadProducer2();
-    dir = mkdtempSync11(join90(tmpdir13(), "hf-validate-assets-"));
+    dir = mkdtempSync12(join90(tmpdir13(), "hf-validate-assets-"));
     const assetDir = dir;
     const media = await localizeRemoteMediaSources2(html, assetDir);
     const images = await localizeRemoteImageSources2(media.html, assetDir);
@@ -138601,7 +138844,7 @@ __export(checkBrowser_exports, {
   preResolveHostileMediaProxies: () => preResolveHostileMediaProxies,
   runBrowserCheck: () => runBrowserCheck
 });
-import { mkdirSync as mkdirSync44, writeFileSync as writeFileSync31 } from "fs";
+import { mkdirSync as mkdirSync43, writeFileSync as writeFileSync31 } from "fs";
 import { join as join91, resolve as resolve56 } from "path";
 async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride) {
   if (!resolveAutoProxy(projectDir, autoProxyOverride)) return;
@@ -138701,7 +138944,7 @@ async function captureFindingCrops(project, options, requests) {
     const page = session.page;
     await waitForPreferredSeekTarget(page);
     const snapshotDir = join91(project.dir, "snapshots");
-    mkdirSync44(snapshotDir, { recursive: true });
+    mkdirSync43(snapshotDir, { recursive: true });
     for (const request of requests) {
       await seekCompositionTimeline(page, request.time, AUDIT_SEEK_OPTIONS);
       const canvas = await page.evaluate(() => ({
@@ -139493,7 +139736,7 @@ var init_checkBrowser = __esm({
 });
 
 // src/utils/checkPipeline.ts
-import { mkdirSync as mkdirSync45, writeFileSync as writeFileSync33 } from "fs";
+import { mkdirSync as mkdirSync44, writeFileSync as writeFileSync33 } from "fs";
 import { join as join93, relative as relative21 } from "path";
 function selectContrastTimes(grid) {
   if (grid.length <= 5) return [...grid];
@@ -140435,7 +140678,7 @@ async function runBrowserCheck2(project, options, motion) {
 }
 async function writeSnapshot(projectDir, index, time, pngBase64) {
   const snapshotDir = join93(projectDir, "snapshots");
-  mkdirSync45(snapshotDir, { recursive: true });
+  mkdirSync44(snapshotDir, { recursive: true });
   const filename = `frame-${String(index).padStart(2, "0")}-at-${time.toFixed(1)}s.png`;
   const path2 = join93(snapshotDir, filename);
   writeFileSync33(path2, Buffer.from(pngBase64, "base64"));
@@ -141132,7 +141375,7 @@ __export(beats_exports, {
   default: () => beats_default,
   examples: () => examples13
 });
-import { existsSync as existsSync83, readFileSync as readFileSync58, mkdirSync as mkdirSync46, writeFileSync as writeFileSync34 } from "fs";
+import { existsSync as existsSync83, readFileSync as readFileSync58, mkdirSync as mkdirSync45, writeFileSync as writeFileSync34 } from "fs";
 import { resolve as resolve57, join as join95, dirname as dirname45 } from "path";
 function fail(message) {
   console.error(c.error(message));
@@ -141205,7 +141448,7 @@ var init_beats2 = __esm({
           fail(`No beats detected in ${rel} \u2014 nothing written. (Track may be silent/ambient.)`);
         }
         const outPath = join95(project.dir, "beats", `${rel}.json`);
-        mkdirSync46(dirname45(outPath), { recursive: true });
+        mkdirSync45(dirname45(outPath), { recursive: true });
         writeFileSync34(outPath, serializeBeats(result.beatTimes, result.beatStrengths, rel));
         report(`beats/${rel}.json`, result, Boolean(args.json));
       }
@@ -143054,10 +143297,10 @@ __export(motionShot_exports, {
   captureMotionPathShot: () => captureMotionPathShot,
   ensureShotOutputDir: () => ensureShotOutputDir
 });
-import { mkdirSync as mkdirSync47, writeFileSync as writeFileSync35 } from "fs";
+import { mkdirSync as mkdirSync46, writeFileSync as writeFileSync35 } from "fs";
 import { dirname as dirname46 } from "path";
 function ensureShotOutputDir(outPath) {
-  mkdirSync47(dirname46(outPath), { recursive: true });
+  mkdirSync46(dirname46(outPath), { recursive: true });
 }
 function applyOrbitCamera(selectors, cam) {
   const first = document.querySelector(selectors[0] ?? "");
@@ -145130,7 +145373,7 @@ var init_remove_background = __esm({
 
 // src/whisper/parakeet.ts
 import { execFileSync as execFileSync12 } from "child_process";
-import { existsSync as existsSync88, mkdtempSync as mkdtempSync12, readFileSync as readFileSync63, rmSync as rmSync28, writeFileSync as writeFileSync36 } from "fs";
+import { existsSync as existsSync88, mkdtempSync as mkdtempSync13, readFileSync as readFileSync63, rmSync as rmSync28, writeFileSync as writeFileSync36 } from "fs";
 import { homedir as homedir17, tmpdir as tmpdir14 } from "os";
 import { basename as basename19, extname as extname17, join as join99 } from "path";
 function isRunnable(bin) {
@@ -145200,7 +145443,7 @@ function transcribeWithParakeet(inputPath, dir, options) {
   options?.onProgress?.(
     cached2 ? "Transcribing with Parakeet..." : "Downloading Parakeet model (first run, ~600MB)..."
   );
-  const workDir = mkdtempSync12(join99(tmpdir14(), "hyperframes-parakeet-"));
+  const workDir = mkdtempSync13(join99(tmpdir14(), "hyperframes-parakeet-"));
   try {
     const argv2 = [inputPath, "--model", model, "--output-format", "json", "--output-dir", workDir];
     if (options?.language) argv2.push("--language", options.language);
@@ -145507,7 +145750,7 @@ var init_transcribe2 = __esm({
 });
 
 // src/tts/manager.ts
-import { existsSync as existsSync90, mkdirSync as mkdirSync48 } from "fs";
+import { existsSync as existsSync90, mkdirSync as mkdirSync47 } from "fs";
 import { homedir as homedir18 } from "os";
 import { join as join101 } from "path";
 function inferLangFromVoiceId(voiceId) {
@@ -145526,7 +145769,7 @@ async function ensureModel3(model = DEFAULT_MODEL4, options) {
       `Unknown TTS model: ${model}. Available: ${Object.keys(MODEL_URLS2).join(", ")}`
     );
   }
-  mkdirSync48(MODELS_DIR3, { recursive: true });
+  mkdirSync47(MODELS_DIR3, { recursive: true });
   options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
   await downloadFile(url, modelPath2);
   if (!existsSync90(modelPath2)) {
@@ -145537,7 +145780,7 @@ async function ensureModel3(model = DEFAULT_MODEL4, options) {
 async function ensureVoices(options) {
   const voicesPath = join101(VOICES_DIR, "voices-v1.0.bin");
   if (existsSync90(voicesPath)) return voicesPath;
-  mkdirSync48(VOICES_DIR, { recursive: true });
+  mkdirSync47(VOICES_DIR, { recursive: true });
   options?.onProgress?.("Downloading voice data (~27 MB)...");
   await downloadFile(VOICES_URL, voicesPath);
   if (!existsSync90(voicesPath)) {
@@ -145681,12 +145924,12 @@ __export(synthesize_exports, {
   synthesize: () => synthesize
 });
 import { execFileSync as execFileSync14 } from "child_process";
-import { existsSync as existsSync91, writeFileSync as writeFileSync38, mkdirSync as mkdirSync49, readdirSync as readdirSync30, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync91, writeFileSync as writeFileSync38, mkdirSync as mkdirSync48, readdirSync as readdirSync30, unlinkSync as unlinkSync7 } from "fs";
 import { join as join103, dirname as dirname50, basename as basename20 } from "path";
 import { homedir as homedir19 } from "os";
 function ensureSynthScript() {
   if (!existsSync91(SCRIPT_PATH)) {
-    mkdirSync49(SCRIPT_DIR, { recursive: true });
+    mkdirSync48(SCRIPT_DIR, { recursive: true });
     writeFileSync38(SCRIPT_PATH, SYNTH_SCRIPT);
     const currentName = basename20(SCRIPT_PATH);
     try {
@@ -145727,7 +145970,7 @@ async function synthesize(text2, outputPath, options) {
     ensureVoices({ onProgress: options?.onProgress })
   ]);
   const scriptPath = ensureSynthScript();
-  mkdirSync49(dirname50(outputPath), { recursive: true });
+  mkdirSync48(dirname50(outputPath), { recursive: true });
   options?.onProgress?.(`Generating speech with voice ${voice} (${lang})...`);
   try {
     const espeakLang = ESPEAK_LANG_OVERRIDES[lang] ?? lang;
@@ -187169,7 +187412,7 @@ __export(snapshot_exports, {
   resolveSnapshotVideoFrameTime: () => resolveSnapshotVideoFrameTime,
   tailFrameTime: () => tailFrameTime
 });
-import { existsSync as existsSync98, mkdtempSync as mkdtempSync13, readFileSync as readFileSync68, mkdirSync as mkdirSync50, rmSync as rmSync29, writeFileSync as writeFileSync41 } from "fs";
+import { existsSync as existsSync98, mkdtempSync as mkdtempSync14, readFileSync as readFileSync68, mkdirSync as mkdirSync49, rmSync as rmSync29, writeFileSync as writeFileSync41 } from "fs";
 import { tmpdir as tmpdir15 } from "os";
 import { resolve as resolve67, join as join106, relative as relative24, isAbsolute as isAbsolute15, basename as basename25 } from "path";
 function orbitStageSource() {
@@ -187214,7 +187457,7 @@ function requireSnapshotFfmpeg(ffmpegPath) {
   );
 }
 async function extractVideoFrameToBuffer(videoPath, timeSeconds, useVp9AlphaDecoder = false) {
-  const tmp = mkdtempSync13(join106(tmpdir15(), "hf-snapshot-frame-"));
+  const tmp = mkdtempSync14(join106(tmpdir15(), "hf-snapshot-frame-"));
   const outPath = join106(tmp, "frame.png");
   try {
     const ffmpegPath = requireSnapshotFfmpeg(findFFmpeg());
@@ -187328,7 +187571,7 @@ async function captureSnapshots(projectDir, opts) {
       }
       const cameraExpr = opts.angle && (opts.angle.yaw !== 0 || opts.angle.pitch !== 0) ? `(${orbitStageSource()})(${JSON.stringify(opts.angle)})` : null;
       const snapshotDir = opts.outputDir ?? join106(projectDir, "snapshots");
-      mkdirSync50(snapshotDir, { recursive: true });
+      mkdirSync49(snapshotDir, { recursive: true });
       try {
         const { readdirSync: readdirSync38 } = await import("fs");
         for (const file of readdirSync38(snapshotDir)) {
@@ -188676,8 +188919,8 @@ __export(grade_compare_exports, {
 import {
   copyFileSync as copyFileSync10,
   existsSync as existsSync100,
-  mkdirSync as mkdirSync51,
-  mkdtempSync as mkdtempSync14,
+  mkdirSync as mkdirSync50,
+  mkdtempSync as mkdtempSync15,
   readFileSync as readFileSync70,
   rmSync as rmSync30,
   writeFileSync as writeFileSync44
@@ -188939,7 +189182,7 @@ function frameFileNameForPath(framePath) {
   return "frame.png";
 }
 async function prepareGradeCompareTempProject(opts) {
-  const tempDir = mkdtempSync14(join107(tmpdir16(), "hf-grade-compare-"));
+  const tempDir = mkdtempSync15(join107(tmpdir16(), "hf-grade-compare-"));
   try {
     const frameFileName2 = opts.frameFileName ?? frameFileNameForPath(opts.framePath);
     writeFileSync44(join107(tempDir, frameFileName2), opts.frameBuffer);
@@ -188986,7 +189229,7 @@ function isVideoPath2(filePath) {
   return [".mp4", ".mov", ".m4v", ".webm", ".mkv", ".avi", ".mpeg", ".mpg", ".ogv"].includes(ext);
 }
 async function extractVideoFrameToBuffer2(videoPath) {
-  const tmp = mkdtempSync14(join107(tmpdir16(), "hf-grade-compare-frame-"));
+  const tmp = mkdtempSync15(join107(tmpdir16(), "hf-grade-compare-frame-"));
   const outPath = join107(tmp, "frame.png");
   try {
     const ffmpegPath = findFFmpeg();
@@ -189183,7 +189426,7 @@ var init_grade_compare = __esm({
             prepared.tempDir,
             parsed.timeoutMs
           );
-          mkdirSync51(dirname54(parsed.outPath), { recursive: true });
+          mkdirSync50(dirname54(parsed.outPath), { recursive: true });
           copyFileSync10(tempSheet, parsed.outPath);
           trackCompareSheet({
             command: "grade-compare",
@@ -189228,7 +189471,7 @@ __export(compare_exports, {
   parseCompareArgs: () => parseCompareArgs,
   prepareCompareVariantProjects: () => prepareCompareVariantProjects
 });
-import { cpSync as cpSync6, existsSync as existsSync101, mkdirSync as mkdirSync53, mkdtempSync as mkdtempSync15, renameSync as renameSync16, rmSync as rmSync31, statSync as statSync35 } from "fs";
+import { cpSync as cpSync6, existsSync as existsSync101, mkdirSync as mkdirSync51, mkdtempSync as mkdtempSync16, renameSync as renameSync16, rmSync as rmSync31, statSync as statSync35 } from "fs";
 import { tmpdir as tmpdir17 } from "os";
 import { basename as basename28, dirname as dirname55, extname as extname24, join as join108 } from "path";
 function defaultLabelForPath(input2) {
@@ -189329,7 +189572,7 @@ function inputError(variant) {
   );
 }
 function stageHtmlVariant(variant) {
-  const stagedDir = mkdtempSync15(join108(tmpdir17(), "hf-compare-variant-"));
+  const stagedDir = mkdtempSync16(join108(tmpdir17(), "hf-compare-variant-"));
   try {
     cpSync6(dirname55(variant.inputPath), stagedDir, {
       recursive: true,
@@ -189426,7 +189669,7 @@ async function renderCompareSheet(parsed) {
   const capResult = capCompareVariants(parsed.variants);
   const variants = capResult.variants;
   const prepared = prepareCompareVariantProjects(variants);
-  const frameDir = mkdtempSync15(join108(tmpdir17(), "hf-compare-frames-"));
+  const frameDir = mkdtempSync16(join108(tmpdir17(), "hf-compare-frames-"));
   const framePaths = [];
   try {
     let renderReadyTimedOut = false;
@@ -189441,7 +189684,7 @@ async function renderCompareSheet(parsed) {
       framePaths.push(rendered.framePath);
       renderReadyTimedOut = renderReadyTimedOut || rendered.renderReadyTimedOut;
     }
-    mkdirSync53(dirname55(parsed.outPath), { recursive: true });
+    mkdirSync51(dirname55(parsed.outPath), { recursive: true });
     await createContactSheet(framePaths, parsed.outPath, {
       cols: parsed.cols ?? defaultCompareCols(framePaths.length),
       maxImages: framePaths.length,
@@ -189560,7 +189803,7 @@ ${c.error("\u2717")} Compare failed: ${message}`);
 });
 
 // src/capture/assetDownloader.ts
-import { writeFileSync as writeFileSync45, mkdirSync as mkdirSync54 } from "fs";
+import { writeFileSync as writeFileSync45, mkdirSync as mkdirSync53 } from "fs";
 import { join as join109, extname as extname25 } from "path";
 import { createHash as createHash18 } from "crypto";
 function svgContentHashSlug(svgSource, isLogo) {
@@ -189569,10 +189812,10 @@ function svgContentHashSlug(svgSource, isLogo) {
 }
 async function downloadAssets(tokens, outputDir, catalogedAssets, faviconLinks) {
   const assetsDir = join109(outputDir, "assets");
-  mkdirSync54(assetsDir, { recursive: true });
+  mkdirSync53(assetsDir, { recursive: true });
   const assets = [];
   const downloadedUrls = /* @__PURE__ */ new Set();
-  mkdirSync54(join109(outputDir, "assets", "svgs"), { recursive: true });
+  mkdirSync53(join109(outputDir, "assets", "svgs"), { recursive: true });
   const usedSvgNames = /* @__PURE__ */ new Set();
   for (let i2 = 0; i2 < tokens.svgs.length && i2 < 30; i2++) {
     const svg = tokens.svgs[i2];
@@ -189703,7 +189946,7 @@ function normalizeUrl(u) {
 }
 async function downloadAndRewriteFonts(css, outputDir) {
   const assetsDir = join109(outputDir, "assets", "fonts");
-  mkdirSync54(assetsDir, { recursive: true });
+  mkdirSync53(assetsDir, { recursive: true });
   const fontUrlRegex = /url\(['"]?(https?:\/\/[^'")\s]+\.(?:woff2?|ttf|otf)[^'")\s]*?)['"]?\)/g;
   const fontUrls = /* @__PURE__ */ new Set();
   let match;
@@ -189896,7 +190139,7 @@ __export(video_exports, {
   runVideoMode: () => runVideoMode,
   safeFilename: () => safeFilename
 });
-import { createWriteStream as createWriteStream4, existsSync as existsSync103, mkdirSync as mkdirSync55, readFileSync as readFileSync71, unlinkSync as unlinkSync9 } from "fs";
+import { createWriteStream as createWriteStream4, existsSync as existsSync103, mkdirSync as mkdirSync54, readFileSync as readFileSync71, unlinkSync as unlinkSync9 } from "fs";
 import { resolve as resolve71, join as join110, basename as basename29 } from "path";
 async function streamToFile(url, destPath) {
   const r2 = await safeFetch(url, {
@@ -190072,7 +190315,7 @@ async function runVideoMode(args) {
     return;
   }
   const outDir = isW2hLayout ? join110(projectDir, "capture", "assets", "videos") : join110(projectDir, "assets", "videos");
-  mkdirSync55(outDir, { recursive: true });
+  mkdirSync54(outDir, { recursive: true });
   const fname = safeFilename(entry.filename || basename29(entry.url));
   const outPath = join110(outDir, fname);
   const relPath = isW2hLayout ? `capture/assets/videos/${fname}` : `assets/videos/${fname}`;
@@ -191641,7 +191884,7 @@ var init_animationCataloger = __esm({
 });
 
 // src/capture/mediaCapture.ts
-import { mkdirSync as mkdirSync56, writeFileSync as writeFileSync47, readdirSync as readdirSync34, readFileSync as readFileSync74, statSync as statSync36 } from "fs";
+import { mkdirSync as mkdirSync55, writeFileSync as writeFileSync47, readdirSync as readdirSync34, readFileSync as readFileSync74, statSync as statSync36 } from "fs";
 import { join as join113, extname as extname26 } from "path";
 async function saveLottieAnimations(discoveredLotties, lottieDir) {
   let savedCount = 0;
@@ -191703,7 +191946,7 @@ async function saveLottieAnimations(discoveredLotties, lottieDir) {
 async function renderLottiePreviews(chromeBrowser, lottieDir, outputDir) {
   const manifest = [];
   const previewDir = join113(lottieDir, "previews");
-  mkdirSync56(previewDir, { recursive: true });
+  mkdirSync55(previewDir, { recursive: true });
   for (const file of readdirSync34(lottieDir)) {
     if (!file.endsWith(".json")) continue;
     try {
@@ -191869,9 +192112,9 @@ async function captureVideoManifest(page, outputDir, progress, opts) {
   const merged = [...byKey.values()];
   if (merged.length === 0) return;
   const videoManifestDir = join113(outputDir, "assets", "videos");
-  mkdirSync56(videoManifestDir, { recursive: true });
+  mkdirSync55(videoManifestDir, { recursive: true });
   const previewDir = join113(videoManifestDir, "previews");
-  mkdirSync56(previewDir, { recursive: true });
+  mkdirSync55(previewDir, { recursive: true });
   const videoManifest = [];
   const dlStart = Date.now();
   for (let vi = 0; vi < merged.length && vi < 20; vi++) {
@@ -192577,11 +192820,11 @@ var screenshotCapture_exports = {};
 __export(screenshotCapture_exports, {
   captureScrollScreenshots: () => captureScrollScreenshots
 });
-import { writeFileSync as writeFileSync50, mkdirSync as mkdirSync57 } from "fs";
+import { writeFileSync as writeFileSync50, mkdirSync as mkdirSync56 } from "fs";
 import { join as join117 } from "path";
 async function captureScrollScreenshots(page, outputDir) {
   const screenshotsDir = join117(outputDir, "screenshots");
-  mkdirSync57(screenshotsDir, { recursive: true });
+  mkdirSync56(screenshotsDir, { recursive: true });
   const MAX_SCREENSHOTS = 20;
   const filePaths = [];
   try {
@@ -193021,7 +193264,7 @@ var capture_exports = {};
 __export(capture_exports, {
   captureWebsite: () => captureWebsite
 });
-import { mkdirSync as mkdirSync58, writeFileSync as writeFileSync51, existsSync as existsSync108 } from "fs";
+import { mkdirSync as mkdirSync57, writeFileSync as writeFileSync51, existsSync as existsSync108 } from "fs";
 import { join as join118 } from "path";
 async function captureWebsite(opts, onProgress) {
   const {
@@ -193039,9 +193282,9 @@ async function captureWebsite(opts, onProgress) {
     onProgress?.(stage, detail);
   };
   loadEnvFile(outputDir);
-  mkdirSync58(join118(outputDir, "extracted"), { recursive: true });
-  mkdirSync58(join118(outputDir, "screenshots"), { recursive: true });
-  mkdirSync58(join118(outputDir, "assets"), { recursive: true });
+  mkdirSync57(join118(outputDir, "extracted"), { recursive: true });
+  mkdirSync57(join118(outputDir, "screenshots"), { recursive: true });
+  mkdirSync57(join118(outputDir, "assets"), { recursive: true });
   progress("browser", "Launching headless Chrome...");
   const { ensureBrowser: ensureBrowser2 } = await Promise.resolve().then(() => (init_manager2(), manager_exports2));
   const browser = await ensureBrowser2();
@@ -193202,7 +193445,7 @@ async function captureWebsite(opts, onProgress) {
     }
     if (discoveredLotties.length > 0) {
       const lottieDir = join118(outputDir, "assets", "lottie");
-      mkdirSync58(lottieDir, { recursive: true });
+      mkdirSync57(lottieDir, { recursive: true });
       const savedCount = await saveLottieAnimations(discoveredLotties, lottieDir);
       if (savedCount > 0) {
         await renderLottiePreviews(chromeBrowser, lottieDir, outputDir);
@@ -193706,8 +193949,8 @@ var init_capture2 = __esm({
         } catch (err) {
           const errMsg = normalizeErrorMessage(err);
           try {
-            const { mkdirSync: mkdirSync69, writeFileSync: writeFileSync61 } = await import("fs");
-            mkdirSync69(outputDir, { recursive: true });
+            const { mkdirSync: mkdirSync68, writeFileSync: writeFileSync61 } = await import("fs");
+            mkdirSync68(outputDir, { recursive: true });
             const isTimeout = /timeout|timed out/i.test(errMsg);
             const reason = isTimeout ? "Page navigation timed out \u2014 the site may be blocking headless browsers or requires authentication." : `Capture failed: ${errMsg}`;
             writeFileSync61(
@@ -193774,14 +194017,14 @@ __export(state_exports, {
   stateFilePath: () => stateFilePath,
   writeStackOutputs: () => writeStackOutputs
 });
-import { existsSync as existsSync109, mkdirSync as mkdirSync59, readdirSync as readdirSync37, readFileSync as readFileSync77, rmSync as rmSync32, writeFileSync as writeFileSync53 } from "fs";
+import { existsSync as existsSync109, mkdirSync as mkdirSync58, readdirSync as readdirSync37, readFileSync as readFileSync77, rmSync as rmSync32, writeFileSync as writeFileSync53 } from "fs";
 import { dirname as dirname56, join as join119 } from "path";
 function stateFilePath(stackName = DEFAULT_STACK_NAME, cwd = process.cwd()) {
   return join119(cwd, STATE_DIR_NAME, `${STATE_FILE_PREFIX}${stackName}.json`);
 }
 function writeStackOutputs(outputs, cwd = process.cwd()) {
   const path2 = stateFilePath(outputs.stackName, cwd);
-  mkdirSync59(dirname56(path2), { recursive: true });
+  mkdirSync58(dirname56(path2), { recursive: true });
   writeFileSync53(path2, JSON.stringify(outputs, null, 2) + "\n");
   return path2;
 }
@@ -195376,7 +195619,7 @@ __export(cloudrun_exports, {
   missingCloudRunAdapterMessage: () => missingCloudRunAdapterMessage
 });
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync116, mkdirSync as mkdirSync60, readFileSync as readFileSync81, writeFileSync as writeFileSync54 } from "fs";
+import { existsSync as existsSync116, mkdirSync as mkdirSync59, readFileSync as readFileSync81, writeFileSync as writeFileSync54 } from "fs";
 import { homedir as homedir20 } from "os";
 import { join as join126, resolve as resolve76 } from "path";
 function loadCloudRunAdapter() {
@@ -195403,7 +195646,7 @@ function statePath() {
   return join126(stateDir(), "cloudrun-state.json");
 }
 function writeState(state) {
-  mkdirSync60(stateDir(), { recursive: true });
+  mkdirSync59(stateDir(), { recursive: true });
   writeFileSync54(statePath(), JSON.stringify(state, null, 2));
 }
 function readState(args) {
@@ -195562,7 +195805,7 @@ function findRepoRoot(tfDir) {
 }
 function writeCloudBuildConfig(image) {
   const cfgPath = join126(stateDir(), "cloudrun-cloudbuild.yaml");
-  mkdirSync60(stateDir(), { recursive: true });
+  mkdirSync59(stateDir(), { recursive: true });
   writeFileSync54(
     cfgPath,
     [
@@ -196215,7 +196458,7 @@ var init_poll = __esm({
 });
 
 // src/cloud/download.ts
-import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync61, unlinkSync as unlinkSync10 } from "fs";
+import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync60, unlinkSync as unlinkSync10 } from "fs";
 import { dirname as dirname58 } from "path";
 async function downloadToFile(url, destPath, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -196226,7 +196469,7 @@ async function downloadToFile(url, destPath, options = {}) {
   if (!res.body) {
     throw new Error(`Failed to download ${url}: empty response body`);
   }
-  mkdirSync61(dirname58(destPath), { recursive: true });
+  mkdirSync60(dirname58(destPath), { recursive: true });
   const totalHeader = res.headers.get("content-length");
   const total = totalHeader ? Number.parseInt(totalHeader, 10) : void 0;
   const totalOpt = total !== void 0 && Number.isFinite(total) ? total : void 0;
@@ -198783,7 +199026,7 @@ var init_parseFigmaRef = __esm({
 });
 
 // ../core/dist/figma/freeze.js
-import { copyFileSync as copyFileSync11, mkdirSync as mkdirSync63, rmSync as rmSync33, statSync as statSync38, writeFileSync as writeFileSync55 } from "fs";
+import { copyFileSync as copyFileSync11, mkdirSync as mkdirSync61, rmSync as rmSync33, statSync as statSync38, writeFileSync as writeFileSync55 } from "fs";
 import { dirname as dirname59 } from "path";
 function exceedsFreezeCap(byteLength) {
   return byteLength > MAX_FREEZE_BYTES;
@@ -198793,7 +199036,7 @@ function freezeBytes(bytes, destPath) {
     throw new Error("freeze failed: empty bytes");
   if (exceedsFreezeCap(bytes.length))
     throw new Error(`freeze failed: ${bytes.length} bytes exceeds ${MAX_FREEZE_BYTES} cap`);
-  mkdirSync63(dirname59(destPath), { recursive: true });
+  mkdirSync61(dirname59(destPath), { recursive: true });
   try {
     writeFileSync55(destPath, bytes, { flag: "wx" });
   } catch (err) {
@@ -198837,7 +199080,7 @@ var init_jsonl = __esm({
 });
 
 // ../core/dist/figma/manifest.js
-import { appendFileSync as appendFileSync2, existsSync as existsSync119, mkdirSync as mkdirSync64, readFileSync as readFileSync85, writeFileSync as writeFileSync56 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync119, mkdirSync as mkdirSync63, readFileSync as readFileSync85, writeFileSync as writeFileSync56 } from "fs";
 import { join as join127 } from "path";
 function mediaDir(projectDir) {
   return join127(projectDir, ".media");
@@ -198870,7 +199113,7 @@ function readManifest(projectDir) {
   return readJsonlValues(manifestPath(projectDir)).filter(isFigmaManifestRecord);
 }
 function appendRecord(projectDir, record) {
-  mkdirSync64(typeDirPath(projectDir, record.type), { recursive: true });
+  mkdirSync63(typeDirPath(projectDir, record.type), { recursive: true });
   appendFileSync2(manifestPath(projectDir), JSON.stringify(record) + "\n");
 }
 function findAllByFigmaNode(projectDir, fileKey, nodeId) {
@@ -198932,7 +199175,7 @@ var init_manifest = __esm({
 });
 
 // ../core/dist/figma/mediaIndex.js
-import { mkdirSync as mkdirSync65, writeFileSync as writeFileSync57 } from "fs";
+import { mkdirSync as mkdirSync64, writeFileSync as writeFileSync57 } from "fs";
 import { dirname as dirname60, join as join128 } from "path";
 function isRow(value) {
   return typeof value === "object" && value !== null;
@@ -198983,7 +199226,7 @@ function regenerateIndex(projectDir) {
   const records = readJsonlValues(manifestPath(projectDir)).filter(isRow);
   const content = generateIndexContent(records);
   const p2 = indexPath(projectDir);
-  mkdirSync65(dirname60(p2), { recursive: true });
+  mkdirSync64(dirname60(p2), { recursive: true });
   writeFileSync57(p2, content);
   return content;
 }
@@ -199049,7 +199292,7 @@ var init_sanitizeSvg = __esm({
 });
 
 // ../core/dist/figma/bindings.js
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync66, writeFileSync as writeFileSync58 } from "fs";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync65, writeFileSync as writeFileSync58 } from "fs";
 import { join as join129 } from "path";
 function bindingsPath(projectDir) {
   return join129(mediaDir(projectDir), BINDINGS_FILE);
@@ -199069,7 +199312,7 @@ function readBindings(projectDir) {
 function upsertBindings(projectDir, records) {
   const incoming = new Set(records.map((r2) => r2.figmaId));
   const survivors = readLines(projectDir).filter((line2) => !(isBindingRecord(line2) && incoming.has(line2.figmaId)));
-  mkdirSync66(mediaDir(projectDir), { recursive: true });
+  mkdirSync65(mediaDir(projectDir), { recursive: true });
   const lines = [...survivors, ...records].map((r2) => JSON.stringify(r2)).join("\n");
   writeFileSync58(bindingsPath(projectDir), lines.length > 0 ? lines + "\n" : "");
 }
@@ -199938,7 +200181,7 @@ __export(component_exports, {
   default: () => component_default,
   runComponentImport: () => runComponentImport
 });
-import { existsSync as existsSync121, mkdirSync as mkdirSync67, writeFileSync as writeFileSync60 } from "fs";
+import { existsSync as existsSync121, mkdirSync as mkdirSync66, writeFileSync as writeFileSync60 } from "fs";
 import { join as join133, relative as relative29 } from "path";
 function escapeAttr2(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -199955,7 +200198,7 @@ async function runComponentImport(refInput, deps) {
     console.warn(
       `component dir compositions/components/${name} already exists \u2014 overwriting (rename the figma frame for a separate import)`
     );
-  mkdirSync67(componentDir, { recursive: true });
+  mkdirSync66(componentDir, { recursive: true });
   const { html, frozenAssets, failedRasterize } = await rasterizeFallback(
     mapped,
     ref2.fileKey,
@@ -200156,7 +200399,7 @@ __export(autoUpdate_exports, {
   scheduleBackgroundInstall: () => scheduleBackgroundInstall
 });
 import { spawn as spawn16 } from "child_process";
-import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync68, openSync as openSync8 } from "fs";
+import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync67, openSync as openSync8 } from "fs";
 import { homedir as homedir21 } from "os";
 import { join as join134 } from "path";
 import { compareVersions as compareVersions3 } from "compare-versions";
@@ -200173,14 +200416,14 @@ function majorOf(version2) {
 }
 function log(line2) {
   try {
-    mkdirSync68(CONFIG_DIR3, { recursive: true, mode: 448 });
+    mkdirSync67(CONFIG_DIR3, { recursive: true, mode: 448 });
     appendFileSync4(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line2}
 `, { mode: 384 });
   } catch {
   }
 }
 function launchDetachedInstall(invocation, displayCommand, version2) {
-  mkdirSync68(CONFIG_DIR3, { recursive: true, mode: 448 });
+  mkdirSync67(CONFIG_DIR3, { recursive: true, mode: 448 });
   const configFile = join134(CONFIG_DIR3, "config.json");
   const nodeScript = `
     const { execFile } = require("node:child_process");