@dxos/plugin-script 0.10.0 → 0.11.1

package/dist/lib/chunk-NotebookArticle.mjs

@@ -0,0 +1,719 @@
+import { Instructions, Operation, Skill } from "@dxos/compute";
+import { isNonNullable, trim } from "@dxos/util";
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+import { Graph } from "@dxos/plugin-explorer";
+import { Text, ViewModel } from "@dxos/schema";
+import { meta } from "#meta";
+import { log } from "@dxos/log";
+import { useCallback, useContext, useMemo, useState } from "react";
+import { DropdownMenu, IconButton, Panel, Toolbar, useTranslation } from "@dxos/react-ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useSpaceCallback } from "@dxos/app-framework/ui";
+import { invariant } from "@dxos/invariant";
+import ts from "typescript";
+import { createSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
+import { Atom } from "@effect-atom/atom";
+import * as Effect from "effect/Effect";
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import { RunInstructions } from "@dxos/assistant-toolkit";
+import { QueryBuilder } from "@dxos/echo-query";
+import { useAttention } from "@dxos/react-ui-attention";
+import { NotebookMenu, NotebookStack } from "#components";
+//#region src/notebook/eval.ts
+/**
+* Evaluate the script (with dependencies as arguments).
+*/
+var evalScript = async (code, deps = {}) => {
+	const sandbox = {
+		...deps,
+		console: void 0,
+		document: void 0,
+		global: void 0,
+		globalThis: void 0,
+		self: void 0,
+		window: void 0,
+		Array,
+		Boolean,
+		Date,
+		Error,
+		JSON,
+		Map,
+		Math,
+		Number,
+		Object,
+		Promise,
+		RegExp,
+		Set,
+		String,
+		isFinite,
+		isNaN,
+		parseFloat,
+		parseInt
+	};
+	const sandboxKeys = Object.keys(sandbox);
+	const sandboxValues = Object.values(sandbox);
+	return new Function(...sandboxKeys, trim`
+      'use strict';
+      return ${code};
+    `)(...sandboxValues);
+};
+/**
+* Globals.
+*/
+var builtIns = /* @__PURE__ */ new Set([
+	"Array",
+	"Date",
+	"Error",
+	"JSON",
+	"Map",
+	"Math",
+	"Number",
+	"Object",
+	"Promise",
+	"RegExp",
+	"Set",
+	"String",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt"
+]);
+/**
+* Default system definitions.
+*/
+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 };
+`;
+//#endregion
+//#region src/notebook/vfs-parser.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/vfs-parser.ts";
+/**
+* Default system definitions.
+*/
+var systemFiles = [{
+	filename: "/lib.d.ts",
+	content: systemDefinitions
+}];
+/**
+* TypeScript parser using Virtual File System for browser compatibility.
+* This provides full TypeScript analysis including type information.
+*/
+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$2,
+			L: 58,
+			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;
+				return { references: this.findAllReferences(sourceFile, typeChecker) };
+			}
+		}
+		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 = (node) => {
+			if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) node.parameters.forEach((param) => {
+				if (ts.isIdentifier(param.name)) localSymbols.add(param.name.text);
+			});
+			if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) localSymbols.add(node.name.text);
+			ts.forEachChild(node, collectLocalSymbols);
+		};
+		collectLocalSymbols(node);
+		const findRefs = (node) => {
+			if (ts.isIdentifier(node)) {
+				if (!localSymbols.has(node.text)) {
+					const parent = node.parent;
+					if (!(ts.isVariableDeclaration(parent) && parent.name === node || ts.isFunctionDeclaration(parent) && parent.name === node || ts.isParameter(parent) && parent.name === node) && !this.isBuiltIn(node.text)) references.add(node.text);
+				}
+			}
+			ts.forEachChild(node, 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);
+		});
+		return createVirtualTypeScriptEnvironment(createSystem(fileMap), allFiles.map(({ filename }) => filename), ts, this.compilerOptions);
+	}
+};
+//#endregion
+//#region src/notebook/compute-graph.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/compute-graph.ts";
+/**
+* Compute graph that evaluates the notebook cells.
+*/
+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_file$1,
+					L: 105,
+					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_file$1,
+					L: 111,
+					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 valuesByCellId[cellId] = await this.eval(cellSource, valuesByName);
+			} catch (error) {
+				log.error("error evaluating cell", {
+					cellId,
+					error
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 147,
+					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);
+			(dependencies[node] || []).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;
+	}
+};
+//#endregion
+//#region src/containers/NotebookArticle/NotebookArticle.tsx
+var __dxlog_file = "/__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 () => {
+		invariant(db, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 51,
+			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 graph = cell.graph?.target;
+					if (!graph) {
+						const { view } = await ViewModel.makeFromDatabase({ db });
+						const newGraph = Graph.make({
+							query: { ast },
+							view
+						});
+						Obj.update(notebook, (obj) => {
+							const c = obj.cells.find((c) => c.id === cell.id);
+							if (c) {
+								c.graph = Ref.make(newGraph);
+								c.name = name;
+							}
+						});
+					} else Obj.update(graph, (graph) => {
+						graph.query.ast = ast;
+					});
+				}
+			}
+			if (cell.name && cell.graph?.target) {
+				const graph = Obj.getSnapshot(cell.graph?.target);
+				const query = Query.fromAst(graph.query.ast);
+				const objectIds = (await db.query(query).run())?.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* () {
+		invariant(graph, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			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) => {
+		invariant(notebook, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 129,
+			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 skills = (await db.query(Query.select(Filter.type(Skill.Skill))).run()).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((cell) => cell.id === after) : notebook.cells.length;
+		Obj.update(notebook, (notebook) => {
+			notebook.cells.splice(idx, 0, cell);
+		});
+	}, [db, notebook]);
+	const handleCellDelete = useCallback((id) => {
+		invariant(notebook, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 164,
+			S: void 0,
+			A: ["notebook", ""]
+		});
+		const idx = notebook.cells.findIndex((cell) => cell.id === id);
+		if (idx !== -1) Obj.update(notebook, (notebook) => {
+			notebook.cells.splice(idx, 1);
+		});
+	}, [notebook]);
+	return /* @__PURE__ */ jsxs(Panel.Root, {
+		role,
+		classNames: "dx-document",
+		children: [/* @__PURE__ */ jsx(Panel.Toolbar, {
+			asChild: true,
+			children: /* @__PURE__ */ jsxs(Toolbar.Root, {
+				disabled: !hasAttention,
+				children: [/* @__PURE__ */ jsxs(DropdownMenu.Root, { children: [/* @__PURE__ */ jsx(DropdownMenu.Trigger, {
+					asChild: true,
+					children: /* @__PURE__ */ jsx(IconButton, {
+						icon: "ph--plus--regular",
+						iconOnly: true,
+						label: t("notebook-cell-insert.label")
+					})
+				}), /* @__PURE__ */ jsx(NotebookMenu, { onCellInsert: handleCellInsert })] }), /* @__PURE__ */ jsx(Toolbar.IconButton, {
+					icon: "ph--play--fill",
+					iconOnly: true,
+					label: t("compute.label"),
+					classNames: "text-success-text",
+					onClick: handleCompute
+				})]
+			})
+		}), /* @__PURE__ */ jsx(Panel.Content, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(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];
+			log.error(error.message, error.cause ?? error.stack, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 226,
+				S: this
+			});
+			onResult(error.message);
+		},
+		onSuccess: (result) => {
+			onResult(result.note);
+		}
+	});
+});
+NotebookArticle.displayName = "NotebookArticle";
+//#endregion
+export { NotebookArticle as default };
+
+//# sourceMappingURL=chunk-NotebookArticle.mjs.map