dshb-exec-ssh 0.0.1

package/lib/index-CDfaZYyK.d.ts

@@ -0,0 +1,1125 @@
+//#region ../../node_modules/@deepseek-ai/cosmokit/lib/types/misc.d.ts
+/** String/symbol keyed dictionary type. */
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
+/** Wrap a value in `Promise`, preserving the resolved type of existing promises. */
+type Promisify<T> = Promise<T extends Promise<infer S> ? S : T>;
+/** Accept a value or promise unless the value type is already promise-like. */
+type Awaitable<T> = [T] extends [Promise<unknown>] ? T : T | Promise<T>;
+//#endregion
+//#region ../../node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/utils.d.ts
+/** Ordered collection of disposable values with O(1) deletion by value. */
+declare class DisposableList<T extends WeakKey> {
+  private sn;
+  private map;
+  private weak;
+  get length(): number;
+  push(value: T): () => boolean;
+  delete(value: T): boolean;
+  clear(): T[];
+  [Symbol.iterator](): MapIterator<T>;
+}
+/** Shared symbols used to avoid public property-name collisions. */
+declare const symbols: {
+  shadow: symbol;
+  receiver: symbol;
+  original: symbol;
+  metadata: symbol;
+  initHooks: symbol;
+  checkProto: symbol;
+  effect: typeof Context.effect;
+  filter: typeof Context.filter;
+  isolate: typeof Context.isolate;
+  intercept: typeof Context.intercept;
+  init: typeof Service.init;
+  check: typeof Service.check;
+  config: typeof Service.config;
+  invoke: typeof Service.invoke;
+  extend: typeof Service.extend;
+  tracker: typeof Service.tracker;
+  resolveConfig: typeof Service.resolveConfig;
+};
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/registry.d.ts
+/**
+ * Service dependency declaration accepted by plugins and the `@Inject`
+ * decorator.
+ *
+ * Array form requests services without intercept config. Object form maps each
+ * service name to optional intercept config for the plugin context.
+ */
+type Inject<M = Dict> = (keyof M)[] | { [K in keyof M]?: M[K]; };
+/** Context keys that correspond to services with typed intercept config. */
+type InjectKey = keyof { [K in keyof Context & string as Context[K] extends {
+  [symbols.config]: any;
+} ? K : never]: any; };
+/**
+ * Decorator for declaring service dependencies on classes or class methods.
+ *
+ * On classes it contributes to the plugin's static `inject` map. On methods it
+ * delays the method call until the declared services are available.
+ */
+/**
+ * @param name — the required service name.
+ * @param config — optional intercept config applied for that service.
+ * @returns the class or method decorator.
+ */
+declare function Inject<K extends InjectKey>(name: K, config?: Context[K] extends {
+  [symbols.config]: infer T;
+} ? T : never): (value: any, decorator: ClassDecoratorContext<any> | ClassMethodDecoratorContext<any>) => void;
+/** Utilities for normalizing plugin dependency declarations. */
+declare namespace Inject {
+  /**
+   * Convert array/object/class-inherited inject metadata into a plain map.
+   *
+   * @param inject — the declaration to normalize; `null`/`undefined` add nothing.
+   * @param result — the map to fill (service name → intercept config or `null`).
+   * @returns `result`.
+   */
+  function resolve(inject: Inject | null | undefined, result?: Dict): Dict;
+}
+/** Supported plugin entrypoint shapes. */
+type Plugin<T = any> = Plugin.Function<T> | Plugin.Constructor<T> | Plugin.Object<T>;
+/** Types associated with plugin entrypoints and runtime records. */
+declare namespace Plugin {
+  /** Shared metadata understood by the plugin registry and related tooling. */
+  interface Base<T = any> {
+    /** Display name used for fiber diagnostics and logger names. */
+    name?: string;
+    /** Standard-schema validator applied to config before the plugin starts. */
+    Config?: StandardSchemaV1<any, T>;
+    /** Services the plugin requires; it only loads while all are available. */
+    inject?: Inject;
+    /** Service name(s) the plugin provides (read by `Service` and by loaders). */
+    provide?: string | string[];
+    /** Service names whose intercept config the plugin declares it consumes. */
+    intercept?: Dict<boolean>;
+  }
+  interface Transform<S, T> {
+    /** Marks the transform object as a schema/config transform. */
+    schema?: true;
+    /** Convert user-facing config to runtime config. */
+    Config: (config: S) => T;
+  }
+  /** Function plugin called with `(ctx, config)`. */
+  interface Function<T = any> extends Base<T> {
+    (ctx: Context, config: T): any;
+  }
+  /** Class plugin constructed with `(ctx, config)`. */
+  interface Constructor<T = any> extends Base<T> {
+    new (ctx: Context, config: T): any;
+  }
+  /** Object plugin with an `apply(ctx, config)` method. */
+  interface Object<T = any> extends Base<T> {
+    apply(ctx: Context, config: T): any;
+  }
+  /** Mutable registry record shared by all fibers of one plugin callback. */
+  interface Runtime {
+    /** Display name copied from the first registered plugin shape. */
+    name?: string;
+    /** Every live fiber of this plugin (one per `ctx.plugin()` call). */
+    fibers: DisposableList<Fiber>;
+    /** The executable entrypoint all fibers share (registry identity key). */
+    callback: globalThis.Function;
+    /** Standard-schema validator applied to each fiber's config. */
+    Config?: StandardSchemaV1;
+  }
+}
+type Spread<T> = undefined extends T ? [config?: T] : [config: T];
+type GetPluginParameters<P> = P extends ((ctx: Context, ...args: infer R) => any) ? R : P extends (new (ctx: Context, ...args: infer R) => any) ? R : P extends {
+  apply(ctx: Context, ...args: infer R): any;
+} ? R : never;
+type GetPluginConfig<P> = P extends Plugin.Transform<infer S, any> ? S : GetPluginParameters<P>[0];
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Run a callback once the requested services are available.
+     *
+     * Shorthand for `ctx.plugin({ inject, apply: callback })`: the callback
+     * is unloaded and re-run whenever a required service changes.
+     *
+     * @param deps — required services, as an array or a name → config map.
+     * @param callback — plugin body called with `(ctx, config)`.
+     * @returns the fiber; awaiting it settles once loading finished.
+     */
+    inject(deps: Inject, callback: Plugin.Function<void>): Fiber & PromiseLike<Fiber>;
+    /**
+     * Load a plugin in the current context.
+     *
+     * @param plugin — a function, class, or `{ apply }` object plugin.
+     * @param args — the plugin config, validated against its `Config` schema.
+     * @returns the fiber; awaiting it settles once loading finished
+     * (rejecting on config or startup errors).
+     */
+    plugin<P extends Plugin>(plugin: P, ...args: Spread<GetPluginConfig<P>>): Fiber & PromiseLike<Fiber>;
+  }
+}
+/**
+ * Plugin registry installed as `ctx.registry` and mixed into every context.
+ *
+ * It normalizes plugin shapes, tracks plugin runtimes, starts fibers, and
+ * exposes map-like inspection over active plugin callbacks.
+ */
+declare class RegistryService {
+  ctx: Context;
+  private _counter;
+  private _internal;
+  constructor(ctx: Context);
+  /** Allocate the next fiber uid (increments on every read). */
+  get counter(): number;
+  /** Number of registered plugin runtimes. */
+  get size(): number;
+  /**
+   * Resolve a supported plugin shape to its executable callback.
+   *
+   * @param plugin — a function, class, or `{ apply }` object plugin.
+   * @returns the callback identifying the plugin, or `undefined` if invalid.
+   */
+  resolve(plugin: Plugin): Function | undefined;
+  /**
+   * Look up the runtime record for a plugin.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns the runtime, or `undefined` when the plugin is not registered.
+   */
+  get(plugin: Plugin): Plugin.Runtime | undefined;
+  /**
+   * Check whether a plugin has a registered runtime.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns `true` when at least one fiber of the plugin exists.
+   */
+  has(plugin: Plugin): boolean;
+  /**
+   * Dispose every running fiber for a plugin and remove its runtime record.
+   *
+   * @param plugin — any supported plugin shape.
+   * @returns the removed runtime, or `undefined` when none was registered.
+   */
+  delete(plugin: Plugin): Plugin.Runtime | undefined;
+  /** Iterate the registered plugin callbacks. */
+  keys(): MapIterator<Function>;
+  /** Iterate the registered plugin runtimes. */
+  values(): MapIterator<Plugin.Runtime>;
+  /** Iterate `[callback, runtime]` pairs. */
+  entries(): MapIterator<[Function, Plugin.Runtime]>;
+  /**
+   * Visit every registered runtime.
+   *
+   * @param callback — receives each runtime and its identifying callback.
+   */
+  forEach(callback: (value: Plugin.Runtime, key: Function) => void): void;
+  /**
+   * Start a callback once the requested dependencies are available.
+   *
+   * @param inject — required services, as an array or a name → config map.
+   * @param callback — plugin body called with `(ctx, config)`.
+   * @returns the fiber; awaiting it settles once loading finished.
+   */
+  inject(inject: Inject, callback: Plugin.Function<void>): Fiber & PromiseLike<Fiber>;
+  /**
+   * Start a plugin in the current context and return its fiber.
+   *
+   * Creates (or reuses) the plugin's runtime record, then starts a new fiber
+   * under the current context. Throws if `plugin` is not a supported shape or
+   * if the current fiber is already disposed.
+   *
+   * @param plugin — a function, class, or `{ apply }` object plugin.
+   * @param config — the plugin config, validated against its `Config` schema.
+   * @param getOuterStack — captures the caller stack for effect diagnostics.
+   * @returns the fiber; awaiting it settles once loading finished.
+   */
+  plugin(plugin: Plugin, config?: any, getOuterStack?: () => string[]): Fiber & PromiseLike<Fiber>;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/reflect.d.ts
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Read a service from the store without the inject requirement.
+     *
+     * @param name — the service name.
+     * @param strict — when `true` (default), only return implementations
+     * whose providing fiber is currently active.
+     * @returns the service value, or `undefined` when not (yet) provided.
+     */
+    get<K extends string & keyof this>(name: K, strict?: boolean): undefined | this[K];
+    /** Same as above for service names outside the typed `Context` surface. */
+    get(name: string, strict?: boolean): any;
+    /**
+     * Overwrite a provided service's value.
+     *
+     * Only the fiber that provided the service may set it; setting an
+     * unprovided name throws.
+     *
+     * @param name — the service name.
+     * @param value — the new service value.
+     */
+    set<K extends string & keyof this>(name: K, value: undefined | this[K]): void;
+    /** Same as above for service names outside the typed `Context` surface. */
+    set(name: string, value: any): void;
+    /**
+     * Register a service implementation owned by the current fiber.
+     *
+     * The service becomes visible to dependents in the same isolation scope
+     * once the fiber is active; it is unregistered (waking dependents) when
+     * the returned disposer runs or the fiber unloads. Throws if the name is
+     * already provided in this scope or declared as an accessor.
+     *
+     * @param name — the service name.
+     * @param value — the service value.
+     * @returns a disposer that unregisters the service.
+     */
+    provide<K extends string & keyof this>(name: K, value: undefined | this[K]): () => void;
+    /** Same as above for service names outside the typed `Context` surface. */
+    provide(name: string, value?: any): () => void;
+    /**
+     * Define a computed context property backed by get/set hooks.
+     *
+     * The accessor is removed when the current fiber unloads. Throws if the
+     * name is already declared.
+     *
+     * @param name — the context property name.
+     * @param options — the `get` hook and optional `set` hook.
+     */
+    accessor(name: string, options: Omit<Property.Accessor, 'type'>): void;
+    /**
+     * Expose selected members of a service directly on `ctx`.
+     *
+     * Each mixed-in key becomes an accessor that forwards to the service
+     * (binding methods to it), so e.g. `ctx.on` forwards to `ctx.events.on`.
+     * Mixins are removed when the current fiber unloads.
+     *
+     * @param name — the context property holding the source service.
+     * @param mixins — keys to forward, or a source-key → ctx-key map.
+     */
+    mixin<K extends string & keyof this>(name: K, mixins: (keyof this & keyof this[K])[] | Dict<string>): void;
+    /** Same as above with a source object instead of a context property name. */
+    mixin<T extends {}>(source: T, mixins: (keyof this & keyof T)[] | Dict<string>): void;
+  }
+}
+/** Context property definition known by the reflection service. */
+type Property = Property.Service | Property.Accessor;
+/** Property definition variants understood by `ReflectService`. */
+declare namespace Property {
+  /** Service property backed by a provided implementation. */
+  interface Service {
+    /** Discriminator. */
+    type: 'service';
+  }
+  /** Computed context property backed by custom get/set hooks. */
+  interface Accessor {
+    /** Discriminator. */
+    type: 'accessor';
+    /** Compute the property value; `error` carries the caller stack for diagnostics. */
+    get: (this: Context, receiver: any, error: Error) => any;
+    /** Optional setter; return `false` to reject the write. */
+    set?: (this: Context, value: any, receiver: any, error: Error) => boolean;
+  }
+}
+/** Concrete service implementation record stored in the root reflect service. */
+interface Impl {
+  /** The service name. */
+  name: string;
+  /** The fiber that provided the service (owns its lifetime). */
+  fiber: Fiber;
+  /** The current service value. */
+  value?: any;
+  /** Optional availability predicate consulted before dependents may load. */
+  check?: () => boolean;
+}
+/**
+ * Reflection and service-resolution layer installed as `ctx.reflect`.
+ *
+ * This service powers the context proxy, service registration, accessors, and
+ * the mixins that expose core service methods directly on `ctx`.
+ */
+declare class ReflectService {
+  ctx: Context;
+  /** Proxy traps implementing service resolution for every context object. */
+  static handler: ProxyHandler<Context>;
+  /** Service implementations, keyed by isolation label. */
+  store: Dict<Impl, symbol>;
+  /** Declared context properties (services and accessors), by name. */
+  props: Dict<Property>;
+  constructor(ctx: Context);
+  /**
+   * Read a service from the store without the inject requirement.
+   *
+   * @param name — the service name.
+   * @param strict — when `true`, only return implementations whose providing
+   * fiber is currently active.
+   * @returns the service value, or `undefined` when not (yet) provided.
+   */
+  get(name: string, strict?: boolean): any;
+  _getImpl(name: string, strict?: boolean): Impl | undefined;
+  /**
+   * Overwrite a provided service's value.
+   *
+   * @param name — the service name.
+   * @param value — the new service value.
+   * @param error — carrier for the caller stack in diagnostics.
+   * @returns `true` on success.
+   * @throws when `name` was never provided, or was provided by another fiber.
+   */
+  set(name: string, value: any, error?: Error): boolean;
+  /**
+   * Register a service implementation owned by the current fiber.
+   *
+   * See the `ctx.provide()` overload above for the full contract.
+   *
+   * @param name — the service name.
+   * @param value — the service value.
+   * @param check — optional availability predicate for dependents.
+   * @returns a disposer that unregisters the service.
+   */
+  provide(name: string, value?: any, check?: () => boolean): Disposable<Promise<void>>;
+  /**
+   * Re-evaluate every fiber that requires one of the given services.
+   *
+   * @param names — the service names that changed.
+   * @param filter — restricts notification to matching isolation scopes.
+   * @returns the fibers whose dependency state was refreshed.
+   */
+  notify(names: string[], filter?: (ctx: Context, name: string) => boolean): Fiber[];
+  /**
+   * Define a computed context property backed by get/set hooks.
+   *
+   * @param name — the context property name.
+   * @param options — the `get` hook and optional `set` hook.
+   * @returns a disposer that removes the accessor.
+   */
+  accessor(name: string, options: Omit<Property.Accessor, 'type'>): Disposable<Promise<void>>;
+  /**
+   * Expose selected members of a service directly on `ctx`.
+   *
+   * See the `ctx.mixin()` overload above for the full contract.
+   *
+   * @param source — a context property name or a source object.
+   * @param mixins — keys to forward, or a source-key → ctx-key map.
+   * @returns a disposer that removes all created accessors.
+   */
+  mixin(source: any, mixins: string[] | Dict<string>): Disposable<Promise<void>>;
+  /**
+   * Attach this context's tracing wrapper to a value.
+   *
+   * @param value — the value to wrap.
+   * @returns the traceable wrapper (or the value itself when not applicable).
+   */
+  trace<T>(value: T): T;
+  /**
+   * Wrap a callback so calls trace `this` and arguments to this context.
+   *
+   * @param callback — the function to wrap.
+   * @returns a proxy delegating to `callback` with traced values.
+   */
+  bind<T extends Function>(callback: T): T;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/fiber.d.ts
+declare module './context.ts' {
+  interface Context extends Pick<Fiber, 'effect'> {
+    /** The fiber (plugin runtime instance) that owns this context. */
+    fiber: Fiber;
+  }
+}
+interface AsyncDisposable<T extends Awaitable<void> = Awaitable<void>> extends PromiseLike<() => T> {
+  (): T;
+}
+/**
+ * Function returned by an effect to release resources during disposal.
+ *
+ * Disposers run in reverse registration order when the owning fiber unloads;
+ * they may be async, in which case unloading awaits them.
+ */
+type Disposable<T = any> = () => T;
+/**
+ * Effect body result accepted by `ctx.effect()` and plugin startup.
+ *
+ * Either a single disposer, a promise of one, or a (possibly async) iterable
+ * yielding several — generator effects register each yielded disposer as it
+ * is produced.
+ */
+type Effect<T = any> = SyncEffect<T> | AsyncEffect<T>;
+type SyncEffect<T = any> = Disposable<T> | Iterable<Disposable<T>, void, void>;
+type AsyncEffect<T = any> = Promise<Disposable<T>> | AsyncIterable<Disposable<T>, void, void>;
+/** Tree node used to expose nested effect labels for diagnostics. */
+interface EffectMeta {
+  /** Human-readable effect label, e.g. `ctx.on("event")` or `ctx.provide("name")`. */
+  label: string;
+  /** Metadata of nested effects registered while this effect ran. */
+  children: EffectMeta[];
+}
+/**
+ * Lifecycle state for one plugin fiber.
+ *
+ * `PENDING` — waiting for required services; `LOADING` — the plugin callback
+ * is running; `ACTIVE` — loaded and providing; `FAILED` — the callback or its
+ * config threw; `UNLOADING` — disposers are running; `DISPOSED` — the fiber
+ * was removed and cannot restart.
+ */
+declare const enum FiberState {
+  PENDING = 0,
+  LOADING = 1,
+  ACTIVE = 2,
+  FAILED = 3,
+  DISPOSED = 4,
+  UNLOADING = 5
+}
+/**
+ * Runtime instance of one plugin application.
+ *
+ * A fiber tracks dependency state, validated config, lifecycle effects, and
+ * cleanup for the plugin context returned by `ctx.plugin()`.
+ */
+declare class Fiber {
+  parent: Context;
+  inject: Dict<any>;
+  runtime: Plugin.Runtime | null;
+  /** Unique id within the registry; 0 for the root fiber, `null` once disposed. */
+  uid: number | null;
+  /** The context this fiber's plugin runs in (extends the parent context). */
+  readonly ctx: Context;
+  /** The validated plugin config (updated by `update()`). */
+  config: any;
+  /** The raw plugin config, re-resolved before each activation. */
+  _config: any;
+  /** Current lifecycle state; transitions emit `internal/status`. */
+  state: FiberState;
+  /** Dispose this fiber: unload the plugin, then settle once cleanup finished. */
+  readonly dispose: () => Promise<void>;
+  /** Snapshot of required service implementations while loaded; `undefined` otherwise. */
+  store: Dict<Impl> | undefined;
+  /** The in-flight load/unload transition, if one is currently running. */
+  inertia: Promise<void> | undefined;
+  readonly _hooks: Dict<DisposableList<Function>>;
+  readonly _disposables: DisposableList<Disposable<any>>;
+  protected context: Context;
+  private _error;
+  private _runner;
+  private _store;
+  /**
+   * Create a fiber. Plugin authors normally obtain fibers from `ctx.plugin()`
+   * rather than constructing them directly.
+   *
+   * @param parent — the context the plugin was loaded from.
+   * @param config — raw config, validated against the runtime's schema.
+   * @param inject — resolved dependency map (service name → intercept config).
+   * @param runtime — the shared plugin runtime, or `null` for the root fiber.
+   * @param getOuterStack — captures the caller stack for effect diagnostics.
+   */
+  constructor(parent: Context, config: any, inject: Dict<any>, runtime: Plugin.Runtime | null, getOuterStack: () => string[]);
+  /** The plugin's display name, inherited from the nearest named ancestor, else `'root'`. */
+  get name(): string;
+  /**
+   * Throw if the fiber has already been disposed.
+   *
+   * @returns nothing when the fiber is still active.
+   * @throws {CordisError} `INACTIVE_EFFECT` when the fiber's uid has been cleared.
+   */
+  assertActive(): void;
+  private _execute;
+  /**
+   * Register a cleanup-aware effect on this fiber.
+   *
+   * `execute` runs immediately; the disposers it produces are collected and
+   * run (in reverse order) either when the returned disposer is called or
+   * when the fiber unloads, whichever comes first. Calling the disposer twice
+   * is a no-op. Throws `CordisError('INACTIVE_EFFECT')` if the fiber is
+   * already disposed, and `TypeError` if `execute` returns an invalid shape.
+   *
+   * @param execute — the effect body; see {@link Effect} for accepted shapes.
+   * @param label — effect label shown in `getEffects()` diagnostics.
+   * @returns a disposer that tears the effect down and settles once done.
+   */
+  effect(execute: () => SyncEffect, label?: string): Disposable<Promise<void>>;
+  /** Same as above for async effects; the disposer is also awaitable. */
+  effect(execute: () => Effect, label?: string): AsyncDisposable<Promise<void>>;
+  /**
+   * Return metadata for currently registered effects.
+   *
+   * @returns one {@link EffectMeta} tree per labeled live effect.
+   */
+  getEffects(): EffectMeta[];
+  private _getState;
+  private _updateState;
+  _checkImpl(name: string): boolean | undefined;
+  _refresh(): void;
+  private _setEpoch;
+  private _resolveConfig;
+  private _reload;
+  private _unload;
+  /**
+   * Wait for current lifecycle work and rethrow startup errors.
+   *
+   * @returns this fiber, once it has settled into a stable state.
+   * @throws the config-validation or plugin-startup error, if any.
+   */
+  await(): Promise<this>;
+  /**
+   * Dispose and immediately reload this plugin with its current config.
+   *
+   * @returns a promise resolving once the reload settled.
+   * @throws {CordisError} `INACTIVE_EFFECT` when the fiber is already disposed.
+   */
+  restart(): Promise<void>;
+  /**
+   * Validate and apply new config, then restart the plugin.
+   *
+   * Runs the `internal/update` waterfall first, so update hooks (and HMR)
+   * can veto or replace the restart.
+   *
+   * @param config — the new raw config; validated before anything restarts.
+   * @param noSave — hint for persistence hooks not to write the change back.
+   * @returns the update waterfall result; the default restart returns a promise.
+   * @throws when validation, an update listener, or the restarted plugin fails.
+   */
+  update(config: any, noSave?: boolean): void | Promise<void>;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/events.d.ts
+/** Extract the parameter tuple from a function type. */
+type Parameters<F> = F extends ((...args: infer P) => any) ? P : never;
+/** Extract the return type from a function type. */
+type ReturnType<F> = F extends ((...args: any) => infer R) ? R : never;
+/** Extract the explicit `this` type from a function type. */
+type ThisType<F> = F extends ((this: infer T, ...args: any) => any) ? T : never;
+/**
+ * Event dispatch strategy used by the event service.
+ *
+ * `emit` runs synchronous listeners without awaiting them, `parallel` awaits
+ * all listeners together, `serial` awaits them in order until one bails,
+ * `bail` stops on the first synchronous bail value, and `waterfall` composes
+ * listeners around a final `next` callback.
+ */
+type DispatchMode = 'emit' | 'parallel' | 'serial' | 'bail' | 'waterfall';
+declare module './context.ts' {
+  interface Context {
+    /**
+     * Dispatch an event, running all listeners concurrently.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to every listener.
+     * @returns a promise resolving once every listener has settled.
+     */
+    parallel<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promise<void>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    parallel<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promise<void>;
+    /**
+     * Dispatch an event synchronously, ignoring listener return values.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to every listener.
+     */
+    emit<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): void;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    emit<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): void;
+    /**
+     * Dispatch an event, awaiting listeners in order until one bails.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to each listener.
+     * @returns the first bail value (non-null, non-false, non-undefined), if any.
+     */
+    serial<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType<Events[K]>>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    serial<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): Promisify<ReturnType<Events[K]>>;
+    /**
+     * Dispatch an event, calling listeners in order until one bails.
+     *
+     * @param name — the event name.
+     * @param args — arguments passed to each listener.
+     * @returns the first bail value (non-null, non-false, non-undefined), if any.
+     */
+    bail<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    bail<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+    /**
+     * Dispatch an event whose last argument is a `next` continuation.
+     *
+     * Each listener wraps the rest of the chain: calling `next()` invokes the
+     * next listener (finally the built-in behavior); not calling it vetoes.
+     *
+     * @param name — the event name.
+     * @param args — listener arguments; the final one is the innermost `next`.
+     * @returns the outermost listener's return value.
+     */
+    waterfall<K extends keyof Events>(name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+    /** Same as above, with an explicit `this` for listeners (also used for filtering). */
+    waterfall<K extends keyof Events>(thisArg: NoInfer<ThisType<Events[K]>>, name: K, ...args: Parameters<Events[K]>): ReturnType<Events[K]>;
+    /**
+     * Register an event listener owned by the current fiber.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    on<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+    /**
+     * Same as `on()`, but the listener disposes itself after its first call.
+     *
+     * @param name — the event name to listen for.
+     * @param listener — called at most once with the dispatch arguments.
+     * @param options — listener options; a boolean is shorthand for `prepend`.
+     * @returns a disposer removing the listener; `true` if it was still registered.
+     */
+    once<K extends keyof Events>(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean;
+  }
+}
+/** Options accepted by `ctx.on()` and `ctx.once()`. */
+interface EventOptions {
+  /** Add the listener before existing listeners for the same event. */
+  prepend?: boolean;
+  /** Receive the event regardless of context filter checks. */
+  global?: boolean;
+}
+/** Registered listener record stored by the event service. */
+interface Hook extends EventOptions {
+  ctx: Context;
+  callback: (...args: any[]) => any;
+}
+/**
+ * Event bus installed as `ctx.events` and mixed into every context.
+ *
+ * The service supports concurrent, synchronous, serial, bail, and waterfall
+ * dispatch and automatically disposes listeners with their owning fiber.
+ */
+declare class EventsService {
+  private ctx;
+  _hooks: Record<keyof any, Hook[]>;
+  constructor(ctx: Context);
+  /**
+   * Resolve listeners for one dispatch and apply context filtering.
+   *
+   * @param type — the dispatch mode, reported on `internal/dispatch`.
+   * @param args — the raw dispatch arguments; consumed up to the event name.
+   * @returns the matching listener callbacks, bound to the dispatch `this`.
+   */
+  dispatch(type: string, args: any[]): ((...args: any[]) => any)[];
+  /**
+   * Run listeners concurrently and wait for all of them.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns a promise resolving once every listener has settled.
+   */
+  parallel(...args: any[]): Promise<void>;
+  /**
+   * Run listeners synchronously without waiting for returned promises.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   */
+  emit(...args: any[]): void;
+  /**
+   * Run listeners in order, awaiting each, until one returns a bail value.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns the first bail value (see {@link isBailed}), if any.
+   */
+  serial(...args: any[]): Promise<any>;
+  /**
+   * Run listeners synchronously until one returns a bail value.
+   *
+   * @param args — optional `this`, the event name, then listener arguments.
+   * @returns the first bail value (see {@link isBailed}), if any.
+   */
+  bail(...args: any[]): any;
+  /**
+   * Compose listeners around the final `next` callback.
+   *
+   * The last dispatch argument is treated as the innermost `next`. Listeners
+   * run outermost-first; a listener that does not call `next()` vetoes the
+   * rest of the chain, including the built-in behavior.
+   *
+   * @param args — optional `this`, the event name, listener arguments, then `next`.
+   * @returns the outermost listener's return value.
+   */
+  waterfall(...args: any[]): any;
+  /**
+   * Store a listener record as an effect on the current fiber.
+   *
+   * @param label — effect label shown in fiber diagnostics.
+   * @param hooks — the listener list for one event.
+   * @param callback — the listener to store.
+   * @param options — placement and filtering options.
+   * @returns a disposer that unregisters the listener.
+   */
+  register(label: string, hooks: Hook[], callback: any, options: EventOptions): () => void;
+  /**
+   * Remove a stored listener record.
+   *
+   * @param hooks — the listener list for one event.
+   * @param callback — the listener to remove.
+   * @returns `true` if the listener was found and removed.
+   */
+  unregister(hooks: Hook[], callback: any): true | undefined;
+  /**
+   * Register an event listener owned by the current fiber.
+   *
+   * The listener is removed automatically when the fiber unloads. Throws
+   * `CordisError('INACTIVE_EFFECT')` if the fiber is already disposed.
+   *
+   * @param name — the event name to listen for.
+   * @param listener — called with the dispatch arguments.
+   * @param options — listener options; a boolean is shorthand for `prepend`.
+   * @returns a disposer removing the listener; `true` if it was still registered.
+   */
+  on(name: string | symbol, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+  /**
+   * Register an event listener that disposes itself after the first call.
+   *
+   * @param name — the event name to listen for.
+   * @param listener — called at most once with the dispatch arguments.
+   * @param options — listener options; a boolean is shorthand for `prepend`.
+   * @returns a disposer removing the listener; `true` if it was still registered.
+   */
+  once(name: string, listener: (...args: any) => any, options?: boolean | EventOptions): any;
+}
+/**
+ * Built-in framework events used by core services and extension points.
+ *
+ * Plugin and status events track fiber lifecycle, service events observe
+ * dependency registration, update/get/set/listener events allow core services
+ * to intercept runtime operations, and `internal/dispatch` exposes event-bus
+ * diagnostics before public events are delivered.
+ */
+interface Events {
+  /** A plugin fiber was created or its uid was cleared on disposal. */
+  'internal/plugin'(fiber: Fiber): void;
+  /** A fiber changed lifecycle state; receives the fiber and its previous state. */
+  'internal/status'(fiber: Fiber, oldValue: FiberState): void;
+  /**
+   * Resolve raw plugin config after the fiber's injections become active.
+   * @param config - the raw config for this activation.
+   * @mode waterfall
+   */
+  'internal/config'(this: Fiber, config: any, next: () => any): any;
+  /** Interception hook for a service binding (no core producer). */
+  'internal/service'(this: Context, name: string, value: any): void;
+  /** Waterfall: a fiber config update is being applied; skip `next()` to veto. */
+  'internal/update'(this: Fiber, config: any, noSave: boolean, next: () => void | Promise<void>): void | Promise<void>;
+  /** Waterfall: a service is being read through the context proxy. */
+  'internal/get'(ctx: Context, name: string, error: Error, next: () => any): any;
+  /** Waterfall: a service is being written through the context proxy. */
+  'internal/set'(ctx: Context, name: string, value: any, error: Error, next: () => boolean): boolean;
+  /** Bail: a listener is being registered; a non-null result replaces registration. */
+  'internal/listener'(this: Context, name: string, listener: any, prepend: boolean): void;
+  /** An event is being dispatched to listeners (fired for non-internal events only). */
+  'internal/dispatch'(mode: DispatchMode, name: string, args: any[], thisArg: any): void;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/logger.d.ts
+declare module './context.ts' {
+  interface Intercept {
+    logger: LoggerService.Intercept;
+  }
+}
+/** Logger method name and severity category. */
+type LoggerType = 'error' | 'info' | 'warn' | 'debug';
+/** Callable shape for one logger severity method. */
+type LoggerMethod = (format: any, ...param: any[]) => void;
+/** Formatter used to resolve a printf-style placeholder. */
+type Formatter = (value: any, exporter: Exporter, message: Message) => any;
+/** Structured log record delivered to exporters. */
+interface Message {
+  sn: number;
+  ts: number;
+  name: string;
+  type: LoggerType;
+  level: number;
+  args: any[];
+  fiber?: WeakRef<Fiber>;
+}
+/** Sink that receives structured log messages. */
+interface Exporter {
+  colors?: number | false;
+  maxLength?: number;
+  levels?: Record<string, number>;
+  formatters?: Record<string, Formatter>;
+  export(message: Message): void;
+}
+/** Options used when creating a named logger facade. */
+interface LoggerOptions {
+  /** The logger name shown with each message. */
+  name: string;
+  /** Message fields merged into every record from this logger. */
+  meta?: Partial<Message>;
+  /** Default maximum level exported when an exporter has no own threshold. */
+  level?: number;
+}
+/** Logger facade identity, inherited message metadata, and optional minimum level. */
+interface Logger extends LoggerOptions {}
+/** Logger facade severity methods. */
+interface Logger extends Record<LoggerType, LoggerMethod> {}
+/** Logger facade for one named subsystem. */
+declare class Logger {
+  private service;
+  static color(exporter: Exporter, code: number, value: any, decoration?: string): string;
+  static code(name: string, level?: false | number): number;
+  static format(exporter: Exporter, message: Message): string;
+  constructor(options: LoggerOptions, service: LoggerService);
+  private _method;
+}
+/** Logger service configuration merged from context intercepts. */
+declare namespace LoggerService {
+  interface Intercept {
+    name?: string;
+    level?: number;
+  }
+}
+/** Callable `ctx.logger` service shape. */
+interface LoggerService extends Record<LoggerType, LoggerMethod> {
+  (name?: string): Logger;
+}
+/**
+ * Built-in logging service.
+ *
+ * Call `ctx.logger()` to create a named logger, or call `ctx.logger.info()`
+ * directly to log with the current fiber-derived name.
+ */
+declare class LoggerService {
+  bufferSize: number;
+  buffer: Message[];
+  ctx: Context;
+  _snMessage: number;
+  _snExporter: number;
+  exporters: Map<number, Exporter>;
+  constructor(ctx: Context);
+  /**
+   * Register an exporter and dispose it with the current fiber.
+   *
+   * @param exporter — the sink that receives structured log messages.
+   * @returns a disposer that removes the exporter.
+   */
+  exporter(exporter: Exporter): Disposable<Promise<void>>;
+  private _resolveConfig;
+  [symbols.invoke](name?: string): Logger;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/context.d.ts
+/**
+ * Public shape of a Cordis context.
+ *
+ * The concrete `Context` class is proxied at runtime, so this interface is
+ * augmented by core services and plugins to describe the properties that may
+ * be read from `ctx`.
+ */
+interface Context {
+  /** Isolation map: service name → scope label. Lookups for a name resolve within its label. */
+  [symbols.isolate]: Dict<symbol>;
+  /** Intercept map: service name → config merged into that service's per-plugin config. */
+  [symbols.intercept]: Dict;
+  /** The root context of the application (every child context shares it). @experimental */
+  root: this;
+  /** Base URL used to resolve relative plugin/module specifiers, if the runtime sets one. */
+  baseUrl?: string;
+  /** The event bus. Its methods are also mixed onto `ctx` (`ctx.on`, `ctx.emit`, ...). */
+  events: EventsService;
+  /** The logging service. Call `ctx.logger(name)` for a named logger. */
+  logger: LoggerService;
+  /** The reflection layer backing the context proxy (`ctx.get`, `ctx.provide`, ...). */
+  reflect: ReflectService;
+  /** The plugin registry. Its methods are mixed onto `ctx` (`ctx.plugin`, `ctx.inject`). */
+  registry: RegistryService;
+}
+/**
+ * Root and child dependency containers for Cordis plugins.
+ *
+ * A context is a proxy: normal property reads go through the service resolver,
+ * while `extend()`, `isolate()`, and `intercept()` create scoped child
+ * contexts without mutating their parent.
+ */
+declare class Context {
+  /** Symbol key under which a disposer exposes its {@link EffectMeta} diagnostics tree. */
+  static readonly effect: unique symbol;
+  /** Symbol key for a context's listener filter, consulted on every event dispatch. */
+  static readonly filter: unique symbol;
+  /** Symbol key of the isolation map (see the `Context[symbols.isolate]` property). */
+  static readonly isolate: unique symbol;
+  /** Symbol key of the intercept map (see the `Context[symbols.intercept]` property). */
+  static readonly intercept: unique symbol;
+  /**
+   * Returns true for Cordis context proxies and context prototypes.
+   *
+   * Works across realms and across multiple copies of cordis, because the
+   * brand is keyed by a global symbol rather than by `instanceof`.
+   *
+   * @param value — the value to test.
+   * @returns `true` if `value` is a Cordis context, narrowing its type.
+   */
+  static is(value: any): value is Context;
+  /** Create the root context and install the built-in services. */
+  constructor();
+  /**
+   * Create a child context with extra metadata on top of the current scope.
+   *
+   * The child prototypally inherits every property of this context; own
+   * properties of `meta` shadow the inherited ones. The parent is not mutated.
+   *
+   * @param meta — own properties (including symbol keys) to define on the child.
+   * @returns a child context inheriting from this one.
+   */
+  extend(meta?: {}): this;
+  /**
+   * Create a child context with an independent service scope for `name`.
+   *
+   * Below the returned context, reads and writes of the service `name`
+   * resolve against the new label instead of the parent's, so a different
+   * implementation can be provided without affecting the parent scope.
+   * Passing the same `label` to two `isolate()` calls joins their scopes.
+   *
+   * @param name — the service name to isolate.
+   * @param label — scope label to join; defaults to a fresh unique symbol.
+   * @returns a child context whose `name` service resolves in the new scope.
+   */
+  isolate(name: string, label?: symbol): this;
+  /**
+   * Add service-specific intercept config for plugins started below this
+   * context.
+   *
+   * Plugins loaded under the returned context see `config` merged into the
+   * service's resolved config (ancestor entries first; see
+   * `Service[symbols.resolveConfig]`). The parent context is not affected.
+   *
+   * @param name — the service name whose config to intercept.
+   * @param config — the intercept config to merge for that service.
+   * @returns a child context carrying the additional intercept entry.
+   */
+  intercept<K extends InjectKey>(name: K, config: Context[K] extends {
+    [symbols.config]: infer T;
+  } ? T : never): this;
+  intercept(name: string, config: any): this;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cordis/lib/types/service.d.ts
+/**
+ * Base class for services that expose a named API on `ctx`.
+ *
+ * Subclasses call `super(ctx, name)` from their constructor. The service is
+ * registered immediately and is automatically removed with the owning fiber.
+ */
+declare abstract class Service<out T = never> {
+  protected ctx: Context;
+  /** Symbol key of an instance method run after construction (class plugins). */
+  static readonly init: unique symbol;
+  /** Symbol key of the availability predicate passed to `ctx.provide()`. */
+  static readonly check: unique symbol;
+  /** Symbol key of the phantom intercept-config type parameter. */
+  static readonly config: unique symbol;
+  /** Symbol key of the call body making a service callable (e.g. `ctx.logger()`). */
+  static readonly invoke: unique symbol;
+  /** Symbol key of the helper deriving an extended service instance. */
+  static readonly extend: unique symbol;
+  /** Symbol key of the tracker metadata used for context tracing. */
+  static readonly tracker: unique symbol;
+  /** Symbol key of the intercept-config resolution helper below. */
+  static readonly resolveConfig: unique symbol;
+  [symbols.config]: T;
+  /** The service name this instance is registered under. */
+  name: string;
+  /**
+   * Register this instance as `name` in the current context.
+   *
+   * Calls `ctx.reflect.provide(name, this, this[Service.check])`, so the
+   * service is unregistered automatically when the owning fiber unloads.
+   * Services with a `[Service.invoke]` body return a callable instance.
+   *
+   * @param ctx — the context to register in (stored as `this.ctx`).
+   * @param name — the service name; defaults to the static `provide` field.
+   */
+  constructor(ctx: Context, name: string);
+  protected [symbols.filter](ctx: Context): boolean;
+  protected [symbols.extend](props?: any): any;
+  /**
+   * Merge intercept config from ancestors with optional base and head values.
+   *
+   * Entries added closer to the root apply first; `base` is prepended and
+   * `head` appended. Uses `Config.merge` when the service declares one,
+   * otherwise a shallow `Object.assign`.
+   *
+   * @param base — lowest-precedence config merged before all intercepts.
+   * @param head — highest-precedence config merged after all intercepts.
+   * @returns the merged config.
+   */
+  [symbols.resolveConfig](base?: T, head?: T): T;
+  static [Symbol.hasInstance](instance: any): boolean;
+}
+//#endregion
+export { Dict as i, Context as n, StandardSchemaV1 as r, Service as t };
+//# sourceMappingURL=index-CDfaZYyK.d.ts.map