@makaio/framework 1.0.0-dev-1781022866275 → 1.0.0-dev-1781023871421

package/dist/types-C2Ob9zz_.d.mts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { SessionMessage } from "@makaio/framework/contracts";
+
+//#region services/core/src/session-editor/types.d.ts
+/**
+ * Category of pipeline action.
+ */
+declare const ActionCategorySchema: z.ZodEnum<{
+  compression: "compression";
+  extraction: "extraction";
+  transformation: "transformation";
+}>;
+type ActionCategory = z.infer<typeof ActionCategorySchema>;
+/**
+ * Result of a pipeline action - either transformed messages or a context JSON.
+ */
+declare const ActionResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+  kind: z.ZodLiteral<"messages">;
+  messages: z.ZodArray<z.ZodObject<{
+    messageId: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    sessionId: z.ZodString;
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+    }>;
+    contentText: z.ZodString;
+    blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"image">;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"document">;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"attachment">;
+      fileName: z.ZodString;
+      filePath: z.ZodString;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+      displayName: z.ZodOptional<z.ZodString>;
+      attachmentType: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"reasoning">;
+      content: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_call">;
+      toolCallId: z.ZodString;
+      name: z.ZodString;
+      args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_output">;
+      toolCallId: z.ZodString;
+      output: z.ZodString;
+      isError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>;
+    agentId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodOptional<z.ZodString>;
+    adapterMessageId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodNumber;
+    editOf: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+      text: "text";
+      voice: "voice";
+      compact: "compact";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"context">;
+  json: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  tokenEstimate: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+type ActionResult = z.infer<typeof ActionResultSchema>;
+/**
+ * Definition of a pipeline action that can be registered and executed.
+ */
+interface SessionEditorAction {
+  /** Unique identifier */
+  id: string;
+  /** Display label */
+  label: string;
+  /** Description shown in UI */
+  description: string;
+  /** Category for grouping in UI */
+  category: ActionCategory;
+  /** Execute the action on messages */
+  execute(messages: SessionMessage[], options?: Record<string, unknown>): Promise<ActionResult>;
+  /** Optional: estimate resulting token count */
+  estimateTokens?(messages: SessionMessage[]): Promise<number>;
+}
+/**
+ * Pipeline step configuration (action + options).
+ */
+interface PipelineStep {
+  actionId: string;
+  options?: Record<string, unknown>;
+}
+//#endregion
+export { PipelineStep as a, ActionResultSchema as i, ActionCategorySchema as n, SessionEditorAction as o, ActionResult as r, ActionCategory as t };

package/dist/types-CCdqjeuH.d.mts

@@ -0,0 +1,262 @@
+import { z } from "zod";
+
+//#region packages/rules/src/types.d.ts
+/**
+ * JSON primitive value supported by serialized rules.
+ */
+type JsonPrimitive = string | number | boolean | null;
+/**
+ * Scalar comparison value supported by field operators.
+ */
+type ScalarValue = JsonPrimitive;
+/**
+ * Leaf-level comparison against a single field value.
+ *
+ * Operator payloads are intentionally scalar-only for compatibility with the
+ * existing payload filter semantics.
+ */
+type FieldOperator = ScalarValue | {
+  $eq: ScalarValue;
+} | {
+  $ne: ScalarValue;
+} | {
+  $in: ScalarValue[];
+} | {
+  $nin: ScalarValue[];
+} | {
+  $exists: boolean;
+} | {
+  $startsWith: string;
+} | {
+  $endsWith: string;
+} | {
+  $glob: string;
+};
+/**
+ * A single field comparison against the evaluation context.
+ */
+interface FieldCondition {
+  /** Dot-notation path into the evaluation context. */
+  field: string;
+  /** Comparison to perform against the resolved field value. */
+  operator: FieldOperator;
+}
+/**
+ * Boolean AND across multiple child conditions.
+ */
+interface AndCondition {
+  /** Child conditions that must all evaluate truthy. */
+  $and: Condition[];
+}
+/**
+ * Boolean OR across multiple child conditions.
+ */
+interface OrCondition {
+  /** Child conditions where any truthy child matches. */
+  $or: Condition[];
+}
+/**
+ * Boolean negation of a child condition.
+ */
+interface NotCondition {
+  /** Child condition to negate. */
+  $not: Condition;
+}
+/**
+ * Jexl-backed expression condition evaluated against the full context.
+ */
+interface ExpressionCondition {
+  /** Expression string evaluated against the full context object. */
+  $expr: string;
+}
+/**
+ * Any condition supported by the rules engine.
+ */
+type Condition = FieldCondition | AndCondition | OrCondition | NotCondition | ExpressionCondition;
+//#endregion
+//#region packages/rules/src/schemas.d.ts
+/**
+ * Zod schema for any supported condition.
+ */
+declare const ConditionSchema: z.ZodType<Condition>;
+//#endregion
+//#region services/core/src/context-rules/types.d.ts
+/**
+ * Default turn-context bucket used for rules that inject additional context.
+ */
+declare const DEFAULT_CONTEXT_RULE_TURN_CONTEXT_KEY = "contextRules";
+/**
+ * Allowlisted managed instruction files owned by Context Rules.
+ */
+declare const MANAGED_INSTRUCTION_FILE_TARGETS: readonly ["AGENTS.md", "CLAUDE.md", "GEMINI.md", "COPILOT.md", "CURSOR.md"];
+/**
+ * Base snapshot fields available from current runtime seams.
+ *
+ * Host-owned fields are added through declaration merging on
+ * {@link ContextSnapshotExtensions}.
+ */
+interface ContextSnapshotBase {
+  /** Current working directory for the active agent/runtime, when known. */
+  cwd?: string;
+  /** Adapter identifier for the active agent/runtime, when known. */
+  adapterId?: string;
+  /** Makaio session identifier, when the runtime is attached to a session. */
+  sessionId?: string;
+  /** Active agent identifier, when resolution is tied to a specific agent. */
+  agentId?: string;
+}
+/**
+ * Host-owned declaration merge target for snapshot enrichment.
+ *
+ * Augment `@makaio/services-core/context-rules` from host code rather than
+ * widening the root services-core module.
+ */
+interface ContextSnapshotExtensions {}
+/**
+ * Fully resolved snapshot shape used for condition evaluation and rendering.
+ */
+type ContextSnapshot = ContextSnapshotBase & ContextSnapshotExtensions;
+/**
+ * Allowlisted managed instruction file target.
+ */
+type ManagedInstructionFileTarget = (typeof MANAGED_INSTRUCTION_FILE_TARGETS)[number];
+/**
+ * Scope levels supported by persisted context rules.
+ */
+type ContextRuleScope = 'global' | 'project' | 'session';
+/**
+ * Any condition supported by context-rule resolution.
+ */
+type ContextRuleCondition = z.infer<typeof ConditionSchema>;
+/**
+ * Rule action that injects rendered content into turn context.
+ */
+interface TurnContextRuleAction {
+  /** Delivery channel for the rendered rule content. */
+  channel: 'turnContext';
+  /** Template content rendered against the resolved snapshot. */
+  content: string;
+  /** Optional turn-context bucket key. Defaults to `contextRules`. */
+  turnContextKey?: string;
+}
+/**
+ * Rule action that projects rendered content into a managed root file.
+ */
+interface FileContextRuleAction {
+  /** Delivery channel for the rendered rule content. */
+  channel: 'file';
+  /** Template content rendered against the resolved snapshot. */
+  content: string;
+  /** Managed instruction file that receives the rendered projection. */
+  fileTarget: ManagedInstructionFileTarget;
+}
+/**
+ * Supported context-rule action payloads.
+ */
+type ContextRuleAction = TurnContextRuleAction | FileContextRuleAction;
+/**
+ * Scope fields shared by rule inputs and persisted rule records.
+ */
+interface ContextRuleScopeFields {
+  /** Hierarchical scope deciding when the rule is a candidate. */
+  scope: ContextRuleScope;
+  /** Project identifier for project scope and optionally project-bound session scope. */
+  projectId?: string;
+  /** Session identifier for session-scoped rules. */
+  sessionId?: string;
+}
+/**
+ * Write payload for creating or updating a context rule.
+ */
+interface ContextRuleInput extends ContextRuleScopeFields {
+  /** Stable rule identifier. */
+  id: string;
+  /** Human-readable rule name. */
+  name: string;
+  /** Optional description for diagnostics or UI display. */
+  description?: string;
+  /** Predicate tree that decides whether the rule matches. */
+  condition: ContextRuleCondition;
+  /** Delivery action attached to matching rules. */
+  action: ContextRuleAction;
+  /** Deterministic ordering key for matching rules. */
+  priority: number;
+  /** Whether the rule is active during resolution. */
+  enabled: boolean;
+}
+/**
+ * Persisted context rule record.
+ */
+interface ContextRule extends ContextRuleInput {
+  /** Creation timestamp in Unix milliseconds. */
+  createdAt: number;
+  /** Last update timestamp in Unix milliseconds. */
+  updatedAt: number;
+}
+/**
+ * Scope-based candidate query for storage-tier listing.
+ */
+interface ContextRuleListQuery {
+  /** Optional project identifier used to include project-scoped candidates and disambiguate project-bound session rules. */
+  projectId?: string;
+  /** Optional session identifier used to include session-scoped candidates. */
+  sessionId?: string;
+}
+/**
+ * Normalized scope identity used for cache invalidation.
+ */
+interface ContextRuleScopeIdentity {
+  /** Hierarchical scope deciding when the rule is a candidate. */
+  scope: ContextRuleScope;
+  /** Project identifier normalized to `null` when not part of the scope key. */
+  projectId: string | null;
+  /** Session identifier normalized to `null` when not part of the scope key. */
+  sessionId: string | null;
+}
+/**
+ * Service request for resolving matching rules against the current runtime.
+ */
+type ContextRuleResolutionRequest = ContextSnapshotBase;
+/**
+ * A matched rule after template rendering.
+ */
+interface ResolvedContextRule {
+  /** Stable rule identifier. */
+  id: string;
+  /** Human-readable rule name. */
+  name: string;
+  /** Deterministic sort key preserved in the resolved output. */
+  priority: number;
+  /** Original action payload for the matching rule. */
+  action: ContextRuleAction;
+  /** Template-rendered content for the concrete snapshot. */
+  renderedContent: string;
+}
+/**
+ * Service response grouping matched rules by delivery channel.
+ */
+interface ResolvedContextRules {
+  /** Concrete snapshot used for evaluation and rendering. */
+  snapshot: ContextSnapshot;
+  /** Resolved turn-context entries grouped by bucket key. */
+  turnContext: Record<string, ResolvedContextRule[]>;
+  /** Resolved managed-file entries grouped by file target. */
+  files: Partial<Record<ManagedInstructionFileTarget, ResolvedContextRule[]>>;
+}
+/**
+ * Lifecycle event emitted whenever persisted context rules change.
+ */
+interface ContextRuleChangedEvent {
+  /** Rule identifier that changed. */
+  ruleId: string;
+  /** Type of storage mutation that occurred. */
+  changeType: 'created' | 'updated' | 'deleted';
+  /** Scope identity before the mutation, or `null` for newly created rules. */
+  previous: ContextRuleScopeIdentity | null;
+  /** Scope identity after the mutation, or `null` for deleted rules. */
+  current: ContextRuleScopeIdentity | null;
+  /** Mutation timestamp in Unix milliseconds. */
+  timestamp: number;
+}
+//#endregion
+export { ManagedInstructionFileTarget as _, ContextRuleInput as a, TurnContextRuleAction as b, ContextRuleScope as c, ContextSnapshot as d, ContextSnapshotBase as f, MANAGED_INSTRUCTION_FILE_TARGETS as g, FileContextRuleAction as h, ContextRuleCondition as i, ContextRuleScopeFields as l, DEFAULT_CONTEXT_RULE_TURN_CONTEXT_KEY as m, ContextRuleAction as n, ContextRuleListQuery as o, ContextSnapshotExtensions as p, ContextRuleChangedEvent as r, ContextRuleResolutionRequest as s, ContextRule as t, ContextRuleScopeIdentity as u, ResolvedContextRule as v, Condition as x, ResolvedContextRules as y };

package/dist/types-DZHvOc_Q.d.mts

@@ -0,0 +1,305 @@
+import { r as LogImportMode, t as LogImporterInfo } from "./index-D9MwJ2Q8.mjs";
+import * as _$_makaio_bus_core0 from "@makaio/framework/bus";
+import { IMakaioBus } from "@makaio/framework/bus";
+import { LogImportOrchestrator, LogImporter } from "@makaio/framework/adapters";
+import { JsonObject } from "type-fest";
+import { CapabilityService } from "@makaio/framework/services/capability";
+
+//#region services/log-import/src/capability-provider.d.ts
+/**
+ * Minimal registry API required to register providers from capability events.
+ *
+ * `LogImportRegistry` satisfies this interface structurally, enabling the
+ * capability integration module to remain decoupled from the concrete class.
+ */
+interface CapabilityProviderRegistrar {
+  /**
+   * Returns the registration entry for an importer ID, or `undefined`.
+   * @param importerId - Unique importer ID
+   */
+  getImporter(importerId: string): LogImporterRegistration | undefined;
+  /**
+   * Registers a new importer.
+   * @param registration - Importer registration data
+   */
+  register(registration: LogImporterRegistration): Promise<void>;
+  /**
+   * Attaches an orchestrator factory to a registered importer.
+   * @param importerId - Unique importer ID
+   * @param factory - Factory function for mode-specific orchestrators
+   */
+  setOrchestratorFactory(importerId: string, factory: OrchestratorFactory): void;
+  /**
+   * Switches the import mode for a registered importer.
+   * @param importerId - Unique importer ID
+   * @param mode - Target import mode
+   */
+  switchMode(importerId: string, mode: LogImportMode): Promise<void>;
+}
+//#endregion
+//#region services/log-import/src/log-import-registry.d.ts
+/**
+ * Registry for managing log importers and their orchestrator lifecycle.
+ *
+ * Follows the ToolRegistry pattern with key differences:
+ * - Manages orchestrators instead of toolsets
+ * - Lazy orchestrator creation (only when started)
+ * - Auto-detection via detectImporter()
+ * @example
+ * ```typescript
+ * const registry = new LogImportRegistry();
+ * await registry.init();
+ *
+ * // Register an importer
+ * await registry.register({
+ *   id: 'claude-code-1',
+ *   adapterName: 'claude-code-cli',
+ *   displayName: 'Claude Code',
+ *   source: 'adapter',
+ *   importer: myImporter,
+ *   logFilePattern: '**\/session.jsonl',
+ * });
+ *
+ * // Start watching for new sessions
+ * await registry.startImporter('claude-code-1');
+ * ```
+ */
+declare class LogImportRegistry implements CapabilityProviderRegistrar {
+  private readonly bus;
+  private readonly capabilityService?;
+  private readonly registrations;
+  private readonly orchestrators;
+  private readonly cleanupHandlers;
+  private initialized;
+  /**
+   * Creates a new LogImportRegistry instance.
+   * @param options - Optional configuration
+   */
+  constructor(options?: LogImportRegistryOptions);
+  /**
+   * Initializes the registry and registers bus handlers.
+   *
+   * Registers handlers for:
+   * - listImporters: List all registered importers
+   * - scan: Scan log directory for sessions (generic handler)
+   * - uploadFiles: Process uploaded files (generic handler)
+   * - importSession: Lazy-load pick-up for discovered sessions
+   * - capability register: Auto-register adapters that publish log-import capabilities
+   *
+   * Must be called before using the registry.
+   */
+  init(): Promise<void>;
+  /**
+   * Registers a log importer.
+   *
+   * Does not start the orchestrator automatically. Use startImporter() to begin watching.
+   * @param registration - Importer registration data
+   * @throws If an importer with the same ID is already registered
+   */
+  register(registration: LogImporterRegistration): Promise<void>;
+  /**
+   * Unregisters a log importer.
+   *
+   * Stops the orchestrator if running, disposes it, and removes all references.
+   * @param importerId - Unique importer ID
+   * @throws If the importer is not registered
+   */
+  unregister(importerId: string): Promise<void>;
+  /**
+   * Starts the orchestrator for a registered importer.
+   *
+   * Creates the orchestrator if not already created (lazy initialization).
+   * Note: Orchestrator creation requires adapter-specific factory logic,
+   * which is handled externally. This method manages the lifecycle only.
+   * @param importerId - Unique importer ID
+   * @throws If the importer is not registered or orchestrator is not provided
+   */
+  startImporter(importerId: string): Promise<void>;
+  /**
+   * Stops the orchestrator for a registered importer.
+   *
+   * Does nothing if the orchestrator is not running.
+   * @param importerId - Unique importer ID
+   */
+  stopImporter(importerId: string): Promise<void>;
+  /**
+   * Switches the orchestrator mode for a registered importer.
+   *
+   * Stops the current orchestrator (if running), disposes it, creates a new
+   * orchestrator for the requested mode via the registration's factory, and
+   * starts it. When `mode` is `'disabled'`, any running orchestrator is stopped
+   * and cleared without starting a replacement.
+   *
+   * No-op when the importer has no `orchestratorFactory` (no orchestrator
+   * classes were provided at registration time).
+   * @param importerId - Unique importer ID
+   * @param mode - Target import mode
+   * @throws If the importer is not registered
+   */
+  switchMode(importerId: string, mode: LogImportMode): Promise<void>;
+  /**
+   * Convenience method that starts discovery mode for a registered importer.
+   *
+   * Equivalent to calling `switchMode(id, 'discover')`. Provided as a
+   * named shorthand so call sites read as intent rather than mechanism.
+   * @param importerId - Unique importer ID
+   * @returns Promise that resolves when the discovery orchestrator has started
+   * @throws If the importer is not registered
+   */
+  startDiscovery(importerId: string): Promise<void>;
+  /**
+   * Attaches an orchestrator factory to a registered importer.
+   *
+   * Called by the runtime after creating orchestrator class instances so the
+   * registry can reconstruct orchestrators when the mode changes via
+   * {@link switchMode}.
+   * @param importerId - Unique importer ID
+   * @param factory - Factory function that produces orchestrators for a given mode
+   * @throws If the importer is not registered
+   */
+  setOrchestratorFactory(importerId: string, factory: OrchestratorFactory): void;
+  /**
+   * Lists all registered importers with their current status.
+   * @returns Array of importer information
+   */
+  listImporters(): LogImporterInfo[];
+  /**
+   * Gets a registered importer by ID.
+   * @param importerId - Unique importer ID
+   * @returns Importer registration or undefined if not found
+   */
+  getImporter(importerId: string): LogImporterRegistration | undefined;
+  /**
+   * Gets a registered importer by adapter name.
+   * @param adapterName - Adapter name (e.g., 'claude-code-cli', 'codex-app-server')
+   * @returns Importer registration or undefined if not found
+   */
+  getImporterByAdapterName(adapterName: string): LogImporterRegistration | undefined;
+  /**
+   * Auto-detects which importer can handle a log sample.
+   *
+   * Used during log upload to match unknown formats with compatible importers.
+   * @param sample - Sample log content (string or parsed JSON object)
+   * @returns Matching importer registration or undefined if no match
+   */
+  detectImporter(sample: string | JsonObject): LogImporterRegistration | undefined;
+  /**
+   * Registers an orchestrator for a specific importer.
+   *
+   * This is called by adapters/extensions after they create their orchestrator instance.
+   * The registry manages the lifecycle but doesn't create orchestrators itself.
+   * @param importerId - Unique importer ID
+   * @param orchestrator - Orchestrator instance
+   * @throws If the importer is not registered
+   */
+  registerOrchestrator(importerId: string, orchestrator: LogImportOrchestrator): Promise<void>;
+  /**
+   * Cleans up registry resources.
+   *
+   * Stops all running orchestrators and unsubscribes from bus handlers.
+   */
+  destroy(): Promise<void>;
+}
+//#endregion
+//#region services/log-import/src/types.d.ts
+/**
+ * Factory function that creates a {@link LogImportOrchestrator} for a given mode.
+ *
+ * Returns `null` when no orchestrator is available for the requested mode
+ * (e.g., discovery requested but no `LogDiscoveryOrchestratorClass` was
+ * registered for this adapter).
+ * @param mode - Target import mode (never `'disabled'`)
+ * @returns Orchestrator instance or null if the mode requires no orchestrator
+ */
+type OrchestratorFactory = (mode: Exclude<LogImportMode, 'disabled'>) => LogImportOrchestrator | null;
+/**
+ * Public provenance class for a registered log importer.
+ */
+type LogImporterSource = 'adapter' | 'extension';
+/**
+ * Registration entry for a log importer.
+ *
+ * Stores metadata and references needed to manage the importer lifecycle.
+ */
+interface LogImporterRegistration {
+  /**
+   * Unique ID: adapterId for adapters, `package:{name}` for extensions.
+   */
+  id: string;
+  /**
+   * Adapter name used for session lookup and provenance tracking.
+   * @example 'claude-code-cli', 'codex-app-server', 'github-copilot-sdk'
+   */
+  adapterName: string;
+  /**
+   * Human-readable name.
+   * @example 'Claude Code', 'GitHub Copilot SDK'
+   */
+  displayName: string;
+  /**
+   * Source type.
+   */
+  source: LogImporterSource;
+  /**
+   * Importer instance.
+   */
+  importer: LogImporter<unknown, unknown>;
+  /**
+   * Glob pattern for log files.
+   * @example '**\/session.jsonl'
+   */
+  logFilePattern: string;
+  /**
+   * Whether this importer supports manual scan/import operations.
+   * Defaults to true.
+   */
+  supportsManualImport?: boolean;
+  /**
+   * Factory for creating orchestrators for this importer.
+   *
+   * When present, the registry can swap orchestrators on mode change via
+   * {@link LogImportRegistry.switchMode}. Absent when neither
+   * `LogOrchestratorClass` nor `LogDiscoveryOrchestratorClass` was provided.
+   */
+  orchestratorFactory?: OrchestratorFactory;
+}
+/**
+ * Configuration options for LogImportRegistry.
+ */
+interface LogImportRegistryOptions {
+  /**
+   * Message bus instance (defaults to MakaioBus).
+   */
+  bus?: _$_makaio_bus_core0.IMakaioBus;
+  /**
+   * Capability service used to backfill providers registered before init().
+   */
+  capabilityService?: CapabilityService;
+}
+/**
+ * Service instance returned by the log-import composition factory.
+ *
+ * Bundles the {@link LogImportRegistry} and the session-import handler
+ * cleanup so both are torn down together on shutdown.
+ */
+interface LogImportServiceInstance {
+  /** The live log-import registry. */
+  readonly registry: LogImportRegistry;
+  /** Tears down the registry and all session-import handlers. */
+  destroy(): Promise<void>;
+}
+/**
+ * Internal storage for orchestrator instances.
+ */
+interface OrchestratorEntry {
+  /**
+   * Orchestrator instance.
+   */
+  orchestrator: LogImportOrchestrator;
+  /**
+   * Whether orchestrator was started by registry.
+   */
+  isManaged: boolean;
+}
+//#endregion
+export { OrchestratorFactory as a, OrchestratorEntry as i, LogImportServiceInstance as n, LogImportRegistry as o, LogImporterRegistration as r, LogImportRegistryOptions as t };