@rezti/dsh-rez-suite 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,1726 @@
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/node_modules/@deepseek-ai/cosmokit/lib/types/types.d.ts
+declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
+declare function isArrayBufferSource(value: any): value is Binary.Source;
+/** Binary source detection and base64/hex conversion helpers. */
+declare namespace Binary {
+  type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>;
+  const is: typeof isArrayBufferLike;
+  const isSource: typeof isArrayBufferSource;
+  function fromSource<T extends ArrayBufferLike>(source: Source<T>): T;
+  function toBase64(source: Source): string;
+  function fromBase64(source: string): ArrayBuffer | Uint8Array<ArrayBuffer>;
+  function toHex(source: Source): string;
+  function fromHex(source: string): ArrayBuffer;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/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/.pnpm/@standard-schema+spec@1.1.0/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>;
+}
+/** The Standard JSON Schema interface. */
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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;
+  }
+}
+/** Error raised when plugin configuration fails standard-schema validation. */
+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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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$1<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$1<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$1<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$1<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$1<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$1<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$1<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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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/.pnpm/@deepseek-ai+cordis@4.0.1_@deepseek-ai+cordis-plugin-include@1.0.6_@deepseek-ai+cordis-plugin-loader@1.0.2/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
+//#region ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.1/node_modules/@deepseek-ai/schemastery/lib/types/index.d.ts
+declare const kSchema: unique symbol;
+declare global {
+  namespace Schemastery {
+    /** Convert primitive constructors, constants, and existing schemas into a schema type. */
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, unknown> ? S : never;
+    type Inverse<X> = X extends Schema<any, infer Y> ? (arg: Y) => void : never;
+    /** Input type accepted by a schema-like value. */
+    type TypeS<X> = TypeS1<From<X>>;
+    /** Output type returned by a schema-like value after validation. */
+    type TypeT<X> = ReturnType<From<X>>;
+    /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
+    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    /** Input type accepted by one schema in an intersection. */
+    type IntersectS<X> = From<X> extends Schema<infer S, unknown> ? S : never;
+    /** Output type returned by one schema in an intersection. */
+    type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
+    type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
+    type TupleT<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeT<L>?, ...TupleT<R>] : any[];
+    type ObjectS<X extends Dict> = { [K in keyof X]?: TypeS<X[K]> | null } & Dict;
+    type ObjectT<X extends Dict> = { [K in keyof X]: TypeT<X[K]> } & Dict;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    /** Static constructor and factory methods exposed by the default `Schema` export. */
+    interface Static {
+      <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      prototype: Schema;
+      /** Validate a value against a schema node and return `[output, adaptedInput?]`. */
+      resolve: Resolve;
+      /** Infer a schema from a primitive value, constructor, or existing schema. */
+      from<X = any>(source?: X): From<X>;
+      /** Register a resolver for a custom schema `type`. */
+      extend(type: string, resolve: Resolve): void;
+      /** Accept any value without validation. */
+      any<T = any>(): Schema<T>;
+      /** Accept only nullable input. */
+      never(): Schema<never>;
+      /** Accept exactly one constant value. */
+      const<const T>(value: T): Schema<T>;
+      /** Accept strings, with optional metadata constraints added by instance methods. */
+      string(): Schema<string>;
+      /** Accept numbers, with optional range and step constraints. */
+      number(): Schema<number>;
+      /** Accept non-negative integer numbers. */
+      natural(): Schema<number>;
+      /** Accept a number between 0 and 1 and mark it as a slider. */
+      percent(): Schema<number>;
+      /** Accept booleans. */
+      boolean(): Schema<boolean>;
+      /** Accept `Date` instances or parse datetime strings into `Date` objects. */
+      date(): Schema<string | Date, Date>;
+      /** Accept `RegExp` instances or parse strings into regular expressions. */
+      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      /** Accept binary sources and normalize them to `ArrayBufferLike`. */
+      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      /** Accept a numeric bitset or string keys and normalize to a number. */
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      /** Accept functions. */
+      function(): Schema<Function, (...args: any[]) => any>;
+      /** Accept instances of a constructor or objects whose constructor name matches. */
+      is(constructor: string): Schema;
+      is<T>(constructor: Constructor<T>): Schema<T>;
+      /** Accept arrays whose elements match `inner`. */
+      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      /** Accept plain objects with values matching `inner` and optional key schema. */
+      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      /** Accept tuple arrays where each index matches the corresponding schema. */
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      /** Accept plain objects whose declared properties match the schema dictionary. */
+      object<X extends Dict>(dict: X): Schema<ObjectS<X>, ObjectT<X>>;
+      /** Accept values matching at least one schema in `list`. */
+      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      /** Accept values matching every schema in `list`, merging object outputs. */
+      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      /** Validate with `inner`, then convert the result with `callback`. */
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      /** Defer construction of a recursive schema until validation or serialization. */
+      lazy<X extends Schema>(callback: () => X): X;
+      ValidationError: typeof ValidationError;
+    }
+    /** Runtime validation options shared by all schema calls. */
+    interface Options {
+      /** Remove invalid object properties instead of throwing when possible. */
+      autofix?: boolean;
+      /** Skip validation for selected values and schema nodes. */
+      ignore?(data: any, schema: Schema): boolean;
+      /** Path used to format nested validation errors. */
+      path?: (keyof any)[];
+    }
+    /** UI and validation metadata attached by schema builder methods. */
+    interface Meta<T = any> {
+      default?: T extends {} ? Partial<T> : T;
+      required?: boolean;
+      disabled?: boolean;
+      collapse?: boolean;
+      badges?: {
+        text: string;
+        type: string;
+      }[];
+      hidden?: boolean;
+      loose?: boolean;
+      role?: string;
+      extra?: any;
+      link?: string;
+      description?: string | Dict<string>;
+      comment?: string;
+      pattern?: {
+        source: string;
+        flags?: string;
+      };
+      max?: number;
+      min?: number;
+      step?: number;
+    }
+  }
+  /** Callable schema instance that validates input and returns normalized output. */
+  interface Schemastery<S = any, T = S> {
+    (data?: S | null, options?: Schemastery.Options): T;
+    new (data?: S | null, options?: Schemastery.Options): T;
+    [kSchema]: true;
+    uid: number;
+    meta: Schemastery.Meta<T>;
+    type: string;
+    sKey?: Schema;
+    inner?: Schema;
+    list?: Schema[];
+    dict?: Dict<Schema>;
+    bits?: Dict<number>;
+    callback?: Function;
+    constructor?: string | Function;
+    builder?: Function;
+    value?: T;
+    refs?: Dict<Schema>;
+    preserve?: boolean;
+    '~standard': StandardSchemaV1.Props;
+    /** Format this schema as a compact TypeScript-like type string. */
+    toString(inline?: boolean): string;
+    /** Serialize this schema, preserving shared and recursive references. */
+    toJSON(): Schema<S, T>;
+    /** Mark nullable input as invalid unless a default supplies a fallback. */
+    required(value?: boolean): Schema<S, T>;
+    /** Hide this schema node from UI renderers. */
+    hidden(value?: boolean): Schema<S, T>;
+    /** Return the default value instead of throwing when validation fails. */
+    loose(value?: boolean): Schema<S, T>;
+    /** Attach a renderer role and optional role-specific metadata. */
+    role(text: string, extra?: any): Schema<S, T>;
+    /** Attach an external documentation link. */
+    link(link: string): Schema<S, T>;
+    /** Set the fallback value used for nullable input. */
+    default(value: T): Schema<S, T>;
+    /** Attach an auxiliary comment for documentation or form UIs. */
+    comment(text: string): Schema<S, T>;
+    /** Attach a localized or plain description for documentation or form UIs. */
+    description(text: string): Schema<S, T>;
+    /** Mark this schema node as disabled for form UIs. */
+    disabled(value?: boolean): Schema<S, T>;
+    /** Request collapsed rendering for nested form UIs. */
+    collapse(value?: boolean): Schema<S, T>;
+    /** Add a deprecated badge to this schema node. */
+    deprecated(): Schema<S, T>;
+    /** Add an experimental badge to this schema node. */
+    experimental(): Schema<S, T>;
+    /** Require strings to match a regular expression. */
+    pattern(regexp: RegExp): Schema<S, T>;
+    /** Set an inclusive maximum for numbers or collection lengths. */
+    max(value: number): Schema<S, T>;
+    /** Set an inclusive minimum for numbers or collection lengths. */
+    min(value: number): Schema<S, T>;
+    /** Set the numeric increment constraint. */
+    step(value: number): Schema<S, T>;
+    /** Add or replace an object property schema. */
+    set(key: string, value: Schema): Schema<S, T>;
+    /** Append a tuple, union, or intersection member schema. */
+    push(value: Schema): Schema<S, T>;
+    /** Remove values equal to schema defaults from normalized output. */
+    simplify(value?: any): any;
+    /** Return a schema clone with descriptions merged from locale messages. */
+    i18n(messages: Dict): Schema<S, T>;
+    /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T>;
+  }
+}
+declare class ValidationError extends TypeError {
+  options: Schemastery.Options;
+  name: string;
+  constructor(message: string, options: Schemastery.Options);
+  static is(error: any): error is ValidationError;
+}
+type Schema<S = any, T = S> = Schemastery<S, T>;
+declare const Schema: Schemastery.Static;
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-settings@0.1.0-rc.6_@deepseek-ai+cordis@4.0.1_@deepseek-ai+dsh-brand@0_52495af71738a1095726249ceff4fd7b/node_modules/@deepseek-ai/dsh-settings/lib/types/redact.d.ts
+/** One schema-declared secret position inside a redacted value. */
+interface RedactedSecret {
+  /** Path from the section root to the removed field (concrete dict keys and array indexes included). */
+  path: string[];
+  /** Whether the field held a value before redaction. */
+  set: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-brand@0.1.0-rc.6_@deepseek-ai+cordis@4.0.1_@deepseek-ai+dsh-invariants_757bf6a984ac37281430ad822ab10469/node_modules/@deepseek-ai/dsh-brand/lib/types/index.d.ts
+/**
+ * The `Branded<B>` nominal-typing primitive — a type-only utility (no runtime
+ * code, no harness-package dependency) shared by every package that owns a
+ * cross-boundary id.
+ *
+ * A brand makes structurally-identical strings non-interchangeable at the type
+ * level: a `SessionId` cannot be passed where a `CallId` is expected, even
+ * though both are plain strings at runtime. Construction goes through a per-id
+ * factory in the OWNING package (a plain cast inside — zero runtime cost);
+ * comparison, logging, and serialization all behave as ordinary strings.
+ *
+ * Policy: a package brands the ids it owns — `CallId` in dsh-llm (tool-call
+ * correlation), the shared agent/session `SessionId` in dsh-session, and
+ * `JobId` in dsh-jobs. Branding is for ids that cross package boundaries and
+ * could plausibly be confused; not every string needs a brand.
+ * This package owns ONLY the primitive — no concrete id, no runtime code beyond
+ * the (erased) type — so the brand vocabulary stays dependency-free and a
+ * package can brand its ids without depending on an unrelated capability
+ * package.
+ *
+ * @module @deepseek-ai/dsh-brand
+ */
+declare const BRAND: unique symbol;
+/** A string carrying a compile-time-only brand `B`. */
+type Branded<B extends string> = string & {
+  readonly [BRAND]: B;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-settings@0.1.0-rc.6_@deepseek-ai+cordis@4.0.1_@deepseek-ai+dsh-brand@0_52495af71738a1095726249ceff4fd7b/node_modules/@deepseek-ai/dsh-settings/lib/types/types.d.ts
+/** Nominal id of one registered settings namespace. */
+type SettingsNamespace = Branded<'SettingsNamespace'>;
+/** Origin of one committed settings change. */
+type SettingsUpdateSource = 'update' | 'provider';
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    /**
+     * Committed change to one registered namespace's resolved value. Emitted
+     * after the provider persisted (for `update`) or published (`provider`)
+     * the change; never emitted when the resolved value is deep-equal.
+     * Listener failures are contained and logged — a sync throw and an async
+     * rejection alike — except `INVARIANT`-coded failures, which rethrow
+     * after every listener ran; that rethrow reaches the emitter only from
+     * synchronous listeners, so invariant checks on this event must not be
+     * async functions.
+     * @param ns - the namespace whose resolved value changed.
+     * @param next - the new resolved value.
+     * @param prev - the previous resolved value.
+     * @param source - whether the change entered through `update()` or the provider.
+     * @mode emit
+     */
+    'settings/updated'(ns: SettingsNamespace, next: unknown, prev: unknown, source: SettingsUpdateSource): void;
+    /**
+     * One registered namespace's RAW user section changed, whether or not the
+     * resolved value did. `settings/updated` is the consumer-facing event and
+     * stays deep-equal-gated; this one exists for configuration surfaces,
+     * which must learn that a field went from inherited to overridden (same
+     * resolved value, different meaning) and that their held revision is
+     * stale. Listener containment matches `settings/updated`.
+     * @param ns - the namespace whose stored section changed.
+     * @param revision - the namespace's new revision.
+     * @mode emit
+     */
+    'settings/document-updated'(ns: SettingsNamespace, revision: number): void;
+  }
+} //# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-settings@0.1.0-rc.6_@deepseek-ai+cordis@4.0.1_@deepseek-ai+dsh-brand@0_52495af71738a1095726249ceff4fd7b/node_modules/@deepseek-ai/dsh-settings/lib/types/index.d.ts
+/** When a namespace's changes take effect for its owner. */
+type SettingsApplies = 'live' | 'restart';
+/** Registration options beyond the namespace schema. */
+interface SettingsRegisterOptions<T> {
+  /** Composition-layer values resolved below the user layer (entry-config subset). */
+  base?: Partial<T>;
+  /** Owner's effect timing, surfaced to configuration UIs; defaults to `live`. */
+  applies?: SettingsApplies;
+  /**
+   * Reject a resolved section the owner could not act on, for constraints its
+   * schema cannot express — a cross-field requirement, or one field's validity
+   * depending on another's. Throwing here refuses the *write* that produced the
+   * value, so a caller learns at `update`/`replace`/`mutate` instead of storing
+   * something that would silently disable the owner.
+   *
+   * Kept separate from the schema because the schema is also what a
+   * configuration surface renders and what an absent section resolves through;
+   * folding a cross-field check into it would change both.
+   *
+   * Once the owner is registered, a stored section that fails this keeps the
+   * namespace's last good value and warns, exactly as a schema failure does,
+   * so an externally edited document cannot strand a running owner. At
+   * registration there is no last good value yet, so a stored section that
+   * already fails rejects the registration itself — again exactly as a schema
+   * failure does.
+   * @param value - the resolved section, schema-valid by construction.
+   */
+  validate?: (value: T) => void;
+}
+/** One registered namespace as surfaced to configuration UIs. */
+interface SettingsDescriptor {
+  /** The registered namespace. */
+  ns: SettingsNamespace;
+  /** Serialized schemastery schema (`schema.toJSON()`). */
+  schema: unknown;
+  /** Current resolved value. */
+  value: unknown;
+  /**
+   * Monotonic revision of the raw user section this descriptor was read at.
+   * Send it back as `expectedRevision` on a write to refuse a stale one.
+   */
+  revision: number;
+  /** Registrant's composition `base` layer (detached), when one was declared. */
+  base?: unknown;
+  /**
+   * Raw user section from the stored document (detached), when one exists and
+   * is well-formed; a field's presence here is what marks it user-overridden.
+   */
+  user?: unknown;
+  /** Owner's declared effect timing. */
+  applies: SettingsApplies;
+  /** Schema-declared secret positions; present only under `redactSecrets`. */
+  secrets?: RedactedSecret[];
+}
+/** Options for {@link SettingsProvider.describe}. */
+interface SettingsDescribeOptions {
+  /**
+   * Strip `role('secret')` fields from `value`/`base`/`user` and enumerate
+   * them in each descriptor's `secrets`. Every wire surface MUST pass this;
+   * the verbatim default exists for same-process configuration UIs only.
+   */
+  redactSecrets?: boolean;
+}
+/** Owner-facing handle for one registered namespace. */
+interface SettingsScope<T> {
+  /** Current resolved value: schema defaults, then `base`, then the user layer. */
+  get(): T;
+  /**
+   * Observe committed changes to this namespace's resolved value. Invocations
+   * of one callback run asynchronously, one at a time, in commit order; a
+   * rejection is contained and logged like a sync throw. After the disposer
+   * returns, no further invocation starts — one already queued is skipped;
+   * one already started still settles, and service disposal waits for it.
+   * @param callback - invoked after each commit with the next and previous values.
+   * @returns the disposer removing this observer.
+   */
+  watch(callback: (next: T, prev: T) => void | Promise<void>): () => void;
+  /**
+   * Merge a partial patch into this namespace's user layer and persist it.
+   * @param patch - plain-object patch over the user section; JSON-compatible data
+   * only (non-JSON values reject with their path before anything persists).
+   */
+  update(patch: object): Promise<void>;
+  /**
+   * Replace this namespace's user section wholesale; absent keys re-inherit
+   * the composition `base` and schema defaults (`replace({})` resets all).
+   * @param section - the complete next user section; JSON-compatible data only,
+   * as for {@link update}.
+   */
+  replace(section: object): Promise<void>;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    settings: SettingsProvider;
+  }
+}
+/**
+ * Deep equality over JSON-compatible data (objects, arrays, primitives) — the
+ * Service Definition's single change-detection predicate, exported so the invariant
+ * companion checks exactly the implementation's relation.
+ * @param a - one JSON-compatible value.
+ * @param b - the other JSON-compatible value.
+ * @returns whether the two values are structurally equal.
+ */
+/**
+ * One path-addressed edit to a namespace's user section. Path mutation exists
+ * for a caller holding an INCOMPLETE view of the section — a configuration UI
+ * reads the redacted descriptor, which by construction never received the
+ * `role('secret')` fields. Such a caller can name the field it means without
+ * restating the section: a wholesale `replace` rebuilt from a redacted
+ * document silently deletes every secret the wire never returned.
+ */
+type SettingsPathOp = {
+  op: 'set';
+  path: readonly string[];
+  value: unknown;
+} | {
+  op: 'unset';
+  path: readonly string[];
+};
+/**
+ * Abstract settings service. Providers implement raw-document storage
+ * (`load`/`persist`) and push external changes through {@link Settings.publish};
+ * the base class owns namespace registration, resolution, validation, change
+ * detection, and the `settings/updated` commit event.
+ */
+declare abstract class SettingsProvider extends Service {
+  private readonly registrations;
+  /** Latest published raw document; empty until the provider's first publish. */
+  private document;
+  /** Per-namespace write chains; settled tails, so a failure never poisons the queue. */
+  private readonly writeQueues;
+  /** In-flight watcher invocation segments, drained by the dispose teardown. */
+  private readonly pendingTails;
+  /** Set at service dispose: refuse new writes while queued ones drain. */
+  private stopped;
+  /** Opaque read of {@link stopped}: control flow cannot narrow it across awaits. */
+  private isStopped;
+  constructor(ctx: Context);
+  /**
+   * Load the provider's document once and publish it before the service
+   * becomes injectable, and register the write-drain teardown. Providers with
+   * their own init (watchers, connections) delegate here first via
+   * `yield* super[Service.init]()`; their disposers then run before the drain.
+   */
+  [Service.init](): AsyncGenerator<() => Promise<void> | void, void, void>;
+  /** Whether {@link update} may persist through this provider. */
+  abstract readonly writable: boolean;
+  /**
+   * Absolute path of the provider's user-editable document, when its storage
+   * is one local file. Configuration surfaces use this only as availability
+   * metadata; the guarded open operation resolves the path again Host-side.
+   * Non-file providers leave it undefined and expose no open-document affordance.
+   * @returns the absolute local document path, or undefined for non-file storage.
+   */
+  get documentPath(): string | undefined;
+  /**
+   * Prepare the provider's user-editable document for a native editor. File
+   * providers may materialize an absent document before returning its path;
+   * non-file providers return undefined.
+   * @returns the absolute local document path, or undefined for non-file storage.
+   */
+  prepareDocument(): Promise<string | undefined>;
+  /**
+   * Read the provider's current raw document (namespace to raw section).
+   * @returns the detached raw document.
+   */
+  protected abstract load(): Promise<Record<string, unknown>>;
+  /**
+   * Durably store one namespace's merged user section.
+   * @param ns - the namespace being written.
+   * @param section - the complete merged user section to store.
+   */
+  protected abstract persist(ns: SettingsNamespace, section: Record<string, unknown>): Promise<void>;
+  /**
+   * Register a namespace schema and receive its owner scope. The registration
+   * is an effect on the calling plugin's fiber: disposing that fiber removes
+   * the namespace and its observers. An invalid stored section fails the
+   * registration itself — the earliest point where the schema can judge it.
+   * @param ns - unique namespace; duplicate registration fails loud.
+   * @param schema - schemastery schema resolving this namespace's value.
+   * @param options - composition `base` layer and effect timing.
+   * @returns the owner scope for reads, observation, and updates.
+   */
+  register<T>(ns: SettingsNamespace, schema: Schema<T>, options?: SettingsRegisterOptions<T>): SettingsScope<T>;
+  /**
+   * Describe every registered namespace for configuration surfaces, including
+   * the composition `base` and raw user layers so a form can mark which fields
+   * the user overrode (presence in `user`) and what a reset returns to.
+   * @param options - redaction switch; wire surfaces must redact.
+   * @returns one descriptor per registered namespace, in registration order.
+   */
+  describe(options?: SettingsDescribeOptions): SettingsDescriptor[];
+  /**
+   * Read one registered namespace's resolved value.
+   * @param ns - the namespace to read.
+   * @returns the resolved value, or `undefined` while unregistered.
+   */
+  get(ns: SettingsNamespace): unknown;
+  /**
+   * Merge a patch into one registered namespace's user layer, validate the
+   * resolved candidate, persist through the provider, then commit and emit.
+   * A validation failure rejects before anything is persisted. Writes to one
+   * namespace are serialized: concurrent updates apply in call order, each
+   * merging over the previous write's committed section.
+   * @param ns - the registered namespace to update.
+   * @param patch - plain-object patch over the user section.
+   * @param expectedRevision - the descriptor `revision` the caller read; a
+   *   namespace that moved past it rejects with {@link SettingsConflictError}.
+   */
+  update(ns: SettingsNamespace, patch: object, expectedRevision?: number): Promise<void>;
+  /**
+   * Replace one registered namespace's user section wholesale, validate,
+   * persist, then commit and emit. Keys absent from `section` fall back to the
+   * composition `base` and schema defaults — this is the removal/reset path a
+   * merge-only patch cannot express (`replace({})` re-inherits everything).
+   * @param ns - the registered namespace to replace.
+   * @param section - the complete next user section.
+   * @param expectedRevision - the descriptor `revision` the caller read; a
+   *   namespace that moved past it rejects with {@link SettingsConflictError}.
+   */
+  replace(ns: SettingsNamespace, section: object, expectedRevision?: number): Promise<void>;
+  /**
+   * Apply path-addressed edits to one registered namespace's user section,
+   * validate, persist, then commit and emit. The ops are applied to the
+   * section as it stands when the write reaches the front of the queue, so a
+   * caller never has to restate fields it did not touch — and, crucially,
+   * cannot delete fields it never saw. This is the write path for any caller
+   * holding a redacted view; `replace` remains the wholesale reset.
+   * @param ns - the registered namespace to edit.
+   * @param ops - ordered path edits; later ops observe earlier ones.
+   * @param expectedRevision - the descriptor `revision` the caller read; a
+   *   namespace that moved past it rejects with {@link SettingsConflictError}.
+   */
+  mutate(ns: SettingsNamespace, ops: readonly SettingsPathOp[], expectedRevision?: number): Promise<void>;
+  /** Validate a write, then queue it on the namespace's serialized write chain. */
+  private write;
+  /**
+   * Provider hook: commit a complete raw document observed in storage. Each
+   * registered namespace re-resolves; an invalid section keeps that
+   * namespace's last good value and warns, other namespaces still commit.
+   * @param doc - the detached raw document (unregistered sections preserved).
+   * @param source - change origin; defaults to `provider`.
+   */
+  protected publish(doc: Record<string, unknown>, source?: SettingsUpdateSource): void;
+  /** Read one namespace's raw user section, rejecting non-object sections. */
+  private section;
+  /** Resolve one namespace value: schema defaults, then `base`, then the user layer. */
+  private resolve;
+  /**
+   * Advance a namespace's revision when its RAW section changed, and announce
+   * it. Deliberately independent of {@link commit}'s resolved-value equality:
+   * storing an override equal to the composition base leaves the resolved
+   * value alone but changes what the document says, which is exactly what a
+   * configuration surface must re-read.
+   */
+  private bumpRevision;
+  /** Contained fan-out of `settings/document-updated`, mirroring {@link commit}'s. */
+  private emitDocumentUpdated;
+  /** Commit a resolved value when changed: swap, notify watchers, emit the event. */
+  private commit;
+  /** Contained-watcher diagnostic shared by the sync and async failure paths. */
+  private warnWatcherFailure;
+  /** Contained-listener diagnostic shared by the sync and async failure paths. */
+  private warnListenerFailure;
+}
+//#endregion
+//#region src/protocol.d.ts
+/** Agent role, the preset-loader key. */
+type RezRoleId = 'engineer' | 'sales' | 'operations' | 'all';
+/** Transport kinds the in-plugin MCP host can connect. */
+type RezMcpTransport = 'stdio' | 'streamable-http';
+/** One MCP server launch descriptor (standard MCP-style config). */
+interface RezMcpServerSpec {
+  /** Master switch for this server. */
+  enabled: boolean;
+  /** stdio or streamable-http. */
+  transport: RezMcpTransport;
+  /** stdio executable (npx, uvx, node, absolute binary, ...). */
+  command?: string;
+  /** stdio args passed without shell interpolation. */
+  args?: string[];
+  /** stdio env merged over the scrubbed parent env. */
+  env?: Record<string, string>;
+  /** stdio working directory. */
+  cwd?: string;
+  /** streamable-http endpoint URL. */
+  url?: string;
+  /** streamable-http request headers (Authorization, ...). */
+  headers?: Record<string, string>;
+  /** Per-tool-call timeout in milliseconds. */
+  toolCallTimeoutMs?: number;
+}
+/** Full plugin configuration persisted under ~/.dsh/dsh-rez-suite.json. */
+interface RezConfig {
+  enabled: boolean;
+  announceToAgent: boolean;
+  role: RezRoleId;
+  servers: Record<string, RezMcpServerSpec>;
+  billing: {
+    inputCostPer1k: number;
+    outputCostPer1k: number;
+    monthlyBudget: number;
+  };
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "rez-suite";
+declare const inject: string[];
+declare const REZ_SETTINGS_NAMESPACE: SettingsNamespace;
+declare const Config: Schema<RezConfig>;
+declare const REZ_GUIDANCE: string;
+declare function apply(ctx: Context, config?: RezConfig): void;
+//#endregion
+export { Config, REZ_GUIDANCE, REZ_SETTINGS_NAMESPACE, apply, inject, name };