@hyperframes/share 0.9.28-alpha.1 → 0.9.28

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 HeyGen, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -35,7 +35,7 @@ const [current, version] = await Promise.all([
 
 `access(refusedToken?)` returns `{ token, heygen, heygenApi, owner }` or null. It is read for every request. A refused bearer is passed back so the host can refresh it. `heygen` is the review API base. A host can inject its own `signedInRequest` to retain network tracing. `execFile` can likewise be injected to retain native process policy.
 
-Video and source uploads require exact storage origins from trusted host configuration. Set `reviewUploadOrigins` on the host or supply a comma-separated `HYPERFRAMES_REVIEW_UPLOAD_ORIGINS` environment variable. Configure the bucket-specific HTTPS origins used by the signer. Use URL origins without paths, trailing slashes, or wildcards. Local tests can explicitly allow an HTTP origin on `127.0.0.1`. An empty list refuses every upload.
+Video uploads require exact storage origins from trusted host configuration. Set `reviewUploadOrigins` on the host or supply a comma-separated `HYPERFRAMES_REVIEW_UPLOAD_ORIGINS` environment variable. Configure the bucket-specific HTTPS origins used by the signer. Use URL origins without paths, trailing slashes, or wildcards. Local tests can explicitly allow an HTTP origin on `127.0.0.1`. An empty list refuses every video upload.
 
 Before first registration the host must obtain explicit audience consent and prepare a current MP4. `shareForReview` registers/enables the link; it does not imply playable media. Await `addVersion`, then check the server project/latest ready version before reporting success. `addFirstVersion` starts background work and is for long-lived hosts only. `open: () => boolean` on `addVersion` bounds the polling lifetime without discarding the saved operation. `filesForExport(projectPath, renderedFingerprint)` optionally supplies an already-synced matching snapshot. Omit it for ordinary video sharing.
 
@@ -50,60 +50,3 @@ Metadata mutations and version uploads use separate cross-process locks under `.
 `snapshotProject` skips symlinks by default, retaining Desktop watcher, change-set and saved-render compatibility; `snapshotFiles` also skips symlink entries. Set `followSymlinks: true` for a link-aware full snapshot. The CLI-facing `projectFingerprint` opts into following linked media (with cycle detection), so edited linked files invalidate its cached render. Both comparisons ignore HTML ID stamps. Export/history metadata, caches, hidden folders and installed packages are excluded. Hosts must record the fingerprint of the actual rendered source and must not relabel an old render with a newer fingerprint.
 
 Public type exports include `ShareHost`, `ReviewClient`, `ReviewShare`, `VersionRequest`, and `Wire`, plus `@hyperframes/share/types/reviewWire` and `types/share`. Per-module entry points preserve Desktop imports during adoption.
-
-## Source snapshots
-
-`shareSources({access, spaceId})` prepares editable source for a rendered version:
-
-```js
-const sources = shareSources({ access, spaceId });
-const result = await sources.prepare(projectPath, renderedFingerprint);
-if (result.at === "ready") {
-  await addVersion({
-    projectPath,
-    title,
-    client,
-    filesForExport: sources.filesForExport,
-    requireSource: true,
-  });
-}
-```
-
-Handle `unavailable.reason` before creating the video version. Plan ineligibility
-can use video-only; changed source, conflicts and unexpected upload failures need
-an explicit choice to omit source. The CLI exposes `--video-only` for that choice.
-`filesForExport` only validates already-prepared source; it does not upload.
-
-The adapter uses the portable-source-v4 capture/manifest rules and
-multipart transport. The pinned policy, Unicode 15.1 registry (with its license),
-and manifest test vectors are checked into this repository. Source is captured through
-verified file handles; upload bytes are streamed and checked against their hash.
-Workspace limits, upload receipts and published snapshot identity are checked.
-Pending uploads retain their original idempotency key across retries. A conflict
-is never auto-resolved. When local source changes, the adapter cancels an older
-pending upload before starting another; uploads under verification are preserved.
-A stalled storage PUT stops after 60 seconds without progress and can retry with
-the same upload identity.
-
-Default state uses `.hyperframes/share-sync.<backend-hash>.json`, with strict
-account/backend/realpath binding, private atomic writes, and a process lock.
-Hosts can inject a compatible `store` or read-only `existingBinding` resolver.
-An external Desktop binding is reused only when exact and settled; this adapter
-never writes Desktop's binding or starts a second upload on its behalf.
-
-Source sharing requires an authorized account and a workspace that supports editable project files.
-Source-plan/feature eligibility remains server controlled. Automated fixtures do
-not establish live entitlement, moderation, source download or outside-editor
-acceptance. See [the source guide](https://hyperframes.heygen.com/developers/share-source).
-
-Tests run locally without an account or service credentials:
-
-```bash
-node --test packages/share/tests/*.test.mjs
-bun run --cwd packages/share build
-```
-
-The bundled Unicode data records SHA-256 hashes for its inputs in `sources`.
-Those files are published in the [Unicode 15.1 database](https://www.unicode.org/Public/15.1.0/ucd/).
-Keep the included Unicode license with redistributed data. The pinned version
-keeps path comparison consistent across Node versions and operating systems.

package/dist/index.d.mts

@@ -19,4 +19,3 @@ export { linkStateOf, reviewLinkStates } from "./reviewLinkStates.mjs";
 export { AccountUnreachable, UNREACHABLE, readOrUnreachable, orIfUnreachable, signedInRequest } from "./signedInRequest.mjs";
 export { HF_ID_ATTRIBUTE, contentKey, snapshotProject, snapshotFingerprint, snapshotFiles, diffChangedFiles, projectFingerprint } from "./projectSnapshot.mjs";
 export { ShareBusyError, withProjectShareLock } from "./projectLock.mjs";
-export { shareSources, shareSourceFingerprint, createProjectShareSourceStore } from "./shareSources.mjs";

package/dist/projectLock.d.mts

@@ -1,6 +1,6 @@
-/** @template T @param {string} projectPath @param {"review" | "export" | "source"} lane @param {() => Promise<T>} run
+/** @template T @param {string} projectPath @param {"review" | "export"} lane @param {() => Promise<T>} run
  * @param {{ timeoutMs?: number, signal?: AbortSignal }} [options] @returns {Promise<T>} */
-export function withProjectShareLock<T>(projectPath: string, lane: "review" | "export" | "source", run: () => Promise<T>, { timeoutMs, signal }?: {
+export function withProjectShareLock<T>(projectPath: string, lane: "review" | "export", run: () => Promise<T>, { timeoutMs, signal }?: {
     timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<T>;

package/dist/projectSnapshot.d.mts

@@ -16,7 +16,5 @@ export function snapshotFiles(dir: string, files: Iterable<string>): Promise<Map
 /** @param {Snapshot} before @param {Snapshot} after */
 export function diffChangedFiles(before: Snapshot, after: Snapshot): string[];
 export const HF_ID_ATTRIBUTE: RegExp;
-export function projectFingerprint(projectPath: string, options?: {
-    byContent?: boolean;
-}): Promise<string>;
+export function projectFingerprint(projectPath: string): Promise<string>;
 export type Snapshot = Map<string, unknown>;

package/dist/reviewClient.d.mts

@@ -18,6 +18,22 @@ export function reviewClient({ access, fetchImpl, signedInEmail }: {
         body: string;
         attachment_ids: string[];
     }) => Promise<any>;
+    /** @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: string, grantId: string, body: {
+        role: import("./types/reviewWire.js").AccessGrantDTO["role"];
+        expected_revision: number;
+    }) => Promise<import("./types/reviewWire.js").AccessGrantDTO>;
+    /** @param {string} id @param {string} grantId @returns {Promise<null>} */
+    revokeGrant: (id: string, grantId: string) => Promise<null>;
+    /** The project's live grants. @param {string} id
+     * @returns {Promise<{items: import("./types/reviewWire.js").AccessGrantDTO[]}>} */
+    grants: (id: string) => Promise<{
+        items: import("./types/reviewWire.js").AccessGrantDTO[];
+    }>;
+    /** @param {string} id @param {import("./types/reviewWire.js").CreateGrantRequest} body
+     * @returns {Promise<import("./types/reviewWire.js").AccessGrantDTO>} */
+    createGrant: (id: string, body: import("./types/reviewWire.js").CreateGrantRequest) => Promise<import("./types/reviewWire.js").AccessGrantDTO>;
     /** @param {string} id @param {{ title: string, expected_title: string }} body
      * @returns {Promise<{title: string}>} */
     updateTitle: (id: string, body: {
@@ -31,19 +47,6 @@ export function reviewClient({ access, fetchImpl, signedInEmail }: {
     listProjects: (spaceId: string, cursor?: string | null) => Promise<import("./types/reviewWire.js").ManagedReviewPage>;
     /** @param {string} id @returns {Promise<null>} */
     removeProject: (id: string) => Promise<null>;
-    /** @param {string} id @returns {Promise<{items: import("./types/reviewWire.js").AccessGrantDTO[]}>} */
-    grants: (id: string) => Promise<{
-        items: import("./types/reviewWire.js").AccessGrantDTO[];
-    }>;
-    createGrant: (id: string, body: import("./types/reviewWire.js").CreateGrantRequest) => Promise<import("./types/reviewWire.js").AccessGrantDTO>;
-    /** @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: string, grantId: string, body: {
-        role: import("./types/reviewWire.js").AccessGrantDTO["role"];
-        expected_revision: number;
-    }) => Promise<import("./types/reviewWire.js").AccessGrantDTO>;
-    /** @param {string} id @param {string} grantId @returns {Promise<null>} */
-    revokeGrant: (id: string, grantId: string) => Promise<null>;
     openSummary: (token: string, versionId: string | null) => Promise<import("./types/shareOpen.js").OpenSummaryDTO>;
     versionFiles: (token: string, versionId: string) => Promise<import("./types/shareOpen.js").VersionFilesDTO>;
     fileUrls: (token: string, versionId: string, continuation: string, sha256s: string[]) => Promise<import("./types/shareOpen.js").FileUrlsDTO>;

package/dist/reviewExport.d.mts

@@ -56,7 +56,6 @@ export function versionFacts(dir: string): Promise<{
         exportedAt: string;
         projectId: string;
         files?: boolean;
-        snapshot?: ExportRequest["snapshot"];
         checksum?: string;
     } | null;
     source: "ready" | "none" | "not-mp4" | "stale";
@@ -70,7 +69,6 @@ export function versionOnPage(dir: string): Promise<{
     exportedAt: string;
     projectId: string;
     files?: boolean;
-    snapshot?: ExportRequest["snapshot"];
     checksum?: string;
 } | null>;
 /** Records that `versionId` carries files now, if it is still the last ready version.
@@ -118,7 +116,6 @@ export type VersionRecord = {
         body: ExportRequest;
         videoId: string | null;
         projectId?: string | null;
-        renderKey?: string;
         checkingSince?: number;
         snapshotRefused?: boolean;
         unanswered?: boolean;
@@ -130,12 +127,8 @@ export type VersionRecord = {
         exportedAt: string;
         projectId: string;
         files?: boolean;
-        snapshot?: ExportRequest["snapshot"];
         checksum?: string;
     } | null;
-    failure?: (Failure & {
-        projectId: string;
-    }) | null;
 };
 /**
  * `onAdded`: a version went ready, with whether it carries files and whether it is the page's first from here.
@@ -149,7 +142,7 @@ export type VersionHooks = {
 /**
  * `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.
  */
 export type VersionRequest = VersionHooks & {
     projectPath: string;
@@ -162,9 +155,6 @@ export type VersionRequest = VersionHooks & {
     projectId?: string | null;
     filesForExport?: FilesForRender;
     fromReview?: FromReview | null;
-    allowPending?: boolean;
-    requireSource?: boolean;
-    omitSource?: boolean;
 };
 /**
  * The snapshot of `rendered`, the project as the export was rendered; null when the folder is not that render.

package/dist/reviewUpload.d.mts

@@ -2,8 +2,6 @@
  * @param {string} file @returns {Promise<string>} */
 export function fileSha256Base64(file: string): Promise<string>;
 /** @typedef {"sent" | "expired" | "refused" | "offline"} PutOutcome */
-/** @param {string} url */
-export function trustedUploadUrl(url: string): URL | null;
 /** 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

package/package.json

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

package/scripts/copy-types.mjs

@@ -1,6 +1,3 @@
 import { cp } from "node:fs/promises";
 await cp("src/types", "dist/types", { recursive: true });
 await cp("src/hosts.d.ts", "dist/hosts.d.ts");
-
-await cp("src/sources/types.d.ts", "dist/sources/types.d.ts");
-await cp("src/sources/adapterTypes.d.ts", "dist/sources/adapterTypes.d.ts");

package/src/index.mjs

@@ -80,9 +80,3 @@ export { bindShareHost } from "./host.mjs";
 /** @typedef {import("./types/share.js").AccessMode} AccessMode */
 /** @typedef {import("./types/share.js").ReviewExportProgress} ReviewExportProgress */
 export { pendingReviewExport } from "./reviewExport.mjs";
-
-export {
-  shareSources,
-  shareSourceFingerprint,
-  createProjectShareSourceStore,
-} from "./shareSources.mjs";

package/src/projectLock.mjs

@@ -80,7 +80,7 @@ async function claim(candidate, lock, owner) {
     }
   }
 }
-/** @template T @param {string} projectPath @param {"review" | "export" | "source"} lane @param {() => Promise<T>} run
+/** @template T @param {string} projectPath @param {"review" | "export"} lane @param {() => Promise<T>} run
  * @param {{ timeoutMs?: number, signal?: AbortSignal }} [options] @returns {Promise<T>} */
 export async function withProjectShareLock(
   projectPath,
@@ -90,14 +90,7 @@ export async function withProjectShareLock(
 ) {
   const root = await realpath(projectPath);
   const folder = await mkdirInside(root, ".hyperframes");
-  const lock = join(
-    folder,
-    lane === "review"
-      ? "review.lock"
-      : lane === "source"
-        ? "share-source.lock"
-        : "review-export.lock",
-  );
+  const lock = join(folder, lane === "review" ? "review.lock" : "review-export.lock");
   const owner = { token: randomUUID(), pid: process.pid, hostname: hostname() };
   const candidate = `${lock}.${owner.token}.tmp`;
   await writeFile(candidate, JSON.stringify(owner), { flag: "wx", mode: 0o600 });

package/src/projectSnapshot.mjs

@@ -1,7 +1,6 @@
 // @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";
@@ -32,7 +31,7 @@ async function snapshotKey(full, byContent) {
     const stat = await handle.stat();
     if (!stat.isFile()) return undefined;
     if (full.endsWith(".html")) return contentKey(await handle.readFile("utf8"));
-    if (byContent) return await hashFile(handle);
+    if (byContent) return sha256(await handle.readFile());
     return `${stat.mtimeMs}:${stat.size}`;
   } catch {
     return undefined;
@@ -41,13 +40,6 @@ async function snapshotKey(full, byContent) {
   }
 }
 
-/** @param {import("node:fs/promises").FileHandle} handle */
-async function hashFile(handle) {
-  const hash = createHash("sha256");
-  for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
-  return hash.digest("hex");
-}
-
 /** @param {import("node:fs").Dirent} entry @param {string} full @param {boolean} followSymlinks */
 async function entryKind(entry, full, followSymlinks) {
   if (!entry.isSymbolicLink()) return entry;
@@ -61,7 +53,6 @@ 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);
@@ -76,7 +67,7 @@ export async function snapshotProject(dir, { byContent = false, followSymlinks =
     }
     for (const entry of entries) {
       const full = path.join(current, entry.name);
-      if (excludedFromSnapshot(dir, full, ignored)) continue;
+      if (isOutsideFilm(path.relative(dir, full))) continue;
       const kind = await entryKind(entry, full, followSymlinks);
       if (kind?.isDirectory()) await walk(full, parents);
       else if (kind?.isFile()) {
@@ -102,12 +93,11 @@ 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() && !excludedFromSnapshot(dir, full, ignored);
+    const holds = stat?.isFile() && !isOutsideFilm(path.relative(dir, full));
     result.set(file, holds ? await snapshotKey(full, false) : undefined);
   }
   return result;
@@ -125,12 +115,6 @@ export function diffChangedFiles(before, after) {
   return changed;
 }
 
-/** @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("/"));
-}
+/** @param {string} projectPath */
+export const projectFingerprint = async (projectPath) =>
+  snapshotFingerprint(await snapshotProject(projectPath, { followSymlinks: true }));