@aiworkbench/vibe-ide 0.0.1

package/dist/mcp/mcp-adapter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * WebContainer MCP tool executor.
+ *
+ * Refactored from usecase-editor to:
+ * - Accept configurable `onApprovalRequest` callback instead of window events
+ * - Accept configurable `maxToolSteps` instead of importing host constants
+ * - Not set any window globals (no `window.__VIBE_IDE_ADAPTER__`)
+ */
+import type { WebContainer } from "@webcontainer/api";
+import type { WebContainerMcpAdapterOptions } from "../types";
+import type { WebContainerToolCall } from "./mcp-tools";
+interface WriteCoalescer {
+    write(path: string, content: string): void;
+    flushImmediate?: (files: {
+        path: string;
+        content: string;
+    }[]) => Promise<void>;
+}
+export declare class WebContainerMcpAdapter {
+    private instance;
+    private coalescer?;
+    private devServerUrlReference;
+    private callCount;
+    private deleteCount;
+    private maxCallsPerCycle;
+    private maxDeletesBeforeApproval;
+    private onApprovalRequest?;
+    constructor(instance: WebContainer, coalescer?: WriteCoalescer | undefined, options?: WebContainerMcpAdapterOptions);
+    setDevServerUrl(url: string | null): void;
+    resetCallCount(): void;
+    private normalizePath;
+    private sanitizePath;
+    private isRequiresApproval;
+    private requestApproval;
+    private listFiles;
+    private ensureParentDirectory;
+    executeTool(toolCall: WebContainerToolCall): Promise<string>;
+}
+/**
+ * Create a WebContainer MCP adapter instance. Unlike the host version, this
+ * does NOT set `window.__VIBE_IDE_ADAPTER__` — the caller retains the reference.
+ */
+export declare function createWebContainerMcpAdapter(instance: WebContainer, coalescer?: WriteCoalescer, options?: WebContainerMcpAdapterOptions): WebContainerMcpAdapter;
+export {};
+//# sourceMappingURL=mcp-adapter.d.ts.map

package/dist/mcp/mcp-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-adapter.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AASxD,UAAU,cAAc;IACtB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,cAAc,CAAC,EAAE,CACf,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,KACvC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED,qBAAa,sBAAsB;IAY/B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS,CAAC;IAZpB,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,wBAAwB,CAAS;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAGH;gBAGb,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,cAAc,YAAA,EAClC,OAAO,CAAC,EAAE,6BAA6B;IAQlC,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIlC,cAAc;IAKrB,OAAO,CAAC,aAAa;IAiCrB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,kBAAkB;YAmBZ,eAAe;YAoCf,SAAS;YAsCT,qBAAqB;IAO7B,WAAW,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;CAoOnE;AAMD;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,cAAc,EAC1B,OAAO,CAAC,EAAE,6BAA6B,GACtC,sBAAsB,CAExB"}

package/dist/mcp/mcp-tools.d.ts

@@ -0,0 +1,467 @@
+/**
+ * Zod schemas and JSON tool definitions for WebContainer MCP tools.
+ */
+import { z } from "zod";
+export declare const webContainerToolArgumentSchemas: {
+    readonly read_file: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+    readonly write_file: z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+    }, {
+        path: string;
+        content: string;
+    }>;
+    readonly batch_write_files: z.ZodEffects<z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+        }, {
+            path: string;
+            content: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }>, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }>;
+    readonly delete_file: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+    readonly list_files: z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        recursive?: boolean | undefined;
+    }, {
+        path: string;
+        recursive?: boolean | undefined;
+    }>;
+    readonly list_dir: z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        recursive?: boolean | undefined;
+    }, {
+        path: string;
+        recursive?: boolean | undefined;
+    }>;
+    readonly get_project_structure: z.ZodObject<{
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        exclude?: string[] | undefined;
+    }, {
+        exclude?: string[] | undefined;
+    }>;
+    readonly get_preview_url: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    readonly run_command: z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args?: string[] | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+    }>;
+};
+export declare const WebContainerToolSchema: z.ZodUnion<[z.ZodObject<{
+    name: z.ZodLiteral<"read_file">;
+    arguments: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "read_file";
+    arguments: {
+        path: string;
+    };
+}, {
+    name: "read_file";
+    arguments: {
+        path: string;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"write_file">;
+    arguments: z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+    }, {
+        path: string;
+        content: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "write_file";
+    arguments: {
+        path: string;
+        content: string;
+    };
+}, {
+    name: "write_file";
+    arguments: {
+        path: string;
+        content: string;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"batch_write_files">;
+    arguments: z.ZodEffects<z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+        }, {
+            path: string;
+            content: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }>, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }, {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "batch_write_files";
+    arguments: {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    };
+}, {
+    name: "batch_write_files";
+    arguments: {
+        files: {
+            path: string;
+            content: string;
+        }[];
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"delete_file">;
+    arguments: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "delete_file";
+    arguments: {
+        path: string;
+    };
+}, {
+    name: "delete_file";
+    arguments: {
+        path: string;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"list_files">;
+    arguments: z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        recursive?: boolean | undefined;
+    }, {
+        path: string;
+        recursive?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "list_files";
+    arguments: {
+        path: string;
+        recursive?: boolean | undefined;
+    };
+}, {
+    name: "list_files";
+    arguments: {
+        path: string;
+        recursive?: boolean | undefined;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"list_dir">;
+    arguments: z.ZodObject<{
+        path: z.ZodString;
+        recursive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        recursive?: boolean | undefined;
+    }, {
+        path: string;
+        recursive?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "list_dir";
+    arguments: {
+        path: string;
+        recursive?: boolean | undefined;
+    };
+}, {
+    name: "list_dir";
+    arguments: {
+        path: string;
+        recursive?: boolean | undefined;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"get_project_structure">;
+    arguments: z.ZodObject<{
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        exclude?: string[] | undefined;
+    }, {
+        exclude?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "get_project_structure";
+    arguments: {
+        exclude?: string[] | undefined;
+    };
+}, {
+    name: "get_project_structure";
+    arguments: {
+        exclude?: string[] | undefined;
+    };
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"get_preview_url">;
+    arguments: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    name: "get_preview_url";
+    arguments: {};
+}, {
+    name: "get_preview_url";
+    arguments: {};
+}>, z.ZodObject<{
+    name: z.ZodLiteral<"run_command">;
+    arguments: z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args?: string[] | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: "run_command";
+    arguments: {
+        command: string;
+        args?: string[] | undefined;
+    };
+}, {
+    name: "run_command";
+    arguments: {
+        command: string;
+        args?: string[] | undefined;
+    };
+}>]>;
+export type WebContainerToolCall = z.infer<typeof WebContainerToolSchema>;
+export declare const webContainerToolsDefinition: ({
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description?: undefined;
+            };
+            content?: undefined;
+            files?: undefined;
+            recursive?: undefined;
+            exclude?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description?: undefined;
+            };
+            content: {
+                type: string;
+            };
+            files?: undefined;
+            recursive?: undefined;
+            exclude?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        path: {
+                            type: string;
+                        };
+                        content: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            path?: undefined;
+            content?: undefined;
+            recursive?: undefined;
+            exclude?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            recursive: {
+                type: string;
+            };
+            content?: undefined;
+            files?: undefined;
+            exclude?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            exclude: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            path?: undefined;
+            content?: undefined;
+            files?: undefined;
+            recursive?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path?: undefined;
+            content?: undefined;
+            files?: undefined;
+            recursive?: undefined;
+            exclude?: undefined;
+            command?: undefined;
+            args?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            command: {
+                type: string;
+            };
+            args: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            path?: undefined;
+            content?: undefined;
+            files?: undefined;
+            recursive?: undefined;
+            exclude?: undefined;
+        };
+        required: string[];
+    };
+})[];
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/mcp/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClC,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqCjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgGvC,CAAC"}

package/dist/react/provider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * VibeIdeProvider — top-level context provider managing the WebContainer
+ * lifecycle. Accepts Bridge, chat adapter, and preview policy from the host.
+ *
+ * No Redux, no Next.js, no `@aiworkbench/vibe-bridge` — all host-specific
+ * concerns flow through the typed adapter interfaces.
+ */
+import React from "react";
+import type { VibeIdeContextValue, VibeIdeProviderProps } from "../types";
+export declare const VibeIdeContext: React.Context<VibeIdeContextValue | null>;
+export declare function VibeIdeProvider({ draftId, templateId, bridge, chat, previewPolicy: previewPolicyProp, persistence, approval, templateVars, initialTree, bootOptions, children, }: VibeIdeProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/react/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/react/provider.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAON,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EAGV,mBAAmB,EAGnB,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAQlB,eAAO,MAAM,cAAc,2CAAkD,CAAC;AA8B9E,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,UAAU,EACV,MAAM,EACN,IAAI,EACJ,aAAa,EAAE,iBAAiB,EAChC,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,WAAW,EACX,QAAQ,GACT,EAAE,oBAAoB,2CA2MtB"}

package/dist/react/use-vibe-ide.d.ts

@@ -0,0 +1,11 @@
+/**
+ * useVibeIde — context consumer hook for the VibeIdeProvider.
+ */
+import type { VibeIdeContextValue } from "../types";
+/**
+ * Access the IDE context. Must be used within a `<VibeIdeProvider>`.
+ *
+ * @throws If called outside a provider.
+ */
+export declare function useVibeIde(): VibeIdeContextValue;
+//# sourceMappingURL=use-vibe-ide.d.ts.map

package/dist/react/use-vibe-ide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-vibe-ide.d.ts","sourceRoot":"","sources":["../../src/react/use-vibe-ide.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,mBAAmB,CAMhD"}

package/dist/react/vibe-ide-bridge-relay.d.ts

@@ -0,0 +1,14 @@
+/**
+ * VibeIdeBridgeRelay — capability-gated bridge relay between the host and
+ * the preview iframe.
+ *
+ * Refactored from usecase-editor's `bridge-relay.tsx`:
+ * - No Redux, no `useIde()` — uses `useVibeIde()` from this package
+ * - Uses host's `previewPolicy` for approval instead of hardcoded constants
+ * - Self-contained approval dialog (no dependency on host UI)
+ */
+import React from "react";
+export declare function VibeIdeBridgeRelay({ iframeRef, }: {
+    iframeRef: React.RefObject<HTMLIFrameElement | null>;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=vibe-ide-bridge-relay.d.ts.map

package/dist/react/vibe-ide-bridge-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibe-ide-bridge-relay.d.ts","sourceRoot":"","sources":["../../src/react/vibe-ide-bridge-relay.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAmD,MAAM,OAAO,CAAC;AA8ExE,wBAAgB,kBAAkB,CAAC,EACjC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;CACtD,kDAweA"}

package/dist/react/vibe-ide-layout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * VibeIdeSplitLayout — two-pane IDE layout with a resizable split.
+ *
+ * Uses pure CSS resize (no `react-split` dependency) for the left/right split.
+ * The host provides `leftPane` content; the right pane is managed internally
+ * (Preview / Code / Terminal tabs).
+ */
+import type { VibeIdeSplitLayoutProps } from "../types";
+export declare function VibeIdeSplitLayout({ leftPane, toolbar, }: VibeIdeSplitLayoutProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=vibe-ide-layout.d.ts.map

package/dist/react/vibe-ide-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibe-ide-layout.d.ts","sourceRoot":"","sources":["../../src/react/vibe-ide-layout.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAgB,MAAM,UAAU,CAAC;AAuEtE,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,OAAO,GACR,EAAE,uBAAuB,2CAqFzB"}

package/dist/react/vibe-ide-preview-pane.d.ts

@@ -0,0 +1,7 @@
+/**
+ * VibeIdePreviewPane — iframe with loading/blocked/error overlays.
+ *
+ * Renders the BridgeRelay as a sibling to gate bridge capabilities.
+ */
+export declare function VibeIdePreviewPane(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=vibe-ide-preview-pane.d.ts.map

package/dist/react/vibe-ide-preview-pane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibe-ide-preview-pane.d.ts","sourceRoot":"","sources":["../../src/react/vibe-ide-preview-pane.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAgB,kBAAkB,4CAwIjC"}

package/dist/react/vibe-ide-toolbar.d.ts

@@ -0,0 +1,15 @@
+/**
+ * VibeIdeToolbar — tab pills, URL bar, and restart button for the right pane.
+ *
+ * No Redux — reads/writes `activeRightPane` from the IDE context.
+ */
+import React from "react";
+interface VibeIdeToolbarProps {
+    /** Extra toolbar content injected after the tab pills. */
+    extra?: React.ReactNode;
+    /** Collapse callback — hides the left pane. */
+    onCollapse?: () => void;
+}
+export declare function VibeIdeToolbar({ extra, onCollapse }: VibeIdeToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=vibe-ide-toolbar.d.ts.map

package/dist/react/vibe-ide-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibe-ide-toolbar.d.ts","sourceRoot":"","sources":["../../src/react/vibe-ide-toolbar.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAU1B,UAAU,mBAAmB;IAC3B,0DAA0D;IAC1D,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,wBAAgB,cAAc,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,mBAAmB,2CAkHxE"}

package/dist/templates/generated.d.ts

@@ -0,0 +1,22 @@
+/**
+ * IDE template generator — produces FileSystemTree objects from the official
+ * vibe-kit/templates/* source of truth, with IDE-specific modifications:
+ *
+ * 1. Strips the dev toolbar from index.html
+ * 2. Adds the `vibe-dev-bridge-injector` Vite plugin
+ * 3. Resolves Eta placeholders (<%= it.xxx %>) with IDE defaults or user vars
+ * 4. Adds `toast` to default manifest permissions
+ * 5. Omits `.env.example`, `.gitignore`, `mock-bridge.ts` (not needed in IDE)
+ */
+import type { FileSystemTree } from "@webcontainer/api";
+import type { TemplateId, TemplateVars } from "../types";
+/**
+ * Generate a `FileSystemTree` for the IDE, derived from the official
+ * vibe-kit templates with IDE-specific modifications applied.
+ *
+ * @param templateId - Which framework template to generate
+ * @param templateVars - Optional overrides for project name, permissions, etc.
+ * @returns A `FileSystemTree` ready to mount into a WebContainer
+ */
+export declare function getVibeIdeTemplateTree(templateId: TemplateId, templateVars?: TemplateVars): FileSystemTree;
+//# sourceMappingURL=generated.d.ts.map

package/dist/templates/generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated.d.ts","sourceRoot":"","sources":["../../src/templates/generated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAggBzD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,YAAY,GAC1B,cAAc,CAkBhB"}