@hyperframes/share 0.9.28-alpha.0 → 0.9.28-alpha.1

package/dist/sourceIgnore.d.mts

@@ -0,0 +1,3 @@
+/** Explicit, project-relative exclusions. This only removes files; it cannot override safety exclusions.
+ * @param {string} root @returns {Promise<(path: string) => boolean>} */
+export function readSourceIgnore(root: string): Promise<(path: string) => boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/share",
-  "version": "0.9.28-alpha.0",
+  "version": "0.9.28-alpha.1",
   "description": "Shared review identity, version upload and sharing state for HyperFrames hosts",
   "license": "Apache-2.0",
   "repository": {

package/src/projectSnapshot.mjs

@@ -1,6 +1,7 @@
 // @ts-check
 // A project's files as change detection sees them: every file the film can use (isOutsideFilm), keyed by mtime and
 // size, except html, keyed by content without the data-hf-id stamps. A run's change set and the watcher both read it.
+import { readSourceIgnore } from "./sourceIgnore.mjs";
 import fs from "node:fs/promises";
 import { constants } from "node:fs";
 import path from "node:path";
@@ -60,6 +61,7 @@ async function entryKind(entry, full, followSymlinks) {
 export async function snapshotProject(dir, { byContent = false, followSymlinks = false } = {}) {
   /** @type {Snapshot} */
   const result = new Map();
+  const ignored = await readSourceIgnore(dir);
   /** @param {string} current @param {Set<string>} ancestors */
   async function walk(current, ancestors) {
     const real = await fs.realpath(current).catch(() => null);
@@ -74,7 +76,7 @@ export async function snapshotProject(dir, { byContent = false, followSymlinks =
     }
     for (const entry of entries) {
       const full = path.join(current, entry.name);
-      if (isOutsideFilm(path.relative(dir, full))) continue;
+      if (excludedFromSnapshot(dir, full, ignored)) continue;
       const kind = await entryKind(entry, full, followSymlinks);
       if (kind?.isDirectory()) await walk(full, parents);
       else if (kind?.isFile()) {
@@ -100,11 +102,12 @@ export function snapshotFingerprint(snapshot) {
 export async function snapshotFiles(dir, files) {
   /** @type {Map<string, unknown>} */
   const result = new Map();
+  const ignored = await readSourceIgnore(dir);
   for (const file of files) {
     const full = path.join(dir, file);
     const stat = await fs.lstat(full).catch(() => null);
     if (stat?.isDirectory()) return null;
-    const holds = stat?.isFile() && !isOutsideFilm(path.relative(dir, full));
+    const holds = stat?.isFile() && !excludedFromSnapshot(dir, full, ignored);
     result.set(file, holds ? await snapshotKey(full, false) : undefined);
   }
   return result;
@@ -125,3 +128,9 @@ export function diffChangedFiles(before, after) {
 /** @param {string} projectPath @param {{ byContent?: boolean }} [options] */
 export const projectFingerprint = async (projectPath, options) =>
   snapshotFingerprint(await snapshotProject(projectPath, { ...options, followSymlinks: true }));
+
+/** @param {string} dir @param {string} full @param {(path: string) => boolean} ignored */
+function excludedFromSnapshot(dir, full, ignored) {
+  const relative = path.relative(dir, full);
+  return isOutsideFilm(relative) || ignored(relative.split(path.sep).join("/"));
+}

package/src/reviewExport.mjs

@@ -705,9 +705,17 @@ async function sendVersion(r, report, source, id, state) {
     const done = await watch(r, id, uploaded, size, report, clock);
     return finishRun(r, state, pending, id, done, first);
   } catch (error) {
-    if (spent(error, state.pending)) await writeState(r.projectPath, { ...state, pending: null });
-    console.error("[review] version failed:", error);
-    return said(error);
+    const failure = said(error);
+    await writeState(r.projectPath, {
+      ...state,
+      pending: spent(error, state.pending) ? null : state.pending,
+      failure: {
+        ...failure,
+        projectId: id,
+        exportKey: await failedExportKey(r.projectPath, pending),
+      },
+    });
+    return failure;
   }
 }
 
@@ -773,7 +781,6 @@ export async function addVersion(request) {
     if (kept) failures.set(key, { ...failure, exportKey: exportKeyOf(r.projectPath) });
     return failure?.sentence ?? null;
   } catch (error) {
-    console.error("[review] version failed:", error);
     const sentence =
       error instanceof SharingStateError ? error.message : "Couldn't add this version. Try again.";
     failures.set(key, {

package/src/reviewVersionSentences.mjs

@@ -14,7 +14,8 @@ const SAID = {
   export_daily_limit: (error) =>
     `You've added the most versions for today. Try again ${laterIn(error.retryAfterMs)}.`,
   content_rejected: "This video can't be shared.",
-  export_blocked: "Adding videos to review pages isn't available for this account.",
+  export_blocked:
+    "Sharing new videos is blocked because of recent content moderation strikes in this workspace. Rendering again will not lift the block. For appeal instructions, visit https://help.heygen.com/en/articles/7842567-the-ethical-use-of-synthetic-media",
   feature_unavailable: "Review pages aren't available for your account yet.",
   permission_denied: "This account can't add videos to this review page yet.",
   upload_expired: "The upload took too long. Try again.",

package/src/sourceIgnore.mjs

@@ -0,0 +1,69 @@
+// @ts-check
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Explicit, project-relative exclusions. This only removes files; it cannot override safety exclusions.
+ * @param {string} root @returns {Promise<(path: string) => boolean>} */
+export async function readSourceIgnore(root) {
+  const file = join(root, ".hyperframesignore");
+  const invalid = () =>
+    new Error(".hyperframesignore must be a regular file inside the project, smaller than 64 KiB.");
+  const handle = await open(
+    file,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0),
+  ).catch(async (/** @type {NodeJS.ErrnoException} */ error) => {
+    if (error.code !== "ENOENT") throw invalid();
+    // An absent file means no exclusions; a dangling symlink is invalid.
+    const named = await lstat(file).catch((/** @type {NodeJS.ErrnoException} */ missing) => {
+      if (missing.code === "ENOENT") return null;
+      throw invalid();
+    });
+    if (named) throw invalid();
+    return null;
+  });
+  if (!handle) return () => false;
+  let text;
+  try {
+    // Validate the opened descriptor before reading. lstat additionally rejects links on
+    // platforms without O_NOFOLLOW; it never authorizes a later open of this path.
+    const [stat, named] = await Promise.all([handle.stat(), lstat(file)]);
+    if (
+      !stat.isFile() ||
+      stat.size >= 65536 ||
+      !named.isFile() ||
+      stat.ino !== named.ino ||
+      stat.dev !== named.dev
+    )
+      throw invalid();
+    const buffer = Buffer.alloc(65536);
+    let length = 0;
+    while (length < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
+      if (!bytesRead) break;
+      length += bytesRead;
+    }
+    if (length === buffer.length) throw invalid();
+    text = buffer.subarray(0, length).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+  const paths = text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"));
+  const entries = paths.map((entry) => {
+    const path = entry.replace(/\/$/, "");
+    if (
+      path === "index.html" ||
+      /[\\*?![\]:]/.test(path) ||
+      path.includes("\0") ||
+      path.split("/").some((part) => !part || part === "." || part === "..")
+    )
+      throw new Error(
+        ".hyperframesignore accepts literal project-relative file or folder paths, one per line. Wildcards and excluding index.html are not supported.",
+      );
+    return path;
+  });
+  return (path) => entries.some((entry) => path === entry || path.startsWith(`${entry}/`));
+}

package/src/sources/capture.mjs

@@ -2,6 +2,7 @@
 // Captures a project folder as the canonical manifest the server accepts: every portable regular file with its
 // SHA-256 and length. A file that cannot be read, a link, a special file or a name no client can store fails the
 // capture with a list of them; it never becomes a deletion. Limits are checked from sizes alone, before any hashing.
+import { readSourceIgnore } from "../sourceIgnore.mjs";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, open, readdir, realpath } from "node:fs/promises";
@@ -83,6 +84,7 @@ async function listFolder(root, dir) {
 async function walkProject(root, renderOutput) {
   /** @type {Walk} */
   const walk = { files: [], problems: [], waiting: [], skippedLinks: [] };
+  const ignored = await readSourceIgnore(root);
   const dirs = [""];
   for (let dir = dirs.pop(); dir !== undefined; dir = dirs.pop()) {
     let entries;
@@ -95,7 +97,7 @@ async function walkProject(root, renderOutput) {
     }
     for (const entry of entries) {
       const rel = dir ? `${dir}/${entry.name}` : entry.name;
-      if (prefiltered(entry.name) || renderOutput(rel)) continue;
+      if (prefiltered(entry.name) || renderOutput(rel) || ignored(rel)) continue;
       await visit(root, rel, entry, walk, dirs);
     }
   }