@vibevibes/sdk 0.5.0 → 0.6.0

package/bin/dev.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+/**
+ * Start the vibevibes dev server for an experience.
+ *
+ * Usage:
+ *   npx vibevibes-dev              # serves from current directory
+ *   npx vibevibes-dev ./my-exp     # serves from a specific path
+ *   npm run dev                    # via package.json script
+ */
+
+import { resolve } from "node:path";
+import { startServer } from "../dist/server.js";
+
+const projectRoot = resolve(process.argv[2] || ".");
+const port = parseInt(process.env.PORT || "4321", 10);
+
+startServer({ projectRoot, port });

package/dist/bundler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Experience bundler — produces server and client bundles from src/index.tsx.
+ *
+ * Server bundle: CJS, eval'd via new Function() to extract tools + manifest.
+ * Client bundle: ESM, loaded in browser via blob URL + dynamic import().
+ *
+ * Extracted from create-experience/runtime/bundler.ts into @vibevibes/runtime.
+ */
+/**
+ * Bundle for server-side tool execution (Node.js eval).
+ * Returns the raw ExperienceModule extracted via new Function().
+ */
+export declare function bundleForServer(entryPath: string): Promise<string>;
+/**
+ * Evaluate a server bundle and extract the ExperienceModule.
+ */
+export declare function evalServerBundle(serverCode: string): Promise<unknown>;
+/**
+ * Bundle for client-side Canvas rendering (browser).
+ * Returns pure ESM. External imports (react, zod, etc.) are left as-is —
+ * the viewer's import map resolves them in the browser.
+ */
+export declare function bundleForClient(entryPath: string): Promise<string>;
+/**
+ * Build both bundles from an entry file.
+ */
+export declare function buildExperience(entryPath: string): Promise<{
+    serverCode: string;
+    clientCode: string;
+}>;
+/**
+ * Validate a client bundle for common issues.
+ * Lightweight — esbuild already validates syntax. This just checks the output exists.
+ * Returns null if OK, or an error message string.
+ */
+export declare function validateClientBundle(code: string): string | null;

package/dist/bundler.js

@@ -0,0 +1,254 @@
+/**
+ * Experience bundler — produces server and client bundles from src/index.tsx.
+ *
+ * Server bundle: CJS, eval'd via new Function() to extract tools + manifest.
+ * Client bundle: ESM, loaded in browser via blob URL + dynamic import().
+ *
+ * Extracted from create-experience/runtime/bundler.ts into @vibevibes/runtime.
+ */
+import * as esbuild from "esbuild";
+const EXTERNALS = ["react", "react/jsx-runtime", "react-dom", "react-dom/client", "yjs", "zod", "@vibevibes/sdk", "@vibevibes/runtime"];
+// Additional externals for server-only bundles — heavy rendering libraries that
+// aren't needed for tool/test execution. Canvas components are never called server-side.
+const SERVER_ONLY_EXTERNALS = [
+    ...EXTERNALS,
+    "three", "three/*",
+    "@react-three/fiber", "@react-three/fiber/*",
+    "@react-three/drei", "@react-three/drei/*",
+];
+/**
+ * Strip esbuild's CJS annotation: `0 && (module.exports = {...})`.
+ * Uses brace-depth counting to handle nested objects/functions in the annotation,
+ * unlike a simple `[^}]*` regex which breaks on nested braces.
+ */
+function stripCjsAnnotation(code) {
+    const marker = /0\s*&&\s*\(module\.exports\s*=\s*\{/g;
+    let match;
+    let result = code;
+    while ((match = marker.exec(code)) !== null) {
+        const start = match.index;
+        let depth = 1; // we matched the opening `{`
+        let i = match.index + match[0].length;
+        while (i < code.length && depth > 0) {
+            if (code[i] === "{")
+                depth++;
+            else if (code[i] === "}")
+                depth--;
+            i++;
+        }
+        // Skip the closing `)` and optional `;`
+        if (i < code.length && code[i] === ")")
+            i++;
+        if (i < code.length && code[i] === ";")
+            i++;
+        result = result.slice(0, start) + "/* [vibevibes] stripped CJS annotation */" + result.slice(i);
+        break; // Only one annotation per bundle
+    }
+    return result;
+}
+/**
+ * Strip import/export statements for external packages.
+ * The runtime provides these via globalThis (browser) or function args (server).
+ */
+/**
+ * Strip external imports from a CJS server bundle so it can be eval'd with new Function().
+ * Only used for server bundles — client bundles keep imports (resolved by browser import map).
+ */
+function stripExternalImports(code, externals = EXTERNALS) {
+    let result = code;
+    for (const ext of externals) {
+        let escaped;
+        if (ext.endsWith("/*")) {
+            const base = ext.slice(0, -2).replace(/[.*+?^${}()|[\]\\\/]/g, "\\$&");
+            escaped = `${base}\\/[^"']+`;
+        }
+        else {
+            escaped = ext.replace(/[.*+?^${}()|[\]\\\/]/g, "\\$&");
+        }
+        // CJS: var import_X = __toESM(require("pkg"), N); or var import_X = require("pkg");
+        result = result.replace(new RegExp(`var\\s+\\w+\\s*=\\s*(?:__toESM\\()?require\\(["']${escaped}["']\\)[^;]{0,500};`, "g"), "");
+    }
+    return result;
+}
+/**
+ * CJS shim definitions for server-side eval (new Function()).
+ * Maps esbuild-generated variable names to runtime-provided globals.
+ */
+const SDK_CORE_SHIM = "{ defineExperience: defineExperience, defineTool: defineTool, defineTest: defineTest, defineStream: defineStream, default: { defineExperience: defineExperience, defineTool: defineTool, defineTest: defineTest, defineStream: defineStream } }";
+const CJS_BASE_SHIMS = {
+    import_react: "{ default: React, __esModule: true, createElement: React.createElement, Fragment: React.Fragment, useState: React.useState, useEffect: React.useEffect, useCallback: React.useCallback, useMemo: React.useMemo, useRef: React.useRef, useContext: React.useContext, useReducer: React.useReducer, createContext: React.createContext, forwardRef: React.forwardRef, memo: React.memo }",
+    import_zod: "{ z: z, default: z }",
+    import_yjs: "{ default: Y }",
+    import_sdk: SDK_CORE_SHIM,
+    import_vibevibes_sdk: SDK_CORE_SHIM,
+    import_runtime: SDK_CORE_SHIM,
+    import_vibevibes_runtime: SDK_CORE_SHIM,
+    import_react_dom: "{ default: {}, __esModule: true }",
+    import_client: "{ default: {}, __esModule: true }",
+    // Proxy stubs for rendering libraries (server-side only — Canvas is never called)
+    import_three: "(new Proxy({}, { get: (_, p) => typeof p === 'string' ? function(){} : undefined }))",
+    import_fiber: "(new Proxy({}, { get: (_, p) => typeof p === 'string' ? function(){} : undefined }))",
+    import_drei: "(new Proxy({}, { get: (_, p) => typeof p === 'string' ? function(){} : undefined }))",
+};
+/**
+ * Inject CJS shim variables for server-side eval.
+ */
+function injectCjsShims(code) {
+    const lines = [];
+    // Emit base shims
+    for (const [name, value] of Object.entries(CJS_BASE_SHIMS)) {
+        lines.push(`var ${name} = ${value};`);
+    }
+    // Scan for numbered variants (e.g. import_react2, import_zod3) and alias them
+    for (const baseName of Object.keys(CJS_BASE_SHIMS)) {
+        const pattern = new RegExp(`\\b(${baseName}(\\d+))\\b`, "g");
+        const seen = new Set();
+        let match;
+        while ((match = pattern.exec(code)) !== null) {
+            const numberedName = match[1];
+            if (!seen.has(numberedName)) {
+                seen.add(numberedName);
+                lines.push(`var ${numberedName} = ${baseName};`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format esbuild errors into actionable messages with file:line and suggestions.
+ */
+function formatEsbuildError(err, target) {
+    const buildErr = err;
+    if (buildErr.errors && Array.isArray(buildErr.errors)) {
+        const formatted = buildErr.errors.map((e) => {
+            const loc = e.location
+                ? `${e.location.file}:${e.location.line}:${e.location.column}`
+                : "unknown location";
+            return `  ${loc}: ${e.text}`;
+        }).join("\n");
+        return new Error(`Build failed (${target} bundle):\n${formatted}\n\n` +
+            `Common fixes:\n` +
+            `- Check for syntax errors at the indicated location\n` +
+            `- Ensure all imports resolve to existing files in src/\n` +
+            `- Verify @vibevibes/sdk imports match the available exports`);
+    }
+    return err instanceof Error ? err : new Error(String(err));
+}
+/**
+ * Bundle for server-side tool execution (Node.js eval).
+ * Returns the raw ExperienceModule extracted via new Function().
+ */
+export async function bundleForServer(entryPath) {
+    let result;
+    try {
+        result = await esbuild.build({
+            entryPoints: [entryPath],
+            bundle: true,
+            format: "cjs",
+            platform: "node",
+            target: "es2022",
+            write: false,
+            external: SERVER_ONLY_EXTERNALS,
+            jsx: "transform",
+            jsxFactory: "React.createElement",
+            jsxFragment: "React.Fragment",
+            logLevel: "silent",
+        });
+    }
+    catch (err) {
+        throw formatEsbuildError(err, "server");
+    }
+    const outputFile = result.outputFiles?.[0];
+    if (!outputFile)
+        throw new Error("esbuild produced no output files for server bundle");
+    let code = outputFile.text;
+    code = stripExternalImports(code, SERVER_ONLY_EXTERNALS);
+    // Strip user-code React hook destructuring (already provided by CJS shims)
+    code = code.replace(/(?:const|let|var)\s+\{[^}]*?\b(?:useState|useEffect|useCallback|useMemo|useRef|useContext|useReducer)\b[^}]*?\}\s*=\s*(?:React|import_react\w*)\s*;/g, "/* [vibevibes] stripped duplicate React destructuring */");
+    // Inject CJS shims for esbuild-generated variable references
+    // Pass code so we can detect numbered variants (import_react2, etc.)
+    code = injectCjsShims(code) + "\n" + code;
+    // Strip esbuild's CJS annotation `0 && (module.exports = {...})` — dead code that
+    // causes syntax errors when module.exports is replaced with var assignment.
+    // Uses brace-depth counting to handle nested objects/functions in the annotation.
+    code = stripCjsAnnotation(code);
+    // Replace module.exports/export default with variable assignment
+    code = code.replace(/module\.exports\s*=\s*/g, "var __experience_export__ = ");
+    code = code.replace(/exports\.default(?!\w)\s*=\s*/g, "var __experience_export__ = ");
+    return code;
+}
+/**
+ * Evaluate a server bundle and extract the ExperienceModule.
+ */
+export async function evalServerBundle(serverCode) {
+    const sdk = await import("@vibevibes/sdk");
+    const { defineExperience, defineTool, defineTest, defineStream } = sdk;
+    const noop = () => null;
+    const stubReact = {
+        createElement: noop, Fragment: "Fragment",
+        useState: (init) => [typeof init === "function" ? init() : init, noop],
+        useEffect: noop, useCallback: (fn) => fn,
+        useMemo: (fn) => fn(), useRef: (init) => ({ current: init ?? null }),
+        useContext: noop, useReducer: noop,
+        createContext: noop, forwardRef: noop, memo: (x) => x,
+    };
+    const zodModule = await import("zod");
+    const z = zodModule.z ?? zodModule.default ?? zodModule;
+    const fn = new Function("globalThis", "process", "global", "React", "Y", "z", "defineExperience", "defineTool", "defineTest", "defineStream", "require", "exports", "module", "console", `"use strict";\n${serverCode}\nreturn typeof __experience_export__ !== 'undefined' ? __experience_export__ : (typeof module !== 'undefined' ? module.exports : undefined);`);
+    const fakeModule = { exports: {} };
+    const sandboxGlobal = Object.create(null);
+    const sandboxProcess = { env: { NODE_ENV: "production" } };
+    const result = fn(sandboxGlobal, sandboxProcess, sandboxGlobal, stubReact, {}, z, defineExperience, defineTool, defineTest, defineStream, (id) => { throw new Error(`require('${id}') is not supported in the vibevibes server sandbox. Add '${id}' to EXTERNALS in bundler.ts.`); }, fakeModule.exports, fakeModule, console);
+    const exports = fakeModule.exports;
+    return result?.default ?? result ?? exports?.default ?? exports;
+}
+/**
+ * Bundle for client-side Canvas rendering (browser).
+ * Returns pure ESM. External imports (react, zod, etc.) are left as-is —
+ * the viewer's import map resolves them in the browser.
+ */
+export async function bundleForClient(entryPath) {
+    let result;
+    try {
+        result = await esbuild.build({
+            entryPoints: [entryPath],
+            bundle: true,
+            format: "esm",
+            platform: "browser",
+            target: "es2020",
+            write: false,
+            external: EXTERNALS,
+            jsx: "transform",
+            jsxFactory: "React.createElement",
+            jsxFragment: "React.Fragment",
+            logLevel: "silent",
+        });
+    }
+    catch (err) {
+        throw formatEsbuildError(err, "client");
+    }
+    const clientOutputFile = result.outputFiles?.[0];
+    if (!clientOutputFile)
+        throw new Error("esbuild produced no output files for client bundle");
+    return clientOutputFile.text;
+}
+/**
+ * Build both bundles from an entry file.
+ */
+export async function buildExperience(entryPath) {
+    const [serverCode, clientCode] = await Promise.all([
+        bundleForServer(entryPath),
+        bundleForClient(entryPath),
+    ]);
+    return { serverCode, clientCode };
+}
+/**
+ * Validate a client bundle for common issues.
+ * Lightweight — esbuild already validates syntax. This just checks the output exists.
+ * Returns null if OK, or an error message string.
+ */
+export function validateClientBundle(code) {
+    if (!code || !code.trim())
+        return "Client bundle is empty";
+    return null;
+}

package/dist/define.d.ts

@@ -0,0 +1,35 @@
+import type { z } from "zod";
+import type { ToolDef, ToolRisk, TestDef, ExperienceModule, StreamDef, ParticipantSlot } from "./types";
+export declare function defineTool<TInput, TOutput>(config: {
+    name: string;
+    description: string;
+    input_schema: z.ZodType<TInput>;
+    risk?: ToolRisk;
+    capabilities_required?: string[];
+    handler: ToolDef<TInput, TOutput>["handler"];
+}): ToolDef<TInput, TOutput>;
+export declare function defineTest(config: {
+    name: string;
+    run: TestDef["run"];
+}): TestDef;
+export declare function defineStream<TInput>(config: {
+    name: string;
+    description?: string;
+    input_schema: z.ZodType<TInput>;
+    merge: (state: Record<string, any>, input: TInput, actorId: string) => Record<string, any>;
+    rateLimit?: number;
+}): StreamDef<TInput>;
+export declare function defineExperience(module: ExperienceModule & {
+    initialState?: Record<string, any>;
+    agents?: Array<{
+        role: string;
+        systemPrompt: string;
+        allowedTools?: string[];
+        autoSpawn?: boolean;
+        maxInstances?: number;
+    }>;
+    participants?: ParticipantSlot[];
+    name?: string;
+}): ExperienceModule & {
+    initialState?: Record<string, any>;
+};

package/dist/define.js

@@ -0,0 +1,69 @@
+export function defineTool(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        input_schema: config.input_schema,
+        risk: config.risk ?? "low",
+        capabilities_required: config.capabilities_required ?? [],
+        handler: config.handler,
+    };
+}
+export function defineTest(config) {
+    return { name: config.name, run: config.run };
+}
+export function defineStream(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        input_schema: config.input_schema,
+        merge: config.merge,
+        rateLimit: config.rateLimit,
+    };
+}
+export function defineExperience(module) {
+    const m = module.manifest ?? {};
+    let initialState = module.initialState;
+    if (module.stateSchema && !initialState) {
+        try {
+            initialState = module.stateSchema.parse(undefined);
+        }
+        catch {
+            try {
+                initialState = module.stateSchema.parse({});
+            }
+            catch {
+                // Schema has required fields with no defaults
+            }
+        }
+    }
+    if (module.stateSchema && initialState) {
+        try {
+            module.stateSchema.parse(initialState);
+        }
+        catch (err) {
+            console.warn(`[vibevibes] initialState does not match stateSchema: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    const rawParticipantSlots = module.participants ??
+        m.participantSlots ??
+        (module.agents || m.agentSlots)?.map((a) => ({ ...a, type: "ai" }));
+    const hasOrchestrator = rawParticipantSlots?.some((s) => s.role === "orchestrator");
+    const participantSlots = rawParticipantSlots
+        ? hasOrchestrator
+            ? rawParticipantSlots
+            : [...rawParticipantSlots, { role: "orchestrator", type: "ai", maxInstances: 1 }]
+        : [{ role: "orchestrator", type: "ai", maxInstances: 1 }];
+    const agentSlots = participantSlots?.filter((s) => s.type === "ai" || s.type === undefined || s.type === "any") ?? m.agentSlots ?? module.agents;
+    return {
+        ...module,
+        initialState,
+        manifest: {
+            ...m,
+            title: m.title || module.name || m.id,
+            version: m.version || "0.0.1",
+            requested_capabilities: m.requested_capabilities || ["state.write"],
+            participantSlots: participantSlots ?? m.participantSlots,
+            agentSlots: agentSlots ?? m.agentSlots,
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,181 +1,2 @@
-import React from 'react';
-import { z } from 'zod';
-
-/**
- * Experience SDK Types
- */
-
-type ToolRisk = "low" | "medium" | "high";
-type CallToolFn = (name: string, input: Record<string, unknown>) => Promise<unknown>;
-type ZodFactory = typeof z;
-type ToolEvent = {
-    id: string;
-    ts: number;
-    actorId: string;
-    owner?: string;
-    tool: string;
-    input: Record<string, unknown>;
-    output?: unknown;
-    error?: string;
-};
-type AgentSlot = {
-    role: string;
-    systemPrompt: string;
-    allowedTools?: string[];
-    autoSpawn?: boolean;
-    maxInstances?: number;
-};
-type ParticipantSlot = {
-    role: string;
-    type?: "human" | "ai" | "any";
-    systemPrompt?: string;
-    allowedTools?: string[];
-    autoSpawn?: boolean;
-    maxInstances?: number;
-};
-type ParticipantDetail = {
-    actorId: string;
-    type: "human" | "ai" | "unknown";
-    role?: string;
-    metadata?: Record<string, string>;
-};
-type ExperienceManifest = {
-    id: string;
-    version: string;
-    title: string;
-    description: string;
-    requested_capabilities: string[];
-    agentSlots?: AgentSlot[];
-    participantSlots?: ParticipantSlot[];
-    category?: string;
-    tags?: string[];
-};
-type StreamDef<TInput = any> = {
-    name: string;
-    description?: string;
-    input_schema: z.ZodTypeAny;
-    merge: (state: Record<string, any>, input: TInput, actorId: string) => Record<string, any>;
-    rateLimit?: number;
-};
-type ToolCtx<TState extends Record<string, any> = Record<string, any>> = {
-    roomId: string;
-    actorId: string;
-    owner?: string;
-    state: TState;
-    setState: (newState: TState) => void;
-    timestamp: number;
-    memory: Record<string, any>;
-    setMemory: (updates: Record<string, any>) => void;
-};
-type ToolDef<TInput = any, TOutput = any> = {
-    name: string;
-    description: string;
-    input_schema: z.ZodTypeAny;
-    risk: ToolRisk;
-    capabilities_required: string[];
-    handler: (ctx: ToolCtx, input: TInput) => Promise<TOutput>;
-    emits?: string[];
-    on?: Record<string, (ctx: ToolCtx, event: ToolEvent) => Promise<void>>;
-    persist?: boolean;
-};
-type CanvasProps<TState extends Record<string, any> = Record<string, any>> = {
-    actorId: string;
-    sharedState: TState;
-    callTool: (name: string, input: Record<string, unknown>, predictFn?: (state: TState) => TState) => Promise<unknown>;
-    callTools?: (calls: Array<{
-        name: string;
-        input: Record<string, unknown>;
-    }>) => Promise<unknown[]>;
-    ephemeralState: Record<string, Record<string, any>>;
-    setEphemeral: (data: Record<string, any>) => void;
-    stream?: (name: string, input: Record<string, unknown>) => void;
-    participants: string[];
-    participantDetails?: ParticipantDetail[];
-    role?: "spectator" | "player";
-};
-type ExpectChain<T> = {
-    toBe: (expected: T) => void;
-    toEqual: (expected: unknown) => void;
-    toBeTruthy: () => void;
-    toBeFalsy: () => void;
-    toContain: (item: unknown) => void;
-    toHaveProperty: (key: string, value?: unknown) => void;
-    toBeGreaterThan: (expected: number) => void;
-    toBeLessThan: (expected: number) => void;
-    not: ExpectChain<T>;
-};
-type TestHelpers = {
-    tool: (name: string) => ToolDef;
-    ctx: (opts?: {
-        state?: Record<string, any>;
-        actorId?: string;
-        roomId?: string;
-        owner?: string;
-    }) => ToolCtx & {
-        getState: () => Record<string, any>;
-    };
-    expect: <T>(actual: T) => ExpectChain<T>;
-    snapshot: (label: string, value: unknown) => void;
-    observe: (state: Record<string, any>, actorId?: string) => Record<string, any>;
-    agentSlots: () => Array<{
-        role: string;
-        systemPrompt?: string;
-        allowedTools?: string[];
-        [k: string]: unknown;
-    }>;
-};
-type TestDef = {
-    name: string;
-    run: (helpers: TestHelpers) => Promise<void>;
-};
-type RegistryEntry = {
-    path: string;
-};
-type ExperienceRegistry = {
-    experiences: Record<string, RegistryEntry>;
-};
-type ExperienceModule = {
-    manifest: ExperienceManifest;
-    Canvas: React.FC<CanvasProps>;
-    tools: ToolDef[];
-    tests?: TestDef[];
-    stateSchema?: z.ZodTypeAny;
-    streams?: StreamDef[];
-    observe?: (state: Record<string, any>, event: ToolEvent | null, actorId: string) => Record<string, any>;
-};
-
-declare function defineTool<TInput, TOutput>(config: {
-    name: string;
-    description: string;
-    input_schema: z.ZodType<TInput>;
-    risk?: ToolRisk;
-    capabilities_required?: string[];
-    handler: ToolDef<TInput, TOutput>["handler"];
-}): ToolDef<TInput, TOutput>;
-declare function defineTest(config: {
-    name: string;
-    run: TestDef["run"];
-}): TestDef;
-declare function defineStream<TInput>(config: {
-    name: string;
-    description?: string;
-    input_schema: z.ZodType<TInput>;
-    merge: (state: Record<string, any>, input: TInput, actorId: string) => Record<string, any>;
-    rateLimit?: number;
-}): StreamDef<TInput>;
-declare function defineExperience(module: ExperienceModule & {
-    initialState?: Record<string, any>;
-    agents?: Array<{
-        role: string;
-        systemPrompt: string;
-        allowedTools?: string[];
-        autoSpawn?: boolean;
-        maxInstances?: number;
-    }>;
-    participants?: ParticipantSlot[];
-    name?: string;
-}): ExperienceModule & {
-    initialState?: Record<string, any>;
-};
-
-export { type AgentSlot, type CallToolFn, type CanvasProps, type ExpectChain, type ExperienceManifest, type ExperienceModule, type ExperienceRegistry, type ParticipantDetail, type ParticipantSlot, type RegistryEntry, type StreamDef, type TestDef, type TestHelpers, type ToolCtx, type ToolDef, type ToolEvent, type ToolRisk, type ZodFactory, defineExperience, defineStream, defineTest, defineTool };
+export * from "./types";
+export * from "./define";

package/dist/index.js

@@ -1,70 +1,2 @@
-// src/define.ts
-function defineTool(config) {
-  return {
-    name: config.name,
-    description: config.description,
-    input_schema: config.input_schema,
-    risk: config.risk ?? "low",
-    capabilities_required: config.capabilities_required ?? [],
-    handler: config.handler
-  };
-}
-function defineTest(config) {
-  return { name: config.name, run: config.run };
-}
-function defineStream(config) {
-  return {
-    name: config.name,
-    description: config.description,
-    input_schema: config.input_schema,
-    merge: config.merge,
-    rateLimit: config.rateLimit
-  };
-}
-function defineExperience(module) {
-  const m = module.manifest ?? {};
-  let initialState = module.initialState;
-  if (module.stateSchema && !initialState) {
-    try {
-      initialState = module.stateSchema.parse(void 0);
-    } catch {
-      try {
-        initialState = module.stateSchema.parse({});
-      } catch {
-      }
-    }
-  }
-  if (module.stateSchema && initialState) {
-    try {
-      module.stateSchema.parse(initialState);
-    } catch (err) {
-      console.warn(
-        `[vibevibes] initialState does not match stateSchema: ${err instanceof Error ? err.message : err}`
-      );
-    }
-  }
-  const rawParticipantSlots = module.participants ?? m.participantSlots ?? (module.agents || m.agentSlots)?.map((a) => ({ ...a, type: "ai" }));
-  const hasOrchestrator = rawParticipantSlots?.some((s) => s.role === "orchestrator");
-  const participantSlots = rawParticipantSlots ? hasOrchestrator ? rawParticipantSlots : [...rawParticipantSlots, { role: "orchestrator", type: "ai", maxInstances: 1 }] : [{ role: "orchestrator", type: "ai", maxInstances: 1 }];
-  const agentSlots = participantSlots?.filter(
-    (s) => s.type === "ai" || s.type === void 0 || s.type === "any"
-  ) ?? m.agentSlots ?? module.agents;
-  return {
-    ...module,
-    initialState,
-    manifest: {
-      ...m,
-      title: m.title || module.name || m.id,
-      version: m.version || "0.0.1",
-      requested_capabilities: m.requested_capabilities || ["state.write"],
-      participantSlots: participantSlots ?? m.participantSlots,
-      agentSlots: agentSlots ?? m.agentSlots
-    }
-  };
-}
-export {
-  defineExperience,
-  defineStream,
-  defineTest,
-  defineTool
-};
+export * from "./types";
+export * from "./define";

package/dist/server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @vibevibes/runtime — the server engine for vibevibes experiences.
+ *
+ * Single-room, single-experience architecture.
+ * AI agents join via MCP or HTTP. Humans join via browser.
+ * Tools are the only mutation path. State is server-authoritative.
+ */
+export interface ServerConfig {
+    /** Absolute path to the experience project root (where manifest.json or src/index.tsx lives). */
+    projectRoot: string;
+    /** Port to listen on. Defaults to 4321 or PORT env var. */
+    port?: number;
+}
+export declare function setPublicUrl(url: string): void;
+export declare function getBaseUrl(): string;
+export declare function startServer(config?: ServerConfig): Promise<import("http").Server>;
+export declare function setProjectRoot(root: string): void;