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

package/dist/index-CokQYGVP.d.mts

@@ -0,0 +1,184 @@
+import { RequestMessagePayload, SubjectDefinition } from "@makaio/framework/core";
+import { IMakaioBus } from "@makaio/framework/bus";
+import { SQLiteColumn, SQLiteTable } from "drizzle-orm/sqlite-core";
+import { Column, SQL } from "drizzle-orm";
+import { MakaioDatabase } from "@makaio/framework/storage/drizzle";
+
+//#region storage/handlers/src/drizzle/types.d.ts
+type RequestSubjectDefinition<Req extends Record<string, unknown>, Res extends Record<string, unknown>> = SubjectDefinition & {
+  $meta: {
+    payload: RequestMessagePayload<Req, Res>;
+  };
+};
+type EventSubjectDefinition<Payload> = SubjectDefinition & {
+  $meta: {
+    payload: Payload;
+  };
+};
+type TableRow<TTable extends SQLiteTable> = TTable['$inferSelect'];
+type TableInsert<TTable extends SQLiteTable> = TTable['$inferInsert'];
+type ColumnKey<TTable extends SQLiteTable> = Extract<keyof TTable['_']['columns'], string>;
+type TimestampedRow = {
+  createdAt: number;
+  updatedAt: number;
+};
+type TimestampedTable<TTable extends SQLiteTable> = TableRow<TTable> extends TimestampedRow ? TTable : never;
+/**
+ * Lifecycle event subjects for CRUD operations.
+ * @typeParam TEntity - API entity type emitted for create/update events
+ */
+interface CrudLifecycleConfig<TEntity> {
+  /** Emitted when a new entity is inserted */
+  created: EventSubjectDefinition<TEntity>;
+  /** Emitted when an existing entity is updated */
+  updated: EventSubjectDefinition<TEntity>;
+  /** Emitted when an entity is deleted */
+  deleted: EventSubjectDefinition<{
+    id: string;
+  }>;
+}
+/**
+ * Configuration for creating standard CRUD handlers.
+ *
+ * Type safety is enforced at the call site and validated at runtime through Zod schemas.
+ * @typeParam TTable - Drizzle SQLite table type (unconstrained for flexibility)
+ * @typeParam ApiType - API response entity type
+ * @typeParam InputType - API input entity type (defaults to ApiType)
+ * @typeParam DbRow - Database row type (explicitly specified for type safety)
+ */
+interface DrizzleCrudConfig<TTable extends SQLiteTable, ApiType, TIdField extends ColumnKey<TTable> = ColumnKey<TTable>, InputType extends Record<TIdField, string> & Record<string, unknown> = (ApiType extends Record<TIdField, string> ? ApiType : Record<TIdField, string> & Record<string, unknown>), TSingularKey extends string = string> {
+  /** Drizzle table definition */
+  table: TimestampedTable<TTable>;
+  /** Storage subjects object with get, set, delete properties */
+  subjects: {
+    /** Subject for getting a single entity by ID */get: RequestSubjectDefinition<{
+      id: string;
+    }, Record<TSingularKey, ApiType | null>>; /** Subject for creating or updating an entity */
+    set: RequestSubjectDefinition<Record<TSingularKey, InputType>, {
+      id: string;
+    }>; /** Subject for deleting an entity by ID */
+    delete: RequestSubjectDefinition<{
+      id: string;
+    }, {
+      deleted: boolean;
+    }>;
+  };
+  /** Primary key field name on the table */
+  idField: TIdField;
+  /** Response key for single entity (e.g., 'profile') */
+  singularKey: TSingularKey;
+  /** Maps database row to API type */
+  mapper: (row: TableRow<TTable>) => ApiType;
+  /** Maps API input to database values for insert/update */
+  toDbValues: (input: InputType) => Partial<TableInsert<TTable>>;
+  /**
+   * Optional conflict target columns for upsert identity.
+   *
+   * Defaults to the primary key column ({@link idField}). Override this when
+   * the table has a natural-key unique index that should govern upsert identity
+   * instead of the synthetic PK. The callback receives the table so callers can
+   * reference column objects directly.
+   *
+   * **PK mutation:** When a conflict fires on the natural key and the incoming
+   * `id` differs from the stored PK, the handler updates the PK column to the
+   * incoming `id` (and returns it). Callers that enable this option must
+   * tolerate non-stable primary keys across upserts.
+   * @example
+   * ```ts
+   * // extension_configs has uniqueIndex('uniq_extension_configs_name_scope')
+   * conflictTarget: (t) => [t.extensionName, t.scope],
+   * ```
+   */
+  conflictTarget?: (table: TTable) => (SQLiteColumn | SQL)[];
+  /**
+   * Optional lifecycle event configuration.
+   *
+   * When provided, the factory emits created/updated/deleted events after
+   * successful mutations via wrapper handlers.
+   */
+  lifecycle?: CrudLifecycleConfig<ApiType>;
+}
+/**
+ * Configuration for creating a list handler.
+ *
+ * Type safety is enforced at the call site and validated at runtime through Zod schemas.
+ * @typeParam TTable - Drizzle SQLite table type (unconstrained for flexibility)
+ * @typeParam ApiType - API response entity type
+ * @typeParam QueryPayload - Query payload type
+ * @typeParam DbRow - Database row type (explicitly specified for type safety)
+ */
+interface DrizzleListConfig<TTable extends SQLiteTable, ApiType, QueryPayload extends Record<string, unknown> = Record<string, unknown>, TPluralKey extends string = string, TSubject extends RequestSubjectDefinition<QueryPayload, Record<TPluralKey, ApiType[]>> = RequestSubjectDefinition<QueryPayload, Record<TPluralKey, ApiType[]>>> {
+  /** Drizzle table definition */
+  table: TTable;
+  /** List subject from storage namespace */
+  subject: TSubject;
+  /** Response key for entity array (e.g., 'profiles') */
+  pluralKey: TPluralKey;
+  /** Maps database row to API type */
+  mapper: (row: TableRow<TTable>) => ApiType;
+  /** Builds query predicates from payload */
+  buildPredicates: (payload: QueryPayload, table: TTable) => SQL[];
+}
+//#endregion
+//#region storage/handlers/src/drizzle/crud-handlers.d.ts
+/**
+ * Creates standard get, set, delete handlers for a Drizzle table.
+ * @param config - CRUD handler configuration.
+ * @returns Function that registers handlers and returns cleanup.
+ */
+declare function createDrizzleCrudHandlers<TTable extends SQLiteTable, ApiType extends Record<string, unknown>, TIdField extends Extract<keyof TTable['_']['columns'], string> = Extract<keyof TTable['_']['columns'], string>, InputType extends Record<TIdField, string> & Record<string, unknown> = (ApiType extends Record<TIdField, string> ? ApiType : Record<TIdField, string> & Record<string, unknown>), TSingularKey extends string = string>(config: DrizzleCrudConfig<TTable, ApiType, TIdField, InputType, TSingularKey>): (bus: IMakaioBus, db: MakaioDatabase) => () => void;
+//#endregion
+//#region storage/handlers/src/drizzle/list-handler.d.ts
+/**
+ * Creates a list handler with customizable query predicates.
+ *
+ * Type safety is maintained at the call site through DrizzleListConfig type
+ * parameters and runtime Zod schema validation.
+ * @param config - List handler configuration
+ * @returns Function that registers the handler and returns cleanup
+ * @example
+ * ```typescript
+ * const registerList = createDrizzleListHandler({
+ *   table: profileDefinitions,
+ *   subject: ProfileStorageSubjects.list,
+ *   pluralKey: 'profiles',
+ *   mapper: mapProfile,
+ *   buildPredicates: (payload, table) => [
+ *     ...buildScopePredicates(table, payload.projectId),
+ *     ...(payload.name ? [eq(table.name, payload.name)] : []),
+ *   ],
+ * });
+ *
+ * const cleanup = registerList(bus, db);
+ * ```
+ */
+declare function createDrizzleListHandler<TTable extends SQLiteTable, ApiType, QueryPayload extends Record<string, unknown> = Record<string, unknown>, TPluralKey extends string = string>(config: DrizzleListConfig<TTable, ApiType, QueryPayload, TPluralKey>): (bus: IMakaioBus, db: MakaioDatabase) => () => void;
+//#endregion
+//#region storage/handlers/src/drizzle/scope-predicates.d.ts
+/**
+ * Table with a scope column for two-tier scoping.
+ */
+interface ScopeTable {
+  /** Scope column for filtering (default or projectId) */
+  scope: Column;
+}
+/**
+ * Builds standard scope predicates for two-tier scoping (default | projectId).
+ *
+ * When projectId is provided: returns both default and project-scoped entities.
+ * When projectId is undefined: returns only default-scoped entities.
+ * @param table - Table with 'scope' column
+ * @param projectId - Optional project ID for scoping
+ * @returns Array of SQL predicates
+ * @example
+ * ```typescript
+ * const predicates = buildScopePredicates(profileDefinitions, 'proj-123');
+ * // Returns: [inArray(profileDefinitions.scope, ['default', 'proj-123'])]
+ *
+ * const predicates = buildScopePredicates(profileDefinitions, undefined);
+ * // Returns: [eq(profileDefinitions.scope, 'default')]
+ * ```
+ */
+declare function buildScopePredicates<T extends ScopeTable>(table: T, projectId: string | undefined): SQL[];
+//#endregion
+export { DrizzleCrudConfig as a, CrudLifecycleConfig as i, createDrizzleListHandler as n, DrizzleListConfig as o, createDrizzleCrudHandlers as r, buildScopePredicates as t };

package/dist/index-Cs0kZXIz2.d.mts

@@ -0,0 +1,37 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { ICapabilityProvider } from "@makaio/framework/contracts";
+import { BaseService } from "@makaio/framework/service-base";
+
+//#region services/core/src/capability/capability-service.d.ts
+/**
+ * Service managing capability provider registration and discovery.
+ *
+ * Listens for `capability.register` events from extensions and maintains
+ * the registry of providers per capability. Handles generic capability
+ * operations (listProviders, validate).
+ */
+declare class CapabilityService extends BaseService {
+  private readonly providers;
+  constructor(bus: IMakaioBus);
+  protected onInit(): Promise<void>;
+  private handleRegister;
+  private handleUnregister;
+  /**
+   * Remove a provider from a capability bucket.
+   * @param capabilityId - Capability bucket to update
+   * @param providerId - Provider identifier to remove
+   */
+  unregisterProvider(capabilityId: string, providerId: string): void;
+  getProviders(capabilityId: string): ICapabilityProvider[];
+  hasProviders(capabilityId: string): boolean;
+  getCapabilities(): string[];
+  validateAll(capabilityId: string): Promise<Array<{
+    id: string;
+    valid: boolean;
+    error?: string;
+  }>>;
+  protected onDestroy(): void;
+  clear(): void;
+}
+//#endregion
+export { CapabilityService as t };

package/dist/index-D5d5HeWI2.d.mts

@@ -0,0 +1,259 @@
+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>;
+  };
+  /**
+   * Request a host restart.
+   *
+   * Subject: `kernel.restart`
+   * Type: Request (RPC)
+   * Purpose: Allows remote callers (e.g., a setup wizard) to request that the
+   *          host process shut down and restart. The host decides whether to
+   *          accept; a declined restart returns `{ accepted: false }`.
+   */
+  restart: {
+    request: z.ZodObject<{
+      reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      accepted: z.ZodBoolean;
+    }, 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>;
+  };
+  restart: {
+    request: _$zod.ZodObject<{
+      reason: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      accepted: _$zod.ZodBoolean;
+    }, _$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)
+ * - restart: Request a host restart (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>;
+  };
+  restart: {
+    request: _$zod.ZodObject<{
+      reason: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      accepted: _$zod.ZodBoolean;
+    }, _$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 };