diff-easy 0.1.0

package/dist/cli/turns.js

@@ -0,0 +1,333 @@
+import { execFileSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { homedir, tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { deleteHubInfo, deleteServerInfo, readHubInfo, readServerInfo, readTurnLog, writeTurnLog, } from '../utils/turnLog.js';
+import { readStdin } from './utils.js';
+/** Git ref that anchors all live snapshot commits so their objects survive GC. */
+const SNAPSHOT_REF = 'refs/difit/snapshots';
+const PROMPT_PREVIEW_MAX = 120;
+/** Per-session retention: keep at most this many most-recent turns. */
+const MAX_TURNS_PER_SESSION = 50;
+function gitEnv(extra = {}) {
+    return {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'diff-easy',
+        GIT_AUTHOR_EMAIL: 'diff-easy@local',
+        GIT_COMMITTER_NAME: 'diff-easy',
+        GIT_COMMITTER_EMAIL: 'diff-easy@local',
+        ...extra,
+    };
+}
+function resolveRepoRoot(cwd) {
+    try {
+        return execFileSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Capture the entire current working tree (tracked + untracked, honoring
+ * .gitignore) as a standalone git commit, without touching the user's real
+ * index or working tree. The commit is kept alive by reanchorSnapshots().
+ */
+function snapshotWorkingTree(repoRoot) {
+    const tmpIndex = join(tmpdir(), `difit-index-${process.pid}-${randomUUID()}`);
+    // Seed the temp index from the repo's real index so `git add -A` reuses the
+    // stat cache and only re-hashes actually-changed files. Without this, a fresh
+    // (empty) index forces git to lstat + hash the ENTIRE working tree every turn
+    // — seconds on a large repo, twice per turn, on the agent's critical path.
+    try {
+        const gitDir = execFileSync('git', ['rev-parse', '--absolute-git-dir'], {
+            cwd: repoRoot,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim();
+        const realIndex = join(gitDir, 'index');
+        if (gitDir && existsSync(realIndex)) {
+            copyFileSync(realIndex, tmpIndex);
+        }
+    }
+    catch {
+        // fall back to an empty temp index (slower but correct)
+    }
+    const env = gitEnv({ GIT_INDEX_FILE: tmpIndex });
+    try {
+        execFileSync('git', ['add', '-A'], { cwd: repoRoot, env, stdio: 'ignore' });
+        const tree = execFileSync('git', ['write-tree'], { cwd: repoRoot, env }).toString().trim();
+        const commit = execFileSync('git', ['commit-tree', tree, '-m', 'diff-easy turn snapshot'], {
+            cwd: repoRoot,
+            env,
+        })
+            .toString()
+            .trim();
+        return { commit, tree };
+    }
+    finally {
+        try {
+            unlinkSync(tmpIndex);
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+}
+/** Keep at most MAX_TURNS_PER_SESSION most-recent turns per session. */
+function pruneLog(log) {
+    const bySession = new Map();
+    for (const turn of log) {
+        const arr = bySession.get(turn.sessionId) ?? [];
+        arr.push(turn);
+        bySession.set(turn.sessionId, arr);
+    }
+    if ([...bySession.values()].every((arr) => arr.length <= MAX_TURNS_PER_SESSION)) {
+        return log;
+    }
+    const keep = new Set();
+    for (const arr of bySession.values()) {
+        // log is chronological (appended in order), so the tail is most-recent.
+        for (const turn of arr.slice(-MAX_TURNS_PER_SESSION))
+            keep.add(turn.id);
+    }
+    return log.filter((turn) => keep.has(turn.id));
+}
+/**
+ * Point SNAPSHOT_REF at a single anchor commit whose parents are every snapshot
+ * commit still referenced by the (pruned) log. Snapshot commits dropped by
+ * pruning are no longer reachable from any ref, so a routine `git gc` reclaims
+ * them — bounding `.git` growth.
+ */
+function reanchorSnapshots(repoRoot, log, tree) {
+    const commits = new Set();
+    for (const turn of log) {
+        if (turn.commitBefore)
+            commits.add(turn.commitBefore);
+        if (turn.commitAfter)
+            commits.add(turn.commitAfter);
+    }
+    const env = gitEnv();
+    if (commits.size === 0) {
+        try {
+            execFileSync('git', ['update-ref', '-d', SNAPSHOT_REF], { cwd: repoRoot, stdio: 'ignore' });
+        }
+        catch {
+            // ref may not exist yet
+        }
+        return;
+    }
+    const parentArgs = [];
+    for (const commit of commits)
+        parentArgs.push('-p', commit);
+    const anchor = execFileSync('git', ['commit-tree', tree, ...parentArgs, '-m', 'diff-easy snapshot anchor'], { cwd: repoRoot, env })
+        .toString()
+        .trim();
+    execFileSync('git', ['update-ref', SNAPSHOT_REF, anchor], { cwd: repoRoot, env });
+}
+function previewOf(prompt) {
+    if (!prompt)
+        return null;
+    const oneLine = prompt.replace(/\s+/gu, ' ').trim();
+    if (oneLine.length <= PROMPT_PREVIEW_MAX)
+        return oneLine;
+    return `${oneLine.slice(0, PROMPT_PREVIEW_MAX - 1)}…`;
+}
+/** True if a process with this pid currently exists (EPERM still means alive). */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
+async function pingTurnComplete(port) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 300);
+        await fetch(`http://127.0.0.1:${port}/events/turn-complete`, {
+            method: 'POST',
+            signal: controller.signal,
+        }).catch(() => undefined);
+        clearTimeout(timer);
+    }
+    catch {
+        // server not running / unreachable — fine, capture is decoupled from viewing
+    }
+}
+/**
+ * Best-effort live-refresh ping. Capped so it never slows the agent's turn.
+ *
+ * A viewer advertises itself in one of two ways: a per-repo `server.json` (a
+ * standalone `difit` opened on this repo) or the global `hub.json` (the
+ * always-on hub, which serves many repos and never writes a per-repo file).
+ * Ping every live advertisement so the timeline refreshes regardless of which
+ * one the user has open — without this, hub users only saw new turns after a
+ * manual refresh.
+ */
+export async function notifyServer(repoRoot) {
+    const targets = [];
+    const repoInfo = readServerInfo(repoRoot);
+    if (repoInfo) {
+        targets.push({ info: repoInfo, clearStale: () => deleteServerInfo(repoRoot) });
+    }
+    const hubInfo = readHubInfo();
+    if (hubInfo) {
+        targets.push({ info: hubInfo, clearStale: () => deleteHubInfo() });
+    }
+    const pingedPorts = new Set();
+    for (const { info, clearStale } of targets) {
+        // A stale advertisement (the viewer exited without cleaning up) would make
+        // us POST to whatever process now holds that port. If the recorded pid is
+        // dead, skip the ping and clear the stale file.
+        if (typeof info.pid === 'number' && !isPidAlive(info.pid)) {
+            clearStale();
+            continue;
+        }
+        if (pingedPorts.has(info.port)) {
+            continue;
+        }
+        pingedPorts.add(info.port);
+        await pingTurnComplete(info.port);
+    }
+}
+async function runSnapshot() {
+    // Skip when this Claude session was spawned internally by diff-easy itself
+    // (e.g. the file-grouping provider's `claude -p` call). Otherwise diff-easy
+    // would record its own tool invocations as spurious agent turns — which also
+    // fires the turn-complete SSE and hijacks the live view away from the diff
+    // the user is grouping. See src/server/grouping/claudeCli.ts.
+    if (process.env.DIFIT_INTERNAL_CLAUDE === '1')
+        return;
+    // Never throw: a failing hook must not block the agent.
+    try {
+        const input = await readStdin().catch(() => '');
+        let payload = {};
+        try {
+            payload = JSON.parse(input || '{}');
+        }
+        catch {
+            payload = {};
+        }
+        const cwd = payload.cwd || process.cwd();
+        const repoRoot = resolveRepoRoot(cwd);
+        if (!repoRoot)
+            return; // no-op outside a git repo
+        const { commit, tree } = snapshotWorkingTree(repoRoot);
+        const sessionId = payload.session_id || 'unknown';
+        const event = payload.hook_event_name || '';
+        const now = Date.now();
+        const log = readTurnLog(repoRoot);
+        if (event === 'UserPromptSubmit') {
+            const prompt = typeof payload.prompt === 'string' ? payload.prompt : null;
+            const record = {
+                id: randomUUID(),
+                sessionId,
+                prompt,
+                promptPreview: previewOf(prompt),
+                commitBefore: commit,
+                commitAfter: null,
+                startedAt: now,
+                endedAt: null,
+                status: 'open',
+            };
+            log.push(record);
+        }
+        else {
+            // Stop / SubagentStop / anything else closes the current open turn.
+            const openTurn = [...log]
+                .reverse()
+                .find((t) => t.sessionId === sessionId && t.status === 'open');
+            if (openTurn) {
+                openTurn.commitAfter = commit;
+                openTurn.endedAt = now;
+                openTurn.status = 'closed';
+            }
+            else {
+                const lastForSession = [...log].reverse().find((t) => t.sessionId === sessionId);
+                log.push({
+                    id: randomUUID(),
+                    sessionId,
+                    prompt: null,
+                    promptPreview: null,
+                    commitBefore: lastForSession?.commitAfter ?? commit,
+                    commitAfter: commit,
+                    startedAt: now,
+                    endedAt: now,
+                    status: 'closed',
+                });
+            }
+        }
+        const pruned = pruneLog(log);
+        writeTurnLog(repoRoot, pruned);
+        reanchorSnapshots(repoRoot, pruned, tree);
+        await notifyServer(repoRoot);
+    }
+    catch {
+        // swallow — hook must always exit 0
+    }
+}
+export function createSnapshotCommand() {
+    return new Command('snapshot')
+        .description('Internal: capture a working-tree snapshot for a Claude Code turn (hook entrypoint)')
+        .action(async () => {
+        await runSnapshot();
+        process.exit(0);
+    });
+}
+const HOOK_EVENTS = ['UserPromptSubmit', 'Stop'];
+function snapshotCommandString() {
+    // Absolute, install-independent invocation of this very CLI.
+    const cliPath = fileURLToPath(import.meta.url).replace(/turns\.js$/u, 'index.js');
+    return `"${process.execPath}" "${cliPath}" snapshot`;
+}
+function readSettings(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function createInitCommand() {
+    return new Command('init')
+        .description('Install the Claude Code hooks that capture per-turn diffs')
+        .option('--project', 'install into ./.claude/settings.json instead of ~/.claude/settings.json')
+        .action((options) => {
+        const settingsPath = options.project
+            ? join(process.cwd(), '.claude', 'settings.json')
+            : join(homedir(), '.claude', 'settings.json');
+        const settings = readSettings(settingsPath);
+        settings.hooks ??= {};
+        const command = snapshotCommandString();
+        let added = 0;
+        let already = 0;
+        for (const event of HOOK_EVENTS) {
+            const entries = (settings.hooks[event] ??= []);
+            const exists = entries.some((entry) => entry.hooks?.some((h) => h.command?.includes('snapshot') && h.command?.includes('index.js')));
+            if (exists) {
+                already += 1;
+                continue;
+            }
+            entries.push({ hooks: [{ type: 'command', command }] });
+            added += 1;
+        }
+        const dir = dirname(settingsPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+        console.log(`diff-easy: hooks written to ${settingsPath}`);
+        console.log(`  added ${added} hook(s), ${already} already present`);
+        console.log('  events: UserPromptSubmit, Stop');
+        console.log('\nStart (or restart) Claude Code in your repo, then run `diff-easy` to review per-turn diffs.');
+    });
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,27 @@
+import { type Stats } from 'node:fs';
+import type { SimpleGit } from 'simple-git';
+import type { CommentImport } from '../types/diff.js';
+type StdinStat = Pick<Stats, 'isFIFO' | 'isFile' | 'isSocket'>;
+type StdinSource = 'pipe' | 'file' | 'socket' | 'tty';
+export declare function detectStdinSource(stdinStat?: StdinStat): StdinSource;
+interface ShouldReadStdinOptions {
+    commitish: string;
+    hasPositionalArgs: boolean;
+    hasPrOption: boolean;
+    stdinSource?: StdinSource;
+}
+export declare function shouldReadStdin(options: ShouldReadStdinOptions): boolean;
+export declare function getGitRoot(): string;
+export declare function validateCommitish(commitish: string): boolean;
+export declare function shortHash(hash: string): string;
+export declare function createCommitRangeString(baseHash: string, targetHash: string): string;
+export declare function parseCommentOptions(commentValues: string[]): CommentImport[];
+export declare function validateDiffArguments(targetCommitish: string, baseCommitish?: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare function findUntrackedFiles(git: SimpleGit): Promise<string[]>;
+export declare function markFilesIntentToAdd(git: SimpleGit, files: string[]): Promise<void>;
+export declare function promptUser(message: string): Promise<boolean>;
+export declare function readStdin(): Promise<string>;
+export {};

package/dist/cli/utils.js

@@ -0,0 +1,204 @@
+import { execSync } from 'child_process';
+import { fstatSync } from 'node:fs';
+import { createInterface } from 'readline/promises';
+import { parseCommentImportValue } from '../utils/commentImports.js';
+export function detectStdinSource(stdinStat = fstatSync(0)) {
+    if (stdinStat.isFIFO()) {
+        return 'pipe';
+    }
+    if (stdinStat.isFile()) {
+        return 'file';
+    }
+    if (stdinStat.isSocket()) {
+        return 'socket';
+    }
+    return 'tty';
+}
+export function shouldReadStdin(options) {
+    if (options.commitish === '-') {
+        return true;
+    }
+    if (options.hasPositionalArgs || options.hasPrOption) {
+        return false;
+    }
+    const stdinSource = options.stdinSource ?? detectStdinSource();
+    return stdinSource === 'pipe' || stdinSource === 'file' || stdinSource === 'socket';
+}
+export function getGitRoot() {
+    try {
+        const result = execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        return result.trim();
+    }
+    catch {
+        throw new Error('Not a git repository (or any of the parent directories)');
+    }
+}
+export function validateCommitish(commitish) {
+    if (!commitish || typeof commitish !== 'string') {
+        return false;
+    }
+    const trimmed = commitish.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    if (trimmed === '.' || trimmed === 'working' || trimmed === 'staged') {
+        return true; // Allow special keywords for working directory and staging area diff
+    }
+    const baseCommitish = stripRevisionSuffix(trimmed);
+    if (baseCommitish.length === 0) {
+        return false;
+    }
+    return isValidCommitishBase(baseCommitish);
+}
+function isValidCommitishBase(baseCommitish) {
+    const validBasePatterns = [
+        /^[a-f0-9]{4,40}$/i, // SHA hashes
+        /^HEAD$/, // HEAD
+        /^@$/, // @ is Git alias for HEAD
+    ];
+    if (validBasePatterns.some((pattern) => pattern.test(baseCommitish))) {
+        return true;
+    }
+    // For branch, tag, and remote refs, use git's ref naming rules.
+    return isValidBranchName(baseCommitish);
+}
+function stripRevisionSuffix(commitish) {
+    let suffixStart = commitish.length;
+    while (suffixStart > 0) {
+        const current = commitish[suffixStart - 1];
+        if (current === '^') {
+            suffixStart--;
+            continue;
+        }
+        if (current === '~') {
+            suffixStart--;
+            continue;
+        }
+        if (!isAsciiDigit(current)) {
+            break;
+        }
+        let digitStart = suffixStart - 1;
+        while (digitStart > 0 && isAsciiDigit(commitish[digitStart - 1])) {
+            digitStart--;
+        }
+        const operator = commitish[digitStart - 1];
+        if (operator !== '^' && operator !== '~') {
+            break;
+        }
+        suffixStart = digitStart - 1;
+    }
+    return commitish.slice(0, suffixStart);
+}
+function isAsciiDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function isValidBranchName(name) {
+    // Git branch name rules
+    if (name.startsWith('-'))
+        return false; // Cannot start with dash
+    if (name.endsWith('.'))
+        return false; // Cannot end with dot
+    // @ is a valid Git alias for HEAD, so we should allow it
+    if (name.includes('..'))
+        return false; // No consecutive dots
+    if (name.includes('@{'))
+        return false; // No @{ sequence
+    if (name.includes('//'))
+        return false; // No consecutive slashes
+    if (name.startsWith('/') || name.endsWith('/'))
+        return false; // No leading/trailing slashes
+    if (name.endsWith('.lock'))
+        return false; // Cannot end with .lock
+    // Check for forbidden characters
+    const forbiddenChars = /[~^:?*[\\\x00-\x20\x7F]/;
+    if (forbiddenChars.test(name))
+        return false;
+    // Check path components
+    const components = name.split('/');
+    for (const component of components) {
+        if (component === '')
+            return false; // Empty component
+        if (component.startsWith('.'))
+            return false; // Component cannot start with dot
+        if (component.endsWith('.lock'))
+            return false; // Component cannot end with .lock
+    }
+    return true;
+}
+export function shortHash(hash) {
+    return hash.substring(0, 7);
+}
+export function createCommitRangeString(baseHash, targetHash) {
+    return `${baseHash}...${targetHash}`;
+}
+export function parseCommentOptions(commentValues) {
+    return commentValues.flatMap((value) => parseCommentImportValue(value));
+}
+export function validateDiffArguments(targetCommitish, baseCommitish) {
+    // Validate target commitish format
+    if (!validateCommitish(targetCommitish)) {
+        return { valid: false, error: 'Invalid target commit-ish format' };
+    }
+    // Validate base commitish format if provided
+    if (baseCommitish !== undefined && !validateCommitish(baseCommitish)) {
+        return { valid: false, error: 'Invalid base commit-ish format' };
+    }
+    // Special arguments are only allowed in target, not base (except staged with working)
+    const specialArgs = ['working', 'staged', '.'];
+    if (baseCommitish && specialArgs.includes(baseCommitish)) {
+        // Allow 'staged' as base only when target is 'working'
+        if (baseCommitish === 'staged' && targetCommitish === 'working') {
+            // This is valid: working vs staged
+        }
+        else {
+            return {
+                valid: false,
+                error: `Special arguments (working, staged, .) are only allowed as target, not base. Got base: ${baseCommitish}`,
+            };
+        }
+    }
+    // Cannot compare same values
+    if (targetCommitish === baseCommitish) {
+        return {
+            valid: false,
+            error: `Cannot compare ${targetCommitish} with itself`,
+        };
+    }
+    // "working" shows unstaged changes and can only be compared with staging area
+    if (targetCommitish === 'working' && baseCommitish && baseCommitish !== 'staged') {
+        return {
+            valid: false,
+            error: '"working" shows unstaged changes and cannot be compared with another commit. Use "." instead to compare all uncommitted changes with a specific commit.',
+        };
+    }
+    return { valid: true };
+}
+export async function findUntrackedFiles(git) {
+    const status = await git.status();
+    return status.not_added;
+}
+// Add files with --intent-to-add to make them visible in `git diff` without staging content
+export async function markFilesIntentToAdd(git, files) {
+    await git.add(['--intent-to-add', ...files]);
+}
+export async function promptUser(message) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question(message);
+    rl.close();
+    // Empty string (Enter) or 'y', 'yes' return true
+    const trimmed = answer.trim().toLowerCase();
+    return trimmed === '' || ['y', 'yes'].includes(trimmed);
+}
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/client/assets/arc-CHYjdFTk.js

@@ -0,0 +1 @@
+import{n as e,t}from"./path-BWPyau1x.js";import{a as n,c as r,d as i,f as a,i as o,l as s,m as c,n as l,o as u,p as d,r as f,u as p}from"./dist-7wVkzZne.js";function m(e){return e.innerRadius}function h(e){return e.outerRadius}function g(e){return e.startAngle}function _(e){return e.endAngle}function v(e){return e&&e.padAngle}function y(e,t,n,r,i,a,o,s){var c=n-e,l=r-t,u=o-i,d=s-a,f=d*c-u*l;if(!(f*f<1e-12))return f=(u*(t-a)-d*(e-i))/f,[e+f*c,t+f*l]}function b(e,t,n,r,i,a,o){var c=e-n,l=t-r,u=(o?a:-a)/d(c*c+l*l),f=u*l,p=-u*c,m=e+f,h=t+p,g=n+f,_=r+p,v=(m+g)/2,y=(h+_)/2,b=g-m,x=_-h,S=b*b+x*x,C=i-a,w=m*_-g*h,T=(x<0?-1:1)*d(s(0,C*C*S-w*w)),E=(w*x-b*T)/S,D=(-w*b-x*T)/S,O=(w*x+b*T)/S,k=(-w*b+x*T)/S,A=E-v,j=D-y,M=O-v,N=k-y;return A*A+j*j>M*M+N*N&&(E=O,D=k),{cx:E,cy:D,x01:-f,y01:-p,x11:E*(i/C-1),y11:D*(i/C-1)}}function x(){var s=m,x=h,S=e(0),C=null,w=g,T=_,E=v,D=null,O=t(k);function k(){var e,t,m=+s.apply(this,arguments),h=+x.apply(this,arguments),g=w.apply(this,arguments)-r,_=T.apply(this,arguments)-r,v=l(_-g),k=_>g;if(D||=e=O(),h<m&&(t=h,h=m,m=t),!(h>1e-12))D.moveTo(0,0);else if(v>c-1e-12)D.moveTo(h*u(g),h*a(g)),D.arc(0,0,h,g,_,!k),m>1e-12&&(D.moveTo(m*u(_),m*a(_)),D.arc(0,0,m,_,g,k));else{var A=g,j=_,M=g,N=_,P=v,F=v,I=E.apply(this,arguments)/2,L=I>1e-12&&(C?+C.apply(this,arguments):d(m*m+h*h)),R=p(l(h-m)/2,+S.apply(this,arguments)),z=R,B=R,V,H;if(L>1e-12){var U=o(L/m*a(I)),W=o(L/h*a(I));(P-=U*2)>1e-12?(U*=k?1:-1,M+=U,N-=U):(P=0,M=N=(g+_)/2),(F-=W*2)>1e-12?(W*=k?1:-1,A+=W,j-=W):(F=0,A=j=(g+_)/2)}var G=h*u(A),K=h*a(A),q=m*u(N),J=m*a(N);if(R>1e-12){var Y=h*u(j),X=h*a(j),Z=m*u(M),Q=m*a(M),$;if(v<i)if($=y(G,K,Z,Q,Y,X,q,J)){var ee=G-$[0],te=K-$[1],ne=Y-$[0],re=X-$[1],ie=1/a(f((ee*ne+te*re)/(d(ee*ee+te*te)*d(ne*ne+re*re)))/2),ae=d($[0]*$[0]+$[1]*$[1]);z=p(R,(m-ae)/(ie-1)),B=p(R,(h-ae)/(ie+1))}else z=B=0}F>1e-12?B>1e-12?(V=b(Z,Q,G,K,h,B,k),H=b(Y,X,q,J,h,B,k),D.moveTo(V.cx+V.x01,V.cy+V.y01),B<R?D.arc(V.cx,V.cy,B,n(V.y01,V.x01),n(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,B,n(V.y01,V.x01),n(V.y11,V.x11),!k),D.arc(0,0,h,n(V.cy+V.y11,V.cx+V.x11),n(H.cy+H.y11,H.cx+H.x11),!k),D.arc(H.cx,H.cy,B,n(H.y11,H.x11),n(H.y01,H.x01),!k))):(D.moveTo(G,K),D.arc(0,0,h,A,j,!k)):D.moveTo(G,K),!(m>1e-12)||!(P>1e-12)?D.lineTo(q,J):z>1e-12?(V=b(q,J,Y,X,m,-z,k),H=b(G,K,Z,Q,m,-z,k),D.lineTo(V.cx+V.x01,V.cy+V.y01),z<R?D.arc(V.cx,V.cy,z,n(V.y01,V.x01),n(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,z,n(V.y01,V.x01),n(V.y11,V.x11),!k),D.arc(0,0,m,n(V.cy+V.y11,V.cx+V.x11),n(H.cy+H.y11,H.cx+H.x11),k),D.arc(H.cx,H.cy,z,n(H.y11,H.x11),n(H.y01,H.x01),!k))):D.arc(0,0,m,N,M,k)}if(D.closePath(),e)return D=null,e+``||null}return k.centroid=function(){var e=(+s.apply(this,arguments)+ +x.apply(this,arguments))/2,t=(+w.apply(this,arguments)+ +T.apply(this,arguments))/2-i/2;return[u(t)*e,a(t)*e]},k.innerRadius=function(t){return arguments.length?(s=typeof t==`function`?t:e(+t),k):s},k.outerRadius=function(t){return arguments.length?(x=typeof t==`function`?t:e(+t),k):x},k.cornerRadius=function(t){return arguments.length?(S=typeof t==`function`?t:e(+t),k):S},k.padRadius=function(t){return arguments.length?(C=t==null?null:typeof t==`function`?t:e(+t),k):C},k.startAngle=function(t){return arguments.length?(w=typeof t==`function`?t:e(+t),k):w},k.endAngle=function(t){return arguments.length?(T=typeof t==`function`?t:e(+t),k):T},k.padAngle=function(t){return arguments.length?(E=typeof t==`function`?t:e(+t),k):E},k.context=function(e){return arguments.length?(D=e??null,k):D},k}export{x as t};

package/dist/client/assets/architecture-7EHR7CIX-weHBYDgM.js

@@ -0,0 +1 @@
+import"./chunk-NNHCCRGN-DlpIbxXb.js";import{x as e}from"./mermaid-parser.core-PVPfUfyU.js";export{e as createArchitectureServices};