@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/producer-ECLEN5RP.js

@@ -0,0 +1,13 @@
+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 {
+  loadProducer
+} from "./chunk-3ZP5DXE7.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  loadProducer
+};

package/vendor/hyperframes/dist/progress-FBIEEB7Y.js

@@ -0,0 +1,73 @@
+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 {
+  requireStack
+} from "./chunk-H4YZZ2VQ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/progress.ts
+async function runProgress(args) {
+  const stack = requireStack(args.stackName);
+  const executionArn = args.target.startsWith("arn:") ? args.target : executionArnFromName(stack.stateMachineArn, args.target);
+  const { getRenderProgress } = await import("@hyperframes/aws-lambda/sdk");
+  const progress = await getRenderProgress({
+    executionArn,
+    region: stack.region,
+    defaultMemorySizeMb: stack.lambdaMemoryMb
+  });
+  if (args.json) {
+    console.log(JSON.stringify(progress, null, 2));
+    return;
+  }
+  const pct = Math.round(progress.overallProgress * 100);
+  console.log(`${c.dim("Status:")}    ${statusColor(progress.status)}`);
+  console.log(`${c.dim("Progress:")}  ${pct}%`);
+  console.log(
+    `${c.dim("Frames:")}    ${progress.framesRendered}${progress.totalFrames === null ? "" : ` / ${progress.totalFrames}`}`
+  );
+  console.log(`${c.dim("Lambdas:")}   ${progress.lambdasInvoked}`);
+  console.log(
+    `${c.dim("Cost:")}      ${progress.costs.displayCost} (Lambda $${progress.costs.breakdown.lambdaUsd.toFixed(4)} + SFN $${progress.costs.breakdown.stepFunctionsUsd.toFixed(4)})`
+  );
+  if (progress.outputFile) {
+    console.log(`${c.dim("Output:")}    ${progress.outputFile.s3Uri}`);
+  }
+  if (progress.errors.length > 0) {
+    console.log();
+    console.log(c.error("Errors:"));
+    for (const err of progress.errors) {
+      console.log(`  ${c.dim(err.state)}: ${err.error} \u2014 ${err.cause}`);
+    }
+  }
+  if (progress.fatalErrorEncountered) {
+    setCommandExitCode(1);
+  }
+}
+function executionArnFromName(stateMachineArn, name) {
+  return stateMachineArn.replace(":stateMachine:", ":execution:") + `:${name}`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "SUCCEEDED":
+      return c.success(status);
+    case "FAILED":
+    case "TIMED_OUT":
+    case "ABORTED":
+      return c.error(status);
+    default:
+      return status;
+  }
+}
+export {
+  runProgress
+};

package/vendor/hyperframes/dist/projectConfig-HYJMJ5BY.js

@@ -0,0 +1,56 @@
+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 {
+  DEFAULT_PROJECT_CONFIG,
+  PROJECT_CONFIG_FILENAME,
+  createProjectConfig,
+  loadProjectConfig,
+  normalizeConfig,
+  projectConfigPath,
+  readProjectConfig,
+  readProjectConfigWithStatus,
+  recordProjectRegistryItems,
+  resolveAutoProxy,
+  seedProjectAuthoringSkill,
+  writeProjectConfig
+} from "./chunk-CFKU7HTK.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-LYNI3FOL.js";
+import "./chunk-CWPVM2QV.js";
+import "./chunk-A2Z4Z4VL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  DEFAULT_PROJECT_CONFIG,
+  PROJECT_CONFIG_FILENAME,
+  createProjectConfig,
+  loadProjectConfig,
+  normalizeConfig,
+  projectConfigPath,
+  readProjectConfig,
+  readProjectConfigWithStatus,
+  recordProjectRegistryItems,
+  resolveAutoProxy,
+  seedProjectAuthoringSkill,
+  writeProjectConfig
+};

package/vendor/hyperframes/dist/publication-HQ5Y3KBM.js

@@ -0,0 +1,29 @@
+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 {
+  publishRegistryFile,
+  registryTargetPath
+} from "./chunk-GMECXFAN.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import {
+  realProjectRoot
+} from "./chunk-OFQWTKPW.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  publishRegistryFile,
+  realProjectRoot as registryRoot,
+  registryTargetPath
+};

package/vendor/hyperframes/dist/publish-VHDYQASC.js

@@ -0,0 +1,430 @@
+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 {
+  API_KEY_ENV_VAR,
+  buildPublishFileMap,
+  ensureProjectId,
+  publishProjectArchive,
+  readProjectLink,
+  readTeamProject,
+  resolvePublishCredential,
+  rewriteHtmlAttributes,
+  writeTeamProject,
+  zipPublishFileMap
+} from "./chunk-JH556Q42.js";
+import "./chunk-ZTZ7NCJT.js";
+import "./chunk-SHB5VDMH.js";
+import "./chunk-I465DBM6.js";
+import "./chunk-X7MTZ4T2.js";
+import {
+  ProxyTranscodeError,
+  TRANSCODE_TIMEOUT_MS,
+  proxyVariantFor,
+  resolveProxy,
+  scanProjectMediaCodecMap,
+  waitForProxy
+} from "./chunk-TCLGPL65.js";
+import {
+  formatLintStartupMessage
+} from "./chunk-6CSYCFQV.js";
+import {
+  resolveAutoProxy
+} from "./chunk-CFKU7HTK.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import {
+  ft,
+  ge,
+  q,
+  ue
+} from "./chunk-WMQNIQDJ.js";
+import "./chunk-LYNI3FOL.js";
+import "./chunk-CWPVM2QV.js";
+import "./chunk-A2Z4Z4VL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import {
+  definitiveEntryMismatchComposition,
+  hasDefinitiveEntryMismatch
+} from "./chunk-Q5X2B5WT.js";
+import {
+  cleanAssetUrl,
+  isRemoteOrInlineUrl,
+  lintProject,
+  resolveLocalAssetCandidates
+} from "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import {
+  rewriteAssetPath
+} from "./chunk-TQFG7HTI.js";
+import {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/publish.ts
+import { join, posix, relative, resolve as resolve2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/publishProxyBake.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { basename, dirname, resolve } from "path";
+var PROXY_ARCHIVE_PREFIX = "_proxy";
+var ProxyBakeError = class extends Error {
+  manifest;
+  constructor(manifest) {
+    const summary = manifest.failed.map((entry) => `${entry.path}: ${entry.error}`).join("; ");
+    super(`Unable to bake required browser media proxies (${summary})`);
+    this.name = "ProxyBakeError";
+    this.manifest = manifest;
+  }
+};
+function emptyManifest() {
+  return { proxied: [], skippedAlpha: [], failed: [] };
+}
+function isHtmlEntry(path) {
+  return path.endsWith(".html") || path.endsWith(".htm");
+}
+async function bakeMediaProxies(projectDir, fileContents) {
+  const manifest = emptyManifest();
+  const absProjectDir = resolve(projectDir);
+  const htmlEntries = [...fileContents.entries()].filter(([path]) => isHtmlEntry(path));
+  if (htmlEntries.length === 0) return manifest;
+  const htmlSources = htmlEntries.map(([entryPath, content]) => ({
+    html: content.toString("utf-8"),
+    compSrcPath: entryPath
+  }));
+  const codecMap = await scanProjectMediaCodecMap(absProjectDir, htmlSources);
+  const hostileEntries = Object.entries(codecMap).filter(([, facts]) => facts.browserHostile);
+  if (hostileEntries.length === 0) return manifest;
+  const proxyByAbsolutePath = /* @__PURE__ */ new Map();
+  await Promise.all(
+    hostileEntries.map(async ([pathname, facts]) => {
+      const absoluteSourcePath = resolve(absProjectDir, pathname.replace(/^\/+/, ""));
+      try {
+        const proxyPath = await waitForProxy(
+          resolveProxy(absProjectDir, absoluteSourcePath, proxyVariantFor(facts)),
+          TRANSCODE_TIMEOUT_MS
+        );
+        const archivePath = `${PROXY_ARCHIVE_PREFIX}/${basename(proxyPath)}`;
+        fileContents.set(archivePath, await readFile(proxyPath));
+        proxyByAbsolutePath.set(absoluteSourcePath, archivePath);
+        manifest.proxied.push(pathname);
+      } catch (err) {
+        const reason = err instanceof ProxyTranscodeError ? err.message : String(err);
+        manifest.failed.push({ path: pathname, error: reason });
+      }
+    })
+  );
+  manifest.proxied.sort();
+  manifest.skippedAlpha.sort();
+  manifest.failed.sort((a, b) => a.path.localeCompare(b.path));
+  if (manifest.failed.length > 0) throw new ProxyBakeError(manifest);
+  if (proxyByAbsolutePath.size === 0) return manifest;
+  for (const [entryPath, content] of htmlEntries) {
+    const { document } = parseHTML(content.toString("utf-8"));
+    const referrerAbsDir = resolve(absProjectDir, dirname(entryPath));
+    const modified = rewriteHtmlAttributes(
+      document,
+      referrerAbsDir,
+      entryPath,
+      (rawValue) => {
+        const cleaned = cleanAssetUrl(rawValue);
+        if (!cleaned || isRemoteOrInlineUrl(cleaned)) return null;
+        const rootRelativeSrc = rewriteAssetPath(
+          entryPath,
+          cleaned,
+          (path) => existsSync(resolve(absProjectDir, path))
+        );
+        for (const candidate of resolveLocalAssetCandidates(absProjectDir, rootRelativeSrc)) {
+          const archivePath = proxyByAbsolutePath.get(candidate);
+          if (archivePath) return archivePath;
+        }
+        return null;
+      },
+      { selector: "video[src]", attrs: ["src"] }
+    );
+    if (modified) fileContents.set(entryPath, Buffer.from(document.toString(), "utf-8"));
+  }
+  return manifest;
+}
+
+// src/commands/publish.ts
+var examples = [
+  ["Publish the current project privately to a stable URL", "hyperframes publish"],
+  ["Publish a specific directory", "hyperframes publish ./my-video"],
+  ["Make the claimed project public to anyone", "hyperframes publish --public"],
+  ["Update an existing published project in place", "hyperframes publish --update <url|id>"],
+  ["Publish to a shared team space", "hyperframes publish --space <space-id>"],
+  ["Skip the consent prompt (scripts)", "hyperframes publish --yes"],
+  ["Skip baking H.264 proxies for browser-hostile video codecs", "hyperframes publish --no-proxy"],
+  ["Show full lint findings instead of the summary line", "hyperframes publish --lint-verbose"]
+];
+function parseUpdateTarget(value) {
+  const trimmed = value.trim();
+  const pathMatch = trimmed.match(/\/p\/([^/?#]+)/);
+  if (pathMatch?.[1]) return pathMatch[1];
+  try {
+    const segment = new URL(trimmed).pathname.split("/").filter(Boolean).pop();
+    if (segment) return segment;
+  } catch {
+  }
+  return trimmed;
+}
+var publish_default = defineCommand({
+  meta: {
+    name: "publish",
+    description: "Upload the project to a stable URL (private by default)"
+  },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip the publish confirmation prompt",
+      default: false
+    },
+    public: {
+      type: "boolean",
+      description: "Make the claimed project public to anyone, not just the claimer",
+      default: false
+    },
+    update: {
+      type: "string",
+      description: "Update an existing published project in place (its URL or id)"
+    },
+    space: {
+      type: "string",
+      description: "Publish into a shared team space (its id) so teammates update one link"
+    },
+    proxy: {
+      type: "boolean",
+      description: "Bake H.264 proxies for browser-hostile video codecs (e.g. HEVC) into the published archive. Default: on, unless disabled via hyperframes.json media.autoProxy. Pass --no-proxy to skip."
+    },
+    "lint-verbose": {
+      type: "boolean",
+      description: "Show full lint findings before publishing (default: a one-line summary)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const rawArg = args.dir;
+    const dir = resolve2(rawArg ?? ".");
+    const indexPath = join(dir, "index.html");
+    if (existsSync2(indexPath)) {
+      const lintResult = await lintProject(dir);
+      const definitiveEntryMismatch = hasDefinitiveEntryMismatch(lintResult);
+      if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
+        console.log();
+        const verbose = Boolean(args["lint-verbose"]) || definitiveEntryMismatch;
+        for (const line of formatLintStartupMessage(
+          lintResult,
+          verbose ? { kind: "verbose" } : { kind: "summary" }
+        ))
+          console.log(line);
+        console.log();
+      }
+      if (definitiveEntryMismatch) {
+        const candidate = definitiveEntryMismatchComposition(lintResult);
+        console.log(c.error("  Aborting publish because the default index.html entry is blank."));
+        if (candidate && posix.basename(candidate) === "index.html") {
+          const candidateDir = posix.dirname(candidate);
+          const target = `<project>/${candidateDir}`;
+          console.log(
+            c.dim(
+              `  Move or mount the authored file, or publish its directory directly: hyperframes publish ${target}. Only use the directory form when its assets are self-contained under that directory; otherwise mount it from the project root.`
+            )
+          );
+        } else if (candidate) {
+          console.log(
+            c.dim(
+              `  Move or mount ${candidate} as a project index.html before publishing; publish accepts project directories, not individual HTML files.`
+            )
+          );
+        }
+        console.log();
+        failCommand();
+      }
+    }
+    if (args.yes !== true) {
+      console.log();
+      if (args.public === true) {
+        console.log(
+          `  ${c.bold("hyperframes publish uploads this project and requests public visibility at a stable URL.")}`
+        );
+        console.log(`  ${c.dim("Anyone with the URL can open a claimed public project.")}`);
+      } else {
+        console.log(
+          `  ${c.bold("hyperframes publish uploads this project privately to a stable URL.")}`
+        );
+        console.log(
+          `  ${c.dim("Viewing requires authentication and access. Pass --public to allow anyone with the URL.")}`
+        );
+      }
+      console.log();
+      const approved = await ue({ message: "Publish this project?" });
+      if (q(approved) || approved !== true) {
+        console.log();
+        console.log(`  ${c.dim("Aborted.")}`);
+        console.log();
+        return;
+      }
+    }
+    const updateTarget = typeof args.update === "string" && args.update.trim() ? parseUpdateTarget(args.update) : void 0;
+    const spaceOverride = typeof args.space === "string" && args.space.trim() ? args.space.trim() : void 0;
+    let credential;
+    try {
+      credential = await resolvePublishCredential();
+    } catch (err) {
+      console.error();
+      console.error(`  ${err.message}`);
+      console.error();
+      setCommandExitCode(1);
+      return;
+    }
+    if (updateTarget || spaceOverride) {
+      if (credential?.type !== "oauth") {
+        const flag = updateTarget ? "--update" : "--space";
+        const envKey = credential?.source === "env" || credential?.source === "env_alias" ? API_KEY_ENV_VAR[credential.source] : void 0;
+        console.log();
+        console.log(
+          `  ${c.error(
+            !credential ? `${flag} requires authentication. Run 'hyperframes auth login' first.` : envKey ? `${flag} requires a login; ${envKey} cannot own a project. Unset it and run 'hyperframes auth login'.` : `${flag} requires a login; an API key cannot own a project. Run 'hyperframes auth login'.`
+          )}`
+        );
+        console.log();
+        setCommandExitCode(1);
+        return;
+      }
+    }
+    const committedTeam = readTeamProject(dir);
+    const requestedProjectId = updateTarget ?? committedTeam?.projectId ?? ensureProjectId(dir);
+    const spaceId = spaceOverride ?? committedTeam?.spaceId;
+    const priorLink = readProjectLink(dir);
+    if (priorLink?.url) {
+      console.log();
+      console.log(`  ${c.dim(`Previously published at ${priorLink.url}`)}`);
+    }
+    ge(c.bold("hyperframes publish"));
+    const publishSpinner = ft();
+    publishSpinner.start("Preparing project...");
+    try {
+      const proxyFlagValue = typeof args.proxy === "boolean" ? args.proxy : void 0;
+      const autoProxy = resolveAutoProxy(dir, proxyFlagValue);
+      const fileMap = buildPublishFileMap(dir);
+      let proxyBakeManifest;
+      if (autoProxy) {
+        proxyBakeManifest = await bakeMediaProxies(dir, fileMap);
+      }
+      const archive = zipPublishFileMap(fileMap);
+      publishSpinner.message("Uploading project...");
+      const published = await publishProjectArchive(dir, {
+        public: args.public === true,
+        projectId: requestedProjectId,
+        spaceId,
+        archive,
+        credential
+      });
+      publishSpinner.stop(c.success("Project published"));
+      console.log();
+      console.log(`  ${c.dim("Project")}              ${c.accent(published.title)}`);
+      console.log(`  ${c.dim("Files")}                ${String(published.fileCount)}`);
+      if (proxyBakeManifest) {
+        console.log(
+          `  ${c.dim("Proxies")}              ${String(proxyBakeManifest.proxied.length)} baked`
+        );
+        if (proxyBakeManifest.skippedAlpha.length > 0) {
+          console.log(
+            `  ${c.dim("Proxy note")}           ${String(proxyBakeManifest.skippedAlpha.length)} alpha source(s) kept original`
+          );
+        }
+      }
+      if (published.claimed) {
+        const updatedInPlace = published.projectId === requestedProjectId;
+        console.log(`  ${c.dim("URL")}                  ${c.accent(published.url)}`);
+        const requestedVisibility = args.public === true ? "Public \u2014 anyone with the URL" : updatedInPlace ? "Unchanged \u2014 keeps this project's current setting" : "Private \u2014 authentication and access required";
+        console.log(`  ${c.dim("Requested visibility")} ${c.accent(requestedVisibility)}`);
+        console.log(
+          `  ${c.dim("Status")}               ${c.accent(updatedInPlace ? "Updated existing project" : "Created new project")}`
+        );
+        if (args.public !== true) {
+          console.log(
+            `  ${c.dim("Tip")}                  ${c.dim("Re-publish with --public to allow anyone with the URL.")}`
+          );
+        }
+        if ((updateTarget || committedTeam) && !updatedInPlace) {
+          const targetDesc = updateTarget ? "The requested project" : "The committed team project";
+          console.log();
+          console.log(
+            `  ${c.dim(`${targetDesc} was not updated (not found, or your space can't access it); a new project was created above instead.`)}`
+          );
+        }
+        if (committedTeam === null || spaceId !== void 0 && committedTeam.spaceId !== spaceId) {
+          try {
+            const file = writeTeamProject(dir, { projectId: published.projectId, spaceId });
+            console.log();
+            console.log(
+              `  ${c.dim(`Wrote ${relative(dir, file) || file} \u2014 commit it so your team publishes to this link.`)}`
+            );
+          } catch {
+          }
+        }
+        console.log();
+      } else {
+        const claimUrl = new URL(published.url);
+        claimUrl.searchParams.set("claim_token", published.claimToken);
+        console.log(`  ${c.dim("Claim URL")}  ${c.accent(claimUrl.toString())}`);
+        console.log(`  ${c.dim("Access")}     ${c.accent("Sign in required to claim")}`);
+        console.log();
+        console.log(
+          `  ${c.dim("Open the claim URL on hyperframes.dev, sign in, and claim the project to continue editing.")}`
+        );
+        console.log();
+        const visibilityTip = args.public === true ? "--public applies to the claimed project; this claim URL still requires sign-in." : "Run 'hyperframes auth login' first for a stable link you can re-publish to; add --public to allow signed-out viewing.";
+        console.log(`  ${c.dim(`Tip: ${visibilityTip}`)}`);
+        console.log();
+      }
+      return;
+    } catch (err) {
+      publishSpinner.stop(c.error("Publish failed"));
+      console.error();
+      console.error(`  ${err.message}`);
+      console.error();
+      setCommandExitCode(1);
+      return;
+    }
+  }
+});
+export {
+  publish_default as default,
+  examples,
+  parseUpdateTarget
+};

package/vendor/hyperframes/dist/refresh-K24ETHMA.js

@@ -0,0 +1,53 @@
+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 "./chunk-ZTZ7NCJT.js";
+import {
+  assertOAuthConfiguredOrExit,
+  isAuthError,
+  readStore,
+  refreshTokens
+} from "./chunk-I465DBM6.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/auth/refresh.ts
+var refresh_default = defineCommand({
+  meta: { name: "refresh", description: "Force-refresh the OAuth access token" },
+  args: {},
+  // fallow-ignore-next-line complexity
+  async run() {
+    assertOAuthConfiguredOrExit();
+    const { credentials, source } = await readStore();
+    if (source === "absent" || !credentials.oauth?.refresh_token) {
+      console.error(c.warn("No OAuth refresh token to use. Run `hyperframes auth login` first."));
+      failCommand();
+    }
+    try {
+      await refreshTokens(credentials.oauth.refresh_token);
+      console.log(c.success("\u2713 Refreshed OAuth access token."));
+    } catch (err) {
+      if (isAuthError(err) && err.code === "REFRESH_FAILED") {
+        console.error(c.error(err.message));
+        if (err.hint) console.error(c.dim(err.hint));
+        failCommand();
+      }
+      throw err;
+    }
+  }
+});
+export {
+  refresh_default as default
+};