@dxos/plugin-script 0.8.3 → 0.8.4-main.1c7ec43d41

package/dist/lib/node-esm/NotebookContainer-DPT65MA7.mjs

@@ -0,0 +1,761 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import "./chunk-HSLMI22Q.mjs";
+
+// src/containers/NotebookContainer/NotebookContainer.tsx
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import React, { useCallback, useContext, useMemo, useState } from "react";
+import { AgentPrompt } from "@dxos/assistant-toolkit";
+import { Blueprint, Routine } from "@dxos/compute";
+import { Operation } from "@dxos/compute";
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+import { QueryBuilder } from "@dxos/echo-query";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { useComputeRuntimeCallback } from "@dxos/plugin-automation/hooks";
+import { Graph } from "@dxos/plugin-explorer/types";
+import { DropdownMenu, IconButton, Panel, Toolbar, useTranslation } from "@dxos/react-ui";
+import { useAttention } from "@dxos/react-ui-attention";
+import { Text, ViewModel } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
+import { NotebookMenu, NotebookStack } from "#components";
+import { meta } from "#meta";
+
+// src/notebook/compute-graph.ts
+import { Atom } from "@effect-atom/atom-react";
+import { log } from "@dxos/log";
+
+// src/notebook/eval.ts
+import { trim } from "@dxos/util";
+var evalScript = async (code, deps = {}) => {
+  const sandbox = {
+    ...deps,
+    // Block access to global objects.
+    console: void 0,
+    document: void 0,
+    global: void 0,
+    globalThis: void 0,
+    self: void 0,
+    window: void 0,
+    // Allow some safe globals.
+    Array,
+    Boolean,
+    Date,
+    Error,
+    JSON,
+    Map,
+    Math,
+    Number,
+    Object,
+    Promise,
+    RegExp,
+    Set,
+    String,
+    // Functions.
+    isFinite,
+    isNaN,
+    parseFloat,
+    parseInt
+  };
+  const sandboxKeys = Object.keys(sandbox);
+  const sandboxValues = Object.values(sandbox);
+  const fn2 = new Function(...sandboxKeys, trim`
+      'use strict';
+      return ${code};
+    `);
+  return fn2(...sandboxValues);
+};
+var builtIns = /* @__PURE__ */ new Set([
+  // Types.
+  "Array",
+  "Date",
+  "Error",
+  "JSON",
+  "Map",
+  "Math",
+  "Number",
+  "Object",
+  "Promise",
+  "RegExp",
+  "Set",
+  "String",
+  // Functions.
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt"
+]);
+var systemDefinitions = trim`
+  interface Array<T> { length: number; [n: number]: T; }
+  interface Boolean {}
+  interface Function {}
+  interface IArguments {}
+  interface Number {}
+  interface Object {}
+  interface RegExp {}
+  interface String { length: number; }
+
+  interface CallableFunction extends Function {}
+  interface NewableFunction extends Function {}
+
+  declare var console: { log(...args: any[]): void };
+`;
+
+// src/notebook/vfs-parser.ts
+import { createSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
+import ts from "typescript";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/vfs-parser.ts";
+var systemFiles = [
+  {
+    filename: "/lib.d.ts",
+    content: systemDefinitions
+  }
+];
+var VirtualTypeScriptParser = class {
+  compilerOptions = {
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    forceConsistentCasingInfilenames: true,
+    jsx: ts.JsxEmit.React,
+    noLib: true
+  };
+  /**
+  * Parse a single expression or statement.
+  */
+  parseExpression(input) {
+    invariant(input.trim() !== "", "input must not be empty", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 34, S: this, A: ["input.trim() !== ''", "'input must not be empty'"] });
+    const files = [
+      {
+        filename: "/temp.ts",
+        content: input
+      }
+    ];
+    const analysis = this.analyzeFiles(files);
+    if (analysis.length === 0) {
+      const sourcefilename = "/temp.ts";
+      const env = this.createEnvironment([
+        {
+          filename: sourcefilename,
+          content: input
+        }
+      ]);
+      const sourceFile = env.getSourceFile(sourcefilename);
+      const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+      if (sourceFile && typeChecker) {
+        const assignmentInfo = this.findAssignmentExpression(sourceFile, typeChecker);
+        if (assignmentInfo) {
+          return assignmentInfo;
+        }
+        const references = this.findAllReferences(sourceFile, typeChecker);
+        return {
+          references
+        };
+      }
+    }
+    return analysis[0];
+  }
+  /**
+  * Analyze multiple files with full type information.
+  */
+  analyzeFiles(files) {
+    const env = this.createEnvironment(files);
+    const results = [];
+    const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+    files.forEach((file) => {
+      const sourceFile = env.getSourceFile(file.filename);
+      if (!sourceFile || !typeChecker) {
+        return;
+      }
+      const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
+      results.push(...fileResults);
+    });
+    return results;
+  }
+  /**
+  * Analyze a source file with type information.
+  */
+  analyzeSourceFile(sourceFile, typeChecker) {
+    const results = [];
+    const visit = (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        const symbol = typeChecker.getSymbolAtLocation(node.name);
+        const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+        const signature = type && typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)[0];
+        results.push({
+          name: node.name.text,
+          type: "function",
+          parameters: this.extractParameters(signature, typeChecker),
+          returnType: signature ? typeChecker.typeToString(signature.getReturnType()) : "any",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      } else if (ts.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((declaration) => {
+          if (ts.isIdentifier(declaration.name)) {
+            const symbol = typeChecker.getSymbolAtLocation(declaration.name);
+            const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
+            let kind = "variable";
+            let parameters;
+            let returnType;
+            let value;
+            const typeString = type ? typeChecker.typeToString(type) : "any";
+            if (declaration.initializer) {
+              if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+                kind = "function";
+                const funcType = typeChecker.getTypeAtLocation(declaration.initializer);
+                const signature = typeChecker.getSignaturesOfType(funcType, ts.SignatureKind.Call)[0];
+                if (signature) {
+                  parameters = this.extractParameters(signature, typeChecker);
+                  returnType = typeChecker.typeToString(signature.getReturnType());
+                }
+              } else {
+                if (ts.isNumericLiteral(declaration.initializer)) {
+                  value = Number(declaration.initializer.text);
+                } else if (ts.isStringLiteral(declaration.initializer)) {
+                  value = declaration.initializer.text;
+                }
+              }
+            }
+            const refs = declaration.initializer ? this.findReferences(declaration.initializer, sourceFile, typeChecker) : [];
+            results.push({
+              name: declaration.name.text,
+              type: kind,
+              valueType: typeString,
+              value,
+              parameters,
+              returnType,
+              references: refs
+            });
+          }
+        });
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        results.push({
+          name: node.name.text,
+          type: "class",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      } else if (ts.isInterfaceDeclaration(node)) {
+        results.push({
+          name: node.name.text,
+          type: "interface",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return results;
+  }
+  /**
+  * Extract parameter information from a signature.
+  */
+  extractParameters(signature, typeChecker) {
+    if (!signature) {
+      return [];
+    }
+    return signature.parameters.map((param) => ({
+      name: param.getName(),
+      type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(param, param.valueDeclaration))
+    }));
+  }
+  /**
+  * Find all references to variables used in a node.
+  */
+  findReferences(node, _sourceFile, _typeChecker) {
+    const references = /* @__PURE__ */ new Set();
+    const localSymbols = /* @__PURE__ */ new Set();
+    const collectLocalSymbols = (node2) => {
+      if (ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)) {
+        node2.parameters.forEach((param) => {
+          if (ts.isIdentifier(param.name)) {
+            localSymbols.add(param.name.text);
+          }
+        });
+      }
+      if (ts.isVariableDeclaration(node2) && ts.isIdentifier(node2.name)) {
+        localSymbols.add(node2.name.text);
+      }
+      ts.forEachChild(node2, collectLocalSymbols);
+    };
+    collectLocalSymbols(node);
+    const findRefs = (node2) => {
+      if (ts.isIdentifier(node2)) {
+        if (!localSymbols.has(node2.text)) {
+          const parent = node2.parent;
+          const isDeclaration = ts.isVariableDeclaration(parent) && parent.name === node2 || ts.isFunctionDeclaration(parent) && parent.name === node2 || ts.isParameter(parent) && parent.name === node2;
+          if (!isDeclaration && !this.isBuiltIn(node2.text)) {
+            references.add(node2.text);
+          }
+        }
+      }
+      ts.forEachChild(node2, findRefs);
+    };
+    findRefs(node);
+    return Array.from(references);
+  }
+  /**
+  * Check if a name is a built-in global.
+  */
+  isBuiltIn(name) {
+    return builtIns.has(name);
+  }
+  /**
+  * Find assignment expressions in a source file.
+  */
+  findAssignmentExpression(sourceFile, typeChecker) {
+    let result = null;
+    const visit = (node) => {
+      if (ts.isExpressionStatement(node) && ts.isBinaryExpression(node.expression)) {
+        const expr = node.expression;
+        if (expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(expr.left)) {
+          const type = typeChecker.getTypeAtLocation(expr.right);
+          const typeString = typeChecker.typeToString(type);
+          let value;
+          if (ts.isNumericLiteral(expr.right)) {
+            value = Number(expr.right.text);
+          } else if (ts.isStringLiteral(expr.right)) {
+            value = expr.right.text;
+          }
+          const references = this.findReferences(expr.right, sourceFile, typeChecker);
+          result = {
+            name: expr.left.text,
+            type: "variable",
+            valueType: typeString,
+            value,
+            references
+          };
+        }
+      }
+      if (!result) {
+        ts.forEachChild(node, visit);
+      }
+    };
+    visit(sourceFile);
+    return result;
+  }
+  /**
+  * Find all identifier references in a source file.
+  */
+  findAllReferences(sourceFile, _typeChecker) {
+    const references = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (ts.isIdentifier(node)) {
+        const parent = node.parent;
+        const isDeclaration = ts.isVariableDeclaration(parent) && parent.name === node || ts.isFunctionDeclaration(parent) && parent.name === node || ts.isParameter(parent) && parent.name === node;
+        const isAssignmentTarget = ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node;
+        if (!isDeclaration && !isAssignmentTarget && !this.isBuiltIn(node.text)) {
+          references.add(node.text);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return Array.from(references);
+  }
+  createEnvironment(files) {
+    const allFiles = [
+      ...systemFiles,
+      ...files
+    ];
+    const fileMap = /* @__PURE__ */ new Map();
+    allFiles.forEach(({ filename, content }) => {
+      fileMap.set(filename, content);
+    });
+    const system = createSystem(fileMap);
+    return createVirtualTypeScriptEnvironment(system, allFiles.map(({ filename }) => filename), ts, this.compilerOptions);
+  }
+};
+
+// src/notebook/compute-graph.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/compute-graph.ts";
+var ComputeGraph = class {
+  _notebook;
+  _registry;
+  _parser = new VirtualTypeScriptParser();
+  _expressionsAtom = Atom.make({});
+  _valuesByCellIdAtom = Atom.make({});
+  _valuesByNameAtom = Atom.make({});
+  constructor(_notebook, _registry) {
+    this._notebook = _notebook;
+    this._registry = _registry;
+  }
+  /**
+  * Atom for parsed expressions by cell ID.
+  */
+  get expressions() {
+    return this._expressionsAtom;
+  }
+  /**
+  * Get current expressions by cell ID.
+  */
+  getExpressions() {
+    return this._registry.get(this._expressionsAtom);
+  }
+  /**
+  * Atom for computed values by cell ID.
+  */
+  get values() {
+    return this._valuesByCellIdAtom;
+  }
+  /**
+  * Get computed values by cell ID.
+  */
+  getValues() {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+  /**
+  * Atom for computed values by name.
+  */
+  get valuesByName() {
+    return this._valuesByNameAtom;
+  }
+  /**
+  * Get current values by name.
+  */
+  getValuesByName() {
+    return this._registry.get(this._valuesByNameAtom);
+  }
+  /**
+  * Get computed value by cell ID.
+  */
+  getValue(cellId) {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
+  }
+  /**
+  * Compute values.
+  */
+  async evaluate() {
+    const { expressions, dependencyGraph } = this.parse();
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
+    const cellExpressions = /* @__PURE__ */ new Map();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      cellExpressions.set(id, expr);
+    });
+    const evaluationOrder = this.topologicalSort(Object.keys(expressions), dependencyGraph);
+    const valuesByName = {};
+    const valuesByCellId = {};
+    for (const cellId of evaluationOrder) {
+      const expr = cellExpressions.get(cellId);
+      if (!expr) {
+        log.error("no expression for cell", {
+          cellId
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 78, S: this });
+        continue;
+      }
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
+      if (!cellSource) {
+        log.error("no source for cell", {
+          cellId
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 85, S: this });
+        continue;
+      }
+      try {
+        if (expr.name && expr.value !== void 0) {
+          valuesByName[expr.name] = expr.value;
+          valuesByCellId[cellId] = expr.value;
+        } else if (expr.name) {
+          const equalIndex = cellSource.indexOf("=");
+          if (equalIndex !== -1) {
+            let rhs = cellSource.substring(equalIndex + 1).trim();
+            if (rhs.endsWith(";")) {
+              rhs = rhs.slice(0, -1).trim();
+            }
+            const result = await this.eval(rhs, valuesByName);
+            valuesByName[expr.name] = result;
+            if (typeof result !== "function") {
+              valuesByCellId[cellId] = result;
+            }
+          }
+        } else {
+          const result = await this.eval(cellSource, valuesByName);
+          valuesByCellId[cellId] = result;
+        }
+      } catch (error) {
+        log.error("error evaluating cell", {
+          cellId,
+          error
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 120, S: this });
+      }
+    }
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
+    return valuesByCellId;
+  }
+  async eval(source, values) {
+    return evalScript(source, values);
+  }
+  /**
+  * Parse expressions.
+  */
+  parse() {
+    const expressions = this._notebook.cells.filter((cell) => cell.type === "script").reduce((acc, cell) => {
+      const text = cell.source?.target?.content.trim();
+      if (text) {
+        const parsed = this._parser.parseExpression(text);
+        acc[cell.id] = parsed;
+      }
+      return acc;
+    }, {});
+    const dependencyGraph = this.buildDependencyGraph(expressions);
+    this._registry.set(this._expressionsAtom, expressions);
+    return {
+      expressions,
+      dependencyGraph
+    };
+  }
+  topologicalSort(nodes, dependencies) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (node) => {
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      const deps = dependencies[node] || [];
+      deps.forEach((dep) => visit(dep));
+      result.push(node);
+    };
+    nodes.forEach((node) => visit(node));
+    return result;
+  }
+  buildDependencyGraph(expressions) {
+    const nameToCellId = /* @__PURE__ */ new Map();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.name) {
+        nameToCellId.set(expr.name, id);
+      }
+    });
+    const graph = {};
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.references && expr.references.length > 0) {
+        const dependencyCellIds = expr.references.map((ref) => nameToCellId.get(ref)).filter((cellId) => cellId !== void 0 && cellId !== id);
+        if (dependencyCellIds.length > 0) {
+          graph[id] = dependencyCellIds;
+        }
+      }
+    });
+    return graph;
+  }
+};
+
+// src/containers/NotebookContainer/NotebookContainer.tsx
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/containers/NotebookContainer/NotebookContainer.tsx";
+var INCLUDE_BLUEPRINTS = [
+  "org.dxos.blueprint.assistant",
+  "org.dxos.blueprint.database",
+  "org.dxos.blueprint.markdown"
+];
+var NotebookContainer = ({ role, subject: notebook, attendableId, env }) => {
+  const { t } = useTranslation(meta.id);
+  const registry = useContext(RegistryContext);
+  const db = Obj.getDatabase(notebook);
+  const { hasAttention } = useAttention(attendableId);
+  const graph = useMemo(() => notebook && new ComputeGraph(notebook, registry), [
+    notebook,
+    registry
+  ]);
+  const [queryValues, setQueryValues] = useState({});
+  const handleExecQueries = useCallback(async () => {
+    invariant2(db, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 43, S: void 0, A: ["db", ""] });
+    const builder = new QueryBuilder();
+    for (const cell of notebook?.cells ?? []) {
+      if (cell.type === "query") {
+        if (cell.source?.target) {
+          const source = cell.source.target.content;
+          const { name, filter } = builder.build(source);
+          if (filter) {
+            const ast = Query.select(filter).ast;
+            const graph2 = cell.graph?.target;
+            if (!graph2) {
+              const { view } = await ViewModel.makeFromDatabase({
+                db
+              });
+              const newGraph = Graph.make({
+                query: {
+                  ast
+                },
+                view
+              });
+              Obj.update(notebook, (obj) => {
+                const c = obj.cells.find((c2) => c2.id === cell.id);
+                if (c) {
+                  c.graph = Ref.make(newGraph);
+                  c.name = name;
+                }
+              });
+            } else {
+              Obj.update(graph2, (graph3) => {
+                graph3.query.ast = ast;
+              });
+            }
+          }
+        }
+        if (cell.name && cell.graph?.target) {
+          const graph2 = Obj.getSnapshot(cell.graph?.target);
+          const query = Query.fromAst(graph2.query.ast);
+          const objects = await db.query(query).run();
+          const objectIds = objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({
+            ...prev,
+            [cell.name]: objectIds
+          }));
+        }
+      }
+    }
+  }, [
+    db,
+    notebook,
+    graph
+  ]);
+  const [promptResults, setPromptResults] = useState({});
+  const handleExecPrompts = useComputeRuntimeCallback(db?.spaceId, Effect.fnUntraced(function* () {
+    invariant2(graph, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 96, S: this, A: ["graph", ""] });
+    const prompts = notebook?.cells.filter((cell) => cell.type === "prompt").map((cell) => cell.prompt).filter(isNonNullable) ?? [];
+    for (const prompt of prompts) {
+      yield* runPrompt({
+        prompt,
+        input: {
+          ...queryValues,
+          ...graph.getValuesByName()
+        },
+        onResult: (result) => setPromptResults((prev) => ({
+          ...prev,
+          [prompt.dxn.toString()]: result
+        }))
+      });
+    }
+  }), [
+    notebook,
+    graph,
+    queryValues
+  ]);
+  const handleCompute = useCallback(async () => {
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [
+    graph,
+    handleExecQueries,
+    handleExecPrompts
+  ]);
+  const handleRearrange = useCallback((source, target) => {
+    invariant2(notebook, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 128, S: void 0, A: ["notebook", ""] });
+    const from = notebook.cells.findIndex((cell) => cell.id === source.id);
+    const to = notebook.cells.findIndex((cell) => cell.id === target.id);
+    if (from != null && to != null) {
+      Obj.update(notebook, (notebook2) => {
+        const cell = notebook2.cells.splice(from, 1)[0];
+        if (cell) {
+          notebook2.cells.splice(to, 0, cell);
+        }
+      });
+    }
+  }, [
+    notebook
+  ]);
+  const handleCellInsert = useCallback(async (type, after) => {
+    invariant2(notebook, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 143, S: void 0, A: ["notebook", ""] });
+    const cell = {
+      id: crypto.randomUUID(),
+      type
+    };
+    switch (type) {
+      case "markdown":
+      case "script":
+      case "query": {
+        cell.source = Ref.make(Text.make());
+        break;
+      }
+      case "prompt": {
+        if (db) {
+          const objects = await db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+          const blueprints = objects.filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key)).map((blueprint) => Ref.make(blueprint));
+          cell.prompt = Ref.make(Routine.make({
+            instructions: "",
+            blueprints
+          }));
+        }
+        break;
+      }
+    }
+    const idx = after ? notebook.cells.findIndex((cell2) => cell2.id === after) : notebook.cells.length;
+    Obj.update(notebook, (notebook2) => {
+      notebook2.cells.splice(idx, 0, cell);
+    });
+  }, [
+    db,
+    notebook
+  ]);
+  const handleCellDelete = useCallback((id) => {
+    invariant2(notebook, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 178, S: void 0, A: ["notebook", ""] });
+    const idx = notebook.cells.findIndex((cell) => cell.id === id);
+    if (idx !== -1) {
+      Obj.update(notebook, (notebook2) => {
+        notebook2.cells.splice(idx, 1);
+      });
+    }
+  }, [
+    notebook
+  ]);
+  return /* @__PURE__ */ React.createElement(Panel.Root, {
+    role,
+    className: "dx-document"
+  }, /* @__PURE__ */ React.createElement(Panel.Toolbar, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+    disabled: !hasAttention
+  }, /* @__PURE__ */ React.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React.createElement(DropdownMenu.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(IconButton, {
+    icon: "ph--plus--regular",
+    iconOnly: true,
+    label: t("notebook-cell-insert.label")
+  })), /* @__PURE__ */ React.createElement(NotebookMenu, {
+    onCellInsert: handleCellInsert
+  })), /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
+    icon: "ph--play--fill",
+    iconOnly: true,
+    label: t("compute.label"),
+    classNames: "text-success-text",
+    onClick: handleCompute
+  }))), /* @__PURE__ */ React.createElement(Panel.Content, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(NotebookStack, {
+    db,
+    notebook,
+    graph,
+    env,
+    promptResults,
+    onRearrange: handleRearrange,
+    onCellInsert: handleCellInsert,
+    onCellDelete: handleCellDelete
+  })));
+};
+var runPrompt = Effect.fn(function* ({ prompt, input, onResult }) {
+  const inputData = {
+    prompt,
+    input
+  };
+  const result = yield* Operation.invoke(AgentPrompt, inputData).pipe(Effect.orDie, Effect.exit);
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log2.error(error.message, error.cause ?? error.stack, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 233, S: this });
+      onResult(error.message);
+    },
+    onSuccess: (result2) => {
+      onResult(result2.note);
+    }
+  });
+});
+export {
+  NotebookContainer as default
+};
+//# sourceMappingURL=NotebookContainer-DPT65MA7.mjs.map