hyperframes 0.4.24 → 0.4.26

package/dist/cli.js

@@ -54,7 +54,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.4.24" : "0.0.0-dev";
+    VERSION = true ? "0.4.26" : "0.0.0-dev";
   }
 });
 
@@ -10790,14 +10790,14 @@ function lintProject(project) {
   totalErrors += rootResult.errorCount;
   totalWarnings += rootResult.warningCount;
   totalInfos += rootResult.infoCount;
-  const allHtmlSources = [rootHtml];
+  const allHtmlSources = [{ html: rootHtml }];
   const compositionsDir = resolve5(project.dir, "compositions");
   if (existsSync7(compositionsDir)) {
     const files = readdirSync2(compositionsDir).filter((f3) => f3.endsWith(".html"));
     for (const file of files) {
       const filePath = join9(compositionsDir, file);
       const html = readFileSync7(filePath, "utf-8");
-      allHtmlSources.push(html);
+      allHtmlSources.push({ html, compSrcPath: `compositions/${file}` });
       const result = lintHyperframeHtml(html, { filePath, isSubComposition: true });
       results.push({ file: `compositions/${file}`, result });
       totalErrors += result.errorCount;
@@ -10840,7 +10840,7 @@ function lintProjectAudioFiles(projectDir, htmlSources) {
     return findings;
   }
   if (audioFiles.length === 0) return findings;
-  const hasAudioElement = htmlSources.some((html) => /<audio\b/i.test(html));
+  const hasAudioElement = htmlSources.some(({ html }) => /<audio\b/i.test(html));
   if (!hasAudioElement) {
     findings.push({
       code: "audio_file_without_element",
@@ -10855,13 +10855,14 @@ function lintAudioSrcNotFound(projectDir, htmlSources) {
   const findings = [];
   const audioSrcRe = /<audio\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/gi;
   const missingSrcs = [];
-  for (const html of htmlSources) {
+  for (const { html, compSrcPath } of htmlSources) {
     let match;
     while ((match = audioSrcRe.exec(html)) !== null) {
       const src = match[1];
       if (/^(https?:|data:|blob:)/i.test(src)) continue;
       if (/^__[A-Z_]+__$/.test(src)) continue;
-      const resolved = resolve5(projectDir, src);
+      const rootRelative = compSrcPath ? rewriteAssetPath(compSrcPath, src) : src;
+      const resolved = resolve5(projectDir, rootRelative);
       if (!existsSync7(resolved)) {
         missingSrcs.push(src);
       }
@@ -10910,7 +10911,7 @@ function lintDuplicateAudioTracks(htmlSources) {
   }
   const tracks = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const html of htmlSources) {
+  for (const { html } of htmlSources) {
     const audioTagRe = /<audio\b[^>]*>/gi;
     let match;
     while ((match = audioTagRe.exec(html)) !== null) {
@@ -10954,6 +10955,7 @@ var init_lintProject = __esm({
   "src/utils/lintProject.ts"() {
     "use strict";
     init_lint();
+    init_src();
     AUDIO_EXTENSIONS2 = /* @__PURE__ */ new Set([".mp3", ".wav", ".aac", ".ogg", ".m4a", ".flac", ".opus"]);
   }
 });
@@ -37570,6 +37572,89 @@ var init_play = __esm({
 import { basename as basename7, join as join39, relative as relative4 } from "path";
 import { readdirSync as readdirSync15, readFileSync as readFileSync27, statSync as statSync14 } from "fs";
 import AdmZip from "adm-zip";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dataRecord(payload) {
+  if (!isRecord(payload) || !isRecord(payload["data"])) return null;
+  return payload["data"];
+}
+function stringField(record, key2) {
+  const value = record[key2];
+  return typeof value === "string" ? value : null;
+}
+function parsePublishedProjectResponse(payload) {
+  const data = dataRecord(payload);
+  if (!data) return null;
+  const projectId = stringField(data, "project_id");
+  const title = stringField(data, "title");
+  const url = stringField(data, "url");
+  const claimToken = stringField(data, "claim_token");
+  const fileCount = data["file_count"];
+  if (!projectId || !title || !url || !claimToken || typeof fileCount !== "number") {
+    return null;
+  }
+  return {
+    projectId,
+    title,
+    fileCount,
+    url,
+    claimToken
+  };
+}
+function parseStagedUploadResponse(payload, archiveByteLength) {
+  const data = dataRecord(payload);
+  if (!data) return null;
+  const uploadUrl = stringField(data, "upload_url");
+  const uploadKey = stringField(data, "upload_key");
+  const contentType = stringField(data, "content_type") || PUBLISH_CONTENT_TYPE;
+  if (!uploadUrl || !uploadKey) return null;
+  return {
+    uploadUrl,
+    uploadKey,
+    contentType,
+    uploadHeaders: getUploadHeaders(data, uploadUrl, contentType, archiveByteLength)
+  };
+}
+function getUploadHeaders(data, uploadUrl, contentType, archiveByteLength) {
+  const headers = {};
+  const uploadHeaders = data["upload_headers"];
+  if (isRecord(uploadHeaders)) {
+    for (const [key2, value] of Object.entries(uploadHeaders)) {
+      if (typeof value === "string" && key2.trim()) {
+        headers[key2] = value;
+      }
+    }
+  }
+  if (!Object.keys(headers).some((key2) => key2.toLowerCase() === "content-type")) {
+    headers["content-type"] = contentType;
+  }
+  const signedHeaders = new URL(uploadUrl).searchParams.get("X-Amz-SignedHeaders");
+  if (signedHeaders?.split(";").includes("x-amz-server-side-encryption") && !Object.keys(headers).some((key2) => key2.toLowerCase() === "x-amz-server-side-encryption")) {
+    headers["x-amz-server-side-encryption"] = "AES256";
+  }
+  if (signedHeaders?.split(";").includes("content-length") && !Object.keys(headers).some((key2) => key2.toLowerCase() === "content-length")) {
+    headers["content-length"] = String(archiveByteLength);
+  }
+  return headers;
+}
+async function readJson(response) {
+  return response.clone().json().catch(() => null);
+}
+async function readErrorMessage(response, fallback) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    const payload = await readJson(response);
+    if (isRecord(payload) && typeof payload["message"] === "string") {
+      return payload["message"];
+    }
+  }
+  if (response.status === 403 && response.headers.get("cf-mitigated") === "challenge") {
+    return "Publish upload was blocked before reaching HyperFrames. Please retry after staged uploads are available.";
+  }
+  const text = await response.text().catch(() => "");
+  return text.trim() ? `${fallback}: ${text.trim().slice(0, 180)}` : fallback;
+}
 function shouldIgnoreSegment(segment) {
   return segment.startsWith(".") || IGNORED_DIRS.has(segment) || IGNORED_FILES.has(segment);
 }
@@ -37605,42 +37690,102 @@ function createPublishArchive(projectDir) {
 function getPublishApiBaseUrl() {
   return (process.env["HYPERFRAMES_PUBLISHED_PROJECTS_API_URL"] || process.env["HEYGEN_API_URL"] || "https://api2.heygen.com").replace(/\/$/, "");
 }
-async function publishProjectArchive(projectDir) {
-  const title = basename7(projectDir);
-  const archive = createPublishArchive(projectDir);
-  const archiveBytes = new Uint8Array(archive.buffer.byteLength);
-  archiveBytes.set(archive.buffer);
+function archiveArrayBuffer(archive) {
+  const arrayBuffer = new ArrayBuffer(archive.buffer.byteLength);
+  new Uint8Array(arrayBuffer).set(archive.buffer);
+  return arrayBuffer;
+}
+async function publishProjectArchiveDirect(apiBaseUrl, title, archive) {
   const body = new FormData();
   body.set("title", title);
-  body.set("file", new File([archiveBytes], `${title}.zip`, { type: "application/zip" }));
+  body.set(
+    "file",
+    new File([archiveArrayBuffer(archive)], `${title}.zip`, { type: PUBLISH_CONTENT_TYPE })
+  );
   const headers = {
     heygen_route: "canary"
   };
-  const response = await fetch(`${getPublishApiBaseUrl()}/v1/hyperframes/projects/publish`, {
+  const response = await fetch(`${apiBaseUrl}/v1/hyperframes/projects/publish`, {
     method: "POST",
     body,
     headers,
-    signal: AbortSignal.timeout(3e4)
+    signal: AbortSignal.timeout(PUBLISH_REQUEST_TIMEOUT_MS)
   });
-  const payload = await response.json().catch(() => null);
-  const message = typeof payload?.message === "string" ? payload.message : "Failed to publish project";
-  if (!response.ok || !payload?.data) {
-    throw new Error(message);
+  const payload = await readJson(response);
+  const publishedProject = parsePublishedProjectResponse(payload);
+  if (!response.ok || !publishedProject) {
+    throw new Error(await readErrorMessage(response, "Failed to publish project"));
   }
-  return {
-    projectId: String(payload.data.project_id),
-    title: String(payload.data.title),
-    fileCount: Number(payload.data.file_count),
-    url: String(payload.data.url),
-    claimToken: String(payload.data.claim_token)
-  };
+  return publishedProject;
+}
+async function publishProjectArchiveStaged(apiBaseUrl, title, archive) {
+  const fileName = `${title}.zip`;
+  const uploadResponse = await fetch(`${apiBaseUrl}/v1/hyperframes/projects/publish/upload`, {
+    method: "POST",
+    body: JSON.stringify({
+      file_name: fileName,
+      content_type: PUBLISH_CONTENT_TYPE,
+      content_length: archive.buffer.byteLength
+    }),
+    headers: {
+      "content-type": "application/json",
+      heygen_route: "canary"
+    },
+    signal: AbortSignal.timeout(PUBLISH_REQUEST_TIMEOUT_MS)
+  });
+  if (uploadResponse.status === 404 || uploadResponse.status === 405) {
+    return null;
+  }
+  const uploadPayload = await readJson(uploadResponse);
+  const stagedUpload = parseStagedUploadResponse(uploadPayload, archive.buffer.byteLength);
+  if (!uploadResponse.ok || !stagedUpload) {
+    throw new Error(await readErrorMessage(uploadResponse, "Failed to prepare project upload"));
+  }
+  const s3Response = await fetch(stagedUpload.uploadUrl, {
+    method: "PUT",
+    body: new Blob([archiveArrayBuffer(archive)], { type: stagedUpload.contentType }),
+    headers: stagedUpload.uploadHeaders,
+    signal: AbortSignal.timeout(PUBLISH_REQUEST_TIMEOUT_MS)
+  });
+  if (!s3Response.ok) {
+    throw new Error(await readErrorMessage(s3Response, "Failed to upload project archive"));
+  }
+  const completeResponse = await fetch(`${apiBaseUrl}/v1/hyperframes/projects/publish/complete`, {
+    method: "POST",
+    body: JSON.stringify({
+      upload_key: stagedUpload.uploadKey,
+      file_name: fileName,
+      title
+    }),
+    headers: {
+      "content-type": "application/json",
+      heygen_route: "canary"
+    },
+    signal: AbortSignal.timeout(PUBLISH_REQUEST_TIMEOUT_MS)
+  });
+  const completePayload = await readJson(completeResponse);
+  const publishedProject = parsePublishedProjectResponse(completePayload);
+  if (!completeResponse.ok || !publishedProject) {
+    throw new Error(await readErrorMessage(completeResponse, "Failed to publish project"));
+  }
+  return publishedProject;
+}
+async function publishProjectArchive(projectDir) {
+  const title = basename7(projectDir);
+  const archive = createPublishArchive(projectDir);
+  const apiBaseUrl = getPublishApiBaseUrl();
+  const stagedResult = await publishProjectArchiveStaged(apiBaseUrl, title, archive);
+  if (stagedResult) return stagedResult;
+  return publishProjectArchiveDirect(apiBaseUrl, title, archive);
 }
-var IGNORED_DIRS, IGNORED_FILES;
+var IGNORED_DIRS, IGNORED_FILES, PUBLISH_CONTENT_TYPE, PUBLISH_REQUEST_TIMEOUT_MS;
 var init_publishProject = __esm({
   "src/utils/publishProject.ts"() {
     "use strict";
     IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".next", "coverage"]);
     IGNORED_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db"]);
+    PUBLISH_CONTENT_TYPE = "application/zip";
+    PUBLISH_REQUEST_TIMEOUT_MS = 3e4;
   }
 });
 
@@ -65169,19 +65314,19 @@ function _moveValueRecursive(data, sourceKeys, destKeys, keyIdx, excludeKeys) {
   const key2 = sourceKeys[keyIdx];
   if (key2.endsWith("[]")) {
     const keyName = key2.slice(0, -2);
-    const dataRecord = data;
-    if (keyName in dataRecord && Array.isArray(dataRecord[keyName])) {
-      for (const item of dataRecord[keyName]) {
+    const dataRecord2 = data;
+    if (keyName in dataRecord2 && Array.isArray(dataRecord2[keyName])) {
+      for (const item of dataRecord2[keyName]) {
         _moveValueRecursive(item, sourceKeys, destKeys, keyIdx + 1, excludeKeys);
       }
     }
   } else if (key2 === "*") {
     if (typeof data === "object" && data !== null && !Array.isArray(data)) {
-      const dataRecord = data;
-      const keysToMove = Object.keys(dataRecord).filter((k2) => !k2.startsWith("_") && !excludeKeys.has(k2));
+      const dataRecord2 = data;
+      const keysToMove = Object.keys(dataRecord2).filter((k2) => !k2.startsWith("_") && !excludeKeys.has(k2));
       const valuesToMove = {};
       for (const k2 of keysToMove) {
-        valuesToMove[k2] = dataRecord[k2];
+        valuesToMove[k2] = dataRecord2[k2];
       }
       for (const [k2, v] of Object.entries(valuesToMove)) {
         const newDestKeys = [];
@@ -65192,16 +65337,16 @@ function _moveValueRecursive(data, sourceKeys, destKeys, keyIdx, excludeKeys) {
             newDestKeys.push(dk);
           }
         }
-        setValueByPath(dataRecord, newDestKeys, v);
+        setValueByPath(dataRecord2, newDestKeys, v);
       }
       for (const k2 of keysToMove) {
-        delete dataRecord[k2];
+        delete dataRecord2[k2];
       }
     }
   } else {
-    const dataRecord = data;
-    if (key2 in dataRecord) {
-      _moveValueRecursive(dataRecord[key2], sourceKeys, destKeys, keyIdx + 1, excludeKeys);
+    const dataRecord2 = data;
+    if (key2 in dataRecord2) {
+      _moveValueRecursive(dataRecord2[key2], sourceKeys, destKeys, keyIdx + 1, excludeKeys);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperframes",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "description": "HyperFrames CLI — create, preview, and render HTML video compositions",
   "repository": {
     "type": "git",