effect-inspect 0.1.1 → 0.2.0

package/app/dist/server/assets/{routes-eZ4XqxE9.js → routes-BmnrEVoN.js}

@@ -1,139 +1,13 @@
-import { a as CollapseButton, c as PanelHeader, i as themeAtom, l as usePanel, n as DEFAULT_THEME, o as CollapsedRail, r as resolvedThemeAtom, s as Empty$1, u as Button } from "./router-CN98Ramo.js";
+import { a as CollapseButton, c as PanelHeader, i as themeAtom, l as usePanel, n as DEFAULT_THEME, o as CollapsedRail, r as resolvedThemeAtom, s as Empty$1, u as Button } from "./router-dMcw-pHq.js";
 import { useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { FilterX, Monitor, Moon, MousePointerClick, PlugZap, Radio, SearchX, Sun, X } from "lucide-react";
 import { RegistryContext, useAtom, useAtomMount, useAtomValue } from "@effect/atom-react";
 import { Atom } from "effect/unstable/reactivity";
 import { Data, Result, Schema } from "effect";
-//#region app/src/chart/Layout.ts
-var EMPTY$1 = {
-	version: -1,
-	rows: [],
-	rowOf: /* @__PURE__ */ new Map(),
-	duration: 0,
-	ordered: []
-};
-/** Effective end of a span: open spans run to `now` (the trace's right edge). */
-var spanEnd = (span, now) => span.end ?? now;
-/**
-* Returns a layout for the store's current version, reusing `previous` when
-* nothing has changed.
-*
-* **A span's row is final once assigned.** `previous.rowOf` is carried over
-* verbatim and only spans the previous layout never saw are packed. A late
-* arrival that fits nowhere takes a new row rather than repacking what the
-* user is already looking at — under a live trace, rows never reshuffle.
-*
-* The cost is deliberate and one-directional: a trace watched live can end up
-* taller than the same trace loaded from scratch, because a gap that opens up
-* later is never reclaimed. Visual stability beats vertical compactness.
-*/
-var layout = (store, previous = EMPTY$1) => {
-	if (previous.version === store.version) return previous;
-	const duration = store.stats().duration;
-	const ordered = [];
-	for (const ids of store.rows) for (const id of ids) {
-		const span = store.spans.get(id);
-		if (span !== void 0) ordered.push(span);
-	}
-	ordered.sort((a, b) => a.start - b.start || a.depth - b.depth);
-	const spansByRow = [];
-	const freeFrom = [];
-	const pinned = [];
-	const rowOf = /* @__PURE__ */ new Map();
-	const claim = (row, span, isPinned) => {
-		while (spansByRow.length <= row) {
-			spansByRow.push([]);
-			freeFrom.push(Number.NEGATIVE_INFINITY);
-			pinned.push([]);
-		}
-		const to = spanEnd(span, duration);
-		spansByRow[row].push(span);
-		if (isPinned) pinned[row].push({
-			from: span.start,
-			to
-		});
-		else if (to > freeFrom[row]) freeFrom[row] = to;
-		rowOf.set(span.spanId, row);
-	};
-	/** True when a span spanning `[from, to)` can be drawn on `row` untouched. */
-	const fits = (row, from, to) => {
-		if (row >= spansByRow.length) return true;
-		if (freeFrom[row] > from) return false;
-		return !pinned[row].some((i) => i.from < to && from < i.to);
-	};
-	if (ordered.length >= previous.ordered.length) for (const span of ordered) {
-		const pinnedRow = previous.rowOf.get(span.spanId);
-		if (pinnedRow !== void 0) claim(pinnedRow, span, true);
-	}
-	const rowFor = (span) => {
-		const parentRow = span.parentId === void 0 ? void 0 : rowOf.get(span.parentId);
-		const from = span.start;
-		const to = spanEnd(span, duration);
-		let row = parentRow === void 0 ? 0 : parentRow + 1;
-		while (!fits(row, from, to)) row++;
-		return row;
-	};
-	for (const span of ordered) {
-		if (rowOf.has(span.spanId)) continue;
-		claim(rowFor(span), span, false);
-	}
-	const rows = spansByRow.map((spans) => {
-		spans.sort((a, b) => a.start - b.start);
-		const maxEnd = new Float64Array(spans.length);
-		let running = Number.NEGATIVE_INFINITY;
-		for (let i = 0; i < spans.length; i++) {
-			const end = spanEnd(spans[i], duration);
-			if (end > running) running = end;
-			maxEnd[i] = running;
-		}
-		return {
-			spans,
-			maxEnd
-		};
-	});
-	return {
-		version: store.version,
-		rows,
-		rowOf,
-		duration,
-		ordered
-	};
-};
-var emptyLayout = () => EMPTY$1;
-/**
-* Index of the first span in `row` that can intersect `[from, to]`.
-*
-* Binary searches the prefix-maximum of end times: everything before the
-* result ends strictly before `from`, so it is safely skipped. Returns
-* `row.spans.length` when nothing intersects.
-*/
-var firstVisible = (row, from) => {
-	let lo = 0;
-	let hi = row.spans.length;
-	while (lo < hi) {
-		const mid = lo + hi >>> 1;
-		if (row.maxEnd[mid] < from) lo = mid + 1;
-		else hi = mid;
-	}
-	return lo;
-};
-/**
-* Walks the spans of `row` intersecting `[from, to]`, in start order.
-*
-* Stops as soon as a span starts after `to` — the row is start-sorted, so
-* everything after it starts later still.
-*/
-var forEachVisible = (row, from, to, now, visit) => {
-	for (let i = firstVisible(row, from); i < row.spans.length; i++) {
-		const span = row.spans[i];
-		if (span.start > to) return;
-		if (spanEnd(span, now) >= from) visit(span);
-	}
-};
-//#endregion
-//#region app/src/chart/metrics.ts
-/** Span timing derived the same way for the chart, the tooltip, the log and the drawer. */
+//#region src/trace/Timing.ts
+/** A span's end, or `now` while it is still open. */
+var spanEnd$1 = (span, now) => span.end ?? now;
 /**
 * Time covered by the union of `span`'s direct children, clipped to `[from, to]`.
 *
@@ -151,7 +25,7 @@ var childUnion = (store, span, now, from, to) => {
 		const child = store.spans.get(id);
 		if (child === void 0) continue;
 		const lo = Math.max(child.start, from);
-		const hi = Math.min(spanEnd(child, now), to);
+		const hi = Math.min(spanEnd$1(child, now), to);
 		if (hi > lo) intervals.push([lo, hi]);
 	}
 	if (intervals.length === 0) return 0;
@@ -179,7 +53,7 @@ var childUnion = (store, span, now, from, to) => {
 */
 var timings = (store, span, now, from = -Infinity, to = Infinity) => {
 	const lo = Math.max(span.start, from);
-	const hi = Math.min(spanEnd(span, now), to);
+	const hi = Math.min(spanEnd$1(span, now), to);
 	if (hi <= lo) return {
 		total: 0,
 		self: 0
@@ -244,7 +118,7 @@ var memoryCollapsedAtom = Atom.make(false);
 * Rebuilt when the viewport, the filter or `store.version` changes — never per
 * frame. The drawer is not in the chart's draw path at all.
 */
-var EMPTY = {
+var EMPTY$1 = {
 	summary: [],
 	callTree: [],
 	bottomUp: [],
@@ -310,7 +184,7 @@ var aggregate = (store, from, to, filter, hides) => {
 			self
 		});
 	}
-	if (visible.length === 0) return EMPTY;
+	if (visible.length === 0) return EMPTY$1;
 	visible.sort((a, b) => a.span.start - b.span.start);
 	const byName = /* @__PURE__ */ new Map();
 	for (const timing of visible) add(descend(byName, "", timing.span.name, timing.span.spanId), timing, timing.self);
@@ -386,7 +260,12 @@ var Json = Schema.Union([
 ]);
 /** Span attributes, log annotations, and metric/event attributes. */
 var Attributes = Schema.Record(Schema.String, Json);
-/** Identifies one run of an instrumented program. */
+/**
+* Identifies one run of an instrumented program.
+*
+* Any string on the wire, so traces from older clients keep decoding. IDs a
+* caller chooses are held to {@link isValidSessionId} by the client instead.
+*/
 var SessionId = Schema.String;
 var sessionId = { sessionId: SessionId };
 /** Mirrors `Tracer.SpanKind`. */
@@ -427,7 +306,14 @@ var Hello = Schema.Struct({
 	pid: Schema.Natural,
 	runtime: Schema.String,
 	protocolVersion: Schema.Natural,
-	clock: Clock
+	clock: Clock,
+	/**
+	* Random per client instance, fixed for its lifetime and re-sent on every
+	* reconnect. Tells a genuine reconnect (same instance) from an independent
+	* run that chose the same `sessionId`. Absent from older clients, which are
+	* treated as one instance per `sessionId`.
+	*/
+	instanceId: Schema.optional(Schema.String)
 });
 /**
 * A span parent that lives outside this session's span tree — propagated from
@@ -624,7 +510,13 @@ var Session = Schema.Struct({
 	runtime: Schema.String,
 	clock: Clock,
 	active: Schema.Boolean,
-	endedAtEpochMillis: Schema.optional(Schema.Natural)
+	endedAtEpochMillis: Schema.optional(Schema.Natural),
+	/**
+	* Connections refused because a different client instance announced this
+	* `sessionId` — an ID collision. Their telemetry was discarded, so this
+	* session holds only the first instance's run. Absent when there were none.
+	*/
+	conflicts: Schema.optional(Schema.Natural)
 });
 /** Every session the collector holds. Sent on connect and on change. */
 var SessionList = Schema.Struct({
@@ -684,6 +576,22 @@ var Unsubscribe = Schema.Struct({
 /** What the webapp sends to the collector. */
 var WebappRequest = Schema.Union([Subscribe, Unsubscribe]);
 /**
+* Collector-side loss counters for one session at snapshot time, carried in
+* a trace file exported from the collector.
+*/
+var TraceCapture = Schema.Struct({
+	/** Messages evicted by the collector's per-session capacity bound. */
+	droppedMessages: Schema.Natural,
+	/** Lines received for the session that could not be decoded. */
+	skippedLines: Schema.Natural,
+	/**
+	* Whether the collector could refuse an independent run reusing this ID.
+	* `false` when the owning client predates instance IDs, so a reused ID
+	* would have merged silently and `session.conflicts` proves nothing.
+	*/
+	conflictDetection: Schema.Boolean
+});
+/**
 * Line 1 of a saved trace file.
 *
 * The rest of the file is {@link ClientMessage} NDJSON, byte-identical to what
@@ -702,7 +610,14 @@ var TraceFileHeader = Schema.Struct({
 	/** {@link protocolVersion} at save time. Recorded for diagnosis, not enforced. */
 	protocolVersion: Schema.Natural,
 	session: Session,
-	savedAtEpochMillis: Schema.Natural
+	savedAtEpochMillis: Schema.Natural,
+	/**
+	* What the collector knew about loss when the file was exported from it.
+	* Absent from browser saves and older files: their capture completeness is
+	* unknown, not complete. Optional and additive, so older builds, which
+	* ignore unknown header keys, still read these files.
+	*/
+	capture: Schema.optional(TraceCapture)
 });
 //#endregion
 //#region src/protocol/Codec.ts
@@ -754,7 +669,7 @@ var webappRequestCodec = make(WebappRequest);
 /** Line 1 of a saved trace file; the rest of the file is {@link clientCodec} lines. */
 var traceFileHeaderCodec = make(TraceFileHeader);
 //#endregion
-//#region app/src/trace/TraceFile.ts
+//#region src/trace/TraceFile.ts
 /**
 * Saving a trace to a file and loading it back.
 *
@@ -776,38 +691,26 @@ var fail = (message) => Result.fail({
 	message
 });
 /**
-* Prefix on a loaded session's id.
-*
-* Without it, loading a trace exported from the collector you are currently
-* connected to would collide with the live session of the same id and the two
-* would fight over the selection.
-*/
-var loadedSessionPrefix = "loaded:";
-/** True for a session id produced by {@link parseTraceFile}. */
-var isLoadedSession = (sessionId) => sessionId.startsWith(loadedSessionPrefix);
-/**
 * Serializes a session and its messages to trace-file text.
 *
 * `messages` is the raw protocol stream in arrival order — not a re-derivation
 * from the rendered trace model, which would silently drop every message the
-* model does not draw.
+* model does not draw. `capture` is written only when the caller knows the
+* collector's loss counters; omitting it marks completeness as unknown.
 */
-var serializeTraceFile = (session, messages, savedAtEpochMillis) => {
+var serializeTraceFile = (session, messages, savedAtEpochMillis, capture) => {
 	const header = traceFileHeaderCodec.encode({
 		_tag: "TraceFileHeader",
 		formatVersion: 1,
 		protocolVersion: 1,
 		session,
-		savedAtEpochMillis
+		savedAtEpochMillis,
+		...capture === void 0 ? {} : { capture }
 	});
 	const body = [];
 	for (const message of messages) body.push(clientCodec.encode(message));
 	return header + body.join("");
 };
-/** A filename safe on every platform, carrying the program and save time. */
-var traceFileName = (session, savedAtEpochMillis) => {
-	return `${(session.program.split(/[/\\]/).pop() ?? "trace").replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "trace"}-${new Date(savedAtEpochMillis).toISOString().replace(/[:.]/g, "-").slice(0, 19)}${traceFileExtension}`;
-};
 /**
 * Parses trace-file text.
 *
@@ -844,6 +747,22 @@ var parseTraceFile = (text) => {
 		truncatedLines
 	});
 };
+//#endregion
+//#region app/src/trace/TraceFile.ts
+/**
+* Prefix on a loaded session's id.
+*
+* Without it, loading a trace exported from the collector you are currently
+* connected to would collide with the live session of the same id and the two
+* would fight over the selection.
+*/
+var loadedSessionPrefix = "loaded:";
+/** True for a session id produced by {@link parseTraceFile}. */
+var isLoadedSession = (sessionId) => sessionId.startsWith(loadedSessionPrefix);
+/** A filename safe on every platform, carrying the program and save time. */
+var traceFileName = (session, savedAtEpochMillis) => {
+	return `${(session.program.split(/[/\\]/).pop() ?? "trace").replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "trace"}-${new Date(savedAtEpochMillis).toISOString().replace(/[:.]/g, "-").slice(0, 19)}${traceFileExtension}`;
+};
 /** The `Session` a loaded trace lists as: never active, id namespaced so it cannot collide. */
 var loadedSession = (header) => ({
 	...header.session,
@@ -852,7 +771,7 @@ var loadedSession = (header) => ({
 	endedAtEpochMillis: header.session.endedAtEpochMillis ?? header.savedAtEpochMillis
 });
 //#endregion
-//#region app/src/trace/TraceStore.ts
+//#region src/trace/TraceStore.ts
 var NANOS_PER_MILLI = 1000000n;
 /**
 * Converts protocol nanos to milliseconds relative to `origin`, as a `number`.
@@ -1412,6 +1331,133 @@ var saveableMessages = (registry, sessionId) => {
 	return registry.get(loadedSessionsAtom).find((entry) => entry.session.sessionId === sessionId)?.messages ?? traceStore.raw;
 };
 //#endregion
+//#region app/src/chart/Layout.ts
+var EMPTY = {
+	version: -1,
+	rows: [],
+	rowOf: /* @__PURE__ */ new Map(),
+	duration: 0,
+	ordered: []
+};
+/** Effective end of a span: open spans run to `now` (the trace's right edge). */
+var spanEnd = (span, now) => span.end ?? now;
+/**
+* Returns a layout for the store's current version, reusing `previous` when
+* nothing has changed.
+*
+* **A span's row is final once assigned.** `previous.rowOf` is carried over
+* verbatim and only spans the previous layout never saw are packed. A late
+* arrival that fits nowhere takes a new row rather than repacking what the
+* user is already looking at — under a live trace, rows never reshuffle.
+*
+* The cost is deliberate and one-directional: a trace watched live can end up
+* taller than the same trace loaded from scratch, because a gap that opens up
+* later is never reclaimed. Visual stability beats vertical compactness.
+*/
+var layout = (store, previous = EMPTY) => {
+	if (previous.version === store.version) return previous;
+	const duration = store.stats().duration;
+	const ordered = [];
+	for (const ids of store.rows) for (const id of ids) {
+		const span = store.spans.get(id);
+		if (span !== void 0) ordered.push(span);
+	}
+	ordered.sort((a, b) => a.start - b.start || a.depth - b.depth);
+	const spansByRow = [];
+	const freeFrom = [];
+	const pinned = [];
+	const rowOf = /* @__PURE__ */ new Map();
+	const claim = (row, span, isPinned) => {
+		while (spansByRow.length <= row) {
+			spansByRow.push([]);
+			freeFrom.push(Number.NEGATIVE_INFINITY);
+			pinned.push([]);
+		}
+		const to = spanEnd(span, duration);
+		spansByRow[row].push(span);
+		if (isPinned) pinned[row].push({
+			from: span.start,
+			to
+		});
+		else if (to > freeFrom[row]) freeFrom[row] = to;
+		rowOf.set(span.spanId, row);
+	};
+	/** True when a span spanning `[from, to)` can be drawn on `row` untouched. */
+	const fits = (row, from, to) => {
+		if (row >= spansByRow.length) return true;
+		if (freeFrom[row] > from) return false;
+		return !pinned[row].some((i) => i.from < to && from < i.to);
+	};
+	if (ordered.length >= previous.ordered.length) for (const span of ordered) {
+		const pinnedRow = previous.rowOf.get(span.spanId);
+		if (pinnedRow !== void 0) claim(pinnedRow, span, true);
+	}
+	const rowFor = (span) => {
+		const parentRow = span.parentId === void 0 ? void 0 : rowOf.get(span.parentId);
+		const from = span.start;
+		const to = spanEnd(span, duration);
+		let row = parentRow === void 0 ? 0 : parentRow + 1;
+		while (!fits(row, from, to)) row++;
+		return row;
+	};
+	for (const span of ordered) {
+		if (rowOf.has(span.spanId)) continue;
+		claim(rowFor(span), span, false);
+	}
+	const rows = spansByRow.map((spans) => {
+		spans.sort((a, b) => a.start - b.start);
+		const maxEnd = new Float64Array(spans.length);
+		let running = Number.NEGATIVE_INFINITY;
+		for (let i = 0; i < spans.length; i++) {
+			const end = spanEnd(spans[i], duration);
+			if (end > running) running = end;
+			maxEnd[i] = running;
+		}
+		return {
+			spans,
+			maxEnd
+		};
+	});
+	return {
+		version: store.version,
+		rows,
+		rowOf,
+		duration,
+		ordered
+	};
+};
+var emptyLayout = () => EMPTY;
+/**
+* Index of the first span in `row` that can intersect `[from, to]`.
+*
+* Binary searches the prefix-maximum of end times: everything before the
+* result ends strictly before `from`, so it is safely skipped. Returns
+* `row.spans.length` when nothing intersects.
+*/
+var firstVisible = (row, from) => {
+	let lo = 0;
+	let hi = row.spans.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (row.maxEnd[mid] < from) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+};
+/**
+* Walks the spans of `row` intersecting `[from, to]`, in start order.
+*
+* Stops as soon as a span starts after `to` — the row is start-sorted, so
+* everything after it starts later still.
+*/
+var forEachVisible = (row, from, to, now, visit) => {
+	for (let i = firstVisible(row, from); i < row.spans.length; i++) {
+		const span = row.spans[i];
+		if (span.start > to) return;
+		if (spanEnd(span, now) >= from) visit(span);
+	}
+};
+//#endregion
 //#region app/src/chart/palette.ts
 /**
 * Resolves one custom property against `<html>`.

package/app/dist/server/server.js

@@ -91,7 +91,7 @@ var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
 * the dev styles URL for route-scoped CSS collection.
 */
 async function getStartManifest(matchedRoutes) {
-	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-CFQ3DEVN.js");
+	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-B2BMiICr.js");
 	const startManifest = tsrStartManifest();
 	let routes = startManifest.routes;
 	routes[rootRouteId];
@@ -1356,7 +1356,7 @@ var getBaseManifest = getProdBaseManifest;
 var createEarlyHintsForRequest = createEarlyHintsCollector;
 async function loadEntries() {
 	const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
-		import("./assets/router-CN98Ramo.js").then((n) => n.t),
+		import("./assets/router-dMcw-pHq.js").then((n) => n.t),
 		import("./assets/start-5Z2QO8AU.js"),
 		import("./assets/empty-plugin-adapters-D9UWiqvJ.js")
 	]);

package/dist/cli/QueryCommands.d.ts

@@ -0,0 +1,127 @@
+/**
+ * The query commands of the `effect-inspect` CLI: `sessions`, `summary`,
+ * `spans`, `span`, `logs` and `export`.
+ *
+ * Every command prints exactly one JSON document on stdout (pretty, or compact
+ * with `--json`) and, on failure, one diagnostic on stderr; the exit code
+ * names the failure (see {@link exitCodes}). Live queries go through
+ * `query/Client.ts`, file queries through `Query.queryFile`, so both answer
+ * with the one contract of `query/Query.ts`.
+ *
+ * The help text here is the primary manual for agents driving the CLI, so it
+ * spells out the whole local contract: sources, flags, defaults, JSON shapes,
+ * errors and exit codes.
+ */
+import { Effect, Option } from 'effect';
+import { FileSystem } from 'effect/FileSystem';
+import * as Stdio from 'effect/Stdio';
+import { Command } from 'effect/unstable/cli';
+import * as Query from '../query/Query.ts';
+/** Process exit code per outcome. `1` is reserved for unexpected internal errors. */
+export declare const exitCodes: Readonly<Record<Query.ErrorTag, number>>;
+declare const CliExit_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CliExit";
+} & Readonly<A>;
+/** A handled failure: its JSON is already printed, only the exit code is left. */
+declare class CliExit extends CliExit_base<{
+    readonly code: number;
+}> {
+}
+/** `export`'s success document. */
+export interface ExportResponse {
+    readonly ok: true;
+    readonly apiVersion: typeof Query.apiVersion;
+    readonly op: 'export';
+    readonly query: {
+        readonly op: 'export';
+        readonly sessionId: string;
+        readonly out: string;
+        readonly force: boolean;
+    };
+    readonly result: {
+        readonly sessionId: string;
+        readonly file: string;
+        readonly bytes: number;
+    };
+}
+type Response = Query.QueryResponse | ExportResponse;
+/**
+ * The exact stdout text for `response`, held to `Query.limits.responseBytes`
+ * as emitted: after formatting, trailing newline included. The query layer
+ * bounds compact JSON only, so indentation (or the newline) can still push a
+ * page over; that becomes a small fixed-shape `ResponseTooLarge` instead.
+ */
+export declare const renderBounded: (response: Response, json: boolean) => {
+    readonly response: Response;
+    readonly text: string;
+};
+/** The query subcommands, in investigation order. */
+export declare const queryCommands: readonly [Command.Command<"summary", {
+    readonly session: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly top: Option.Option<number>;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>, Command.Command<"spans", {
+    readonly limit: Option.Option<number>;
+    readonly offset: Option.Option<number>;
+    readonly fromMs: Option.Option<number>;
+    readonly toMs: Option.Option<number>;
+    readonly session: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly status: Option.Option<"any" | "defect" | "error" | "failed" | "interrupted" | "ok" | "open">;
+    readonly name: Option.Option<string>;
+    readonly minDurationMs: Option.Option<number>;
+    readonly sort: Option.Option<"duration" | "outsideChildren" | "start">;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>, Command.Command<"span", {
+    readonly session: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly span: string;
+    readonly children: Option.Option<number>;
+    readonly events: Option.Option<number>;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>, Command.Command<"logs", {
+    readonly limit: Option.Option<number>;
+    readonly offset: Option.Option<number>;
+    readonly fromMs: Option.Option<number>;
+    readonly toMs: Option.Option<number>;
+    readonly session: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly span: Option.Option<string>;
+    readonly scope: Option.Option<"span" | "subtree">;
+    readonly minLevel: Option.Option<"Debug" | "Error" | "Fatal" | "Info" | "Trace" | "Warn">;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>, Command.Command<"export", {
+    readonly session: Option.Option<string>;
+    readonly out: Option.Option<string>;
+    readonly force: boolean;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>, Command.Command<"sessions", {
+    readonly limit: Option.Option<number>;
+    readonly offset: Option.Option<number>;
+    readonly file: Option.Option<string>;
+    readonly url: Option.Option<string>;
+    readonly timeoutMs: Option.Option<number>;
+    readonly json: boolean;
+}, {}, CliExit, FileSystem | Stdio.Stdio>];
+/**
+ * Runs `cli` on `args` and resolves to the process exit code.
+ *
+ * For a query command (without `--help`/`--version`) the parser's own help dump
+ * on a usage error is suppressed: its errors become one `InvalidRequest` JSON
+ * on stdout, a stderr diagnostic and exit 2, so stdout stays machine-readable.
+ * Other invocations (`start`, the root, help) render exactly as the framework
+ * does.
+ */
+export declare const runCli: <Name extends string, Input, E, R, ContextInput>(cli: Command.Command<Name, Input, ContextInput, E, R>, version: string, args: ReadonlyArray<string>) => Effect.Effect<number, Exclude<E, import("effect/Terminal").QuitError>, Exclude<R, never> | Command.Environment>;
+export {};