catherd-cli 1.5.0 → 2.0.0-beta.20261022113309

package/src/services/scorecard.ts

@@ -0,0 +1,382 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { z } from "zod";
+import { CatherdError } from "../domain/errors.ts";
+import { latestOutcomes } from "../domain/route.ts";
+import {
+  assertLabel,
+  SCORECARD_TASKS,
+  assertScorecardRows,
+  type ScorecardFile,
+  ScorecardFileSchema,
+  type ScorecardTask,
+  ScorecardTaskSchema,
+  type ScorecardTaskId,
+  type TaskScore,
+} from "../domain/scorecard.ts";
+import { assetPath } from "../infra/assets.ts";
+import { git, gitHead } from "../infra/git.ts";
+import { dataDir } from "../infra/paths.ts";
+import { ensurePrivateDir, readVersioned, writeJsonAtomic } from "../infra/store.ts";
+import { landedMilestones, reviewRounds } from "./milestones.ts";
+import { checkEnvFor, runCheck } from "./preflight.ts";
+import { runMilestones } from "./protocol.ts";
+import { openQuestions } from "./questions.ts";
+import {
+  findRun,
+  listRuns,
+  readAgentRuns,
+  readOutcomes,
+  readRecords,
+  type Run,
+  supersededBy,
+} from "./run-store.ts";
+import { failoverRecovered, interventionsOf, pausedMs, runEnd } from "./scorecard-metrics.ts";
+import { quotaByBackend } from "./summary.ts";
+
+// Plan 28: prepare a scorecard task's reproducible starting point, score the run that ended there, store the row.
+
+/** The checkout's `scorecard/` folder, or null for an installed package (it ships no fixtures). */
+export const scorecardRoot = (): string | null => {
+  const root = assetPath("scorecard");
+  return existsSync(root) ? root : null;
+};
+
+export const defaultPreparedRoot = (): string => join(dataDir(), "scorecard");
+
+const minutes = (ms: number): number => Math.round(ms / 6000) / 10;
+
+export function loadTask(id: string, root: string): ScorecardTask {
+  if (!(SCORECARD_TASKS as readonly string[]).includes(id))
+    throw new CatherdError("E_INPUT_INVALID", `no scorecard task ${id}`, {
+      fix: `catherd scorecard prepare ${SCORECARD_TASKS.join("|")}`,
+    });
+  const file = join(root, "tasks", id, "task.json");
+  const task = readVersioned(file, ScorecardTaskSchema, 1);
+  if (task.id !== id)
+    throw new CatherdError("E_CONFIG_INVALID", `${file} names task ${task.id}, not ${id}`, {
+      fix: `set "id" to ${id} in ${file}`,
+    });
+  return task;
+}
+
+const PreparedSchema = z.looseObject({
+  schema: z.literal(1),
+  task: z.enum(SCORECARD_TASKS),
+  dir: z.string(),
+  repo: z.string(),
+  plan: z.string(),
+  startCommit: z.string(),
+  limits: z.string().nullable(),
+  shim: z.string().nullable(),
+  preparedAt: z.string(),
+  prompt: z.string(),
+});
+export type Prepared = z.infer<typeof PreparedSchema> & { task: ScorecardTaskId };
+
+/** A URL (`scheme://`) or an scp-like `user@host:path`: anything else is a local path. */
+const REMOTE = /^(?:[a-z][a-z0-9+.-]*:\/\/|[^/\s]+@[^/\s:]+:)/i;
+
+const GIT_LONG = 30 * 60_000;
+
+/** A git command that must succeed: its failure is `fail`'s error. */
+async function must(
+  repo: string,
+  args: string[],
+  fail: () => CatherdError,
+  timeoutMs?: number,
+): Promise<string> {
+  const r = await git(repo, args, timeoutMs);
+  if (r.kind !== "ok") throw fail();
+  return r.out;
+}
+
+export async function prepareTask(i: {
+  task: ScorecardTask;
+  root: string;
+  into: string;
+  source?: string;
+  now: Date;
+  setup: boolean;
+}): Promise<Prepared> {
+  const { task } = i;
+  const given = i.source ?? task.source;
+  if (!given)
+    throw new CatherdError("E_INPUT_INVALID", `${task.id} names no source`, {
+      fix: `catherd scorecard prepare ${task.id} --source <path or URL>`,
+    });
+  // the clone runs inside the new folder, so a local path must be absolute before it gets there
+  const src = REMOTE.test(given) ? given : resolve(given);
+  ensurePrivateDir(dirname(i.into));
+  try {
+    mkdirSync(i.into);
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "EEXIST")
+      throw new CatherdError("E_INPUT_INVALID", `${i.into} already exists`, {
+        fix: "prepare again: the folder name carries the time",
+      });
+    throw e;
+  }
+  // the run's own repo toplevel is the real path; findRun and listRuns key runs by it
+  const into = realpathSync(i.into);
+  const repo = join(into, "repo");
+  const io = (what: string) => () =>
+    new CatherdError("E_IO_UNEXPECTED", `${what} failed in ${into}`, {
+      fix: `check that git works in ${into}`,
+    });
+  await must(
+    into,
+    ["clone", "--quiet", "--no-checkout", src, "repo"],
+    () =>
+      new CatherdError("E_INPUT_INVALID", `cannot clone ${src}`, {
+        fix: `catherd scorecard prepare ${task.id} --source <path or URL>`,
+      }),
+    GIT_LONG,
+  );
+  await must(
+    repo,
+    ["checkout", "--quiet", "-b", `scorecard/${task.id}`, task.commit],
+    () =>
+      new CatherdError("E_INPUT_INVALID", `${src} has no commit ${task.commit}`, {
+        fix: `catherd scorecard prepare ${task.id} --source <a clone that has it>`,
+      }),
+  );
+  await must(repo, ["remote", "remove", "origin"], io("git remote remove"));
+
+  if (task.inject) {
+    for (const e of task.inject.edits) {
+      const file = join(repo, e.path);
+      const text = existsSync(file) ? readFileSync(file, "utf8") : "";
+      const parts = text.split(e.find);
+      if (parts.length !== 2)
+        throw new CatherdError(
+          "E_CONFIG_INVALID",
+          `${e.path}: the inject text is there ${parts.length - 1} times, not once`,
+          {
+            fix: `update scorecard/tasks/${task.id}/task.json`,
+          },
+        );
+      writeFileSync(file, parts.join(e.replace));
+    }
+    await must(repo, ["add", "-A"], io("git add"));
+    await must(
+      repo,
+      [
+        "-c",
+        "user.name=catherd-scorecard",
+        "-c",
+        "user.email=scorecard@catherd.invalid",
+        "commit",
+        "--quiet",
+        "-m",
+        task.inject.message,
+      ],
+      io("git commit"),
+    );
+  }
+
+  let plan: string;
+  if ("file" in task.plan) {
+    plan = join(into, "plan.md");
+    copyFileSync(join(i.root, "tasks", task.id, task.plan.file), plan);
+  } else {
+    plan = join(repo, task.plan.repoPath);
+    if (!existsSync(plan))
+      throw new CatherdError("E_CONFIG_INVALID", `${task.plan.repoPath} is not in ${src} at ${task.commit}`, {
+        fix: `update scorecard/tasks/${task.id}/task.json`,
+      });
+  }
+
+  let limits: string | null = null;
+  if (task.limits > 0) {
+    limits = join(into, "limits");
+    mkdirSync(join(limits, "taken"), { recursive: true });
+    mkdirSync(join(limits, "tokens"));
+    for (let n = 1; n <= task.limits; n++)
+      writeFileSync(join(limits, "tokens", String(n)), "", { flag: "w" });
+  }
+
+  if (i.setup) {
+    const env = await checkEnvFor(repo);
+    for (const cmd of task.setup) {
+      const r = await runCheck(repo, cmd, GIT_LONG, env);
+      if (r.code !== 0 || r.timedOut)
+        throw new CatherdError(
+          "E_IO_UNEXPECTED",
+          `setup \`${cmd}\` failed in ${repo}: ${r.tail.at(-1) ?? "no output"}`,
+          {
+            fix: `fix it and run it in ${repo}, or prepare again`,
+          },
+        );
+    }
+  }
+
+  const startCommit = (await must(repo, ["rev-parse", "HEAD"], io("git rev-parse"))).trim();
+  const prepared: Prepared = {
+    schema: 1,
+    task: task.id,
+    dir: into,
+    repo,
+    plan,
+    startCommit,
+    limits,
+    shim: limits ? join(i.root, "shim") : null,
+    preparedAt: i.now.toISOString(),
+    prompt: task.prompt.replaceAll("{plan}", () => plan).replaceAll("{acceptance}", () => task.acceptance),
+  };
+  writeJsonAtomic(join(into, "prepared.json"), prepared);
+  return prepared;
+}
+
+export function readPrepared(dir: string): Prepared {
+  const file = join(dir, "prepared.json");
+  if (!existsSync(file))
+    throw new CatherdError("E_INPUT_INVALID", `${dir} is not a prepared scorecard task`, {
+      fix: `catherd scorecard prepare ${SCORECARD_TASKS.join("|")}`,
+    });
+  return readVersioned(file, PreparedSchema, 1) as Prepared;
+}
+
+/** The one run to score: the named one, else the only open run created in the prepared repo since it was prepared. */
+function pickRun(p: Prepared, id: string | undefined): Run {
+  if (id) {
+    const run = findRun(id);
+    if (run.meta.repo !== p.repo)
+      throw new CatherdError("E_INPUT_INVALID", `run ${id} belongs to ${run.meta.repo}, not ${p.repo}`, {
+        fix: "name a run of the prepared repo, or leave --run out",
+      });
+    return run;
+  }
+  const since = Date.parse(p.preparedAt);
+  const runs = listRuns([p.repo]).runs.filter(
+    (r) => Date.parse(r.meta.createdAt) >= since && !supersededBy(r),
+  );
+  if (runs.length === 0)
+    throw new CatherdError("E_INPUT_INVALID", `no run in ${p.repo} yet`, {
+      fix: "run the task's start line, paste its prompt, and record once it has landed or been given up",
+    });
+  if (runs.length > 1)
+    throw new CatherdError("E_INPUT_INVALID", `${p.repo} has runs ${runs.map((r) => r.id).join(", ")}`, {
+      fix: `catherd scorecard record ${p.dir} --label <l> --run <id>`,
+    });
+  return runs[0] as Run;
+}
+
+export async function scoreTask(i: {
+  dir: string;
+  root: string;
+  run?: string;
+  chat?: number;
+  now: number;
+}): Promise<TaskScore> {
+  const p = readPrepared(i.dir);
+  const task = loadTask(p.task, i.root);
+  const run = pickRun(p, i.run);
+  const milestones = runMilestones(run);
+  const landed = landedMilestones(run);
+  const finished =
+    milestones.length > 0 &&
+    milestones.every((m) => landed.includes(m)) &&
+    openQuestions(run).length === 0 &&
+    !supersededBy(run);
+  const end = runEnd(run);
+  const start = Date.parse(run.meta.createdAt);
+
+  const copies = task.acceptFiles.map((f) => ({
+    from: join(i.root, "tasks", task.id, f.from),
+    to: join(p.repo, f.to),
+  }));
+  for (const c of copies)
+    if (existsSync(c.to))
+      throw new CatherdError(
+        "E_INPUT_INVALID",
+        `${c.to.slice(p.repo.length + 1)} already exists in the run's tree`,
+        {
+          fix: "the run wrote a file the hidden acceptance test needs; rename the file in the run, or score it by hand",
+        },
+      );
+  const done: string[] = [];
+  let check: Awaited<ReturnType<typeof runCheck>>;
+  const head = await gitHead(p.repo);
+  try {
+    for (const c of copies) {
+      mkdirSync(dirname(c.to), { recursive: true });
+      copyFileSync(c.from, c.to);
+      done.push(c.to);
+    }
+    check = await runCheck(
+      p.repo,
+      task.acceptance,
+      task.acceptanceTimeoutMin * 60_000,
+      await checkEnvFor(p.repo),
+    );
+  } finally {
+    for (const f of done) rmSync(f, { force: true });
+  }
+  const acceptance = {
+    passed: check.code === 0 && !check.timedOut,
+    code: check.code,
+    timedOut: check.timedOut,
+    tail: check.tail,
+  };
+
+  const outcomes = latestOutcomes(readOutcomes(run));
+  const takenDir = p.limits ? join(p.limits, "taken") : null;
+  return {
+    task: task.id,
+    run: run.id,
+    catherdVersion: run.meta.catherdVersion,
+    startCommit: p.startCommit,
+    head,
+    milestones,
+    landed,
+    finished,
+    interventions: interventionsOf(run, end, i.chat ?? 0),
+    reviewRounds: milestones.reduce((n, m) => n + reviewRounds(run, m), 0),
+    lanes: {
+      total: outcomes.length,
+      landed: outcomes.filter((o) => o.landed).length,
+      climbs: outcomes.reduce((n, o) => n + o.climbs.length, 0),
+    },
+    wallMinutes: minutes(end - start),
+    pausedMinutes: minutes(pausedMs(run, end)),
+    quota: {
+      backends: quotaByBackend(readRecords(run).records),
+      claudeAgentTokens: readAgentRuns(run).reduce((n, a) => n + a.totalTokens, 0),
+    },
+    acceptance,
+    firstTry: acceptance.passed && finished && new Set(landed).size === landed.length,
+    injected:
+      task.limits > 0
+        ? {
+            limits: takenDir && existsSync(takenDir) ? readdirSync(takenDir).length : 0,
+            standInOk: failoverRecovered(run),
+          }
+        : null,
+    recordedAt: new Date(i.now).toISOString(),
+  };
+}
+
+export const resultsFile = (dir: string, label: string): string => join(dir, `${assertLabel(label)}.json`);
+
+export function readScorecard(file: string): ScorecardFile | null {
+  return existsSync(file) ? assertScorecardRows(readVersioned(file, ScorecardFileSchema, 1), file) : null;
+}
+
+/** Sets the task's row in the label's file (a re-record replaces it) and returns the file's contents. */
+export function saveTaskScore(file: string, label: string, s: TaskScore): ScorecardFile {
+  const f = readScorecard(file) ?? { schema: 1 as const, label, tasks: {} };
+  f.tasks[s.task] = s;
+  ensurePrivateDir(dirname(file));
+  writeJsonAtomic(file, f);
+  return f;
+}

package/src/services/summary.ts

@@ -3,11 +3,13 @@ import type { QueueCapability } from "../infra/codex-queue.ts";
 import { inspectionHost, inspectDeliveries, type DeliveryInspection } from "./run-debug.ts";
 import { resolve } from "node:path";
 import { type BudgetStatus, budgetStatus } from "../domain/budget.ts";
-import { isCatherdError } from "../domain/errors.ts";
-import type { Tokens } from "../domain/record.ts";
+import { errorMessage, isCatherdError } from "../domain/errors.ts";
+import type { RunRecord, Tokens } from "../domain/record.ts";
+import type { QuotaRow } from "../domain/scorecard.ts";
 import { median } from "../domain/util.ts";
 import { nonBlankLines, readJsonl } from "../infra/store.ts";
 import { spendOf } from "./budget.ts";
+import { ensureDaemon } from "./daemon.ts";
 import { verifierStepView, type VerifierStepView } from "./verifier-step.ts";
 import { type Pause, pausesOver } from "./pause.ts";
 import { pinChanges } from "./run-pin.ts";
@@ -64,6 +66,13 @@ export interface RunSummary {
 /** One run at a glance. Spec §3.4: reads are pure; nothing here finalizes a dispatch or writes a file. */
 export function summarizeRun(deps: Deps, run: Run): RunSummary {
   const now = deps.now();
+  const warnings: string[] = [];
+  // an unfinished 2.0 run whose daemon died gets it back from any reader: status, watch, the panel
+  try {
+    ensureDaemon(run);
+  } catch (e) {
+    warnings.push(`daemon: ${errorMessage(e)}`);
+  }
   const { records, corrupt } = readRecords(run);
   const live = liveDispatches(run, now);
   const recorded = new Set(records.map((r) => r.dispatchId));
@@ -71,7 +80,7 @@ export function summarizeRun(deps: Deps, run: Run): RunSummary {
   const jev = readJsonl<{ source?: string }>(runPaths(run.dir).jev).rows;
   const sum = (f: (t: Tokens) => number) => records.reduce((n, r) => n + f(r.tokens), 0);
   let budget: BudgetStatus | null = null;
-  const warnings = corrupt ? [`runs.jsonl: skipped ${corrupt} unreadable row(s)`] : [];
+  if (corrupt) warnings.push(`runs.jsonl: skipped ${corrupt} unreadable row(s)`);
   // spec 1.5 "Pinned per run": a change since the pin, which dispatch does not follow
   const pinned = pinChanges(deps, run);
   for (const c of pinned) warnings.push(`pinned: ${c}; dispatch keeps the pinned value (run_pin re-pins)`);
@@ -250,6 +259,21 @@ function harnessCosts(runs: Run[]): HarnessCost[] {
   });
 }
 
+/** Plan 28: tokens and usage limits per backend over `records`, sorted by backend. */
+export function quotaByBackend(records: RunRecord[]): QuotaRow[] {
+  const by = new Map<string, QuotaRow>();
+  for (const r of records) {
+    const q = by.get(r.backend) ?? { backend: r.backend, runs: 0, input: 0, cached: 0, output: 0, limits: 0 };
+    q.runs++;
+    q.input += r.tokens.input;
+    q.cached += r.tokens.cached;
+    q.output += r.tokens.output;
+    if (r.status === "limit") q.limits++;
+    by.set(r.backend, q);
+  }
+  return [...by.values()].sort((a, b) => a.backend.localeCompare(b.backend));
+}
+
 /** Per role and rung over past runs: runs, ok, refusals, climbs from it, seconds and tokens. Reads only. */
 export function runsSummary(f: { run?: string; repo?: string; role?: string; sinceDays?: number }): {
   rungs: RungStats[];

package/src/services/tree-path.ts

@@ -0,0 +1,27 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CatherdError } from "../domain/errors.ts";
+import type { Run } from "./run-store.ts";
+
+/** `<run dir>/trees/<m>`: where milestone `m` of a base run works. */
+export const treeDir = (run: Run, m: string): string => join(run.dir, "trees", m);
+
+/** The marker beside the tree, never inside it, that Setup: finished. */
+export const readyFile = (run: Run, m: string): string => join(run.dir, "trees", `${m}.ready`);
+
+/**
+ * Where milestone `m` works: its worktree in a base run once it exists, else the repo (a run without base, the
+ * run itself, a milestone not claimed yet). A claimed milestone whose folder is gone is an error, never the repo:
+ * its commits, checks and merge would land in the owner's own checkout. Kept apart from milestone-tree.ts so the services that only ask
+ * where a milestone works do not import the claiming code, which imports them.
+ */
+export function treeOf(run: Run, m: string | null): string {
+  if (!run.meta.base || m === null) return run.meta.repo;
+  const tree = treeDir(run, m);
+  if (existsSync(tree)) return tree;
+  if (existsSync(readyFile(run, m)))
+    throw new CatherdError("E_TREE", `the worktree of ${m} is gone: ${tree}`, {
+      fix: "restore the tree (git worktree add it back on the milestone's branch) or cancel the run",
+    });
+  return run.meta.repo;
+}

package/src/services/workspace-admission.ts

@@ -3,11 +3,11 @@ import { budgetStatus, formatBudget, type BudgetStatus, type Spend } from "../do
 import { CatherdError, errorMessage, isCatherdError } from "../domain/errors.ts";
 import type { Workspace, WorkspaceStep } from "../domain/workspace.ts";
 import { withFileLock } from "../infra/filelock.ts";
-import { git, gitToplevel } from "../infra/git.ts";
+import { gitToplevel, isAncestor } from "../infra/git.ts";
 import { writeTextAtomic } from "../infra/store.ts";
 import { spendOf } from "./budget.ts";
 import { pendingDispatches } from "./dispatches.ts";
-import { landedCommits, landedMilestones } from "./milestones.ts";
+import { landedCommitOf, landedMilestones } from "./milestones.ts";
 import { readRecords, type Run, runPaths } from "./run-store.ts";
 import {
   findWorkspace,
@@ -123,14 +123,6 @@ export async function dependencyBlockers(
   return out;
 }
 
-/** The commit the ledger holds for `milestone`, its latest landing; null when it never landed. */
-function landedCommitOf(run: Run, milestone: string): string | null {
-  const commits = landedCommits(run);
-  const milestones = landedMilestones(run);
-  const at = milestones.lastIndexOf(milestone);
-  return at < 0 ? null : (commits[at] ?? null);
-}
-
 /**
  * A `release: "merge"` step releases its dependents once its landed commit is an ancestor of its base ref
  * (`git merge-base --is-ancestor`), in the repository as it stands: catherd never fetches or polls.
@@ -139,9 +131,9 @@ async function unmerged(step: WorkspaceStep, child: Run): Promise<string | null>
   if (step.release !== "merge" || !step.base) return null;
   const commit = landedCommitOf(child, step.milestone);
   if (!commit) return `${step.id} has no landed commit for ${step.milestone} in its ledger`;
-  const r = await git(child.meta.repo, ["merge-base", "--is-ancestor", commit, step.base]);
-  if (r.kind === "ok") return null;
-  if (r.kind === "failed" && r.exit === 1)
+  const merged = await isAncestor(child.meta.repo, commit, step.base);
+  if (merged === true) return null;
+  if (merged === false)
     return `${step.id}'s ${step.milestone} (${commit.slice(0, 7)}) is not merged into ${step.base} yet: merge it, git fetch, then ask again`;
   return `${step.id}: git cannot tell whether ${commit.slice(0, 7)} is in ${step.base} (does the ref exist in ${child.meta.repo}?)`;
 }

package/src/services/workspace-service.ts

@@ -6,7 +6,10 @@ import { CatherdError } from "../domain/errors.ts";
 import { WORKSPACE_LIMIT, WorkspaceIdSchema, WorkspaceSchema, type Workspace } from "../domain/workspace.ts";
 import { withFileLock } from "../infra/filelock.ts";
 import { gitToplevel } from "../infra/git.ts";
+import { indexPath } from "../infra/paths.ts";
+import { readIndexFile } from "../infra/slopalytics.ts";
 import { readVersioned, writeTextAtomic } from "../infra/store.ts";
+import { writeRunIndex } from "./catalog-service.ts";
 import { listDispatches } from "./dispatches.ts";
 import { landedCommits, landedMilestones } from "./milestones.ts";
 import { assertNotPaused, pausesOver } from "./pause.ts";
@@ -193,6 +196,8 @@ async function childFor(
       workspace: { id: workspace.id, step: step.id },
     });
     writePin(deps, run);
+    // pinned like startRun does, so a pair the machine index drops later never breaks the child midway
+    writeRunIndex(run.dir, readIndexFile(indexPath()));
   }
   const contract = existsSync(contractFile) ? join(run.dir, "workspace-contract.md") : null;
   if (contract && !existsSync(contract)) writeTextAtomic(contract, readFileSync(contractFile, "utf8"));

package/web/dist/assets/Brand-PKlUX5TE.js

@@ -0,0 +1 @@
+import{r as e}from"./rolldown-runtime-XKyaHtl9.js";import{$ as t,Sn as n,xn as r}from"./react-query.gen-Bu2yV-qJ.js";import{u as i}from"./index-B6GiwDkh.js";var a=e(n(),1),o=`heroui-theme`,s=`(prefers-color-scheme: dark)`;function c(e){if(typeof window>`u`)return()=>{};let t=window.matchMedia(s);return t.addEventListener(`change`,e),()=>t.removeEventListener(`change`,e)}function l(){return window.matchMedia?.(s).matches?`dark`:`light`}function u(){}function d(e,t){t!==e&&(t&&document.documentElement.classList.remove(t),document.documentElement.classList.add(e),document.documentElement.setAttribute(`data-theme`,e))}function f(e=`system`){let[t,n]=(0,a.useState)(()=>typeof window>`u`?e:localStorage.getItem(o)??e),r=(0,a.useSyncExternalStore)(c,l,u),s=t===`system`?r:t,f=(0,a.useRef)(void 0);return i(()=>{s&&(d(s,f.current),f.current=s)},[s]),{resolvedTheme:s,setTheme:(0,a.useCallback)(e=>{typeof window<`u`&&(localStorage.setItem(o,e),n(e))},[]),theme:t}}var p=r();function m({className:e}){return(0,p.jsxs)(`svg`,{viewBox:`0 0 20 20`,"aria-hidden":`true`,className:t(`size-5 shrink-0`,e),children:[(0,p.jsx)(`rect`,{x:`2`,y:`12`,width:`16`,height:`4`,className:`fill-foreground`}),(0,p.jsx)(`rect`,{x:`3`,y:`6`,width:`3`,height:`3`,className:`fill-accent`}),(0,p.jsx)(`rect`,{x:`8.5`,y:`6`,width:`3`,height:`3`,className:`fill-ink-faint`}),(0,p.jsx)(`rect`,{x:`14`,y:`6`,width:`3`,height:`3`,className:`fill-ink-faint`})]})}function h({className:e}){return(0,p.jsxs)(`span`,{className:t(`inline-flex items-center gap-2`,e),children:[(0,p.jsx)(m,{}),(0,p.jsx)(`span`,{className:`text-[15px] font-semibold tracking-[-0.02em]`,children:`catherd`})]})}export{f as n,h as t};

package/web/dist/assets/Modal-Dxc5so53.js

@@ -0,0 +1 @@
+import{r as e}from"./rolldown-runtime-XKyaHtl9.js";import{Dt as t,G as n,K as r,Lt as i,Ot as a,Sn as o,Vt as s,W as c,X as l,_t as u,ct as d,dt as f,ft as p,ut as m}from"./react-query.gen-Bu2yV-qJ.js";import{$ as h,Q as g,X as _,Z as v,bt as y,ft as b,m as x,nt as S,ot as C,p as w,pt as T,st as E,tt as D,vt as O}from"./use-css-variable-CpnN9WtA.js";import{D as k}from"./label-DFSYBc62.js";var A=e(o(),1),j=typeof document<`u`&&window.visualViewport;function M(){let e=t(),n=(0,A.useRef)(null),[r,a]=(0,A.useState)(()=>e?{width:0,height:0}:N());return(0,A.useEffect)(()=>{let e=e=>{a(t=>e.width===t.width&&e.height===t.height?t:e)},t=()=>{j&&j.scale>1||e(N())},r=t=>{j&&j.scale>1||k(u(t))&&(n.current=O(t=>{t||e({width:document.documentElement.clientWidth,height:document.documentElement.clientHeight})}))};return e(N()),s()&&i()&&window.addEventListener(`blur`,r,!0),j?j.addEventListener(`resize`,t):window.addEventListener(`resize`,t),()=>{n.current?.(),s()&&i()&&window.removeEventListener(`blur`,r,!0),j?j.removeEventListener(`resize`,t):window.removeEventListener(`resize`,t)}},[]),r}function N(){return{width:j?Math.min(j.width*j.scale,document.documentElement.clientWidth):document.documentElement.clientWidth,height:j?j.height*j.scale:document.documentElement.clientHeight}}function P(e,t,n){let{overlayProps:r,underlayProps:i}=S({...e,isOpen:t.isOpen,onClose:t.close},n);D({isDisabled:!t.isOpen,UNSTABLE_overrideFocus:e.UNSTABLE_overrideFocus}),v();let{isEntering:a}=e;return(0,A.useEffect)(()=>{if(t.isOpen&&n.current)return a?C(n.current):E([n.current],{shouldUseInert:!0})},[t.isOpen,a,n]),{modalProps:f(r),underlayProps:i}}var F=(0,A.createContext)(null),I=(0,A.createContext)(null),L=(0,A.forwardRef)(function(e,t){if((0,A.useContext)(I))return A.createElement(H,{...e,modalRef:t},e.children);let{isDismissable:n,isKeyboardDismissDisabled:r,isOpen:i,defaultOpen:a,onOpenChange:o,children:s,isEntering:c,isExiting:l,UNSTABLE_portalContainer:u,shouldCloseOnInteractOutside:d,...f}=e;return A.createElement(z,{isDismissable:n,isKeyboardDismissDisabled:r,isOpen:i,defaultOpen:a,onOpenChange:o,isEntering:c,isExiting:l,UNSTABLE_portalContainer:u,shouldCloseOnInteractOutside:d},A.createElement(H,{...f,modalRef:t},s))});function R(e,r){[e,r]=n(e,r,F);let i=(0,A.useContext)(x),a=_(e),o=e.isOpen!=null||e.defaultOpen!=null||!i?a:i,s=d(r),c=(0,A.useRef)(null),l=b(s,o.isOpen,e.onExit),u=(0,A.useRef)(null),f=b(c,o.isOpen,e=>u.current?.(e)),p=l||f||e.isExiting||!1,m=t();return!o.isOpen&&!p||m?null:A.createElement(B,{...e,state:o,isExiting:p,overlayRef:s,modalRef:c,onExitRef:u})}var z=(0,A.forwardRef)(R);function B({UNSTABLE_portalContainer:e,UNSTABLE_deferUntilEntered:t,...n}){let i=n.modalRef,{state:o}=n,[s,u]=(0,A.useState)(!1),d=T(n.overlayRef,s,n.onEnter)||n.isEntering||!1,p=!!t&&(!s||d),{modalProps:h,underlayProps:_}=P({...n,isEntering:p},o,i),v=(0,A.useContext)(w),b=t?V(v,{isEntering:p}):v,S=r({...n,defaultClassName:`react-aria-ModalOverlay`,values:{isEntering:d,isExiting:n.isExiting,state:o}}),C=M(),E,D;if(typeof document<`u`){let e=y(document.body)?document.body:document.scrollingElement||document.documentElement,t=e.getBoundingClientRect().width%1,n=e.getBoundingClientRect().height%1;E=e.scrollWidth-t,D=e.scrollHeight-n}let k={...S.style,"--visual-viewport-width":C.width+`px`,"--visual-viewport-height":C.height+`px`,"--page-width":E===void 0?void 0:E+`px`,"--page-height":D===void 0?void 0:D+`px`};return a(()=>O(()=>u(!0)),[]),A.createElement(g,{isExiting:n.isExiting,portalContainer:e},A.createElement(l.div,{...f(m(n,{global:!0}),_),...S,style:k,ref:n.overlayRef,"data-entering":d||void 0,"data-exiting":n.isExiting||void 0},A.createElement(c,{values:[[I,{modalProps:h,modalRef:i,isExiting:n.isExiting,onExitRef:n.onExitRef,isOpen:s,isDismissable:n.isDismissable}],[x,o],[w,b]]},S.children)))}function V(e,t){if(e&&`slots`in e&&e.slots){let n={};for(let r in e.slots)n[r]={...e.slots[r],...t};return{...e,slots:n}}return{...e,...t}}function H(e){let{modalProps:t,modalRef:n,isExiting:i,onExitRef:o,isDismissable:s,isOpen:c}=(0,A.useContext)(I),u=(0,A.useContext)(x),g=(0,A.useMemo)(()=>p(e.modalRef,n),[e.modalRef,n]),_=d(g),v=T(_,c,e.onEnter),y=r({...e,defaultClassName:`react-aria-Modal`,values:{isEntering:v,isExiting:i,state:u}});return a(()=>{o&&(o.current=e.onExit)}),A.createElement(l.div,{...f(m(e,{global:!0}),t),...y,ref:_,"data-entering":v||void 0,"data-exiting":i||void 0},s&&A.createElement(h,{onDismiss:u.close}),y.children)}export{z as n,L as t};

package/web/dist/assets/Pressable-C8-T6Ed_.js

@@ -0,0 +1 @@
+import{r as e}from"./rolldown-runtime-XKyaHtl9.js";import{C as t,O as n,Sn as r,ct as i,dt as a,ft as o}from"./react-query.gen-Bu2yV-qJ.js";var s=e(r(),1),c=s.forwardRef(({children:e,...r},c)=>{c=i(c);let{pressProps:l}=t({...r,ref:c}),{focusableProps:u}=n(r,c),d=s.Children.only(e);(0,s.useEffect)(()=>{},[c,r.isDisabled]);let f=d.props.ref;return s.cloneElement(d,{...a(l,u,d.props),ref:o(f,c)})});export{c as t};