@dxos/plugin-script 0.9.1-staging.ee54ba693a → 0.11.0

package/dist/lib/neutral/NotebookArticle-AOBB3XGD.mjs

@@ -1,745 +0,0 @@
-import "./chunk-J5LGTIGS.mjs";
-
-// src/containers/NotebookArticle/NotebookArticle.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 { useSpaceCallback } from "@dxos/app-framework/ui";
-import { RunInstructions } from "@dxos/assistant-toolkit";
-import { Instructions, Skill } 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 { Graph } from "@dxos/plugin-explorer";
-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/NotebookArticle/NotebookArticle.tsx
-var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/containers/NotebookArticle/NotebookArticle.tsx";
-var INCLUDE_SKILLS = [
-  "org.dxos.skill.assistant",
-  "org.dxos.skill.database",
-  "org.dxos.skill.markdown"
-];
-var NotebookArticle = ({ role, subject: notebook, attendableId, env }) => {
-  const { t } = useTranslation(meta.profile.key);
-  const registry = useContext(RegistryContext);
-  const db = notebook ? Obj.getDatabase(notebook) : void 0;
-  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 = useSpaceCallback(db?.spaceId, [], Effect.fnUntraced(function* () {
-    invariant2(graph, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 96, S: this, A: ["graph", ""] });
-    const allInstructions = notebook?.cells.filter((cell) => cell.type === "prompt").map((cell) => cell.prompt).filter(isNonNullable) ?? [];
-    for (const instructions of allInstructions) {
-      yield* runPrompt({
-        instructions,
-        input: {
-          ...queryValues,
-          ...graph.getValuesByName()
-        },
-        onResult: (result) => setPromptResults((prev) => ({
-          ...prev,
-          [instructions.uri]: result
-        }))
-      });
-    }
-  }), [
-    notebook,
-    graph,
-    queryValues
-  ]);
-  const handleCompute = useCallback(async () => {
-    await graph?.evaluate();
-    await handleExecQueries();
-    await handleExecPrompts();
-  }, [
-    graph,
-    handleExecQueries,
-    handleExecPrompts
-  ]);
-  const handleCellInsert = useCallback(async (type, after) => {
-    invariant2(notebook, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 128, 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(Skill.Skill))).run();
-          const skills = objects.filter((skill) => {
-            const key = Obj.getMeta(skill).key;
-            return key !== void 0 && INCLUDE_SKILLS.includes(key);
-          }).map((skill) => Ref.make(skill));
-          cell.prompt = Ref.make(Instructions.make({
-            text: "",
-            skills
-          }));
-        }
-        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: 166, 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, null, /* @__PURE__ */ React.createElement(NotebookStack, {
-    db,
-    notebook,
-    graph,
-    env,
-    promptResults,
-    onCellInsert: handleCellInsert,
-    onCellDelete: handleCellDelete
-  })));
-};
-var runPrompt = Effect.fn(function* ({ instructions, input, onResult }) {
-  const inputData = {
-    instructions,
-    input
-  };
-  const result = yield* Operation.invoke(RunInstructions, 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: 218, S: this });
-      onResult(error.message);
-    },
-    onSuccess: (result2) => {
-      onResult(result2.note);
-    }
-  });
-});
-export {
-  NotebookArticle as default
-};
-//# sourceMappingURL=NotebookArticle-AOBB3XGD.mjs.map