@feltdb/core 0.4.4 → 0.4.6

package/dist/react/useFeltDB.js

@@ -0,0 +1,350 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * useFeltDB - React hook for FeltDB integration
+ *
+ * This module provides React hooks for easily integrating FeltDB
+ * into React applications with automatic state management.
+ *
+ * Usage:
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList() {
+ *   const users = useFeltDB("users");
+ *
+ *   const addUser = (name, email) => {
+ *     users.insert(name, email);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {users.records.map(user => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import { useState, useEffect, useCallback, useRef } from 'react';
+/**
+ * React hook for FeltDB state-first collections
+ *
+ * This is a thin adapter that bridges React state management with FeltDB's
+ * unified state model. All applications (React, Vue, Svelte) use the same
+ * underlying Collection semantics.
+ *
+ * @param collection A FeltDB Collection (live application state)
+ * @param options Configuration options
+ * @returns UseFeltDBResult with records and helper methods
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from 'feltdb/useFeltDB';
+ *
+ * function UserList({ collection }) {
+ *   const { records, loading, error, insert, update } = useFeltDB(collection);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user) => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useFeltDB(collection, options = {}) {
+    const [records, setRecords] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const unsubscribeRef = useRef(null);
+    // Subscribe to collection updates
+    useEffect(() => {
+        if (!collection) {
+            setLoading(false);
+            return;
+        }
+        let isMounted = true;
+        const subscribe = async () => {
+            try {
+                setLoading(true);
+                // Initial load
+                const data = await collection.all();
+                if (isMounted) {
+                    setRecords(data);
+                    setError(null);
+                    options.onUpdate?.(data);
+                }
+                // Subscribe to live updates
+                const unsubscribe = collection.subscribe((updatedData) => {
+                    if (isMounted) {
+                        setRecords(updatedData);
+                        setError(null);
+                        options.onUpdate?.(updatedData);
+                    }
+                }, options.refreshInterval);
+                unsubscribeRef.current = unsubscribe;
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : "Failed to load collection";
+                if (isMounted) {
+                    setError(errorMsg);
+                    options.onError?.(errorMsg);
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setLoading(false);
+                }
+            }
+        };
+        subscribe();
+        // Cleanup
+        return () => {
+            isMounted = false;
+            if (unsubscribeRef.current) {
+                unsubscribeRef.current();
+            }
+        };
+    }, [collection, options]);
+    // Insert a new record
+    const insert = useCallback((key, data) => {
+        if (!collection) {
+            setError("Collection not initialized");
+            return false;
+        }
+        try {
+            const [, id] = key.split(':');
+            collection.insert(data, id);
+            return true;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Insert failed";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+            return false;
+        }
+    }, [collection, options]);
+    // Get a single record
+    const get = useCallback((key) => {
+        if (!collection) {
+            return null;
+        }
+        try {
+            const [, id] = key.split(':');
+            // This would need to be async in a real implementation
+            // For now, return null since we can't await in a sync callback
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }, [collection]);
+    // Update a record
+    const update = useCallback(async (id, changes) => {
+        if (!collection) {
+            throw new Error("Collection not initialized");
+        }
+        await collection.update(id, changes);
+    }, [collection]);
+    // Delete a record
+    const deleteRecord = useCallback(async (id) => {
+        if (!collection) {
+            throw new Error("Collection not initialized");
+        }
+        await collection.delete(id);
+    }, [collection]);
+    // Manual refresh
+    const refresh = useCallback(async () => {
+        if (!collection) {
+            return;
+        }
+        await collection.refresh();
+    }, [collection]);
+    return {
+        records,
+        loading,
+        error,
+        insert,
+        get,
+        refresh,
+        update,
+        delete: deleteRecord,
+    };
+}
+/**
+ * Legacy compatibility: React hook for FeltDB capability queries
+ * Uses the low-level JsDb API for backward compatibility.
+ *
+ * New code should use useFeltDB with Collections instead.
+ */
+export function useLegacyFeltDB(db, capability, options = {}) {
+    const [records, setRecords] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const refreshIntervalRef = useRef(null);
+    // Fetch records from database
+    const fetchRecords = useCallback(() => {
+        if (!db) {
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            const result = db.query(capability);
+            if (result.success && result.data) {
+                const parsedRecords = JSON.parse(result.data);
+                setRecords(parsedRecords);
+                setError(null);
+                options.onUpdate?.(parsedRecords);
+            }
+            else {
+                setError(result.error || "Unknown error");
+                options.onError?.(result.error || "Unknown error");
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Failed to fetch records";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [db, capability, options]);
+    // Initial fetch
+    useEffect(() => {
+        fetchRecords();
+    }, [fetchRecords]);
+    // Setup auto-refresh interval
+    useEffect(() => {
+        if (options.refreshInterval && options.refreshInterval > 0) {
+            refreshIntervalRef.current = setInterval(fetchRecords, options.refreshInterval);
+            return () => {
+                if (refreshIntervalRef.current) {
+                    clearInterval(refreshIntervalRef.current);
+                }
+            };
+        }
+    }, [fetchRecords, options.refreshInterval]);
+    // Insert a new record
+    const insert = useCallback((key, data) => {
+        if (!db) {
+            setError("Database not initialized");
+            return false;
+        }
+        try {
+            const result = db.insert(key, JSON.stringify(data));
+            if (result.success) {
+                fetchRecords(); // Refresh after insert
+                return true;
+            }
+            else {
+                setError(result.error || "Insert failed");
+                options.onError?.(result.error || "Insert failed");
+                return false;
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Insert failed";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+            return false;
+        }
+    }, [db, fetchRecords, options]);
+    // Get a single record
+    const get = useCallback((key) => {
+        if (!db) {
+            return null;
+        }
+        try {
+            const result = db.get(key);
+            if (result.success && result.data) {
+                return JSON.parse(result.data);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }, [db]);
+    return {
+        records,
+        loading,
+        error,
+        insert,
+        get,
+        refresh: fetchRecords,
+        update: async () => { },
+        delete: async () => { },
+    };
+}
+/**
+ * Higher-order component for wrapping components with FeltDB
+ *
+ * @param Component React component that receives db and useFeltDB hook
+ * @param dbPath Path to the database file
+ * @returns Wrapped component
+ *
+ * @example
+ * ```jsx
+ * const UserListWithDb = withFeltDB(UserList, "app.db");
+ * ```
+ */
+export function withFeltDB(Component, dbPath) {
+    return (props) => {
+        const [db, setDb] = useState(null);
+        const [dbError, setDbError] = useState(null);
+        useEffect(() => {
+            try {
+                // Dynamically import feltdb module (WASM module)
+                import('@feltdb/core/wasm').then((feltdb) => {
+                    setDb(feltdb.open(dbPath));
+                }).catch((err) => {
+                    setDbError(`Failed to load FeltDB: ${err.message}`);
+                });
+            }
+            catch (err) {
+                setDbError(err instanceof Error ? err.message : "Unknown error");
+            }
+        }, []);
+        if (dbError) {
+            return _jsxs("div", { className: "error", children: ["Database Error: ", dbError] });
+        }
+        if (!db) {
+            return _jsx("div", { className: "loading", children: "Loading database..." });
+        }
+        return _jsx(Component, { ...props, db: db });
+    };
+}
+/**
+ * Example component using useFeltDB
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList({ db }) {
+ *   const { records, loading, error, insert } = useFeltDB(db, "users", {
+ *     refreshInterval: 5000, // Refresh every 5 seconds
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user: any) => (
+ *         <div key={user.id}>{user.name} ({user.email})</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export default useFeltDB;

package/dist/studio/.gitkeep

@@ -0,0 +1 @@
+# Public assets for FeltDB Studio

package/dist/studio/KeyManagementPanel-BOvWTRyH.js

@@ -0,0 +1,246 @@
+import { useEffect as e, useState as t } from "react";
+import { jsx as n, jsxs as r } from "react/jsx-runtime";
+var i = {
+	panel: "_panel_1cbba_1",
+	header: "_header_1cbba_8",
+	createButton: "_createButton_1cbba_23",
+	error: "_error_1cbba_38",
+	createForm: "_createForm_1cbba_47",
+	formGroup: "_formGroup_1cbba_55",
+	scopeList: "_scopeList_1cbba_76",
+	scopeCheckbox: "_scopeCheckbox_1cbba_82",
+	submitButton: "_submitButton_1cbba_94",
+	empty: "_empty_1cbba_109",
+	keysList: "_keysList_1cbba_117",
+	keyCard: "_keyCard_1cbba_123",
+	keyHeader: "_keyHeader_1cbba_135",
+	namespace: "_namespace_1cbba_150",
+	status: "_status_1cbba_156",
+	active: "_active_1cbba_163",
+	expired: "_expired_1cbba_168",
+	keyDetails: "_keyDetails_1cbba_173",
+	detail: "_detail_1cbba_179",
+	copyBtn: "_copyBtn_1cbba_203",
+	daysLeft: "_daysLeft_1cbba_217",
+	scopes: "_scopes_1cbba_223",
+	scopeTags: "_scopeTags_1cbba_227",
+	scopeTag: "_scopeTag_1cbba_227",
+	keyActions: "_keyActions_1cbba_243",
+	revokeBtn: "_revokeBtn_1cbba_250",
+	info: "_info_1cbba_265"
+}, a = ({ apiUrl: a, token: o, namespace: s = "app-store-sherpa" }) => {
+	let [c, l] = t([]), [u, d] = t(!0), [f, p] = t(null), [m, h] = t(!1), [g, _] = t(null), [v, y] = t(""), [b, x] = t([
+		"state:read",
+		"state:write",
+		"events:read"
+	]), S = [
+		"state:read",
+		"state:write",
+		"events:read",
+		"backup:create",
+		"backup:restore",
+		"admin:logs",
+		"admin:restart"
+	], C = [
+		"state:read",
+		"state:write",
+		"events:read",
+		"backup:create",
+		"backup:restore",
+		"admin:logs",
+		"admin:restart"
+	];
+	e(() => {
+		w();
+	}, []);
+	let w = async () => {
+		try {
+			d(!0), p(null);
+			let e = await fetch(`${a}/api/keys`, { headers: { Authorization: `Bearer ${o}` } });
+			if (!e.ok) throw Error(`Failed to fetch keys: ${e.statusText}`);
+			let t = await e.json();
+			l(t.tokens || []);
+		} catch (e) {
+			p(e instanceof Error ? e.message : "Failed to fetch keys");
+		} finally {
+			d(!1);
+		}
+	}, T = async (e) => {
+		e.preventDefault();
+		try {
+			let e = await fetch(`${a}/api/keys`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${o}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					id: v || `key-${Date.now()}`,
+					namespace: s,
+					scopes: b.length > 0 ? b : C,
+					expiresIn: 90
+				})
+			});
+			if (!e.ok) throw Error(`Failed to create key: ${e.statusText}`);
+			y(""), x(C), h(!1), await w();
+		} catch (e) {
+			p(e instanceof Error ? e.message : "Failed to create key");
+		}
+	}, E = async (e) => {
+		if (confirm(`Revoke key "${e}"? This cannot be undone.`)) try {
+			let t = await fetch(`${a}/api/keys/${e}`, {
+				method: "DELETE",
+				headers: { Authorization: `Bearer ${o}` }
+			});
+			if (!t.ok) throw Error(`Failed to revoke key: ${t.statusText}`);
+			await w();
+		} catch (e) {
+			p(e instanceof Error ? e.message : "Failed to revoke key");
+		}
+	}, D = (e, t) => {
+		navigator.clipboard.writeText(e), _(t), setTimeout(() => _(null), 2e3);
+	}, O = (e) => new Date(e).toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit"
+	}), k = (e) => new Date(e) < /* @__PURE__ */ new Date(), A = (e) => Math.ceil((new Date(e).getTime() - (/* @__PURE__ */ new Date()).getTime()) / 864e5);
+	return u ? /* @__PURE__ */ n("div", {
+		className: i.panel,
+		children: "Loading keys..."
+	}) : /* @__PURE__ */ r("div", {
+		className: i.panel,
+		children: [
+			/* @__PURE__ */ r("div", {
+				className: i.header,
+				children: [/* @__PURE__ */ n("h2", { children: "API Key Management" }), /* @__PURE__ */ n("button", {
+					className: i.createButton,
+					onClick: () => h(!m),
+					children: m ? "✕ Cancel" : "+ New Key"
+				})]
+			}),
+			f && /* @__PURE__ */ r("div", {
+				className: i.error,
+				children: ["⚠ ", f]
+			}),
+			m && /* @__PURE__ */ r("form", {
+				onSubmit: T,
+				className: i.createForm,
+				children: [
+					/* @__PURE__ */ r("div", {
+						className: i.formGroup,
+						children: [/* @__PURE__ */ n("label", { children: "Key Name (optional)" }), /* @__PURE__ */ n("input", {
+							type: "text",
+							value: v,
+							onChange: (e) => y(e.target.value),
+							placeholder: "e.g., staging-key-001"
+						})]
+					}),
+					/* @__PURE__ */ r("div", {
+						className: i.formGroup,
+						children: [/* @__PURE__ */ n("label", { children: "Scopes" }), /* @__PURE__ */ n("div", {
+							className: i.scopeList,
+							children: S.map((e) => /* @__PURE__ */ r("label", {
+								className: i.scopeCheckbox,
+								children: [/* @__PURE__ */ n("input", {
+									type: "checkbox",
+									checked: b.includes(e),
+									onChange: (t) => {
+										t.target.checked ? x([...b, e]) : x(b.filter((t) => t !== e));
+									}
+								}), e]
+							}, e))
+						})]
+					}),
+					/* @__PURE__ */ n("button", {
+						type: "submit",
+						className: i.submitButton,
+						children: "Create Key"
+					})
+				]
+			}),
+			c.length === 0 ? /* @__PURE__ */ n("div", {
+				className: i.empty,
+				children: "No API keys configured. Create one to get started."
+			}) : /* @__PURE__ */ n("div", {
+				className: i.keysList,
+				children: c.map((e) => /* @__PURE__ */ r("div", {
+					className: i.keyCard,
+					children: [
+						/* @__PURE__ */ r("div", {
+							className: i.keyHeader,
+							children: [/* @__PURE__ */ r("div", { children: [/* @__PURE__ */ n("h3", { children: e.id }), /* @__PURE__ */ r("p", {
+								className: i.namespace,
+								children: ["Namespace: ", e.namespace]
+							})] }), /* @__PURE__ */ n("span", {
+								className: `${i.status} ${k(e.expires_at) ? i.expired : i.active}`,
+								children: k(e.expires_at) ? "Expired" : "Active"
+							})]
+						}),
+						/* @__PURE__ */ r("div", {
+							className: i.keyDetails,
+							children: [
+								/* @__PURE__ */ r("div", {
+									className: i.detail,
+									children: [
+										/* @__PURE__ */ n("strong", { children: "Secret:" }),
+										/* @__PURE__ */ r("code", { children: [e.secret.substring(0, 20), "..."] }),
+										/* @__PURE__ */ n("button", {
+											className: i.copyBtn,
+											onClick: () => D(e.secret, e.id),
+											children: g === e.id ? "✓ Copied" : "Copy"
+										})
+									]
+								}),
+								/* @__PURE__ */ r("div", {
+									className: i.detail,
+									children: [/* @__PURE__ */ n("strong", { children: "Created:" }), /* @__PURE__ */ n("span", { children: O(e.created_at) })]
+								}),
+								/* @__PURE__ */ r("div", {
+									className: i.detail,
+									children: [/* @__PURE__ */ n("strong", { children: "Expires:" }), /* @__PURE__ */ r("span", { children: [O(e.expires_at), !k(e.expires_at) && /* @__PURE__ */ r("span", {
+										className: i.daysLeft,
+										children: [
+											"(",
+											A(e.expires_at),
+											" days)"
+										]
+									})] })]
+								}),
+								e.last_used && /* @__PURE__ */ r("div", {
+									className: i.detail,
+									children: [/* @__PURE__ */ n("strong", { children: "Last Used:" }), /* @__PURE__ */ n("span", { children: O(e.last_used) })]
+								}),
+								/* @__PURE__ */ r("div", {
+									className: i.scopes,
+									children: [/* @__PURE__ */ n("strong", { children: "Scopes:" }), /* @__PURE__ */ n("div", {
+										className: i.scopeTags,
+										children: e.scopes.map((e) => /* @__PURE__ */ n("span", {
+											className: i.scopeTag,
+											children: e
+										}, e))
+									})]
+								})
+							]
+						}),
+						/* @__PURE__ */ n("div", {
+							className: i.keyActions,
+							children: /* @__PURE__ */ n("button", {
+								className: i.revokeBtn,
+								onClick: () => E(e.id),
+								children: "Revoke"
+							})
+						})
+					]
+				}, e.id))
+			}),
+			/* @__PURE__ */ n("div", {
+				className: i.info,
+				children: /* @__PURE__ */ r("p", { children: [/* @__PURE__ */ n("strong", { children: "Security:" }), " Store tokens securely. Never commit to version control. Tokens expire after 90 days."] })
+			})
+		]
+	});
+};
+//#endregion
+export { a as t };

package/dist/studio/app.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { StateFirstDB } from '@feltdb/core';
+export interface StudioAppProps {
+    db?: StateFirstDB;
+    remoteUrl?: string;
+    namespace?: string;
+}
+export declare function StudioApp({ db, remoteUrl, namespace }: StudioAppProps): React.JSX.Element;
+export default StudioApp;
+//# sourceMappingURL=app.d.ts.map

package/dist/studio/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAmBnD,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,SAAqB,EAAE,EAAE,cAAc,qBA2GjF;AAED,eAAe,SAAS,CAAC"}

package/dist/studio/components/AgentExplorer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FlowSpec, StateFirstDB } from '@feltdb/core';
+export interface AgentExplorerProps {
+    db?: StateFirstDB;
+    model?: FlowSpec | null;
+}
+export declare function AgentExplorer({ model }: AgentExplorerProps): React.JSX.Element;
+export default AgentExplorer;
+//# sourceMappingURL=AgentExplorer.d.ts.map

package/dist/studio/components/AgentExplorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentExplorer.d.ts","sourceRoot":"","sources":["../../src/components/AgentExplorer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAA;CAAE;AAElF,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE,EAAE,kBAAkB,qBAK1D;AACD,eAAe,aAAa,CAAC"}

package/dist/studio/components/ApplicationDesigner.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { StateFirstDB, FlowSpec } from '@feltdb/core';
+export interface ApplicationDesignerProps {
+    db?: StateFirstDB;
+    namespace?: string;
+    projectSpec?: FlowSpec | null;
+    onSpecChange?: (spec: FlowSpec) => void;
+}
+export declare function ApplicationDesigner({ db, namespace, projectSpec, onSpecChange }: ApplicationDesignerProps): React.JSX.Element;
+export default ApplicationDesigner;
+//# sourceMappingURL=ApplicationDesigner.d.ts.map

package/dist/studio/components/ApplicationDesigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationDesigner.d.ts","sourceRoot":"","sources":["../../src/components/ApplicationDesigner.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAU3E,MAAM,WAAW,wBAAwB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAA;CAAE;AAE3J,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,SAAqB,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,wBAAwB,qBAsGrH;AACD,eAAe,mBAAmB,CAAC"}

package/dist/studio/components/CapabilityExplorer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FlowSpec, StateFirstDB } from '@feltdb/core';
+export interface CapabilityExplorerProps {
+    db?: StateFirstDB;
+    model?: FlowSpec | null;
+}
+export declare function CapabilityExplorer({ model }: CapabilityExplorerProps): React.JSX.Element;
+export default CapabilityExplorer;
+//# sourceMappingURL=CapabilityExplorer.d.ts.map

package/dist/studio/components/CapabilityExplorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityExplorer.d.ts","sourceRoot":"","sources":["../../src/components/CapabilityExplorer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,WAAW,uBAAuB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAA;CAAE;AAEvF,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,EAAE,uBAAuB,qBAMpE;AACD,eAAe,kBAAkB,CAAC"}

package/dist/studio/components/ConflictExplorer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { RuntimeDiagnostics, StateFirstDB } from '@feltdb/core';
+export interface ConflictExplorerProps {
+    db?: StateFirstDB;
+    diagnostics?: RuntimeDiagnostics | null;
+}
+export declare function ConflictExplorer({ db, diagnostics }: ConflictExplorerProps): React.JSX.Element;
+export default ConflictExplorer;
+//# sourceMappingURL=ConflictExplorer.d.ts.map

package/dist/studio/components/ConflictExplorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConflictExplorer.d.ts","sourceRoot":"","sources":["../../src/components/ConflictExplorer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACrE,MAAM,WAAW,qBAAqB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,WAAW,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAA;CAAE;AACrG,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,qBAAqB,qBAG1E;AACD,eAAe,gBAAgB,CAAC"}

package/dist/studio/components/ExecutionViewer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FlowSpec, StateFirstDB } from '@feltdb/core';
+export interface ExecutionViewerProps {
+    db?: StateFirstDB;
+    model?: FlowSpec | null;
+}
+export declare function ExecutionViewer({ db, model }: ExecutionViewerProps): React.JSX.Element;
+export default ExecutionViewer;
+//# sourceMappingURL=ExecutionViewer.d.ts.map

package/dist/studio/components/ExecutionViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionViewer.d.ts","sourceRoot":"","sources":["../../src/components/ExecutionViewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG3D,MAAM,WAAW,oBAAoB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAA;CAAE;AAQpF,wBAAgB,eAAe,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,oBAAoB,qBAOlE;AACD,eAAe,eAAe,CAAC"}