hyperframes 0.8.59 → 0.8.61

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.8.59" : "0.0.0-dev";
+    VERSION = true ? "0.8.61" : "0.0.0-dev";
   }
 });
 
@@ -93100,17 +93100,34 @@ function* riffChunks(buffer) {
     offset2 += 8 + size + size % 2;
   }
 }
+function extensibleFormatTag(fmt) {
+  const extraSize = fmt.readUInt16LE(16);
+  if (extraSize < 22 || 18 + extraSize > fmt.length) return null;
+  return EXTENSIBLE_FORMATS.get(fmt.toString("hex", 24, 40)) ?? null;
+}
+function wavFormatTag(buffer, body, size) {
+  const fmt = buffer.subarray(body, body + size);
+  if (fmt.length < 16) return null;
+  const tag = fmt.readUInt16LE(0);
+  if (tag !== 65534) return tag;
+  return fmt.length < 40 ? null : extensibleFormatTag(fmt);
+}
+var EXTENSIBLE_FORMATS;
 var init_wavChunks = __esm({
   "../engine/src/services/wavChunks.ts"() {
     "use strict";
+    EXTENSIBLE_FORMATS = /* @__PURE__ */ new Map([
+      ["0100000000001000800000aa00389b71", 1],
+      ["0300000000001000800000aa00389b71", 3]
+    ]);
   }
 });
 
 // ../engine/src/services/audioVolumeEnvelope.ts
 import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync7, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname10, join as join15 } from "path";
-function readFmtChunk(buffer, body) {
-  const format = buffer.readUInt16LE(body);
+function readFmtChunk(buffer, body, size) {
+  const format = wavFormatTag(buffer, body, size);
   const bits = buffer.readUInt16LE(body + 14);
   const float = format === FLOAT_FORMAT;
   if (!float && format !== PCM_FORMAT) return null;
@@ -93128,7 +93145,7 @@ function parseWavLayout(buffer) {
   let data2 = null;
   for (const { id, body, size } of riffChunks(buffer)) {
     if (id === "fmt " && body + 16 <= buffer.length) {
-      fmt = readFmtChunk(buffer, body);
+      fmt = readFmtChunk(buffer, body, size);
     } else if (id === "data") {
       data2 = { offset: body, size: Math.min(size, buffer.length - body) };
     }
@@ -93346,7 +93363,9 @@ function readWavChunks(buf) {
   let data2;
   for (const { id, body, size } of riffChunks(buf)) {
     if (id === "fmt ") {
-      head.format = buf.readUInt16LE(body);
+      const format = wavFormatTag(buf, body, size);
+      if (format === null) throw new AudioFxRenderError("Invalid or unsupported WAV format header");
+      head.format = format;
       head.channels = buf.readUInt16LE(body + 2);
       head.sampleRate = buf.readUInt32LE(body + 4);
       head.bits = buf.readUInt16LE(body + 14);
@@ -96222,10 +96241,10 @@ var init_shaderTransitions = __esm({
         const dist = Math.sqrt(uvx * uvx + uvy * uvy);
         const warp = fbm(ux * 4, uy * 4) * 0.5;
         const fromAng = p2 * (1 - dist) * 10 + warp * p2 * 3;
-        const fs3 = Math.sin(fromAng);
+        const fs4 = Math.sin(fromAng);
         const fc = Math.cos(fromAng);
-        const fromUx = Math.max(0, Math.min(1, uvx * fc - uvy * fs3 + 0.5));
-        const fromUy = Math.max(0, Math.min(1, uvx * fs3 + uvy * fc + 0.5));
+        const fromUx = Math.max(0, Math.min(1, uvx * fc - uvy * fs4 + 0.5));
+        const fromUy = Math.max(0, Math.min(1, uvx * fs4 + uvy * fc + 0.5));
         const toAng = -(1 - p2) * (1 - dist) * 10 - warp * (1 - p2) * 3;
         const ts = Math.sin(toAng);
         const tc = Math.cos(toAng);
@@ -121535,19 +121554,21 @@ import { bodyLimit } from "hono/body-limit";
 import {
   closeSync as closeSync8,
   existsSync as existsSync37,
-  ftruncateSync as ftruncateSync2,
   openSync as openSync8,
   readFileSync as readFileSync52,
-  writeFileSync as writeFileSync52,
+  writeFileSync as writeFileSync42,
   writeSync as writeSync2,
   mkdirSync as mkdirSync32,
   unlinkSync as unlinkSync23,
   rmSync as rmSync32,
-  statSync as statSync23,
+  statSync as statSync32,
+  fstatSync as fstatSync4,
   renameSync as renameSync22,
   readdirSync as readdirSync42
 } from "fs";
 import { resolve as resolve32, dirname as dirname32, join as join62 } from "path";
+import * as fs2 from "fs";
+import { randomUUID as randomUUID9 } from "crypto";
 import { spawn as spawn11 } from "child_process";
 import {
   existsSync as existsSync38,
@@ -121567,31 +121588,22 @@ import { basename as basename8, join as join42 } from "path";
 import { mkdirSync as mkdirSync22, readdirSync as readdirSync32, readFileSync as readFileSync26, unlinkSync as unlinkSync5, writeFileSync as writeFileSync32 } from "fs";
 import { Buffer as Buffer2 } from "buffer";
 import { join as join52, relative as relative22 } from "path";
-import { createHash as createHash22, randomUUID as randomUUID9 } from "crypto";
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync42 } from "fs";
+import { createHash as createHash22, randomUUID as randomUUID22 } from "crypto";
+import { readFileSync as readFileSync32, statSync as statSync23 } from "fs";
 import { existsSync as existsSync211, readFileSync as readFileSync42, realpathSync as realpathSync8 } from "fs";
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID32 } from "crypto";
 import { dirname as dirname22, relative as relative32, resolve as resolve24, sep as sep22 } from "path";
-import { createReadStream as createReadStream3, existsSync as existsSync52, readFileSync as readFileSync82, statSync as statSync32 } from "fs";
+import { createReadStream as createReadStream3, existsSync as existsSync52, readFileSync as readFileSync82, statSync as statSync52 } from "fs";
 import { Readable as Readable2 } from "stream";
 import { join as join82, resolve as resolve42 } from "path";
 import { createHash as createHash32 } from "crypto";
 import { existsSync as existsSync42, readFileSync as readFileSync62 } from "fs";
 import { join as join72 } from "path";
-import {
-  closeSync as closeSync22,
-  constants as constants4,
-  fstatSync as fstatSync4,
-  ftruncateSync as ftruncateSync22,
-  openSync as openSync22,
-  readFileSync as readFileSync72,
-  writeFileSync as writeFileSync62,
-  writeSync as writeSync22
-} from "fs";
+import { closeSync as closeSync22, constants as constants4, fstatSync as fstatSync22, openSync as openSync22, readFileSync as readFileSync72, statSync as statSync42 } from "fs";
 import { readFileSync as readFileSync92 } from "fs";
 import { join as join92 } from "path";
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync62, readFileSync as readFileSync102, mkdirSync as mkdirSync42, unlinkSync as unlinkSync32, readdirSync as readdirSync52, statSync as statSync42 } from "fs";
+import { existsSync as existsSync62, readFileSync as readFileSync102, mkdirSync as mkdirSync42, unlinkSync as unlinkSync32, readdirSync as readdirSync52, statSync as statSync62 } from "fs";
 import { join as join102 } from "path";
 import {
   existsSync as existsSync72,
@@ -121600,15 +121612,15 @@ import {
   readdirSync as readdirSync62,
   renameSync as renameSync32,
   rmSync as rmSync42,
-  statSync as statSync52,
+  statSync as statSync72,
   unlinkSync as unlinkSync42,
-  writeFileSync as writeFileSync72
+  writeFileSync as writeFileSync52
 } from "fs";
 import { join as join112 } from "path";
-import { createHash as createHash42, randomUUID as randomUUID32 } from "crypto";
-import { existsSync as existsSync82, readFileSync as readFileSync122, statSync as statSync62 } from "fs";
+import { createHash as createHash42, randomUUID as randomUUID42 } from "crypto";
+import { existsSync as existsSync82, readFileSync as readFileSync122, statSync as statSync82 } from "fs";
 import { join as join122 } from "path";
-import { closeSync as closeSync32, constants as constants22, fstatSync as fstatSync22, openSync as openSync32, readSync as readSync2 } from "fs";
+import { closeSync as closeSync32, constants as constants22, fstatSync as fstatSync32, openSync as openSync32, readSync as readSync2 } from "fs";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 import { existsSync as existsSync92, mkdirSync as mkdirSync62 } from "fs";
 import { basename as basename22, dirname as dirname42, extname as extname22, join as join132 } from "path";
@@ -121807,6 +121819,20 @@ function getMimeType(path) {
 function isAudioFile2(name) {
   return (getMimeType(name) ?? "").startsWith("audio/");
 }
+function replaceFileAtomically(filePath, content, mode, operations = fs2) {
+  const tempPath = `${filePath}.${process.pid}.${randomUUID9()}.tmp`;
+  try {
+    operations.writeFileSync(tempPath, content, { encoding: "utf-8", mode });
+    operations.chmodSync(tempPath, mode);
+    operations.renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      operations.unlinkSync(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
 function buildWaveformCacheKey(assetPath, fingerprint) {
   const name = assetPath.replace(/[/\\]/g, "_");
   if (!fingerprint) return `${WAVEFORM_CACHE_VERSION}_${name}.json`;
@@ -122013,7 +122039,7 @@ function fileContentVersion(content) {
 }
 function createWriteToken(requestToken) {
   const token = requestToken?.trim();
-  return token && token.length <= 200 ? token : randomUUID9();
+  return token && token.length <= 200 ? token : randomUUID22();
 }
 function recordFileWriteReceipt(absPath, receipt) {
   const now = Date.now();
@@ -122045,7 +122071,7 @@ function identifyFileWrite(absPath, expectedVersion) {
   const { path, version: version2, writeToken } = receipt;
   return { path, version: version2, writeToken };
 }
-function applyFileMutations(projectDir, mutations, requestToken, writeFile3 = writeFileSync42) {
+function applyFileMutations(projectDir, mutations, requestToken, writeFile3 = (path, content) => replaceFileAtomically(path, content, statSync23(path).mode)) {
   const prepared = mutations.map((mutation) => ({
     ...mutation,
     before: mutation.before ?? readFileSync32(mutation.absPath, "utf-8")
@@ -122269,7 +122295,7 @@ function insertCompositionIntoSource(input2) {
   const host = document2.createElement("div");
   host.id = hostId;
   host.className = "clip";
-  host.setAttribute("data-hf-id", `hf-${randomUUID22()}`);
+  host.setAttribute("data-hf-id", `hf-${randomUUID32()}`);
   host.setAttribute("data-composition-id", hostId);
   host.setAttribute("data-composition-src", relativeSourcePath(targetAbs, sourceAbs));
   host.setAttribute("data-start", String(Math.round(input2.start * 100) / 100));
@@ -122303,13 +122329,18 @@ async function resolveProjectPath(c3, adapter2, pathPrefix, opts) {
   if (!project) {
     return { error: c3.json({ error: "not found" }, 404) };
   }
+  if (!existsSync37(project.dir)) {
+    return {
+      error: c3.json({ error: "not found", why: "project_dir_missing" }, 404)
+    };
+  }
   const filePath = decodeURIComponent(c3.req.path.replace(pathPrefix(project.id), ""));
   if (filePath.includes("\0")) {
-    return { error: c3.json({ error: "forbidden" }, 403) };
+    return { error: c3.json({ error: "forbidden", why: "nul" }, 403) };
   }
   const absPath = resolveWithinProject(project.dir, filePath);
   if (!absPath) {
-    return { error: c3.json({ error: "forbidden" }, 403) };
+    return { error: c3.json({ error: "forbidden", why: "outside_project" }, 403) };
   }
   if (opts?.mustExist && !existsSync37(absPath)) {
     return { error: c3.json({ error: "not found" }, 404) };
@@ -122368,7 +122399,7 @@ function foldElementPatches(originalContent, patches) {
   }
   return { content, matched };
 }
-function commitElementPatchBatches(projectDir, batches, writeFile3 = writeFileSync52, requestToken) {
+function commitElementPatchBatches(projectDir, batches, writeFile3 = (path, content) => replaceFileAtomically(path, content, statSync32(path).mode), requestToken) {
   const resolvedPaths = /* @__PURE__ */ new Set();
   const prepared = [];
   for (const batch of batches) {
@@ -122429,7 +122460,7 @@ function commitElementPatchBatchesWithReceipts(c3, projectDir, batches) {
   return commitElementPatchBatches(
     projectDir,
     batches,
-    writeFileSync52,
+    writeFileSync42,
     c3.req.header("X-Hyperframes-Write-Token")
   );
 }
@@ -122440,7 +122471,7 @@ function recordMutationReceipt(c3, filePath, absPath, html) {
   return { version: version2, writeToken };
 }
 function writeFileWithReceipt(c3, filePath, absPath, html) {
-  writeFileSync52(absPath, html, "utf-8");
+  replaceFileAtomically(absPath, html, statSync32(absPath).mode);
   return recordMutationReceipt(c3, filePath, absPath, html);
 }
 function writeMutationResult(c3, projectDir, filePath, absPath, html) {
@@ -122529,7 +122560,7 @@ function updateReferences(projectDir, oldPath, newPath) {
     if (!content.includes(oldPath)) continue;
     const updated = content.split(oldPath).join(newPath);
     if (updated !== content) {
-      writeFileSync52(file, updated, "utf-8");
+      replaceFileAtomically(file, updated, statSync32(file).mode);
       updatedCount++;
     }
   }
@@ -123618,7 +123649,7 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
       try {
         const fd = openSync8(finalPath, "wx");
         try {
-          writeFileSync52(fd, buffer);
+          writeFileSync42(fd, buffer);
         } finally {
           closeSync8(fd);
         }
@@ -123746,10 +123777,12 @@ function registerFileRoutes(api, adapter2) {
         }
         backup = snapshotBeforeWrite(res.project.dir, res.absPath);
         if (backup.error) return c3.json({ error: `backup failed: ${backup.error}` }, 500);
-        ftruncateSync2(fd, 0);
-        writeSync2(fd, body, 0, body.length, 0);
-      } finally {
+        const mode = fstatSync4(fd).mode;
         closeSync8(fd);
+        fd = null;
+        replaceFileAtomically(res.absPath, body, mode);
+      } finally {
+        if (fd !== null) closeSync8(fd);
       }
     }
     const version2 = fileContentVersion(body);
@@ -123770,7 +123803,7 @@ function registerFileRoutes(api, adapter2) {
     ensureDir(res.absPath);
     const body = Buffer.from(await c3.req.arrayBuffer());
     try {
-      writeFileSync52(res.absPath, body, { flag: "wx" });
+      writeFileSync42(res.absPath, body, { flag: "wx" });
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
         throw error;
@@ -123782,7 +123815,7 @@ function registerFileRoutes(api, adapter2) {
   api.delete("/projects/:id/files/*", async (c3) => {
     const res = await resolveProjectFile(c3, adapter2, { mustExist: true });
     if ("error" in res) return res.error;
-    const stat = statSync23(res.absPath);
+    const stat = statSync32(res.absPath);
     const backup = snapshotBeforeWrite(res.project.dir, res.absPath);
     if (backup.error) return c3.json({ error: `backup failed: ${backup.error}` }, 500);
     if (stat.isDirectory()) {
@@ -123972,7 +124005,7 @@ function registerFileRoutes(api, adapter2) {
       const written = [];
       try {
         for (const file of prepared) {
-          writeFileSync52(file.absPath, file.after, "utf-8");
+          replaceFileAtomically(file.absPath, file.after, statSync32(file.absPath).mode);
           written.push(file);
           recordFileWriteReceipt(file.absPath, {
             path: file.path,
@@ -123989,7 +124022,7 @@ function registerFileRoutes(api, adapter2) {
               conflicts.push(file.path);
               continue;
             }
-            writeFileSync52(file.absPath, file.before, "utf-8");
+            replaceFileAtomically(file.absPath, file.before, statSync32(file.absPath).mode);
             recordFileWriteReceipt(file.absPath, {
               path: file.path,
               version: fileContentVersion(file.before),
@@ -124316,7 +124349,7 @@ function registerFileRoutes(api, adapter2) {
       return c3.json({ error: "forbidden" }, 403);
     }
     ensureDir(destAbs);
-    writeFileSync52(destAbs, readFileSync52(srcAbs));
+    writeFileSync42(destAbs, readFileSync52(srcAbs));
     return c3.json({ ok: true, path: copyPath }, 201);
   });
   const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
@@ -124409,7 +124442,7 @@ function registerFileRoutes(api, adapter2) {
     if (current2 !== body.expected) {
       return c3.json({ ok: true, restored: false, conflict: true });
     }
-    writeFileSync52(res.absPath, body.restore, "utf-8");
+    replaceFileAtomically(res.absPath, body.restore, statSync32(res.absPath).mode);
     return c3.json({ ok: true, restored: true, conflict: false });
   });
 }
@@ -124587,7 +124620,7 @@ function persistHfIdsIfNeeded(filePath, html) {
     try {
       const current2 = readFileSync72(filePath, "utf-8");
       if (current2 === html) {
-        writeFileSync62(filePath, normalized2, "utf-8");
+        replaceFileAtomically(filePath, normalized2, statSync42(filePath).mode);
       }
     } catch (err) {
       console.warn("[hyperframes] persistHfIdsIfNeeded: failed to write ids to disk:", err);
@@ -124612,21 +124645,23 @@ function stampFileHfIds(filePath) {
   }
   if (fd === null) return null;
   try {
-    if (!fstatSync4(fd).isFile()) return null;
+    if (!fstatSync22(fd).isFile()) return null;
     const html = readFileSync72(fd, "utf-8");
     const normalized2 = ensureHfIds(html);
     const idsBefore = (html.match(/\bdata-hf-id=/g) ?? []).length;
     const idsAfter = (normalized2.match(/\bdata-hf-id=/g) ?? []).length;
     if (writable && idsAfter > idsBefore) {
-      ftruncateSync22(fd, 0);
-      writeSync22(fd, normalized2, 0, "utf-8");
+      const mode = fstatSync22(fd).mode;
+      closeSync22(fd);
+      fd = null;
+      replaceFileAtomically(filePath, normalized2, mode);
     }
     return normalized2;
   } catch (err) {
     console.warn("[hyperframes] stampFileHfIds: failed to stamp ids:", err);
     return null;
   } finally {
-    closeSync22(fd);
+    if (fd !== null) closeSync22(fd);
   }
 }
 function isVariablesPayload(value) {
@@ -124901,7 +124936,7 @@ ${runtimeTag}`;
       c3.req.path.replace(`/projects/${project.id}/preview/comp/`, "").split("?")[0] ?? ""
     );
     const compFile = resolveWithinProject(project.dir, compPath);
-    if (!compFile || !existsSync52(compFile) || !statSync32(compFile).isFile()) {
+    if (!compFile || !existsSync52(compFile) || !statSync52(compFile).isFile()) {
       return c3.text("not found", 404);
     }
     const compPathHash = createHash32("sha1").update(compPath).digest("hex");
@@ -124941,7 +124976,7 @@ ${runtimeTag}`;
     if (!file) {
       return c3.text("not found", 404);
     }
-    const stat = existsSync52(file) ? statSync32(file) : null;
+    const stat = existsSync52(file) ? statSync52(file) : null;
     if (!stat?.isFile()) {
       return c3.text("not found", 404);
     }
@@ -124991,7 +125026,7 @@ ${runtimeTag}`;
       servedContentType = PROXY_VARIANT_CONFIG[proxyVariant].contentType;
     }
     const textBuffer = isText2 ? Buffer.from(readFileSync82(file, "utf-8"), "utf-8") : null;
-    const totalSize2 = textBuffer ? textBuffer.length : statSync32(servedPath).size;
+    const totalSize2 = textBuffer ? textBuffer.length : statSync52(servedPath).size;
     const bodyFor = (start, end) => textBuffer ? new Uint8Array(textBuffer.subarray(start, end + 1)) : (
       // Node's web stream type and the DOM one do not overlap for tsc on
       // every platform's lib set; the double cast is the documented bridge.
@@ -125280,7 +125315,7 @@ function registerRenderRoutes(api, adapter2) {
     if (!existsSync62(rendersDir)) return c3.json({ renders: [] });
     const files = readdirSync52(rendersDir).filter((f) => f.endsWith(".mp4") || f.endsWith(".webm") || f.endsWith(".mov")).map((f) => {
       const fp = join102(rendersDir, f);
-      const stat = statSync42(fp);
+      const stat = statSync62(fp);
       const rid = f.replace(/\.(mp4|webm|mov)$/, "");
       const metaPath = join102(rendersDir, `${rid}.meta.json`);
       let status = "complete";
@@ -125322,7 +125357,7 @@ function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
     if (!entry.isFile()) return [];
     const path = join112(cacheDir, entry.name);
     try {
-      const stats = statSync52(path);
+      const stats = statSync72(path);
       return [{ path, bytes: stats.size, mtimeMs: stats.mtimeMs }];
     } catch {
       return [];
@@ -125348,9 +125383,9 @@ function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
   }
 }
 function writeThumbnailAtomically(path, buffer) {
-  const temporaryPath = `${path}.${process.pid}.${randomUUID32()}.tmp`;
+  const temporaryPath = `${path}.${process.pid}.${randomUUID42()}.tmp`;
   try {
-    writeFileSync72(temporaryPath, buffer, { flag: "wx" });
+    writeFileSync52(temporaryPath, buffer, { flag: "wx" });
     renameSync32(temporaryPath, path);
   } finally {
     rmSync42(temporaryPath, { force: true });
@@ -125390,7 +125425,7 @@ function registerThumbnailRoutes(api, adapter2) {
     if (existsSync72(htmlFile)) {
       const html = readFileSync112(htmlFile, "utf-8");
       sourceKey = `_${createHash42("sha1").update(html).digest("hex").slice(0, 16)}`;
-      sourceMtime = Math.round(statSync52(htmlFile).mtimeMs);
+      sourceMtime = Math.round(statSync72(htmlFile).mtimeMs);
       if (!vpWidth) {
         const wMatch = html.match(/data-width=["'](\d+)["']/);
         const hMatch = html.match(/data-height=["'](\d+)["']/);
@@ -125403,14 +125438,14 @@ function registerThumbnailRoutes(api, adapter2) {
     if (existsSync72(manualEditsFile)) {
       const manualEditsContent = readFileSync112(manualEditsFile, "utf-8");
       manualEditsKey = `_${createHash42("sha1").update(manualEditsContent).digest("hex").slice(0, 16)}`;
-      sourceMtime = Math.max(sourceMtime, Math.round(statSync52(manualEditsFile).mtimeMs));
+      sourceMtime = Math.max(sourceMtime, Math.round(statSync72(manualEditsFile).mtimeMs));
     }
     const motionFile = join112(project.dir, STUDIO_MOTION_PATH);
     let motionKey = "";
     if (existsSync72(motionFile)) {
       const motionContent = readFileSync112(motionFile, "utf-8");
       motionKey = `_${createHash42("sha1").update(motionContent).digest("hex").slice(0, 16)}`;
-      sourceMtime = Math.max(sourceMtime, Math.round(statSync52(motionFile).mtimeMs));
+      sourceMtime = Math.max(sourceMtime, Math.round(statSync72(motionFile).mtimeMs));
     }
     const previewUrl = compPath === "index.html" ? `http://${c3.req.header("host")}/api/projects/${project.id}/preview` : `http://${c3.req.header("host")}/api/projects/${project.id}/preview/comp/${compPath}`;
     const cacheDir = join112(project.dir, ".thumbnails");
@@ -125491,7 +125526,7 @@ function registerWaveformRoutes(api, adapter2) {
       c3.req.path.replace(`/projects/${project.id}/waveform/`, "").split("?")[0] ?? ""
     );
     const audioPath = join122(project.dir, assetPath);
-    const stats = statSync62(audioPath, { throwIfNoEntry: false });
+    const stats = statSync82(audioPath, { throwIfNoEntry: false });
     if (!stats) return c3.json({ error: "file not found" }, 404);
     const cacheDir = join122(project.dir, ".waveform-cache");
     const cachePath2 = join122(cacheDir, buildWaveformCacheKey(assetPath, stats));
@@ -125592,7 +125627,7 @@ function registerFontRoutes(api) {
       return c3.json({ error: "font file not accessible" }, 404);
     }
     try {
-      const stat = fstatSync22(fd);
+      const stat = fstatSync32(fd);
       if (stat.size > SYSTEM_FONT_SIZE_LIMIT) {
         return c3.json({ error: "font file too large" }, 413);
       }
@@ -151841,7 +151876,10 @@ function createStudioServer(options) {
         } catch {
         }
         const receipt = version2 ? identifyFileWrite(absPath, version2) : null;
-        stream.writeSSE({ event: "file-change", data: JSON.stringify({ path, version: version2, ...receipt }) }).catch(() => {
+        stream.writeSSE({
+          event: "file-change",
+          data: JSON.stringify({ path, version: version2, projectId: project.id, ...receipt })
+        }).catch(() => {
         });
       };
       const wrappedListener = (changedPath) => {
@@ -156607,12 +156645,12 @@ var init_paths2 = __esm({
 });
 
 // src/auth/store.ts
-import { promises as fs2 } from "fs";
+import { promises as fs3 } from "fs";
 import { dirname as dirname43 } from "path";
 async function readStore(path = credentialPath()) {
   let raw;
   try {
-    raw = await fs2.readFile(path, "utf8");
+    raw = await fs3.readFile(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { credentials: {}, source: "absent" };
@@ -156633,14 +156671,14 @@ async function writeStore(credentials, path = credentialPath()) {
   await ensureDir2(dirname43(path));
   const body = JSON.stringify(serializeCredentials(credentials), null, 2);
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await fs2.writeFile(tmp, `${body}
+  await fs3.writeFile(tmp, `${body}
 `, { mode: FILE_MODE, encoding: "utf8" });
-  await fs2.chmod(tmp, FILE_MODE);
-  await fs2.rename(tmp, path);
+  await fs3.chmod(tmp, FILE_MODE);
+  await fs3.rename(tmp, path);
 }
 async function deleteStore(path = credentialPath()) {
   try {
-    await fs2.unlink(path);
+    await fs3.unlink(path);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -156668,16 +156706,16 @@ async function clearOAuth(path = credentialPath()) {
 }
 async function ensureDir2(dir) {
   try {
-    const stat = await fs2.stat(dir);
+    const stat = await fs3.stat(dir);
     if (!stat.isDirectory()) {
       throw ErrInvalidStore(`${dir} exists and is not a directory`);
     }
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    await fs2.mkdir(dir, { recursive: true, mode: DIR_MODE });
+    await fs3.mkdir(dir, { recursive: true, mode: DIR_MODE });
   }
   try {
-    await fs2.chmod(dir, DIR_MODE);
+    await fs3.chmod(dir, DIR_MODE);
   } catch {
   }
 }
@@ -174171,11 +174209,11 @@ function lintFeedbackComment(input2) {
   if (!trimmed) return [];
   const upperTrimmed = trimmed.toUpperCase();
   const warnings = [];
-  if (!upperTrimmed.includes(REPRO_MARKER)) {
+  if (!hasReproCommandBody(trimmed)) {
     warnings.push({
       code: "missing-repro-command",
       message: [
-        `Comment on a ${rating}/${FEEDBACK_RATING_SCALE} report is missing a "${REPRO_MARKER}" block \u2014`,
+        `Comment on a ${rating}/${FEEDBACK_RATING_SCALE} report is missing a non-empty "${REPRO_MARKER}" block \u2014`,
         "maintainers can't rerun the failure from a symptom summary alone.",
         "See `references/preview-render.md` \u2192 feedback for the required packet shape."
       ].join(" ")
@@ -174194,13 +174232,29 @@ function lintFeedbackComment(input2) {
   }
   return warnings;
 }
+function hasReproCommandBody(comment) {
+  const lines = comment.split(/\r?\n/);
+  return lines.some((line3, index) => {
+    const markerIndex = line3.toUpperCase().indexOf(REPRO_MARKER);
+    if (markerIndex === -1) return false;
+    const inlineBody = line3.slice(markerIndex + REPRO_MARKER.length).trim();
+    if (inlineBody) return !startsWithFeedbackPacketMarker(inlineBody);
+    const nextContentLine = lines.slice(index + 1).find((candidate) => candidate.trim());
+    if (!nextContentLine) return false;
+    return !startsWithFeedbackPacketMarker(nextContentLine.trimStart());
+  });
+}
+function startsWithFeedbackPacketMarker(value) {
+  const upperValue = value.toUpperCase();
+  return FEEDBACK_PACKET_MARKERS.some((marker) => upperValue.startsWith(marker));
+}
 function escapeRegex3(input2) {
   return input2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function mentionsVisualDefect(comment) {
   return VISUAL_DEFECT_REGEX.test(comment);
 }
-var VISUAL_DEFECT_KEYWORDS, COMPOSITION_STRUCTURE_RATING_CEILING, REPRO_MARKER, STRUCTURE_MARKER, VISUAL_DEFECT_REGEX;
+var VISUAL_DEFECT_KEYWORDS, COMPOSITION_STRUCTURE_RATING_CEILING, REPRO_MARKER, STRUCTURE_MARKER, FEEDBACK_PACKET_MARKERS, VISUAL_DEFECT_REGEX;
 var init_feedbackLint = __esm({
   "src/utils/feedbackLint.ts"() {
     "use strict";
@@ -174216,6 +174270,14 @@ var init_feedbackLint = __esm({
     COMPOSITION_STRUCTURE_RATING_CEILING = 7;
     REPRO_MARKER = "REPRO COMMAND:";
     STRUCTURE_MARKER = "COMPOSITION_STRUCTURE:";
+    FEEDBACK_PACKET_MARKERS = [
+      REPRO_MARKER,
+      "EXPECTED / ACTUAL:",
+      "EXACT ERROR:",
+      "OUTCOME:",
+      "WORKAROUND:",
+      STRUCTURE_MARKER
+    ];
     VISUAL_DEFECT_REGEX = new RegExp(
       `(^|[^A-Za-z0-9_])(?:${VISUAL_DEFECT_KEYWORDS.map(escapeRegex3).join("|")})(?![A-Za-z0-9_])`,
       "i"

package/dist/fontLocalizeCli.js

@@ -80176,17 +80176,34 @@ function* riffChunks(buffer) {
     offset2 += 8 + size + size % 2;
   }
 }
+function extensibleFormatTag(fmt) {
+  const extraSize = fmt.readUInt16LE(16);
+  if (extraSize < 22 || 18 + extraSize > fmt.length) return null;
+  return EXTENSIBLE_FORMATS.get(fmt.toString("hex", 24, 40)) ?? null;
+}
+function wavFormatTag(buffer, body, size) {
+  const fmt = buffer.subarray(body, body + size);
+  if (fmt.length < 16) return null;
+  const tag = fmt.readUInt16LE(0);
+  if (tag !== 65534) return tag;
+  return fmt.length < 40 ? null : extensibleFormatTag(fmt);
+}
+var EXTENSIBLE_FORMATS;
 var init_wavChunks = __esm({
   "../engine/src/services/wavChunks.ts"() {
     "use strict";
+    EXTENSIBLE_FORMATS = /* @__PURE__ */ new Map([
+      ["0100000000001000800000aa00389b71", 1],
+      ["0300000000001000800000aa00389b71", 3]
+    ]);
   }
 });
 
 // ../engine/src/services/audioVolumeEnvelope.ts
 import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname8, join as join13 } from "path";
-function readFmtChunk(buffer, body) {
-  const format = buffer.readUInt16LE(body);
+function readFmtChunk(buffer, body, size) {
+  const format = wavFormatTag(buffer, body, size);
   const bits = buffer.readUInt16LE(body + 14);
   const float = format === FLOAT_FORMAT;
   if (!float && format !== PCM_FORMAT) return null;
@@ -80204,7 +80221,7 @@ function parseWavLayout(buffer) {
   let data2 = null;
   for (const { id, body, size } of riffChunks(buffer)) {
     if (id === "fmt " && body + 16 <= buffer.length) {
-      fmt = readFmtChunk(buffer, body);
+      fmt = readFmtChunk(buffer, body, size);
     } else if (id === "data") {
       data2 = { offset: body, size: Math.min(size, buffer.length - body) };
     }
@@ -80367,7 +80384,9 @@ function readWavChunks(buf) {
   let data2;
   for (const { id, body, size } of riffChunks(buf)) {
     if (id === "fmt ") {
-      head.format = buf.readUInt16LE(body);
+      const format = wavFormatTag(buf, body, size);
+      if (format === null) throw new AudioFxRenderError("Invalid or unsupported WAV format header");
+      head.format = format;
       head.channels = buf.readUInt16LE(body + 2);
       head.sampleRate = buf.readUInt32LE(body + 4);
       head.bits = buf.readUInt16LE(body + 14);
@@ -102729,8 +102748,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.59" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.59" : "0.0.0-dev";
+var VERSION = true ? "0.8.61" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.61" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {