@vibesdotdev/runtime-client 0.0.1

package/dist/docs/runtime-client.surface.docs.descriptor.js

@@ -0,0 +1,464 @@
+/**
+ * Descriptor for runtime-client.surface
+ * How surfaces (CLI, SSR, browser, worker) initialize runtime clients
+ */
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'runtime-client.surface',
+    title: 'Surface Initialization',
+    summary: 'How different surfaces (CLI, SSR, browser, worker) initialize runtime clients',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: Surface Initialization
+summary: How different surfaces (CLI, SSR, browser, worker) initialize runtime clients
+tags: [runtime-client, surfaces, initialization, cli, ssr, browser, worker]
+parent: runtime-client
+order: 3
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+---
+
+# Surface Initialization
+
+Runtime clients are initialized differently depending on the **surface** (CLI, SSR, browser, worker) and **hardware** (consumer, cloud). This guide covers initialization patterns for each surface type.
+
+## Surface Types
+
+The Vibes runtime supports four surface types:
+
+| Surface | Description | Typical Use | Hardware |
+|---------|-------------|-------------|----------|
+| \`cli\` | Command-line interface | CLI commands, scripts | consumer |
+| \`ssr\` | Server-side rendering | SvelteKit +page.server.ts | consumer |
+| \`browser\` | Client-side browser | SvelteKit +page.svelte | consumer |
+| \`worker\` | Cloudflare Workers | Edge functions, queues | cloud |
+
+Each surface gets its own runtime instance with appropriate scope bindings:
+
+\`\`\`ts
+runtime.scope;
+// {
+//   surface: 'cli' | 'ssr' | 'browser' | 'worker',
+//   hardware: 'consumer' | 'cloud',
+//   purpose?: 'direct' | 'embedded'
+// }
+\`\`\`
+
+## CLI Surface
+
+### Bootstrap Flow
+
+The CLI bootstrap is defined in \`@vibesdotdev/cli/bootstrap\`:
+
+\`\`\`ts
+// packages/cli/src/bootstrap.ts
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { CLISurface } from './surface';
+
+export async function createVibesCliApp() {
+  const runtime = getVibesRuntime();
+  
+  // Set CLI scope
+  runtime.setScope({ 
+    surface: 'cli', 
+    hardware: 'consumer', 
+    purpose: 'direct' 
+  });
+  
+  // Register core plugins (order matters)
+  await registerCorePlugins(runtime);
+  
+  // Register project plugins
+  // ...
+  
+  // Activate plugins (fires onActivate hooks)
+  await runtime.activatePlugins();
+  
+  // Create CLI surface
+  const cli = new CLISurface(runtime, program);
+  
+  return { runtime, program, cli };
+}
+
+async function registerCorePlugins(runtime: VibesRuntime) {
+  // Order: context → cli → runtime-client → hooks → logging → runtime.docs
+  const runtimeClientPlugin = (
+    await import('@vibesdotdev/runtime-client/plugin')
+  ).default;
+  await runtime.registerPlugin(runtimeClientPlugin);
+  
+  // ... other plugins
+}
+\`\`\`
+
+### Key Points
+
+1. **runtime-client plugin registered early** — Before module plugins (ai, tools, etc.)
+2. **Plugin activation deferred** — \`activatePlugins()\` fires after all plugins registered
+3. **Module plugins register loaders** — In \`onActivate()\` hook, they register \`runtime/client\` loaders
+
+### Module Plugin Pattern
+
+\`\`\`ts
+// packages/ai/src/ai.plugin.ts
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+
+export const aiPlugin = createRuntimePlugin({
+  id: 'ai',
+  name: 'AI Module',
+  dependencies: ['runtime-client'],  // Declare dependency
+  
+  onActivate(runtime) {
+    // Register per-id loader for runtime/client kind
+    runtime.registerLoader('runtime/client', 'ai', async () => {
+      const { AIClient } = await import('./client/ai-client');
+      return new AIClient({
+        kind: 'runtime/client',
+        id: 'ai',
+        configManifestId: 'ai/config'
+      });
+    });
+  }
+});
+\`\`\`
+
+### Usage in CLI Commands
+
+\`\`\`ts
+// packages/cli/src/commands/ai/generate.ts
+import { getVibesClient } from '@vibesdotdev/runtime-client';
+
+export async function generateCommand(options: { prompt: string }) {
+  // Resolve client (runtime already bootstrapped by CLI)
+  const ai = await getVibesClient('ai');
+  
+  // Generate
+  const response = await ai.generate({ prompt: options.prompt });
+  console.log(response);
+}
+\`\`\`
+
+## SSR Surface (SvelteKit)
+
+### Bootstrap Flow
+
+SSR surfaces bootstrap in SvelteKit's \`hooks.server.ts\`:
+
+\`\`\`ts
+// apps/ai-web/src/hooks.server.ts
+import { bootstrapVibesRuntime } from '@vibesdotdev/runtime';
+import { consumerRuntimePlugin } from './runtime/consumer.plugin';
+
+export async function handle({ event, resolve }) {
+  // Bootstrap runtime once per request (or use singleton)
+  await bootstrapVibesRuntime({
+    plugins: [consumerRuntimePlugin],
+    scope: { 
+      surface: 'ssr', 
+      hardware: 'consumer', 
+      purpose: 'direct' 
+    }
+  });
+  
+  return resolve(event);
+}
+\`\`\`
+
+### Usage in +page.server.ts
+
+\`\`\`ts
+// apps/ai-web/src/routes/chat/+page.server.ts
+import { getVibesClient } from '@vibesdotdev/runtime-client';
+import type { PageServerLoad } from './$types';
+
+export const load: PageServerLoad = async () => {
+  // Resolve client (runtime bootstrapped in hooks.server.ts)
+  const ai = await getVibesClient('ai');
+  
+  // Use client
+  const models = await ai.listModels();
+  
+  return { models };
+};
+\`\`\`
+
+### SSR-Specific Considerations
+
+1. **Request isolation** — Each request may get its own runtime instance
+2. **No global state** — Don't store client references in module scope
+3. **Lazy initialization** — Clients initialize on first use
+4. **Config loading** — Happens per-request if not cached
+
+## Browser Surface
+
+### Bootstrap Flow
+
+Browser surfaces bootstrap in SvelteKit's \`+layout.svelte\` or \`app.html\`:
+
+\`\`\`ts
+// apps/ai-web/src/routes/+layout.svelte
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { bootstrapVibesRuntime } from '@vibesdotdev/runtime';
+  import { browserRuntimePlugin } from '$lib/runtime/browser.plugin';
+
+  onMount(async () => {
+    await bootstrapVibesRuntime({
+      plugins: [browserRuntimePlugin],
+      scope: { 
+        surface: 'browser', 
+        hardware: 'consumer', 
+        purpose: 'direct' 
+      }
+    });
+  });
+</script>
+
+<slot />
+\`\`\`
+
+### Usage in +page.svelte
+
+\`\`\`ts
+// apps/ai-web/src/routes/chat/+page.svelte
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { getVibesClient } from '@vibesdotdev/runtime-client';
+  import type { AIClient } from '@vibesdotdev/ai/client';
+
+  let aiClient: AIClient | null = null;
+
+  onMount(async () => {
+    // Resolve client (runtime bootstrapped in +layout.svelte)
+    aiClient = await getVibesClient<AIClient>('ai');
+  });
+
+  async function generate(prompt: string) {
+    if (!aiClient) return;
+    const response = await aiClient.generate({ prompt });
+    // Handle response...
+  }
+</script>
+
+<button on:click={() => generate('Hello')}>Generate</button>
+\`\`\`
+
+### Browser-Specific Considerations
+
+1. **Client-side only** — Browser surface can't access server-only plugins
+2. **API boundaries** — Use bridge pattern for server operations
+3. **Memory constraints** — Dispose clients on unmount if needed
+4. **Network latency** — Client methods may involve network calls
+
+## Worker Surface (Cloudflare)
+
+### Bootstrap Flow
+
+Worker surfaces bootstrap in worker entrypoint:
+
+\`\`\`ts
+// workers/jobs/src/entrypoint.ts
+import { bootstrapVibesRuntime } from '@vibesdotdev/runtime';
+import { runtimeClientPlugin } from '@vibesdotdev/runtime-client';
+import { workersPlugin } from '@vibesdotdev/workers';
+
+export default {
+  async fetch(request, env, ctx) {
+    // Bootstrap runtime
+    await bootstrapVibesRuntime({
+      plugins: [runtimeClientPlugin, workersPlugin],
+      scope: { 
+        surface: 'worker', 
+        hardware: 'cloud', 
+        purpose: 'direct' 
+      },
+      env  // Cloudflare env bindings
+    });
+    
+    // Handle request
+    const runtime = getVibesRuntime();
+    const workers = await runtime
+      .query('runtime/client')
+      .withId('workers')
+      .resolve();
+    
+    // ...
+  }
+};
+\`\`\`
+
+### Worker-Specific Considerations
+
+1. **Cold starts** — First request pays bootstrap cost
+2. **Stateless** — No persistent memory between requests
+3. **Env bindings** — Pass Cloudflare env to bootstrap
+4. **Limited plugins** — Only cloud-compatible plugins work
+
+## Cross-Surface Patterns
+
+### Pattern 1: Surface-Agnostic Services
+
+Write services that work in any surface:
+
+\`\`\`ts
+// packages/my-lib/src/content-generator.ts
+import { getVibesClient } from '@vibesdotdev/runtime-client';
+import type { AIClient } from '@vibesdotdev/ai/client';
+
+export class ContentGenerator {
+  async generate(topic: string): Promise<string> {
+    // Works in CLI, SSR, browser, worker
+    const ai = await getVibesClient<AIClient>('ai');
+    return ai.generate({ 
+      prompt: \`Write about \${topic}\` 
+    });
+  }
+}
+\`\`\`
+
+### Pattern 2: Surface Detection
+
+Detect current surface via runtime scope:
+
+\`\`\`ts
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+
+const runtime = getVibesRuntime();
+const { surface, hardware } = runtime.scope;
+
+if (surface === 'browser') {
+  // Browser-specific logic
+} else if (surface === 'ssr') {
+  // SSR-specific logic
+}
+\`\`\`
+
+### Pattern 3: Surface-Specific Implementations
+
+Register different implementations per surface:
+
+\`\`\`ts
+// packages/storage/src/storage.plugin.ts
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+
+export const storagePlugin = createRuntimePlugin({
+  id: 'storage',
+  onActivate(runtime) {
+    const { surface, hardware } = runtime.scope;
+    
+    if (hardware === 'cloud') {
+      // Cloud implementation
+      runtime.registerLoader('runtime/client', 'storage', async () => {
+        const { CloudStorageClient } = await import('./client/cloud');
+        return new CloudStorageClient();
+      });
+    } else {
+      // Consumer implementation
+      runtime.registerLoader('runtime/client', 'storage', async () => {
+        const { LocalStorageClient } = await import('./client/local');
+        return new LocalStorageClient();
+      });
+    }
+  }
+});
+\`\`\`
+
+## WRONG patterns
+
+:::card{title="Anti-patterns"}
+- ❌ **Manual runtime instantiation** — Use \`bootstrapVibesRuntime()\` or surface helpers
+- ❌ **Cross-surface state sharing** — Each surface has its own runtime instance
+- ❌ **Storing clients in module scope** — Resolve at call site with \`getVibesClient()\`
+- ❌ **Assuming surface** — Check \`runtime.scope\` if behavior differs
+- ❌ **Skipping plugin activation** — Call \`activatePlugins()\` after registration
+:::
+
+## Example: Multi-surface service
+
+\`\`\`ts
+// packages/notification-service/src/index.ts
+import { getVibesRuntime, getVibesClient } from '@vibesdotdev/runtime';
+import type { AIClient } from '@vibesdotdev/ai/client';
+
+export class NotificationService {
+  async sendNotification(
+    userId: string,
+    message: string
+  ): Promise<void> {
+    const runtime = getVibesRuntime();
+    const { surface, hardware } = runtime.scope;
+    
+    // Surface-specific notification strategy
+    if (surface === 'browser') {
+      // Browser: show toast notification
+      this.showBrowserNotification(message);
+    } else if (surface === 'ssr') {
+      // SSR: send email via server
+      const ai = await getVibesClient<AIClient>('ai');
+      const emailBody = await ai.generate({
+        prompt: \`Write email: \${message}\`
+      });
+      await this.sendEmail(userId, emailBody);
+    } else if (surface === 'worker') {
+      // Worker: queue notification job
+      await this.queueNotification(userId, message);
+    }
+  }
+  
+  private showBrowserNotification(message: string) {
+    // Browser-specific: toast, badge, etc.
+  }
+  
+  private async sendEmail(userId: string, body: string) {
+    // SSR-specific: email service
+  }
+  
+  private async queueNotification(userId: string, message: string) {
+    // Worker-specific: job queue
+  }
+}
+\`\`\`
+
+## Code paths
+
+- CLI bootstrap: [\`packages/cli/src/bootstrap.ts\`](https://github.com/vibesdotdev/monorepo/tree/main/packages/cli/src/bootstrap.ts)
+- Runtime bootstrap: [\`packages/runtime/src/bootstrap/index.ts\`](https://github.com/vibesdotdev/monorepo/tree/main/packages/runtime/src/bootstrap/index.ts)
+- Helper: [\`packages/runtime-client/src/helper.ts\`](https://github.com/vibesdotdev/monorepo/tree/main/packages/runtime-client/src/helper.ts)
+- Plugin: [\`packages/runtime-client/src/plugin.ts\`](https://github.com/vibesdotdev/monorepo/tree/main/packages/runtime-client/src/plugin.ts)
+
+:::card{title="See also"}
+- [\`runtime-client.api\`](runtime-client.api) — BaseRuntimeClient and extension patterns
+- [\`runtime-client.helpers\`](runtime-client.helpers) — getVibesClient() helper functions
+- [\`runtime.scopes\`](runtime.scopes) — Consumer vs cloud scopes
+- [\`bootstrapVibesRuntime\`](bootstrap) — Runtime bootstrap API
+:::
+`
+    },
+    parent: 'runtime-client',
+    order: 3,
+    tags: ['runtime-client', 'surfaces', 'initialization', 'cli', 'ssr', 'browser', 'worker'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true,
+    man: {
+        name: 'runtime-client.surface — surface initialization patterns',
+        section: 1,
+        synopsis: 'vibes man runtime-client.surface',
+        options: [],
+        examples: [
+            {
+                description: 'CLI surface bootstrap',
+                command: 'await createVibesCliApp()'
+            },
+            {
+                description: 'SSR surface in SvelteKit',
+                command: 'await bootstrapVibesRuntime({ scope: { surface: "ssr" } })'
+            }
+        ],
+        seeAlso: ['runtime-client.api', 'runtime-client.helpers', 'runtime.scopes']
+    }
+};
+export default descriptor;
+//# sourceMappingURL=runtime-client.surface.docs.descriptor.js.map

package/dist/docs/runtime-client.surface.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-client.surface.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/runtime-client.surface.docs.descriptor.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,GAAwB;IACtC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,wBAAwB;IAC5B,KAAK,EAAE,wBAAwB;IAC/B,OAAO,EAAE,+EAA+E;IACxF,IAAI,EAAE;QACJ,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwaX;KACE;IACD,MAAM,EAAE,gBAAgB;IACxB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,gBAAgB,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC;IACzF,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;IACb,GAAG,EAAE;QACH,IAAI,EAAE,0DAA0D;QAChE,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,kCAAkC;QAC5C,OAAO,EAAE,EAAE;QACX,QAAQ,EAAE;YACR;gBACE,WAAW,EAAE,uBAAuB;gBACpC,OAAO,EAAE,2BAA2B;aACrC;YACD;gBACE,WAAW,EAAE,0BAA0B;gBACvC,OAAO,EAAE,4DAA4D;aACtE;SACF;QACD,OAAO,EAAE,CAAC,oBAAoB,EAAE,wBAAwB,EAAE,gBAAgB,CAAC;KAC5E;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/types.d.ts

@@ -0,0 +1,19 @@
+export type DocsTopicDescriptor = {
+    kind: 'docs/topic';
+    id: string;
+    title: string;
+    summary?: string;
+    body: {
+        type: 'markdown';
+        sourceType: 'raw';
+        source: string;
+    };
+    parent?: string;
+    order?: number;
+    enabled?: boolean;
+    man?: unknown;
+    tags?: string[];
+    surfaces?: string[];
+    hardware?: string[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/docs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/docs/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE;QACL,IAAI,EAAE,UAAU,CAAC;QACjB,UAAU,EAAE,KAAK,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC"}

package/dist/docs/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/docs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/docs/types.ts"],"names":[],"mappings":""}

package/dist/helper.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeClient } from './contract.ts';
+/**
+ * Ambient helper to resolve a module-level client by id.
+ *
+ * ```ts
+ * const ai = await getVibesClient<AIClient>('ai');
+ * const response = await ai.generate({ prompt: 'Hello' });
+ * ```
+ *
+ * Equivalent to calling `runtime.query('runtime/client').withId(id).resolve()`
+ * on the ambient runtime, with a clearer error when the client isn't registered.
+ */
+export declare function getVibesClient<T extends RuntimeClient = RuntimeClient>(id: string): Promise<T>;
+//# sourceMappingURL=helper.d.ts.map

package/dist/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAC3E,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,CAAC,CAAC,CAcZ"}

package/dist/helper.js

@@ -0,0 +1,27 @@
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { runtimeClientPlugin } from "./plugin.js";
+/**
+ * Ambient helper to resolve a module-level client by id.
+ *
+ * ```ts
+ * const ai = await getVibesClient<AIClient>('ai');
+ * const response = await ai.generate({ prompt: 'Hello' });
+ * ```
+ *
+ * Equivalent to calling `runtime.query('runtime/client').withId(id).resolve()`
+ * on the ambient runtime, with a clearer error when the client isn't registered.
+ */
+export async function getVibesClient(id) {
+    const runtime = getVibesRuntime();
+    if (!runtime.hasKind('runtime/client')) {
+        await runtime.registerPlugin(runtimeClientPlugin);
+    }
+    const client = await runtime.query('runtime/client').withId(id).resolve();
+    if (!client) {
+        throw new Error(`No runtime client registered with id "${id}". ` +
+            `Compose the owning module's plugin (e.g. aiPlugin for id="ai") before use, ` +
+            `and ensure runtimeClientPlugin is registered.`);
+    }
+    return client;
+}
+//# sourceMappingURL=helper.js.map

package/dist/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CACnC,EAAU;IAEV,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAClC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACxC,MAAM,OAAO,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC;IACnD,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAC1E,IAAI,CAAC,MAAM,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACd,yCAAyC,EAAE,KAAK;YAC/C,6EAA6E;YAC7E,+CAA+C,CAChD,CAAC;IACH,CAAC;IACD,OAAO,MAAW,CAAC;AACpB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { runtimeClientPlugin } from './plugin.ts';
+export { runtimeClientKind } from './kind.ts';
+export { BaseRuntimeClient } from './base.ts';
+export { getVibesClient } from './helper.ts';
+export type { RuntimeClient } from './contract.ts';
+export type { RuntimeClientDescriptor } from './schema.ts';
+export { RuntimeClientDescriptorSchema } from './schema.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// @vibesdotdev/runtime-client
+// One-client-per-module pattern: shared base, kind, and resolver helper.
+export { runtimeClientPlugin } from "./plugin.js";
+export { runtimeClientKind } from "./kind.js";
+export { BaseRuntimeClient } from "./base.js";
+export { getVibesClient } from "./helper.js";
+export { RuntimeClientDescriptorSchema } from "./schema.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,yEAAyE;AAEzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC"}

package/dist/kind.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime';
+import type { RuntimeClient } from './contract.ts';
+/**
+ * `runtime/client` kind descriptor record.
+ *
+ * No `defaultImplementation` — each module registers its own class via a
+ * per-descriptor loader (see `runtime.registerLoader('runtime/client', '<id>', …)`).
+ */
+export declare const runtimeClientKind: RuntimeKindDescriptorRecord<RuntimeClient>;
+//# sourceMappingURL=kind.d.ts.map

package/dist/kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.d.ts","sourceRoot":"","sources":["../src/kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,2BAA2B,CAAC,aAAa,CAGxE,CAAC"}

package/dist/kind.js

@@ -0,0 +1,12 @@
+import { RuntimeClientDescriptorSchema } from "./schema.js";
+/**
+ * `runtime/client` kind descriptor record.
+ *
+ * No `defaultImplementation` — each module registers its own class via a
+ * per-descriptor loader (see `runtime.registerLoader('runtime/client', '<id>', …)`).
+ */
+export const runtimeClientKind = {
+    id: 'runtime/client',
+    descriptorSchema: RuntimeClientDescriptorSchema
+};
+//# sourceMappingURL=kind.js.map

package/dist/kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.js","sourceRoot":"","sources":["../src/kind.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAG5D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA+C;IAC5E,EAAE,EAAE,gBAAgB;IACpB,gBAAgB,EAAE,6BAA6B;CAC/C,CAAC"}

package/dist/plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Registers the `runtime/client` kind.
+ *
+ * Compose this plugin once at app bootstrap. Module plugins (ai, tools,
+ * knowledge, …) declare `dependencies: ['runtime-client', …]` and register
+ * their per-id loaders in their `onRegister` hook.
+ */
+export declare const runtimeClientPlugin: import("@vibesdotdev/runtime").RuntimePlugin;
+export default runtimeClientPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,8CAM9B,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/plugin.js

@@ -0,0 +1,17 @@
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+import { runtimeClientKind } from "./kind.js";
+/**
+ * Registers the `runtime/client` kind.
+ *
+ * Compose this plugin once at app bootstrap. Module plugins (ai, tools,
+ * knowledge, …) declare `dependencies: ['runtime-client', …]` and register
+ * their per-id loaders in their `onRegister` hook.
+ */
+export const runtimeClientPlugin = createRuntimePlugin({
+    id: 'runtime-client',
+    name: 'Runtime Client',
+    description: 'Shared `runtime/client` kind. Each module registers one descriptor; consumers resolve via `runtime.query(\"runtime/client\").withId(\"ai\")`.',
+    kinds: [runtimeClientKind]
+});
+export default runtimeClientPlugin;
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;IACtD,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EACV,+IAA+I;IAChJ,KAAK,EAAE,CAAC,iBAAiB,CAAC;CAC1B,CAAC,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/runtime-client.plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runtime Client Docs Plugin
+ *
+ * Registers documentation descriptors for runtime-client APIs:
+ * - runtime-client.api — BaseRuntimeClient class, client patterns, how to extend
+ * - runtime-client.helpers — getVibesClient() helper functions, surface detection
+ * - runtime-client.surface — How surfaces (CLI, SSR, browser, worker) initialize clients
+ *
+ * This plugin is surface-neutral — docs descriptors work in CLI, SSR, and worker contexts.
+ */
+export declare const runtimeClientDocsPlugin: import("@vibesdotdev/runtime").RuntimePlugin;
+export default runtimeClientDocsPlugin;
+//# sourceMappingURL=runtime-client.plugin.d.ts.map

package/dist/runtime-client.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-client.plugin.d.ts","sourceRoot":"","sources":["../src/runtime-client.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH,eAAO,MAAM,uBAAuB,8CAWlC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}