@makaio/framework 1.0.0-dev-1779046984397

package/dist/index-6lyShOoU.d.mts

@@ -0,0 +1,225 @@
+import * as _$zod from "zod";
+import { z } from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+import { IWorkflowTriggerTypeRegistry } from "@makaio/framework/contracts";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region packages/kernel/src/namespace/kernel-schemas.d.ts
+/**
+ * Kernel domain schemas.
+ *
+ * Provides subjects for kernel introspection and lifecycle signalling.
+ * Plugin/extension discovery has moved to the `kernel:extension.*` namespace
+ * served by the ExtensionCoordinator.
+ */
+declare const KernelSchemas: {
+  /**
+   * Probe kernel readiness state.
+   *
+   * Subject: `kernel.isReady`
+   * Type: Request (RPC)
+   * Purpose: Allows clients that connect after startup to query readiness
+   *          without waiting for the one-time `kernel.ready` event.
+   */
+  isReady: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      ready: z.ZodBoolean;
+      machineId: z.ZodString;
+    }, z.core.$strip>;
+  };
+  /**
+   * Signal that the bus has been created and is ready for use.
+   *
+   * Subject: `kernel.phase.busCreated`
+   * Type: Event (fire-and-forget)
+   * Purpose: Emitted immediately after bus creation so early external observers
+   *          (e.g., transport bridges) can attach before config or services start.
+   */
+  'phase.busCreated': z.ZodObject<{
+    machineId: z.ZodString;
+  }, z.core.$strip>;
+  /**
+   * Signal that the bus, config service, and runtime-host resource handlers are ready.
+   *
+   * Subject: `kernel.phase.coreReady`
+   * Type: Event (fire-and-forget)
+   * Purpose: Emitted after bus creation, config service registration, and runtime
+   *          resource provider registration — before lifecycle wiring begins.
+   *          External transports (e.g., WebSocket bus server) hook in here so they
+   *          have bus and machine identity but are available before full service readiness.
+   */
+  'phase.coreReady': z.ZodObject<{
+    machineId: z.ZodString;
+  }, z.core.$strip>;
+  /**
+   * Signal that lifecycle wiring and lifecycle.start have completed.
+   *
+   * Subject: `kernel.phase.servicesReady`
+   * Type: Event (fire-and-forget)
+   * Purpose: Emitted after `startLifecycleWiring` and `lifecycle.start` complete.
+   *          All core services are registered and ready to handle requests at this point.
+   */
+  'phase.servicesReady': z.ZodObject<{
+    machineId: z.ZodString;
+  }, z.core.$strip>;
+  /**
+   * Lifecycle barrier emitted after the extension coordinator has started all
+   * loaded packages.
+   *
+   * Subject: `kernel.phase.coordinatorReady`
+   * Type: Broadcast request
+   * Purpose: Allows host-owned integrations to finish post-coordinator wiring
+   *          before the kernel announces full readiness.
+   */
+  'phase.coordinatorReady': _$_makaio_core0.LocalSubjectSchema<{
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{}, z.core.$strip>;
+  }>;
+  /**
+   * Signal that the kernel has completed initialization.
+   *
+   * Subject: `kernel.ready`
+   * Type: Event (fire-and-forget)
+   * Purpose: SharedWorker waits for this before considering the backend ready.
+   *          Eliminates the handler registration race where tabs send requests
+   *          before registerRuntimeHandlers() completes.
+   */
+  ready: z.ZodObject<{
+    machineId: z.ZodString;
+  }, z.core.$strip>;
+  /**
+   * Notify observers that lifecycle wiring has completed.
+   *
+   * Subject: `kernel.lifecycle.start`
+   * Type: Request (RPC)
+   * Purpose: Used as an observability/synchronization hook.
+   *          Package startup is performed by the extension coordinator, not by
+   *          handlers on this subject.
+   */
+  'lifecycle.start': {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{}, z.core.$strip>;
+  };
+  /**
+   * Notify observers that lifecycle wiring shutdown has completed.
+   *
+   * Subject: `kernel.lifecycle.shutdown`
+   * Type: Request (RPC)
+   * Purpose: Used as an observability/synchronization hook.
+   *          Package teardown is performed by the extension coordinator, not by
+   *          handlers on this subject.
+   */
+  'lifecycle.shutdown': {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{}, z.core.$strip>;
+  };
+};
+//#endregion
+//#region packages/kernel/src/namespace/index.d.ts
+/**
+ * Kernel namespace for bus operations.
+ */
+declare const KernelNamespace: _$_makaio_core0.BusNamespaceDefinition<"kernel", {
+  isReady: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      ready: _$zod.ZodBoolean;
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+  };
+  'phase.busCreated': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.coreReady': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.servicesReady': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.coordinatorReady': _$_makaio_core0.LocalSubjectSchema<{
+    request: _$zod.ZodObject<{
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  }>;
+  ready: _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'lifecycle.start': {
+    request: _$zod.ZodObject<{
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  };
+  'lifecycle.shutdown': {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  };
+}>;
+/**
+ * Kernel subjects for type-safe bus operations.
+ *
+ * Subjects:
+ * - isReady: Probe kernel readiness state (RPC)
+ * - phase.busCreated: Signal that the bus has been created (event)
+ * - phase.coreReady: Signal that bus, config, and runtime-host resource handlers are ready (event)
+ * - phase.servicesReady: Signal that lifecycle wiring and lifecycle.start have completed (event)
+ * - phase.coordinatorReady: Barrier after extension coordinator has started all packages (broadcast RPC)
+ * - ready: Signal full kernel initialization complete (event)
+ * - lifecycle.start: Observability hook — lifecycle wiring complete (RPC)
+ * - lifecycle.shutdown: Observability hook — lifecycle shutdown complete (RPC)
+ */
+declare const KernelSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"kernel", {
+  isReady: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      ready: _$zod.ZodBoolean;
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+  };
+  'phase.busCreated': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.coreReady': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.servicesReady': _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'phase.coordinatorReady': _$_makaio_core0.LocalSubjectSchema<{
+    request: _$zod.ZodObject<{
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  }>;
+  ready: _$zod.ZodObject<{
+    machineId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strip>;
+  'lifecycle.start': {
+    request: _$zod.ZodObject<{
+      machineId: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  };
+  'lifecycle.shutdown': {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+  };
+}>, "kernel">;
+/**
+ * Set the workflow trigger type registry reference.
+ * @param value - Workflow trigger type registry instance or undefined.
+ */
+declare function setWorkflowTriggerTypeRegistry(value: IWorkflowTriggerTypeRegistry | undefined): void;
+/**
+ * Get the workflow trigger type registry reference.
+ * @returns Workflow trigger type registry instance or undefined.
+ */
+declare function getWorkflowTriggerTypeRegistry(): IWorkflowTriggerTypeRegistry | undefined;
+//#endregion
+export { KernelSchemas as a, setWorkflowTriggerTypeRegistry as i, KernelSubjects as n, getWorkflowTriggerTypeRegistry as r, KernelNamespace as t };

package/dist/index-7sXlairn2.d.mts

@@ -0,0 +1,43 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { BaseService } from "@makaio/framework/service-base";
+
+//#region packages/services/core/src/tray-menu/tray-menu-service.d.ts
+/**
+ * In-memory registry for package-contributed tray menu entries.
+ *
+ * Registrations are idempotent and keyed by owning package. The service owns
+ * tray menu state for every host surface; renderers consume it through the
+ * `host:tray.list` RPC and observe mutations through `host:tray.changed`.
+ */
+declare class TrayMenuService extends BaseService {
+  /** Dependency tokens required before this service. */
+  static readonly needs: readonly [];
+  static readonly critical: true;
+  /**
+   * Factory for DI container startup.
+   * @param ctx - Start context providing the bus
+   * @returns Initialized TrayMenuService instance
+   */
+  static create(ctx: {
+    bus: IMakaioBus;
+  }): Promise<TrayMenuService>;
+  private readonly entries;
+  private readonly groups;
+  private readonly groupEntryIds;
+  /**
+   * Create a tray menu service.
+   * @param bus - Bus instance used for tray menu subjects
+   */
+  constructor(bus: IMakaioBus);
+  protected onInit(): void;
+  protected onDestroy(): void;
+  private listEntries;
+  private assertEntryCanRegister;
+  private assertGroupCanRegister;
+  private collectGroupEntryIds;
+  private emitChanged;
+  private entryKey;
+  private groupKey;
+}
+//#endregion
+export { TrayMenuService as t };