@dxos/plugin-script 0.8.4-main.70d3990 → 0.8.4-main.765dc60934

package/dist/lib/{browser/NotebookContainer-MHY3DXDE.mjs → neutral/NotebookArticle-3TE4WBZC.mjs}

@@ -1,39 +1,29 @@
-import {
-  NotebookMenu,
-  NotebookStack
-} from "./chunk-ALS6X4HU.mjs";
-import "./chunk-M6KJPUJK.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";
+// 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, useMemo, useState } from "react";
-import { Agent } from "@dxos/assistant-toolkit";
-import { Blueprint, Prompt } from "@dxos/blueprints";
+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 { 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 { useComputeRuntimeCallback } from "@dxos/plugin-automation/hooks";
+import { Graph } from "@dxos/plugin-explorer";
+import { DropdownMenu, IconButton, Panel, 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 { 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 { signal } from "@preact/signals-core";
+import { Atom } from "@effect-atom/atom-react";
 import { log } from "@dxos/log";
 
 // src/notebook/eval.ts
@@ -127,6 +117,7 @@ var VirtualTypeScriptParser = class {
   compilerOptions = {
     target: ts.ScriptTarget.ES2020,
     module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
     strict: true,
     esModuleInterop: true,
     skipLibCheck: true,
@@ -138,15 +129,7 @@ var VirtualTypeScriptParser = class {
   * 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'"
-      ]
-    });
+    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",
@@ -186,7 +169,9 @@ var VirtualTypeScriptParser = class {
     const typeChecker = env.languageService.getProgram()?.getTypeChecker();
     files.forEach((file) => {
       const sourceFile = env.getSourceFile(file.filename);
-      if (!sourceFile || !typeChecker) return;
+      if (!sourceFile || !typeChecker) {
+        return;
+      }
       const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
       results.push(...fileResults);
     });
@@ -270,7 +255,9 @@ var VirtualTypeScriptParser = class {
   * Extract parameter information from a signature.
   */
   extractParameters(signature, typeChecker) {
-    if (!signature) return [];
+    if (!signature) {
+      return [];
+    }
     return signature.parameters.map((param) => ({
       name: param.getName(),
       type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(param, param.valueDeclaration))
@@ -388,44 +375,64 @@ var VirtualTypeScriptParser = class {
 var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/compute-graph.ts";
 var ComputeGraph = class {
   _notebook;
+  _registry;
   _parser = new VirtualTypeScriptParser();
-  _expressions = signal({});
-  _valuesByCellId = signal({});
-  _valuesByName = signal({});
-  constructor(_notebook) {
+  _expressionsAtom = Atom.make({});
+  _valuesByCellIdAtom = Atom.make({});
+  _valuesByNameAtom = Atom.make({});
+  constructor(_notebook, _registry) {
     this._notebook = _notebook;
+    this._registry = _registry;
   }
   /**
-  * Parsed expressions by cell ID.
+  * Atom for parsed expressions by cell ID.
   */
   get expressions() {
-    return this._expressions;
+    return this._expressionsAtom;
   }
   /**
-  * Computed values by cell ID.
+  * Get current expressions by cell ID.
+  */
+  getExpressions() {
+    return this._registry.get(this._expressionsAtom);
+  }
+  /**
+  * Atom for computed values by cell ID.
   */
   get values() {
-    return this._valuesByCellId;
+    return this._valuesByCellIdAtom;
   }
   /**
-  * Computed values by name.
+  * Get computed values by cell ID.
+  */
+  getValues() {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+  /**
+  * Atom for computed values by name.
   */
   get valuesByName() {
-    return this._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._valuesByCellId.value[cellId];
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
   /**
   * Compute values.
   */
   async evaluate() {
     const { expressions, dependencyGraph } = this.parse();
-    this._valuesByCellId.value = {};
-    this._valuesByName.value = {};
+    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);
@@ -438,24 +445,14 @@ var ComputeGraph = class {
       if (!expr) {
         log.error("no expression for cell", {
           cellId
-        }, {
-          F: __dxlog_file2,
-          L: 81,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~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
-        }, {
-          F: __dxlog_file2,
-          L: 87,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 85, S: this });
         continue;
       }
       try {
@@ -483,16 +480,11 @@ var ComputeGraph = class {
         log.error("error evaluating cell", {
           cellId,
           error
-        }, {
-          F: __dxlog_file2,
-          L: 123,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 120, S: this });
       }
     }
-    this._valuesByCellId.value = valuesByCellId;
-    this._valuesByName.value = valuesByName;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
   async eval(source, values) {
@@ -511,7 +503,7 @@ var ComputeGraph = class {
       return acc;
     }, {});
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return {
       expressions,
       dependencyGraph
@@ -552,266 +544,220 @@ var ComputeGraph = class {
   }
 };
 
-// src/components/NotebookContainer.tsx
-var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/NotebookContainer.tsx";
+// src/containers/NotebookArticle/NotebookArticle.tsx
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/containers/NotebookArticle/NotebookArticle.tsx";
 var INCLUDE_BLUEPRINTS = [
-  "dxos.org/blueprint/assistant",
-  "dxos.org/blueprint/markdown"
+  "org.dxos.blueprint.assistant",
+  "org.dxos.blueprint.database",
+  "org.dxos.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;
-              }
+var NotebookArticle = ({ 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 result = await space?.db.query(query).run();
-            const objectIds = result?.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) => ({
+        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,
-            [prompt.dxn.toString()]: result
-          }))
-        });
+            [cell.name]: objectIds
+          }));
+        }
       }
-    }), [
-      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",
-          ""
-        ]
+    }
+  }, [
+    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
+        }))
       });
-      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];
+    }
+  }), [
+    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) {
-          notebook.cells.splice(to, 0, cell);
+          notebook2.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 result = await space.db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
-            const blueprints = result.objects.filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key)).map((blueprint) => Ref.make(blueprint));
-            cell.prompt = Ref.make(Prompt.make({
-              instructions: "",
-              blueprints
-            }));
-          }
-          break;
+    }
+  }, [
+    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) => {
+            const key = Obj.getMeta(blueprint).key;
+            return key !== void 0 && INCLUDE_BLUEPRINTS.includes(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;
-      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 = 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: 181, 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);
       });
-      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();
-  }
+    }
+  }, [
+    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 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);
+  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, {
-        F: __dxlog_file3,
-        L: 247,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log2.error(error.message, error.cause ?? error.stack, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 236, S: this });
       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
+  NotebookArticle as default
 };
-//# sourceMappingURL=NotebookContainer-MHY3DXDE.mjs.map
+//# sourceMappingURL=NotebookArticle-3TE4WBZC.mjs.map