@agimon-ai/doompi-minor-mode 0.0.1-alpha.100

package/dist/mode-EZWqhrYy.d.mts

@@ -0,0 +1,492 @@
+import { Static, Type } from "typebox";
+import { DoomExtensionContext } from "@agimon-ai/doompi-core/runtimeConfig";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/schemas/mode.d.ts
+declare const MINOR_MODE_CATALOG_SOURCE = "@agimon-ai/doompi/mode-catalog";
+declare const DOOM_MINOR_MODE_CATALOG_SERVICE = "doom/minor-mode-catalog";
+declare const MINOR_MODE_TOOL_NAME = "minor_mode";
+declare const MINOR_MODE_ACTION_TIMEOUT_MS = 30000;
+declare const MINOR_MODE_MAX_RECORDS = 128;
+declare const MINOR_MODE_MAX_ACTIONS = 16;
+declare const MINOR_MODE_MAX_PARAMETERS = 16;
+declare const MINOR_MODE_MAX_ENUM_CHOICES = 32;
+declare const MINOR_MODE_MAX_ARGUMENT_LENGTH = 4096;
+declare const MINOR_MODE_ERROR_CODE: {
+  readonly actionAborted: 'MINOR_MODE_ACTION_ABORTED';
+  readonly actionDisabled: 'MINOR_MODE_ACTION_DISABLED';
+  readonly actionNotFound: 'MINOR_MODE_ACTION_NOT_FOUND';
+  readonly actionTimeout: 'MINOR_MODE_ACTION_TIMEOUT';
+  readonly invalidArguments: 'MINOR_MODE_INVALID_ARGUMENTS';
+  readonly modeBusy: 'MINOR_MODE_BUSY';
+  readonly modeNotFound: 'MINOR_MODE_NOT_FOUND';
+  readonly ownerFailed: 'MINOR_MODE_OWNER_FAILED';
+  readonly registrationConflict: 'MINOR_MODE_REGISTRATION_CONFLICT';
+  readonly sessionReplaced: 'MINOR_MODE_SESSION_REPLACED';
+  readonly staleRegistration: 'MINOR_MODE_STALE_REGISTRATION';
+  readonly unsupportedContext: 'MINOR_MODE_UNSUPPORTED_CONTEXT';
+};
+declare const MinorModeSourceSchema: Type.TString;
+declare const MinorModeIdSchema: Type.TString;
+declare const MinorModeParameterNameSchema: Type.TString;
+declare const ModeTextColorSchema: Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>;
+type ModeTextColor = Static<typeof ModeTextColorSchema>;
+declare const MinorModeSessionKindSchema: Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>;
+type MinorModeSessionKind = Static<typeof MinorModeSessionKindSchema>;
+declare const MinorModeActivationSchema: Type.TUnion<[Type.TLiteral<"inactive">, Type.TLiteral<"activating">, Type.TLiteral<"active">, Type.TLiteral<"deactivating">]>;
+type MinorModeActivation = Static<typeof MinorModeActivationSchema>;
+declare const MinorModeConditionSchema: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"paused">, Type.TLiteral<"blocked">, Type.TLiteral<"limited">, Type.TLiteral<"queued">, Type.TLiteral<"degraded">, Type.TLiteral<"failed">]>;
+type MinorModeCondition = Static<typeof MinorModeConditionSchema>;
+declare const MinorModeScalarSchema: Type.TUnion<[Type.TString, Type.TNumber, Type.TBoolean]>;
+type MinorModeScalar = Static<typeof MinorModeScalarSchema>;
+declare const MinorModeActionParameterSchema: Type.TUnion<[Type.TObject<{
+  name: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  required: Type.TBoolean;
+  kind: Type.TLiteral<"string">;
+  minLength: Type.TOptional<Type.TInteger>;
+  maxLength: Type.TOptional<Type.TInteger>;
+}>, Type.TObject<{
+  name: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  required: Type.TBoolean;
+  kind: Type.TLiteral<"number">;
+  integer: Type.TOptional<Type.TBoolean>;
+  minimum: Type.TOptional<Type.TNumber>;
+  maximum: Type.TOptional<Type.TNumber>;
+}>, Type.TObject<{
+  name: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  required: Type.TBoolean;
+  kind: Type.TLiteral<"boolean">;
+}>, Type.TObject<{
+  name: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  required: Type.TBoolean;
+  kind: Type.TLiteral<"enum">;
+  choices: Type.TArray<Type.TObject<{
+    value: Type.TString;
+    label: Type.TString;
+  }>>;
+}>]>;
+type MinorModeActionParameter = Static<typeof MinorModeActionParameterSchema>;
+declare const MinorModeActionDescriptorSchema: Type.TObject<{
+  id: Type.TString;
+  label: Type.TString;
+  description: Type.TString;
+  contexts: Type.TArray<Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>>;
+  parameters: Type.TArray<Type.TUnion<[Type.TObject<{
+    name: Type.TString;
+    label: Type.TString;
+    description: Type.TOptional<Type.TString>;
+    required: Type.TBoolean;
+    kind: Type.TLiteral<"string">;
+    minLength: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>, Type.TObject<{
+    name: Type.TString;
+    label: Type.TString;
+    description: Type.TOptional<Type.TString>;
+    required: Type.TBoolean;
+    kind: Type.TLiteral<"number">;
+    integer: Type.TOptional<Type.TBoolean>;
+    minimum: Type.TOptional<Type.TNumber>;
+    maximum: Type.TOptional<Type.TNumber>;
+  }>, Type.TObject<{
+    name: Type.TString;
+    label: Type.TString;
+    description: Type.TOptional<Type.TString>;
+    required: Type.TBoolean;
+    kind: Type.TLiteral<"boolean">;
+  }>, Type.TObject<{
+    name: Type.TString;
+    label: Type.TString;
+    description: Type.TOptional<Type.TString>;
+    required: Type.TBoolean;
+    kind: Type.TLiteral<"enum">;
+    choices: Type.TArray<Type.TObject<{
+      value: Type.TString;
+      label: Type.TString;
+    }>>;
+  }>]>>;
+}>;
+type MinorModeActionDescriptor = Static<typeof MinorModeActionDescriptorSchema>;
+declare const MinorModeDescriptorSchema: Type.TObject<{
+  source: Type.TString;
+  id: Type.TString;
+  label: Type.TString;
+  description: Type.TString;
+  order: Type.TInteger;
+  actions: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    description: Type.TString;
+    contexts: Type.TArray<Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>>;
+    parameters: Type.TArray<Type.TUnion<[Type.TObject<{
+      name: Type.TString;
+      label: Type.TString;
+      description: Type.TOptional<Type.TString>;
+      required: Type.TBoolean;
+      kind: Type.TLiteral<"string">;
+      minLength: Type.TOptional<Type.TInteger>;
+      maxLength: Type.TOptional<Type.TInteger>;
+    }>, Type.TObject<{
+      name: Type.TString;
+      label: Type.TString;
+      description: Type.TOptional<Type.TString>;
+      required: Type.TBoolean;
+      kind: Type.TLiteral<"number">;
+      integer: Type.TOptional<Type.TBoolean>;
+      minimum: Type.TOptional<Type.TNumber>;
+      maximum: Type.TOptional<Type.TNumber>;
+    }>, Type.TObject<{
+      name: Type.TString;
+      label: Type.TString;
+      description: Type.TOptional<Type.TString>;
+      required: Type.TBoolean;
+      kind: Type.TLiteral<"boolean">;
+    }>, Type.TObject<{
+      name: Type.TString;
+      label: Type.TString;
+      description: Type.TOptional<Type.TString>;
+      required: Type.TBoolean;
+      kind: Type.TLiteral<"enum">;
+      choices: Type.TArray<Type.TObject<{
+        value: Type.TString;
+        label: Type.TString;
+      }>>;
+    }>]>>;
+  }>>;
+}>;
+type MinorModeDescriptor = Static<typeof MinorModeDescriptorSchema>;
+declare const MinorModeActionAvailabilitySchema: Type.TObject<{
+  id: Type.TString;
+  enabled: Type.TBoolean;
+  disabledReason: Type.TOptional<Type.TString>;
+}>;
+type MinorModeActionAvailability = Static<typeof MinorModeActionAvailabilitySchema>;
+declare const MinorModeStateSchema: Type.TObject<{
+  activation: Type.TUnion<[Type.TLiteral<"inactive">, Type.TLiteral<"activating">, Type.TLiteral<"active">, Type.TLiteral<"deactivating">]>;
+  condition: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"paused">, Type.TLiteral<"blocked">, Type.TLiteral<"limited">, Type.TLiteral<"queued">, Type.TLiteral<"degraded">, Type.TLiteral<"failed">]>;
+  detail: Type.TOptional<Type.TString>;
+  color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+  modelContextVariant: Type.TOptional<Type.TString>;
+  actions: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    enabled: Type.TBoolean;
+    disabledReason: Type.TOptional<Type.TString>;
+  }>>;
+}>;
+type MinorModeState = Static<typeof MinorModeStateSchema>;
+declare const MinorModeRegistrationRefSchema: Type.TObject<{
+  source: Type.TString;
+  id: Type.TString;
+  ownerGeneration: Type.TString;
+  registrationId: Type.TString;
+}>;
+type MinorModeRegistrationRef = Static<typeof MinorModeRegistrationRefSchema>;
+declare const MinorModeRecordSchema: Type.TObject<{
+  descriptor: Type.TObject<{
+    source: Type.TString;
+    id: Type.TString;
+    label: Type.TString;
+    description: Type.TString;
+    order: Type.TInteger;
+    actions: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      description: Type.TString;
+      contexts: Type.TArray<Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>>;
+      parameters: Type.TArray<Type.TUnion<[Type.TObject<{
+        name: Type.TString;
+        label: Type.TString;
+        description: Type.TOptional<Type.TString>;
+        required: Type.TBoolean;
+        kind: Type.TLiteral<"string">;
+        minLength: Type.TOptional<Type.TInteger>;
+        maxLength: Type.TOptional<Type.TInteger>;
+      }>, Type.TObject<{
+        name: Type.TString;
+        label: Type.TString;
+        description: Type.TOptional<Type.TString>;
+        required: Type.TBoolean;
+        kind: Type.TLiteral<"number">;
+        integer: Type.TOptional<Type.TBoolean>;
+        minimum: Type.TOptional<Type.TNumber>;
+        maximum: Type.TOptional<Type.TNumber>;
+      }>, Type.TObject<{
+        name: Type.TString;
+        label: Type.TString;
+        description: Type.TOptional<Type.TString>;
+        required: Type.TBoolean;
+        kind: Type.TLiteral<"boolean">;
+      }>, Type.TObject<{
+        name: Type.TString;
+        label: Type.TString;
+        description: Type.TOptional<Type.TString>;
+        required: Type.TBoolean;
+        kind: Type.TLiteral<"enum">;
+        choices: Type.TArray<Type.TObject<{
+          value: Type.TString;
+          label: Type.TString;
+        }>>;
+      }>]>>;
+    }>>;
+  }>;
+  state: Type.TObject<{
+    activation: Type.TUnion<[Type.TLiteral<"inactive">, Type.TLiteral<"activating">, Type.TLiteral<"active">, Type.TLiteral<"deactivating">]>;
+    condition: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"paused">, Type.TLiteral<"blocked">, Type.TLiteral<"limited">, Type.TLiteral<"queued">, Type.TLiteral<"degraded">, Type.TLiteral<"failed">]>;
+    detail: Type.TOptional<Type.TString>;
+    color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+    modelContextVariant: Type.TOptional<Type.TString>;
+    actions: Type.TArray<Type.TObject<{
+      id: Type.TString;
+      enabled: Type.TBoolean;
+      disabledReason: Type.TOptional<Type.TString>;
+    }>>;
+  }>;
+  ownerGeneration: Type.TString;
+  registrationId: Type.TString;
+  stateRevision: Type.TInteger;
+}>;
+type MinorModeRecord = Static<typeof MinorModeRecordSchema>;
+declare const MinorModeCatalogSnapshotSchema: Type.TObject<{
+  hostGeneration: Type.TString;
+  revision: Type.TInteger;
+  modes: Type.TArray<Type.TObject<{
+    descriptor: Type.TObject<{
+      source: Type.TString;
+      id: Type.TString;
+      label: Type.TString;
+      description: Type.TString;
+      order: Type.TInteger;
+      actions: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        description: Type.TString;
+        contexts: Type.TArray<Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>>;
+        parameters: Type.TArray<Type.TUnion<[Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"string">;
+          minLength: Type.TOptional<Type.TInteger>;
+          maxLength: Type.TOptional<Type.TInteger>;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"number">;
+          integer: Type.TOptional<Type.TBoolean>;
+          minimum: Type.TOptional<Type.TNumber>;
+          maximum: Type.TOptional<Type.TNumber>;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"boolean">;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"enum">;
+          choices: Type.TArray<Type.TObject<{
+            value: Type.TString;
+            label: Type.TString;
+          }>>;
+        }>]>>;
+      }>>;
+    }>;
+    state: Type.TObject<{
+      activation: Type.TUnion<[Type.TLiteral<"inactive">, Type.TLiteral<"activating">, Type.TLiteral<"active">, Type.TLiteral<"deactivating">]>;
+      condition: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"paused">, Type.TLiteral<"blocked">, Type.TLiteral<"limited">, Type.TLiteral<"queued">, Type.TLiteral<"degraded">, Type.TLiteral<"failed">]>;
+      detail: Type.TOptional<Type.TString>;
+      color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+      modelContextVariant: Type.TOptional<Type.TString>;
+      actions: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        enabled: Type.TBoolean;
+        disabledReason: Type.TOptional<Type.TString>;
+      }>>;
+    }>;
+    ownerGeneration: Type.TString;
+    registrationId: Type.TString;
+    stateRevision: Type.TInteger;
+  }>>;
+}>;
+type MinorModeCatalogSnapshot = Static<typeof MinorModeCatalogSnapshotSchema>;
+declare const MinorModeArgumentsSchema: Type.TRecord<"^.*$", Type.TUnion<[Type.TString, Type.TNumber, Type.TBoolean]>>;
+type MinorModeArguments = Static<typeof MinorModeArgumentsSchema>;
+declare const MinorModeToolInputSchema: Type.TObject<{
+  action: Type.TUnion<[Type.TLiteral<"list">, Type.TLiteral<"invoke">]>;
+  source: Type.TOptional<Type.TString>;
+  id: Type.TOptional<Type.TString>;
+  ownerGeneration: Type.TOptional<Type.TString>;
+  registrationId: Type.TOptional<Type.TString>;
+  modeAction: Type.TOptional<Type.TString>;
+  arguments: Type.TOptional<Type.TRecord<"^.*$", Type.TUnion<[Type.TString, Type.TNumber, Type.TBoolean]>>>;
+}>;
+type MinorModeToolInput = Static<typeof MinorModeToolInputSchema>;
+declare const MinorModeToolResultSchema: Type.TUnknown;
+declare const MinorModeActionRequestSchema: Type.TObject<{
+  operationId: Type.TString;
+  mode: Type.TObject<{
+    source: Type.TString;
+    id: Type.TString;
+    ownerGeneration: Type.TString;
+    registrationId: Type.TString;
+  }>;
+  actionId: Type.TString;
+  arguments: Type.TRecord<"^.*$", Type.TUnion<[Type.TString, Type.TNumber, Type.TBoolean]>>;
+}>;
+type MinorModeActionRequest = Static<typeof MinorModeActionRequestSchema>;
+declare const MinorModeActionResponseSchema: Type.TObject<{
+  operationId: Type.TString;
+  catalogRevision: Type.TInteger;
+  mode: Type.TObject<{
+    descriptor: Type.TObject<{
+      source: Type.TString;
+      id: Type.TString;
+      label: Type.TString;
+      description: Type.TString;
+      order: Type.TInteger;
+      actions: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        label: Type.TString;
+        description: Type.TString;
+        contexts: Type.TArray<Type.TUnion<[Type.TLiteral<"tui">, Type.TLiteral<"headless">]>>;
+        parameters: Type.TArray<Type.TUnion<[Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"string">;
+          minLength: Type.TOptional<Type.TInteger>;
+          maxLength: Type.TOptional<Type.TInteger>;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"number">;
+          integer: Type.TOptional<Type.TBoolean>;
+          minimum: Type.TOptional<Type.TNumber>;
+          maximum: Type.TOptional<Type.TNumber>;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"boolean">;
+        }>, Type.TObject<{
+          name: Type.TString;
+          label: Type.TString;
+          description: Type.TOptional<Type.TString>;
+          required: Type.TBoolean;
+          kind: Type.TLiteral<"enum">;
+          choices: Type.TArray<Type.TObject<{
+            value: Type.TString;
+            label: Type.TString;
+          }>>;
+        }>]>>;
+      }>>;
+    }>;
+    state: Type.TObject<{
+      activation: Type.TUnion<[Type.TLiteral<"inactive">, Type.TLiteral<"activating">, Type.TLiteral<"active">, Type.TLiteral<"deactivating">]>;
+      condition: Type.TUnion<[Type.TLiteral<"ready">, Type.TLiteral<"paused">, Type.TLiteral<"blocked">, Type.TLiteral<"limited">, Type.TLiteral<"queued">, Type.TLiteral<"degraded">, Type.TLiteral<"failed">]>;
+      detail: Type.TOptional<Type.TString>;
+      color: Type.TOptional<Type.TUnion<[Type.TLiteral<"accent">, Type.TLiteral<"warning">, Type.TLiteral<"mdHeading">, Type.TLiteral<"muted">, Type.TLiteral<"dim">]>>;
+      modelContextVariant: Type.TOptional<Type.TString>;
+      actions: Type.TArray<Type.TObject<{
+        id: Type.TString;
+        enabled: Type.TBoolean;
+        disabledReason: Type.TOptional<Type.TString>;
+      }>>;
+    }>;
+    ownerGeneration: Type.TString;
+    registrationId: Type.TString;
+    stateRevision: Type.TInteger;
+  }>;
+  message: Type.TOptional<Type.TString>;
+}>;
+type MinorModeActionResponse = Static<typeof MinorModeActionResponseSchema>;
+/**
+ * The custom session entry the catalog host journals whenever its projection
+ * changes. It rides Pi's entry_appended frames, so any RPC client (the web
+ * cockpit) sees minor-mode state live and on replay without a new protocol.
+ */
+declare const DOOM_MINOR_MODE_ENTRY_TYPE = "doom-minor-modes";
+interface MinorModeActionProjection {
+  readonly id: string;
+  readonly label: string;
+  readonly description: string;
+  readonly enabled: boolean;
+  readonly disabledReason?: string;
+  /** Whether invoking it needs arguments a client must ask for first. */
+  readonly needsInput: boolean;
+}
+interface MinorModeRecordProjection {
+  readonly id: string;
+  readonly label: string;
+  readonly description: string;
+  readonly order: number;
+  readonly activation: MinorModeActivation;
+  readonly condition: MinorModeCondition;
+  readonly detail?: string;
+  readonly actions: readonly MinorModeActionProjection[];
+}
+interface MinorModeProjection {
+  readonly version: 1;
+  readonly revision: number;
+  readonly modes: readonly MinorModeRecordProjection[];
+}
+interface MinorModeOwnerActionResult {
+  message?: string;
+}
+interface MinorModeOwnerActionContext<ExtensionContext extends DoomExtensionContext> {
+  context: ExtensionContext;
+  operationId: string;
+  sessionKind: MinorModeSessionKind;
+  signal: AbortSignal;
+}
+interface MinorModeOwnerDefinition<ExtensionContext extends DoomExtensionContext> {
+  descriptor: MinorModeDescriptor;
+  initialState: MinorModeState;
+  handleAction(actionId: string, argumentsValue: MinorModeArguments, execution: MinorModeOwnerActionContext<ExtensionContext>): MinorModeOwnerActionResult | void | Promise<MinorModeOwnerActionResult | void>;
+  onError?(error: unknown): void;
+}
+interface MinorModeOwnerHandle {
+  getState(): MinorModeState;
+  publish(state: MinorModeState): void;
+  dispose(): void;
+}
+interface MinorModeInvokeOptions {
+  readonly signal?: AbortSignal;
+}
+/** Direct session-local catalog shared through Cordis. */
+interface MinorModeCatalogService {
+  readonly generation: string;
+  getSnapshot(): MinorModeCatalogSnapshot;
+  list(): MinorModeRecord[];
+  subscribe(listener: () => void): () => void;
+  registerOwner<ExtensionContext extends DoomExtensionContext>(definition: MinorModeOwnerDefinition<ExtensionContext>): MinorModeOwnerHandle;
+  invoke(request: MinorModeActionRequest, requesterSource: string, signal?: AbortSignal): Promise<MinorModeActionResponse>;
+  dispose(): void;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    'doom/minor-mode-catalog': MinorModeCatalogService;
+  }
+}
+declare function readMinorModeCatalog(context: Context): MinorModeCatalogService | undefined;
+declare function requireMinorModeCatalog(context: Context): MinorModeCatalogService;
+//#endregion
+export { MinorModeStateSchema as $, MinorModeCondition as A, MinorModeParameterNameSchema as B, MinorModeActivation as C, MinorModeCatalogService as D, MinorModeArgumentsSchema as E, MinorModeInvokeOptions as F, MinorModeRegistrationRef as G, MinorModeRecord as H, MinorModeOwnerActionContext as I, MinorModeScalarSchema as J, MinorModeRegistrationRefSchema as K, MinorModeOwnerActionResult as L, MinorModeDescriptor as M, MinorModeDescriptorSchema as N, MinorModeCatalogSnapshot as O, MinorModeIdSchema as P, MinorModeState as Q, MinorModeOwnerDefinition as R, MinorModeActionResponseSchema as S, MinorModeArguments as T, MinorModeRecordProjection as U, MinorModeProjection as V, MinorModeRecordSchema as W, MinorModeSessionKindSchema as X, MinorModeSessionKind as Y, MinorModeSourceSchema as Z, MinorModeActionParameterSchema as _, MINOR_MODE_ERROR_CODE as a, readMinorModeCatalog as at, MinorModeActionRequestSchema as b, MINOR_MODE_MAX_ENUM_CHOICES as c, MINOR_MODE_TOOL_NAME as d, MinorModeToolInput as et, MinorModeActionAvailability as f, MinorModeActionParameter as g, MinorModeActionDescriptorSchema as h, MINOR_MODE_CATALOG_SOURCE as i, ModeTextColorSchema as it, MinorModeConditionSchema as j, MinorModeCatalogSnapshotSchema as k, MINOR_MODE_MAX_PARAMETERS as l, MinorModeActionDescriptor as m, DOOM_MINOR_MODE_ENTRY_TYPE as n, MinorModeToolResultSchema as nt, MINOR_MODE_MAX_ACTIONS as o, requireMinorModeCatalog as ot, MinorModeActionAvailabilitySchema as p, MinorModeScalar as q, MINOR_MODE_ACTION_TIMEOUT_MS as r, ModeTextColor as rt, MINOR_MODE_MAX_ARGUMENT_LENGTH as s, DOOM_MINOR_MODE_CATALOG_SERVICE as t, MinorModeToolInputSchema as tt, MINOR_MODE_MAX_RECORDS as u, MinorModeActionProjection as v, MinorModeActivationSchema as w, MinorModeActionResponse as x, MinorModeActionRequest as y, MinorModeOwnerHandle as z };
+//# sourceMappingURL=mode-EZWqhrYy.d.mts.map

package/dist/mode-EZWqhrYy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-EZWqhrYy.d.mts","names":[],"sources":["../src/schemas/mode.ts"],"mappings":";;;;cAIa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cASA;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;cAGW,uBAAqB,KAAA;cAKrB,mBAAiB,KAAA;cAKjB,8BAA4B,KAAA;cAU5B,qBAAmB,KAAA,QAAA,KAAA,oBAAA,KAAA,qBAAA,KAAA,uBAAA,KAAA,mBAAA,KAAA;KAOpB,gBAAgB,cAAc;cAE7B,4BAA0B,KAAA,QAAA,KAAA,iBAAA,KAAA;KAC3B,uBAAuB,cAAc;cAEpC,2BAAyB,KAAA,QAAA,KAAA,sBAAA,KAAA,wBAAA,KAAA,oBAAA,KAAA;KAM1B,sBAAsB,cAAc;cAEnC,0BAAwB,KAAA,QAAA,KAAA,mBAAA,KAAA,oBAAA,KAAA,qBAAA,KAAA,qBAAA,KAAA,oBAAA,KAAA,sBAAA,KAAA;KASzB,qBAAqB,cAAc;cAElC,uBAAqB,KAAA,QAAA,KAAA,SAAA,KAAA,SAAA,KAAA;KAKtB,kBAAkB,cAAc;cAS/B,gCAA8B,KAAA,QAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuC/B,2BAA2B,cAAc;cAExC,iCAA+B,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUhC,4BAA4B,cAAc;cAEzC,2BAAyB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAW1B,sBAAsB,cAAc;cAEnC,mCAAiC,KAAA;;;;;KAQlC,8BAA8B,cAAc;cAE3C,sBAAoB,KAAA;;;;;;;;;;;;KAWrB,iBAAiB,cAAc;cAE9B,gCAA8B,KAAA;;;;;;KAS/B,2BAA2B,cAAc;cAExC,uBAAqB,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUtB,kBAAkB,cAAc;cAE/B,gCAA8B,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQ/B,2BAA2B,cAAc;cAExC,0BAAwB,KAAA,gBAAA,KAAA,QAAA,KAAA,SAAA,KAAA,SAAA,KAAA;KAGzB,qBAAqB,cAAc;cAElC,0BAAwB,KAAA;;;;;;;;;KAYzB,qBAAqB,cAAc;cAClC,2BAAyB,KAAA;cAEzB,8BAA4B,KAAA;;;;;;;;;;;KAS7B,yBAAyB,cAAc;cAEtC,+BAA6B,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAS9B,0BAA0B,cAAc;;;;;;cAOvC;UAEI;WACN;WACA;WACA;WACA;WACA;;WAEA;;UAGM;WACN;WACA;WACA;WACA;WACA,YAAY;WACZ,WAAW;WACX;WACA,kBAAkB;;UAGZ;WACN;WACA;WACA,gBAAgB;;UAGV;EACf;;UAGe,4BAA4B,yBAAyB;EACpE,SAAS;EACT;EACA,aAAa;EACb,QAAQ;;UAGO,yBAAyB,yBAAyB;EACjE,YAAY;EACZ,cAAc;EACd,aACE,kBACA,gBAAgB,oBAChB,WAAW,4BAA4B,oBACtC,oCAAoC,QAAQ;EAC/C,SAAS;;UAGM;EACf,YAAY;EACZ,QAAQ,OAAO;EACf;;UAGe;WACN,SAAS;;;UAIH;WACN;EACT,eAAe;EACf,QAAQ;EACR,UAAU;EACV,cAAc,yBAAyB,sBACrC,YAAY,yBAAyB,oBACpC;EACH,OACE,SAAS,wBACT,yBACA,SAAS,cACR,QAAQ;EACX;;;YAIU;IACR,2BAA2B;;;iBAIf,qBAAqB,SAAS,UAAU;iBAIxC,wBAAwB,SAAS,UAAU"}

package/dist/mode.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_mode = require("./mode-Dft08ke8.cjs");
+exports.DOOM_MINOR_MODE_CATALOG_SERVICE = require_mode.DOOM_MINOR_MODE_CATALOG_SERVICE;
+exports.DOOM_MINOR_MODE_ENTRY_TYPE = require_mode.DOOM_MINOR_MODE_ENTRY_TYPE;
+exports.MINOR_MODE_ACTION_TIMEOUT_MS = require_mode.MINOR_MODE_ACTION_TIMEOUT_MS;
+exports.MINOR_MODE_CATALOG_SOURCE = require_mode.MINOR_MODE_CATALOG_SOURCE;
+exports.MINOR_MODE_ERROR_CODE = require_mode.MINOR_MODE_ERROR_CODE;
+exports.MINOR_MODE_MAX_ACTIONS = require_mode.MINOR_MODE_MAX_ACTIONS;
+exports.MINOR_MODE_MAX_ARGUMENT_LENGTH = require_mode.MINOR_MODE_MAX_ARGUMENT_LENGTH;
+exports.MINOR_MODE_MAX_ENUM_CHOICES = require_mode.MINOR_MODE_MAX_ENUM_CHOICES;
+exports.MINOR_MODE_MAX_PARAMETERS = require_mode.MINOR_MODE_MAX_PARAMETERS;
+exports.MINOR_MODE_MAX_RECORDS = require_mode.MINOR_MODE_MAX_RECORDS;
+exports.MINOR_MODE_TOOL_NAME = require_mode.MINOR_MODE_TOOL_NAME;
+exports.MinorModeActionAvailabilitySchema = require_mode.MinorModeActionAvailabilitySchema;
+exports.MinorModeActionDescriptorSchema = require_mode.MinorModeActionDescriptorSchema;
+exports.MinorModeActionParameterSchema = require_mode.MinorModeActionParameterSchema;
+exports.MinorModeActionRequestSchema = require_mode.MinorModeActionRequestSchema;
+exports.MinorModeActionResponseSchema = require_mode.MinorModeActionResponseSchema;
+exports.MinorModeActivationSchema = require_mode.MinorModeActivationSchema;
+exports.MinorModeArgumentsSchema = require_mode.MinorModeArgumentsSchema;
+exports.MinorModeCatalogSnapshotSchema = require_mode.MinorModeCatalogSnapshotSchema;
+exports.MinorModeConditionSchema = require_mode.MinorModeConditionSchema;
+exports.MinorModeDescriptorSchema = require_mode.MinorModeDescriptorSchema;
+exports.MinorModeIdSchema = require_mode.MinorModeIdSchema;
+exports.MinorModeParameterNameSchema = require_mode.MinorModeParameterNameSchema;
+exports.MinorModeRecordSchema = require_mode.MinorModeRecordSchema;
+exports.MinorModeRegistrationRefSchema = require_mode.MinorModeRegistrationRefSchema;
+exports.MinorModeScalarSchema = require_mode.MinorModeScalarSchema;
+exports.MinorModeSessionKindSchema = require_mode.MinorModeSessionKindSchema;
+exports.MinorModeSourceSchema = require_mode.MinorModeSourceSchema;
+exports.MinorModeStateSchema = require_mode.MinorModeStateSchema;
+exports.MinorModeToolInputSchema = require_mode.MinorModeToolInputSchema;
+exports.MinorModeToolResultSchema = require_mode.MinorModeToolResultSchema;
+exports.ModeTextColorSchema = require_mode.ModeTextColorSchema;
+exports.readMinorModeCatalog = require_mode.readMinorModeCatalog;
+exports.requireMinorModeCatalog = require_mode.requireMinorModeCatalog;

package/dist/mode.d.mts

@@ -0,0 +1,2 @@
+import { $ as MinorModeStateSchema, A as MinorModeCondition, B as MinorModeParameterNameSchema, C as MinorModeActivation, D as MinorModeCatalogService, E as MinorModeArgumentsSchema, F as MinorModeInvokeOptions, G as MinorModeRegistrationRef, H as MinorModeRecord, I as MinorModeOwnerActionContext, J as MinorModeScalarSchema, K as MinorModeRegistrationRefSchema, L as MinorModeOwnerActionResult, M as MinorModeDescriptor, N as MinorModeDescriptorSchema, O as MinorModeCatalogSnapshot, P as MinorModeIdSchema, Q as MinorModeState, R as MinorModeOwnerDefinition, S as MinorModeActionResponseSchema, T as MinorModeArguments, U as MinorModeRecordProjection, V as MinorModeProjection, W as MinorModeRecordSchema, X as MinorModeSessionKindSchema, Y as MinorModeSessionKind, Z as MinorModeSourceSchema, _ as MinorModeActionParameterSchema, a as MINOR_MODE_ERROR_CODE, at as readMinorModeCatalog, b as MinorModeActionRequestSchema, c as MINOR_MODE_MAX_ENUM_CHOICES, d as MINOR_MODE_TOOL_NAME, et as MinorModeToolInput, f as MinorModeActionAvailability, g as MinorModeActionParameter, h as MinorModeActionDescriptorSchema, i as MINOR_MODE_CATALOG_SOURCE, it as ModeTextColorSchema, j as MinorModeConditionSchema, k as MinorModeCatalogSnapshotSchema, l as MINOR_MODE_MAX_PARAMETERS, m as MinorModeActionDescriptor, n as DOOM_MINOR_MODE_ENTRY_TYPE, nt as MinorModeToolResultSchema, o as MINOR_MODE_MAX_ACTIONS, ot as requireMinorModeCatalog, p as MinorModeActionAvailabilitySchema, q as MinorModeScalar, r as MINOR_MODE_ACTION_TIMEOUT_MS, rt as ModeTextColor, s as MINOR_MODE_MAX_ARGUMENT_LENGTH, t as DOOM_MINOR_MODE_CATALOG_SERVICE, tt as MinorModeToolInputSchema, u as MINOR_MODE_MAX_RECORDS, v as MinorModeActionProjection, w as MinorModeActivationSchema, x as MinorModeActionResponse, y as MinorModeActionRequest, z as MinorModeOwnerHandle } from "./mode-EZWqhrYy.mjs";
+export { DOOM_MINOR_MODE_CATALOG_SERVICE, DOOM_MINOR_MODE_ENTRY_TYPE, MINOR_MODE_ACTION_TIMEOUT_MS, MINOR_MODE_CATALOG_SOURCE, MINOR_MODE_ERROR_CODE, MINOR_MODE_MAX_ACTIONS, MINOR_MODE_MAX_ARGUMENT_LENGTH, MINOR_MODE_MAX_ENUM_CHOICES, MINOR_MODE_MAX_PARAMETERS, MINOR_MODE_MAX_RECORDS, MINOR_MODE_TOOL_NAME, MinorModeActionAvailability, MinorModeActionAvailabilitySchema, MinorModeActionDescriptor, MinorModeActionDescriptorSchema, MinorModeActionParameter, MinorModeActionParameterSchema, MinorModeActionProjection, MinorModeActionRequest, MinorModeActionRequestSchema, MinorModeActionResponse, MinorModeActionResponseSchema, MinorModeActivation, MinorModeActivationSchema, MinorModeArguments, MinorModeArgumentsSchema, MinorModeCatalogService, MinorModeCatalogSnapshot, MinorModeCatalogSnapshotSchema, MinorModeCondition, MinorModeConditionSchema, MinorModeDescriptor, MinorModeDescriptorSchema, MinorModeIdSchema, MinorModeInvokeOptions, MinorModeOwnerActionContext, MinorModeOwnerActionResult, MinorModeOwnerDefinition, MinorModeOwnerHandle, MinorModeParameterNameSchema, MinorModeProjection, MinorModeRecord, MinorModeRecordProjection, MinorModeRecordSchema, MinorModeRegistrationRef, MinorModeRegistrationRefSchema, MinorModeScalar, MinorModeScalarSchema, MinorModeSessionKind, MinorModeSessionKindSchema, MinorModeSourceSchema, MinorModeState, MinorModeStateSchema, MinorModeToolInput, MinorModeToolInputSchema, MinorModeToolResultSchema, ModeTextColor, ModeTextColorSchema, readMinorModeCatalog, requireMinorModeCatalog };

package/dist/mode.mjs

@@ -0,0 +1,2 @@
+import { A as MinorModeToolInputSchema, C as MinorModeParameterNameSchema, D as MinorModeSessionKindSchema, E as MinorModeScalarSchema, M as ModeTextColorSchema, N as readMinorModeCatalog, O as MinorModeSourceSchema, P as requireMinorModeCatalog, S as MinorModeIdSchema, T as MinorModeRegistrationRefSchema, _ as MinorModeActivationSchema, a as MINOR_MODE_ERROR_CODE, b as MinorModeConditionSchema, c as MINOR_MODE_MAX_ENUM_CHOICES, d as MINOR_MODE_TOOL_NAME, f as MinorModeActionAvailabilitySchema, g as MinorModeActionResponseSchema, h as MinorModeActionRequestSchema, i as MINOR_MODE_CATALOG_SOURCE, j as MinorModeToolResultSchema, k as MinorModeStateSchema, l as MINOR_MODE_MAX_PARAMETERS, m as MinorModeActionParameterSchema, n as DOOM_MINOR_MODE_ENTRY_TYPE, o as MINOR_MODE_MAX_ACTIONS, p as MinorModeActionDescriptorSchema, r as MINOR_MODE_ACTION_TIMEOUT_MS, s as MINOR_MODE_MAX_ARGUMENT_LENGTH, t as DOOM_MINOR_MODE_CATALOG_SERVICE, u as MINOR_MODE_MAX_RECORDS, v as MinorModeArgumentsSchema, w as MinorModeRecordSchema, x as MinorModeDescriptorSchema, y as MinorModeCatalogSnapshotSchema } from "./mode-BwRkDqO4.mjs";
+export { DOOM_MINOR_MODE_CATALOG_SERVICE, DOOM_MINOR_MODE_ENTRY_TYPE, MINOR_MODE_ACTION_TIMEOUT_MS, MINOR_MODE_CATALOG_SOURCE, MINOR_MODE_ERROR_CODE, MINOR_MODE_MAX_ACTIONS, MINOR_MODE_MAX_ARGUMENT_LENGTH, MINOR_MODE_MAX_ENUM_CHOICES, MINOR_MODE_MAX_PARAMETERS, MINOR_MODE_MAX_RECORDS, MINOR_MODE_TOOL_NAME, MinorModeActionAvailabilitySchema, MinorModeActionDescriptorSchema, MinorModeActionParameterSchema, MinorModeActionRequestSchema, MinorModeActionResponseSchema, MinorModeActivationSchema, MinorModeArgumentsSchema, MinorModeCatalogSnapshotSchema, MinorModeConditionSchema, MinorModeDescriptorSchema, MinorModeIdSchema, MinorModeParameterNameSchema, MinorModeRecordSchema, MinorModeRegistrationRefSchema, MinorModeScalarSchema, MinorModeSessionKindSchema, MinorModeSourceSchema, MinorModeStateSchema, MinorModeToolInputSchema, MinorModeToolResultSchema, ModeTextColorSchema, readMinorModeCatalog, requireMinorModeCatalog };

package/dist/modeDefinition-BcqEwTzh.mjs

@@ -0,0 +1,46 @@
+//#region src/services/modeDefinition/index.ts
+/** Shares one typed mode definition across Pi and session-server owners. */
+function defineMinorMode(mode) {
+	return {
+		descriptor: mode.descriptor,
+		createOwner(runtime) {
+			let handle;
+			const listeners = /* @__PURE__ */ new Set();
+			const state = () => mode.state(runtime);
+			const publish = () => {
+				handle?.publish(state());
+				listeners.forEach((listener) => listener());
+			};
+			return {
+				definition: {
+					descriptor: mode.descriptor,
+					initialState: state(),
+					async handleAction(actionId, args, execution) {
+						execution.signal.throwIfAborted();
+						const result = await mode.handleAction(runtime, actionId, args, execution);
+						publish();
+						return result;
+					}
+				},
+				state,
+				publish,
+				attach: (owner) => {
+					handle = owner;
+				},
+				detach: () => {
+					handle = void 0;
+				},
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { defineMinorMode as t };
+
+//# sourceMappingURL=modeDefinition-BcqEwTzh.mjs.map

package/dist/modeDefinition-BcqEwTzh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeDefinition-BcqEwTzh.mjs","names":[],"sources":["../src/services/modeDefinition/index.ts"],"sourcesContent":["import type {\n  MinorModeArguments,\n  MinorModeDescriptor,\n  MinorModeOwnerActionResult,\n  MinorModeOwnerHandle,\n  MinorModeState,\n} from '../../schemas/mode';\n\nexport interface MinorModeExecution {\n  readonly signal: AbortSignal;\n}\n\nexport interface MinorModeDefinition<TRuntime, TExecution extends MinorModeExecution = MinorModeExecution> {\n  readonly descriptor: MinorModeDescriptor;\n  state(runtime: TRuntime): MinorModeState;\n  handleAction(\n    runtime: TRuntime,\n    actionId: string,\n    argumentsValue: MinorModeArguments,\n    execution: TExecution,\n  ): MinorModeOwnerActionResult | void | Promise<MinorModeOwnerActionResult | void>;\n}\n\nexport interface MinorModeOwner<TExecution extends MinorModeExecution = MinorModeExecution> {\n  readonly definition: {\n    readonly descriptor: MinorModeDescriptor;\n    readonly initialState: MinorModeState;\n    handleAction(\n      actionId: string,\n      argumentsValue: MinorModeArguments,\n      execution: TExecution,\n    ): Promise<MinorModeOwnerActionResult | void>;\n  };\n  state(): MinorModeState;\n  publish(): void;\n  attach(handle: MinorModeOwnerHandle): void;\n  detach(): void;\n  subscribe(listener: () => void): () => void;\n}\n\nexport interface DefinedMinorMode<TRuntime, TExecution extends MinorModeExecution = MinorModeExecution> {\n  readonly descriptor: MinorModeDescriptor;\n  createOwner(runtime: TRuntime): MinorModeOwner<TExecution>;\n}\n\n/** Shares one typed mode definition across Pi and session-server owners. */\nexport function defineMinorMode<TRuntime, TExecution extends MinorModeExecution = MinorModeExecution>(\n  mode: MinorModeDefinition<TRuntime, TExecution>,\n): DefinedMinorMode<TRuntime, TExecution> {\n  return {\n    descriptor: mode.descriptor,\n    createOwner(runtime: TRuntime): MinorModeOwner<TExecution> {\n      let handle: MinorModeOwnerHandle | undefined;\n      const listeners = new Set<() => void>();\n      const state = (): MinorModeState => mode.state(runtime);\n      const publish = (): void => {\n        handle?.publish(state());\n        listeners.forEach((listener) => listener());\n      };\n      return {\n        definition: {\n          descriptor: mode.descriptor,\n          initialState: state(),\n          async handleAction(actionId: string, args: MinorModeArguments, execution: TExecution) {\n            execution.signal.throwIfAborted();\n            const result = await mode.handleAction(runtime, actionId, args, execution);\n            publish();\n            return result;\n          },\n        },\n        state,\n        publish,\n        attach: (owner: MinorModeOwnerHandle) => {\n          handle = owner;\n        },\n        detach: () => {\n          handle = undefined;\n        },\n        subscribe(listener) {\n          listeners.add(listener);\n          return () => {\n            listeners.delete(listener);\n          };\n        },\n      };\n    },\n  };\n}\n"],"mappings":";;AA8CA,SAAgB,gBACd,MACwC;CACxC,OAAO;EACL,YAAY,KAAK;EACjB,YAAY,SAA+C;GACzD,IAAI;GACJ,MAAM,4BAAY,IAAI,IAAgB;GACtC,MAAM,cAA8B,KAAK,MAAM,OAAO;GACtD,MAAM,gBAAsB;IAC1B,QAAQ,QAAQ,MAAM,CAAC;IACvB,UAAU,SAAS,aAAa,SAAS,CAAC;GAC5C;GACA,OAAO;IACL,YAAY;KACV,YAAY,KAAK;KACjB,cAAc,MAAM;KACpB,MAAM,aAAa,UAAkB,MAA0B,WAAuB;MACpF,UAAU,OAAO,eAAe;MAChC,MAAM,SAAS,MAAM,KAAK,aAAa,SAAS,UAAU,MAAM,SAAS;MACzE,QAAQ;MACR,OAAO;KACT;IACF;IACA;IACA;IACA,SAAS,UAAgC;KACvC,SAAS;IACX;IACA,cAAc;KACZ,SAAS,KAAA;IACX;IACA,UAAU,UAAU;KAClB,UAAU,IAAI,QAAQ;KACtB,aAAa;MACX,UAAU,OAAO,QAAQ;KAC3B;IACF;GACF;EACF;CACF;AACF"}

package/dist/modeDefinition-BtgwqXMo.cjs

@@ -0,0 +1,51 @@
+//#region src/services/modeDefinition/index.ts
+/** Shares one typed mode definition across Pi and session-server owners. */
+function defineMinorMode(mode) {
+	return {
+		descriptor: mode.descriptor,
+		createOwner(runtime) {
+			let handle;
+			const listeners = /* @__PURE__ */ new Set();
+			const state = () => mode.state(runtime);
+			const publish = () => {
+				handle?.publish(state());
+				listeners.forEach((listener) => listener());
+			};
+			return {
+				definition: {
+					descriptor: mode.descriptor,
+					initialState: state(),
+					async handleAction(actionId, args, execution) {
+						execution.signal.throwIfAborted();
+						const result = await mode.handleAction(runtime, actionId, args, execution);
+						publish();
+						return result;
+					}
+				},
+				state,
+				publish,
+				attach: (owner) => {
+					handle = owner;
+				},
+				detach: () => {
+					handle = void 0;
+				},
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				}
+			};
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "defineMinorMode", {
+	enumerable: true,
+	get: function() {
+		return defineMinorMode;
+	}
+});
+
+//# sourceMappingURL=modeDefinition-BtgwqXMo.cjs.map