@dxos/plugin-script 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/browser/NotebookContainer-GL2Z5I5Q.mjs

@@ -0,0 +1,817 @@
+import {
+  NotebookMenu,
+  NotebookStack
+} from "./chunk-2SXDKBM7.mjs";
+import "./chunk-6X7QVTRB.mjs";
+import {
+  meta
+} from "./chunk-EB6AXFXO.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/components/NotebookContainer.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import React, { useCallback, useMemo, useState } from "react";
+import { Agent } from "@dxos/assistant-toolkit";
+import { Blueprint, Prompt } from "@dxos/blueprints";
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+import { QueryBuilder } from "@dxos/echo-query";
+import { FunctionInvocationService } from "@dxos/functions";
+import { InvocationTracer } from "@dxos/functions-runtime";
+import { TracingServiceExt } from "@dxos/functions-runtime";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { useComputeRuntimeCallback } from "@dxos/plugin-automation";
+import { Graph } from "@dxos/plugin-explorer/types";
+import { getSpace } from "@dxos/react-client/echo";
+import { DropdownMenu, IconButton, Toolbar, useTranslation } from "@dxos/react-ui";
+import { useAttention } from "@dxos/react-ui-attention";
+import { StackItem } from "@dxos/react-ui-stack";
+import { Text, View } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
+
+// src/notebook/compute-graph.ts
+import { signal } from "@preact/signals-core";
+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,
+    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", {
+      F: __dxlog_file,
+      L: 57,
+      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;
+  _parser = new VirtualTypeScriptParser();
+  _expressions = signal({});
+  _valuesByCellId = signal({});
+  _valuesByName = signal({});
+  constructor(_notebook) {
+    this._notebook = _notebook;
+  }
+  /**
+  * Parsed expressions by cell ID.
+  */
+  get expressions() {
+    return this._expressions;
+  }
+  /**
+  * Computed values by cell ID.
+  */
+  get values() {
+    return this._valuesByCellId;
+  }
+  /**
+  * Computed values by name.
+  */
+  get valuesByName() {
+    return this._valuesByName;
+  }
+  /**
+  * Get computed value by cell ID.
+  */
+  getValue(cellId) {
+    return this._valuesByCellId.value[cellId];
+  }
+  /**
+  * Compute values.
+  */
+  async evaluate() {
+    const { expressions, dependencyGraph } = this.parse();
+    this._valuesByCellId.value = {};
+    this._valuesByName.value = {};
+    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
+        }, {
+          F: __dxlog_file2,
+          L: 81,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
+      if (!cellSource) {
+        log.error("no source for cell", {
+          cellId
+        }, {
+          F: __dxlog_file2,
+          L: 87,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        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
+        }, {
+          F: __dxlog_file2,
+          L: 123,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    this._valuesByCellId.value = valuesByCellId;
+    this._valuesByName.value = 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._expressions.value = 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/components/NotebookContainer.tsx
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/NotebookContainer.tsx";
+var INCLUDE_BLUEPRINTS = [
+  "dxos.org/blueprint/assistant",
+  "dxos.org/blueprint/markdown"
+];
+var NotebookContainer = ({ notebook, env }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(meta.id);
+    const space = getSpace(notebook);
+    const attendableId = notebook ? Obj.getDXN(notebook).toString() : "";
+    const { hasAttention } = useAttention(attendableId);
+    const graph = useMemo(() => notebook && new ComputeGraph(notebook), [
+      notebook
+    ]);
+    const [queryValues, setQueryValues] = useState({});
+    const handleExecQueries = useCallback(async () => {
+      invariant2(space, void 0, {
+        F: __dxlog_file3,
+        L: 56,
+        S: void 0,
+        A: [
+          "space",
+          ""
+        ]
+      });
+      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 View.makeFromSpace({
+                  space
+                });
+                const graph3 = Graph.make({
+                  query: {
+                    ast
+                  },
+                  view
+                });
+                cell.graph = Ref.make(graph3);
+                cell.name = name;
+              } else {
+                graph2.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 space?.db.query(query).run();
+            const objectIds = objects?.map((obj) => obj.id);
+            setQueryValues((prev) => ({
+              ...prev,
+              [cell.name]: objectIds
+            }));
+          }
+        }
+      }
+    }, [
+      space,
+      notebook,
+      graph
+    ]);
+    const [promptResults, setPromptResults] = useState({});
+    const handleExecPrompts = useComputeRuntimeCallback(space, Effect.fnUntraced(function* () {
+      invariant2(graph, void 0, {
+        F: __dxlog_file3,
+        L: 93,
+        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.valuesByName.value
+          },
+          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, {
+        F: __dxlog_file3,
+        L: 126,
+        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) {
+        const cell = notebook.cells.splice(from, 1)[0];
+        if (cell) {
+          notebook.cells.splice(to, 0, cell);
+        }
+      }
+    }, [
+      notebook
+    ]);
+    const handleCellInsert = useCallback(async (type, after) => {
+      invariant2(notebook, void 0, {
+        F: __dxlog_file3,
+        L: 141,
+        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 (space) {
+            const objects = await space.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(Prompt.make({
+              instructions: "",
+              blueprints
+            }));
+          }
+          break;
+        }
+      }
+      const idx = after ? notebook.cells.findIndex((cell2) => cell2.id === after) : notebook.cells.length;
+      notebook.cells.splice(idx, 0, cell);
+    }, [
+      space,
+      notebook
+    ]);
+    const handleCellDelete = useCallback((id) => {
+      invariant2(notebook, void 0, {
+        F: __dxlog_file3,
+        L: 171,
+        S: void 0,
+        A: [
+          "notebook",
+          ""
+        ]
+      });
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        notebook.cells.splice(idx, 1);
+      }
+    }, [
+      notebook
+    ]);
+    return /* @__PURE__ */ React.createElement(StackItem.Content, {
+      toolbar: true
+    }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+      disabled: !hasAttention,
+      textBlockWidth: true
+    }, /* @__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-green-500",
+      onClick: handleCompute
+    })), /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      className: "flex bs-full overflow-hidden -mis-[1px] -mie-[1px]"
+    }, /* @__PURE__ */ React.createElement(NotebookStack, {
+      classNames: "container-max-width border-l border-r border-subduedSeparator",
+      space,
+      notebook,
+      graph,
+      env,
+      promptResults,
+      onRearrange: handleRearrange,
+      onCellInsert: handleCellInsert,
+      onCellDelete: handleCellDelete
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var NotebookContainer_default = NotebookContainer;
+var runPrompt = Effect.fn(function* ({ prompt, input, onResult }) {
+  const inputData = {
+    prompt,
+    input
+  };
+  const tracer = yield* InvocationTracer;
+  const trace = yield* tracer.traceInvocationStart({
+    target: void 0,
+    payload: {
+      data: {}
+    }
+  });
+  const result = yield* FunctionInvocationService.invokeFunction(Agent.prompt, inputData).pipe(Effect.provide(TracingServiceExt.layerQueue(trace.invocationTraceQueue)), Effect.exit);
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log2.error(error.message, error.cause ?? error.stack, {
+        F: __dxlog_file3,
+        L: 247,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      onResult(error.message);
+    },
+    onSuccess: (result2) => {
+      onResult(result2.note);
+    }
+  });
+  yield* tracer.traceInvocationEnd({
+    trace,
+    // TODO(dmaretskyi): Might miss errors.
+    exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : void 0
+  });
+});
+export {
+  NotebookContainer,
+  NotebookContainer_default as default
+};
+//# sourceMappingURL=NotebookContainer-GL2Z5I5Q.mjs.map