@vscode/component-explorer-cli 0.2.1-18 → 0.2.1-180

package/dist/daemon/types.d.ts

@@ -1,12 +1,1659 @@
+import * as zod_v4_core from 'zod/v4/core';
+import { $ZodType, output } from 'zod/v4/core';
+import * as zod_mini from 'zod/mini';
+import { z } from 'zod';
+
+//#region src/protocol/jsonValue.d.ts
 /**
- * Shared types for the daemon API.
- * These are imported by both the CLI (server) and the explorer (client).
+ * The JSON value lattice. Anything the wire can carry.
+ *
+ * Object values are `JsonValue | undefined` so `undefined`-valued fields
+ * may be present in source and are simply omitted at canonicalisation
+ * time (rather than serialised as `null`).
  */
-import type { DaemonService } from './DaemonService.js';
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue | undefined;
+};
+//#endregion
+//#region src/protocol/jsonRpc.d.ts
+type RequestId = number | string;
+interface JsonRpcRequest<TParams = JsonValue> {
+  jsonrpc: "2.0";
+  id: RequestId;
+  method: string;
+  params?: TParams;
+}
+interface JsonRpcNotification<TParams = JsonValue> {
+  jsonrpc: "2.0";
+  method: string;
+  params?: TParams;
+}
+interface JsonRpcSuccess {
+  jsonrpc: "2.0";
+  id: RequestId | null;
+  result: JsonValue;
+}
+interface JsonRpcError {
+  jsonrpc: "2.0";
+  id: RequestId | null;
+  error: {
+    code: number;
+    message: string;
+    data?: JsonValue;
+  };
+}
+type JsonRpcResponse = JsonRpcSuccess | JsonRpcError;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+//#endregion
+//#region src/schema/linkRpcJsonSchema.d.ts
+type LinkRpcJsonSchema = true | false | NullSchema | BooleanSchema | NumberSchema | IntegerSchema | StringSchema | ConstSchema | EnumSchema | ArraySchema | TupleSchema | ObjectSchema | UnionSchema | OneOfSchema | RefSchema;
+interface SchemaBase {
+  [key: `x-${string}`]: unknown;
+  title?: string;
+  description?: string;
+  /**
+   * Additional draft 2020-12 constraints that refine (never replace) this
+   * node. This extension is non-normative for LinkRPC identity; use
+   * {@link materializeJsonSchema} when exporting to a general validator.
+   */
+  "x-json-schema"?: boolean | Record<string, unknown>;
+}
+interface NullSchema extends SchemaBase {
+  type: "null";
+}
+interface BooleanSchema extends SchemaBase {
+  type: "boolean";
+}
+interface NumberSchema extends SchemaBase {
+  type: "number";
+  /** Opaque well-known refinement tag, e.g. "float32", "percentage". */
+  format?: string;
+}
+interface IntegerSchema extends SchemaBase {
+  type: "integer";
+  /** Opaque well-known refinement tag, e.g. "int32", "uint8", "unix-time". */
+  format?: string;
+}
+interface StringSchema extends SchemaBase {
+  type: "string";
+  /** Opaque well-known refinement tag, e.g. "email", "uri", "uuid", "date-time". */
+  format?: string;
+}
+/** Single literal value. */
+interface ConstSchema extends SchemaBase {
+  const: JsonValue;
+}
+/** Finite set of literal values. */
+interface EnumSchema extends SchemaBase {
+  enum: JsonValue[];
+}
+/** Homogeneous array. */
+interface ArraySchema extends SchemaBase {
+  type: "array";
+  items: LinkRpcJsonSchema;
+}
+/** Fixed-length head plus optional rest element type. */
+interface TupleSchema extends SchemaBase {
+  type: "array";
+  prefixItems: LinkRpcJsonSchema[];
+  /** `false` => exact length; schema => typed rest; omitted => exact length. */
+  items?: LinkRpcJsonSchema | false;
+}
+interface ObjectSchema extends SchemaBase {
+  type: "object";
+  properties: Record<string, LinkRpcJsonSchema>;
+  /** Names of required properties. Must all be keys of `properties`. */
+  required?: string[];
+  /** `false` => closed; schema => value type for unknown keys. */
+  additionalProperties: LinkRpcJsonSchema | false;
+}
+/** Untagged union. Assignability distributes over branches. */
+interface UnionSchema extends SchemaBase {
+  anyOf: LinkRpcJsonSchema[];
+}
 /**
- * The typed API interface for the daemon, extracted from DaemonService.
- * Use this with `createFetchClient<DaemonApiType>()` for type-safe client calls.
+ * Tagged-or-disjoint union (`oneOf`). Structurally treated the same as
+ * `UnionSchema` for assignability; the distinction is preserved so the
+ * wire schema faithfully reflects whether the source was a
+ * discriminated union (e.g. Zod's `z.discriminatedUnion`) or a plain
+ * union.
+ *
+ * `discriminator`, when present, is a pure consumer hint: it names the
+ * property that branches dispatch on. Every branch SHOULD be an object
+ * with that property set to a distinct `const` value, but the subset
+ * does not enforce this — broken discriminators are tolerated.
  */
-export type DaemonApiType = DaemonService['api']['TMethods'];
-export type { DaemonEvent, SessionInfo } from './DaemonService.js';
-//# sourceMappingURL=types.d.ts.map
+interface OneOfSchema extends SchemaBase {
+  oneOf: LinkRpcJsonSchema[];
+  discriminator?: DiscriminatorSchema;
+}
+interface DiscriminatorSchema {
+  propertyName: string;
+}
+/** Reference to a named entry in `SvcInterfaceSchema.components.schemas`. */
+interface RefSchema extends SchemaBase {
+  /** JSON Pointer, restricted to "#/components/schemas/<name>". */
+  $ref: string;
+}
+//#endregion
+//#region src/schema/linkRpcInterfaceSchema.d.ts
+/**
+ * Minimal interface schema for linkrpc. A strict subset of OpenRPC 1.x:
+ * identity & addressing live in linkrpc, so this format only describes the
+ * contract of a single interface (methods + reusable JSON Schemas).
+ */
+interface LinkRpcInterfaceSchema {
+  [key: `x-${string}`]: unknown;
+  /** Stable interface id, e.g. "de.hediet.notification-target". */
+  id: string;
+  /**
+   * Content hash of the normalized schema. Pairs with `id` to form `id@hash`.
+   * Normalization: serialize this object with `hash` omitted, object keys
+   * sorted recursively, and no insignificant whitespace; hash the bytes.
+   */
+  hash: string;
+  /**
+   * Normative human description (GitHub-flavored markdown). Part of the
+   * interface hash — changing `description` is a contract change. Use it
+   * for the canonical purpose / semantics of the interface.
+   */
+  description?: string;
+  /**
+   * Non-normative implementation notes (markdown). Stripped from the hash,
+   * so editing `comment` never changes the interface identity. Use it for
+   * rationale, changelog notes, examples, etc.
+   */
+  comment?: string;
+  /** Non-normative discovery labels, excluded from the interface hash. */
+  tags?: string[];
+  /** Methods keyed by local member name. */
+  methods: Record<string, MethodSchema>;
+  /** Reusable schema definitions, referenced via `#/components/schemas/<name>`. */
+  components?: {
+    schemas?: Record<string, LinkRpcJsonSchema>;
+  };
+}
+interface MethodSchema {
+  [key: `x-${string}`]: unknown;
+  /** Schema for the user params object. */
+  params: LinkRpcJsonSchema;
+  /** Result schema. Omit to declare a notification-only method. */
+  result?: LinkRpcJsonSchema;
+  /**
+   * Schema for client-emitted stream messages (`$stream::send` from
+   * caller to callee) on an in-flight call. Absent means the client
+   * may not stream on this method.
+   */
+  clientStream?: LinkRpcJsonSchema;
+  /**
+   * Schema for server-emitted stream messages (`$stream::send` from
+   * callee to caller) on an in-flight call. Absent means the server
+   * may not stream on this method.
+   */
+  serverStream?: LinkRpcJsonSchema;
+  /** Raw codes are exclusive; named and legacy declarations may form a union per code. */
+  errors?: ErrorSchema[];
+  summary?: string;
+  /**
+   * Normative description of this method's contract (markdown). Part of
+   * the interface hash — changing it is a contract change.
+   */
+  description?: string;
+  /** Non-normative implementation notes. Stripped from the hash. */
+  comment?: string;
+  deprecated?: boolean;
+  /**
+   * Behavioral claims about this method. All flags default to `false`;
+   * setting one is always a positive refinement of the contract.
+   * Part of the interface hash — these are normative claims callers
+   * may rely on, so changing them is a contract change.
+   */
+  annotations?: MemberAnnotations;
+}
+/**
+ * Behavioral claims about a method. Every flag is a positive assertion
+ * (default `false` ≡ "no claim"); setting one strengthens the contract
+ * the caller may rely on.
+ *
+ * These are normative — they are included in the interface hash.
+ */
+interface MemberAnnotations {
+  /**
+   * The method does not modify any observable state on the callee
+   * (or anywhere reachable from it). Pure query.
+   *
+   * Implies `idempotent` and `reversible` (a no-op has nothing to
+   * undo and repeats trivially).
+   */
+  readOnly?: boolean;
+  /**
+   * Calling N times with the same params has the same observable effect
+   * as calling once. Safe to retry on transport failure.
+   */
+  idempotent?: boolean;
+  /**
+   * Effects of this method are reversible — the caller (or operator)
+   * can undo them with a follow-up call. Implies the method is not
+   * `dangerous`.
+   */
+  reversible?: boolean;
+  /**
+   * Calling this method is expensive (slow, costly, or rate-limited).
+   * Callers should avoid unnecessary invocations and may want to
+   * confirm / batch.
+   */
+  expensive?: boolean;
+  /**
+   * Method has irreversible or destructive effects (data loss, money
+   * spent, message sent, etc.). UIs should require confirmation.
+   */
+  dangerous?: boolean;
+}
+type ErrorSchema = LegacyErrorSchema | RawErrorSchema;
+interface RawErrorSchema {
+  code: number;
+  /** Schema of the wire body { message, data? }, excluding the outer code. */
+  schema: LinkRpcJsonSchema;
+  type?: never;
+  message?: never;
+  data?: never;
+}
+interface LegacyErrorSchema {
+  schema?: never;
+  /** Named error discriminator in `error.data.type`. Absent for legacy numeric errors. */
+  type?: string;
+  /** JSON-RPC error code. -32768..-32000 and LinkRPC cancellation code -32800 are reserved. */
+  code: number;
+  message: string;
+  /** Payload schema: `error.data.data` for named errors, `error.data` for legacy errors. */
+  data?: LinkRpcJsonSchema;
+}
+//#endregion
+//#region src/connection/rpcFailure.d.ts
+declare const rpcFailureBrand: unique symbol;
+/** A nominal failure wrapper: successful application objects can never collide with it. */
+declare class RpcFailure<E> {
+  readonly error: E;
+  readonly [rpcFailureBrand] = true;
+  constructor(error: E);
+}
+type Result$1<T, E = never> = T | RpcFailure<E>;
+//#endregion
+//#region src/schema/applicationErrorBrand.d.ts
+declare const applicationErrorBrand: unique symbol;
+//#endregion
+//#region src/schema/memberTypes.d.ts
+/**
+ * The schema type linkrpc accepts everywhere: the zod *core* base shared by
+ * both classic `zod` and `zod/mini`. Typing against it (instead of classic
+ * `z.ZodType`) lets callers author interfaces with either flavour — classic
+ * for ergonomics, mini for minimal bundle size — while linkrpc's own internal
+ * interfaces use mini. `O` is the validated output type.
+ */
+type Schema<O = unknown> = $ZodType<O>;
+/**
+ * Marker base for a typed method member. Carries enough metadata to:
+ *  - validate / parse params at runtime (via the zod schemas),
+ *  - emit a JSON schema for reflection,
+ *  - propagate TS types up to the interface definition.
+ */
+type MemberType = RequestType<any, any, any, any, any, any, any> | NotificationType<any>;
+type ApplicationErrorValue<TCode extends number = number, TMessage extends string = string, TData = never, TType extends string | undefined = undefined> = {
+  readonly kind: 'application';
+  readonly code: TCode;
+  readonly message: TMessage;
+} & ([TData] extends [never] ? {
+  readonly data?: never;
+} : {
+  readonly data: TData;
+}) & (TType extends string ? {
+  readonly type: TType;
+} : {
+  readonly type?: never;
+});
+type CreatedApplicationErrorValue<TCode extends number = number, TMessage extends string = string, TData = never, TType extends string | undefined = undefined> = ApplicationErrorValue<TCode, TMessage, TData, TType> & {
+  readonly [applicationErrorBrand]: true;
+  readonly kind: 'application';
+  readonly code: TCode;
+  readonly message: TMessage;
+  readonly data?: TData;
+  readonly type?: TType;
+};
+interface ApplicationErrorDescriptor<TCode extends number = number, TMessage extends string = string, TData = never, TType extends string | undefined = undefined> {
+  readonly code: TCode;
+  readonly message: TMessage;
+  readonly dataSchema?: Schema<TData>;
+  readonly type: TType;
+  /** Match a validated application payload or its failure wrapper. */
+  is(value: RpcFailure<unknown>): value is RpcFailure<ApplicationErrorValue<TCode, string, TData, TType>>;
+  is(value: {
+    readonly kind: 'application';
+  }): value is ApplicationErrorValue<TCode, string, TData, TType>;
+  is(value: unknown): value is ApplicationErrorValue<TCode, string, TData, TType> | RpcFailure<ApplicationErrorValue<TCode, string, TData, TType>>;
+  readonly create: [TData] extends [never] ? () => CreatedApplicationErrorValue<TCode, TMessage, TData, TType> : (data: TData) => CreatedApplicationErrorValue<TCode, TMessage, TData, TType>;
+}
+interface ApplicationErrorDescriptorBase {
+  readonly type?: string;
+  readonly code: number;
+  readonly message?: string;
+  readonly bodySchema?: Schema;
+  readonly dataSchema?: Schema<any>;
+  readonly create: (...args: any[]) => {
+    readonly kind: 'application';
+    readonly code: number;
+    readonly message: string;
+    readonly data?: unknown;
+    readonly type?: string;
+    readonly [applicationErrorBrand]: true;
+  };
+}
+type ApplicationErrorOf<T> = T extends RpcErrorDescriptor<infer C, infer B> ? CreatedRpcErrorValue<C, B> : T extends ApplicationErrorDescriptor<infer C, infer M, infer D, infer N> ? CreatedApplicationErrorValue<C, M, D, N> : never;
+type PublicApplicationErrorOf<T> = 0 extends (1 & T) ? never : T extends {
+  readonly [rawErrorBrand]: true;
+} ? Omit<T, typeof applicationErrorBrand | typeof rawErrorBrand> : T extends CreatedApplicationErrorValue<infer C, infer M, infer D, infer N> ? ApplicationErrorValue<C, N extends string ? string : M, D, N> : never;
+type DeclaredApplicationErrorOf<T> = 0 extends (1 & T) ? never : Extract<T, ReturnType<ApplicationErrorDescriptorBase['create']>>;
+type ApplicationErrorsOf<T extends readonly ApplicationErrorDescriptorBase[]> = ApplicationErrorOf<T[number]>;
+declare const rawErrorBrand: unique symbol;
+type RpcErrorBody = {
+  readonly message: string;
+  readonly data?: unknown;
+};
+type RpcErrorValue<C extends number, B extends RpcErrorBody> = B & {
+  readonly kind: 'application';
+  readonly code: C;
+  readonly type?: never;
+};
+type CreatedRpcErrorValue<C extends number, B extends RpcErrorBody> = RpcErrorValue<C, B> & {
+  readonly [applicationErrorBrand]: true;
+  readonly [rawErrorBrand]: true;
+};
+interface RpcErrorDescriptor<C extends number = number, B extends RpcErrorBody = RpcErrorBody> {
+  readonly code: C;
+  readonly bodySchema: Schema<B>;
+  readonly type?: never;
+  readonly message?: never;
+  readonly dataSchema?: never;
+  create(body: B): CreatedRpcErrorValue<C, B>;
+  is(value: RpcFailure<unknown>): value is RpcFailure<RpcErrorValue<C, B>>;
+  is(value: {
+    readonly kind: 'application';
+  }): value is RpcErrorValue<C, B>;
+  is(value: unknown): value is RpcErrorValue<C, B> | RpcFailure<RpcErrorValue<C, B>>;
+}
+/**
+ * Optional documentation for a method member.
+ *
+ * - `description` is the **normative** contract of the method (included in the
+ *   interface hash — changing it changes `schemaHash`).
+ * - `comment` is non-normative implementation notes (stripped from the hash).
+ * - `annotations` are normative behavioral claims (e.g. `readOnly`,
+ *   `idempotent`); included in the hash.
+ */
+interface MemberDocs {
+  description?: string;
+  comment?: string;
+  annotations?: MemberAnnotations;
+}
+declare class RequestType<TParams = unknown, TResult = void, TError = void, TClientStream = never, TServerStream = never, TErrors extends readonly ApplicationErrorDescriptorBase[] = readonly ApplicationErrorDescriptorBase[], TLegacyError = TError> {
+  readonly paramsSchema: Schema<TParams>;
+  readonly resultSchema: Schema<TResult>;
+  readonly errorSchema: Schema<TLegacyError>;
+  readonly docs: MemberDocs;
+  /**
+   * Schema for stream messages the **client** may emit on an
+   * in-flight call (e.g. cancellation, input). `undefined` means
+   * the client may not stream on this method.
+   */
+  readonly clientStreamSchema?: Schema<TClientStream> | undefined;
+  /**
+   * Schema for stream messages the **server** may emit while
+   * handling an in-flight call (e.g. progress, partial results).
+   * `undefined` means the server may not stream on this method.
+   */
+  readonly serverStreamSchema?: Schema<TServerStream> | undefined;
+  /** Checked application errors explicitly declared with `.withErrors()`. */
+  readonly applicationErrors: TErrors;
+  readonly kind: "request";
+  constructor(paramsSchema: Schema<TParams>, resultSchema: Schema<TResult>, errorSchema: Schema<TLegacyError>, docs?: MemberDocs,
+  /**
+   * Schema for stream messages the **client** may emit on an
+   * in-flight call (e.g. cancellation, input). `undefined` means
+   * the client may not stream on this method.
+   */
+  clientStreamSchema?: Schema<TClientStream> | undefined,
+  /**
+   * Schema for stream messages the **server** may emit while
+   * handling an in-flight call (e.g. progress, partial results).
+   * `undefined` means the server may not stream on this method.
+   */
+  serverStreamSchema?: Schema<TServerStream> | undefined,
+  /** Checked application errors explicitly declared with `.withErrors()`. */
+  applicationErrors?: TErrors);
+  /** Declared checked errors, retained as a tuple for generated-contract consumers. */
+  readonly errors: TErrors;
+  /** Phantom field — typed-only, do not access at runtime. */
+  readonly _params: TParams;
+  readonly _result: TResult;
+  readonly _error: TError;
+  readonly _clientStream: TClientStream;
+  readonly _serverStream: TServerStream;
+  /**
+   * Return a copy of this request type with stream payload schemas
+   * attached. Pass `undefined` for either direction to leave it
+   * closed.
+   * `NoInfer` keeps a contextual MemberMap's `any` stream slots from
+   * widening undeclared directions; only the supplied schemas infer payloads.
+   */
+  withStream<TClient = TClientStream, TServer = TServerStream>(opts: {
+    client?: Schema<TClient>;
+    server?: Schema<TServer>;
+  }): RequestType<TParams, TResult, TError, NoInfer<TClient>, NoInfer<TServer>, TErrors, TLegacyError>;
+  /**
+   * Return a copy with an explicit, typed set of checked application errors.
+   * The legacy third `requestType` schema remains accepted for compatibility,
+   * but does not opt a method into checked errors.
+   */
+  withErrors<const TErrors extends readonly ApplicationErrorDescriptorBase[]>(errors: TErrors): RequestType<TParams, TResult, ApplicationErrorsOf<TErrors>, TClientStream, TServerStream, TErrors, TLegacyError>;
+}
+declare class NotificationType<TParams = unknown> {
+  readonly paramsSchema: Schema<TParams>;
+  readonly docs: MemberDocs;
+  readonly kind: "notification";
+  constructor(paramsSchema: Schema<TParams>, docs?: MemberDocs);
+  readonly _params: TParams;
+}
+interface SchemaParameterReference<TName extends string = string> {
+  readonly $parameter: TName;
+}
+type NonRecursiveJsonSchema = Exclude<LinkRpcJsonSchema, ArraySchema | TupleSchema | ObjectSchema | UnionSchema | OneOfSchema>;
+type InterfaceTemplateJsonSchema<TParameter extends string = string> = NonRecursiveJsonSchema | SchemaParameterReference<TParameter> | (Omit<ArraySchema, "items"> & {
+  readonly items: InterfaceTemplateJsonSchema<TParameter>;
+}) | (Omit<TupleSchema, "prefixItems" | "items"> & {
+  readonly prefixItems: readonly InterfaceTemplateJsonSchema<TParameter>[];
+  readonly items?: InterfaceTemplateJsonSchema<TParameter> | false;
+}) | (Omit<ObjectSchema, "properties" | "additionalProperties"> & {
+  readonly properties: Readonly<Record<string, InterfaceTemplateJsonSchema<TParameter>>>;
+  readonly additionalProperties: InterfaceTemplateJsonSchema<TParameter> | false;
+}) | (Omit<UnionSchema, "anyOf"> & {
+  readonly anyOf: readonly InterfaceTemplateJsonSchema<TParameter>[];
+}) | (Omit<OneOfSchema, "oneOf"> & {
+  readonly oneOf: readonly InterfaceTemplateJsonSchema<TParameter>[];
+});
+type InterfaceTemplateMethodSchema<TParameter extends string = string> = Omit<MethodSchema, "params" | "result" | "clientStream" | "serverStream" | "errors"> & {
+  readonly params: InterfaceTemplateJsonSchema<TParameter>;
+  readonly result?: InterfaceTemplateJsonSchema<TParameter>;
+  readonly clientStream?: InterfaceTemplateJsonSchema<TParameter>;
+  readonly serverStream?: InterfaceTemplateJsonSchema<TParameter>;
+  readonly errors?: readonly InterfaceTemplateErrorSchema<TParameter>[];
+};
+type InterfaceTemplateErrorSchema<TParameter extends string = string> = {
+  readonly code: number;
+  readonly schema: InterfaceTemplateJsonSchema<TParameter>;
+  readonly type?: never;
+  readonly message?: never;
+  readonly data?: never;
+} | {
+  readonly schema?: never;
+  readonly type?: string;
+  readonly code: number;
+  readonly message: string;
+  readonly data?: InterfaceTemplateJsonSchema<TParameter>;
+};
+interface InterfaceTemplateSchema<TParameter extends string = string> {
+  readonly id: string;
+  /** Non-normative discovery labels contributed when this template is instantiated. */
+  readonly tags?: readonly string[];
+  readonly parameters: readonly TParameter[];
+  readonly methods: Readonly<Record<string, InterfaceTemplateMethodSchema<TParameter>>>;
+  readonly components?: {
+    readonly schemas?: Readonly<Record<string, InterfaceTemplateJsonSchema<TParameter>>>;
+  };
+}
+interface InterfaceTemplateArgument {
+  readonly schema: LinkRpcJsonSchema;
+  readonly components?: {
+    readonly schemas?: Readonly<Record<string, LinkRpcJsonSchema>>;
+  };
+}
+interface InterfaceTemplateInstance {
+  readonly name: string;
+  readonly template: string;
+  readonly members: Readonly<Record<string, string>>;
+  readonly arguments: Readonly<Record<string, InterfaceTemplateArgument>>;
+}
+interface MappedInterfaceTemplate {
+  readonly template: InterfaceTemplateSchema;
+  readonly schema: Omit<InterfaceTemplateInstance, "name">;
+}
+//#endregion
+//#region src/schema/validationIssue.d.ts
+interface JsonSchemaValidationIssue {
+  readonly path: string;
+  readonly message: string;
+}
+//#endregion
+//#region src/connection/nonCompliantServerError.d.ts
+/** JSON Pointer diagnostics relative to the original wire error. */
+type RpcValidationIssue = JsonSchemaValidationIssue;
+declare class NonCompliantServerError extends Error {
+  readonly original: JsonRpcError['error'];
+  readonly issues: readonly RpcValidationIssue[];
+  readonly kind: "nonCompliantServer";
+  constructor(original: JsonRpcError['error'], issues: readonly RpcValidationIssue[]);
+}
+//#endregion
+//#region src/schema/interfaceTemplateGroup.d.ts
+/** Local authoring marker. Never serialized into the wire contract. */
+declare const interfaceTemplateGroup: unique symbol;
+interface InterfaceTemplateGroup<M extends Record<string, MemberType> = Record<string, MemberType>, Mapping extends Record<keyof M, string> | undefined = Record<keyof M, string> | undefined> {
+  readonly [interfaceTemplateGroup]: true;
+  readonly members: M;
+  readonly template: InterfaceTemplateSchema;
+  readonly arguments: Readonly<Record<string, InterfaceTemplateArgument>>;
+  readonly mapping: Mapping;
+}
+//#endregion
+//#region src/connection/interfaceDefinition.d.ts
+/**
+ * Per-call stream API handed to a request handler as its third argument.
+ * Allows the handler to consume {@link STREAM_METHOD} notifications
+ * emitted by the caller (`onMessage`) and emit stream notifications to
+ * the caller (`send`) while the request is in flight.
+ *
+ * Members are typed by the originating method's
+ * {@link RequestType.clientStreamSchema} / `serverStreamSchema`.
+ * Streams whose schema is `undefined` make the corresponding member
+ * effectively unusable: `send` is typed `(payload: never) => void` and
+ * the registered `onMessage` listener can never fire because the
+ * receiver-side validator rejects the wire payload.
+ */
+interface StreamApi<TClient = unknown, TServer = unknown> {
+  /** Emit a server→client stream message. */
+  send(payload: TServer): Promise<void>;
+  /**
+   * Register a listener for client→server stream messages on this
+   * request. Calling twice replaces the previous listener.
+   */
+  onMessage(listener: (payload: TClient) => void): void;
+  /**
+   * Liveness probe toward the caller: resolves once the caller
+   * acknowledges with a matching pong, rejects if the call settles
+   * first. Independent of the channel's automatic keepalive ping.
+   */
+  ping(): Promise<void>;
+  /**
+   * Aborts when the caller cancels this in-flight request, or when the
+   * hub cancels it on the caller's behalf (caller disconnect / idle
+   * timeout). Observe it to stop work early and settle the request
+   * (e.g. `signal.throwIfAborted()`), which surfaces as a `cancelled`
+   * error to the caller.
+   */
+  readonly signal: AbortSignal;
+}
+interface InterfaceInfo {
+  id: string;
+  /** Non-normative discovery labels; do not affect interface identity. */
+  tags?: readonly string[];
+  /**
+   * Normative description of the interface (markdown). Part of the
+   * interface hash — changing it is a contract change.
+   */
+  description?: string;
+  /** Non-normative implementation notes. Stripped from the hash. */
+  comment?: string;
+  /**
+   * Optional expected content hash (see `computeInterfaceHash`). When
+   * set, {@link InterfaceDefinition}'s constructor verifies that the
+   * computed {@link InterfaceDefinition.schemaHash} matches and throws
+   * otherwise — a guard against silent contract drift when the wire
+   * shape changes but a pinned hash was not updated.
+   */
+  hash?: string;
+}
+type MemberMap = Record<string, MemberType>;
+type InterfaceDeclarations = Record<string, MemberType | InterfaceTemplateGroup>;
+/** Stable wire identity of one member in an interface definition. */
+interface InterfaceMemberRef<TName extends string = string> {
+  readonly interfaceId: string;
+  readonly interfaceHash: string;
+  readonly member: TName;
+}
+type InterfaceMemberRefMap<TMembers extends MemberMap> = { readonly [K in keyof TMembers & string]: InterfaceMemberRef<K>; };
+/**
+ * Per-call options accepted by a streaming-enabled client method. Currently
+ * only `onMessage` for consuming server→client stream notifications; the
+ * caller addresses client→server stream messages via the returned
+ * {@link StreamingCall}.
+ */
+interface StreamCallOptions<TServer> {
+  /** Listener for server→client stream messages on this in-flight call. */
+  onMessage?: (payload: TServer) => void;
+}
+/**
+ * Return shape of a streaming-enabled client method. Behaves as a
+ * `Promise<TResult>` for the final response, and exposes `send` for
+ * emitting client→server stream messages on the in-flight call. The
+ * wire request id is also exposed (resolved once the request has
+ * been allocated).
+ *
+ * For methods whose interface schema declares no client stream
+ * (`TClient = never`), `send` is typed `(payload: never) => Promise<void>`
+ * and is effectively uncallable — matching the runtime behavior, where
+ * the receiver would drop client-emitted stream messages anyway.
+ */
+interface StreamingCall<TResult, TClient> extends Promise<TResult> {
+  /** Resolves to the wire request id once the call has been sent. */
+  readonly requestId: Promise<RequestId>;
+  /** Emit a client→server stream message on this in-flight call. */
+  send(payload: TClient): Promise<void>;
+  /**
+   * Ask the callee to abort this in-flight call. Advisory: the call
+   * settles via its normal response (typically a `cancelled` error).
+   * `reason` is an open-set diagnostic string (see `StreamControlReason`).
+   */
+  cancel(reason?: string): Promise<void>;
+  /**
+   * Stop tracking this call locally. This does not notify the callee; call
+   * {@link cancel} first when remote work should also be cancelled.
+   */
+  dispose?(reason?: string): void;
+  /**
+   * Liveness probe toward the callee: resolves once the callee
+   * acknowledges with a matching pong, rejects if the call settles
+   * first. Independent of the channel's automatic keepalive ping.
+   */
+  ping(): Promise<void>;
+}
+interface RemoteRpcError {
+  readonly kind: 'remote';
+  readonly code: number;
+  readonly message: string;
+  readonly data?: JsonValue;
+}
+interface LocalRpcError {
+  readonly kind: 'local';
+  readonly cause: unknown;
+}
+interface TransportRpcError {
+  readonly kind: 'transport';
+  readonly cause: unknown;
+}
+type GenericRpcError = RemoteRpcError | LocalRpcError | TransportRpcError | NonCompliantServerError;
+type RpcCallError<E = never> = {
+  readonly kind: 'application';
+  readonly error: E;
+} | {
+  readonly kind: 'generic';
+  readonly error: GenericRpcError;
+};
+type CheckedCallResult<TResult, TApplicationError = never> = {
+  readonly ok: true;
+  readonly value: TResult;
+} | {
+  readonly ok: false;
+  readonly error: TApplicationError | GenericRpcError;
+};
+interface CheckedCall<TResult, TApplicationError = never> extends Promise<Result$1<TResult, TApplicationError>> {
+  /**
+   * @deprecated Use getResultClient() for values that include generic errors.
+   */
+  result(): Promise<CheckedCallResult<TResult, TApplicationError>>;
+}
+/**
+ * `true` iff at least one stream direction is declared (either client or
+ * server stream schema present). Used by {@link InterfaceClient} to pick
+ * between the plain `Promise<R>` shape and the {@link StreamingCall}
+ * shape per method.
+ */
+type _HasStream<TClient, TServer> = [TClient] extends [never] ? ([TServer] extends [never] ? false : true) : true;
+type ClientCall<TResult, TApplicationError> = [TApplicationError] extends [never] ? Promise<TResult> : CheckedCall<TResult, TApplicationError>;
+type ClientResult<R, E> = [E] extends [never] ? R : Result$1<R, E>;
+/**
+ * Compile-time TypeScript shape of an interface — useful for typed
+ * client/server implementations on top of the runtime definition.
+ *
+ * Methods whose `RequestType` declares stream payloads via
+ * `.withStream({ client, server })` return a {@link StreamingCall}
+ * augmented with `send`; all others return a plain `Promise<TResult>`.
+ *
+ * @example
+ *   type Client = InterfaceClient<typeof myInterface>;
+ *   // => { bar(p: {...}): Promise<string>; foo(p: {...}): void; }
+ */
+type InterfaceClientMember<TMember> = TMember extends RequestType<infer P, infer R, infer E, infer TC, infer TS, any, any> ? (_HasStream<TC, TS> extends true ? (params: P, opts?: StreamCallOptions<TS>) => StreamingCall<ClientResult<R, PublicApplicationErrorOf<E>>, TC> & ClientCall<R, PublicApplicationErrorOf<E>> : (params: P) => ClientCall<R, PublicApplicationErrorOf<E>>) : TMember extends NotificationType<infer P> ? (params: P) => void : never;
+type MembersClient<M extends MemberMap> = { [K in keyof M]: InterfaceClientMember<M[K]>; };
+/** A reusable consumer's client shape, independent of instance name or wire mapping. */
+type InterfaceTemplateClient<T extends InterfaceTemplateGroup> = MembersClient<T['members']>;
+type DeclarationClient<M> = M extends InterfaceTemplateGroup ? InterfaceTemplateClient<M> : InterfaceClientMember<M>;
+type InterfaceClient<TDef extends InterfaceDefinition<any>> = { [K in keyof TDef['_declarations']]: DeclarationClient<TDef['_declarations'][K]>; };
+type InterfaceResultClientMember<TMember> = TMember extends RequestType<infer P, infer R, infer E, infer TC, infer TS, any, any> ? _HasStream<TC, TS> extends true ? (params: P, opts?: StreamCallOptions<TS>) => StreamingCall<Result$1<R, RpcCallError<PublicApplicationErrorOf<E>>>, TC> : (params: P) => Promise<Result$1<R, RpcCallError<PublicApplicationErrorOf<E>>>> : TMember extends NotificationType<infer P> ? (params: P) => void : never;
+type MembersResultClient<M extends MemberMap> = { [K in keyof M]: InterfaceResultClientMember<M[K]>; };
+/** Result-client counterpart of {@link InterfaceTemplateClient}. */
+type InterfaceTemplateResultClient<T extends InterfaceTemplateGroup> = MembersResultClient<T['members']>;
+/** Every request returns failures as values, including methods with no declared errors. */
+type DeclarationResultClient<M> = M extends InterfaceTemplateGroup ? InterfaceTemplateResultClient<M> : InterfaceResultClientMember<M>;
+type InterfaceResultClient<TDef extends InterfaceDefinition<any>> = { [K in keyof TDef['_declarations']]: DeclarationResultClient<TDef['_declarations'][K]>; };
+/**
+ * Compile-time shape of a server implementation for an interface — used by
+ * `LinkRpcConnection.register`. Request handlers may return synchronously or
+ * via a promise; notification handlers return void.
+ *
+ * `TCtx` is the call-context type carried by the hosting connection — see
+ * `LinkRpcConnection<TCtx>`. For the default connection (`TCtx = undefined`)
+ * handlers may take a single params arg; for ctx-aware connections (e.g.
+ * the hub's self connection) they may take a second `ctx` arg of the
+ * concrete type. A 1-arg handler remains assignable where a 2-arg handler
+ * is expected, so existing handlers compile unchanged.
+ */
+type InterfaceHandler<TMember, TCtx> = TMember extends RequestType<infer P, infer R, infer E, infer TC, infer TS, any, any> ? (params: P, ctx: TCtx, stream: StreamApi<TC, TS>) => R | DeclaredApplicationErrorOf<E> | Promise<R | DeclaredApplicationErrorOf<E>> : TMember extends NotificationType<infer P> ? (params: P, ctx: TCtx) => void | Promise<void> : never;
+type DeclarationHandler<M, TCtx> = M extends InterfaceTemplateGroup ? { [K in keyof M['members']]: InterfaceHandler<M['members'][K], TCtx>; } : InterfaceHandler<M, TCtx>;
+type KnownKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: unknown; };
+type InterfaceHandlers<TDef extends InterfaceDefinition<any>, TCtx = undefined> = { [K in keyof TDef['_declarations']]: DeclarationHandler<TDef['_declarations'][K], TCtx>; } & { [K in Exclude<KnownKeys<TDef['members']>, keyof TDef['_declarations']>]?: K extends keyof Object ? Object[K] : never; };
+/**
+ * Options accepted by {@link InterfaceDefinition}'s constructor.
+ *
+ * `frozenSchema` lets callers supply an externally-authored
+ * `LinkRpcInterfaceSchema` (e.g. produced by codegen or, in the faker, by an
+ * LLM at runtime) verbatim. When set, `toSchema()` returns that document
+ * (with `hash` overlaid) and `schemaHash` is computed from it — the
+ * `members` map is used only for runtime dispatch (param/result
+ * validation, stream routing) and is no longer the source of truth for
+ * the wire shape.
+ */
+interface InterfaceAuthoringOptions {
+  /** Checked structural instances; implementations remain in connection.register(). */
+  readonly templates?: Readonly<Record<string, MappedInterfaceTemplate>>;
+}
+interface InterfaceDefinitionOpts extends InterfaceAuthoringOptions {
+  frozenSchema?: LinkRpcInterfaceSchema;
+}
+declare class InterfaceDefinition<TMembers extends MemberMap, TDeclarations extends InterfaceDeclarations = TMembers> {
+  readonly info: InterfaceInfo;
+  readonly members: TMembers;
+  /** Compile-time authoring shape shared by clients and handlers; wire members remain flat. */
+  readonly _declarations: TDeclarations;
+  /** Typed wire references for capability and access-request construction. */
+  readonly ref: InterfaceMemberRefMap<TMembers>;
+  constructor(info: InterfaceInfo, members: TMembers, opts?: InterfaceDefinitionOpts);
+  /** @internal Materialize authored groups using the existing wire call functions verbatim. */
+  nestClient(client: Record<string, unknown>): Record<string, unknown>;
+  /** Validate grouped implementations atomically, then lower them to wire handlers. */
+  flattenHandlers(handlers: unknown): Record<string, unknown>;
+  /** Content hash of this interface (see `computeInterfaceHash`). */
+  get schemaHash(): string;
+  /** Lower the definition to a wire-format `LinkRpcInterfaceSchema`, hash filled in. */
+  toSchema(): LinkRpcInterfaceSchema;
+}
+//#endregion
+//#region src/transport/messageTransport.d.ts
+interface IMessageTransport<TIncoming = JsonRpcMessage, TOutgoing = JsonRpcMessage> {
+  send(message: TOutgoing): void | Promise<void>;
+  /**
+   * Sets the listener for incoming messages. Setting `undefined` detaches.
+   * The transport buffers messages received before a listener is attached
+   * and delivers them the next tick when one is set.
+   * Forgetting to set a listener will cause the queue to leak.
+   */
+  setListener(listener: ((message: TIncoming) => void) | undefined): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/connection/channel.d.ts
+declare class Channel<TInCtx = undefined, TOutCtx = undefined> {
+  readonly sender: IRequestSender<TOutCtx>;
+  private readonly _setHandler;
+  private readonly _setWireObserver?;
+  constructor(sender: IRequestSender<TOutCtx>, _setHandler: (h: IRequestHandler<TInCtx> | undefined) => void, _setWireObserver?: ((observer: WireMessageObserver | undefined) => void) | undefined);
+  /** Bind the inbound request/notification handler. May be called before or after construction of {@link LinkRpcConnection}. */
+  setRequestHandler(handler: IRequestHandler<TInCtx> | undefined): void;
+  /**
+   * Install the endpoint inspection observer at the JSON-RPC wire boundary.
+   * Intended for {@link LinkRpcConnection}; ordinary consumers should use the
+   * public `hubrpc.traffic` service instead.
+   */
+  setWireMessageObserver(observer: WireMessageObserver | undefined): void;
+  /**
+   * Compose this channel with a sender-side decorator (typically the
+   * signing layer). The decorator wraps {@link sender} only; the
+   * {@link setRequestHandler} binding is shared with the original channel
+   * so the receive side is bound exactly once regardless of decoration depth.
+   */
+  withSender<TNewOutCtx>(decorate: (raw: IRequestSender<TOutCtx>) => IRequestSender<TNewOutCtx>): Channel<TInCtx, TNewOutCtx>;
+}
+type WireMessageDirection = 'inbound' | 'outbound';
+type WireMessageObserver = (direction: WireMessageDirection, message: JsonRpcMessage) => void;
+interface IRequestHandler<TInCtx = undefined> {
+  handleRequest(call: IncomingCall<TInCtx>): Promise<Result>;
+  handleNotification(call: IncomingCall<TInCtx>): void;
+}
+/**
+ * Inbound call observed by an {@link IRequestHandler}. `TInCtx` is the
+ * per-call out-of-band context the transport attached on the receiving
+ * side (e.g. the hub stamps `Participant` on overlay-bound messages).
+ * For wire transports it's `undefined`.
+ */
+interface IncomingCall<TInCtx = undefined> {
+  method: string;
+  params: JsonValue | undefined;
+  /** Out-of-band context attached by the transport, if any. */
+  context: TInCtx;
+  /**
+   * Per-call streaming handle. Both directions live on this object,
+   * scoped to the request's lifetime. The inbound listener is auto-
+   * detached when the handler's response settles. For notifications
+   * (no request id) the handle is a no-op stub.
+   */
+  stream: IncomingStream;
+  /**
+   * Aborts when the caller cancels this in-flight request (a
+   * `toCallee` `cancel` control), or when the hub cancels it on the
+   * caller's behalf (caller disconnect / idle timeout). The handler
+   * should observe this and settle promptly — typically by throwing,
+   * which surfaces as a `cancelled` error response. For notifications
+   * this never aborts.
+   */
+  signal: AbortSignal;
+}
+/**
+ * Per-call streaming handle attached to {@link IncomingCall.stream}.
+ * Scoped to a single in-flight request; the channel automatically
+ * detaches the inbound listener when the handler's response settles.
+ *
+ * For notifications (which have no request id), `requestId` is
+ * `undefined`, `send` is a no-op, and `onMessage` is a no-op.
+ */
+interface IncomingStream {
+  /** Emit a server→client stream notification correlated with this call. */
+  send(payload: JsonValue): Promise<void>;
+  /**
+   * Register a listener for client→server stream messages correlated
+   * with this call. Pass `undefined` to detach. Replaces any prior
+   * listener. The channel detaches the listener automatically when
+   * the handler's response settles.
+   */
+  onMessage(listener: ((payload: JsonValue) => void) | undefined): void;
+  /**
+   * Liveness probe toward the caller: emit a `toCaller` ping and
+   * resolve once the caller's `pong` (matching nonce) returns. Rejects
+   * if the request settles first. Independent of the channel's
+   * automatic keepalive ping.
+   */
+  ping(): Promise<void>;
+}
+type Result = {
+  result: JsonValue;
+} | {
+  error: {
+    code: number;
+    message: string;
+    data?: JsonValue;
+  };
+};
+/**
+ * What callers use to send. The {@link Channel} factory binds an
+ * {@link IRequestHandler} at construction (immutable for the channel's
+ * lifetime) and hands the caller back an `IRequestSender`.
+ *
+ * `TOutCtx` is the per-call context bag this sender understands. For
+ * the base {@link JsonRpcChannel} it's `undefined` (the channel
+ * doesn't read any overrides). Decorators like `SigningSender`
+ * parametrise it on their own ctx shape.
+ */
+interface IRequestSender<TOutCtx = undefined> {
+  sendRequest(method: string, params: JsonValue | undefined, opts?: SendOpts<TOutCtx>): Promise<JsonValue>;
+  sendNotification(method: string, params: JsonValue | undefined, opts?: SendOpts<TOutCtx>): Promise<void>;
+  /**
+   * Issue a request that participates in the streaming sub-protocol.
+   * Returns synchronously with the wire request id, the result
+   * promise, and a `send` for emitting client→server stream messages.
+   */
+  sendRequestWithStream(method: string, params: JsonValue | undefined, opts?: StreamSendOpts<TOutCtx>): RawStreamingCall;
+  close(): void;
+}
+/**
+ * Handle for a request issued via
+ * {@link IRequestSender.sendRequestWithStream}. `send` emits
+ * client→server stream messages correlated with this call. `result`
+ * resolves with the call's response.
+ */
+interface RawStreamingCall {
+  readonly result: Promise<JsonValue>;
+  /** Emit a client→server (`toCallee`) stream message correlated with this call. */
+  send(payload: JsonValue): void;
+  /**
+   * Ask the callee to abort this in-flight request (a `toCallee`
+   * `cancel` control). Advisory: the request settles via its normal
+   * response (typically a `cancelled` error). `reason` is an open-set
+   * diagnostic string (see `StreamControlReason`).
+   */
+  cancel(reason?: string): void;
+  /**
+   * Stop tracking this request locally and reject {@link result}. This does
+   * not notify the callee; call {@link cancel} first when remote work should
+   * also be cancelled. Safe to call after the request has already settled.
+   */
+  dispose?(reason?: string): void;
+  /**
+   * Liveness probe toward the callee: emit a `toCallee` ping and
+   * resolve once the callee's `pong` (matching nonce) returns. Rejects
+   * if the request settles first. Independent of the channel's
+   * automatic keepalive ping.
+   */
+  ping(): Promise<void>;
+}
+/**
+ * Per-send options.
+ *
+ * `interfaceHash` is interface-level call metadata: the schema hash of
+ * the interface a typed proxy is calling. It is independent of
+ * `TOutCtx` — the connection stamps it from the interface definition,
+ * the base {@link JsonRpcChannel} ignores it, and signing decorators
+ * bake it into the `$hubrpc` envelope.
+ *
+ * `ctx` is the sender's `TOutCtx`-typed override / extension bag for
+ * per-call decorator overrides (e.g. `signerOverride`, `capsOverride`).
+ * The base {@link JsonRpcChannel} ignores `ctx` entirely; decorators
+ * like `SigningSender` interpret it.
+ */
+interface SendOpts<TOutCtx = undefined> {
+  readonly ctx?: TOutCtx;
+  /** Interface schema hash for this call (interface-level metadata). */
+  readonly interfaceHash?: string;
+}
+interface StreamSendOpts<TOutCtx = undefined> extends SendOpts<TOutCtx> {
+  readonly onStreamMessage?: (payload: JsonValue) => void;
+}
+/**
+ * Type of incoming messages on the channel's transport. With
+ * `TInCtx = undefined` (default) this is just `JsonRpcMessage`. With a
+ * concrete `TInCtx`, the transport carries a `context` field alongside
+ * the message — out-of-band, never sent over a wire, set by the
+ * in-process producer.
+ */
+type MessageWithCtx<TInCtx> = [TInCtx] extends [undefined] ? JsonRpcMessage : JsonRpcMessage & {
+  context: TInCtx;
+};
+declare const zParticipantDescriptorSource: zod_mini.ZodMiniObject<{
+  source: zod_mini.ZodMiniEnum<{
+    self: "self";
+    attacher: "attacher";
+  }>;
+  descriptor: zod_mini.ZodMiniObject<{
+    type: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+    label: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+    processId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniNumber<number>>;
+    processType: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+    nodeStatusServiceId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+    metadata: zod_mini.ZodMiniOptional<zod_mini.ZodMiniRecord<zod_mini.ZodMiniString<string>, zod_mini.ZodMiniUnion<readonly [zod_mini.ZodMiniString<string>, zod_mini.ZodMiniNumber<number>, zod_mini.ZodMiniBoolean<boolean>]>>>;
+  }, zod_v4_core.$strip>;
+}, zod_v4_core.$strip>;
+type ParticipantDescriptorSource = output<typeof zParticipantDescriptorSource>;
+declare const zTrafficTransitEvent: zod_mini.ZodMiniObject<{
+  type: zod_mini.ZodMiniLiteral<"transit">;
+  timeMs: zod_mini.ZodMiniNumber<number>;
+  nodeId: zod_mini.ZodMiniString<string>;
+  in: zod_mini.ZodMiniOptional<zod_mini.ZodMiniObject<{
+    edgeId: zod_mini.ZodMiniString<string>;
+    portId: zod_mini.ZodMiniString<string>;
+    requestId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniUnion<readonly [zod_mini.ZodMiniNumber<number>, zod_mini.ZodMiniString<string>]>>;
+  }, zod_v4_core.$strip>>;
+  out: zod_mini.ZodMiniOptional<zod_mini.ZodMiniObject<{
+    edgeId: zod_mini.ZodMiniString<string>;
+    portId: zod_mini.ZodMiniString<string>;
+    requestId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniUnion<readonly [zod_mini.ZodMiniNumber<number>, zod_mini.ZodMiniString<string>]>>;
+  }, zod_v4_core.$strip>>;
+  disposition: zod_mini.ZodMiniEnum<{
+    forwarded: "forwarded";
+    consumed: "consumed";
+    dropped: "dropped";
+    unroutable: "unroutable";
+  }>;
+  kind: zod_mini.ZodMiniEnum<{
+    request: "request";
+    notification: "notification";
+    response: "response";
+    stream: "stream";
+  }>;
+  method: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+  params: zod_mini.ZodMiniOptional<zod_mini.ZodMiniUnknown>;
+  result: zod_mini.ZodMiniOptional<zod_mini.ZodMiniUnknown>;
+  error: zod_mini.ZodMiniOptional<zod_mini.ZodMiniObject<{
+    code: zod_mini.ZodMiniNumber<number>;
+    message: zod_mini.ZodMiniString<string>;
+    data: zod_mini.ZodMiniOptional<zod_mini.ZodMiniUnknown>;
+  }, zod_v4_core.$strip>>;
+}, zod_v4_core.$strip>;
+type TrafficTransitEvent = output<typeof zTrafficTransitEvent>;
+//#endregion
+//#region src/inspection/node.interfaces.d.ts
+declare const zNodeInfo: zod_mini.ZodMiniObject<{
+  nodeId: zod_mini.ZodMiniString<string>;
+  portId: zod_mini.ZodMiniString<string>;
+  descriptors: zod_mini.ZodMiniOptional<zod_mini.ZodMiniArray<zod_mini.ZodMiniObject<{
+    source: zod_mini.ZodMiniEnum<{
+      self: "self";
+      attacher: "attacher";
+    }>;
+    descriptor: zod_mini.ZodMiniObject<{
+      type: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+      label: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+      processId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniNumber<number>>;
+      processType: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+      nodeStatusServiceId: zod_mini.ZodMiniOptional<zod_mini.ZodMiniString<string>>;
+      metadata: zod_mini.ZodMiniOptional<zod_mini.ZodMiniRecord<zod_mini.ZodMiniString<string>, zod_mini.ZodMiniUnion<readonly [zod_mini.ZodMiniString<string>, zod_mini.ZodMiniNumber<number>, zod_mini.ZodMiniBoolean<boolean>]>>>;
+    }, zod_v4_core.$strip>;
+  }, zod_v4_core.$strip>>>;
+}, zod_v4_core.$strip>;
+type NodeInfo = output<typeof zNodeInfo>;
+/**
+ * Generates unique topology-correlation labels, not security identities.
+ * Custom generators must avoid collisions across nodes and ports. Tests can
+ * supply an independent deterministic sequence for each participant.
+ */
+type TopologyIdGenerator = (kind: 'node' | 'port') => string;
+//#endregion
+//#region src/connection/bareInterfaceTarget.d.ts
+/** A metadata-free foreign-protocol interface and its wire-method prefix. */
+interface BareInterfaceTarget<TDef extends InterfaceDefinition<any>> {
+  readonly mode: 'bare';
+  readonly interface: TDef;
+  readonly prefix: string;
+}
+//#endregion
+//#region src/connection/interfaceTarget.d.ts
+/** A qualified LinkRPC route. An empty serviceId addresses the root interface. */
+interface QualifiedInterfaceTarget<TDef extends InterfaceDefinition<any>> {
+  readonly mode: 'qualified';
+  readonly interface: TDef;
+  readonly serviceId: string;
+}
+/** The peer's preset form-1 route, retaining LinkRPC metadata and streaming. */
+interface DefaultInterfaceTarget<TDef extends InterfaceDefinition<any>> {
+  readonly mode: 'default';
+  readonly interface: TDef;
+}
+type InterfaceTarget<TDef extends InterfaceDefinition<any>> = QualifiedInterfaceTarget<TDef> | DefaultInterfaceTarget<TDef> | BareInterfaceTarget<TDef>;
+/** One OR-set. The set is satisfied by holding *any one* of its principals. */
+declare const zRootPrincipalSet: zod_mini.ZodMiniArray<zod_mini.ZodMiniObject<{
+  principal: zod_mini.ZodMiniString<string>;
+  transitive: zod_mini.ZodMiniOptional<zod_mini.ZodMiniBoolean<boolean>>;
+}, zod_v4_core.$strip>>;
+type RootPrincipalSet = output<typeof zRootPrincipalSet>;
+//#endregion
+//#region src/connection/linkRpcConnection.d.ts
+interface LinkRpcConnectionOptions {
+  /** Topology node/port ID generator. Defaults to cryptographic randomness. */
+  readonly generateTopologyId?: TopologyIdGenerator;
+  /**
+   * Validate parameters passed through typed interface clients before sending
+   * them. Enabled by default. Disable only when interoperating with a peer
+   * whose accepted wire shape intentionally differs from the local schema.
+   */
+  readonly validateOutboundParams?: boolean;
+}
+/**
+ * High-level linkrpc connection. Layers method-name routing and zod-driven
+ * validation on top of a plain JSON-RPC channel.
+ *
+ * Typed proxies built by this class merely forward each call's
+ * `interfaceHash` hint to the channel so the signer stamps it into the
+ * `$hubrpc` envelope.
+ *
+ * `TInCtx` is the per-call out-of-band context the connection's transport
+ * carries. Default `undefined` covers cross-process and ordinary in-process
+ * transports. The hub's self/overlay connections instantiate with a
+ * concrete `TInCtx` (e.g. `Participant`) so handlers can see who originated
+ * the call.
+ *
+ * `TOutCtx` is the per-call override / extension bag the outbound sender
+ * understands (see {@link SendOpts.ctx}). It only ever flows into the
+ * sender as input, so it is a contravariant type parameter. Default `any`
+ * keeps the bare `LinkRpcConnection` a valid supertype for holders that do
+ * not care about the outbound ctx; pass a concrete shape (e.g.
+ * `SigningCallCtx`) to get precise {@link get} typing. The connection
+ * itself is agnostic to its contents — it merely forwards the `ctx`
+ * defaults supplied to {@link get}.
+ */
+declare class LinkRpcConnection<TInCtx = any, TOutCtx = any> {
+  /**
+   * Convenience: build a {@link JsonRpcChannel} `Channel` from the
+   * given transport and wrap it in an `LinkRpcConnection`. Use this
+   * when you have a transport at hand and don't need a decorator
+   * stack (e.g. signing).
+   */
+  static fromTransport<TInCtx = undefined>(transport: IMessageTransport<MessageWithCtx<TInCtx>, JsonRpcMessage>, options?: LinkRpcConnectionOptions): LinkRpcConnection<TInCtx>;
+  /** Underlying JSON-RPC sender — useful for callers that need raw access (e.g. to call hub-served methods that bypass the interface registry). */
+  readonly channel: IRequestSender<TOutCtx>;
+  /** key = `${serviceId ?? ""}::${interfaceId}` */
+  private readonly _registry;
+  /** Descriptions for services that have been registered with a `serviceDescription`. */
+  private readonly _serviceDescriptions;
+  /** Root-node-id requirement sets recorded per serviceId. */
+  private readonly _serviceRootPrincipalSets;
+  private readonly _directoryWatchers;
+  private readonly _directoryListeners;
+  private _inspection;
+  private _inspectionHost;
+  private readonly _serviceInspectionRegistrations;
+  private readonly _wireObservers;
+  private readonly _closeListeners;
+  private _closed;
+  private readonly _wireChannel;
+  private readonly _validateOutboundParams;
+  /** Bare-method bindings, keyed by their exact wire prefix. */
+  private readonly _bareBindings;
+  private readonly _generateTopologyId;
+  /**
+   * Construct from a {@link Channel} (binds the inbound handler and uses
+   * `channel.sender` for outbound calls) or from a bare
+   * {@link IRequestSender} (send-only — no inbound handler is registered,
+   * useful for bootstrap flows like `createManagedIdentity`).
+   */
+  constructor(channel: Channel<TInCtx, TOutCtx> | IRequestSender<TOutCtx>, options?: LinkRpcConnectionOptions);
+  /** Get a typed client using a bundled qualified, default, or bare route. */
+  get<TDef extends InterfaceDefinition<any>>(target: InterfaceTarget<TDef>): InterfaceClient<TDef>;
+  /** Get a typed client for `iface`, routed to the implicit (root) service. */
+  get<TDef extends InterfaceDefinition<any>>(iface: TDef, opts?: GetOptions<TOutCtx>): InterfaceClient<TDef>;
+  private _getClient;
+  /**
+   * Get a typed client that emits foreign-protocol bare method names.
+   * Unlike {@link get}, these calls carry no LinkRPC interface metadata.
+   */
+  getBare<TDef extends InterfaceDefinition<any>>(iface: TDef, opts?: BareGetOptions): InterfaceClient<TDef>;
+  private _buildBareClient;
+  /** Return request failures as values for a bundled qualified, default, or bare route. */
+  getResultClient<TDef extends InterfaceDefinition<any>>(target: InterfaceTarget<TDef>): InterfaceResultClient<TDef>;
+  /** Return application and generic request failures as values instead of throwing. */
+  getResultClient<TDef extends InterfaceDefinition<any>>(iface: TDef, opts?: GetOptions<TOutCtx>): InterfaceResultClient<TDef>;
+  /** Get a service-scoped handle; all interfaces obtained from it route via `serviceId` (form 3). */
+  service(serviceId: string): ServiceHandle<TInCtx, TOutCtx>;
+  /** Register handlers, adding preset routing when passed a default or bare target. */
+  register<TDef extends InterfaceDefinition<any>>(ifaceOrTarget: TDef | InterfaceTarget<TDef>, handlers: InterfaceHandlers<TDef, TInCtx>, opts?: RegisterOptions): InterfaceRegistration;
+  /** Register inspection contracts without recursively enabling service inspection. */
+  registerInspection<TDef extends InterfaceDefinition<any>>(iface: TDef, handlers: InterfaceHandlers<TDef, TInCtx>, opts?: RegisterOptions): InterfaceRegistration;
+  /** Observe this connection without replacing another inspection scope's observer. */
+  observeWireMessages(observer: WireMessageObserver): InterfaceRegistration;
+  onDidClose(listener: () => void): InterfaceRegistration;
+  private _register;
+  /** Snapshot of every interface currently registered on this connection. */
+  listRegisteredInterfaces(): readonly {
+    readonly serviceId: string;
+    readonly interfaceId: string;
+    readonly interfaceHash: string;
+    readonly tags?: readonly string[];
+    readonly serviceDescription?: string;
+    readonly rootPrincipalSets?: readonly RootPrincipalSet[];
+  }[];
+  /** Subscribe to coarse local directory changes; listeners must re-list. */
+  onDidChangeDirectory(listener: () => void): () => void;
+  /**
+   * Look up a registered interface definition by id (and optional content
+   * hash). Returns `undefined` if no registered interface matches.
+   */
+  findRegisteredInterface(interfaceId: string, hash?: string): InterfaceDefinition<any> | undefined;
+  /**
+   * Register the three linkrpc reflection interfaces (`defaults`,
+   * `directory`, `schemas`), backed by this connection's live registry.
+   *
+   * By default they live under the root service (form-2 reachable as
+   * `hubrpc.directory::list`). Pass `serviceId` to additionally mount
+   * them under a specific service — useful for participants that live
+   * behind a hub, so callers can reach reflection via form-3
+   * `<serviceId>::hubrpc.directory::list`.
+   *
+   * Idempotent: re-registering the same `(serviceId, interfaceId)` pair
+   * is a no-op.
+   */
+  enableReflection(opts?: {
+    serviceId?: string;
+  }): InterfaceRegistration;
+  private _notifyDirectoryWatchers;
+  /**
+   * Enable the root `hubrpc.node::getNodeId` topology-bootstrap service.
+   *
+   * The generated ids are stable while this registration is active. They are
+   * unauthenticated correlation labels only; callers must not use them for
+   * identity, capability, or authorization decisions.
+   */
+  enableInspection(descriptors?: readonly ParticipantDescriptorSource[]): InspectionRegistration;
+  /** Number of active endpoint traffic stream subscribers. */
+  get trafficObserverCount(): number;
+  close(): void;
+  private _buildClient;
+  private _validateOutboundParamsFor;
+  private _handleRequest;
+  private _buildStreamApi;
+  private _handleNotification;
+  private _parseRouted;
+  private _installServiceInspection;
+  private _removeServiceInspection;
+  private _hasBusinessServiceRegistration;
+}
+/**
+ * Options when obtaining a typed client for an interface.
+ *
+ *  - `serviceId`: route to a specific service (form 3). Omit for form 2
+ *    (implicit / root service on the connection).
+ *  - any `TOutCtx` property: a per-client default merged into the `ctx`
+ *    of every call issued through the returned proxy (e.g.
+ *    `signerOverride`, `capsOverride` for a signing channel). The
+ *    connection forwards these verbatim; it does not interpret them.
+ *
+ * Schema-version pinning travels as interface-level call metadata
+ * ({@link SendOpts.interfaceHash}); the typed proxy stamps
+ * `iface.schemaHash` automatically, independent of `TOutCtx`.
+ */
+type GetOptions<TOutCtx = undefined> = {
+  serviceId?: string;
+} & Partial<TOutCtx>;
+/** Options for a metadata-free, bare-method typed client. */
+interface BareGetOptions {
+  prefix?: string;
+}
+interface RegisterOptions {
+  /**
+   * If set, this interface is mounted under this service id (form 3).
+   */
+  serviceId?: string;
+  /**
+   * Optional human description recorded for `serviceId` and surfaced
+   * through `hubrpc.directory::list`. Requires `serviceId`. The first
+   * registration's description wins; any later registration that
+   * supplies a *different* non-undefined description throws.
+   */
+  serviceDescription?: string;
+  /**
+   * Root node ids required to access `serviceId`, in CNF (AND of OR-sets):
+   * the caller must satisfy **every** set, and a set is satisfied by **any
+   * one** of its node ids. Surfaced through `hubrpc.directory::list`.
+   * Requires `serviceId`. Recorded per service; a later registration that
+   * supplies a *different* value for the same `serviceId` throws.
+   */
+  rootPrincipalSets?: readonly RootPrincipalSet[];
+}
+/** A live interface registration. Disposing it removes dispatch and reflection state. */
+interface InterfaceRegistration {
+  /** Remove this exact registration. Idempotent. */
+  dispose(): void;
+}
+/** Generated topology identity and its live root-interface registration. */
+interface InspectionRegistration extends InterfaceRegistration, NodeInfo {
+  /**
+   * Observe this endpoint's full-payload traffic in-process. Watch-control
+   * flows are tracked even when no public observations are active.
+   */
+  observeTraffic(observer: (transit: TrafficTransitEvent) => void): InterfaceRegistration;
+}
+/** Service-scoped handle returned by `connection.service(id)`. */
+declare class ServiceHandle<TInCtx = undefined, TOutCtx = undefined> {
+  private readonly _connection;
+  private readonly _serviceId;
+  constructor(_connection: LinkRpcConnection<TInCtx, TOutCtx>, _serviceId: string);
+  getResultClient<TDef extends InterfaceDefinition<any>>(iface: TDef, opts?: Partial<TOutCtx>): InterfaceResultClient<TDef>;
+  get<TDef extends InterfaceDefinition<any>>(iface: TDef, opts?: Partial<TOutCtx>): InterfaceClient<TDef>;
+  register<TDef extends InterfaceDefinition<any>>(ifaceOrTarget: TDef | BareInterfaceTarget<TDef>, handlers: InterfaceHandlers<TDef, TInCtx>, opts?: Omit<RegisterOptions, 'serviceId'>): InterfaceRegistration;
+}
+
+declare const sessionInfo: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        current: "current";
+        worktree: "worktree";
+    }>;
+    isLoading: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        current: "current";
+        worktree: "worktree";
+    }>;
+    isLoading: z.ZodOptional<z.ZodLiteral<false>>;
+    serverUrl: z.ZodString;
+    sourceTreeId: z.ZodString;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+declare const daemonEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"source-change">;
+    sessionName: z.ZodString;
+    sourceTreeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ref-change">;
+    sessionName: z.ZodString;
+    newCommit: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"session-change">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"log">;
+    level: z.ZodEnum<{
+        info: "info";
+        debug: "debug";
+        trace: "trace";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+type DaemonEvent = z.infer<typeof daemonEventSchema>;
+type SessionInfo = z.infer<typeof sessionInfo>;
+declare function createDaemonMethods(connection: LinkRpcConnection): {
+    fixtures: {
+        list: (params: {
+            sessionName: string;
+            sourceTreeId: string;
+        }) => Promise<{
+            fixtures: {
+                fixtureId: string;
+                fixtureName: string;
+                groupPath: string[];
+                background: "light" | "dark";
+                labels: readonly string[];
+                expectedVisualDescriptions: readonly string[];
+                inputSchema?: unknown;
+            }[];
+            loadError?: string | undefined;
+        }>;
+    };
+    screenshots: {
+        take: (params: {
+            fixtureId: string;
+            sourceTreeId: string;
+            sessionName: string;
+            includeImage?: boolean | undefined;
+            stabilityCheck?: boolean | undefined;
+            reloadBeforeRender?: boolean | undefined;
+            input?: unknown;
+            disposeAfter?: boolean | undefined;
+        }) => Promise<{
+            hasError: boolean;
+            sourceTreeId: string;
+            hash?: string | undefined;
+            image?: string | undefined;
+            error?: {
+                message: string;
+                stack?: string | undefined;
+            } | undefined;
+            events?: {
+                type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                message: string;
+                stack?: string | undefined;
+            }[] | undefined;
+            output?: unknown;
+            isStable?: boolean | undefined;
+            stabilityScreenshots?: {
+                hash: string;
+                delayMs: number;
+                image?: string | undefined;
+            }[] | undefined;
+            previousDispose?: {
+                hasError: boolean;
+                errors: readonly {
+                    message: string;
+                    stack?: string | undefined;
+                }[];
+                events: readonly {
+                    type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                    message: string;
+                    stack?: string | undefined;
+                }[];
+            } | undefined;
+            currentDispose?: {
+                hasError: boolean;
+                errors: readonly {
+                    message: string;
+                    stack?: string | undefined;
+                }[];
+                events: readonly {
+                    type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                    message: string;
+                    stack?: string | undefined;
+                }[];
+            } | undefined;
+        }>;
+        takeBatch: (params: {
+            fixtureIds: string[];
+            sourceTreeId: string;
+            sessionName: string;
+            includeImages?: boolean | undefined;
+            reloadBetweenFixtures?: boolean | undefined;
+            input?: unknown;
+        }) => Promise<{
+            sourceTreeId: string;
+            screenshots: {
+                hasError: boolean;
+                fixtureId: string;
+                hash?: string | undefined;
+                image?: string | undefined;
+                error?: {
+                    message: string;
+                    stack?: string | undefined;
+                } | undefined;
+                events?: {
+                    type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                    message: string;
+                    stack?: string | undefined;
+                }[] | undefined;
+                output?: unknown;
+            }[];
+        }>;
+        compare: (params: {
+            fixtureId: string;
+            baselineSessionName: string;
+            baselineSourceTreeId: string;
+            currentSessionName: string;
+            currentSourceTreeId: string;
+            includeImages?: boolean | undefined;
+        }) => Promise<{
+            match: boolean;
+            baselineHasError: boolean;
+            currentHasError: boolean;
+            baselineHash?: string | undefined;
+            currentHash?: string | undefined;
+            baselineImage?: string | undefined;
+            currentImage?: string | undefined;
+            baselineError?: {
+                message: string;
+                stack?: string | undefined;
+            } | undefined;
+            baselineEvents?: {
+                type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                message: string;
+                stack?: string | undefined;
+            }[] | undefined;
+            baselineOutput?: unknown;
+            currentError?: {
+                message: string;
+                stack?: string | undefined;
+            } | undefined;
+            currentEvents?: {
+                type: "console.error" | "console.warn" | "console.log" | "window.error" | "window.unhandledrejection";
+                message: string;
+                stack?: string | undefined;
+            }[] | undefined;
+            currentOutput?: unknown;
+            labels?: readonly string[] | undefined;
+            labelsBefore?: readonly string[] | undefined;
+            approval?: {
+                fixtureId: string;
+                originalHash: string;
+                modifiedHash: string;
+                comment: string;
+                approvedAt: string;
+            } | undefined;
+        }>;
+    };
+    approvals: {
+        approve: (params: {
+            fixtureId: string;
+            originalHash: string;
+            modifiedHash: string;
+            comment: string;
+        }) => Promise<void>;
+        revoke: (params: {
+            fixtureId: string;
+            originalHash: string;
+            modifiedHash: string;
+        }) => Promise<void>;
+        list: (params: {
+            fixtureId?: string | undefined;
+        }) => Promise<{
+            fixtureId: string;
+            originalHash: string;
+            modifiedHash: string;
+            comment: string;
+            approvedAt: string;
+        }[]>;
+        lookup: (params: {
+            fixtureId: string;
+            originalHash: string;
+            modifiedHash: string;
+        }) => Promise<{
+            fixtureId: string;
+            originalHash: string;
+            modifiedHash: string;
+            comment: string;
+            approvedAt: string;
+        } | null>;
+    };
+    visualReview: {
+        getStatus: (params: {
+            fixtureId: string;
+            expectedVisualDescriptions: string[];
+            screenshotHash: string;
+        }) => Promise<"no-expectations" | {
+            expectedVisualDescriptions: readonly string[];
+            status: "approved" | "needs-review";
+            approval?: {
+                approvedAt: string;
+                comment: string;
+            } | undefined;
+        }>;
+        approve: (params: {
+            fixtureId: string;
+            expectedVisualDescriptions: string[];
+            screenshotHash: string;
+            comment: string;
+        }) => Promise<void>;
+    };
+    evaluate: (params: {
+        sessionName: string;
+        sourceTreeId: string;
+        expression: string;
+        fixtureId?: string | undefined;
+    }) => Promise<{
+        result: unknown;
+    }>;
+    setBrowserVisibility: (params: {
+        visible: boolean;
+    }) => Promise<{
+        visible: boolean;
+    }>;
+    events: (params: Record<string, never>, opts?: StreamCallOptions<NoInfer<{
+        type: "source-change";
+        sessionName: string;
+        sourceTreeId: string;
+    } | {
+        type: "ref-change";
+        sessionName: string;
+        newCommit: string;
+    } | {
+        type: "session-change";
+    } | {
+        type: "log";
+        level: "info" | "debug" | "trace";
+        message: string;
+    }>> | undefined) => StreamingCall<void, never> & Promise<void>;
+    sessions: (params: Record<string, never>) => Promise<({
+        name: string;
+        sourceKind: "current" | "worktree";
+        isLoading: true;
+    } | {
+        name: string;
+        sourceKind: "current" | "worktree";
+        serverUrl: string;
+        sourceTreeId: string;
+        isLoading?: false | undefined;
+        worktreePath?: string | undefined;
+        ref?: string | undefined;
+    })[]>;
+    restartSession: (params: {
+        sessionName: string;
+    }) => Promise<({
+        name: string;
+        sourceKind: "current" | "worktree";
+        isLoading: true;
+    } | {
+        name: string;
+        sourceKind: "current" | "worktree";
+        serverUrl: string;
+        sourceTreeId: string;
+        isLoading?: false | undefined;
+        worktreePath?: string | undefined;
+        ref?: string | undefined;
+    })[]>;
+    openSession: (params: {
+        name: string;
+        ref: string;
+    }) => Promise<{
+        sessions: ({
+            name: string;
+            sourceKind: "current" | "worktree";
+            isLoading: true;
+        } | {
+            name: string;
+            sourceKind: "current" | "worktree";
+            serverUrl: string;
+            sourceTreeId: string;
+            isLoading?: false | undefined;
+            worktreePath?: string | undefined;
+            ref?: string | undefined;
+        })[];
+    } | {
+        error: string;
+    }>;
+    closeSession: (params: {
+        name: string;
+    }) => Promise<{
+        sessions: ({
+            name: string;
+            sourceKind: "current" | "worktree";
+            isLoading: true;
+        } | {
+            name: string;
+            sourceKind: "current" | "worktree";
+            serverUrl: string;
+            sourceTreeId: string;
+            isLoading?: false | undefined;
+            worktreePath?: string | undefined;
+            ref?: string | undefined;
+        })[];
+    } | {
+        error: string;
+    }>;
+    updateSessionRef: (params: {
+        name: string;
+        ref: string;
+    }) => Promise<{
+        sessions: ({
+            name: string;
+            sourceKind: "current" | "worktree";
+            isLoading: true;
+        } | {
+            name: string;
+            sourceKind: "current" | "worktree";
+            serverUrl: string;
+            sourceTreeId: string;
+            isLoading?: false | undefined;
+            worktreePath?: string | undefined;
+            ref?: string | undefined;
+        })[];
+    } | {
+        error: string;
+    }>;
+    shutdown: (params: Record<string, never>) => Promise<void>;
+};
+type DaemonMethods = ReturnType<typeof createDaemonMethods>;
+interface DaemonClient {
+    readonly methods: DaemonMethods;
+    dispose(): void;
+}
+
+export type { DaemonClient, DaemonEvent, DaemonMethods, SessionInfo };