61:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 62:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 63:Tc13,"use client"; import { animate, motion, useMotionValue, type MotionValue } from "motion/react"; import { useEffect } from "react"; import { ease, useSafeReducedMotion } from "../../lib/motion"; import type { StepStatus } from "../thinking-core/types"; import { edgeProgressTarget } from "./status"; export type EdgeProgressOptions = { /** Seconds to draw an edge. Default 0.5: a hand-off, read at a glance. */ duration?: number; /** Seconds before drawing starts, e.g. after the source node's check has drawn. Default 0. */ delay?: number; /** Override the reduced-motion read (it is read after hydration by default). */ reduced?: boolean; }; /** * An edge's `pathLength` (0–1) as a motion value that follows its status: it draws from the * source to the target when the edge becomes active or complete, and rewinds faster (≤ 0.75 × * the draw) when a retry resets it. Interruptible: it always continues from what's on screen. * Reduced motion jumps. A complete edge on mount starts drawn, so a finished run doesn't replay. */ export function useEdgeProgress(status: StepStatus, { duration = 0.5, delay = 0, reduced: reducedProp }: EdgeProgressOptions = {}): MotionValue { const reducedRead = useSafeReducedMotion(); const reduced = reducedProp ?? reducedRead; const target = edgeProgressTarget(status); const progress = useMotionValue(status === "complete" ? 1 : 0); useEffect(() => { if (progress.get() === target) return; if (reduced) { progress.jump(target); return; } const rewinding = target < progress.get(); const controls = animate(progress, target, { duration: rewinding ? duration * 0.6 : duration, delay: rewinding ? 0 : delay, ease: rewinding ? ease.exit : ease.inOut, }); return () => controls.stop(); }, [target, reduced, duration, delay, progress]); return progress; } export type FlowEdgePathProps = EdgeProgressOptions & { /** SVG path data, e.g. `PlacedEdge.path`. */ d: string; status: StepStatus; /** Classes for the drawn stroke. Default `stroke-text-secondary`; tint it per status. */ className?: string; /** Classes for the undrawn track. Default `stroke-line`; skipped edges are dashed. */ trackClassName?: string; strokeWidth?: number; }; /** * The one piece of UI flow-core ships: an edge as a track plus a stroke drawn along it by * `useEdgeProgress`. Everything else (nodes, labels, colours per status) is the builder's. */ export function FlowEdgePath({ d, status, className = "stroke-text-secondary", trackClassName = "stroke-line", strokeWidth = 1.5, ...options }: FlowEdgePathProps) { const progress = useEdgeProgress(status, options); return ( ); } 64:T2755,import { edgeId, type FlowEdge, type FlowGraph, type FlowNode } from "./types"; export type FlowDirection = "LR" | "TB"; export type FlowLayoutOptions = { /** Left to right (pipelines, payment routes) or top to bottom (org charts, approval chains). Default `LR`. */ direction?: FlowDirection; /** Default node size; a node's own `width`/`height` wins. Default 152 × 40. */ nodeWidth?: number; nodeHeight?: number; /** Space between ranks (columns in LR). Default 40. */ rankGap?: number; /** Space between siblings in a rank. Default 12. */ nodeGap?: number; /** Space around the whole graph. Default 0. */ padding?: number; /** `curve` is a smooth S-bezier; `step` is orthogonal with rounded corners (GitHub Actions). Default `curve`. */ edgeShape?: "curve" | "step"; /** Corner radius of `step` edges. Default 8. */ cornerRadius?: number; }; export type PlacedNode = { node: FlowNode; id: string; /** Top-left corner and size, in layout px. */ x: number; y: number; width: number; height: number; /** Column (LR) or row (TB) index, from 0 at the sources. */ rank: number; /** Position inside its rank, after crossing reduction. */ order: number; }; export type PlacedEdge = { edge: FlowEdge; id: string; from: string; to: string; /** SVG path data. Draw it with `pathLength` progress (`FlowEdgePath`, `useEdgeProgress`). */ path: string; /** Start (source port) and end (target port). */ start: { x: number; y: number }; end: { x: number; y: number }; /** Points against the ranking: a cycle was broken here. Drawn, but not used for layout. */ back: boolean; }; export type FlowLayout = { nodes: PlacedNode[]; edges: PlacedEdge[]; /** Node ids per rank, in order. */ ranks: string[][]; width: number; height: number; byId: Map>; }; /** * Lays out a small DAG (up to a few dozen nodes): longest-path ranks, barycentre sweeps to * reduce crossings, ranks centred on each other, edges from the trailing port of a node to the * leading port of the next. Pure and deterministic (input order breaks ties), so call it in a * `useMemo` and it gives the same picture on the server and the client. Cycles are tolerated: * the closing edge is marked `back` and skipped for ranking. * * const layout = useMemo(() => layoutFlow(pipeline, { edgeShape: "step" }), [pipeline]); */ export function layoutFlow(graph: FlowGraph, options: FlowLayoutOptions = {}): FlowLayout { const { direction = "LR", nodeWidth = 152, nodeHeight = 40, rankGap = 40, nodeGap = 12, padding = 0, edgeShape = "curve", cornerRadius = 8, } = options; const lr = direction === "LR"; const nodes = graph.nodes; const index = new Map(nodes.map((n, i) => [n.id, i])); const edges = graph.edges.filter((e) => index.has(e.from) && index.has(e.to) && e.from !== e.to); // 1. Break cycles: DFS in input order; an edge to a node on the stack is a back edge. const out: number[][] = nodes.map(() => []); edges.forEach((e, i) => out[index.get(e.from)!].push(i)); const back = new Set(); const state = new Uint8Array(nodes.length); // 0 new, 1 on stack, 2 done const visit = (v: number) => { state[v] = 1; for (const ei of out[v]) { const w = index.get(edges[ei].to)!; if (state[w] === 1) back.add(ei); else if (state[w] === 0) visit(w); } state[v] = 2; }; nodes.forEach((_, v) => state[v] === 0 && visit(v)); const forward = edges.map((e, i) => ({ e, i, from: index.get(e.from)!, to: index.get(e.to)! })).filter((x) => !back.has(x.i)); // 2. Longest-path ranks (Kahn's order). const preds: number[][] = nodes.map(() => []); const succs: number[][] = nodes.map(() => []); for (const f of forward) { preds[f.to].push(f.from); succs[f.from].push(f.to); } const rank = new Array(nodes.length).fill(0); const indeg = preds.map((p) => p.length); const queue = nodes.map((_, i) => i).filter((i) => indeg[i] === 0); for (let q = 0; q < queue.length; q++) { const v = queue[q]; for (const w of succs[v]) { rank[w] = Math.max(rank[w], rank[v] + 1); if (--indeg[w] === 0) queue.push(w); } } // Pull sources forward to sit just before their first consumer (a lone "lint" next to "test", not at column 0). for (let i = queue.length - 1; i >= 0; i--) { const v = queue[i]; if (preds[v].length === 0 && succs[v].length) rank[v] = Math.min(...succs[v].map((w) => rank[w])) - 1; } const rankCount = nodes.length ? Math.max(...rank) + 1 : 0; const ranks: number[][] = Array.from({ length: rankCount }, () => []); nodes.forEach((_, v) => ranks[rank[v]].push(v)); // 3. Crossing reduction: barycentre sweeps down then up, ties kept in input order. const pos = new Array(nodes.length); const setPos = () => ranks.forEach((r) => r.forEach((v, i) => (pos[v] = i))); setPos(); const sweep = (r: number[], neighbours: number[][]) => { const bary = new Map(); for (const v of r) { const ns = neighbours[v]; bary.set(v, ns.length ? ns.reduce((s, w) => s + pos[w], 0) / ns.length : pos[v]); } r.sort((a, b) => bary.get(a)! - bary.get(b)! || pos[a] - pos[b]); r.forEach((v, i) => (pos[v] = i)); }; for (let iter = 0; iter < 4; iter++) { for (let r = 1; r < rankCount; r++) sweep(ranks[r], preds); for (let r = rankCount - 2; r >= 0; r--) sweep(ranks[r], succs); } // 4. Coordinates. "Along" is the rank axis (x in LR), "across" stacks a rank's nodes. const size = (v: number) => ({ w: nodes[v].width ?? nodeWidth, h: nodes[v].height ?? nodeHeight }); const alongSize = (v: number) => (lr ? size(v).w : size(v).h); const acrossSize = (v: number) => (lr ? size(v).h : size(v).w); const rankDepth = ranks.map((r) => Math.max(0, ...r.map(alongSize))); const rankSpan = ranks.map((r) => r.reduce((s, v) => s + acrossSize(v), 0) + Math.max(0, r.length - 1) * nodeGap); const maxSpan = Math.max(0, ...rankSpan); const placed: PlacedNode[] = new Array(nodes.length); let along = padding; ranks.forEach((r, ri) => { let across = padding + (maxSpan - rankSpan[ri]) / 2; for (const v of r) { const { w, h } = size(v); const a = along + (rankDepth[ri] - alongSize(v)) / 2; placed[v] = { node: nodes[v], id: nodes[v].id, x: lr ? a : across, y: lr ? across : a, width: w, height: h, rank: ri, order: pos[v] }; across += acrossSize(v) + nodeGap; } along += rankDepth[ri] + rankGap; }); const totalAlong = rankCount ? along - rankGap + padding : 2 * padding; const width = lr ? totalAlong : maxSpan + 2 * padding; const height = lr ? maxSpan + 2 * padding : totalAlong; // 5. Edges. const placedEdges: PlacedEdge[] = edges.map((e, i) => { const a = placed[index.get(e.from)!]; const b = placed[index.get(e.to)!]; const isBack = back.has(i); const start = lr ? { x: a.x + a.width, y: a.y + a.height / 2 } : { x: a.x + a.width / 2, y: a.y + a.height }; const end = lr ? { x: b.x, y: b.y + b.height / 2 } : { x: b.x + b.width / 2, y: b.y }; return { edge: e, id: edgeId(e), from: e.from, to: e.to, start, end, back: isBack, path: edgeShape === "step" ? stepPath(start, end, lr, cornerRadius) : curvePath(start, end, lr), }; }); return { nodes: placed, edges: placedEdges, ranks: ranks.map((r) => r.map((v) => nodes[v].id)), width, height, byId: new Map(placed.map((p) => [p.id, p])), }; } type Pt = { x: number; y: number }; const f = (n: number) => Math.round(n * 100) / 100; /** A smooth S-curve between two ports, tangent to the flow direction at both ends. */ export function curvePath(a: Pt, b: Pt, lr = true): string { if (lr) { const dx = Math.max(16, Math.abs(b.x - a.x) / 2); return `M${f(a.x)},${f(a.y)} C${f(a.x + dx)},${f(a.y)} ${f(b.x - dx)},${f(b.y)} ${f(b.x)},${f(b.y)}`; } const dy = Math.max(16, Math.abs(b.y - a.y) / 2); return `M${f(a.x)},${f(a.y)} C${f(a.x)},${f(a.y + dy)} ${f(b.x)},${f(b.y - dy)} ${f(b.x)},${f(b.y)}`; } /** An orthogonal edge that turns once at the midpoint with rounded corners. */ export function stepPath(a: Pt, b: Pt, lr = true, radius = 8): string { // Work in "along/across" space so one routine serves both directions. const A = lr ? [a.x, a.y] : [a.y, a.x]; const B = lr ? [b.x, b.y] : [b.y, b.x]; const pt = (al: number, ac: number) => (lr ? `${f(al)},${f(ac)}` : `${f(ac)},${f(al)}`); const d = B[1] - A[1]; if (Math.abs(d) < 0.5) return `M${pt(A[0], A[1])} L${pt(B[0], B[1])}`; const mid = (A[0] + B[0]) / 2; const s = Math.sign(d); const r = Math.max(0, Math.min(radius, Math.abs(d) / 2, Math.abs(B[0] - A[0]) / 2)); return [ `M${pt(A[0], A[1])}`, `L${pt(mid - r, A[1])}`, `Q${pt(mid, A[1])} ${pt(mid, A[1] + s * r)}`, `L${pt(mid, B[1] - s * r)}`, `Q${pt(mid, B[1])} ${pt(mid + r, B[1])}`, `L${pt(B[0], B[1])}`, ].join(" "); } /** * A view transform that fits the layout (or centres one node, for "search glides the viewport * to the match") inside a `width × height` viewport. Apply as `translate(x, y) scale(scale)`; * spring between two results to glide. */ export function fitView( layout: Pick, viewport: { width: number; height: number }, { focus, padding = 16, maxScale = 1, minScale = 0.25 }: { focus?: string; padding?: number; maxScale?: number; minScale?: number } = {}, ) { const fit = Math.min((viewport.width - 2 * padding) / Math.max(1, layout.width), (viewport.height - 2 * padding) / Math.max(1, layout.height)); const scale = Math.max(minScale, Math.min(maxScale, fit)); const node = focus ? layout.byId.get(focus) : undefined; const cx = node ? node.x + node.width / 2 : layout.width / 2; const cy = node ? node.y + node.height / 2 : layout.height / 2; return { scale, x: viewport.width / 2 - cx * scale, y: viewport.height / 2 - cy * scale }; } 65:T1555,import { summarizeSteps, type StepSummary } from "../thinking-core/steps"; import { SETTLED_STEP, type StepStatus } from "../thinking-core/types"; import type { FlowEdge, FlowGraph, FlowNode } from "./types"; const statusOf = (n: FlowNode | undefined): StepStatus => n?.status ?? "pending"; /** * An edge's status from its two nodes, so a renderer only has to set node statuses: * * from complete, to active → active (the hand-off is happening: fill and flow) * from complete, to skipped → skipped * from complete, anything else → complete (the dependency is met) * from error or skipped → skipped (nothing will flow down it) * from pending or active → pending */ export function edgeStatus(from: StepStatus, to: StepStatus): StepStatus { if (from === "complete") return to === "active" ? "active" : to === "skipped" ? "skipped" : "complete"; if (from === "error" || from === "skipped") return "skipped"; return "pending"; } /** `edgeStatus` for an edge in a graph, honouring an explicit `edge.status`. */ export function resolveEdgeStatus(graph: FlowGraph, edge: FlowEdge, byId = nodeMap(graph)): StepStatus { return edge.status ?? edgeStatus(statusOf(byId.get(edge.from)), statusOf(byId.get(edge.to))); } /** Where an edge's `pathLength` should be for a status: drawn for active and complete, empty otherwise. */ export function edgeProgressTarget(status: StepStatus): number { return status === "active" || status === "complete" ? 1 : 0; } export const nodeMap = (graph: FlowGraph) => new Map(graph.nodes.map((n) => [n.id, n])); /** Ids of the nodes upstream of `id`. */ export function predecessors(graph: FlowGraph, id: string): string[] { return graph.edges.filter((e) => e.to === id).map((e) => e.from); } /** Every node reachable downstream of `id` (not including it). */ export function descendants(graph: FlowGraph, id: string): Set { const seen = new Set(); const stack = [id]; while (stack.length) { const v = stack.pop()!; for (const e of graph.edges) { if (e.from !== v || seen.has(e.to) || e.to === id) continue; seen.add(e.to); stack.push(e.to); } } return seen; } /** Pending nodes whose predecessors have all completed (or were skipped): what can start next. */ export function readyNodes(graph: FlowGraph): FlowNode[] { const byId = nodeMap(graph); return graph.nodes.filter( (n) => statusOf(n) === "pending" && predecessors(graph, n.id).every((p) => { const s = statusOf(byId.get(p)); return s === "complete" || s === "skipped"; }) && // A node downstream of a failure never becomes ready. !predecessors(graph, n.id).some((p) => statusOf(byId.get(p)) === "error"), ); } /** * Immutable status change for one node, stamping `startedAt` / `endedAt` like thinking-core's * `updateStep`. Setting `error` marks everything downstream that hasn't settled as `skipped` * unless `skipDownstream` is false. */ export function setNodeStatus(graph: FlowGraph, id: string, status: StepStatus, { now = Date.now(), skipDownstream = true } = {}): FlowGraph { const downstream = status === "error" && skipDownstream ? descendants(graph, id) : new Set(); return { ...graph, nodes: graph.nodes.map((n) => { if (n.id === id) return stamp(n, status, now); if (downstream.has(n.id) && !SETTLED_STEP.has(statusOf(n))) return stamp(n, "skipped", now); return n; }), }; } function stamp(n: FlowNode, status: StepStatus, now: number): FlowNode { const prev = statusOf(n); if (prev === status) return n; const next = { ...n, status }; if (status === "active" || status === "pending") { next.startedAt = status === "active" ? now : undefined; next.endedAt = undefined; } if (SETTLED_STEP.has(status) && !SETTLED_STEP.has(prev)) next.endedAt = now; return next; } /** * One beat of a run: settles every active node (`outcome` decides each one's fate, default * complete) and starts every node that became ready. Parallel branches advance together, a * failure skips its downstream. Drive a scripted CI or agent-run demo with it on a clock. * * setGraph((g) => stepFlow(g, { outcome: (n) => (n.id === "e2e" ? "error" : "complete") })); */ export function stepFlow( graph: FlowGraph, { outcome = () => "complete", now = Date.now() }: { outcome?: (node: FlowNode) => "complete" | "error" | "skipped"; now?: number } = {}, ): FlowGraph { let g = graph; const active = g.nodes.filter((n) => statusOf(n) === "active"); for (const n of active) g = setNodeStatus(g, n.id, outcome(n), { now }); // On the very first beat nothing is active yet: start the sources. for (const n of readyNodes(g)) g = setNodeStatus(g, n.id, "active", { now }); return g; } /** Every node back to pending, times cleared: the "retry" rewind. */ export function resetFlow(graph: FlowGraph): FlowGraph { return { ...graph, nodes: graph.nodes.map((n) => ({ ...n, status: "pending", startedAt: undefined, endedAt: undefined })) }; } /** thinking-core's `summarizeSteps` over the nodes: progress, current, status, durationMs. */ export function summarizeFlow(graph: FlowGraph): StepSummary { return summarizeSteps(graph.nodes.map((n) => ({ id: n.id, label: n.label, status: statusOf(n), startedAt: n.startedAt, endedAt: n.endedAt }))); } 66:T4d0,import type { StepStatus } from "../thinking-core/types"; export type { StepStatus }; /** One node of a flow: a CI job, an agent step, a payment hop, an approver. */ export type FlowNode = { /** Stable id: edges refer to it and renderers key by it. */ id: string; label: string; /** Where the node is. Shares thinking-core's frozen `StepStatus`. Default `pending`. */ status?: StepStatus; /** A secondary line: "2m 14s", "0.3% fee", "Partner". */ detail?: string; /** Epoch ms when it became active / settled (stamped by `setNodeStatus` and `stepFlow`). */ startedAt?: number; endedAt?: number; /** Size override for this node in the layout. */ width?: number; height?: number; /** Anything the renderer needs: an icon, an avatar, a fee. */ data?: D; }; /** A directed edge `from → to`. */ export type FlowEdge = { /** Defaults to `from->to`. */ id?: string; from: string; to: string; label?: string; /** Forces the edge's status; otherwise it is derived from its two nodes (`edgeStatus`). */ status?: StepStatus; }; export type FlowGraph = { nodes: FlowNode[]; edges: FlowEdge[] }; export const edgeId = (e: FlowEdge) => e.id ?? `${e.from}->${e.to}`; 60:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","motion",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/motion","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"motion"}]]}]}]]}],["$","$L61",null,{"namespace":"@registrydirectory","registryDependencies":["https://eased.dev/r/eased-tokens.json","https://eased.dev/r/eased-motion.json","https://eased.dev/r/eased-thinking-core.json"]}]]}],null]}],["$","$L62",null,{"files":[{"path":"src/registry/eased/_primitives/flow-core/edge-progress.tsx","content":"$63","type":"registry:lib","target":"@components/eased/_primitives/flow-core/edge-progress.tsx"},{"path":"src/registry/eased/_primitives/flow-core/flow-core.ts","content":"/**\n * flow-core: node/edge graphs for CI pipelines, agent runs, payment routes, org charts and\n * approval flows. A typed graph model whose statuses are thinking-core's `StepStatus`, a small\n * DAG auto layout, status propagation, and edges drawn on `pathLength`.\n * Import from here; the files behind it may move.\n */\nexport { edgeId, type FlowEdge, type FlowGraph, type FlowNode, type StepStatus } from \"./types\";\nexport {\n curvePath,\n fitView,\n layoutFlow,\n stepPath,\n type FlowDirection,\n type FlowLayout,\n type FlowLayoutOptions,\n type PlacedEdge,\n type PlacedNode,\n} from \"./layout\";\nexport {\n descendants,\n edgeProgressTarget,\n edgeStatus,\n nodeMap,\n predecessors,\n readyNodes,\n resetFlow,\n resolveEdgeStatus,\n setNodeStatus,\n stepFlow,\n summarizeFlow,\n} from \"./status\";\nexport { FlowEdgePath, useEdgeProgress, type EdgeProgressOptions, type FlowEdgePathProps } from \"./edge-progress\";\n","type":"registry:lib","target":"@components/eased/_primitives/flow-core/flow-core.ts"},{"path":"src/registry/eased/_primitives/flow-core/layout.ts","content":"$64","type":"registry:lib","target":"@components/eased/_primitives/flow-core/layout.ts"},{"path":"src/registry/eased/_primitives/flow-core/status.ts","content":"$65","type":"registry:lib","target":"@components/eased/_primitives/flow-core/status.ts"},{"path":"src/registry/eased/_primitives/flow-core/types.ts","content":"$66","type":"registry:lib","target":"@components/eased/_primitives/flow-core/types.ts"}],"className":"h-[70svh] min-h-80"}]]}]