@vscode/component-explorer 0.2.1-17 → 0.2.1-170

package/dist/viewer.d.ts

@@ -1,34 +1,2910 @@
-import { FixtureModules, ExplorerRuntime } from './core/index.js';
-import { DaemonConfig } from './daemon/DaemonConfig.js';
-/**
- * Viewer entry point
- *
- * This module exports everything needed by the Component Explorer viewer.
- * Projects should NOT import from this module - use '@vscode/component-explorer' instead.
- */
-export * from './core/index.js';
-export type { FixtureExport, SingleFixtureExport, FixtureGroupExport, FixtureVariantsExport, } from './core/fixtureApi.js';
-export type { ExplorerMode, ExplorerQueryParams } from './lib/explorerQueryParams.js';
-export { Explorer, ExplorerModel } from './components/index.js';
-export type { ExplorerTreeNode } from './components/index.js';
-export { toExplorerTree } from './components/index.js';
-export { TitleBar, TitleBarButton, LeftSidebar, RightSidebar, TreeView, TreeItem, } from './components/index.js';
-export * from './components/icons.js';
-export { styles, mergeStyles } from './components/index.js';
-export { DaemonModel } from './daemon/index.js';
-export type { DaemonScreenshotResult, DaemonCompareResult, DaemonFixtureInfo } from './daemon/DaemonModel.js';
-export { ReportModel } from './report/index.js';
-export type { ScreenshotReport, ReportFixtureEntry, ReportSummary, FixtureStatus } from './report/index.js';
-export interface ExplorerAppOptions {
+import { k as DisplayMode, x as StyleDefinition, s as IJsonSchema, p as FixtureInputControlOptions, b as DebugPanelDefinition, R as RenderContext, w as RenderReturn, S as SingleFixtureExport, n as FixtureGroupExport, q as FixtureVariantsExport, l as FixtureExport, P as PageMode, I as IDisposable$2, u as RenderHost, v as RenderResult, g as DebugPanelViewStateOptions, f as DebugPanelViewState } from './fixtureApi.d-DjVuiRlO.js';
+export { C as ComponentMode, D as DebugPanelActivation, a as DebugPanelChannel, c as DebugPanelPlacement, d as DebugPanelViewContext, e as DebugPanelViewInstance, h as DefineComponentOptions, i as DefineDebugPanelOptions, j as DefineFixtureOptions, F as FixtureDebugApi, m as FixtureGroupEntry, o as FixtureGroupInput, r as FixtureVariantsInput, t as InteractiveOutput, V as ViewportPreset, y as ViewportPresetName, L as asyncRender, z as defineDebugPanel, A as defineFixture, B as defineFixtureGroup, E as defineFixtureVariants, G as fixtureGroupBrand, H as fixtureVariantsBrand, J as interactiveOutput, M as isInteractiveOutput, K as singleFixtureBrand, N as syncRender } from './fixtureApi.d-DjVuiRlO.js';
+import * as React from 'react';
+import { Context } from 'react';
+import * as zod_v4_core from 'zod/v4/core';
+import { $ZodType, output } from 'zod/v4/core';
+import * as zod_mini from 'zod/mini';
+import 'zod';
+
+/**
+ * Type guard for SingleFixtureExport.
+ * Uses the global symbol brand for cross-version compatibility.
+ */
+declare function isSingleFixture(value: unknown): value is SingleFixtureExport;
+/**
+ * Type guard for FixtureGroupExport.
+ * Uses the global symbol brand for cross-version compatibility.
+ */
+declare function isFixtureGroup(value: unknown): value is FixtureGroupExport;
+/**
+ * Type guard for FixtureVariantsExport.
+ * Uses the global symbol brand for cross-version compatibility.
+ */
+declare function isFixtureVariants(value: unknown): value is FixtureVariantsExport;
+type ParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Parses and validates a potential fixture export.
+ * Returns a ParseResult with either the validated data or an error message.
+ */
+declare function parseFixtureExport(value: unknown): ParseResult<FixtureExport>;
+/**
+ * Parses and validates a single fixture export.
+ */
+declare function parseSingleFixture(value: unknown): ParseResult<SingleFixtureExport>;
+/**
+ * Parses and validates a fixture group export.
+ */
+declare function parseFixtureGroup(value: unknown): ParseResult<FixtureGroupExport>;
+/**
+ * Parses and validates a fixture variants export.
+ */
+declare function parseFixtureVariants(value: unknown): ParseResult<FixtureVariantsExport>;
+/**
+ * Definition of a component fixture (internal representation).
+ */
+interface ComponentDefinition {
+    /** Unique identifier within the fixture file */
+    readonly id: string;
+    /** Display name shown in the tree */
+    readonly name: string;
+    /** Optional description for documentation */
+    readonly description?: string;
+    /** How to isolate this component from other components */
+    readonly isolation: 'none' | 'shadow-dom' | 'iframe';
+    /** How to display: page (device viewport) or component (natural size) */
+    readonly displayMode: DisplayMode;
+    /** Stylesheets to inject (into document head, shadow root, or iframe head depending on isolation mode) */
+    readonly styles?: readonly StyleDefinition[];
+    /** Background pattern for the preview canvas: 'light' (default) or 'dark' for dark transparent pattern */
+    readonly background: 'light' | 'dark';
+    /** Labels for categorization and filtering */
+    readonly labels: readonly string[];
+    /** Accumulated expected visual descriptions (from self + parent groups/variants) */
+    readonly expectedVisualDescriptions: readonly string[];
+    /** JSON Schema describing the expected shape of `RenderContext.input` (always an object). */
+    readonly inputSchema?: IJsonSchema;
+    /** Explorer presentation metadata for input properties. */
+    readonly inputControls?: Readonly<Record<string, FixtureInputControlOptions>>;
+    /** Statically declared custom debug panels. */
+    readonly debugPanels: readonly DebugPanelDefinition<unknown, unknown>[];
+    /** Source file path this fixture was defined in */
+    readonly sourceFile: string;
+    /**
+     * Render the component into the container.
+     * Returns an optional RenderResult or Promise for cleanup and async readiness.
+     */
+    render(container: HTMLElement, context: RenderContext): RenderReturn;
+}
+/**
+ * Creates the component definition from a validated SingleFixtureExport.
+ *
+ * @param inheritedInputSchema - JSON Schema accumulated from enclosing groups/variants; merged
+ *   with the fixture's own schema (the fixture's properties win on conflict).
+ */
+declare function createComponentDefinition(fixture: SingleFixtureExport, id: string, name: string, sourceFile: string, inheritedVisualDescriptions?: readonly string[], inheritedInputSchema?: IJsonSchema | undefined): ComponentDefinition;
+/**
+ * Merges two object JSON Schemas. `child` properties win over `parent` on key conflicts;
+ * `required` is the de-duplicated union. Returns whichever side is defined when only one is.
+ */
+declare function mergeInputSchemas(parent: IJsonSchema | undefined, child: IJsonSchema | undefined): IJsonSchema | undefined;
+/**
+ * Builds the effective `input` object passed to a fixture: the schema's top-level property
+ * defaults, overlaid with any caller-provided overrides. Returns the override unchanged when
+ * there is no schema (so schemaless fixtures keep their original `undefined`/passthrough input).
+ */
+declare function applyInputDefaults(schema: IJsonSchema | undefined, input: unknown): unknown;
+/**
+ * Type guard for checking if a value is a ComponentDefinition.
+ * @deprecated Use isSingleFixture or isFixtureGroup instead
+ */
+declare function isComponentDefinition(value: unknown): value is ComponentDefinition;
+
+interface IDisposable$1 {
+    dispose(): void;
+}
+declare class DisposableStore$1 implements IDisposable$1 {
+    private disposables;
+    private _isDisposed;
+    get isDisposed(): boolean;
+    dispose(): void;
+    add<T extends IDisposable$1 | undefined>(disposable: T): T;
+    remove<T extends IDisposable$1 | undefined>(disposable: T): T;
+    clear(): void;
+    leakItems(): void;
+}
+
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ */
+interface IObservable$1<T> extends IObservableWithChange$1<T, unknown> {
+}
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ * @template TChange The type used to describe value changes
+ * (usually `void` and only used in advanced scenarios).
+ * While observers can miss temporary values of an observable,
+ * they will receive all change values (as long as they are subscribed)!
+ */
+interface IObservableWithChange$1<T, TChange = unknown> {
+    /**
+     * Returns the current value.
+     *
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    get(): T;
+    /**
+     * Forces the observable to check for changes and report them.
+     *
+     * Has the same effect as calling {@link IObservable.get}, but does not force the observable
+     * to actually construct the value, e.g. if change deltas are used.
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    reportChanges(): void;
+    /**
+     * Adds the observer to the set of subscribed observers.
+     * This method is idempotent.
+     */
+    addObserver(observer: IObserver$1): void;
+    /**
+     * Removes the observer from the set of subscribed observers.
+     * This method is idempotent.
+     */
+    removeObserver(observer: IObserver$1): void;
+    /**
+     * Reads the current value and subscribes the reader to this observable.
+     *
+     * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
+     * (see {@link ConvenientObservable.read} for the implementation).
+     */
+    read(reader: IReader$1 | undefined): T;
+    /**
+     * Makes sure this value is computed eagerly.
+     */
+    recomputeInitiallyAndOnChange(store: DisposableStore$1, handleValue?: (value: T) => void): IObservable$1<T>;
+    /**
+     * Makes sure this value is cached.
+     */
+    keepObserved(store: DisposableStore$1): IObservable$1<T>;
+    /**
+     * Creates a derived observable that depends on this observable.
+     * Use the reader to read other observables
+     * (see {@link ConvenientObservable.map} for the implementation).
+     */
+    map<TNew>(fn: (value: T, reader: IReader$1) => TNew): IObservable$1<TNew>;
+    map<TNew>(owner: object, fn: (value: T, reader: IReader$1) => TNew): IObservable$1<TNew>;
+    flatten<TNew>(this: IObservable$1<IObservable$1<TNew>>): IObservable$1<TNew>;
+    /**
+     * ONLY FOR DEBUGGING!
+     * Logs computations of this derived.
+    */
+    log(): IObservableWithChange$1<T, TChange>;
+    /**
+     * A human-readable name for debugging purposes.
+     */
+    readonly debugName: string;
+    /**
+     * ONLY FOR DEBUGGING!
+    */
+    debugGetDependencyGraph(): string;
+    /**
+     * This property captures the type of the change object. Do not use it at runtime!
+     */
+    readonly TChange: TChange;
+}
+/**
+ * Represents an observer that can be subscribed to an observable.
+ *
+ * If an observer is subscribed to an observable and that observable didn't signal
+ * a change through one of the observer methods, the observer can assume that the
+ * observable didn't change.
+ * If an observable reported a possible change, {@link IObservable.reportChanges} forces
+ * the observable to report an actual change if there was one.
+ */
+interface IObserver$1 {
+    /**
+     * Signals that the given observable might have changed and a transaction potentially modifying that observable started.
+     * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     */
+    beginUpdate<T>(observable: IObservable$1<T>): void;
+    /**
+     * Signals that the transaction that potentially modified the given observable ended.
+     * This is a good place to react to (potential) changes.
+     */
+    endUpdate<T>(observable: IObservable$1<T>): void;
+    /**
+     * Signals that the given observable might have changed.
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     */
+    handlePossibleChange<T>(observable: IObservable$1<T>): void;
+    /**
+     * Signals that the given {@link observable} changed.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     *
+     * @param change Indicates how or why the value changed.
+     */
+    handleChange<T, TChange>(observable: IObservableWithChange$1<T, TChange>, change: TChange): void;
+}
+interface IReader$1 {
+    /**
+     * Reads the value of an observable and subscribes to it.
+     */
+    readObservable<T>(observable: IObservableWithChange$1<T, any>): T;
+}
+interface ISettable<T, TChange = void> {
+    /**
+     * Sets the value of the observable.
+     * Use a transaction to batch multiple changes (with a transaction, observers only react at the end of the transaction).
+     *
+     * @param transaction When given, value changes are handled on demand or when the transaction ends.
+     * @param change Describes how or why the value changed.
+     */
+    set(value: T, transaction: ITransaction | undefined, change: TChange): void;
+}
+interface ITransaction {
+    /**
+     * Calls {@link Observer.beginUpdate} immediately
+     * and {@link Observer.endUpdate} when the transaction ends.
+     */
+    updateObserver(observer: IObserver$1, observable: IObservableWithChange$1<any, any>): void;
+}
+/**
+ * A settable observable.
+ */
+interface ISettableObservable<T, TChange = void> extends IObservableWithChange$1<T, TChange>, ISettable<T, TChange> {
+}
+
+/** A fixture's input override object (only the keys the user explicitly changed). */
+type FixtureInputOverride = Record<string, unknown>;
+/**
+ * Central store of `input` overrides for the explorer UI.
+ *
+ * Values are keyed by **property identity** (name + structural schema), not by fixture, so a
+ * value chosen on one fixture is automatically reused by every other fixture that declares the
+ * same input — navigating between fixtures keeps the shared value instead of resetting it.
+ * The whole map is persisted to `localStorage` so choices survive reloads. Schema defaults are
+ * applied at render time (see `applyInputDefaults`); only explicit overrides are stored here.
+ */
+declare class FixtureInputStore {
+    /** Shared values keyed by `inputPropertyKey(name, schema)`. */
+    private readonly _values;
+    /** Cache of derived per-fixture override observables. */
+    private readonly _byFixture;
+    constructor();
+    /**
+     * Returns a derived observable of `fixtureId`'s input overrides, mapped from the shared
+     * per-property store. Only properties the user explicitly set (across any fixture) appear.
+     */
+    getInput(fixtureId: string, schema: IJsonSchema | undefined): IObservable$1<FixtureInputOverride>;
+    /** The currently effective value of a shared property: explicit override, else schema default. */
+    readValue(reader: IReader$1, name: string, schema: IJsonSchema): unknown;
+    /** Sets a shared input property (applies to every fixture that declares it) and persists. */
+    setValue(name: string, schema: IJsonSchema, value: unknown): void;
+    private _load;
+    private _persist;
+}
+
+/**
+ * A single input property shared by one or more of the currently rendered fixtures.
+ * Properties are grouped by name **and** structural schema equality, so a control can edit
+ * every fixture that declares the same property at once.
+ */
+interface AggregatedInputProperty {
+    readonly name: string;
+    readonly schema: IJsonSchema;
+    /** Ids of the fixtures that declare this exact property (same name + schema). */
+    readonly fixtureIds: readonly string[];
+}
+/** Minimal shape needed to aggregate: a fixture id and its (merged) input schema. */
+interface ComponentInputInfo {
+    readonly id: string;
+    readonly inputSchema?: IJsonSchema;
+}
+/**
+ * Collects the input properties declared across the given fixtures, grouping identical
+ * (name + schema) properties so they can be edited together. Order follows first appearance.
+ */
+declare function aggregateInputProperties(components: readonly ComponentInputInfo[]): AggregatedInputProperty[];
+/** The value currently in effect for a property: explicit override, else schema default. */
+declare function effectiveInputValue(override: Record<string, unknown> | undefined, name: string, schema: IJsonSchema): unknown;
+
+interface ExceptionError {
+    readonly message: string;
+    readonly stack?: string;
+}
+type RenderEventType = 'console.error' | 'console.warn' | 'console.log' | 'window.error' | 'window.unhandledrejection';
+interface RenderEvent {
+    readonly type: RenderEventType;
+    readonly message: string;
+    readonly stack?: string;
+}
+/**
+ * Errors and events captured while disposing a fixture (the implicit dispose
+ * that runs before a new render, or the explicit one triggered by
+ * `disposeAfter` / `disposeCurrentFixture()`).
+ */
+interface DisposeReport {
+    readonly hasError: boolean;
+    /** Errors thrown by `dispose()` calls (RenderResult.dispose, addDisposable disposables). */
+    readonly errors: readonly ExceptionError[];
+    /** Console / window error events fired during the dispose call. */
+    readonly events: readonly RenderEvent[];
+}
+interface RenderReport {
+    readonly hasError: boolean;
+    readonly error?: ExceptionError;
+    readonly events: RenderEvent[];
+    /** Output data the fixture provided via `RenderResult.output` (counterpart of `RenderContext.input`). */
+    readonly output?: unknown;
+    readonly renderTimeMs: {
+        readonly sync: number;
+        readonly total: number;
+    };
+    /**
+     * Errors / events captured while disposing the previous fixture (the implicit
+     * dispose that runs at the start of `renderFixture`). Present only if the
+     * dispose actually surfaced something.
+     */
+    readonly previousDispose?: DisposeReport;
+}
+
+declare class FixturePath {
+    readonly value: string;
+    private _segments;
+    constructor(value: string);
+    get segments(): readonly string[];
+    toString(): string;
+}
+
+/**
+ * A node in the fixture tree.
+ * Can be a folder (with children), variants (with children, horizontal layout), or a component leaf.
+ */
+interface FixtureNode {
+    readonly id: FixturePath;
+    /** Display name */
+    readonly name: string;
+    /** Node type: folder for groups, variants for horizontal variant display, component for leaves */
+    readonly type: 'folder' | 'variants' | 'component';
+    /** Children (for folders and variants) */
+    readonly children?: readonly FixtureNode[];
+    /** Component definition (only for component nodes) */
+    readonly component?: ComponentDefinition;
+    /** Labels for categorization and filtering */
+    readonly labels: readonly string[];
+    /** Source fixture file path — present on skeleton nodes (component is undefined) for on-demand loading */
+    readonly sourceFile?: string;
+}
+/**
+ * Creates a fixture tree from a map of fixture exports.
+ * Entries with `undefined` value are rendered as skeleton nodes (loaded on demand).
+ */
+declare function createFixtureTree(fixtures: Map<string, FixtureExport>): FixtureNode;
+/**
+ * Finds a node in the tree by path.
+ */
+declare function findNodeByPath(root: FixtureNode, path: string[]): FixtureNode | undefined;
+/**
+ * Collects all component nodes from a subtree.
+ */
+declare function collectComponents(node: FixtureNode): ComponentDefinition[];
+
+/**
+ * Viewport preset - either a named preset or custom dimensions.
+ */
+type ViewportPreset = ViewportPresetName | {
+    readonly name: string;
+    readonly width: number;
+    readonly height: number;
+};
+type ViewportPresetName = 'mobile' | 'tablet' | 'desktop';
+/**
+ * Standard viewport dimensions for presets.
+ */
+declare const VIEWPORT_SIZES: Record<ViewportPresetName, {
+    readonly width: number;
+    readonly height: number;
+}>;
+/**
+ * Resolves a viewport preset to actual dimensions.
+ */
+declare function resolveViewport(preset: ViewportPreset): {
+    name: string;
+    width: number;
+    height: number;
+};
+
+declare class FixtureRegistry {
+    readonly storageScope?: string | undefined;
+    constructor(storageScope?: string | undefined);
+    private readonly _fixtures;
+    readonly loading: ISettableObservable<boolean, void>;
+    readonly error: ISettableObservable<string | undefined, void>;
+    readonly root: IObservable$1<FixtureNode>;
+    register(path: string, fixtureExport: FixtureExport): void;
+    unregister(path: string): void;
+    clear(): void;
+    getNode(reader: IReader$1, path: string[]): FixtureNode | undefined;
+    getComponentByPath(path: string[]): ComponentDefinition | undefined;
+}
+
+interface FixtureModules {
+    [path: string]: {
+        default?: unknown;
+    };
+}
+interface ExplorerRuntime {
+    updateFixtures(fixtureModules: FixtureModules): void;
+    bumpVersion(): void;
+}
+
+/**
+ * Configuration injected by the daemon via the Vite plugin.
+ * Passed to ExplorerApp as `options.daemonConfig`.
+ */
+interface DaemonConfig {
+    /** Name of the session this explorer instance belongs to (e.g. 'current' or 'baseline') */
+    readonly sessionName: string;
+    /** Runtime version required by the vite plugin for the explorer bundle it serves. */
+    readonly runtimeVersionNeededByPlugin: string;
+}
+
+type ExplorerMode = 'headless' | 'embedded';
+interface ExplorerQueryParams {
+    readonly mode?: ExplorerMode;
+    readonly fixture?: string;
+    readonly file?: string;
+    readonly report?: string;
+}
+
+//#region src/protocol/jsonValue.d.ts
+/**
+ * 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`).
+ */
+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[];
+}
+/**
+ * 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.
+ */
+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 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>;
+
+/** Screenshot result from the daemon */
+type DaemonScreenshotResult = Awaited<ReturnType<DaemonMethods['screenshots']['take']>>;
+/** Comparison result from the daemon */
+type DaemonCompareResult = Awaited<ReturnType<DaemonMethods['screenshots']['compare']>>;
+/** Fixture info from the daemon */
+type DaemonFixtureInfo = Awaited<ReturnType<DaemonMethods['fixtures']['list']>>['fixtures'][number];
+interface DaemonSession {
+    readonly name: string;
+    readonly serverUrl: string;
+    readonly sourceKind: 'current' | 'worktree';
+}
+/**
+ * Client-side model for interacting with the daemon.
+ * Manages source tree IDs, screenshot caching, and the event stream.
+ */
+declare class DaemonModel {
+    readonly config: DaemonConfig;
+    private readonly _sourceTreeIds;
+    private readonly _sessions;
+    private readonly _screenshotCache;
+    private _client;
+    private _stopEventStream;
+    private _reconnectTimer;
+    private _disposed;
+    readonly sessionName: string;
+    /** Observable map of sessionName → current sourceTreeId */
+    readonly sourceTreeIds: IObservable$1<ReadonlyMap<string, string>>;
+    /** Observable list of sessions from the daemon */
+    readonly sessions: IObservable$1<readonly DaemonSession[]>;
+    constructor(config: DaemonConfig);
+    /**
+     * Initializes the model: fetches initial session info and starts listening to events.
+     * Call this once after construction.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get a screenshot for a fixture in a session, using cache when available.
+     * Cache is keyed on sessionName + fixtureId and invalidated when sourceTreeId changes.
+     */
+    getScreenshot(sessionName: string, fixtureId: string): Promise<DaemonScreenshotResult>;
+    /**
+     * Compare a fixture across two sessions. Returns match status and hashes (no images).
+     */
+    compare(fixtureId: string, baselineSessionName: string, currentSessionName: string): Promise<DaemonCompareResult>;
+    /**
+     * List fixtures from a session.
+     */
+    listFixtures(sessionName: string): Promise<readonly DaemonFixtureInfo[]>;
+    /**
+     * Get the explorer URL for a different session (for session switching via full navigation).
+     */
+    getSessionExplorerUrl(sessionName: string): string | undefined;
+    dispose(): void;
+    private _requireClient;
+    private _connect;
+    private _fetchSessionInfos;
+    private _startEventStream;
+    private _onEventStreamEnded;
+    private _scheduleReconnect;
+    private _handleEvent;
+    private _validateProtocolVersions;
+}
+
+type FixtureStatus = 'unchanged' | 'changed' | 'added';
+interface ReportFixtureEntry {
+    readonly status: FixtureStatus;
+    readonly targetHash: string;
+    readonly compareHash?: string;
+    readonly background?: 'light' | 'dark';
+    readonly baselineScreenshot?: string;
+    readonly currentScreenshot?: string;
+    readonly labels?: readonly string[];
+}
+interface ReportSummary {
+    readonly total: number;
+    readonly added: number;
+    readonly changed: number;
+    readonly unchanged: number;
+}
+interface ScreenshotReport {
+    readonly timestamp: string;
+    readonly target: string;
+    readonly compareTarget: string;
+    readonly summary: ReportSummary;
+    readonly fixtures: {
+        readonly [fixtureId: string]: ReportFixtureEntry | undefined;
+    };
+}
+
+type ExplorerTreeKind = 'components' | 'favorites';
+/**
+ * Explorer's tree node structure, derived from FixtureNode.
+ * This is the explorer's own representation of the fixture tree.
+ */
+interface ExplorerTreeNode {
+    readonly id: FixturePath;
+    readonly name: string;
+    readonly type: 'folder' | 'variants' | 'component';
+    readonly children?: readonly ExplorerTreeNode[];
+    readonly component?: ComponentDefinition;
+    readonly labels: readonly string[];
+    readonly isFavoritesRoot?: boolean;
+}
+/**
+ * Converts a FixtureNode tree to ExplorerTreeNode tree.
+ * This allows the explorer to have its own tree structure.
+ */
+declare function toExplorerTree(node: FixtureNode): ExplorerTreeNode;
+
+type ReportState = {
+    readonly status: 'loading';
+} | {
+    readonly status: 'ready';
+    readonly report: ScreenshotReport;
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+declare class ReportModel {
+    readonly reportUrl: string;
+    readonly state: ISettableObservable<ReportState, void>;
+    private readonly _baseUrl;
+    constructor(reportUrl: string);
+    resolveScreenshotUrl(relativePath: string): string;
+    buildTree(reader: IReader$1): ExplorerTreeNode;
+    private _fetch;
+}
+
+declare const Explorer: React.ComponentType<{
+    registry: FixtureRegistry;
+    daemonModel: DaemonModel | undefined;
+    reportModel: ReportModel | undefined;
+} & {} & {
+    daemonModel: DaemonModel | undefined;
+    reportModel: ReportModel | undefined;
+} & {}>;
+
+interface IDisposable {
+    dispose(): void;
+}
+declare class DisposableStore implements IDisposable {
+    private disposables;
+    private _isDisposed;
+    get isDisposed(): boolean;
+    dispose(): void;
+    add<T extends IDisposable | undefined>(disposable: T): T;
+    remove<T extends IDisposable | undefined>(disposable: T): T;
+    clear(): void;
+    leakItems(): void;
+}
+
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ */
+interface IObservable<T> extends IObservableWithChange<T, unknown> {
+}
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ * @template TChange The type used to describe value changes
+ * (usually `void` and only used in advanced scenarios).
+ * While observers can miss temporary values of an observable,
+ * they will receive all change values (as long as they are subscribed)!
+ */
+interface IObservableWithChange<T, TChange = unknown> {
+    /**
+     * Returns the current value.
+     *
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    get(): T;
+    /**
+     * Forces the observable to check for changes and report them.
+     *
+     * Has the same effect as calling {@link IObservable.get}, but does not force the observable
+     * to actually construct the value, e.g. if change deltas are used.
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    reportChanges(): void;
+    /**
+     * Adds the observer to the set of subscribed observers.
+     * This method is idempotent.
+     */
+    addObserver(observer: IObserver): void;
+    /**
+     * Removes the observer from the set of subscribed observers.
+     * This method is idempotent.
+     */
+    removeObserver(observer: IObserver): void;
+    /**
+     * Reads the current value and subscribes the reader to this observable.
+     *
+     * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
+     * (see {@link ConvenientObservable.read} for the implementation).
+     */
+    read(reader: IReader | undefined): T;
+    /**
+     * Makes sure this value is computed eagerly.
+     */
+    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+    /**
+     * Makes sure this value is cached.
+     */
+    keepObserved(store: DisposableStore): IObservable<T>;
+    /**
+     * Creates a derived observable that depends on this observable.
+     * Use the reader to read other observables
+     * (see {@link ConvenientObservable.map} for the implementation).
+     */
+    map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    flatten<TNew>(this: IObservable<IObservable<TNew>>): IObservable<TNew>;
+    /**
+     * ONLY FOR DEBUGGING!
+     * Logs computations of this derived.
+    */
+    log(): IObservableWithChange<T, TChange>;
+    /**
+     * A human-readable name for debugging purposes.
+     */
+    readonly debugName: string;
+    /**
+     * ONLY FOR DEBUGGING!
+    */
+    debugGetDependencyGraph(): string;
+    /**
+     * This property captures the type of the change object. Do not use it at runtime!
+     */
+    readonly TChange: TChange;
+}
+/**
+ * Represents an observer that can be subscribed to an observable.
+ *
+ * If an observer is subscribed to an observable and that observable didn't signal
+ * a change through one of the observer methods, the observer can assume that the
+ * observable didn't change.
+ * If an observable reported a possible change, {@link IObservable.reportChanges} forces
+ * the observable to report an actual change if there was one.
+ */
+interface IObserver {
+    /**
+     * Signals that the given observable might have changed and a transaction potentially modifying that observable started.
+     * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     */
+    beginUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the transaction that potentially modified the given observable ended.
+     * This is a good place to react to (potential) changes.
+     */
+    endUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the given observable might have changed.
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     */
+    handlePossibleChange<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the given {@link observable} changed.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     *
+     * @param change Indicates how or why the value changed.
+     */
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
+}
+interface IReader {
+    /**
+     * Reads the value of an observable and subscribes to it.
+     */
+    readObservable<T>(observable: IObservableWithChange<T, any>): T;
+}
+
+type Readable<T> = (reader: IReader) => T;
+interface IReadableObj<T> {
+    /**
+     * The reader of the component.
+    */
+    read(reader: IReader): T;
+}
+interface IPropertyTransformerFactory<TIn, TOut> {
+    /** If set, this context's value is passed to create() */
+    readonly _requiredContext?: Context<unknown>;
+    /** @param contextValue - value of _requiredContext if declared, otherwise undefined */
+    create(readable: Readable<TIn>, contextValue: unknown): IReadableObj<TOut>;
+}
+
+declare const ViewModelContextSymbol: unique symbol;
+type PropsDesc = Record<string, IPropertyTransformerFactory<any, any>>;
+type PropsIn<T extends PropsDesc> = {
+    [K in keyof T]: T[K] extends IPropertyTransformerFactory<infer U, any> ? U : never;
+};
+type PropsOut<T extends PropsDesc> = {
+    [K in keyof T]: T[K] extends IPropertyTransformerFactory<any, infer U> ? U : never;
+};
+declare class BaseViewModel<TProps> implements IDisposable {
+    protected readonly props: TProps;
+    protected _store: DisposableStore;
+    constructor(props: TProps);
+    dispose(): void;
+}
+type ViewModelClass<TProps extends PropsDesc> = {
+    new (arg: PropsOut<TProps>): BaseViewModel<PropsOut<TProps>>;
+    _props: TProps;
+    [ViewModelContextSymbol]?: Context<unknown>;
+};
+
+interface ReportFixtureItem {
+    readonly fixtureId: string;
+    readonly name: string;
+    readonly path: string;
+    readonly entry: ReportFixtureEntry;
+}
+
+type PagePreviewMode = 'fit' | 'responsive' | 'actual';
+type ComponentPreviewMode = Exclude<PagePreviewMode, 'responsive'>;
+interface PageViewportSettings {
+    readonly viewportIndex: number;
+    readonly width: number;
+    readonly height: number;
+    readonly mode: PagePreviewMode;
+}
+declare class FixtureViewportStore {
+    private readonly _values;
+    readonly mode: ISettableObservable<PagePreviewMode, void>;
+    constructor();
+    read(reader: IReader$1, fixtureId: string, pageMode: PageMode): PageViewportSettings;
+    get(fixtureId: string, pageMode: PageMode): PageViewportSettings;
+    readComponentMode(reader: IReader$1): ComponentPreviewMode;
+    selectViewport(fixtureId: string, pageMode: PageMode, viewportIndex: number): void;
+    setWidth(fixtureId: string, pageMode: PageMode, width: number): void;
+    setHeight(fixtureId: string, pageMode: PageMode, height: number): void;
+    private _set;
+    private _load;
+    private _persist;
+}
+
+interface ActiveDebugPanelSession extends IDisposable$2 {
+    sendAction(action: unknown): void;
+}
+
+declare class ComponentRendering {
+    readonly component: ComponentDefinition;
+    private readonly _renderHost;
+    private readonly _input?;
+    private readonly _onInputReport?;
+    readonly renderTarget: HTMLElement;
+    readonly iframe: HTMLIFrameElement | null;
+    private readonly _abortController;
+    private _resolvedResult;
+    private _injectedElements;
+    private _adoptedSheets;
+    private _styleTarget;
+    private readonly _disposables;
+    private readonly _rendered;
+    private readonly _inputRuntime;
+    private readonly _debugRuntime;
+    private readonly _iframeActiveSessions;
+    private readonly _iframePanelStateHandlers;
+    private _iframeHasOutput;
+    private _iframeOutputEditable;
+    private _nextIframePanelSessionId;
+    private _currentInput;
+    constructor(host: HTMLElement, component: ComponentDefinition, _renderHost?: RenderHost, _input?: unknown | undefined, _onInputReport?: ((key: string, value: unknown) => void) | undefined);
+    private readonly _pendingInputReports;
+    private _queueInputReport;
+    updateInput(input: unknown): boolean;
+    get hasOutput(): boolean;
+    get outputEditable(): boolean;
+    getOutputSnapshot(): unknown;
+    activateDebugPanel(panelId: string, publish: (state: unknown) => void): ActiveDebugPanelSession;
+    private _connectDebugPanel;
+    waitForRendering(): Promise<RenderResult | undefined>;
+    dispose(): Promise<readonly ExceptionError[]>;
+}
+
+interface FixtureDebugInfo {
+    readonly fixture: FixtureItem;
+    readonly rendering: ComponentRendering;
+    readonly ready: boolean;
+    readonly hasOutput: boolean;
+    readonly outputEditable: boolean;
+}
+declare class FixtureDebugStore {
+    private readonly _entries;
+    read(reader: IReader$1, fixtureId: string): FixtureDebugInfo | undefined;
+    get(fixtureId: string): FixtureDebugInfo | undefined;
+    setRendering(fixture: FixtureItem, rendering: ComponentRendering): void;
+    markReady(fixture: FixtureItem, rendering: ComponentRendering): void;
+    remove(fixtureId: string, rendering: ComponentRendering): void;
+    private _set;
+}
+
+type DebugSplitOrientation = 'horizontal' | 'vertical';
+interface DebugStackNode {
+    readonly type: 'stack';
+    readonly id: string;
+    readonly entryKeys: readonly string[];
+    readonly activeEntryKey: string;
+}
+interface DebugSplitNode {
+    readonly type: 'split';
+    readonly id: string;
+    readonly orientation: DebugSplitOrientation;
+    readonly ratio: number;
+    readonly first: DebugWorkbenchNode;
+    readonly second: DebugWorkbenchNode;
+}
+type DebugWorkbenchNode = DebugStackNode | DebugSplitNode;
+
+declare class DebugWorkbenchStateStore {
+    private readonly _storage?;
+    readonly error: ISettableObservable<string | undefined, void>;
+    private readonly _state;
+    private readonly _bindings;
+    private readonly _storageKey;
+    static forBrowser(projectScope: string): DebugWorkbenchStateStore;
+    constructor(projectScope?: string, _storage?: Pick<Storage, "getItem" | "setItem"> | undefined);
+    readonly synchronized: IObservableWithChange$1<boolean, void>;
+    setSynchronized(enabled: boolean, seedWorkbenchId?: string): void;
+    getEntryKey(workbenchId: string, key: string): string;
+    getPrimaryEntryKey(key: string): string;
+    duplicateEntry(workbenchId: string, key: string): string;
+    getLayout(workbenchId: string, entryKeys: readonly string[], _activeEntryKey?: string): ISettableObservable<DebugWorkbenchNode>;
+    getActiveEntry(workbenchId: string): ISettableObservable<string | undefined>;
+    readActiveEntry(reader: IReader$1 | undefined, workbenchId: string, entryKeys: readonly string[]): string | undefined;
+    private _visibleActiveEntry;
+    getPaneHeight(workbenchId: string): ISettableObservable<number | 'viewport' | undefined>;
+    getPaneFraction(workbenchId: string): ISettableObservable<number>;
+    viewState<T>(workbenchId: string, entryKey: string, fixtureId: string, options: DebugPanelViewStateOptions<T>): DebugPanelViewState<T>;
+    private _binding;
+    private _getState;
+    private _visibleState;
+    private _edit;
+    private _save;
+    private _reportError;
+}
+
+type ViewMode = 'session' | 'diff' | 'report';
+/**
+ * A fixture item to be rendered in the preview area.
+ */
+interface FixtureItem {
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly component: ComponentDefinition;
+}
+/**
+ * A screenshot comparison item for diff mode.
+ */
+interface ScreenshotComparisonItem {
+    readonly fixtureId: string;
+    readonly name: string;
+    readonly path: string;
+}
+interface RevealTreeNodeRequest {
+    readonly id: number;
+    readonly nodeId: string;
+}
+/**
+ * A preview row can be a live fixture, a variant group, or a screenshot comparison.
+ */
+type PreviewRow = {
+    readonly type: 'single';
+    readonly fixture: FixtureItem;
+} | {
+    readonly type: 'variants';
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly fixtures: readonly FixtureItem[];
+} | {
+    readonly type: 'screenshot-comparison';
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly items: readonly ScreenshotComparisonItem[];
+} | {
+    readonly type: 'report-comparison';
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly items: readonly ReportFixtureItem[];
+};
+declare const ExplorerModel_base: ViewModelClass<{
+    registry: IPropertyTransformerFactory<FixtureRegistry, FixtureRegistry>;
+    daemonModel: IPropertyTransformerFactory<DaemonModel | undefined, DaemonModel | undefined>;
+    reportModel: IPropertyTransformerFactory<ReportModel | undefined, ReportModel | undefined>;
+}>;
+declare class ExplorerModel extends ExplorerModel_base {
+    readonly leftSidebarVisible: ISettableObservable<boolean, void>;
+    readonly rightSidebarVisible: ISettableObservable<boolean, void>;
+    readonly isDarkTheme: ISettableObservable<boolean, void>;
+    readonly selectedNodeId: ISettableObservable<string | undefined, void>;
+    readonly expandedNodeKeys: ISettableObservable<ReadonlySet<string>, void>;
+    readonly revealTreeNodeRequest: ISettableObservable<RevealTreeNodeRequest | undefined, void>;
+    private _nextRevealTreeNodeRequestId;
+    readonly favoriteNodeIds: ISettableObservable<ReadonlySet<string>, void>;
+    readonly viewMode: ISettableObservable<ViewMode, void>;
+    get daemonAvailable(): boolean;
+    get daemon(): DaemonModel | undefined;
+    get reportModel(): ReportModel | undefined;
+    get isReportMode(): boolean;
+    readonly loading: IObservableWithChange$1<boolean, void>;
+    readonly error: IObservableWithChange$1<string | undefined, void>;
+    readonly searchQuery: ISettableObservable<string | undefined, void>;
+    /** The explorer's tree derived from the registry or report */
+    readonly tree: IObservableWithChange$1<ExplorerTreeNode, void>;
+    readonly filteredTree: IObservableWithChange$1<ExplorerTreeNode, void>;
+    readonly sidebarTrees: IObservableWithChange$1<readonly ExplorerTreeNode[], void>;
+    readonly selectedNode: IObservableWithChange$1<ExplorerTreeNode | undefined, void>;
+    /** List of preview rows to render based on current selection and view mode */
+    readonly selectedFixtures: IObservableWithChange$1<readonly PreviewRow[], void>;
+    /** Shared store of per-fixture `input` overrides, edited via the properties panel. */
+    readonly inputStore: FixtureInputStore;
+    /** Explorer-only page viewport size and presentation overrides. */
+    readonly viewportStore: FixtureViewportStore;
+    /** Live rendered fixture instances used by visibility-scoped debug panels. */
+    readonly debugStore: FixtureDebugStore;
+    /** Docking layouts and open-panel selections that survive preview-row recycling. */
+    readonly debugWorkbenchState: DebugWorkbenchStateStore;
+    /** Flattened list of the live fixtures currently shown in the preview area. */
+    readonly renderedFixtures: IObservableWithChange$1<readonly FixtureItem[], void>;
+    setViewMode: (mode: ViewMode) => void;
+    navigateToSession: (sessionName: string) => void;
+    toggleLeftSidebar: () => void;
+    toggleRightSidebar: () => void;
+    toggleTheme: () => void;
+    selectNode: (nodeId: string) => void;
+    toggleNodeExpanded: (treeKind: ExplorerTreeKind, nodeId: string) => void;
+    toggleNodeFavorite: (nodeId: string) => void;
+    revealSelectedNodeInTree: () => void;
+    isNodeExpanded(treeKind: ExplorerTreeKind, nodeId: string, reader: IReader$1): boolean;
+    private _initialExpandedNodes;
+    private _findNode;
+    private _collectPreviewRows;
+    /**
+     * In diff mode: fixtures become screenshot comparison items showing current vs baseline.
+     * Variants become comparison groups.
+     */
+    private _collectDiffRows;
+    private _collectReportRows;
+}
+
+declare const TitleBar: React.ComponentType<PropsIn<{
+    model: IPropertyTransformerFactory<ExplorerModel, ExplorerModel>;
+}>>;
+
+declare const TitleBarButton: React.ComponentType<{
+    active: boolean;
+} & {} & {
+    onClick: () => void;
+    title: string;
+    children: React.ReactNode;
+} & {}>;
+
+declare const LeftSidebar: React.ComponentType<PropsIn<{
+    model: IPropertyTransformerFactory<ExplorerModel, ExplorerModel>;
+}>>;
+
+/**
+ * Properties panel: aggregates the input schemas of every fixture currently rendered in the
+ * preview area and presents one control per shared property. Editing a control updates the
+ * `input` of all fixtures that declare that property (same name + schema), so common values
+ * like a theme can be switched across the whole view at once.
+ */
+declare const RightSidebar: React.ComponentType<PropsIn<{
+    model: IPropertyTransformerFactory<ExplorerModel, ExplorerModel>;
+}>>;
+
+declare const TreeView: React.ComponentType<PropsIn<{
+    model: IPropertyTransformerFactory<ExplorerModel, ExplorerModel>;
+    nodes: IPropertyTransformerFactory<readonly ExplorerTreeNode[], readonly ExplorerTreeNode[]>;
+    depth: IPropertyTransformerFactory<number, number>;
+    treeKind: IPropertyTransformerFactory<ExplorerTreeKind, ExplorerTreeKind>;
+}>>;
+declare const TreeItem: React.ComponentType<{
+    model: ExplorerModel;
+    node: ExplorerTreeNode;
+    depth: number;
+    treeKind: ExplorerTreeKind;
+} & {} & {} & {}>;
+
+declare const ChevronRightIcon: ({ style }: {
+    style?: React.CSSProperties;
+}) => React.JSX.Element;
+declare const ChevronDownIcon: ({ style }: {
+    style?: React.CSSProperties;
+}) => React.JSX.Element;
+declare const ComponentIcon: ({ style }: {
+    style?: React.CSSProperties;
+}) => React.JSX.Element;
+declare const FolderIcon: ({ style }: {
+    style?: React.CSSProperties;
+}) => React.JSX.Element;
+declare const StarIcon: ({ filled }: {
+    filled?: boolean;
+}) => React.JSX.Element;
+declare const RevealInTreeIcon: () => React.JSX.Element;
+declare const PanelLeftIcon: () => React.JSX.Element;
+declare const PanelRightIcon: () => React.JSX.Element;
+declare const SunIcon: () => React.JSX.Element;
+declare const MoonIcon: () => React.JSX.Element;
+
+declare const styles: {
+    readonly container: {
+        readonly display: "flex";
+        readonly flexDirection: "row";
+        readonly height: "100%";
+        readonly width: "100%";
+        readonly fontFamily: "var(--component-explorer-font-family)";
+        readonly fontSize: "var(--component-explorer-font-size)";
+        readonly color: "var(--component-explorer-foreground)";
+        readonly backgroundColor: "var(--component-explorer-editor-background)";
+    };
+    readonly centerArea: {
+        readonly display: "flex";
+        readonly flexDirection: "column";
+        readonly flex: 1;
+        readonly overflow: "hidden";
+    };
+    readonly titleBar: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly justifyContent: "space-between";
+        readonly height: "35px";
+        readonly minHeight: "35px";
+        readonly padding: "0 10px";
+        readonly backgroundColor: "var(--component-explorer-titleBar-activeBackground)";
+        readonly color: "var(--component-explorer-titleBar-activeForeground)";
+        readonly borderBottom: "1px solid var(--component-explorer-titleBar-border, var(--component-explorer-panel-border))";
+    };
+    readonly titleBarSection: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly gap: "2px";
+    };
+    readonly titleBarCenter: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly gap: "4px";
+        readonly fontSize: "13px";
+        readonly fontWeight: 400;
+    };
+    readonly titleBarButton: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly justifyContent: "center";
+        readonly width: "28px";
+        readonly height: "28px";
+        readonly border: "none";
+        readonly background: "transparent";
+        readonly color: "var(--component-explorer-titleBar-activeForeground)";
+        readonly cursor: "pointer";
+        readonly borderRadius: "4px";
+    };
+    readonly titleBarButtonHover: {
+        readonly backgroundColor: "var(--component-explorer-toolbar-hoverBackground)";
+    };
+    readonly titleBarButtonActive: {
+        readonly backgroundColor: "var(--component-explorer-toolbar-activeBackground)";
+        readonly color: "var(--component-explorer-focusBorder)";
+    };
+    readonly sidebar: {
+        readonly display: "flex";
+        readonly flexDirection: "column";
+        readonly width: "260px";
+        readonly minWidth: "200px";
+        readonly backgroundColor: "var(--component-explorer-sideBar-background)";
+        readonly borderRight: "1px solid var(--component-explorer-titleBar-border, var(--component-explorer-panel-border))";
+    };
+    readonly sidebarRight: {
+        readonly borderRight: "none";
+        readonly borderLeft: "1px solid var(--component-explorer-titleBar-border, var(--component-explorer-panel-border))";
+    };
+    readonly sidebarHeader: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly height: "35px";
+        readonly minHeight: "35px";
+        readonly padding: "0 12px";
+        readonly fontSize: "11px";
+        readonly fontWeight: 700;
+        readonly textTransform: "uppercase";
+        readonly letterSpacing: "0.04em";
+        readonly color: "var(--component-explorer-titleBar-activeForeground)";
+        readonly backgroundColor: "var(--component-explorer-titleBar-activeBackground)";
+        readonly borderBottom: "1px solid var(--component-explorer-titleBar-border, var(--component-explorer-panel-border))";
+    };
+    readonly sidebarContent: {
+        readonly flex: 1;
+        readonly overflow: "auto";
+        readonly padding: "4px 0";
+    };
+    readonly treeItem: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly height: "22px";
+        readonly paddingRight: "8px";
+        readonly cursor: "pointer";
+        readonly userSelect: "none";
+    };
+    readonly treeItemSelected: {
+        readonly backgroundColor: "var(--component-explorer-list-activeSelectionBackground)";
+        readonly color: "var(--component-explorer-list-activeSelectionForeground)";
+    };
+    readonly treeItemHover: {
+        readonly backgroundColor: "var(--component-explorer-list-hoverBackground)";
+    };
+    readonly treeItemChevron: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly justifyContent: "center";
+        readonly width: "16px";
+        readonly height: "16px";
+        readonly color: "var(--component-explorer-foreground)";
+        readonly opacity: 0.8;
+        readonly cursor: "pointer";
+    };
+    readonly treeItemChevronPlaceholder: {
+        readonly width: "16px";
+    };
+    readonly treeItemIcon: {
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly justifyContent: "center";
+        readonly width: "16px";
+        readonly height: "16px";
+        readonly marginRight: "4px";
+    };
+    readonly treeItemLabel: {
+        readonly flex: 1;
+        readonly overflow: "hidden";
+        readonly textOverflow: "ellipsis";
+        readonly whiteSpace: "nowrap";
+        readonly fontSize: "13px";
+    };
+    readonly treeItemCount: {
+        readonly marginLeft: "8px";
+        readonly fontSize: "11px";
+        readonly color: "var(--component-explorer-descriptionForeground)";
+    };
+    readonly mainContent: {
+        readonly flex: 1;
+        readonly display: "flex";
+        readonly alignItems: "center";
+        readonly justifyContent: "center";
+        readonly backgroundColor: "var(--component-explorer-editor-background)";
+        readonly color: "var(--component-explorer-descriptionForeground)";
+        readonly fontSize: "14px";
+    };
+    readonly propertiesPanel: {
+        readonly padding: "12px";
+    };
+    readonly propertyRow: {
+        readonly marginBottom: "12px";
+    };
+    readonly propertyLabel: {
+        readonly fontSize: "12px";
+        readonly color: "var(--component-explorer-foreground)";
+        readonly marginBottom: "4px";
+    };
+    readonly propertyDescription: {
+        readonly fontSize: "11px";
+        readonly color: "var(--component-explorer-descriptionForeground)";
+        readonly marginTop: "2px";
+    };
+    readonly propertyInput: {
+        readonly width: "100%";
+        readonly height: "26px";
+        readonly padding: "0 8px";
+        readonly fontSize: "13px";
+        readonly color: "var(--component-explorer-input-foreground)";
+        readonly backgroundColor: "var(--component-explorer-input-background)";
+        readonly border: "1px solid var(--component-explorer-input-border, transparent)";
+        readonly borderRadius: "2px";
+        readonly outline: "none";
+        readonly boxSizing: "border-box";
+    };
+    readonly propertySelect: {
+        readonly width: "100%";
+        readonly height: "26px";
+        readonly padding: "0 8px";
+        readonly fontSize: "13px";
+        readonly color: "var(--component-explorer-dropdown-foreground)";
+        readonly backgroundColor: "var(--component-explorer-dropdown-background)";
+        readonly border: "1px solid var(--component-explorer-dropdown-border)";
+        readonly borderRadius: "2px";
+        readonly outline: "none";
+        readonly boxSizing: "border-box";
+        readonly cursor: "pointer";
+    };
+};
+declare function mergeStyles(...styleObjects: (React.CSSProperties | undefined | false)[]): React.CSSProperties;
+
+interface ExplorerAppOptions {
+    readonly storageScope?: string;
     readonly loadFixtures: (filter?: {
         file: string;
     }) => Promise<FixtureModules>;
     readonly daemonConfig?: DaemonConfig;
 }
-export declare class ExplorerApp implements ExplorerRuntime {
+declare class ExplorerApp implements ExplorerRuntime {
     private readonly _runtime;
     constructor(element: HTMLElement, options: ExplorerAppOptions);
     updateFixtures(fixtureModules: FixtureModules): void;
     bumpVersion(): void;
 }
-//# sourceMappingURL=viewer.d.ts.map
+
+export { ChevronDownIcon, ChevronRightIcon, ComponentIcon, DaemonModel, DebugPanelDefinition, DebugPanelViewState, DebugPanelViewStateOptions, DisplayMode, Explorer, ExplorerApp, ExplorerModel, FixtureExport, FixtureGroupExport, FixtureInputControlOptions, FixtureInputStore, FixturePath, FixtureRegistry, FixtureVariantsExport, FolderIcon, IDisposable$2 as IDisposable, IJsonSchema, LeftSidebar, MoonIcon, PageMode, PanelLeftIcon, PanelRightIcon, RenderContext, RenderHost, RenderResult, RenderReturn, ReportModel, RevealInTreeIcon, RightSidebar, SingleFixtureExport, StarIcon, StyleDefinition, SunIcon, TitleBar, TitleBarButton, TreeItem, TreeView, VIEWPORT_SIZES, aggregateInputProperties, applyInputDefaults, collectComponents, createComponentDefinition, createFixtureTree, effectiveInputValue, findNodeByPath, isComponentDefinition, isFixtureGroup, isFixtureVariants, isSingleFixture, mergeInputSchemas, mergeStyles, parseFixtureExport, parseFixtureGroup, parseFixtureVariants, parseSingleFixture, resolveViewport, styles, toExplorerTree };
+export type { AggregatedInputProperty, ComponentDefinition, ComponentInputInfo, DaemonCompareResult, DaemonFixtureInfo, DaemonScreenshotResult, ExceptionError, ExplorerAppOptions, ExplorerMode, ExplorerQueryParams, ExplorerRuntime, ExplorerTreeNode, FixtureInputOverride, FixtureModules, FixtureNode, FixtureStatus, ParseResult, RenderEvent, RenderEventType, RenderReport, ReportFixtureEntry, ReportSummary, ScreenshotReport };