@hediet/linkrpc-cli 0.0.1

package/dist/chunks/runUi-D-8LMU4F.js

@@ -0,0 +1,1143 @@
+import { D as formatPrincipalSource, L as validateValueAgainstSchema, S as fetchSchema, T as walkHubDetailed, b as setupSigning, k as connect, x as fetchDefaults } from "./runComplete-BkQwzPbF.js";
+import { a as observableValue, c as Disposable, i as ObservablePromise, o as autorun, r as ObservableLazyPromise, s as derived } from "./cli-D_-vlAa2.js";
+import { n as useObservable, t as useScroll } from "./scroll-BTzAYh4N.js";
+import { ChannelConnector, RpcError, SigningSender } from "@hediet/linkrpc";
+import { isHubEndpoint, openHubChannel } from "@hediet/linkrpc/node";
+import React from "react";
+import { Box, Text, render, useApp, useInput, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/ui/UiModel.ts
+/**
+* View model for the TUI. Owns the live channel and an in-memory schema cache
+* keyed by interface id. Loading state for every async lookup is expressed as
+* an `ObservablePromise` from `@vscode/observables` — no ad-hoc loading flags.
+*/
+var UiModel = class extends Disposable {
+	_channel;
+	/** Initial directory fetch — kicked off in the constructor. */
+	servicesPromise;
+	/** Non-fatal discovery failures for services that could not be inspected. */
+	discoveryWarnings = observableValue("UiModel.discoveryWarnings", []);
+	selection = observableValue("UiModel.selection", void 0);
+	formValues = observableValue("UiModel.formValues", {});
+	/** Index of the currently-focused form field (clamped at render time). */
+	formCursor = observableValue("UiModel.formCursor", 0);
+	/** True when the focused field is in input mode (text being typed). */
+	formEditing = observableValue("UiModel.formEditing", false);
+	/** Which Miller column currently owns keyboard focus. */
+	focusedColumn = observableValue("UiModel.focusedColumn", 0);
+	rawJsonMode = observableValue("UiModel.rawJsonMode", false);
+	rawJsonText = observableValue("UiModel.rawJsonText", "{}");
+	history = observableValue("UiModel.history", []);
+	/**
+	* Wraps the in-flight call (if any). `undefined` until the user first
+	* submits, then re-assigned on each submit. The view reads
+	* `promiseResult` to render loading / result / error.
+	*/
+	lastCall = observableValue("UiModel.lastCall", void 0);
+	/**
+	* Server→client stream messages received during the in-flight call.
+	* Reset to `[]` on each `submit()`, then appended to as `$stream::send`
+	* notifications arrive. The view renders these live below the result.
+	*/
+	streamChunks = observableValue("UiModel.streamChunks", []);
+	/**
+	* One-line, human-readable description of the identity signing outbound
+	* calls (e.g. `managed (node abcd012345…)`). Rendered in the header.
+	* `undefined` until `runUi` resolves the principal.
+	*/
+	identity = observableValue("UiModel.identity", void 0);
+	/**
+	* Per-interface schema cache. `ObservableLazyPromise` defers the actual
+	* fetch until something asks for it; the autorun below makes "something
+	* asks" happen whenever a method on that interface is selected.
+	*/
+	_schemas = /* @__PURE__ */ new Map();
+	constructor(_channel) {
+		super();
+		this._channel = _channel;
+		this.servicesPromise = ObservablePromise.fromFn(async () => {
+			const result = await loadUiServices(_channel);
+			this.discoveryWarnings.set(result.warnings, void 0);
+			return result.services;
+		});
+		this.servicesPromise.promise.catch(() => {});
+		this._register(autorun((reader) => {
+			const sel = this.selection.read(reader);
+			if (!sel) return;
+			this._getOrCreateSchema(sel.serviceId, sel.interfaceId, sel.isDefault === true).getPromise().catch(() => {});
+		}));
+		this._register(autorun((reader) => {
+			if (this.focusedColumn.read(reader) !== 1) return;
+			const sel = this.selection.read(reader);
+			if (!sel || sel.methodName !== void 0) return;
+			const methods = this.currentMethods.read(reader);
+			if (methods.length === 0) return;
+			this.selection.set({
+				...sel,
+				methodName: methods[0].name
+			}, void 0);
+		}));
+	}
+	currentSchemaState = derived(this, (reader) => {
+		const sel = this.selection.read(reader);
+		if (!sel) return { kind: "none" };
+		const result = this._getOrCreateSchema(sel.serviceId, sel.interfaceId, sel.isDefault === true).cachedPromiseResult.read(reader);
+		if (!result) return { kind: "loading" };
+		if (result.error) return {
+			kind: "error",
+			error: result.error
+		};
+		const schema = result.data;
+		const methodSchema = sel.methodName !== void 0 ? schema.methods[sel.methodName] : void 0;
+		return {
+			kind: "loaded",
+			schema,
+			method: methodSchema && sel.methodName !== void 0 ? {
+				...methodSchema,
+				name: sel.methodName
+			} : void 0
+		};
+	});
+	/** Flat list of top-level fields for the currently-selected method. */
+	currentFields = derived(this, (reader) => {
+		const state = this.currentSchemaState.read(reader);
+		if (state.kind !== "loaded" || !state.method) return [];
+		const paramsSchema = state.method.params;
+		return collectTopLevelFields(paramsSchema, state.schema.components?.schemas ?? {});
+	});
+	/** All methods on the currently-selected interface (column 2). */
+	currentMethods = derived(this, (reader) => {
+		const state = this.currentSchemaState.read(reader);
+		return state.kind === "loaded" ? Object.entries(state.schema.methods).map(([name, method]) => ({
+			name,
+			...method
+		})) : [];
+	});
+	/**
+	* Whether the currently-selected method declares stream payloads in
+	* either direction. Drives the "streaming" affordance in the view.
+	*/
+	currentMethodStreams = derived(this, (reader) => {
+		const state = this.currentSchemaState.read(reader);
+		if (state.kind !== "loaded" || !state.method) return {
+			server: false,
+			client: false
+		};
+		return {
+			server: state.method.serverStream !== void 0,
+			client: state.method.clientStream !== void 0
+		};
+	});
+	/** Per-field validation errors against the live method schema. */
+	formErrors = derived(this, (reader) => {
+		const state = this.currentSchemaState.read(reader);
+		const errors = /* @__PURE__ */ new Map();
+		if (state.kind !== "loaded" || !state.method) return errors;
+		const paramsSchema = state.method.params;
+		const components = state.schema.components?.schemas ?? {};
+		const resolvedParamsSchema = resolveSchema(paramsSchema, components);
+		if (!isObjectSchema(resolvedParamsSchema)) return errors;
+		const values = this.formValues.read(reader);
+		const required = new Set(resolvedParamsSchema.required ?? []);
+		for (const [name, sub] of Object.entries(resolvedParamsSchema.properties)) {
+			const value = values[name];
+			if (value === void 0) {
+				if (required.has(name)) errors.set(name, "required");
+				continue;
+			}
+			const reason = validateValueAgainstSchema(value, sub, components);
+			if (reason !== void 0) errors.set(name, reason);
+		}
+		return errors;
+	});
+	canSubmit = derived(this, (reader) => {
+		const sel = this.selection.read(reader);
+		if (!sel || sel.methodName === void 0) return false;
+		const state = this.currentSchemaState.read(reader);
+		if (state.kind !== "loaded" || !state.method) return false;
+		return this.formErrors.read(reader).size === 0;
+	});
+	select(key) {
+		this.selection.set(key, void 0);
+		this.formValues.set({}, void 0);
+		this.rawJsonText.set("{}", void 0);
+		this.formCursor.set(0, void 0);
+		this.formEditing.set(false, void 0);
+	}
+	/** Pick a concrete method on the currently-selected service/interface. */
+	selectMethod(methodName) {
+		const sel = this.selection.get();
+		if (!sel) return;
+		this.select({
+			...sel,
+			methodName
+		});
+	}
+	focusColumn(column) {
+		this.focusedColumn.set(column, void 0);
+	}
+	/**
+	* Move the column-0 cursor by `delta`. The cursor is implicit: it's the
+	* row whose `(serviceId, interfaceId)` matches the current selection.
+	* Stepping off the ends clamps; methodName is cleared so the methods
+	* column re-previews the new service.
+	*/
+	moveServiceCursor(delta) {
+		const services = this.servicesPromise.promiseResult.get()?.data ?? [];
+		if (services.length === 0) return;
+		const sel = this.selection.get();
+		const currentIdx = sel ? services.findIndex((s) => s.serviceId === sel.serviceId && s.interfaceId === sel.interfaceId && s.isDefault === true === (sel.isDefault === true)) : -1;
+		const next = services[Math.max(0, Math.min(services.length - 1, currentIdx + delta))];
+		this.select({
+			serviceId: next.serviceId,
+			interfaceId: next.interfaceId,
+			methodName: void 0,
+			...next.isDefault === true ? { isDefault: true } : {}
+		});
+	}
+	/**
+	* Move the column-1 cursor by `delta`. Triggers a full `select()` so the
+	* form column starts fresh for the newly-previewed method (Miller-style
+	* "each cursor move is a new preview").
+	*/
+	moveMethodCursor(delta) {
+		const methods = this.currentMethods.get();
+		if (methods.length === 0) return;
+		const sel = this.selection.get();
+		if (!sel) return;
+		const currentIdx = sel.methodName !== void 0 ? methods.findIndex((m) => m.name === sel.methodName) : -1;
+		const nextIdx = Math.max(0, Math.min(methods.length - 1, currentIdx + delta));
+		this.selectMethod(methods[nextIdx].name);
+	}
+	setField(name, value) {
+		const current = this.formValues.get();
+		if (value === void 0) {
+			const { [name]: _drop, ...rest } = current;
+			this.formValues.set(rest, void 0);
+			return;
+		}
+		this.formValues.set({
+			...current,
+			[name]: value
+		}, void 0);
+	}
+	/**
+	* Returns the exact `{ method, params }` `submit` would send right
+	* now, or `undefined` when no method is fully selected. Lets a host
+	* (e.g. the explorer's access-request prompt) preview the concrete
+	* call before issuing a one-shot capability bound to it.
+	*/
+	peekPendingCall() {
+		const sel = this.selection.get();
+		if (!sel || sel.methodName === void 0) return void 0;
+		const params = this._collectParams();
+		return {
+			method: sel.isDefault === true ? sel.methodName : sel.serviceId ? `${sel.serviceId}::${sel.interfaceId}::${sel.methodName}` : `${sel.interfaceId}::${sel.methodName}`,
+			params
+		};
+	}
+	submit() {
+		const sel = this.selection.get();
+		if (!sel || sel.methodName === void 0) return;
+		const params = this._collectParams();
+		const wireMethod = sel.isDefault === true ? sel.methodName : sel.serviceId ? `${sel.serviceId}::${sel.interfaceId}::${sel.methodName}` : `${sel.interfaceId}::${sel.methodName}`;
+		const start = performance.now();
+		this.streamChunks.set([], void 0);
+		const promise = ObservablePromise.fromFn(async () => {
+			return {
+				result: await this._channel.sendRequestWithStream(wireMethod, params, { onStreamMessage: (payload) => {
+					this.streamChunks.set([...this.streamChunks.get(), payload], void 0);
+				} }).result,
+				latencyMs: performance.now() - start
+			};
+		});
+		this.lastCall.set(promise, void 0);
+		promise.promise.then((outcome) => {
+			this.history.set([...this.history.get(), {
+				method: wireMethod,
+				params,
+				result: outcome.result,
+				error: void 0,
+				latencyMs: outcome.latencyMs,
+				timestamp: Date.now()
+			}], void 0);
+		}, (error) => {
+			const latencyMs = performance.now() - start;
+			this.history.set([...this.history.get(), {
+				method: wireMethod,
+				params,
+				result: void 0,
+				error,
+				latencyMs,
+				timestamp: Date.now()
+			}], void 0);
+		});
+	}
+	_collectParams() {
+		if (this.rawJsonMode.get()) {
+			const text = this.rawJsonText.get().trim();
+			if (text.length === 0) return void 0;
+			try {
+				return JSON.parse(text);
+			} catch {
+				return text;
+			}
+		}
+		return this.formValues.get();
+	}
+	_getOrCreateSchema(serviceId, interfaceId, isDefault) {
+		const key = `${isDefault ? "default" : serviceId}::${interfaceId}`;
+		let p = this._schemas.get(key);
+		if (!p) {
+			const match = (this.servicesPromise.promiseResult.get()?.data ?? []).find((s) => s.serviceId === serviceId && s.interfaceId === interfaceId && s.isDefault === true === isDefault);
+			const reporter = isDefault ? "" : match?.discoveredFrom ?? serviceId;
+			const target = reporter === "" ? void 0 : reporter;
+			p = new ObservableLazyPromise(() => fetchSchema(this._channel, interfaceId, match?.hash, target));
+			this._schemas.set(key, p);
+		}
+		return p;
+	}
+};
+async function loadUiServices(channel) {
+	const [walkResult, defaultsResult] = await Promise.all([walkHubDetailed(channel), fetchDefaults(channel).then((defaults) => ({
+		ok: true,
+		defaults
+	}), (error) => ({
+		ok: false,
+		error
+	}))]);
+	const warnings = walkResult.inaccessible.map(({ serviceId, reason }) => `Service "${serviceId}" does not offer a usable hubrpc.directory::list: ${reason}`);
+	if (!defaultsResult.ok) {
+		warnings.push(`The root service does not offer hubrpc.defaults::get: ${getErrorMessage(defaultsResult.error)}`);
+		return {
+			services: walkResult.listings,
+			warnings
+		};
+	}
+	const { defaults } = defaultsResult;
+	if (defaults.interfaceId === void 0) return {
+		services: walkResult.listings,
+		warnings
+	};
+	return {
+		services: [{
+			serviceId: "",
+			interfaceId: defaults.interfaceId,
+			...defaults.hash === void 0 ? {} : { hash: defaults.hash },
+			discoveredFrom: "",
+			isDefault: true
+		}, ...walkResult.listings],
+		warnings
+	};
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function collectTopLevelFields(schema, components) {
+	const resolved = resolveSchema(schema, components);
+	if (!isObjectSchema(resolved)) return [];
+	const required = new Set(resolved.required ?? []);
+	return Object.entries(resolved.properties).map(([name, sub]) => ({
+		name,
+		required: required.has(name),
+		schema: resolveSchema(sub, components) ?? sub
+	}));
+}
+function resolveSchema(schema, components, seen = /* @__PURE__ */ new Set()) {
+	if (schema === void 0 || typeof schema !== "object" || !("$ref" in schema)) return schema;
+	if (!schema.$ref.startsWith("#/components/schemas/") || seen.has(schema.$ref)) return schema;
+	const target = components[schema.$ref.slice(21)];
+	if (target === void 0) return schema;
+	return resolveSchema(target, components, /* @__PURE__ */ new Set([...seen, schema.$ref]));
+}
+function isObjectSchema(s) {
+	return !!s && typeof s === "object" && "type" in s && s.type === "object" && "properties" in s;
+}
+//#endregion
+//#region src/ui/schemaInspect.ts
+function classifyField(schema) {
+	if (typeof schema === "boolean") return { kind: "json" };
+	if ("enum" in schema) return {
+		kind: "enum",
+		enumValues: schema.enum
+	};
+	if ("const" in schema) return {
+		kind: "enum",
+		enumValues: [schema.const]
+	};
+	if ("anyOf" in schema) {
+		const values = [];
+		for (const branch of schema.anyOf) if (typeof branch === "object" && "const" in branch) values.push(branch.const);
+		else if (typeof branch === "object" && "enum" in branch) values.push(...branch.enum);
+		else return { kind: "json" };
+		return {
+			kind: "enum",
+			enumValues: values
+		};
+	}
+	if ("type" in schema && typeof schema.type === "string") switch (schema.type) {
+		case "string": return { kind: "string" };
+		case "number": return { kind: "number" };
+		case "integer": return { kind: "integer" };
+		case "boolean": return { kind: "boolean" };
+		default: return { kind: "json" };
+	}
+	return { kind: "json" };
+}
+/** A sensible default value for a freshly-focused field, by kind. */
+function defaultValueFor(c) {
+	switch (c.kind) {
+		case "string": return "";
+		case "number":
+		case "integer": return 0;
+		case "boolean": return false;
+		case "enum": return c.enumValues?.[0] ?? null;
+		case "json": return null;
+	}
+}
+/**
+* Move to the next/previous value in an enum field. Wraps at the ends. The
+* cycle is what powers `←`/`→` on enum fields without needing edit mode.
+*/
+function cycleEnum(values, current, delta) {
+	if (values.length === 0) return current;
+	const idx = values.findIndex((v) => deepEqual(v, current));
+	return values[(idx < 0 ? 0 : idx + delta + values.length) % values.length];
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a === null || b === null) return false;
+	if (typeof a !== "object") return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+/** Parse a user-typed string into a value compatible with the given kind. */
+function parseTypedValue(raw, kind) {
+	switch (kind) {
+		case "string": return {
+			ok: true,
+			value: raw
+		};
+		case "number": {
+			if (raw.trim() === "") return {
+				ok: true,
+				value: void 0
+			};
+			const n = Number(raw);
+			if (!Number.isFinite(n)) return {
+				ok: false,
+				error: `not a number: ${raw}`
+			};
+			return {
+				ok: true,
+				value: n
+			};
+		}
+		case "integer": {
+			if (raw.trim() === "") return {
+				ok: true,
+				value: void 0
+			};
+			const n = Number(raw);
+			if (!Number.isInteger(n)) return {
+				ok: false,
+				error: `not an integer: ${raw}`
+			};
+			return {
+				ok: true,
+				value: n
+			};
+		}
+		case "json":
+			if (raw.trim() === "") return {
+				ok: true,
+				value: void 0
+			};
+			try {
+				return {
+					ok: true,
+					value: JSON.parse(raw)
+				};
+			} catch (e) {
+				return {
+					ok: false,
+					error: e.message
+				};
+			}
+		case "boolean":
+		case "enum": return {
+			ok: false,
+			error: "not editable via text input"
+		};
+	}
+}
+/** A short human description of the schema, shown in dim text after the value. */
+function describeSchema(s) {
+	if (typeof s === "boolean") return s ? "any" : "never";
+	if ("type" in s && typeof s.type === "string") return s.type;
+	if ("enum" in s) return `enum(${s.enum.map((v) => JSON.stringify(v)).join(" | ")})`;
+	if ("const" in s) return `const ${JSON.stringify(s.const)}`;
+	if ("anyOf" in s) return s.anyOf.map(describeSchema).join(" | ");
+	if ("$ref" in s) return s.$ref;
+	return "?";
+}
+//#endregion
+//#region src/ui/FieldRow.tsx
+const NAME_W = 12;
+const VALUE_W = 24;
+/**
+* One row of the method form. To keep ink/yoga happy across resizes, the
+* non-editing path renders the whole row as a single `<Text>` with nested
+* colored spans, instead of multiple Boxes that try to share the column's
+* width. Boxes-around-Text in row direction tend to collapse to the
+* narrowest measurement on the first paint — single-Text rows lay out
+* predictably.
+*
+* The editing path swaps the value column for a `TextInput`; the surrounding
+* row stays a Box because TextInput is a component, not a string.
+*/
+const FieldRow = ({ model, field, value, focused, editing, error }) => {
+	const cls = classifyField(field.schema);
+	const cursor = focused ? "› " : "  ";
+	const namePadded = pad(field.name, NAME_W);
+	const optionalMark = field.required ? "" : "?";
+	const typeLabel = describeSchema(field.schema);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		flexShrink: 0,
+		children: [editing ? /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "row",
+			flexShrink: 0,
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: focused ? "cyan" : void 0,
+					children: cursor
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: namePadded
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: optionalMark === "" ? "" : optionalMark + " "
+				}),
+				/* @__PURE__ */ jsx(Box, {
+					flexGrow: 1,
+					flexShrink: 1,
+					children: /* @__PURE__ */ jsx(TextEditor, {
+						model,
+						field,
+						value,
+						cls
+					})
+				}),
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: ["  ", typeLabel]
+				})
+			]
+		}) : /* @__PURE__ */ jsxs(Text, { children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: focused ? "cyan" : void 0,
+				children: cursor
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: namePadded
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: optionalMark + "  "
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "yellow",
+				children: pad(formatValue(value, cls), VALUE_W)
+			}),
+			/* @__PURE__ */ jsxs(Text, {
+				dimColor: true,
+				children: ["  ", typeLabel]
+			})
+		] }), error ? /* @__PURE__ */ jsx(Box, {
+			marginLeft: 14,
+			flexShrink: 0,
+			children: /* @__PURE__ */ jsxs(Text, {
+				color: "red",
+				children: ["! ", error]
+			})
+		}) : null]
+	});
+};
+const TextEditor = ({ model, field, value, cls }) => {
+	const initial = textForEditing(value, cls.kind);
+	const [draft, setDraft] = React.useState(initial);
+	React.useEffect(() => {
+		setDraft(initial);
+	}, [initial]);
+	return /* @__PURE__ */ jsx(TextInput, {
+		value: draft,
+		onChange: setDraft,
+		onSubmit: (submitted) => {
+			const parsed = parseTypedValue(submitted, cls.kind);
+			if (parsed.ok) {
+				model.setField(field.name, parsed.value);
+				model.formEditing.set(false, void 0);
+			}
+		},
+		focus: true
+	});
+};
+function textForEditing(value, kind) {
+	if (value === void 0) return "";
+	if (kind === "string") return typeof value === "string" ? value : JSON.stringify(value);
+	if (kind === "json") return JSON.stringify(value);
+	return String(value);
+}
+function formatValue(value, cls) {
+	if (value === void 0) return "(unset)";
+	switch (cls.kind) {
+		case "boolean": return value ? "[x]" : "[ ]";
+		case "enum": return `< ${stringifyEnum(value)} >`;
+		case "string": return typeof value === "string" ? value : JSON.stringify(value);
+		case "json": {
+			const text = JSON.stringify(value);
+			return text.length > 40 ? text.slice(0, 37) + "..." : text;
+		}
+		default: return JSON.stringify(value);
+	}
+}
+function stringifyEnum(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+/** Pad to `width` with spaces, or truncate with `…` if too long. */
+function pad(text, width) {
+	if (text.length === width) return text;
+	if (text.length < width) return text + " ".repeat(width - text.length);
+	return text.slice(0, width - 1) + "…";
+}
+//#endregion
+//#region src/ui/App.tsx
+const IDENTITY_HEADER_H = 1;
+const FOOTER_H = 1;
+const RESULT_H = 8;
+/** Column chrome that is not list rows: top border + bottom border + title. */
+const COLUMN_CHROME_H = 3;
+/** Re-render on terminal resize so the height math tracks the live row count. */
+function useTerminalRows() {
+	const { stdout } = useStdout();
+	const [rows, setRows] = React.useState(stdout.rows ?? 30);
+	React.useEffect(() => {
+		const onResize = () => setRows(stdout.rows ?? 30);
+		stdout.on("resize", onResize);
+		return () => {
+			stdout.off("resize", onResize);
+		};
+	}, [stdout]);
+	return rows;
+}
+/**
+* Miller-column TUI: three columns left → right (services, methods, form)
+* plus a result pane at the bottom. ←/→ moves focus between columns, ↑/↓
+* moves the cursor inside the focused column. Each cursor move in columns
+* 0 / 1 immediately previews into the column to its right.
+*/
+const App = ({ model }) => {
+	const focusedColumn = useObservable(model.focusedColumn);
+	const editing = useObservable(model.formEditing);
+	const discoveryWarnings = useObservable(model.discoveryWarnings);
+	const termRows = useTerminalRows();
+	const { exit } = useApp();
+	useInput((input, key) => {
+		if (editing) return;
+		if (input === "q") {
+			exit();
+			return;
+		}
+		if (key.leftArrow && focusedColumn > 0) {
+			model.focusColumn(focusedColumn - 1);
+			return;
+		}
+		if (key.rightArrow && focusedColumn < 2) {
+			model.focusColumn(focusedColumn + 1);
+			return;
+		}
+	});
+	const headerHeight = IDENTITY_HEADER_H + discoveryWarnings.length;
+	const bodyHeight = Math.max(4, termRows - headerHeight - RESULT_H - FOOTER_H);
+	const listHeight = Math.max(1, bodyHeight - COLUMN_CHROME_H);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		height: termRows,
+		children: [
+			/* @__PURE__ */ jsx(Header, {
+				model,
+				warnings: discoveryWarnings
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				height: bodyHeight,
+				children: [
+					/* @__PURE__ */ jsx(ServicesColumn, {
+						model,
+						focused: focusedColumn === 0,
+						height: bodyHeight,
+						listHeight
+					}),
+					/* @__PURE__ */ jsx(MethodsColumn, {
+						model,
+						focused: focusedColumn === 1,
+						height: bodyHeight,
+						listHeight
+					}),
+					/* @__PURE__ */ jsx(FormColumn, {
+						model,
+						focused: focusedColumn === 2,
+						height: bodyHeight,
+						listHeight
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(ResultPane, { model }),
+			/* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "←/→: switch column | ↑/↓: move | enter: edit / submit | esc: cancel edit | q: quit"
+			}) })
+		]
+	});
+};
+/** "▲ N more" / "▼ N more" indicator row, shown only when items are hidden. */
+const ScrollIndicator = ({ direction, count }) => {
+	if (count <= 0) return null;
+	return /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: `  ${direction === "up" ? "▲" : "▼"} ${count} more`
+	});
+};
+const Header = ({ model, warnings }) => {
+	const identity = useObservable(model.identity);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "identity: "
+		}), /* @__PURE__ */ jsx(Text, { children: identity ?? "(resolving…)" })] }), warnings.map((warning) => /* @__PURE__ */ jsxs(Text, {
+			color: "yellow",
+			wrap: "truncate-end",
+			children: ["! ", warning]
+		}, warning))]
+	});
+};
+const ServicesColumn = ({ model, focused, height, listHeight }) => {
+	const result = useObservable(model.servicesPromise.promiseResult);
+	const selection = useObservable(model.selection);
+	useInput((_input, key) => {
+		if (key.upArrow) model.moveServiceCursor(-1);
+		else if (key.downArrow) model.moveServiceCursor(1);
+		else if (key.return) model.focusColumn(1);
+	}, { isActive: focused });
+	const services = !result || result.error ? [] : result.data ?? [];
+	const cursorIdx = selection ? services.findIndex((s) => s.serviceId === selection.serviceId && s.interfaceId === selection.interfaceId && s.isDefault === true === (selection.isDefault === true)) : -1;
+	const win = useScroll(services.length, Math.max(0, cursorIdx), listHeight);
+	return /* @__PURE__ */ jsx(Column, {
+		title: "Services",
+		focused,
+		width: "25%",
+		height,
+		children: !result ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "Loading…"
+		}) : result.error ? /* @__PURE__ */ jsxs(Text, {
+			color: "red",
+			children: ["Error: ", String(result.error)]
+		}) : services.length === 0 ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "(no services)"
+		}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsx(ScrollIndicator, {
+				direction: "up",
+				count: win.above
+			}),
+			services.slice(win.start, win.end).map((s) => {
+				const isCursor = !!selection && selection.serviceId === s.serviceId && selection.interfaceId === s.interfaceId && selection.isDefault === true === (s.isDefault === true);
+				return /* @__PURE__ */ jsxs(Text, {
+					color: isCursor ? focused ? "cyan" : "white" : void 0,
+					wrap: "truncate-end",
+					children: [(isCursor ? "› " : "  ") + (s.isDefault === true ? "default " : s.serviceId ? `${s.serviceId} ` : ""), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: s.interfaceId
+					})]
+				}, `${s.isDefault === true ? "default" : s.serviceId}/${s.interfaceId}`);
+			}),
+			/* @__PURE__ */ jsx(ScrollIndicator, {
+				direction: "down",
+				count: win.below
+			})
+		] })
+	});
+};
+const MethodsColumn = ({ model, focused, height, listHeight }) => {
+	const selection = useObservable(model.selection);
+	const schemaState = useObservable(model.currentSchemaState);
+	const methods = useObservable(model.currentMethods);
+	useInput((_input, key) => {
+		if (key.upArrow) model.moveMethodCursor(-1);
+		else if (key.downArrow) model.moveMethodCursor(1);
+		else if (key.return) model.focusColumn(2);
+	}, { isActive: focused });
+	const cursorIdx = selection?.methodName !== void 0 ? methods.findIndex((m) => m.name === selection.methodName) : -1;
+	const win = useScroll(methods.length, Math.max(0, cursorIdx), listHeight);
+	return /* @__PURE__ */ jsx(Column, {
+		title: "Methods",
+		focused,
+		width: "25%",
+		height,
+		children: !selection ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "(select a service)"
+		}) : schemaState.kind === "loading" ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "Loading…"
+		}) : schemaState.kind === "error" ? /* @__PURE__ */ jsxs(Text, {
+			color: "red",
+			children: ["Error: ", String(schemaState.error)]
+		}) : methods.length === 0 ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "(no methods)"
+		}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsx(ScrollIndicator, {
+				direction: "up",
+				count: win.above
+			}),
+			methods.slice(win.start, win.end).map((m) => {
+				const isCursor = selection.methodName === m.name;
+				return /* @__PURE__ */ jsxs(Text, {
+					color: isCursor ? focused ? "cyan" : "white" : void 0,
+					wrap: "truncate-end",
+					children: [
+						isCursor ? "› " : "  ",
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: m.result === void 0 ? "notify " : "req    "
+						}),
+						m.name,
+						m.serverStream !== void 0 ? /* @__PURE__ */ jsx(Text, {
+							color: "magenta",
+							children: " ↓stream"
+						}) : null
+					]
+				}, m.name);
+			}),
+			/* @__PURE__ */ jsx(ScrollIndicator, {
+				direction: "down",
+				count: win.below
+			})
+		] })
+	});
+};
+const FormColumn = ({ model, focused, height, listHeight }) => {
+	const selection = useObservable(model.selection);
+	const schemaState = useObservable(model.currentSchemaState);
+	return /* @__PURE__ */ jsx(Column, {
+		title: "Form",
+		focused,
+		flexGrow: 1,
+		height,
+		children: !selection ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "(select a service first)"
+		}) : selection.methodName === void 0 ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "(select a method first)"
+		}) : schemaState.kind === "loading" ? /* @__PURE__ */ jsx(Text, {
+			dimColor: true,
+			children: "Loading…"
+		}) : schemaState.kind === "loaded" && schemaState.method ? /* @__PURE__ */ jsx(MethodForm, {
+			model,
+			method: schemaState.method,
+			focused,
+			listHeight
+		}) : schemaState.kind === "error" ? /* @__PURE__ */ jsxs(Text, {
+			color: "red",
+			children: ["Error: ", String(schemaState.error)]
+		}) : /* @__PURE__ */ jsxs(Text, {
+			color: "red",
+			children: [
+				"Method \"",
+				selection.methodName,
+				"\" not in schema"
+			]
+		})
+	});
+};
+const MethodForm = ({ model, method, focused, listHeight }) => {
+	const fields = useObservable(model.currentFields);
+	const formValues = useObservable(model.formValues);
+	const errors = useObservable(model.formErrors);
+	const canSubmit = useObservable(model.canSubmit);
+	const cursor = useObservable(model.formCursor);
+	const editing = useObservable(model.formEditing);
+	const submitRowIdx = fields.length;
+	const safeCursor = Math.max(0, Math.min(submitRowIdx, cursor));
+	const focusedField = safeCursor < submitRowIdx ? fields[safeCursor] : void 0;
+	const headerLines = 1 + (method.summary ? 1 : 0) + 1;
+	const fieldsHeight = Math.max(1, listHeight - headerLines - 2);
+	const win = useScroll(fields.length, Math.min(safeCursor, Math.max(0, fields.length - 1)), fieldsHeight);
+	useInput((input, key) => {
+		if (key.upArrow) {
+			model.formCursor.set(Math.max(0, safeCursor - 1), void 0);
+			return;
+		}
+		if (key.downArrow) {
+			model.formCursor.set(Math.min(submitRowIdx, safeCursor + 1), void 0);
+			return;
+		}
+		if (focusedField) {
+			const cls = classifyField(focusedField.schema);
+			const current = formValues[focusedField.name];
+			if (cls.kind === "boolean" && input === " ") {
+				model.setField(focusedField.name, !current);
+				return;
+			}
+			if (cls.kind === "enum") {
+				if (key.leftArrow || key.rightArrow) {
+					const dir = key.rightArrow ? 1 : -1;
+					const seed = current === void 0 ? defaultValueFor(cls) : current;
+					model.setField(focusedField.name, cycleEnum(cls.enumValues ?? [], seed, dir));
+					return;
+				}
+			}
+			if (key.return) {
+				if (cls.kind === "boolean") {
+					model.setField(focusedField.name, !current);
+					return;
+				}
+				if (cls.kind === "enum") {
+					const seed = current === void 0 ? defaultValueFor(cls) : current;
+					model.setField(focusedField.name, cycleEnum(cls.enumValues ?? [], seed, 1));
+					return;
+				}
+				if (current === void 0) model.setField(focusedField.name, defaultValueFor(cls));
+				model.formEditing.set(true, void 0);
+				return;
+			}
+			if (input === "x" && focusedField.required === false && current !== void 0) {
+				model.setField(focusedField.name, void 0);
+				return;
+			}
+		} else if (safeCursor === submitRowIdx && key.return) {
+			if (canSubmit) model.submit();
+			return;
+		}
+	}, { isActive: focused && !editing });
+	useInput((_input, key) => {
+		if (key.escape) model.formEditing.set(false, void 0);
+	}, { isActive: focused && editing });
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		flexShrink: 0,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: (method.result === void 0 ? "notify  " : "request ") + selection?.methodName
+			}),
+			method.summary ? /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: method.summary
+			}) : null,
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				flexShrink: 0,
+				children: fields.length === 0 ? /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "(no parameters)"
+				}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(ScrollIndicator, {
+						direction: "up",
+						count: win.above
+					}),
+					fields.slice(win.start, win.end).map((f, i) => {
+						const idx = win.start + i;
+						return /* @__PURE__ */ jsx(FieldRow, {
+							model,
+							field: f,
+							value: formValues[f.name],
+							focused: focused && safeCursor === idx,
+							editing: editing && safeCursor === idx,
+							error: errors.get(f.name)
+						}, f.name);
+					}),
+					/* @__PURE__ */ jsx(ScrollIndicator, {
+						direction: "down",
+						count: win.below
+					})
+				] })
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexShrink: 0,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: canSubmit ? "green" : "gray",
+					children: submitLabel(focused && safeCursor === submitRowIdx, canSubmit)
+				})
+			})
+		]
+	});
+};
+function submitLabel(focused, canSubmit) {
+	return `${focused ? "› " : "  "}[Submit${canSubmit ? "" : " — fix errors first"}]`;
+}
+const Column = ({ title, focused, children, width, flexGrow, height }) => {
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width,
+		flexGrow,
+		height,
+		overflow: "hidden",
+		borderStyle: "single",
+		borderColor: focused ? "cyan" : void 0,
+		paddingX: 1,
+		children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: title
+		}), children]
+	});
+};
+const ResultPane = ({ model }) => {
+	const promise = useObservable(model.lastCall);
+	const result = useObservable(promise ? promise.promiseResult : NO_RESULT);
+	const chunks = useObservable(model.streamChunks);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		height: RESULT_H,
+		overflow: "hidden",
+		borderStyle: "single",
+		paddingX: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: "Result"
+			}),
+			chunks.length > 0 ? /* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				children: chunks.map((c, i) => /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: "│ " + formatChunk(c)
+				}, i))
+			}) : null,
+			!promise ? /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: "(no calls yet)"
+			}) : !result ? /* @__PURE__ */ jsx(Text, {
+				dimColor: true,
+				children: chunks.length > 0 ? "Streaming…" : "Calling…"
+			}) : result.error ? /* @__PURE__ */ jsxs(Text, {
+				color: "red",
+				children: ["Error: ", formatError(result.error)]
+			}) : /* @__PURE__ */ jsxs(Text, { children: [
+				JSON.stringify(result.data?.result),
+				"  ",
+				/* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [result.data?.latencyMs.toFixed(1), "ms"]
+				})
+			] })
+		]
+	});
+};
+const NO_RESULT = observableValue("App.NO_RESULT", void 0);
+function formatChunk(c) {
+	return typeof c === "string" ? c : JSON.stringify(c);
+}
+function formatError(e) {
+	if (e instanceof Error) return e.message;
+	return String(e);
+}
+//#endregion
+//#region src/ui/runUi.tsx
+async function runUi(opts) {
+	if (isHubEndpoint(opts.endpoint)) await _runUiReconnecting(opts.endpoint, opts.principalSpec);
+	else await _runUiOnce(opts.endpoint, opts.principalSpec);
+}
+/** Non-Hub endpoints: a single connection, no redial. */
+async function _runUiOnce(endpoint, principalSpec) {
+	const conn = await connect(endpoint);
+	const identity = _isRawEndpoint(endpoint) ? "unsigned (raw endpoint)" : _formatIdentity(await setupSigning(conn.channel, conn.signing, principalSpec, { negotiateHubCaps: false }));
+	const model = new UiModel(conn.channel);
+	model.identity.set(identity, void 0);
+	const instance = render(/* @__PURE__ */ jsx(App, { model }));
+	try {
+		await instance.waitUntilExit();
+	} finally {
+		model.dispose();
+		conn.close();
+	}
+}
+function _isRawEndpoint(endpoint) {
+	return endpoint.kind === "ws-no-init" || endpoint.kind === "socket" && endpoint.brokerMode === "raw";
+}
+/**
+* Hub / env connection: keep the UI alive across socket drops. A stable
+* {@link SwappableSender} backs the {@link UiModel}; on every (re)connect we
+* open a fresh hub channel, install signing, and point the swappable sender at
+* the new signed channel. The TUI is rendered once, after the first connect.
+*/
+async function _runUiReconnecting(endpoint, principalSpec) {
+	const swappable = new SwappableSender();
+	let model;
+	const hubEndpoint = endpoint.kind === "ws" ? endpoint.url : endpoint.path;
+	const handle = ChannelConnector.expBackoff(() => openHubChannel({
+		endpoint: hubEndpoint,
+		token: endpoint.token ?? ""
+	})).keepConnected(async ({ channel }) => {
+		const signing = {};
+		const signed = SigningSender.wrapChannel(channel, signing).sender;
+		const session = await setupSigning(signed, signing, principalSpec, { negotiateHubCaps: true });
+		swappable.setTarget(signed);
+		if (!model) {
+			model = new UiModel(swappable);
+			model.identity.set(_formatIdentity(session), void 0);
+			render(/* @__PURE__ */ jsx(App, { model })).waitUntilExit().finally(() => handle.stop());
+		} else model.identity.set(_formatIdentity(session), void 0);
+	});
+	try {
+		await handle.done;
+	} finally {
+		model?.dispose();
+	}
+}
+/** One-line identity label for the TUI header (source + truncated nodeId). */
+function _formatIdentity(session) {
+	return formatPrincipalSource(session.principalSource, session.principal.identity.publicSigningIdentity.principal);
+}
+/**
+* An {@link IRequestSender} whose delegate can be swapped at runtime. Lets the
+* {@link UiModel} hold one stable channel reference while the underlying signed
+* channel is replaced on each reconnect. Calls issued while disconnected reject.
+*/
+var SwappableSender = class {
+	_target;
+	setTarget(target) {
+		this._target = target;
+	}
+	_require() {
+		if (!this._target) throw new RpcError("not connected", -32e3);
+		return this._target;
+	}
+	sendRequest(method, params, opts) {
+		return this._require().sendRequest(method, params, opts);
+	}
+	sendNotification(method, params, opts) {
+		return this._require().sendNotification(method, params, opts);
+	}
+	sendRequestWithStream(method, params, opts) {
+		return this._require().sendRequestWithStream(method, params, opts);
+	}
+	close() {
+		this._target?.close();
+	}
+};
+//#endregion
+export { runUi };
+
+//# sourceMappingURL=runUi-D-8LMU4F.js.map