Refactor ObjectKernel integration; update plugin usage and documentation across runtime and objectql packages

Author: hotlong

content/docs/developers/mini-kernel.mdx

@@ -41,41 +41,44 @@ The MiniKernel architecture enables:
 
 The kernel manages plugin lifecycle and provides core services.
 
-**Location:** `packages/runtime/src/mini-kernel.ts`
+**Location:** `packages/core/src/kernel.ts`
 
 **API:**
 ```typescript
-import { ObjectKernel } from '@objectstack/runtime';
+import { ObjectKernel } from '@objectstack/core';
+import { ObjectQLPlugin, DriverPlugin } from '@objectstack/runtime';
 
 const kernel = new ObjectKernel();
 
 // Register plugins
-kernel.use(plugin);
+kernel.use(new ObjectQLPlugin())
+      .use(new DriverPlugin(driver, 'memory'));
 
 // Start the kernel
 await kernel.bootstrap();
 
 // Access services
-const ql = kernel.getService('objectql');
+const ql = kernel.context.getService('objectql'); // Or via getKernel() if exposed
 
 // Shutdown
-await kernel.shutdown();
+// await kernel.shutdown(); // (Future)
 ```
 
 ### 2. Plugin Interface
 
 All plugins must implement the Plugin interface.
 
-**Location:** `packages/runtime/src/types.ts`
+**Location:** `packages/core/src/types.ts`
 
 **Definition:**
 ```typescript
 interface Plugin {
   name: string;
+  version?: string;
   dependencies?: string[];
-  init(ctx: PluginContext): Promise<void>;
-  start?(ctx: PluginContext): Promise<void>;
-  destroy?(): Promise<void>;
+  init?(ctx: PluginContext): Promise<void> | void;
+  start?(ctx: PluginContext): Promise<void> | void;
+  destroy?(): Promise<void> | void;
 }
 ```
 

packages/core/README.md

@@ -0,0 +1,41 @@
+# @objectstack/core
+
+The Microkernel for the ObjectStack Operating System.
+
+## Overview
+
+This package defines the fundamental runtime mechanics of the ObjectStack architecture:
+1.  **Dependency Injection (DI)**: A `services` registry.
+2.  **Plugin Lifecycle**: `init` (Registration) -> `start` (Execution).
+3.  **Event Bus**: Simple hook system (`hook`, `trigger`).
+
+It is completely agnostic of "Data", "HTTP", or "Apps". It only knows `Plugin` and `Service`.
+
+## Installation
+
+```bash
+npm install @objectstack/core
+```
+
+## Usage
+
+```typescript
+import { ObjectKernel, Plugin, PluginContext } from '@objectstack/core';
+
+// 1. Define a Plugin
+class MyPlugin implements Plugin {
+    name = 'my-plugin';
+    
+    async init(ctx: PluginContext) {
+        ctx.registerService('my-service', { hello: 'world' });
+    }
+}
+
+// 2. Boot Kernel
+const kernel = new ObjectKernel();
+kernel.use(new MyPlugin());
+await kernel.bootstrap();
+
+// 3. Use Service
+const service = kernel.context.getService('my-service');
+```

packages/objectql/README.md

@@ -12,16 +12,18 @@
 
 ## Usage
 
+### 1. Standalone Usage
+
 ```typescript
 import { ObjectQL } from '@objectstack/objectql';
-import { MemoryDriver } from '@objectstack/driver-memory'; // Example driver
+import { InMemoryDriver } from '@objectstack/driver-memory'; // Note: Package name might export InMemoryDriver now
 
 async function main() {
   // 1. Initialize Engine
   const ql = new ObjectQL();
 
   // 2. Register Drivers
-  const memDriver = new MemoryDriver({ name: 'default' });
+  const memDriver = new InMemoryDriver({ name: 'default' });
   ql.registerDriver(memDriver, true);
 
   // 3. Load Schema (via Plugin/Manifest)
@@ -61,6 +63,26 @@ async function main() {
 }
 ```
 
+### 2. Using with ObjectKernel (Recommended)
+
+When building full applications, use the `ObjectKernel` to manage plugins and configuration.
+
+```typescript
+import { ObjectKernel } from '@objectstack/core';
+import { ObjectQLPlugin, DriverPlugin } from '@objectstack/runtime';
+import { InMemoryDriver } from '@objectstack/driver-memory';
+
+const kernel = new ObjectKernel();
+
+// Register Engine and Drivers as Kernel Plugins
+kernel.use(new ObjectQLPlugin())
+      .use(new DriverPlugin(new InMemoryDriver(), 'default'));
+
+await kernel.bootstrap();
+
+// The engine automatically discovers drivers and apps registered in the kernel.
+```
+
 ## Architecture
 
 - **SchemaRegistry**: Central store for all metadata (Objects, Apps, Config).

packages/runtime/README.md

@@ -1,21 +1,16 @@
 # @objectstack/runtime
 
-ObjectStack Core Runtime & Query Engine
+ObjectStack Standard System Library
 
 ## Overview
 
-The runtime package provides the `ObjectKernel` (MiniKernel) - a highly modular, plugin-based microkernel that orchestrates ObjectStack applications. It manages the application lifecycle through a standardized plugin system with dependency injection and event hooks.
-
-The package also defines **capability contract interfaces** (`IHttpServer`, `IDataEngine`) that enable plugins to interact with common services without depending on concrete implementations, following the **Dependency Inversion Principle**.
+The runtime package provides the **Standard Library** for the ObjectStack Operating System. It bridges the pure **ObjectKernel** (from `@objectstack/core`) with the **Data Engine** (`@objectstack/objectql`) and provides essential infrastructure adapters.
 
 ### Architecture Highlights
 
-- **MiniKernel Design**: Business logic is completely separated into plugins
+- **Standard Library**: Contains essential plugins (`AppManifestPlugin`, `DriverPlugin`)
+- **Core Integration**: Re-exports `ObjectKernel` for convenience
 - **Capability Contracts**: Abstract interfaces for HTTP server and data persistence
-- **Dependency Injection**: Service registry for inter-plugin communication
-- **Event/Hook System**: Publish-subscribe mechanism for loose coupling
-- **Lifecycle Management**: Standardized init/start/destroy phases
-- **Dependency Resolution**: Automatic topological sorting based on plugin dependencies
 
 ## Installation
 
@@ -28,7 +23,8 @@ npm install @objectstack/runtime
 ### Basic Setup (Recommended)
 
 ```typescript
-import { ObjectKernel, ObjectQLPlugin, DriverPlugin } from '@objectstack/runtime';
+import { ObjectKernel } from '@objectstack/core';
+import { ObjectQLPlugin, DriverPlugin, AppManifestPlugin } from '@objectstack/runtime';
 import { InMemoryDriver } from '@objectstack/driver-memory';
 
 const kernel = new ObjectKernel();