@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-JH556Q42.js

@@ -0,0 +1,647 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  refreshIfNeeded
+} from "./chunk-SHB5VDMH.js";
+import {
+  buildAuthHeaders,
+  isAuthError,
+  isTokenExpired,
+  tryResolveCredential
+} from "./chunk-I465DBM6.js";
+import {
+  CSS_URL_RE,
+  isNonRelativeUrl,
+  isPathInside
+} from "./chunk-TQFG7HTI.js";
+import {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
+
+// src/utils/projectLink.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var CONFIG_DIR = join(homedir(), ".hyperframes");
+var PROJECTS_FILE = join(CONFIG_DIR, "projects.json");
+function readJsonRecord(path) {
+  try {
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isProjectLink(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const link = value;
+  return typeof link.projectId === "string" && link.projectId.length > 0 && typeof link.url === "string";
+}
+function readProjectLinks() {
+  const record = readJsonRecord(PROJECTS_FILE);
+  if (!record) return {};
+  const links = {};
+  for (const [path, value] of Object.entries(record)) {
+    if (isProjectLink(value)) {
+      links[path] = { projectId: value.projectId, url: value.url };
+    }
+  }
+  return links;
+}
+function writeProjectLinks(links) {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+    writeFileSync(PROJECTS_FILE, `${JSON.stringify(links, null, 2)}
+`, { mode: 384 });
+  } catch {
+  }
+}
+function readProjectLink(absDir) {
+  return readProjectLinks()[resolve(absDir)] ?? null;
+}
+function writeProjectLink(absDir, link) {
+  const links = readProjectLinks();
+  links[resolve(absDir)] = { projectId: link.projectId, url: link.url };
+  writeProjectLinks(links);
+}
+function ensureProjectId(absDir) {
+  const links = readProjectLinks();
+  const path = resolve(absDir);
+  const existing = links[path];
+  if (existing) return existing.projectId;
+  const projectId = randomUUID();
+  links[path] = { projectId, url: "" };
+  writeProjectLinks(links);
+  return projectId;
+}
+var TEAM_PROJECT_DIR = ".hyperframes";
+var TEAM_PROJECT_FILE = "project.json";
+function teamProjectPath(projectDir) {
+  return join(resolve(projectDir), TEAM_PROJECT_DIR, TEAM_PROJECT_FILE);
+}
+function readTeamProject(projectDir) {
+  const record = readJsonRecord(teamProjectPath(projectDir));
+  if (!record || typeof record.projectId !== "string" || record.projectId.length === 0) return null;
+  const spaceId = typeof record.spaceId === "string" && record.spaceId.length > 0 ? record.spaceId : void 0;
+  return { projectId: record.projectId, ...spaceId ? { spaceId } : {} };
+}
+function writeTeamProject(projectDir, team) {
+  const file = teamProjectPath(projectDir);
+  const body = {
+    projectId: team.projectId,
+    ...team.spaceId ? { spaceId: team.spaceId } : {}
+  };
+  mkdirSync(join(resolve(projectDir), TEAM_PROJECT_DIR), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(body, null, 2)}
+`);
+  return file;
+}
+
+// src/utils/publishProject.ts
+import { basename, dirname, join as join2, posix, relative, resolve as resolve2 } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import AdmZip from "adm-zip";
+import ignore from "ignore";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".next", "coverage"]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db"]);
+var HYPERFRAMES_IGNORE_FILE = ".hyperframesignore";
+var DEFAULT_PROJECT_IGNORE = ["/renders/", "/snapshots/", ".*"];
+var PUBLISH_CONTENT_TYPE = "application/zip";
+var PUBLISH_METADATA_TIMEOUT_MS = 3e4;
+var PUBLISH_UPLOAD_MIN_TIMEOUT_MS = 12e4;
+var PUBLISH_TRANSPORT_ATTEMPTS = 2;
+var PUBLISH_RETRY_DELAY_MS = 200;
+var PUBLISH_UPLOAD_BYTES_PER_SECOND = 5e5;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dataRecord(payload) {
+  if (!isRecord(payload) || !isRecord(payload["data"])) return null;
+  return payload["data"];
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : null;
+}
+function parsePublishedProjectResponse(payload) {
+  const data = dataRecord(payload);
+  if (!data) return null;
+  const projectId = stringField(data, "project_id");
+  const title = stringField(data, "title");
+  const url = stringField(data, "url");
+  const claimToken = stringField(data, "claim_token") ?? "";
+  const claimed = data["claimed"] === true;
+  const fileCount = data["file_count"];
+  if (!projectId || !title || !url || typeof fileCount !== "number") {
+    return null;
+  }
+  if (!claimed && !claimToken) {
+    return null;
+  }
+  return {
+    projectId,
+    title,
+    fileCount,
+    url,
+    claimToken,
+    claimed
+  };
+}
+function parseStagedUploadResponse(payload, archiveByteLength) {
+  const data = dataRecord(payload);
+  if (!data) return null;
+  const uploadUrl = stringField(data, "upload_url");
+  const uploadKey = stringField(data, "upload_key");
+  const contentType = stringField(data, "content_type") || PUBLISH_CONTENT_TYPE;
+  if (!uploadUrl || !uploadKey) return null;
+  const rawExpires = data["expires_in_seconds"];
+  const expiresInSeconds = typeof rawExpires === "number" && rawExpires > 0 ? rawExpires : 1800;
+  return {
+    uploadUrl,
+    uploadKey,
+    contentType,
+    uploadHeaders: getUploadHeaders(data, uploadUrl, contentType, archiveByteLength),
+    expiresInSeconds
+  };
+}
+function getUploadHeaders(data, uploadUrl, contentType, archiveByteLength) {
+  const headers = {};
+  const uploadHeaders = data["upload_headers"];
+  if (isRecord(uploadHeaders)) {
+    for (const [key, value] of Object.entries(uploadHeaders)) {
+      if (typeof value === "string" && key.trim()) {
+        headers[key] = value;
+      }
+    }
+  }
+  if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+    headers["content-type"] = contentType;
+  }
+  const signedHeaders = new URL(uploadUrl).searchParams.get("X-Amz-SignedHeaders");
+  if (signedHeaders?.split(";").includes("x-amz-server-side-encryption") && !Object.keys(headers).some((key) => key.toLowerCase() === "x-amz-server-side-encryption")) {
+    headers["x-amz-server-side-encryption"] = "AES256";
+  }
+  if (signedHeaders?.split(";").includes("content-length") && !Object.keys(headers).some((key) => key.toLowerCase() === "content-length")) {
+    headers["content-length"] = String(archiveByteLength);
+  }
+  return headers;
+}
+async function readJson(response) {
+  return response.clone().json().catch(() => null);
+}
+var CredentialRejectedError = class extends Error {
+};
+async function metadataRequestError(response, fallback) {
+  const message = await readErrorMessage(response, fallback);
+  return response.status === 401 ? new CredentialRejectedError(message) : new Error(message);
+}
+var LOGIN_EXPIRED = "Your login expired. Run hyperframes auth login, then publish again.";
+var LOGIN_CHANGED = "Your login changed during publish. Run publish again.";
+var API_KEY_ENV_VAR = { env: "HEYGEN_API_KEY", env_alias: "HYPERFRAMES_API_KEY" };
+function rejectedCredentialMessage(credential) {
+  if (credential.type === "api_key" && (credential.source === "env" || credential.source === "env_alias")) {
+    return `${API_KEY_ENV_VAR[credential.source]} was rejected. Fix or unset it, then publish again.`;
+  }
+  return LOGIN_EXPIRED;
+}
+async function resolvePublishCredential(checked) {
+  try {
+    const credential = checked === void 0 ? await tryResolveCredential() : checked;
+    if (!credential) return null;
+    const expired = credential.type === "oauth" && isTokenExpired(credential.expires_at, /* @__PURE__ */ new Date());
+    if (expired && !credential.refresh_token) throw new Error(LOGIN_EXPIRED);
+    return await refreshIfNeeded(expired ? { ...credential, refreshable: true } : credential);
+  } catch (error) {
+    if (isAuthError(error) && (error.code === "REFRESH_FAILED" || error.code === "LOGIN_EXPIRED")) {
+      throw new Error(LOGIN_EXPIRED);
+    }
+    if (isAuthError(error) && error.code === "LOGIN_CHANGED") throw new Error(LOGIN_CHANGED);
+    throw error;
+  }
+}
+async function readErrorMessage(response, fallback) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    const payload = await readJson(response);
+    if (isRecord(payload) && typeof payload["message"] === "string") {
+      return payload["message"];
+    }
+  }
+  if (response.status === 403 && response.headers.get("cf-mitigated") === "challenge") {
+    return "Publish upload was blocked before reaching HyperFrames. Please retry after staged uploads are available.";
+  }
+  const text = await response.text().catch(() => "");
+  return text.trim() ? `${fallback}: ${text.trim().slice(0, 180)}` : fallback;
+}
+function systemErrorMetadata(value) {
+  if (!isRecord(value)) return [];
+  const metadata = [];
+  if (typeof value["code"] === "string") metadata.push(value["code"]);
+  if (typeof value["syscall"] === "string") metadata.push(`syscall=${value["syscall"]}`);
+  if (typeof value["errno"] === "string" || typeof value["errno"] === "number") {
+    metadata.push(`errno=${value["errno"]}`);
+  }
+  return metadata;
+}
+function redactUrlQuery(message) {
+  return message.replace(/(https?:\/\/[^\s?]+)\?[^\s]+/gu, "$1?[redacted]");
+}
+function proxySupportHint() {
+  const proxyConfigured = ["HTTPS_PROXY", "HTTP_PROXY", "https_proxy", "http_proxy"].some(
+    (key) => Boolean(process.env[key]?.trim())
+  );
+  const proxyEnabled = process.env["NODE_USE_ENV_PROXY"] === "1" || process.execArgv.includes("--use-env-proxy") || process.env["NODE_OPTIONS"]?.split(/\s+/u).includes("--use-env-proxy") === true;
+  if (!proxyConfigured || proxyEnabled) return "";
+  return ". Proxy variables are set but ignored by Node fetch; if this network requires them, retry with NODE_USE_ENV_PROXY=1 (Node 22.21+)";
+}
+function describeFetchFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const cause = error instanceof Error ? error.cause : void 0;
+  const causeMessage = cause instanceof Error ? cause.message : "";
+  const metadata = [...systemErrorMetadata(cause), ...systemErrorMetadata(error)].filter(
+    (value, index, all) => all.indexOf(value) === index
+  );
+  const distinctCauseMessage = causeMessage && causeMessage !== message ? causeMessage : "";
+  const detail = [metadata.join(", "), distinctCauseMessage].filter(Boolean).join(": ");
+  return `${redactUrlQuery(message)}${detail ? ` (${redactUrlQuery(detail)})` : ""}${proxySupportHint()}`;
+}
+function isRequestTimeout(error) {
+  return error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+function waitBeforePublishRetry() {
+  return new Promise((resolve3) => setTimeout(resolve3, PUBLISH_RETRY_DELAY_MS));
+}
+async function fetchForPublish(input, createInit, failureStage, attempts = 1) {
+  if (attempts < 1) throw new RangeError("Publish fetch attempts must be at least 1");
+  let lastError;
+  let attemptsMade = 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    attemptsMade = attempt;
+    try {
+      return await fetch(input, createInit());
+    } catch (error) {
+      lastError = error;
+      if (isRequestTimeout(error) || attempt === attempts) break;
+      await waitBeforePublishRetry();
+    }
+  }
+  const attemptDetail = attemptsMade > 1 ? ` after ${attemptsMade} attempts` : "";
+  throw new Error(`${failureStage}${attemptDetail}: ${describeFetchFailure(lastError)}`, {
+    cause: lastError instanceof Error ? lastError : void 0
+  });
+}
+function uploadTimeoutMs(byteLength) {
+  return Math.max(
+    PUBLISH_UPLOAD_MIN_TIMEOUT_MS,
+    Math.ceil(byteLength / PUBLISH_UPLOAD_BYTES_PER_SECOND * 1e3)
+  );
+}
+function shouldIgnoreSegment(segment) {
+  return IGNORED_DIRS.has(segment) || IGNORED_FILES.has(segment);
+}
+function createProjectIgnore(rootDir) {
+  const matcher = ignore().add(DEFAULT_PROJECT_IGNORE);
+  const ignorePath = join2(rootDir, HYPERFRAMES_IGNORE_FILE);
+  if (existsSync2(ignorePath)) {
+    matcher.add(readFileSync2(ignorePath, "utf-8"));
+  }
+  return matcher;
+}
+function collectProjectFiles(rootDir, currentDir, paths, matcher) {
+  for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+    if (shouldIgnoreSegment(entry.name)) continue;
+    const absolutePath = join2(currentDir, entry.name);
+    const relativePath = relative(rootDir, absolutePath).replaceAll("\\", "/");
+    if (!relativePath) continue;
+    if (entry.isDirectory()) {
+      if (matcher.ignores(`${relativePath}/`)) continue;
+      collectProjectFiles(rootDir, absolutePath, paths, matcher);
+      continue;
+    }
+    if (!statSync(absolutePath).isFile()) continue;
+    if (matcher.ignores(relativePath)) continue;
+    paths.push(relativePath);
+  }
+}
+var EXT_ASSETS_PREFIX = "_ext";
+function addExternalAsset(ctx, absPath) {
+  const existing = ctx.externalMap.get(absPath);
+  if (existing) return existing;
+  const rel = relative(ctx.absProjectDir, absPath).replaceAll("\\", "/");
+  const stripped = rel.replace(/^(?:\.\.\/)+/, "");
+  let archivePath = `${EXT_ASSETS_PREFIX}/${stripped}`;
+  if (ctx.usedArchivePaths.has(archivePath)) {
+    const ext = posix.extname(archivePath);
+    const base = archivePath.slice(0, archivePath.length - ext.length);
+    let i = 2;
+    while (ctx.usedArchivePaths.has(`${base}_${i}${ext}`)) i++;
+    archivePath = `${base}_${i}${ext}`;
+  }
+  ctx.fileContents.set(archivePath, readFileSync2(absPath));
+  ctx.externalMap.set(absPath, archivePath);
+  ctx.usedArchivePaths.add(archivePath);
+  return archivePath;
+}
+function tryResolveExternal(ctx, rawPath, referrerAbsDir) {
+  if (isNonRelativeUrl(rawPath)) return null;
+  const absPath = resolve2(referrerAbsDir, rawPath);
+  if (isPathInside(absPath, ctx.absProjectDir)) return null;
+  try {
+    if (!existsSync2(absPath) || !statSync(absPath).isFile()) return null;
+  } catch {
+    return null;
+  }
+  return addExternalAsset(ctx, absPath);
+}
+function rewriteCssUrls(ctx, css, referrerAbsDir, entryPath) {
+  let modified = false;
+  const rewritten = css.replace(CSS_URL_RE, (full, quote, rawUrl) => {
+    const archivePath = tryResolveExternal(ctx, (rawUrl || "").trim(), referrerAbsDir);
+    if (!archivePath) return full;
+    modified = true;
+    return `url(${quote || ""}${posix.relative(posix.dirname(entryPath), archivePath)}${quote || ""})`;
+  });
+  return { css: rewritten, modified };
+}
+function rewriteHtmlAttributes(document, referrerAbsDir, entryPath, resolveTarget, options = {}) {
+  const attrs = options.attrs ?? ["src", "href"];
+  const selector = options.selector ?? attrs.map((attr) => `[${attr}]`).join(", ");
+  let modified = false;
+  for (const el of document.querySelectorAll(selector)) {
+    for (const attr of attrs) {
+      const val = (el.getAttribute(attr) || "").trim();
+      if (!val) continue;
+      const archivePath = resolveTarget(val, referrerAbsDir);
+      if (!archivePath) continue;
+      el.setAttribute(attr, posix.relative(posix.dirname(entryPath), archivePath));
+      modified = true;
+    }
+  }
+  return modified;
+}
+function rewriteStyleBlocks(ctx, document, referrerAbsDir, entryPath) {
+  let modified = false;
+  for (const styleEl of document.querySelectorAll("style")) {
+    const css = styleEl.textContent || "";
+    if (!css.includes("url(")) continue;
+    const result = rewriteCssUrls(ctx, css, referrerAbsDir, entryPath);
+    if (result.modified) {
+      styleEl.textContent = result.css;
+      modified = true;
+    }
+  }
+  for (const el of document.querySelectorAll("[style]")) {
+    const style = el.getAttribute("style") || "";
+    if (!style.includes("url(")) continue;
+    const result = rewriteCssUrls(ctx, style, referrerAbsDir, entryPath);
+    if (result.modified) {
+      el.setAttribute("style", result.css);
+      modified = true;
+    }
+  }
+  return modified;
+}
+function localizeHtmlEntry(ctx, entryPath, content) {
+  const referrerAbsDir = resolve2(ctx.absProjectDir, dirname(entryPath));
+  const { document } = parseHTML(content.toString("utf-8"));
+  const attrsChanged = rewriteHtmlAttributes(
+    document,
+    referrerAbsDir,
+    entryPath,
+    (val, dir) => tryResolveExternal(ctx, val, dir)
+  );
+  const stylesChanged = rewriteStyleBlocks(ctx, document, referrerAbsDir, entryPath);
+  if (attrsChanged || stylesChanged) {
+    ctx.fileContents.set(entryPath, Buffer.from(document.toString(), "utf-8"));
+  }
+}
+function localizeCssEntry(ctx, entryPath, content) {
+  const referrerAbsDir = resolve2(ctx.absProjectDir, dirname(entryPath));
+  const css = content.toString("utf-8");
+  if (!css.includes("url(")) return;
+  const result = rewriteCssUrls(ctx, css, referrerAbsDir, entryPath);
+  if (result.modified) {
+    ctx.fileContents.set(entryPath, Buffer.from(result.css, "utf-8"));
+  }
+}
+function localizeExternalAssets(absProjectDir, fileContents) {
+  const ctx = {
+    absProjectDir,
+    fileContents,
+    externalMap: /* @__PURE__ */ new Map(),
+    usedArchivePaths: /* @__PURE__ */ new Set()
+  };
+  for (const [entryPath, content] of [...fileContents.entries()]) {
+    if (entryPath.startsWith(EXT_ASSETS_PREFIX + "/")) continue;
+    if (entryPath.endsWith(".html") || entryPath.endsWith(".htm")) {
+      localizeHtmlEntry(ctx, entryPath, content);
+    } else if (entryPath.endsWith(".css")) {
+      localizeCssEntry(ctx, entryPath, content);
+    }
+  }
+  return ctx.externalMap.size;
+}
+function buildPublishFileMap(projectDir) {
+  const absProjectDir = resolve2(projectDir);
+  const filePaths = [];
+  collectProjectFiles(absProjectDir, absProjectDir, filePaths, createProjectIgnore(absProjectDir));
+  if (!filePaths.includes("index.html")) {
+    throw new Error(
+      "Project archive must include index.html at the root. Check that .hyperframesignore does not exclude it."
+    );
+  }
+  const fileContents = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    fileContents.set(filePath, readFileSync2(join2(absProjectDir, filePath)));
+  }
+  localizeExternalAssets(absProjectDir, fileContents);
+  return fileContents;
+}
+var ARCHIVE_ENTRY_TIME = new Date(1980, 0, 1, 0, 0, 0, 0);
+function zipPublishFileMap(fileContents) {
+  const archive = new AdmZip();
+  for (const [filePath, content] of fileContents) {
+    archive.addFile(filePath, content);
+  }
+  for (const entry of archive.getEntries()) {
+    entry.header.time = ARCHIVE_ENTRY_TIME;
+  }
+  return {
+    buffer: archive.toBuffer(),
+    fileCount: fileContents.size
+  };
+}
+function createPublishArchive(projectDir) {
+  return zipPublishFileMap(buildPublishFileMap(projectDir));
+}
+function getPublishApiBaseUrl() {
+  return (process.env["HYPERFRAMES_PUBLISHED_PROJECTS_API_URL"] || process.env["HEYGEN_API_URL"] || "https://api2.heygen.com").replace(/\/$/, "");
+}
+function archiveArrayBuffer(archive) {
+  const arrayBuffer = new ArrayBuffer(archive.buffer.byteLength);
+  new Uint8Array(arrayBuffer).set(archive.buffer);
+  return arrayBuffer;
+}
+async function publishProjectArchiveDirect(apiBaseUrl, title, archive, isPublic, authHeaders, projectId) {
+  const body = new FormData();
+  body.set("title", title);
+  if (isPublic) body.set("is_public", "true");
+  if (projectId) body.set("project_id", projectId);
+  body.set(
+    "file",
+    new File([archiveArrayBuffer(archive)], `${title}.zip`, { type: PUBLISH_CONTENT_TYPE })
+  );
+  const headers = { ...authHeaders };
+  const response = await fetchForPublish(
+    `${apiBaseUrl}/v1/hyperframes/projects/publish`,
+    () => ({
+      method: "POST",
+      body,
+      headers,
+      signal: AbortSignal.timeout(uploadTimeoutMs(archive.buffer.byteLength))
+    }),
+    "Failed to publish project"
+  );
+  const payload = await readJson(response);
+  const publishedProject = parsePublishedProjectResponse(payload);
+  if (!response.ok || !publishedProject) {
+    throw await metadataRequestError(response, "Failed to publish project");
+  }
+  return publishedProject;
+}
+async function uploadArchiveToPresignedUrl(stagedUpload, archive) {
+  const presignedUrlTtlMs = stagedUpload.expiresInSeconds * 1e3 - PUBLISH_METADATA_TIMEOUT_MS;
+  const s3Response = await fetchForPublish(
+    stagedUpload.uploadUrl,
+    () => ({
+      method: "PUT",
+      body: new Blob([archiveArrayBuffer(archive)], { type: stagedUpload.contentType }),
+      headers: stagedUpload.uploadHeaders,
+      signal: AbortSignal.timeout(
+        Math.min(uploadTimeoutMs(archive.buffer.byteLength), presignedUrlTtlMs)
+      )
+    }),
+    "Failed to upload project archive",
+    PUBLISH_TRANSPORT_ATTEMPTS
+  );
+  if (!s3Response.ok) {
+    throw new Error(await readErrorMessage(s3Response, "Failed to upload project archive"));
+  }
+}
+async function publishProjectArchiveStaged(apiBaseUrl, title, archive, isPublic, authHeaders, projectId) {
+  const fileName = `${title}.zip`;
+  const uploadResponse = await fetchForPublish(
+    `${apiBaseUrl}/v1/hyperframes/projects/publish/upload`,
+    () => ({
+      method: "POST",
+      body: JSON.stringify({
+        file_name: fileName,
+        content_type: PUBLISH_CONTENT_TYPE,
+        content_length: archive.buffer.byteLength
+      }),
+      headers: {
+        ...authHeaders,
+        "content-type": "application/json"
+      },
+      signal: AbortSignal.timeout(PUBLISH_METADATA_TIMEOUT_MS)
+    }),
+    "Failed to prepare project upload",
+    PUBLISH_TRANSPORT_ATTEMPTS
+  );
+  if (uploadResponse.status === 404 || uploadResponse.status === 405) {
+    return null;
+  }
+  const uploadPayload = await readJson(uploadResponse);
+  const stagedUpload = parseStagedUploadResponse(uploadPayload, archive.buffer.byteLength);
+  if (!uploadResponse.ok || !stagedUpload) {
+    throw await metadataRequestError(uploadResponse, "Failed to prepare project upload");
+  }
+  await uploadArchiveToPresignedUrl(stagedUpload, archive);
+  const completeResponse = await fetchForPublish(
+    `${apiBaseUrl}/v1/hyperframes/projects/publish/complete`,
+    () => ({
+      method: "POST",
+      body: JSON.stringify({
+        upload_key: stagedUpload.uploadKey,
+        file_name: fileName,
+        title,
+        ...isPublic ? { is_public: true } : {},
+        ...projectId ? { project_id: projectId } : {}
+      }),
+      headers: {
+        ...authHeaders,
+        "content-type": "application/json"
+      },
+      signal: AbortSignal.timeout(uploadTimeoutMs(archive.buffer.byteLength))
+    }),
+    "Failed to finalize project publish"
+  );
+  const completePayload = await readJson(completeResponse);
+  const publishedProject = parsePublishedProjectResponse(completePayload);
+  if (!completeResponse.ok || !publishedProject) {
+    throw await metadataRequestError(completeResponse, "Failed to publish project");
+  }
+  return publishedProject;
+}
+async function publishProjectArchive(projectDir, opts = {}) {
+  const isPublic = opts.public === true;
+  const title = basename(projectDir);
+  const archive = opts.archive ?? createPublishArchive(projectDir);
+  const apiBaseUrl = getPublishApiBaseUrl();
+  const credential = await resolvePublishCredential(opts.credential);
+  const authHeaders = credential ? buildAuthHeaders(credential) : {};
+  const projectId = credential ? opts.projectId : void 0;
+  const spaceId = credential ? opts.spaceId : void 0;
+  const metadataHeaders = spaceId ? { ...authHeaders, "x-space-id": spaceId } : authHeaders;
+  let result;
+  try {
+    result = await publishProjectArchiveStaged(
+      apiBaseUrl,
+      title,
+      archive,
+      isPublic,
+      metadataHeaders,
+      projectId
+    ) ?? await publishProjectArchiveDirect(
+      apiBaseUrl,
+      title,
+      archive,
+      isPublic,
+      metadataHeaders,
+      projectId
+    );
+    if (credential?.type === "oauth" && !result.claimed) {
+      throw new CredentialRejectedError("unclaimed publish");
+    }
+  } catch (error) {
+    if (error instanceof CredentialRejectedError && credential) {
+      throw new Error(rejectedCredentialMessage(credential));
+    }
+    throw error;
+  }
+  if (result.claimed) {
+    writeProjectLink(projectDir, { projectId: result.projectId, url: result.url });
+  }
+  return result;
+}
+
+export {
+  readProjectLink,
+  ensureProjectId,
+  readTeamProject,
+  writeTeamProject,
+  API_KEY_ENV_VAR,
+  resolvePublishCredential,
+  rewriteHtmlAttributes,
+  buildPublishFileMap,
+  zipPublishFileMap,
+  getPublishApiBaseUrl,
+  publishProjectArchive
+};