@hyperframes/share 0.0.0-stage → 0.9.21

package/dist/types/reviewWire.d.ts

@@ -0,0 +1,200 @@
+// Review API request and response shapes. Nullable fields use `| null`.
+
+import type { AccessMode, LinkRole } from "./share.js";
+
+export interface ErrorEnvelope {
+  code: number;
+  message: string;
+  data: {
+    reason: string;
+    current_revision?: number;
+    /** On a 403 `workspace_membership_required`: the team workspace the link is for, absent when it has no name of
+     * its own to show (a personal space never has one). */
+    space?: { name: string; kind: "team" };
+    workspace_id?: string;
+    project_limit?: number;
+    projects_used_up_to_limit?: number;
+    requested_feature?: string;
+  };
+}
+
+export interface RegisterProjectRequest {
+  studio_project_id: string;
+  title: string;
+  client_operation_id: string;
+}
+
+interface Capabilities {
+  can_view: true;
+  can_comment: boolean;
+  can_export: boolean;
+  can_resolve: boolean;
+  can_manage_sharing: boolean;
+}
+
+export interface ProjectDTO {
+  review_entitlements?: ReviewEntitlements | null;
+  project_id: string;
+  title: string;
+  access_mode: AccessMode;
+  latest_ready_version_id: string | null;
+  review_url: string | null;
+  authenticated_review_url: string;
+  capabilities: Capabilities;
+}
+
+// GET /v1/hyperframes/review-spaces: personal first, then team spaces by last use. The data
+// is `{ items: SpaceDTO[], version_sharing?: boolean, share_files?: boolean }`: the server's per-account flags for
+// shared reviews and for files on their versions, and anything but `true` (absent from an older server too) is off.
+export interface SpaceDTO {
+  review_entitlements?: ReviewEntitlements | null;
+  space_id: string;
+  name: string;
+  kind: "personal" | "team";
+  can_create_review: boolean;
+  last_used_at: string | null;
+  /** The workspace this token is bound to; absent from servers before it. */
+  bound?: boolean;
+  /** Someone other than the calling user is a member; absent when the server could not count, or
+   * predates it. */
+  has_other_members?: boolean;
+}
+
+// The workspace a project was registered in.
+interface SpaceRef {
+  space_id: string;
+  name: string;
+  kind: SpaceDTO["kind"];
+  /** Someone other than the project's owner is a member; absent as on SpaceDTO. */
+  has_other_members?: boolean;
+}
+
+export interface ShareDTO {
+  review_entitlements?: ReviewEntitlements | null;
+  sharing_state?: ReviewSharingState;
+  project_id: string;
+  access_mode: AccessMode;
+  default_role: LinkRole;
+  comments_enabled: boolean;
+  revision: number;
+  link_generation: number;
+  /** Null when the link is off or the frontend base is unset. */
+  review_url: string | null;
+  authenticated_review_url: string;
+  revoked: boolean;
+  space?: SpaceRef | null;
+  /** While a moderation hold is active, link viewers and guests receive 404. */
+  moderation_hold?: boolean;
+  /** Which hold: a staff takedown admits only the owner and refuses any reshare with 409 moderation_hold. */
+  moderation_hold_kind?: "takedown" | "auto_reports" | null;
+}
+
+export interface UpdateProjectShareRequest {
+  access_mode: AccessMode;
+  default_role: LinkRole;
+  comments_enabled: boolean;
+  expected_revision: number;
+}
+
+export interface ProjectOperationRequest {
+  expected_link_generation: number;
+  client_operation_id: string;
+}
+
+// GET …/feedback: only the final page carries change_cursor.
+export interface FeedbackPage {
+  items: unknown[];
+  next_cursor: string | null;
+  change_cursor: string | null;
+}
+
+// POST /v1/hyperframes/review-projects/{id}/exports with a local MP4 (contract "Export a new video version").
+export interface ExportRequest {
+  client_operation_id: string;
+  title_snapshot: string;
+  coordinate_width: number;
+  coordinate_height: number;
+  duration_seconds: number;
+  render_settings: Record<string, never>;
+  source_revision_id: null;
+  source_fingerprint: string | null;
+  local_upload: { size_bytes: number; checksum_sha256: string; content_type: "video/mp4" };
+  /** The synced snapshot the video was rendered from, sent only while the server's `share_files` is on. The server
+   * refuses one it cannot match with 422 `snapshot_mismatch`. */
+  snapshot?: SnapshotRef;
+  /** Whether this version addresses review feedback, when the host can tell. */
+  from_review?: "yes" | "no";
+}
+
+/** A composition-sync snapshot a review version carries, named in the snapshot's own workspace, which may differ from
+ * the review project's. Also the body of PUT …/versions/{version_id}/snapshot, which attaches one later. */
+export interface SnapshotRef {
+  space_id: string;
+  composition_id: string;
+  snapshot_id: string;
+}
+
+// A version is playable only after screening completes.
+export interface ExportDTO {
+  video_id: string;
+  version_id: string;
+  status: "upload_pending" | "processing" | "screening" | "ready" | "failed";
+  exported_at: string;
+  upload: { put_url: string; headers: Record<string, string> } | null;
+  error: { reason: string; message: string } | null;
+  /** Owner reads only (absent from an older backend); status stays "screening" for both, null when not screening.
+   * "checking" is any screening not held for a person at HeyGen. */
+  screening_state?: "checking" | "held" | null;
+}
+
+export interface ReviewEntitlements {
+  policy_version: 1;
+  workspace_id: string;
+  plan: "free" | "subscribed";
+  project_limit: 5 | null;
+  projects_used_up_to_limit: number | null;
+  can_register_project: boolean;
+  allowed_collaborative_access_modes: Array<"public" | "team" | "invite">;
+  can_manage_email_grants: boolean;
+  /** Whether the owner's plan can give Can edit; sent only while `share_files` is on, false on Free. */
+  can_offer_edit?: boolean;
+}
+interface ReviewSharingState {
+  state: "available" | "closed" | "subscription_required";
+  can_close_access: boolean;
+  can_create_email_grants?: boolean;
+  can_update_email_grants?: boolean;
+  can_rotate_link?: boolean;
+  can_create_link?: boolean;
+  can_revoke_link?: boolean;
+  allowed_collaborative_access_modes?: Array<"public" | "team" | "invite">;
+  allowed_default_roles?: LinkRole[];
+  can_enable_comments?: boolean;
+}
+export interface AccessGrantDTO {
+  effective?: boolean;
+  can_revoke?: boolean;
+  allowed_roles?: Array<"viewer" | "commenter" | "editor">;
+  id: string;
+  email: string;
+  role: "viewer" | "commenter" | "editor";
+  revision: number;
+  revoked_at: string | null;
+}
+export interface CreateGrantRequest {
+  client_operation_id: string;
+  email: string;
+  role: AccessGrantDTO["role"];
+  expected_revision: number | null;
+}
+export interface ManagedReviewPage {
+  items: Array<{
+    project_id: string;
+    title: string;
+    created_at: string;
+    owner_user_id: string;
+    can_remove: boolean;
+  }>;
+  next_cursor: string | null;
+  review_entitlements: ReviewEntitlements | null;
+}

package/dist/types/share.d.ts

@@ -0,0 +1,119 @@
+/** Who a review link lets in, and as what, as the shared-reviews server names them. */
+export type AccessMode = "public" | "invite" | "team" | "private";
+export type LinkRole = "viewer" | "commenter" | "editor";
+
+/** Whether the version on the page, or the one a press would add, carries the project's synced files. `included`: it
+ * does. `not_synced`: the render is the project as it is now, but that is not what was last synced. `changed`: the
+ * project moved past the render. `other_workspace`: the project syncs to `workspace`, not the one Desktop is signed
+ * into, whose sign-in can't read its snapshots. `off`: share_files or sync is off, or there is no render to speak of. */
+export type ReviewFiles =
+  | { at: "off" }
+  | { at: "included" }
+  | { at: "not_synced" }
+  | { at: "changed" }
+  | { at: "other_workspace"; workspace: string };
+export type ReviewFilesState = ReviewFiles["at"];
+
+/** An upload under way: bytes sent of the archive's total (0 while the archive is made). */
+export interface ShareProgress {
+  sent: number;
+  total: number;
+}
+
+/** A project's shared link, as the Share popover reads it. */
+export interface ShareStatus {
+  /** Null until the first share; changedFiles counts the project's files changed since that link was made. */
+  link: { url: string; sharedAt: number; changedFiles: number } | null;
+  /** The project's files in bytes, and the most a shared project may be. */
+  bytes: number;
+  limit: number;
+  publishing: ShareProgress | null;
+}
+
+/** A project's review link, as the server holds it. */
+export interface ReviewShare {
+  projectId?: string;
+  entitlements?: import("./reviewWire.js").ReviewEntitlements | null | undefined;
+  sharingState?: import("./reviewWire.js").ShareDTO["sharing_state"];
+  removed?: boolean;
+  /** Null while the link is off. */
+  url: string | null;
+  access: AccessMode;
+  role: LinkRole;
+  commentsOn: boolean;
+  /** The space the link belongs to; null from a server that does not say. */
+  space: ReviewSpaceRef | null;
+  /** The link's space is not the one Desktop is signed into. Everything still works there; this only names it. */
+  elsewhere: boolean;
+  /** A report paused access through the link: only the owner, invited people and workspace members get in. */
+  held: boolean;
+  /** Staff took the review down: only the owner can open it, at `page`, and it can't be shared again. */
+  takedown?: { page: string };
+  /** Where the page's versions stand; every answer over IPC carries it. */
+  version?: ReviewVersion;
+  /** After a change of space: the old link not yet turned off, and whether retries keep failing. */
+  oldLink?: { space: string; stuck: boolean } | null;
+}
+
+/** An upload to the review page in flight. `checking` is the server's screening, which can take a while. */
+export interface ReviewExportProgress {
+  step: "preparing" | "uploading" | "processing" | "checking";
+  sent: number;
+  total: number;
+  /** Checking for over 2 minutes: staff review can take a while. */
+  slow?: boolean;
+  /** How screening stands, from a server that says: held for a person at HeyGen (no bar, polled slowly, up to a day)
+   * or checking. Absent from an older server, which leaves `slow` to say a long check. */
+  screening?: "checking" | "held";
+  /** Checking for over 15 minutes since the upload completed, by this computer's clock. */
+  late?: boolean;
+}
+
+export interface ReviewVersion {
+  /** The newest version this app put on the page; `current` when it is the project as it is now. */
+  last: { exportedAt: string; current: boolean } | null;
+  /** The newest export: ready to go up, none, not MP4, or older than the project now. */
+  source: "ready" | "none" | "not-mp4" | "stale";
+  exporting: ReviewExportProgress | null;
+  /** The last run's sentence when it did not go up. */
+  failure: string | null;
+  /** False when the same video would be refused again (blocked, rejected, not available): no Try again. */
+  retryable?: boolean;
+  /** With `retryable` false: a smaller or shorter export can go up, so offer Export MP4. */
+  exportHelps?: boolean;
+  /** The watch ran out while the video was held for review: not a refusal, so it is never shown as one. */
+  held?: boolean;
+}
+
+export interface ReviewSpaceRef {
+  id: string;
+  name: string;
+  kind: "personal" | "team";
+  /** Someone besides the link's owner (on a space list: besides the caller) is in the space; absent when the server
+   * does not say, which Share reads as yes. */
+  hasOtherMembers?: boolean;
+}
+
+/** A space the account is in. v1 shares into the signed-in one; the later workspace switch lists the rest. */
+export interface ReviewSpace extends ReviewSpaceRef {
+  /** Existing native registration verified by reading its owner share; a retry needs no new slot. */
+  existingProjectId?: string;
+  /** A durable registration request can be replayed; the server still decides admission. */
+  resumingRegistration?: boolean;
+  sharingState?: ReviewShare["sharingState"];
+  entitlements?: import("./reviewWire.js").ReviewEntitlements | null | undefined;
+  lastUsedAt: string | null;
+  canCreate: boolean;
+  /** The workspace Desktop is signed into, where a new link goes. */
+  signedIn: boolean;
+}
+
+export type ReviewAccessChange = { access: ReviewShare["access"] } | { role: ReviewShare["role"] };
+
+/** A share link as Settings' Cloud list shows it (packages/agent-runtime/src/share/reviewLinkStates.mjs). */
+export interface ReviewLinkState {
+  state: "on" | "off" | "paused" | "taken-down";
+  access: import("./share.js").AccessMode;
+  /** Why a paused link is paused: a report HyperFrames looks into, or a plan that no longer includes it. */
+  pausedFor?: "report" | "plan";
+}

package/dist/types/shareOpen.d.ts

@@ -0,0 +1,96 @@
+// Open in Studio from a share page (docs/sync-backed-sharing/contracts.md C1-C3, C7): the server's answers, and what
+// Desktop's choice dialog is told.
+
+/** C1: `GET /v1/hyperframes/reviews/{token}/open?version_id=`. */
+export interface OpenSummaryDTO {
+  /** `project_id` is the review project, which Work on {owner}'s project names on composition calls (C5). */
+  project: { project_id: string; title: string; owner_name: string; space_name: string | null };
+  version: {
+    version_id: string;
+    label: string;
+    has_files: boolean;
+    files?: { count: number; bytes: number } | null;
+  };
+  fallback_version: { version_id: string; label: string; published_at: string } | null;
+  composition: {
+    space_id: string;
+    composition_id: string;
+    latest_snapshot_id: string;
+    newer_than_version: boolean;
+  } | null;
+  can_get: boolean;
+  plan_space_id: string | null;
+  plan_space_name: string | null;
+}
+
+/** One signed read URL in a sync download batch. */
+export interface SignedBlobDTO {
+  sha256: string;
+  size: number;
+  url: string;
+  expires_at: string;
+}
+
+/** C2: `GET /v1/hyperframes/reviews/{token}/versions/{version_id}/files`, the snapshot's manifest and the first URLs
+ * (at most 500 files). More, or fresh ones, come from `POST` on the same path with `{continuation_token, sha256s}`,
+ * which answers exactly the sync `DownloadUrlsResponse`. */
+export interface VersionFilesDTO {
+  version_id: string;
+  snapshot_id: string;
+  manifest_sha256: string;
+  manifest: { document: unknown; file_count: number; total_bytes: number };
+  continuation_token: string;
+  continuation_expires_at: string;
+  urls: SignedBlobDTO[];
+}
+
+/** C2's refresh: the sync download batch for the same snapshot. */
+export interface FileUrlsDTO {
+  snapshot_id: string;
+  manifest_sha256: string;
+  continuation_token: string;
+  continuation_expires_at: string;
+  urls: SignedBlobDTO[];
+}
+
+/** The copy card: the version's files, the earlier version that has some, or nothing to copy. */
+export type ShareCopyCard =
+  | { at: "ready"; versionId: string; label: string; files: number; bytes: number }
+  | {
+      at: "fallback";
+      label: string;
+      fallback: { versionId: string; label: string; publishedAt: string };
+    }
+  | { at: "none"; label: string };
+
+/** The Work on {owner}'s project card (C7): `open` to Get the owner's latest sync (`newer` when it is newer than the
+ * version the page showed); `locked` when the signed-in workspace (`planSpace`) has no paid plan; `linked` when this
+ * Mac already has a folder bound to it, with its edits not sent yet (null when they could not be counted). */
+export type ShareWorkCard =
+  | { at: "open"; newer: boolean }
+  | { at: "locked"; planSpace: string | null }
+  | { at: "linked"; unsent: number | null };
+
+/** The one press a failed open offers beside Close; `none` when no press here can change the answer. */
+export type ShareOpenOffer = "try_again" | "switch_account" | "sign_in" | "open_latest" | "none";
+
+/** What the choice dialog shows for the share link main is opening; null when none is. */
+export type ShareOpenView =
+  | { id: string; at: "loading" }
+  | { id: string; at: "failed"; sentence: string; offers: ShareOpenOffer }
+  | {
+      id: string;
+      at: "choose";
+      /** The review project (C1), kept for Work on {owner}'s project's composition calls. */
+      projectId: string;
+      title: string;
+      owner: string;
+      space: string | null;
+      versionLabel: string;
+      /** Null when the card is hidden: the project was never synced with files, or sync is off on this Mac. */
+      work: ShareWorkCard | null;
+      copy: ShareCopyCard;
+    }
+  | { id: string; at: "copying"; title: string; label: string; fraction: number | null }
+  /** Work on {owner}'s project is getting the owner's latest sync into a new linked folder. */
+  | { id: string; at: "linking"; title: string; owner: string };

package/package.json

@@ -1,6 +1,115 @@
 {
   "name": "@hyperframes/share",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.9.21",
+  "description": "Shared review identity, version upload and sharing state for HyperFrames hosts",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/heygen-com/hyperframes",
+    "directory": "packages/share"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md",
+    "scripts/copy-types.mjs"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./hosts": "./dist/hosts.d.ts",
+    "./package.json": "./package.json",
+    "./appOwnedPaths.mjs": {
+      "import": "./src/appOwnedPaths.mjs",
+      "types": "./dist/appOwnedPaths.d.mts"
+    },
+    "./grantRefusal.mjs": {
+      "import": "./src/grantRefusal.mjs",
+      "types": "./dist/grantRefusal.d.mts"
+    },
+    "./host.mjs": {
+      "import": "./src/host.mjs",
+      "types": "./dist/host.d.mts"
+    },
+    "./index.mjs": {
+      "import": "./src/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./projectLock.mjs": {
+      "import": "./src/projectLock.mjs",
+      "types": "./dist/projectLock.d.mts"
+    },
+    "./projectSnapshot.mjs": {
+      "import": "./src/projectSnapshot.mjs",
+      "types": "./dist/projectSnapshot.d.mts"
+    },
+    "./reviewAudience.mjs": {
+      "import": "./src/reviewAudience.mjs",
+      "types": "./dist/reviewAudience.d.mts"
+    },
+    "./reviewClient.mjs": {
+      "import": "./src/reviewClient.mjs",
+      "types": "./dist/reviewClient.d.mts"
+    },
+    "./reviewExport.mjs": {
+      "import": "./src/reviewExport.mjs",
+      "types": "./dist/reviewExport.d.mts"
+    },
+    "./reviewFiles.mjs": {
+      "import": "./src/reviewFiles.mjs",
+      "types": "./dist/reviewFiles.d.mts"
+    },
+    "./reviewLinkStates.mjs": {
+      "import": "./src/reviewLinkStates.mjs",
+      "types": "./dist/reviewLinkStates.d.mts"
+    },
+    "./reviewOpenCalls.mjs": {
+      "import": "./src/reviewOpenCalls.mjs",
+      "types": "./dist/reviewOpenCalls.d.mts"
+    },
+    "./reviewShare.mjs": {
+      "import": "./src/reviewShare.mjs",
+      "types": "./dist/reviewShare.d.mts"
+    },
+    "./reviewSwitch.mjs": {
+      "import": "./src/reviewSwitch.mjs",
+      "types": "./dist/reviewSwitch.d.mts"
+    },
+    "./reviewUpload.mjs": {
+      "import": "./src/reviewUpload.mjs",
+      "types": "./dist/reviewUpload.d.mts"
+    },
+    "./reviewVersionSentences.mjs": {
+      "import": "./src/reviewVersionSentences.mjs",
+      "types": "./dist/reviewVersionSentences.d.mts"
+    },
+    "./signedInRequest.mjs": {
+      "import": "./src/signedInRequest.mjs",
+      "types": "./dist/signedInRequest.d.mts"
+    },
+    "./storage.mjs": {
+      "import": "./src/storage.mjs",
+      "types": "./dist/storage.d.mts"
+    },
+    "./types/access": "./dist/types/access.d.ts",
+    "./types/review": "./dist/types/review.d.ts",
+    "./types/reviewWire": "./dist/types/reviewWire.d.ts",
+    "./types/share": "./dist/types/share.d.ts",
+    "./types/shareOpen": "./dist/types/shareOpen.d.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-types.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test tests/*.test.mjs"
+  }
 }

package/scripts/copy-types.mjs

@@ -0,0 +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");

package/src/appOwnedPaths.mjs

@@ -0,0 +1,27 @@
+// @ts-check
+/** @param {string} path */
+const pathParts = (path) => path.split(/[\\/]/);
+export const APP_OWNED_DIRS = [
+  ".thumbnails",
+  ".hyperframes",
+  ".claude",
+  "renders",
+  ".transcode-cache",
+  ".waveform-cache",
+];
+
+/** True for a project-relative path that lives under one of the app's own folders. @param {string} relativePath */
+export const isAppOwned = (relativePath) =>
+  APP_OWNED_DIRS.includes(/** @type {string} */ (pathParts(relativePath)[0]));
+
+/** A file the film can never load, so no change report counts it: the app's own folders, anything hidden
+ * (a dot file or folder: .git, .DS_Store), installed packages, and temporary editor or download files.
+ * @param {string} relativePath */
+export function isOutsideFilm(relativePath) {
+  const parts = pathParts(relativePath);
+  return (
+    isAppOwned(relativePath) ||
+    parts.some((part) => part.startsWith(".") || part === "node_modules") ||
+    /(?:~|\.swp|\.tmp|\.part)$/.test(parts.at(-1) ?? "")
+  );
+}

package/src/fromReview.mjs

@@ -0,0 +1,27 @@
+// @ts-check
+
+/** @typedef {{ read: (dir: string) => Promise<"yes" | "no" | null>,
+ *   published: (dir: string, since: number) => Promise<void>, now: () => number }} FromReview */
+
+/** @param {FromReview} host @param {string} dir */
+export async function readFromReview(host, dir) {
+  const since = host.now();
+  try {
+    const value = await host.read(dir);
+    return { since, ...(value && { value }) };
+  } catch (error) {
+    console.error("[share] review mark not read:", error);
+    return { since };
+  }
+}
+
+/** Clear activity through the start of the successful share, keeping anything recorded later.
+ * @param {FromReview | null} host @param {string} dir @param {number | undefined} since */
+export async function sharedFromReview(host, dir, since) {
+  if (!host || since === undefined) return;
+  try {
+    await host.published(dir, since);
+  } catch (error) {
+    console.error("[share] review mark not cleared:", error);
+  }
+}

package/src/grantRefusal.mjs

@@ -0,0 +1,28 @@
+// @ts-check
+const PREFIX = "ReviewGrantRefusal:v1:";
+const REASONS = new Set(["revision_conflict", "grant_exists", "operation_result_revoked"]);
+
+/** Definitive refusals are per-call data, not the project's mutable last-issue lookup.
+ * @param {unknown} error */
+export function rejectedGrantRequest(error) {
+  return error instanceof Error && "reason" in error && REASONS.has(String(error.reason));
+}
+
+/** An explicit wire protocol survives Electron's Error-only serialization and the browser bridge.
+ * @param {string} reason @param {string} message */
+export function grantRefusalMessage(reason, message) {
+  return REASONS.has(reason) ? PREFIX + JSON.stringify({ reason, message }) : message;
+}
+
+/** @param {unknown} error */
+export function decodeGrantRefusal(error) {
+  if (!(error instanceof Error) || !error.message.startsWith(PREFIX)) return error;
+  try {
+    const data = JSON.parse(error.message.slice(PREFIX.length));
+    if (REASONS.has(data.reason) && typeof data.message === "string")
+      return Object.assign(new Error(data.message), { reason: data.reason });
+  } catch {
+    // An invalid wire payload remains an ambiguous failure and keeps its saved request.
+  }
+  return error;
+}

package/src/host.mjs

@@ -0,0 +1,46 @@
+import { promisify } from "node:util";
+import { execFile as nodeExecFile } from "node:child_process";
+import { signedInRequest as defaultRequest } from "./signedInRequest.mjs";
+// @ts-check
+/** @typedef {import("./hosts.js").ShareHost} ShareHost */
+/** @type {Partial<ShareHost>} */
+const host = { execFile: nodeExecFile, signedInRequest: defaultRequest };
+/** Bind the host services used by the sharing runtime. @param {Partial<ShareHost>} part */
+export const bindShareHost = (part) => void Object.assign(host, part);
+/** @template {keyof ShareHost} K @param {K} name @returns {ShareHost[K]} */
+const bound = (name) => {
+  const part = host[name];
+  if (part === undefined) throw new Error(`No host is bound to share projects (${name}).`);
+  return /** @type {ShareHost[K]} */ (part);
+};
+
+/** @type {ShareHost["normalize"]} */
+export const normalize = (path) => bound("normalize")(path);
+/** @type {ShareHost["assertOpenProject"]} */
+export const assertOpenProject = (path) => bound("assertOpenProject")(path);
+/** @type {ShareHost["resolveOpenProjectByPath"]} */
+export const resolveOpenProjectByPath = (path) => bound("resolveOpenProjectByPath")(path);
+/** @type {ShareHost["listOpenProjects"]} */
+export const listOpenProjects = () => bound("listOpenProjects")();
+/** @type {ShareHost["homeName"]} */
+export const homeName = (path, folder) => bound("homeName")(path, folder);
+/** @type {ShareHost["uploadWithProgress"]} */
+export const uploadWithProgress = (url, headers, archive, onSent) =>
+  bound("uploadWithProgress")(url, headers, archive, onSent);
+/** @type {ShareHost["signedInRequest"]} */
+export const signedInRequest = (deps) => bound("signedInRequest")(deps);
+/** @type {ShareHost["latestExportFile"]} */
+export const latestExportFile = (dir) => bound("latestExportFile")(dir);
+export const reviewUploadOrigins = () =>
+  host.reviewUploadOrigins ??
+  (process.env.HYPERFRAMES_REVIEW_UPLOAD_ORIGINS ?? "").split(",").map((origin) => origin.trim());
+/** @type {ShareHost["projectFingerprint"]} */
+export const projectFingerprint = (dir) => bound("projectFingerprint")(dir);
+/** @type {ShareHost["ffBinary"]} */
+export const ffBinary = (name) => bound("ffBinary")(name);
+export const channelSite = () => bound("channelSite");
+export const signinSites = () => bound("signinSites");
+
+/** @param {string} file @param {string[]} args */
+export const runFile = (file, args) =>
+  promisify(bound("execFile"))(file, args, { windowsHide: true });