@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-IVSUQR2B.js

@@ -0,0 +1,161 @@
+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 {
+  trackLintReport,
+  trackLintRuleStreak
+} from "./chunk-GNEFDLFB.js";
+import {
+  shouldTrack
+} from "./chunk-2UZQHDM7.js";
+import {
+  LINT_RULE_COUNT,
+  LINT_RULE_GROUP_COUNTS
+} from "./chunk-4P7NX5BM.js";
+
+// src/telemetry/lintStreaks.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var STATE_FILE = join(homedir(), ".hyperframes", "lint-streaks.json");
+var UNRESOLVED_REPORT_AT = 3;
+var ENTRY_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var MAX_TRACKED_FILES = 500;
+function emptyState() {
+  return { version: 1, files: {} };
+}
+function readState() {
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+    if (typeof parsed === "object" && parsed !== null && parsed.version === 1 && typeof parsed.files === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return emptyState();
+}
+function writeState(state, now) {
+  const entries = Object.entries(state.files).filter(([, entry]) => now - entry.updatedAt < ENTRY_TTL_MS).sort(([, a], [, b]) => b.updatedAt - a.updatedAt).slice(0, MAX_TRACKED_FILES);
+  try {
+    mkdirSync(join(homedir(), ".hyperframes"), { recursive: true });
+    writeFileSync(
+      STATE_FILE,
+      JSON.stringify({ version: 1, files: Object.fromEntries(entries) }),
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function fileKey(projectDir, file) {
+  return createHash("sha256").update(`${projectDir}\0${file}`).digest("hex").slice(0, 16);
+}
+function recordLintRun(projectDir, results, now = Date.now()) {
+  if (!shouldTrack()) return [];
+  const state = readState();
+  const events = [];
+  for (const { file, contentHash, findings } of results) {
+    const key = fileKey(projectDir, file);
+    const previous = state.files[key];
+    const severityByCode = firstSeverityPerCode(findings);
+    const codes = !previous || previous.contentHash === contentHash ? carryForward(previous, severityByCode) : foldEdit(previous, severityByCode, events);
+    state.files[key] = { contentHash, codes, updatedAt: now };
+  }
+  writeState(state, now);
+  return events;
+}
+function firstSeverityPerCode(findings) {
+  const severityByCode = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    if (!severityByCode.has(finding.code)) severityByCode.set(finding.code, finding.severity);
+  }
+  return severityByCode;
+}
+function carryForward(previous, severityByCode) {
+  const codes = {};
+  for (const [code, severity] of severityByCode) {
+    codes[code] = previous?.codes[code] ?? { edits: 0, reported: false, severity };
+  }
+  return codes;
+}
+function foldEdit(previous, severityByCode, events) {
+  const codes = {};
+  for (const [code, severity] of severityByCode) {
+    const prior = previous.codes[code];
+    if (!prior) {
+      codes[code] = { edits: 0, reported: false, severity };
+      continue;
+    }
+    const edits = prior.edits + 1;
+    const shouldReport = !prior.reported && edits >= UNRESOLVED_REPORT_AT;
+    if (shouldReport) events.push({ code, severity, edits, cleared: false });
+    codes[code] = { edits, reported: prior.reported || shouldReport, severity };
+  }
+  for (const [code, prior] of Object.entries(previous.codes)) {
+    if (severityByCode.has(code)) continue;
+    events.push({ code, severity: prior.severity, edits: prior.edits + 1, cleared: true });
+  }
+  return codes;
+}
+
+// src/telemetry/lintRun.ts
+function trackLintRun(projectDir, lintResult, options) {
+  try {
+    const runIdField = options.runId !== void 0 ? { runId: options.runId } : {};
+    trackLintReport({
+      command: options.command,
+      durationMs: options.durationMs,
+      filesScanned: lintResult.results.length,
+      errorCount: lintResult.totalErrors,
+      warningCount: lintResult.totalWarnings,
+      infoCount: lintResult.totalInfos,
+      ruleCount: LINT_RULE_COUNT,
+      ruleGroupCounts: LINT_RULE_GROUP_COUNTS,
+      ...summarize(lintResult),
+      ...runIdField
+    });
+    const streaks = recordLintRun(
+      projectDir,
+      lintResult.results.map(({ file, contentHash, result }) => ({
+        file,
+        contentHash,
+        findings: result.findings
+      }))
+    );
+    for (const streak of streaks) {
+      trackLintRuleStreak({ ...streak, command: options.command, ...runIdField });
+    }
+  } catch {
+  }
+}
+function summarize(lintResult) {
+  const codeCounts = {};
+  const ruleGroupMs = {};
+  let slowestRule = "";
+  let slowestRuleMs = 0;
+  for (const { result } of lintResult.results) {
+    for (const finding of result.findings) {
+      codeCounts[finding.code] = (codeCounts[finding.code] ?? 0) + 1;
+    }
+    const timings = result.timings;
+    if (!timings) continue;
+    for (const [group, ms] of Object.entries(timings.groupMs)) {
+      ruleGroupMs[group] = (ruleGroupMs[group] ?? 0) + ms;
+    }
+    if (timings.slowestRuleMs > slowestRuleMs) {
+      slowestRuleMs = timings.slowestRuleMs;
+      slowestRule = timings.slowestRule;
+    }
+  }
+  for (const group of Object.keys(ruleGroupMs)) {
+    ruleGroupMs[group] = Math.round(ruleGroupMs[group]);
+  }
+  return { codeCounts, ruleGroupMs, slowestRule, slowestRuleMs };
+}
+
+export {
+  trackLintRun
+};

package/vendor/framey/dist/chunk-IXU6PQSW.js

@@ -0,0 +1,259 @@
+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 {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import {
+  DEFAULT_HISTORY_ROOT,
+  HistoryBusyError,
+  MAX_WINDOW_IDLE_MS,
+  openProjectHistory,
+  readProjectHistory
+} from "./chunk-YPRBGITP.js";
+import {
+  findPreviewServerForProject,
+  studioApiUrl
+} from "./chunk-DQBY7FRR.js";
+
+// src/utils/historyOwner.ts
+import { randomUUID } from "crypto";
+import {
+  accessSync,
+  constants,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, resolve } from "path";
+var historyDeps = {
+  historyRoot: resolve(process.env.HYPERFRAMES_HISTORY_ROOT || DEFAULT_HISTORY_ROOT),
+  findServer: (projectDir) => findPreviewServerForProject(projectDir),
+  /** A turn with no write for this long has ended, through a preview or not. */
+  turnIdleMs: MAX_WINDOW_IDLE_MS,
+  ownerWaitMs: void 0,
+  now: () => Date.now()
+};
+var Refusal = class extends Error {
+};
+var turnFile = (dir) => join(dir, ".hyperframes", "history-turn.json");
+function readTurn(dir) {
+  try {
+    const turn = JSON.parse(readFileSync(turnFile(dir), "utf-8"));
+    return typeof turn.lastWriteAt === "number" ? { ...turn, parts: turn.parts ?? [] } : null;
+  } catch {
+    return null;
+  }
+}
+function writeTurn(dir, turn) {
+  if (!turn) return rmSync(turnFile(dir), { force: true });
+  mkdirSync(dirname(turnFile(dir)), { recursive: true });
+  writeFileSync(turnFile(dir), JSON.stringify(turn));
+}
+var lastTurnsFile = (dir) => join(dir, ".hyperframes", "history-turns.json");
+function readLastTurns(dir) {
+  try {
+    const turns = JSON.parse(readFileSync(lastTurnsFile(dir), "utf-8"));
+    return turns && typeof turns === "object" ? turns : {};
+  } catch {
+    return {};
+  }
+}
+function lastTurnParts(dir, name) {
+  return readLastTurns(dir)[name] ?? null;
+}
+var samePart = (a, b) => a.who.kind === b.who.kind && a.who.name === b.who.name && a.label === b.label && a.startedAt === b.startedAt;
+async function endTurn(owner, turn, dir) {
+  const entry = await owner.end(turn.id);
+  const cut = (await owner.list()).filter((other) => samePart(other, entry ?? turn));
+  const own = entry ? [entry.id] : [];
+  const parts = [.../* @__PURE__ */ new Set([...turn.parts, ...cut.map((part) => part.id), ...own])];
+  const draft = `${lastTurnsFile(dir)}.${process.pid}.tmp`;
+  mkdirSync(dirname(draft), { recursive: true });
+  writeFileSync(draft, JSON.stringify({ ...readLastTurns(dir), [turn.who.name]: parts }));
+  renameSync(draft, lastTurnsFile(dir));
+  writeTurn(dir, null);
+  return { entry, parts };
+}
+function previewOwner(route) {
+  const call = async (path, body, signal) => {
+    const init = {
+      ...body && {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      },
+      ...signal && { signal }
+    };
+    const response = await fetch(route(path), init);
+    if (response.ok) return response;
+    const error = await response.json().catch(() => null);
+    throw new Refusal(error?.error ?? `The preview answered ${response.status}.`);
+  };
+  const json = async (path, body, signal) => (await call(path, body, signal)).json();
+  const list = async () => (await json("")).entries;
+  return {
+    via: "preview",
+    list,
+    peek: async (point) => (await json(`/peek/${encodeURIComponent(point)}`)).files,
+    blob: async (hash) => Buffer.from(await (await call(`/blob/${hash}`)).arrayBuffer()),
+    undo: (id, who, mode) => json("/undo", { entryId: id, who, mode }),
+    restore: (point, who) => json("/restore", { point, who }),
+    pin: async (id, pinned) => void await json("/pin", { entryId: id, pinned }),
+    begin: async (who, label, exclusive) => {
+      const opened = await json("/window", {
+        who,
+        label,
+        idleMs: historyDeps.turnIdleMs,
+        ...exclusive && { exclusive: true }
+      });
+      return { id: opened.windowId, startedAt: opened.startedAt ?? historyDeps.now() };
+    },
+    // A preview restarted since begin committed the window on its way down.
+    end: (id) => json(`/window/${id}/close`, {}).then((closed) => closed.entry).catch(async () => (await list()).find((entry) => entry.id === id) ?? null),
+    checkpoint: async () => void await json("/checkpoint", {}, AbortSignal.timeout(5e3)),
+    close: async () => {
+    }
+  };
+}
+async function directOwner(projectDir, ownerWaitMs = historyDeps.ownerWaitMs) {
+  let turn = null;
+  const history = await openProjectHistory({
+    projectDir,
+    historyRoot: historyDeps.historyRoot,
+    now: () => historyDeps.now(),
+    pruneGoneProjectsBudgetMs: 1e3,
+    ownerWaitMs,
+    closedWindowAfterOwnership: () => {
+      turn = readTurn(projectDir);
+      return turn ? {
+        id: turn.id,
+        who: turn.who,
+        label: turn.label,
+        startedAt: turn.startedAt,
+        lastWriteAt: turn.lastWriteAt,
+        idleMs: historyDeps.turnIdleMs
+      } : void 0;
+    }
+  });
+  return {
+    turn,
+    owner: {
+      via: "direct",
+      list: async () => history.list(),
+      peek: async (point) => history.peek(point),
+      blob: (hash) => history.readBlob(hash),
+      undo: (id, who, mode) => history.undo(id, { who, ...mode && { mode } }),
+      restore: (point, who) => history.restore(point, who),
+      pin: async (id, pinned) => history.pin(id, pinned),
+      // Opening filed every earlier write; the turn's own writes are filed to it when the next open passes it.
+      begin: async () => ({ id: randomUUID(), startedAt: historyDeps.now() }),
+      end: async (id) => history.list().find((entry) => entry.id === id) ?? null,
+      checkpoint: () => history.checkpoint(),
+      close: () => history.close()
+    }
+  };
+}
+async function connect(projectDir, ownerWaitMs) {
+  const server = await historyDeps.findServer(projectDir);
+  if (server) {
+    const route = (path) => studioApiUrl(server, `history${path}`);
+    const status = await fetch(route("")).then(
+      (response) => response.status,
+      () => 404
+    );
+    if (status !== 404) return { owner: previewOwner(route), turn: readTurn(projectDir) };
+  }
+  return directOwner(projectDir, ownerWaitMs);
+}
+async function withOwner(dir, task, { ownerWaitMs } = {}) {
+  const { dir: projectDir } = resolveProject(dir);
+  const { owner, turn } = await connect(projectDir, ownerWaitMs);
+  try {
+    return await task(owner, turn, projectDir);
+  } finally {
+    try {
+      if (owner.via === "direct" && turn) {
+        const kept = (await owner.list()).find((entry) => entry.id === turn.id);
+        if (readTurn(projectDir)?.id === turn.id) {
+          const lastWriteAt = kept ? kept.endedAt : turn.lastWriteAt;
+          const parts = kept ? [...turn.parts, kept.id] : turn.parts;
+          writeTurn(projectDir, { ...turn, via: "direct", id: randomUUID(), lastWriteAt, parts });
+        }
+      }
+    } finally {
+      await owner.close();
+    }
+  }
+}
+var CANNOT_WRITE = /* @__PURE__ */ new Set(["ENOSPC", "EDQUOT", "EACCES", "EPERM", "EROFS"]);
+var WRITE_CALLS = /* @__PURE__ */ new Set([
+  "mkdir",
+  "write",
+  "rename",
+  "unlink",
+  "link",
+  "copyfile",
+  "rmdir",
+  "symlink",
+  "utime",
+  "ftruncate",
+  "fsync"
+]);
+function openedForWriting(path) {
+  try {
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+}
+function failedWrite(error) {
+  const { code = "", syscall = "", path } = error;
+  if (!CANNOT_WRITE.has(code)) return false;
+  return WRITE_CALLS.has(syscall) || syscall === "open" && path !== void 0 && openedForWriting(path);
+}
+async function withReader(dir, task) {
+  let ran = false;
+  try {
+    return await withOwner(dir, (owner) => {
+      ran = true;
+      return task(owner);
+    });
+  } catch (error) {
+    const unwritable = failedWrite(error);
+    if (ran || !(error instanceof HistoryBusyError || unwritable)) throw error;
+    if (unwritable)
+      console.error(
+        `[hyperframes] Could not write this project's history (${error.message}); showing it as last recorded.`
+      );
+  }
+  const view = readProjectHistory({
+    projectDir: resolveProject(dir).dir,
+    historyRoot: historyDeps.historyRoot
+  });
+  return task({
+    via: "direct",
+    list: async () => view.list(),
+    peek: async (point) => view.peek(point),
+    // The owner may have pruned a blob since its log was read.
+    blob: (hash) => view.readBlob(hash).catch((error) => {
+      throw error.code === "ENOENT" ? new Refusal("That point is no longer kept") : error;
+    })
+  });
+}
+
+export {
+  historyDeps,
+  Refusal,
+  writeTurn,
+  lastTurnParts,
+  endTurn,
+  withOwner,
+  withReader
+};

package/vendor/framey/dist/chunk-IZCW2NKT.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);
+
+// ../parsers/dist/mediaAlpha.js
+var ALPHA_PIX_FMT_RE = /^(?:yuva|rgba|argb|bgra|abgr|gbrap|ya|ayuv)/i;
+function pixelFormatHasAlpha(pixFmt) {
+  return pixFmt !== void 0 && ALPHA_PIX_FMT_RE.test(pixFmt);
+}
+function videoStreamHasAlpha(stream) {
+  if (pixelFormatHasAlpha(stream.pix_fmt)) return true;
+  return Object.entries(stream.tags ?? {}).some(
+    ([key, value]) => key.toLowerCase() === "alpha_mode" && value === "1"
+  );
+}
+function alphaDecoderFor(codecName) {
+  const codec = codecName?.toLowerCase();
+  if (codec === "vp9") return "libvpx-vp9";
+  if (codec === "vp8") return "libvpx";
+  return null;
+}
+
+export {
+  videoStreamHasAlpha,
+  alphaDecoderFor
+};

package/vendor/framey/dist/chunk-JGXJU5PF.js

@@ -0,0 +1,68 @@
+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 {
+  c
+} from "./chunk-VORQIH64.js";
+
+// src/utils/lintFormat.ts
+function formatLintFindings({ results, totalErrors, totalWarnings, totalInfos }, options = {}) {
+  const {
+    showElementId = true,
+    showSummary = false,
+    errorsFirst = false,
+    verbose = false
+  } = options;
+  const lines = [];
+  const multiFile = results.length > 1;
+  for (const { file, result } of results) {
+    if (result.findings.length === 0) continue;
+    const format = (finding) => {
+      if (!verbose && finding.severity === "info") return;
+      const prefix = finding.severity === "error" ? c.error("\u2717") : finding.severity === "warning" ? c.warn("\u26A0") : c.dim("\u2139");
+      const fileLabel = findingFileLabel(file, finding, multiFile);
+      const loc = showElementId && finding.elementId ? ` ${c.accent(`[${finding.elementId}]`)}` : "";
+      lines.push(`  ${prefix} ${fileLabel}${c.bold(finding.code)}${loc}: ${finding.message}`);
+      if (finding.fixHint) lines.push(`    ${c.dim(`Fix: ${finding.fixHint}`)}`);
+    };
+    if (errorsFirst) {
+      for (const f of result.findings) if (f.severity === "error") format(f);
+      for (const f of result.findings) if (f.severity === "warning") format(f);
+      if (verbose) {
+        for (const f of result.findings) if (f.severity === "info") format(f);
+      }
+    } else {
+      for (const f of result.findings) format(f);
+    }
+  }
+  if (showSummary) {
+    const icon = totalErrors > 0 ? c.error("\u25C7") : c.success("\u25C7");
+    lines.push("");
+    lines.push(`${icon}  ${formatLintCounts(totalErrors, totalWarnings, totalInfos, verbose)}`);
+  }
+  return lines;
+}
+function formatLintCounts(totalErrors, totalWarnings, totalInfos, verbose) {
+  const parts = [`${totalErrors} error(s)`, `${totalWarnings} warning(s)`];
+  if (verbose && totalInfos > 0) parts.push(`${totalInfos} info(s)`);
+  return parts.join(", ");
+}
+function formatLintStartupMessage(lintResult, mode) {
+  if (mode.kind === "verbose") return formatLintFindings(lintResult, mode.options);
+  const counts = formatLintCounts(lintResult.totalErrors, lintResult.totalWarnings, 0, false);
+  const hint = mode.pointer === "studio" ? "see the Lint badge in Studio, or run `framey lint` for full output" : "run with --lint-verbose for full output";
+  return [`  Lint: ${counts} \u2014 ${hint}.`];
+}
+function findingFileLabel(file, finding, multiFile) {
+  if (finding.line === void 0) return multiFile ? c.dim(`[${file}] `) : "";
+  const column = finding.column === void 0 ? "" : `:${finding.column}`;
+  return c.dim(`[${finding.file ?? file}:${finding.line}${column}] `);
+}
+
+export {
+  formatLintFindings,
+  formatLintStartupMessage
+};

package/vendor/framey/dist/chunk-JHOCK3DG.js

@@ -0,0 +1,27 @@
+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);
+
+// src/utils/concurrency.ts
+async function runWithConcurrencyLimit(inputs, limit, worker) {
+  if (limit < 1) throw new Error(`runWithConcurrencyLimit: limit must be \u2265 1, got ${limit}`);
+  const results = new Array(inputs.length);
+  let cursor = 0;
+  const workerCount = Math.min(limit, inputs.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (cursor < inputs.length) {
+        const idx = cursor++;
+        results[idx] = await worker(inputs[idx], idx);
+      }
+    })
+  );
+  return results;
+}
+
+export {
+  runWithConcurrencyLimit
+};

package/vendor/framey/dist/chunk-JVBRJMOP.js

@@ -0,0 +1,121 @@
+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);
+
+// src/utils/commandResult.ts
+var SUCCESS_RESULT = { exitCode: 0, kind: "success" };
+var pendingResult = SUCCESS_RESULT;
+var rootExitRequester;
+var rootExitCodeSanitizer;
+var CliUsageError = class extends Error {
+  result;
+  constructor(message = "Invalid command usage", options = {}) {
+    super(message);
+    this.name = "CliUsageError";
+    this.result = {
+      exitCode: options.exitCode ?? 1,
+      kind: "usage_error",
+      presented: options.presented
+    };
+  }
+};
+var CliRuntimeError = class extends Error {
+  result;
+  constructor(message = "Command failed", options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "CliRuntimeError";
+    this.result = {
+      exitCode: options.exitCode ?? 1,
+      kind: "runtime_error",
+      presented: options.presented
+    };
+  }
+};
+var CliResultSignal = class extends Error {
+  result;
+  constructor(result) {
+    super(`CLI result ${result.exitCode}`);
+    this.name = "CliResultSignal";
+    this.result = result;
+  }
+};
+function failCommand(exitCode = 1, cause) {
+  throw new CliRuntimeError("Command failed", { exitCode, presented: true, cause });
+}
+function failUsage(exitCode = 1) {
+  throw new CliUsageError("Invalid command usage", { exitCode, presented: true });
+}
+function finishCommand(exitCode = 0) {
+  throw new CliResultSignal({
+    exitCode,
+    kind: exitCode === 0 ? "success" : "runtime_error",
+    presented: true
+  });
+}
+function setCommandResult(result) {
+  if (pendingResult.exitCode !== 0 && result.exitCode === 0) return;
+  pendingResult = result;
+}
+function setCommandExitCode(exitCode) {
+  setCommandResult({
+    exitCode,
+    kind: exitCode === 0 ? "success" : "runtime_error",
+    presented: true
+  });
+}
+function consumeCommandResult() {
+  const result = pendingResult;
+  pendingResult = SUCCESS_RESULT;
+  return result;
+}
+function registerRootExitRequester(requester) {
+  rootExitRequester = requester;
+}
+function registerRootExitCodeSanitizer(sanitizer) {
+  rootExitCodeSanitizer = sanitizer;
+}
+function sanitizeSuccessfulExitCode() {
+  rootExitCodeSanitizer?.();
+}
+async function outputWritten() {
+  const written = (stream) => new Promise((resolve) => stream.write("", () => resolve()));
+  await Promise.all([written(process.stdout), written(process.stderr)]);
+}
+function requestCliExit(exitCode = 0) {
+  if (!rootExitRequester) {
+    setCommandResult({
+      exitCode,
+      kind: exitCode === 0 ? "success" : "runtime_error",
+      presented: true
+    });
+    return;
+  }
+  rootExitRequester(exitCode);
+}
+function isUnrefableTimer(timer) {
+  return typeof timer === "object" && timer !== null && "unref" in timer && typeof timer.unref === "function";
+}
+function scheduleCliExit(exitCode = 0) {
+  const timer = setTimeout(() => requestCliExit(exitCode), 100);
+  if (isUnrefableTimer(timer)) timer.unref();
+}
+
+export {
+  CliUsageError,
+  CliRuntimeError,
+  CliResultSignal,
+  failCommand,
+  failUsage,
+  finishCommand,
+  setCommandExitCode,
+  consumeCommandResult,
+  registerRootExitRequester,
+  registerRootExitCodeSanitizer,
+  sanitizeSuccessfulExitCode,
+  outputWritten,
+  requestCliExit,
+  scheduleCliExit
+};

package/vendor/framey/dist/chunk-K4MJX7SR.js

@@ -0,0 +1,17 @@
+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);
+
+// ../core/dist/browserMarker.js
+var HYPERFRAMES_BROWSER_MARKER_ARG = "--hyperframes-owned-browser";
+function withHyperframesBrowserMarker(args = []) {
+  return args.includes(HYPERFRAMES_BROWSER_MARKER_ARG) ? [...args] : [...args, HYPERFRAMES_BROWSER_MARKER_ARG];
+}
+
+export {
+  HYPERFRAMES_BROWSER_MARKER_ARG,
+  withHyperframesBrowserMarker
+};