@hyperframes/share 0.9.28-alpha.0 → 0.9.28

package/src/shareSources.mjs

@@ -1,236 +0,0 @@
-// @ts-check
-import { realpath } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { basename } from "node:path";
-import { projectFingerprint } from "./projectSnapshot.mjs";
-import { withProjectShareLock } from "./projectLock.mjs";
-import { captureProject } from "./sources/capture.mjs";
-import { sourceApi } from "./sources/api.mjs";
-import { createProjectShareSourceStore } from "./sources/store.mjs";
-import { realWait } from "./sources/transfer.mjs";
-import { recoverSourceUpload, uploadSource } from "./sources/upload.mjs";
-
-/** @typedef {import("./sources/adapterTypes.js").SourceResult} SourceResult
- * @typedef {import("./sources/types.js").Binding} Binding */
-/** @param {string} reason @returns {SourceResult} */
-const unavailable = (reason) => ({ at: "unavailable", reason });
-/** Content identity for sharing, including portable hidden render inputs. The Desktop watch inventory stays separate.
- * @param {string} projectPath @returns {Promise<string | null>} */
-export async function shareSourceFingerprint(projectPath) {
-  const capture = await captureProject(await realpath(projectPath));
-  return capture.at === "captured" && !captureRefusal(capture) ? capture.manifest.sha256 : null;
-}
-/** @param {Binding} binding @param {string} space */
-function bindingRefusal(binding, space) {
-  if (binding.ownerSpaceId !== space) return "source_other_workspace";
-  if (binding.sharedFrom) return "source_owned_by_someone_else";
-  if (binding.gettingFromCloud || binding.duplicate) return "source_operation_in_progress";
-  return null;
-}
-/** @param {import("./sources/types.js").Capture} capture */
-function captureRefusal(capture) {
-  if (capture.at === "too-big") return `source_${capture.over.limit}_exceeded`;
-  if (capture.at === "problems") return `source_${capture.problems[0]?.problem ?? "invalid"}`;
-  if (capture.settled.agentTurnOpen || capture.settled.projectLocked || capture.waiting.length)
-    return "source_edit_in_progress";
-  return 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) {
-  const store = options.store ?? createProjectShareSourceStore();
-  const fingerprint = options.fingerprint ?? projectFingerprint;
-  const signal = options.signal ?? new AbortController().signal;
-  /** @type {Map<string, { rendered: string, digest: string, snapshot: import("./types/reviewWire.js").SnapshotRef, account: string, backend: string }>} */
-  const prepared = new Map();
-  /** @param {string} projectPath @param {string | null} rendered @returns {Promise<SourceResult>} */
-  const prepare = async (projectPath, rendered) => {
-    const root = await realpath(projectPath);
-    prepared.delete(root);
-    if (!enabled(options)) return unavailable("source_disabled");
-    if (!rendered || (await fingerprint(root)) !== rendered)
-      return unavailable("source_render_changed");
-    return withProjectShareLock(
-      root,
-      "source",
-      async () => {
-        const signed = await options.access();
-        if (!signed?.owner) return unavailable("source_signed_out");
-        const key = { backend: signed.heygenApi, account: signed.owner, projectPath: root };
-        const guardedAccess = async (/** @type {string | undefined} */ refused) => {
-          const next = await options.access(refused);
-          if (!next || next.owner !== key.account || next.heygenApi !== key.backend)
-            throw new Error("Source account or backend changed while sharing.");
-          return next;
-        };
-        const api =
-          options.api ?? sourceApi({ access: guardedAccess, fetchImpl: options.fetchImpl });
-        const { own, existing, binding } = await selectBinding(key, options, store);
-        const refused = bindingRefusal(binding, options.spaceId);
-        if (refused) return unavailable(refused);
-        const result = await prepareBinding({
-          binding,
-          own: Boolean(own),
-          external: Boolean(existing),
-          api,
-          store,
-          options,
-          signal,
-          fingerprint,
-          rendered,
-        });
-        const manifest = result.manifest;
-        await guardedAccess(undefined);
-        if (result.at !== "ready" || !manifest) return result;
-        if (!(await stillMatches(root, rendered, manifest.sha256, fingerprint)))
-          return unavailable("source_render_changed");
-        prepared.set(root, {
-          rendered,
-          digest: manifest.sha256,
-          snapshot: result.snapshot,
-          account: key.account,
-          backend: key.backend,
-        });
-        return { at: "ready", snapshot: result.snapshot };
-      },
-      { signal },
-    );
-  };
-  /** @param {string} projectPath @param {string | null} rendered */
-  const filesForExport = async (projectPath, rendered) => {
-    const root = await realpath(projectPath);
-    const held = prepared.get(root);
-    const signed = await options.access();
-    if (
-      !held ||
-      !rendered ||
-      held.rendered !== rendered ||
-      !sameOwner(signed, held) ||
-      !enabled(options)
-    )
-      return null;
-    return (await stillMatches(root, rendered, held.digest, fingerprint)) ? held.snapshot : null;
-  };
-  return { prepare, filesForExport };
-}
-
-/** @param {import("./sources/adapterTypes.js").SourceOptions} options */
-const enabled = (options) => options.enabled?.() ?? true;
-/** @param {Awaited<ReturnType<import("./signedInRequest.mjs").SignedInAccess>>} signed
- * @param {{account: string, backend: string}} held */
-const sameOwner = (signed, held) =>
-  signed?.owner === held.account && signed?.heygenApi === held.backend;
-/** @typedef {{ 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 }} Preparation */
-/** @param {Preparation} job @returns {Promise<SourceResult & {manifest?: import("./sources/types.js").Manifest}>} */
-async function prepareBinding(job) {
-  const { binding, api, fingerprint, rendered } = job;
-  const limits = await api.limits(binding.ownerSpaceId);
-  if (!limits.syncAllowed) return unavailable("source_plan_required");
-  const capture = await captureProject(binding.projectPath, { limits: limits.push });
-  const bad = captureRefusal(capture);
-  if (bad) return unavailable(bad);
-  if (capture.at !== "captured") return unavailable("source_invalid");
-  if ((await fingerprint(binding.projectPath)) !== rendered)
-    return unavailable("source_render_changed");
-  const result = await snapshotFor(job, capture.manifest, limits);
-  return { ...result, manifest: capture.manifest };
-}
-/** @param {Preparation} job @param {import("./sources/types.js").Manifest} manifest
- * @param {Extract<import("./sources/types.js").SyncLimitsRead, {at: "read"}>} limits @returns {Promise<SourceResult>} */
-async function snapshotFor(job, manifest, limits) {
-  const { binding, api, store, options, signal } = job;
-  const blocked = await recoverEarlierCapture(job, manifest.sha256);
-  if (blocked) return blocked;
-  if (binding.base?.manifestSha256 === manifest.sha256 && !binding.inflight)
-    return reuseSnapshot(api, binding, manifest.sha256);
-  if (job.external) return unavailable("source_sync_required");
-  if (!job.own && limits.compositions >= limits.maxCompositions)
-    return unavailable("source_composition_limit");
-  await store.write(binding);
-  binding.composition = await api.create(
-    binding.ownerSpaceId,
-    binding.compositionId,
-    basename(binding.projectPath),
-  );
-  await store.write(binding);
-  return uploadSource({ binding, manifest, api, store, signal, ...uploadOptions(options) });
-}
-/** @param {Preparation} job @param {string} digest */
-function recoverEarlierCapture({ external, binding, api, store }, digest) {
-  const inflight = binding.inflight;
-  if (external || !inflight || inflight.manifestSha256 === digest) return null;
-  return recoverSourceUpload({ binding, api, store });
-}
-
-/** @param {import("./sources/adapterTypes.js").SourceOptions} options */
-function uploadOptions(options) {
-  return {
-    fetchImpl: options.fetchImpl ?? fetch,
-    wait: options.wait ?? realWait,
-    timeoutMs: options.verificationTimeoutMs ?? 120_000,
-    onProgress: options.onProgress ?? (() => {}),
-  };
-}
-
-/** @param {import("./sources/types.js").BindingKey} key @param {import("./sources/adapterTypes.js").SourceOptions} options
- * @param {import("./sources/adapterTypes.js").SourceStore} store */
-async function selectBinding(key, options, store) {
-  const own = await store.read(key);
-  const existing = own ? null : await options.existingBinding?.(key);
-  return { own, existing, binding: own ?? existing ?? newBinding(key, options.spaceId) };
-}
-/** @param {import("./sources/types.js").BindingKey} key @param {string} space @returns {Binding} */
-function newBinding(key, space) {
-  return {
-    ...key,
-    version: 1,
-    compositionId: randomUUID(),
-    ownerSpaceId: space,
-    boundAt: Date.now(),
-    composition: null,
-    etag: null,
-    base: null,
-    inflight: null,
-  };
-}
-/** @param {import("./sources/api.mjs").SourceApi} api @param {Binding} binding @param {string} digest @returns {Promise<SourceResult>} */
-async function reuseSnapshot(api, binding, digest) {
-  if (!binding.base) return unavailable("source_sync_required");
-  const remote = await api.snapshot(
-    binding.ownerSpaceId,
-    binding.compositionId,
-    binding.base.snapshotId,
-  );
-  if (
-    remote.id !== binding.base.snapshotId ||
-    remote.compositionId !== binding.compositionId ||
-    remote.manifestSha256 !== digest ||
-    remote.manifest?.sha256 !== digest ||
-    remote.publicationOutcome !== "published"
-  )
-    return unavailable("source_snapshot_mismatch");
-  return {
-    at: "ready",
-    snapshot: {
-      space_id: binding.ownerSpaceId,
-      composition_id: binding.compositionId,
-      snapshot_id: remote.id,
-    },
-  };
-}
-/** @param {string} root @param {string} rendered @param {string} digest @param {(path: string) => Promise<string | null>} fingerprint */
-async function stillMatches(root, rendered, digest, fingerprint) {
-  if ((await fingerprint(root)) !== rendered) return false;
-  const capture = await captureProject(root);
-  return (
-    !captureRefusal(capture) &&
-    capture.at === "captured" &&
-    capture.manifest.sha256 === digest &&
-    (await fingerprint(root)) === rendered
-  );
-}
-export { createProjectShareSourceStore } from "./sources/store.mjs";

package/src/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;
-}

package/src/sources/api.mjs

@@ -1,114 +0,0 @@
-// @ts-check
-import { signedInRequest } from "../signedInRequest.mjs";
-import { SyncApiError, refusalOf } from "./errors.mjs";
-import {
-  beginOf,
-  grantsOf,
-  objectOf,
-  uploadOf,
-  syncLimitsOf,
-  compositionOf,
-  snapshotOf,
-} from "./wire.mjs";
-
-/** @param {{ access: import("../signedInRequest.mjs").SignedInAccess, fetchImpl?: typeof fetch }} deps */
-export function sourceApi({ access, fetchImpl = fetch }) {
-  const request = signedInRequest({
-    access,
-    fetchImpl,
-    timeoutMs: 120_000,
-    tag: "share-source",
-    host: "heygenApi",
-    offline: () => new SyncApiError("offline"),
-    signedOut: () => new SyncApiError("signed-out"),
-  });
-  /** @param {string} method @param {string} route @param {unknown} [body] @param {Record<string,string>} [headers] */
-  const send = async (method, route, body, headers) => {
-    const { reply } = await request(method, route, body, headers);
-    if (!reply.ok) throw await refusalOf(reply);
-    return objectOf(await reply.json(), "envelope").data;
-  };
-  /** @param {string} space @param {string} composition */
-  const path = (space, composition) =>
-    `/v3/hyperframes/workspaces/${encodeURIComponent(space)}/compositions/${encodeURIComponent(composition)}`;
-  return {
-    /** @param {string} space */
-    limits: async (space) =>
-      syncLimitsOf(
-        await send(
-          "GET",
-          `/v3/hyperframes/workspaces/${encodeURIComponent(space)}/composition-sync/limits`,
-        ),
-      ),
-    /** @param {string} space @param {string} composition @param {string} title */
-    create: async (space, composition, title) =>
-      compositionOf(await send("PUT", path(space, composition), { title })),
-    /** @param {string} space @param {string} composition @param {string} snapshot */
-    snapshot: async (space, composition, snapshot) =>
-      snapshotOf(
-        await send(
-          "GET",
-          `${path(space, composition)}/snapshots/${encodeURIComponent(snapshot)}?include=manifest`,
-        ),
-      ),
-    /** @param {string} space @param {string} composition @param {import("./types.js").BeginRequest} body */
-    begin: async (space, composition, body) =>
-      beginOf(
-        await send(
-          "POST",
-          `${path(space, composition)}/uploads`,
-          {
-            base_snapshot_id: body.baseSnapshotId,
-            resolves_conflict_snapshot_ids: [],
-            client_type: "cli",
-            manifest_sha256: body.manifest.sha256,
-            manifest: body.manifest.document,
-          },
-          { "Idempotency-Key": body.idempotencyKey },
-        ),
-        false,
-      ),
-    /** @param {string} space @param {string} composition @param {string} upload @param {import("./types.js").GrantRequest[]} files */
-    uploadUrls: async (space, composition, upload, files) =>
-      grantsOf(
-        await send(
-          "POST",
-          `${path(space, composition)}/uploads/${encodeURIComponent(upload)}/upload-urls`,
-          {
-            files: files.map((file) => ({
-              sha256: file.sha256,
-              ...(file.multipartUploadId && { multipart_upload_id: file.multipartUploadId }),
-              ...(file.parts && {
-                parts: file.parts.map((part) => ({
-                  part_number: part.partNumber,
-                  sha256: part.sha256,
-                })),
-              }),
-            })),
-          },
-        ),
-      ),
-    /** @param {string} space @param {string} composition @param {string} upload */
-    status: async (space, composition, upload) =>
-      uploadOf(
-        await send("GET", `${path(space, composition)}/uploads/${encodeURIComponent(upload)}`),
-      ),
-    /** @param {string} space @param {string} composition @param {string} upload */
-    cancel: async (space, composition, upload) =>
-      uploadOf(
-        await send(
-          "POST",
-          `${path(space, composition)}/uploads/${encodeURIComponent(upload)}/cancel`,
-        ),
-      ),
-    /** @param {string} space @param {string} composition @param {string} upload */
-    submit: async (space, composition, upload) =>
-      uploadOf(
-        await send(
-          "POST",
-          `${path(space, composition)}/uploads/${encodeURIComponent(upload)}/verification`,
-        ),
-      ),
-  };
-}
-/** @typedef {ReturnType<typeof sourceApi>} SourceApi */

package/src/sources/capture.mjs

@@ -1,262 +0,0 @@
-// @ts-check
-// 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 { createHash } from "node:crypto";
-import { constants } from "node:fs";
-import { lstat, open, readdir, realpath } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { ENTRYPOINT, ManifestInvalid, canonicalBytes, parseManifest } from "./manifest.mjs";
-import { V1_LIMITS, overLimit } from "./limits.mjs";
-import {
-  PathViolation,
-  checkInventoryPaths,
-  classifyPath,
-  excludedFolder,
-  prefiltered,
-  skippedSymlink,
-  validatePath,
-} from "./pathPolicy.mjs";
-import { readRenderOutputs, settledState } from "./projectState.mjs";
-
-/** @typedef {import("./types.js").CaptureProblem} CaptureProblem @typedef {import("./types.js").Found} Found
- * @typedef {import("./types.js").Walk} Walk @typedef {import("./types.js").Capture} Capture */
-
-/** Files up to this size use one bounded buffer; larger files stream from the verified handle. */
-const INLINE_HASH_BYTES = 4 * 1024 * 1024;
-const HASHING_AT_ONCE = 4;
-
-/** @param {string} root @param {string} rel @param {import("node:fs").Dirent} entry @param {Walk} walk
- * @param {string[]} dirs */
-async function visit(root, rel, entry, walk, dirs) {
-  if (entry.isDirectory()) {
-    if (!excludedFolder(rel)) dirs.push(rel);
-    return;
-  }
-  const action = classifyPath(rel).client_action;
-  if (action === "exclude") return;
-  if (action === "wait_then_exclude") return void walk.waiting.push(rel);
-  if (entry.isSymbolicLink()) {
-    if (skippedSymlink(rel)) walk.skippedLinks.push(rel);
-    else walk.problems.push({ path: rel, problem: "symlink" });
-    return;
-  }
-  if (!entry.isFile()) return void walk.problems.push({ path: rel, problem: "special-file" });
-  await visitFile(root, rel, walk);
-}
-/** @param {string} root @param {string} rel @param {Walk} walk */
-async function visitFile(root, rel, walk) {
-  try {
-    validatePath(rel);
-  } catch (error) {
-    if (!(error instanceof PathViolation)) throw error;
-    return void walk.problems.push({ path: rel, problem: "invalid-name", code: error.code });
-  }
-  const full = join(root, rel);
-  try {
-    const { size, mtimeMs, ino, dev } = await lstat(full);
-    walk.files.push({ path: rel, full, size, mtimeMs, ino, dev });
-  } catch {
-    walk.problems.push({ path: rel, problem: "unreadable" });
-  }
-}
-
-/** A folder that was a link, or another folder, by the time it was read. */
-class FolderMoved extends Error {}
-
-/** A folder's entries, read only while the same real folder stands at its path before and after: one swapped for a
- * link to somewhere else is never listed. @param {string} root @param {string} dir */
-async function listFolder(root, dir) {
-  const full = join(root, dir);
-  const before = await lstat(full);
-  if (!before.isDirectory()) throw new FolderMoved();
-  const entries = await readdir(full, { withFileTypes: true });
-  const after = await lstat(full);
-  if (!after.isDirectory() || after.ino !== before.ino || after.dev !== before.dev)
-    throw new FolderMoved();
-  return entries;
-}
-
-/** Every file a capture would list, and what keeps one from being listed. @param {string} root
- * @param {(rel: string) => boolean} renderOutput @returns {Promise<Walk>} */
-async function walkProject(root, renderOutput) {
-  /** @type {Walk} */
-  const walk = { files: [], problems: [], waiting: [], skippedLinks: [] };
-  const dirs = [""];
-  for (let dir = dirs.pop(); dir !== undefined; dir = dirs.pop()) {
-    let entries;
-    try {
-      entries = await listFolder(root, dir);
-    } catch (error) {
-      const changed = error instanceof FolderMoved;
-      walk.problems.push({ path: dir, problem: changed ? "changed" : "unreadable" });
-      continue;
-    }
-    for (const entry of entries) {
-      const rel = dir ? `${dir}/${entry.name}` : entry.name;
-      if (prefiltered(entry.name) || renderOutput(rel)) continue;
-      await visit(root, rel, entry, walk, dirs);
-    }
-  }
-  return walk;
-}
-
-/** The manifest's canonical length, from paths and sizes alone: every SHA-256 is 64 characters.
- * @param {Found[]} files */
-const manifestBytes = (files) =>
-  canonicalBytes({
-    format_version: 1,
-    entrypoint: ENTRYPOINT,
-    files: files.map(({ path, size }) => ({ path, sha256: "0".repeat(64), size })),
-  }).length;
-
-/** A file changed this recently can be written again within its time's granularity, keeping its size and time. */
-const SETTLED_MS = 2_000;
-
-/** A file's SHA-256 by path, size, time and inode, kept for the launch so a check after a focus reads no bytes.
- * Only a settled file's hash is kept. */
-export function hashMemo(now = Date.now) {
-  /** @type {Map<string, { size: number, mtimeMs: number, ino: number, sha256: string }>} */
-  const known = new Map();
-  return {
-    /** @param {Found} file */
-    get: (file) => {
-      const kept = known.get(file.full);
-      const same =
-        kept?.size === file.size && kept.mtimeMs === file.mtimeMs && kept.ino === file.ino;
-      return same ? kept.sha256 : null;
-    },
-    /** @param {Found} file @param {string} sha256 */
-    set: (file, sha256) => {
-      if (now() - file.mtimeMs > SETTLED_MS) known.set(file.full, { ...file, sha256 });
-    },
-  };
-}
-
-/** The file the walk listed, as an open handle: never through a link at its own name (O_NOFOLLOW), and only when the
- * opened file is the same regular file (inode, device, size) found inside the project, so a file or folder swapped
- * for a link after the walk is refused rather than followed. Null when it is not. @param {string} root
- * @param {Found} file @param {typeof realpath} [resolve] */
-async function openListed(root, file, resolve = realpath) {
-  const handle = await open(file.full, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)).catch(
-    (/** @type {NodeJS.ErrnoException} */ error) => {
-      if (error.code === "ELOOP" || error.code === "EMLINK") return null;
-      throw error;
-    },
-  );
-  if (!handle) return null;
-  try {
-    const opened = await handle.stat();
-    const same =
-      opened.isFile() &&
-      opened.ino === file.ino &&
-      opened.dev === file.dev &&
-      opened.size === file.size &&
-      (await resolve(dirname(file.full))) === join(root, dirname(file.path));
-    if (same) return handle;
-  } catch (error) {
-    await handle.close();
-    throw error;
-  }
-  await handle.close();
-  return null;
-}
-
-/** The file's SHA-256, read through the handle `openListed` checked; null when the file is not the one listed, or its
- * bytes changed while being read. `root` is the project's real path; `resolve` finds a folder's real path.
- * @param {string} root @param {Found} file @param {typeof realpath} [resolve] */
-export async function hashListedFile(root, file, resolve = realpath) {
-  const handle = await openListed(root, file, resolve);
-  if (!handle) return null;
-  try {
-    const sha256 =
-      file.size <= INLINE_HASH_BYTES
-        ? await handle
-            .readFile()
-            .then((bytes) =>
-              bytes.length === file.size ? createHash("sha256").update(bytes).digest("hex") : null,
-            )
-        : await hashHandle(handle);
-    const after = await handle.stat();
-    return after.size === file.size && after.mtimeMs === file.mtimeMs ? sha256 : null;
-  } finally {
-    await handle.close();
-  }
-}
-
-/** @param {string} root @param {Found[]} files @param {ReturnType<typeof hashMemo>} memo
- * @returns {Promise<{ hashed: import("./types.js").ManifestFile[], problems: CaptureProblem[] }>} */
-async function hashAll(root, files, memo) {
-  /** @type {import("./types.js").ManifestFile[]} */
-  const hashed = [];
-  /** @type {CaptureProblem[]} */
-  const problems = [];
-  const queue = [...files];
-  const worker = async () => {
-    for (let file = queue.shift(); file; file = queue.shift()) {
-      const sha256 = memo.get(file) ?? (await hashListedFile(root, file).catch(() => undefined));
-      if (sha256 === undefined) problems.push({ path: file.path, problem: "unreadable" });
-      else if (sha256 === null) problems.push({ path: file.path, problem: "changed" });
-      else {
-        memo.set(file, sha256);
-        hashed.push({ path: file.path, sha256, size: file.size });
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: HASHING_AT_ONCE }, worker));
-  return { hashed, problems };
-}
-
-/** Problems that keep the files found from being one manifest: two names one disk stores as one, no index.html.
- * @param {Found[]} files @returns {CaptureProblem[]} */
-function inventoryProblems(files) {
-  if (!files.some((file) => file.path === ENTRYPOINT))
-    return [{ path: ENTRYPOINT, problem: "no-entrypoint" }];
-  try {
-    checkInventoryPaths(files.map((file) => file.path));
-    return [];
-  } catch (error) {
-    if (!(error instanceof PathViolation)) throw error;
-    return [{ path: error.path, problem: "invalid-name", code: error.code }];
-  }
-}
-
-/** Captures `root` (a project's real path). `memo` reuses hashes of unchanged files; a send should pass a fresh one.
- * @param {string} root @param {{ memo?: ReturnType<typeof hashMemo>, limits?: import("./types.js").Limits }} [options]
- * @returns {Promise<Capture>} */
-export async function captureProject(root, { memo = hashMemo(), limits = V1_LIMITS } = {}) {
-  const renderOutput = await readRenderOutputs(root);
-  const walk = await walkProject(root, renderOutput);
-  const problems = walk.problems.length ? walk.problems : inventoryProblems(walk.files);
-  if (problems.length) return { at: "problems", problems };
-  const over = overLimit(walk.files, manifestBytes(walk.files), limits);
-  if (over) return { at: "too-big", over };
-  const { hashed, problems: unhashed } = await hashAll(await realpath(root), walk.files, memo);
-  if (unhashed.length) return { at: "problems", problems: unhashed };
-  try {
-    const manifest = parseManifest({ format_version: 1, entrypoint: ENTRYPOINT, files: hashed });
-    const settled = await settledState(root);
-    return {
-      at: "captured",
-      manifest,
-      settled,
-      waiting: walk.waiting,
-      skippedLinks: walk.skippedLinks,
-    };
-  } catch (error) {
-    if (!(error instanceof ManifestInvalid)) throw error;
-    const first = error.violations[0];
-    return {
-      at: "problems",
-      problems: [{ path: first?.path ?? "", problem: "invalid-name", code: error.code }],
-    };
-  }
-}
-
-/** @param {import("node:fs/promises").FileHandle} handle */
-async function hashHandle(handle) {
-  const hash = createHash("sha256");
-  for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
-  return hash.digest("hex");
-}