@hyperframes/share 0.9.28-alpha.1 → 0.9.28

package/src/reviewClient.mjs

@@ -92,6 +92,7 @@ export function reviewClient({ access, fetchImpl = fetch, signedInEmail = async
      * @returns {Promise<{ versionSharing: boolean, shareFiles: boolean }>} */
     reviewFlags: async () => {
       const data = await call("GET", SPACES, undefined, {}, SHARING_REFUSALS);
+      if (!Array.isArray(data?.items)) throw new ReviewFailed(502, "malformed_spaces");
       return {
         versionSharing: data?.version_sharing === true,
         shareFiles: data?.share_files === true,
@@ -152,9 +153,8 @@ function threadWrites(call, project) {
   };
 }
 
-/** An invite to an email whose grant was revoked: the server keeps the revoked row, leaves it out of the grant list,
- * and takes it back only with that row's revision and a fresh operation ID, so the one revision the client can learn is
- * the conflict's. Null for any other refusal, or one the same revision already got.
+/** An invite to an email whose grant was revoked: the server takes the row back only at its revision with a fresh
+ * operation ID, here the conflict's revision. Null for any other refusal, or one the same revision already got.
  * @param {unknown} error @param {import("./types/reviewWire.js").CreateGrantRequest} body
  * @returns {import("./types/reviewWire.js").CreateGrantRequest | null} */
 function regrantOf(error, body) {
@@ -166,17 +166,24 @@ function regrantOf(error, body) {
   return { ...body, client_operation_id: randomUUID(), expected_revision: revision };
 }
 
-/** Creating a grant, keeping the re-grant `regrantOf` makes as that invitation's retry. The window retries with the
- * operation it first sent; once a re-grant went out under a new operation, that exact re-grant is sent again, so the
- * server's replay recovers a lost answer (or refuses it as revoked since) and no further re-grant is made. It goes
- * exactly when the window drops its own operation: on an answer, on a refusal `rejectedGrantRequest` (the window's own
- * test) calls final, or when the email is invited afresh. Any other refusal, a moderation hold among them, keeps it.
+/** Grants listed with their revoked rows, whose revisions let a re-invite go straight out as the re-grant; a server
+ * that ignores `include_revoked` lists none, and the re-invite meets `revision_conflict` first. A re-grant is kept as
+ * its invitation's retry, sent again as itself until an answer or a refusal `rejectedGrantRequest` calls final.
  * @param {(method: string, route: string, body?: unknown) => Promise<any>} call @param {(id: string) => string} project
  * @param {import("./types/access.js").ApiAccess} access */
-function grantCreator(call, project, access) {
+function grantCalls(call, project, access) {
   /** Re-grants awaiting a final answer, by site, account, project and the operation the window sent.
    * @type {Map<string, { email: string, regrant: import("./types/reviewWire.js").CreateGrantRequest }>} */
   const sent = new Map();
+  /** The revision of each revoked grant the last list read, by site, account and project, then email.
+   * @type {Map<string, Map<string, number>>} */
+  const revoked = new Map();
+  /** @param {string} id */
+  const scopeOf = async (id) => {
+    // expected: signed out, the call itself refuses as login_required; the scope is only a key.
+    const who = await access().catch(() => null);
+    return [who?.heygen ?? "", who?.owner ?? "", id].join("\n");
+  };
   /** @param {string} route @param {string} key @param {import("./types/reviewWire.js").CreateGrantRequest} body */
   const settle = async (route, key, body) => {
     try {
@@ -188,29 +195,76 @@ function grantCreator(call, project, access) {
       throw error;
     }
   };
-  /** @param {string} id @param {import("./types/reviewWire.js").CreateGrantRequest} body
-   * @returns {Promise<import("./types/reviewWire.js").AccessGrantDTO>} */
-  return async (id, body) => {
-    const route = `${project(id)}/access-grants`;
-    // expected: signed out, the POST below refuses as login_required; the scope is only a key.
-    const who = await access().catch(() => null);
-    const scope = grantScope(who, id);
-    const key = `${scope}\n${body.client_operation_id}`;
-    const retained = sent.get(key);
-    if (retained) return settle(route, key, retained.regrant);
+  /** @param {string} route @param {string} key @param {import("./types/reviewWire.js").CreateGrantRequest} body */
+  const regranting = (route, key, body) => {
+    sent.set(key, { email: body.email, regrant: body });
+    return settle(route, key, body);
+  };
+  /** @param {string} scope @param {string} email */
+  const forgetEarlierInvites = (scope, email) => {
     for (const [other, kept] of sent)
-      if (other.startsWith(`${scope}\n`) && kept.email === body.email) sent.delete(other);
-    try {
-      return await call("POST", route, body);
-    } catch (error) {
-      const regrant = regrantOf(error, body);
-      if (!regrant) throw error;
-      sent.set(key, { email: body.email, regrant });
-      return settle(route, key, regrant);
-    }
+      if (other.startsWith(`${scope}\n`) && kept.email === email) sent.delete(other);
+  };
+  return {
+    /** The project's live grants. @param {string} id
+     * @returns {Promise<{items: import("./types/reviewWire.js").AccessGrantDTO[]}>} */
+    grants: async (id) => {
+      const scope = await scopeOf(id);
+      const items = await everyGrant(call, `${project(id)}/access-grants`);
+      revoked.set(
+        scope,
+        new Map(
+          items.filter((grant) => grant.revoked_at).map((grant) => [grant.email, grant.revision]),
+        ),
+      );
+      return { items: items.filter((grant) => !grant.revoked_at) };
+    },
+    /** @param {string} id @param {import("./types/reviewWire.js").CreateGrantRequest} body
+     * @returns {Promise<import("./types/reviewWire.js").AccessGrantDTO>} */
+    createGrant: async (id, body) => {
+      const route = `${project(id)}/access-grants`;
+      const scope = await scopeOf(id);
+      const key = `${scope}\n${body.client_operation_id}`;
+      const retained = sent.get(key);
+      if (retained) return settle(route, key, retained.regrant);
+      forgetEarlierInvites(scope, body.email);
+      const known =
+        body.expected_revision === null ? revoked.get(scope)?.get(body.email) : undefined;
+      revoked.get(scope)?.delete(body.email);
+      const first =
+        known === undefined
+          ? body
+          : { ...body, client_operation_id: randomUUID(), expected_revision: known };
+      try {
+        return await (first === body ? call("POST", route, body) : regranting(route, key, first));
+      } catch (error) {
+        const regrant = regrantOf(error, first);
+        if (!regrant) throw error;
+        return regranting(route, key, regrant);
+      }
+    },
   };
 }
 
+/** Every page of a grant list, revoked rows included where the server lists them.
+ * @param {(method: string, route: string) => Promise<any>} call @param {string} route
+ * @returns {Promise<import("./types/reviewWire.js").AccessGrantDTO[]>} */
+async function everyGrant(call, route) {
+  const items = [];
+  const cursors = new Set();
+  let cursor = null;
+  do {
+    const query = new URLSearchParams({ include_revoked: "true", ...(cursor ? { cursor } : {}) });
+    const page = await call("GET", `${route}?${query}`);
+    items.push(...page.items);
+    cursor = page.next_cursor;
+    if (cursor && (cursors.has(cursor) || cursors.size >= 1000))
+      throw new ReviewFailed(502, "malformed_grant_pagination");
+    cursors.add(cursor);
+  } while (cursor);
+  return items;
+}
+
 /** @typedef {ReturnType<typeof reviewClient>} ReviewClient
  * @typedef {import("./types/reviewWire.js").ExportRequest} ExportRequest */
 
@@ -229,23 +283,7 @@ function managementClient(call, project, access) {
       }),
     /** @param {string} id @returns {Promise<null>} */
     removeProject: (id) => call("DELETE", project(id)),
-    /** @param {string} id @returns {Promise<{items: import("./types/reviewWire.js").AccessGrantDTO[]}>} */
-    grants: async (id) => {
-      const items = [];
-      const cursors = new Set();
-      let cursor = null;
-      do {
-        const query = new URLSearchParams(cursor ? { cursor } : {});
-        const page = await call("GET", `${project(id)}/access-grants?${query}`);
-        items.push(...page.items);
-        cursor = page.next_cursor;
-        if (cursor && (cursors.has(cursor) || cursors.size >= 1000))
-          throw new ReviewFailed(502, "malformed_grant_pagination");
-        cursors.add(cursor);
-      } while (cursor);
-      return { items };
-    },
-    createGrant: grantCreator(call, project, access),
+    ...grantCalls(call, project, access),
     /** @param {string} id @param {string} grantId @param {{role: import("./types/reviewWire.js").AccessGrantDTO["role"],
      * expected_revision: number}} body @returns {Promise<import("./types/reviewWire.js").AccessGrantDTO>} */
     updateGrant: (id, grantId, body) =>
@@ -255,6 +293,3 @@ function managementClient(call, project, access) {
       call("DELETE", `${project(id)}/access-grants/${encodeURIComponent(grantId)}`),
   };
 }
-
-/** @param {Awaited<ReturnType<import("./types/access.js").ApiAccess>>} who @param {string} id */
-const grantScope = (who, id) => [who?.heygen ?? "", who?.owner ?? "", id].join("\n");

package/src/reviewExport.mjs

@@ -39,10 +39,9 @@ import { versionSentence } from "./reviewVersionSentences.mjs";
  * definitive result; `reviewSent`: cleanup cutoff, with attribution only when the accepted attempt is
  * known; `last`: the newest version.
  * @typedef {{ pending: { body: ExportRequest, videoId: string | null, projectId?: string | null,
- *   renderKey?: string, checkingSince?: number, snapshotRefused?: boolean, unanswered?: boolean, reviewSent?: ReviewSent } | null,
- *   last: { fingerprint: string, versionId: string, exportedAt: string, projectId: string, files?: boolean,
- *     snapshot?: ExportRequest["snapshot"], checksum?: string }
- *   | null, failure?: (Failure & { projectId: string }) | null }} VersionRecord */
+ *   checkingSince?: number, snapshotRefused?: boolean, unanswered?: boolean, reviewSent?: ReviewSent } | null,
+ *   last: { fingerprint: string, versionId: string, exportedAt: string, projectId: string, files?: boolean, checksum?: string }
+ *   | null }} VersionRecord */
 
 /** `onAdded`: a version went ready, with whether it carries files and whether it is the page's first from here.
  * @typedef {{ onProgress?: (progress: ReviewExportProgress | null) => void, onUploaded?: () => Promise<void>,
@@ -50,11 +49,10 @@ import { versionSentence } from "./reviewVersionSentences.mjs";
 
 /** `projectId` overrides the recorded review project; `open`: a held video is watched only while the project is open.
  * `filesForExport`: the synced snapshot a new version carries, null for
- * none. `allowPending` lets a host treat accepted processing or screening as a successful return.
+ * none.
  * @typedef {VersionHooks & { projectPath: string, title: string, client: ReviewClient, put?: typeof putFile,
  *   sleep?: (ms: number) => Promise<void>, probe?: (file: string) => Promise<VideoFacts | null>, now?: () => number,
- *   projectId?: string | null, filesForExport?: FilesForRender, fromReview?: FromReview | null,
- *   allowPending?: boolean, requireSource?: boolean, omitSource?: boolean }} VersionRequest */
+ *   projectId?: string | null, filesForExport?: FilesForRender, fromReview?: FromReview | null }} VersionRequest */
 
 /** The snapshot of `rendered`, the project as the export was rendered; null when the folder is not that render.
  * @typedef {(projectPath: string, rendered: string | null) => Promise<import("./types/reviewWire.js").SnapshotRef | null>}
@@ -179,36 +177,18 @@ function isLast(value) {
     isSavedId(value.versionId) &&
     isSavedId(value.exportedAt) &&
     isSavedId(value.projectId) &&
-    isLastMetadata(value)
-  );
-}
-
-/** @param {Record<string, unknown>} value */
-function isLastMetadata(value) {
-  return (
     isOptionalBoolean(value.files) &&
-    isOptionalSnapshot(value.snapshot) &&
     (value.checksum === undefined || isSavedId(value.checksum))
   );
 }
 
 /** @param {Record<string, unknown>} saved
- * @returns {saved is {pending?: VersionRecord["pending"], last?: SavedLast | null, failure?: unknown}} */
+ * @returns {saved is {pending?: VersionRecord["pending"], last?: SavedLast | null}} */
 const isExportState = (saved) =>
   ("pending" in saved || "last" in saved) &&
   (saved.pending == null || isPending(saved.pending)) &&
   (saved.last == null || isLast(saved.last));
 
-/** @param {unknown} value @returns {value is Failure & { projectId: string }} */
-const isSavedFailure = (value) =>
-  isJsonObject(value) &&
-  isSavedId(value.projectId) &&
-  typeof value.exportKey === "string" &&
-  typeof value.sentence === "string" &&
-  typeof value.final === "boolean" &&
-  typeof value.exportHelps === "boolean" &&
-  isOptionalBoolean(value.held);
-
 /** @param {string} dir @returns {Promise<VersionRecord>} */
 async function readState(dir) {
   const file = statePath(dir);
@@ -218,7 +198,6 @@ async function readState(dir) {
   const { last, pending } = saved;
   return {
     pending: pending ?? null,
-    failure: isSavedFailure(saved.failure) ? saved.failure : null,
     last: typeof last?.fingerprint === "string" ? { ...last, fingerprint: last.fingerprint } : null,
   };
 }
@@ -255,7 +234,7 @@ const failures = new Map();
 /** Which export a failure was about: the newest export file and the project as it was rendered. @param {string} dir */
 const exportKeyOf = (dir) => {
   const latest = latestExportFile(dir);
-  return latest ? `${latest.path}\n${latest.fingerprint ?? ""}\n${latest.id}` : "";
+  return latest ? `${latest.path}\n${latest.fingerprint ?? ""}` : "";
 };
 
 /** Whether the newest export can go up now: there is one, it is MP4, and the project has not moved past it.
@@ -280,8 +259,7 @@ export async function reviewVersion(projectPath, server = {}) {
   const last = state.last?.projectId === projectId ? state.last : null;
   const onServer =
     server.latestReadyVersionId === undefined || server.latestReadyVersionId === last?.versionId;
-  const savedFailure = state.failure?.projectId === projectId ? state.failure : null;
-  const failed = savedFailure ?? failures.get(key);
+  const failed = failures.get(key);
   return {
     last: last
       ? { exportedAt: last.exportedAt, current: last.fingerprint === now && onServer }
@@ -301,8 +279,8 @@ export async function reviewVersion(projectPath, server = {}) {
 
 /** The newest MP4 and the body that adds it; a stale, non-MP4, too big or too long export never sends anything.
  * @param {string} dir @param {string} title @param {(file: string) => Promise<VideoFacts | null>} probe
- * @param {FilesForRender} filesForExport @param {boolean} requireSource */
-async function exportSource(dir, title, probe, filesForExport, requireSource) {
+ * @param {FilesForRender} filesForExport */
+async function exportSource(dir, title, probe, filesForExport) {
   const latest = latestExportFile(dir);
   if (!latest || sourceOf(dir, await projectFingerprint(dir)) !== "ready")
     return { failure: local("Export an MP4 of the project as it is now first.") };
@@ -329,32 +307,16 @@ async function exportSource(dir, title, probe, filesForExport, requireSource) {
       content_type: "video/mp4",
     },
   };
-  const snapshot = await sourceSnapshot(
-    dir,
-    body.source_fingerprint,
-    filesForExport,
-    requireSource,
-  );
-  if (missingRequiredSource(requireSource, snapshot))
-    return {
-      failure: local(
-        "Source changed after preparation. Retry sharing, or choose video-only explicitly.",
-      ),
-    };
-  if (snapshot) body.snapshot = snapshot;
-  return { file: latest.path, body };
-}
-
-/** @param {boolean} required @param {import("./types/reviewWire.js").SnapshotRef | null} snapshot */
-const missingRequiredSource = (required, snapshot) => required && !snapshot;
-
-/** @param {string} dir @param {string | null} rendered @param {FilesForRender} filesForExport @param {boolean} requireSource */
-async function sourceSnapshot(dir, rendered, filesForExport, requireSource) {
-  return filesForExport(dir, rendered).catch((error) => {
-    if (requireSource) throw error;
-    console.error("[review files] could not read source; adding video only:", error);
+  const snapshot = await filesForExport(dir, body.source_fingerprint).catch((error) => {
+    // expected: the version still goes up, and Share's files line says it has no files and offers Sync now.
+    console.error(
+      "[review files] couldn't read the synced snapshot; the version goes up without files:",
+      error,
+    );
     return null;
   });
+  if (snapshot) body.snapshot = snapshot;
+  return { file: latest.path, body };
 }
 
 /** @param {ExportRequest["snapshot"]} a @param {ExportRequest["snapshot"]} b */
@@ -406,7 +368,7 @@ async function createdExport(r, id, pending, kept) {
     return await sendCreate(r, id, pending, kept);
   } catch (error) {
     const refused = error instanceof ReviewFailed && error.reason === "snapshot_mismatch";
-    if (!refused || !pending.body.snapshot || pending.unanswered || r.requireSource) throw error;
+    if (!refused || !pending.body.snapshot || pending.unanswered) throw error;
     console.error("[review] snapshot refused; the version goes up without files:", error);
     const body = { ...pending.body, client_operation_id: `export-${randomUUID()}` };
     delete body.snapshot;
@@ -602,31 +564,17 @@ const spent = (error, pending) =>
  * @param {string} id @param {ExportDTO} done @param {FromReview | null} fromReview @returns {Promise<Said | null>} */
 async function finish(dir, state, pending, id, done, fromReview) {
   const ready = done.status === "ready";
-  const last = readyRecord(pending, id, done);
-  const failure = ready ? null : said(new ReviewFailed(200, done.error?.reason ?? ""));
-  await writeState(dir, {
-    pending: null,
-    last: ready ? last : state.last,
-    ...(failure && {
-      failure: { ...failure, projectId: id, exportKey: await failedExportKey(dir, pending) },
-    }),
-  });
+  const last = {
+    fingerprint: pending.body.source_fingerprint ?? "",
+    versionId: done.version_id,
+    exportedAt: done.exported_at,
+    projectId: id,
+    files: Boolean(pending.body.snapshot),
+    checksum: pending.body.local_upload.checksum_sha256,
+  };
+  await writeState(dir, { pending: null, last: ready ? last : state.last });
   if (ready) await sharedFromReview(fromReview, dir, pending.reviewSent?.since);
-  return failure;
-}
-
-/** @param {string} dir @param {NonNullable<VersionRecord["pending"]>} pending */
-async function failedExportKey(dir, pending) {
-  if (typeof pending.renderKey === "string") return pending.renderKey;
-  const latest = latestExportFile(dir);
-  if (!latest) return "";
-  const checksum =
-    latest.fingerprint === pending.body.source_fingerprint
-      ? await fileSha256Base64(latest.path).catch(() => null)
-      : null;
-  return checksum === pending.body.local_upload.checksum_sha256
-    ? exportKeyOf(dir)
-    : `pending:${pending.body.client_operation_id}`;
+  return ready ? null : said(new ReviewFailed(200, done.error?.reason ?? ""));
 }
 
 /** @param {Required<VersionRequest>} r @param {(progress: ReviewExportProgress) => void} report
@@ -634,37 +582,17 @@ async function failedExportKey(dir, pending) {
 async function run(r, report) {
   report({ step: "preparing", sent: 0, total: 0 });
   const state = await readState(r.projectPath);
-  const source = await exportSource(
-    r.projectPath,
-    r.title,
-    r.probe,
-    r.omitSource ? noSource : r.filesForExport,
-    r.requireSource,
-  );
+  const source = await exportSource(r.projectPath, r.title, r.probe, r.filesForExport);
   if ("failure" in source) return source.failure ?? null;
   const id = r.projectId ?? (await reviewProjectId(r.projectPath));
   if (!id) return local("Share the project first, then add a version.");
-  if (
-    sameSourceMode(r, state.last, source.body.snapshot) &&
-    (await alreadyUploaded(r.client, id, state, source.body))
-  )
-    return null;
+  if (await alreadyUploaded(r.client, id, state, source.body)) return null;
   return sendVersion(r, report, source, id, state);
 }
-const noSource = async () => null;
-
-/** @param {Required<VersionRequest>} r @param {VersionRecord["last"]} last @param {ExportRequest["snapshot"]} snapshot */
-function sameSourceMode(r, last, snapshot) {
-  if (r.requireSource) return sameSnapshot(last?.snapshot, snapshot);
-  if (r.omitSource) return last?.files !== true;
-  return true;
-}
-
 /** @param {ReviewClient} client @param {string} id @param {VersionRecord} state @param {ExportRequest} body */
 async function alreadyUploaded(client, id, state, body) {
   const last = state.last;
-  if (state.pending || state.failure?.projectId === id || !last || last.projectId !== id)
-    return false;
+  if (state.pending || !last || last.projectId !== id) return false;
   if (
     last.fingerprint !== body.source_fingerprint ||
     last.checksum !== body.local_upload.checksum_sha256
@@ -676,10 +604,8 @@ async function alreadyUploaded(client, id, state, body) {
  * @param {{file: string, body: ExportRequest}} source @param {string} id @param {VersionRecord} state */
 async function sendVersion(r, report, source, id, state) {
   const first = state.last?.projectId !== id;
-  let pending = bindRenderKey(bodyToSend(state, source.body, id), r.projectPath);
-  const sourceConflict = pendingSourceConflict(r, pending, source.body);
-  if (sourceConflict) return local(sourceConflict);
-  await writeState(r.projectPath, (state = { ...state, pending, failure: null }));
+  let pending = bodyToSend(state, source.body, id);
+  await writeState(r.projectPath, (state = { ...state, pending }));
   try {
     const answer = await createdExport(r, id, pending, (next) =>
       writeState(r.projectPath, (state = { ...state, pending: next })),
@@ -705,35 +631,16 @@ 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) {
-    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;
+    if (spent(error, state.pending)) await writeState(r.projectPath, { ...state, pending: null });
+    console.error("[review] version failed:", error);
+    return said(error);
   }
 }
 
-/** @param {Required<VersionRequest>} r @param {NonNullable<VersionRecord["pending"]>} pending @param {ExportRequest} fresh */
-function pendingSourceConflict(r, pending, fresh) {
-  if (r.requireSource && !pending.body.snapshot)
-    return "A pending video-only upload must finish before attaching source. Retry with --video-only, then share source again.";
-  if (r.omitSource && pending.body.snapshot)
-    return "A pending upload includes source. Check its status or retry with source before creating a video-only version.";
-  if (r.requireSource && !sameSnapshot(pending.body.snapshot, fresh.snapshot))
-    return "A pending upload includes a different source snapshot. Check its status before sharing again.";
-  return null;
-}
-
 /** @param {Required<VersionRequest>} r @param {VersionRecord} state
  * @param {NonNullable<VersionRecord["pending"]>} pending @param {string} id @param {ExportDTO} done @param {boolean} first */
 async function finishRun(r, state, pending, id, done, first) {
-  if (going(done)) return r.allowPending ? null : stillGoing(done);
+  if (going(done)) return stillGoing(done);
   const failed = await finish(r.projectPath, state, pending, id, done, r.fromReview);
   if (!failed) {
     const fromReview = pending.reviewSent?.value;
@@ -756,11 +663,8 @@ export async function addVersion(request) {
     now: () => Date.now(),
     onProgress: () => {},
     open: () => true,
-    allowPending: false,
-    filesForExport: noSource,
+    filesForExport: async () => null,
     fromReview: null,
-    requireSource: false,
-    omitSource: false,
     onAdded: () => {},
     ...request,
     projectId: request.projectId ?? null,
@@ -781,6 +685,7 @@ 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, {
@@ -850,7 +755,7 @@ async function settleSavedExport(dir, client, fromReview) {
   const id = await reviewProjectId(dir);
   if (!pending?.videoId || !id || pending.projectId !== id) return;
   const done = await client.readExport(id, pending.videoId);
-  if (done.status === "upload_pending" || going(done)) return;
+  if (going(done)) return;
   const failure = await finish(dir, state, pending, id, done, fromReview);
   const key = normalize(dir);
   if (failure) failures.set(key, { ...failure, exportKey: exportKeyOf(dir) });
@@ -920,23 +825,3 @@ export async function pendingReviewExport(projectPath) {
     checksum: pending.body.local_upload.checksum_sha256,
   };
 }
-
-/** @param {NonNullable<VersionRecord["pending"]>} pending @param {string} id @param {ExportDTO} done */
-function readyRecord(pending, id, done) {
-  return {
-    fingerprint: pending.body.source_fingerprint ?? "",
-    versionId: done.version_id,
-    exportedAt: done.exported_at,
-    projectId: id,
-    files: Boolean(pending.body.snapshot),
-    ...(pending.body.snapshot && { snapshot: pending.body.snapshot }),
-    checksum: pending.body.local_upload.checksum_sha256,
-  };
-}
-
-/** @param {NonNullable<VersionRecord["pending"]>} pending @param {string} dir */
-function bindRenderKey(pending, dir) {
-  return typeof pending.renderKey === "string"
-    ? pending
-    : { ...pending, renderKey: exportKeyOf(dir) };
-}

package/src/reviewUpload.mjs

@@ -18,22 +18,6 @@ export function fileSha256Base64(file) {
 
 /** @typedef {"sent" | "expired" | "refused" | "offline"} PutOutcome */
 
-/** @param {string} url */
-export function trustedUploadUrl(url) {
-  if (!URL.canParse(url)) return null;
-  const target = new URL(url);
-  const loopback = target.protocol === "http:" && target.hostname === "127.0.0.1";
-  if (
-    (target.protocol !== "https:" && !loopback) ||
-    target.username ||
-    target.password ||
-    target.hash ||
-    !reviewUploadOrigins().includes(target.origin)
-  )
-    return null;
-  return target;
-}
-
 /** Streams the file to the signed URL through main's fetch (the app's proxy), the server's headers as given plus
  * the length, and no bearer. Nothing sent or answered for `stallMs` ends it as offline, never "Uploading" forever.
  * @param {{ put_url: string, headers: Record<string, string> }} upload @param {string} file @param {number} size
@@ -45,8 +29,22 @@ export async function putFile(
   onSent,
   { stallMs = 60_000, fetchImpl = fetch } = {},
 ) {
-  const target = trustedUploadUrl(upload.put_url);
-  if (!target) return "refused";
+  let target;
+  try {
+    target = new URL(upload.put_url);
+  } catch {
+    return "refused";
+  }
+  const loopback = target.protocol === "http:" && target.hostname === "127.0.0.1";
+  if (
+    (target.protocol !== "https:" && !loopback) ||
+    target.username ||
+    target.password ||
+    target.hash ||
+    !reviewUploadOrigins().includes(target.origin)
+  ) {
+    return "refused";
+  }
   const stall = new AbortController();
   /** @type {ReturnType<typeof setTimeout> | undefined} */
   let timer;

package/src/reviewVersionSentences.mjs

@@ -14,8 +14,7 @@ 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:
-    "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",
+  export_blocked: "Adding videos to review pages isn't available for this account.",
   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/dist/shareSources.d.mts

@@ -1,24 +0,0 @@
-/** Content identity for sharing, including portable hidden render inputs. The Desktop watch inventory stays separate.
- * @param {string} projectPath @returns {Promise<string | null>} */
-export function shareSourceFingerprint(projectPath: string): Promise<string | null>;
-/** Prepare source explicitly before adding the video version. No unexpected network or filesystem failure is
- * converted to video-only. `filesForExport` revalidates the prepared bytes and never starts another upload.
- * @param {import("./sources/adapterTypes.js").SourceOptions} options */
-export function shareSources(options: import("./sources/adapterTypes.js").SourceOptions): {
-    prepare: (projectPath: string, rendered: string | null) => Promise<SourceResult>;
-    filesForExport: (projectPath: string, rendered: string | null) => Promise<import("./types/reviewWire.js").SnapshotRef | null>;
-};
-export { createProjectShareSourceStore } from "./sources/store.mjs";
-export type Preparation = {
-    binding: Binding;
-    own: boolean;
-    external: boolean;
-    api: import("./sources/api.mjs").SourceApi;
-    store: import("./sources/adapterTypes.js").SourceStore;
-    options: import("./sources/adapterTypes.js").SourceOptions;
-    signal: AbortSignal;
-    fingerprint: (path: string) => Promise<string | null>;
-    rendered: string;
-};
-export type SourceResult = import("./sources/adapterTypes.js").SourceResult;
-export type Binding = import("./sources/types.js").Binding;

package/dist/sourceIgnore.d.mts

@@ -1,3 +0,0 @@
-/** 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/dist/sources/adapterTypes.d.ts

@@ -1,39 +0,0 @@
-import type { Binding, BindingKey, Manifest } from "./types.js";
-import type { SnapshotRef } from "../types/reviewWire.js";
-import type { SignedInAccess } from "../signedInRequest.mjs";
-import type { SourceApi } from "./api.mjs";
-
-export interface SourceStore {
-  read(key: BindingKey): Promise<Binding | null>;
-  write(binding: Binding): Promise<void>;
-}
-export type SourceResult =
-  | { at: "ready"; snapshot: SnapshotRef }
-  | { at: "unavailable"; reason: string };
-export interface SourceOptions {
-  access: SignedInAccess;
-  spaceId: string;
-  store?: SourceStore;
-  enabled?: () => boolean;
-  fingerprint?: (path: string) => Promise<string | null>;
-  /** Host-owned Desktop bindings may be read for exact reuse, never overwritten. */
-  existingBinding?: (key: BindingKey) => Promise<Binding | null>;
-  fetchImpl?: typeof fetch;
-  signal?: AbortSignal;
-  verificationTimeoutMs?: number;
-  onProgress?: (bytes: number) => void;
-  /** Test/host seams; the default is the authenticated v3 client. */
-  api?: SourceApi;
-  wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
-}
-export interface SourceRun {
-  binding: Binding;
-  manifest: Manifest;
-  api: SourceApi;
-  store: SourceStore;
-  fetchImpl: typeof fetch;
-  signal: AbortSignal;
-  wait: (ms: number, signal?: AbortSignal) => Promise<void>;
-  timeoutMs: number;
-  onProgress: (bytes: number) => void;
-}