@dxos/plugin-debug 0.8.3 → 0.8.4-main.1068cf700f

package/dist/lib/browser/SpaceGenerator-W3LJORYT.mjs

@@ -0,0 +1,1152 @@
+// src/components/SpaceGenerator/SpaceGenerator.tsx
+import React2, { useCallback, useMemo, useState } from "react";
+import { useOperationInvoker } from "@dxos/app-framework/ui";
+import { ComputeGraph as ComputeGraph2 } from "@dxos/conductor";
+import { Filter as Filter3, Obj as Obj2 } from "@dxos/echo";
+import { Markdown as Markdown3 } from "@dxos/plugin-markdown/types";
+import { Sheet as Sheet2 } from "@dxos/plugin-sheet/types";
+import { Diagram as Diagram2 } from "@dxos/plugin-sketch/types";
+import { useClient } from "@dxos/react-client";
+import { IconButton as IconButton2, Input, Layout, ScrollArea, Toolbar, useAsyncEffect } from "@dxos/react-ui";
+import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { Organization as Organization2, Person as Person2, Task } from "@dxos/types";
+import { jsonKeyReplacer, sortKeys } from "@dxos/util";
+
+// src/components/SpaceGenerator/ObjectGenerator.tsx
+import { addressToA1Notation } from "@dxos/compute";
+import { ComputeGraph, ComputeGraphModel, DEFAULT_OUTPUT, NODE_INPUT, NODE_OUTPUT } from "@dxos/conductor";
+import { DXN, Filter, Key } from "@dxos/echo";
+import { Markdown } from "@dxos/plugin-markdown/types";
+import { Sheet } from "@dxos/plugin-sheet/types";
+import { Diagram } from "@dxos/plugin-sketch/types";
+import { SpaceOperation } from "@dxos/plugin-space/types";
+import { faker } from "@dxos/random";
+import { View, getTypenameFromQuery } from "@dxos/schema";
+import { createAsyncGenerator } from "@dxos/schema/testing";
+import { range } from "@dxos/util";
+var generator = faker;
+var findViewByTypename = async (views, typename) => {
+  return views.find((view) => getTypenameFromQuery(view.query.ast) === typename);
+};
+var createGenerator = (client, invokePromise, schema) => {
+  return async (space, n) => {
+    const typename = schema.typename;
+    const views = await space.db.query(Filter.type(View.View)).run();
+    const view = await findViewByTypename(views, typename);
+    const staticSchema = client?.graph.schemaRegistry.query({
+      typename
+    }).runSync()[0];
+    if (!view && !staticSchema) {
+      await invokePromise(SpaceOperation.AddSchema, {
+        db: space.db,
+        schema,
+        show: false
+      });
+    } else if (!view && staticSchema) {
+      await invokePromise(SpaceOperation.UseStaticSchema, {
+        db: space.db,
+        typename,
+        show: false
+      });
+    }
+    const generate = createAsyncGenerator(generator, schema, {
+      db: space.db
+    });
+    return generate.createObjects(n);
+  };
+};
+var staticGenerators = /* @__PURE__ */ new Map([
+  [
+    Markdown.Document.typename,
+    async (space, n, cb) => {
+      const objects = range(n).map(() => {
+        return space.db.add(Markdown.make({
+          name: faker.commerce.productName(),
+          content: faker.lorem.sentences(5)
+        }));
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ],
+  [
+    Diagram.Diagram.typename,
+    async (space, n, cb) => {
+      const objects = range(n).map(() => {
+        const obj = space.db.add(Diagram.make({
+          name: faker.commerce.productName()
+        }));
+        return obj;
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ],
+  // TODO(burdon): Create unit tests.
+  [
+    Sheet.Sheet.typename,
+    async (space, n, cb) => {
+      const objects = range(n).map(() => {
+        const cells = {};
+        const year = (/* @__PURE__ */ new Date()).getFullYear();
+        const cols = 4;
+        const rows = 16;
+        for (let col = 1; col <= cols; col++) {
+          for (let row = 1; row <= rows; row++) {
+            const cell = addressToA1Notation({
+              col,
+              row
+            });
+            if (row === 1) {
+              cells[cell] = {
+                value: `${year} Q${col}`
+              };
+            } else if (row === rows) {
+              const from = addressToA1Notation({
+                col,
+                row: 2
+              });
+              const to = addressToA1Notation({
+                col,
+                row: rows - 1
+              });
+              cells[cell] = {
+                value: `=SUM(${from}:${to})`
+              };
+            } else if (row > 2 && row < rows - 1) {
+              cells[cell] = {
+                value: Math.floor(Math.random() * 1e4)
+              };
+            }
+          }
+        }
+        return space.db.add(Sheet.make({
+          name: faker.commerce.productName(),
+          cells
+        }));
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ],
+  [
+    ComputeGraph.typename,
+    async (space, n, cb) => {
+      const objects = range(n, () => {
+        const model = ComputeGraphModel.create();
+        model.builder.createNode({
+          id: "gpt-INPUT",
+          type: NODE_INPUT
+        }).createNode({
+          id: "gpt-GPT",
+          type: "gpt"
+        }).createNode({
+          id: "gpt-QUEUE_ID",
+          type: "constant",
+          value: new DXN(DXN.kind.QUEUE, [
+            "data",
+            space.id,
+            Key.ObjectId.random()
+          ]).toString()
+        }).createNode({
+          id: "gpt-APPEND",
+          type: "append"
+        }).createNode({
+          id: "gpt-OUTPUT",
+          type: NODE_OUTPUT
+        }).createEdge({
+          node: "gpt-INPUT",
+          property: "prompt"
+        }, {
+          node: "gpt-GPT",
+          property: "prompt"
+        }).createEdge({
+          node: "gpt-GPT",
+          property: "text"
+        }, {
+          node: "gpt-OUTPUT",
+          property: "text"
+        }).createEdge({
+          node: "gpt-QUEUE_ID",
+          property: DEFAULT_OUTPUT
+        }, {
+          node: "gpt-APPEND",
+          property: "id"
+        }).createEdge({
+          node: "gpt-GPT",
+          property: "messages"
+        }, {
+          node: "gpt-APPEND",
+          property: "items"
+        }).createEdge({
+          node: "gpt-QUEUE_ID",
+          property: DEFAULT_OUTPUT
+        }, {
+          node: "gpt-OUTPUT",
+          property: "queue"
+        });
+        return space.db.add(model.root);
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ]
+]);
+
+// src/components/SpaceGenerator/presets.ts
+import * as Schema from "effect/Schema";
+import { Agent, EntityExtraction, ResearchBlueprint } from "@dxos/assistant-toolkit";
+import { Prompt } from "@dxos/blueprints";
+import { NODE_INPUT as NODE_INPUT2 } from "@dxos/conductor";
+import { DXN as DXN2, Filter as Filter2, Key as Key2, Obj, Query, Ref, Tag, Type } from "@dxos/echo";
+import { Trigger, serializeFunction } from "@dxos/functions";
+import { invariant } from "@dxos/invariant";
+import { gmail } from "@dxos/plugin-inbox";
+import { Mailbox } from "@dxos/plugin-inbox/types";
+import { Markdown as Markdown2 } from "@dxos/plugin-markdown/types";
+import { createAppend, createChat, createComputeGraph, createConstant, createFunction, createGpt, createQueue, createRandom, createSurface, createTemplate, createText, createTrigger } from "@dxos/react-ui-canvas-compute";
+import { CanvasBoard, CanvasGraphModel, pointMultiply, pointsToRect, rectToPoints } from "@dxos/react-ui-canvas-editor";
+import { View as View2 } from "@dxos/schema";
+import { Message, Organization, Person, Pipeline } from "@dxos/types";
+import { range as range2, trim } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts";
+var PresetName = /* @__PURE__ */ (function(PresetName2) {
+  PresetName2["DXOS_TEAM"] = "dxos-team";
+  PresetName2["ORG_RESEARCH_PROJECT"] = "org-research-project";
+  PresetName2["GPT_QUEUE"] = "webhook-gpt-queue";
+  PresetName2["CHAT_GPT"] = "chat-gpt-text";
+  PresetName2["OBJECT_CHANGE_QUEUE"] = "objectChange-queue";
+  PresetName2["TIMER_TICK_QUEUE"] = "timerTick-queue";
+  PresetName2["FOREX_FUNCTION_CALL"] = "forex-function-call";
+  PresetName2["DISCORD_MESSAGES"] = "discord-messages";
+  return PresetName2;
+})({});
+var generator2 = () => ({
+  schemas: [
+    CanvasBoard.CanvasBoard,
+    Trigger.Trigger
+  ],
+  types: Object.values(PresetName).map((name) => ({
+    typename: name
+  })),
+  items: [
+    [
+      "dxos-team",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const org = space.db.add(Obj.make(Organization.Organization, {
+            name: "DXOS",
+            website: "https://dxos.org"
+          }));
+          const doc = space.db.add(Markdown2.make({
+            name: "DXOS Research",
+            content: "DXOS builds Composer, an open-source AI-powered malleable application."
+          }));
+          const tag = space.db.add(Tag.make({
+            label: "Investor"
+          }));
+          const tagDxn = Obj.getDXN(tag).toString();
+          Obj.change(doc, (d) => {
+            Obj.getMeta(d).tags = [
+              tagDxn
+            ];
+          });
+          space.db.add(Obj.make(Person.Person, {
+            fullName: "Rich",
+            organization: Ref.make(org)
+          }, {
+            tags: [
+              tagDxn
+            ]
+          }));
+          space.db.add(Obj.make(Person.Person, {
+            fullName: "Josiah",
+            organization: Ref.make(org)
+          }));
+          space.db.add(Obj.make(Person.Person, {
+            fullName: "Dima",
+            organization: Ref.make(org)
+          }));
+          space.db.add(Obj.make(Person.Person, {
+            fullName: "Mykola",
+            organization: Ref.make(org)
+          }));
+          return doc;
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    [
+      "org-research-project",
+      async (space, n, cb) => {
+        const mailbox = await space.db.query(Filter2.type(Mailbox.Mailbox)).first();
+        const tag = await space.db.query(Filter2.type(Tag.Tag, {
+          label: "Investor"
+        })).first();
+        const tagDxn = Obj.getDXN(tag).toString();
+        const objects = range2(n, () => {
+          const contactsQuery = Query.select(Filter2.type(Person.Person)).select(Filter2.tag(tagDxn));
+          const organizationsQuery = Query.select(Filter2.type(Organization.Organization)).select(Filter2.tag(tagDxn));
+          const notesQuery = Query.select(Filter2.type(Markdown2.Document)).select(Filter2.tag(tagDxn));
+          space.db.add(Trigger.make({
+            enabled: true,
+            spec: {
+              kind: "timer",
+              cron: "* * * * *"
+            },
+            function: Ref.make(serializeFunction(gmail.sync)),
+            input: {
+              mailbox: Ref.make(mailbox)
+            }
+          }));
+          space.db.add(Trigger.make({
+            enabled: true,
+            // TODO(wittjosiah): Queue trigger doesn't support matching query of the column.
+            spec: {
+              kind: "queue",
+              queue: mailbox.queue.dxn.toString()
+            },
+            function: Ref.make(serializeFunction(EntityExtraction.extract)),
+            input: {
+              source: "{{event.item}}"
+            }
+          }));
+          const researchPrompt = space.db.add(Prompt.make({
+            name: "Research",
+            description: "Research organization",
+            input: Schema.Struct({
+              org: Schema.Any
+            }),
+            output: Schema.Any,
+            // TODO(dmaretskyi): This mocks research (returns pre-baked result), the actual research might take compute minutes.
+            // Remove the mock prompt to do the actual research.
+            instructions: trim`
+                Research the organization provided as input.
+                Create a research note for it at the end.
+                NOTE: Do mocked reseach (set mockSearch to true).
+              `,
+            blueprints: [
+              Ref.make(ResearchBlueprint)
+            ]
+          }));
+          space.db.add(Trigger.make({
+            enabled: true,
+            spec: {
+              kind: "subscription",
+              query: {
+                ast: organizationsQuery.ast
+              }
+            },
+            function: Ref.make(serializeFunction(Agent.prompt)),
+            input: {
+              prompt: Ref.make(researchPrompt),
+              input: "{{event.subject}}"
+            }
+          }));
+          const mailboxView = View2.make({
+            query: Query.select(Filter2.type(Message.Message, {
+              properties: {
+                labels: Filter2.contains("investor")
+              }
+            })).options({
+              queues: [
+                mailbox.queue.dxn.toString()
+              ]
+            }),
+            jsonSchema: Type.toJsonSchema(Message.Message)
+          });
+          const contactsView = View2.make({
+            query: contactsQuery,
+            jsonSchema: Type.toJsonSchema(Person.Person)
+          });
+          const organizationsView = View2.make({
+            query: organizationsQuery,
+            jsonSchema: Type.toJsonSchema(Organization.Organization)
+          });
+          const notesView = View2.make({
+            query: notesQuery,
+            jsonSchema: Type.toJsonSchema(Markdown2.Document)
+          });
+          return space.db.add(Pipeline.make({
+            name: "Investor Research",
+            columns: [
+              {
+                name: "Mailbox",
+                view: Ref.make(mailboxView),
+                order: []
+              },
+              {
+                name: "Contacts",
+                view: Ref.make(contactsView),
+                order: []
+              },
+              {
+                name: "Organizations",
+                view: Ref.make(organizationsView),
+                order: []
+              },
+              {
+                name: "Notes",
+                view: Ref.make(notesView),
+                order: []
+              }
+            ]
+          }));
+        });
+        cb?.(objects.flat());
+        return objects.flat();
+      }
+    ],
+    [
+      "webhook-gpt-queue",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          let functionTrigger;
+          canvasModel.builder.call((builder) => {
+            const gpt = canvasModel.createNode(createGpt(position({
+              x: 0,
+              y: -14
+            })));
+            const triggerShape = createTrigger({
+              spaceId: space.id,
+              triggerKind: "webhook",
+              ...position({
+                x: -18,
+                y: -2
+              })
+            });
+            const trigger = canvasModel.createNode(triggerShape);
+            const text = canvasModel.createNode(createText(position({
+              x: 19,
+              y: 3,
+              width: 10,
+              height: 10
+            })));
+            const { queueId } = setupQueue(space, canvasModel);
+            const append = canvasModel.createNode(createAppend(position({
+              x: 10,
+              y: 6
+            })));
+            builder.createEdge({
+              source: trigger.id,
+              target: gpt.id,
+              input: "prompt",
+              output: "bodyText"
+            }).createEdge({
+              source: gpt.id,
+              target: text.id,
+              output: "text"
+            }).createEdge({
+              source: queueId.id,
+              target: append.id,
+              input: "id"
+            }).createEdge({
+              source: gpt.id,
+              target: append.id,
+              output: "messages",
+              input: "items"
+            });
+            functionTrigger = triggerShape.functionTrigger.target;
+          });
+          const computeModel = createComputeGraph(canvasModel);
+          attachTrigger(functionTrigger, computeModel);
+          return addToSpace("webhook-gpt-queue", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    [
+      "objectChange-queue",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const { canvasModel, computeModel } = createQueueSinkPreset(space, "subscription", (triggerSpec) => triggerSpec.query = {
+            ast: Query.select(Filter2.typename("dxos.org/type/Chess")).ast
+          }, "type");
+          return addToSpace("objectChange-queue", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    [
+      "timerTick-queue",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const { canvasModel, computeModel } = createQueueSinkPreset(space, "timer", (triggerSpec) => triggerSpec.cron = "*/5 * * * * *", "result");
+          return addToSpace("timerTick-queue", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    // TODO(wittjosiah): Remove?
+    // [
+    //   PresetName.EMAIL_TABLE,
+    //   async (space, n, cb) => {
+    //     const objects = range(n, () => {
+    //       const canvasModel = CanvasGraphModel.create<ComputeShape>();
+    //       const results = space.db.query(Filter.type(TableType)).runSync();
+    //       const emailTable = results.find((r) => r.object?.view?.target?.query?.typename?.endsWith('Email'));
+    //       invariant(emailTable, 'Email table not found.');
+    //       const template = canvasModel.createNode(
+    //         createTemplate({
+    //           valueType: 'object',
+    //           ...rawPosition({ centerX: -80, centerY: -64, width: 320, height: 320 }),
+    //         }),
+    //       );
+    //       const templateContent = ['{'];
+    //       let functionTrigger: FunctionTrigger | undefined;
+    //       canvasModel.builder.call((builder) => {
+    //         const triggerShape = createTrigger({
+    //           spaceId: space.id,
+    //           triggerKind: 'email',
+    //           ...position({ x: -18, y: -2 }),
+    //         });
+    //         const trigger = canvasModel.createNode(triggerShape);
+    //         const tableId = canvasModel.createNode(
+    //           createConstant({
+    //             value: DXN.fromLocalObjectId(emailTable.id).toString(),
+    //             ...position({ x: -18, y: 5, width: 8, height: 6 }),
+    //           }),
+    //         );
+    //         const appendToTable = canvasModel.createNode(createAppend(position({ x: 10, y: 6 })));
+    //         const properties = SchemaAST.getPropertySignatures(EmailTriggerOutput.ast);
+    //         for (let i = 0; i < properties.length; i++) {
+    //           const propName = properties[i].name.toString();
+    //           builder.createEdge({ source: trigger.id, target: template.id, input: propName, output: propName });
+    //           templateContent.push(`  "${propName}": "{{${propName}}}"` + (i === properties.length - 1 ? '' : ','));
+    //         }
+    //         templateContent.push('}');
+    //         builder
+    //           .createEdge({ source: tableId.id, target: appendToTable.id, input: 'id' })
+    //           .createEdge({ source: template.id, target: appendToTable.id, input: 'items' });
+    //         functionTrigger = triggerShape.functionTrigger!.target!;
+    //       });
+    //       const computeModel = createComputeGraph(canvasModel);
+    //       const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
+    //       invariant(templateComputeNode, 'Template compute node was not created.');
+    //       templateComputeNode.value = templateContent.join('\n');
+    //       templateComputeNode.inputSchema = Type.toJsonSchema(EmailTriggerOutput);
+    //       attachTrigger(functionTrigger, computeModel);
+    //       return addToSpace(PresetName.EMAIL_TABLE, space, canvasModel, computeModel);
+    //     });
+    //     cb?.(objects);
+    //     return objects;
+    //   },
+    // ],
+    [
+      "chat-gpt-text",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          canvasModel.builder.call((builder) => {
+            const gpt = canvasModel.createNode(createGpt(position({
+              x: 0,
+              y: -14
+            })));
+            const chat = canvasModel.createNode(createChat(position({
+              x: -18,
+              y: -2
+            })));
+            const text = canvasModel.createNode(createText(position({
+              x: 19,
+              y: 3,
+              width: 10,
+              height: 10
+            })));
+            const { queueId } = setupQueue(space, canvasModel);
+            const append = canvasModel.createNode(createAppend(position({
+              x: 10,
+              y: 6
+            })));
+            builder.createEdge({
+              source: chat.id,
+              target: gpt.id,
+              input: "prompt"
+            }).createEdge({
+              source: gpt.id,
+              target: text.id,
+              output: "text"
+            }).createEdge({
+              source: queueId.id,
+              target: append.id,
+              input: "id"
+            }).createEdge({
+              source: gpt.id,
+              target: append.id,
+              output: "messages",
+              input: "items"
+            });
+          });
+          const computeModel = createComputeGraph(canvasModel);
+          return addToSpace("chat-gpt-text", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    // TODO(wittjosiah): Remove?
+    // [
+    //   PresetName.EMAIL_WITH_SUMMARY,
+    //   async (space, n, cb) => {
+    //     const objects = range(n, () => {
+    //       const canvasModel = CanvasGraphModel.create<ComputeShape>();
+    //       const results = space.db.query(Filter.type(TableType)).runSync();
+    //       const emailTable = results.find((r) => r.object?.view?.target?.query?.typename?.endsWith('Email'));
+    //       invariant(emailTable, 'Email table not found.');
+    //       const template = canvasModel.createNode(
+    //         createTemplate({
+    //           valueType: 'object',
+    //           ...rawPosition({ centerX: 192, centerY: -176, width: 320, height: 320 }),
+    //         }),
+    //       );
+    //       const templateContent = ['{'];
+    //       let functionTrigger: FunctionTrigger | undefined;
+    //       canvasModel.builder.call((builder) => {
+    //         const gpt = canvasModel.createNode(
+    //           createGpt(rawPosition({ centerX: -400, centerY: -112, width: 256, height: 202 })),
+    //         );
+    //         const systemPrompt = canvasModel.createNode(
+    //           createConstant({
+    //             value: "use one word to describe content category. don't write anything else",
+    //             ...rawPosition({ centerX: -800, centerY: -160, width: 192, height: 128 }),
+    //           }),
+    //         );
+    //         const triggerShape = createTrigger({
+    //           spaceId: space.id,
+    //           triggerKind: 'email',
+    //           ...rawPosition({ centerX: -736, centerY: -384, width: 182, height: 192 }),
+    //         });
+    //         const trigger = canvasModel.createNode(triggerShape);
+    //         const { queueId } = setupQueue(space, canvasModel, {
+    //           idPosition: { centerX: -720, centerY: 224, width: 192, height: 256 },
+    //           queuePosition: { centerX: -144, centerY: 416, width: 320, height: 448 },
+    //         });
+    //         const appendToQueue = canvasModel.createNode(
+    //           createAppend(rawPosition({ centerX: -80, centerY: 96, width: 122, height: 128 })),
+    //         );
+    //         const tableId = canvasModel.createNode(
+    //           createConstant({
+    //             value: DXN.fromLocalObjectId(emailTable.id).toString(),
+    //             ...rawPosition({ centerX: -112, centerY: -544, width: 192, height: 256 }),
+    //           }),
+    //         );
+    //         const appendToTable = canvasModel.createNode(
+    //           createAppend(rawPosition({ centerX: 560, centerY: -416, width: 128, height: 122 })),
+    //         );
+    //         templateContent.push('  "category": "{{text}}",');
+    //         builder.createEdge({ source: gpt.id, target: template.id, input: 'text', output: 'text' });
+    //         const properties = SchemaAST.getPropertySignatures(EmailTriggerOutput.ast);
+    //         for (let i = 0; i < properties.length; i++) {
+    //           const propName = properties[i].name.toString();
+    //           builder.createEdge({ source: trigger.id, target: template.id, input: propName, output: propName });
+    //           templateContent.push(`  "${propName}": "{{${propName}}}"` + (i === properties.length - 1 ? '' : ','));
+    //         }
+    //         templateContent.push('}');
+    //         builder
+    //           .createEdge({ source: tableId.id, target: appendToTable.id, input: 'id' })
+    //           .createEdge({ source: queueId.id, target: appendToQueue.id, input: 'id' })
+    //           .createEdge({ source: gpt.id, target: appendToQueue.id, output: 'messages', input: 'items' })
+    //           .createEdge({ source: systemPrompt.id, target: gpt.id, input: 'systemPrompt' })
+    //           .createEdge({ source: trigger.id, target: gpt.id, input: 'prompt', output: 'body' })
+    //           .createEdge({ source: template.id, target: appendToTable.id, input: 'items' });
+    //         functionTrigger = triggerShape.functionTrigger!.target!;
+    //       });
+    //       const computeModel = createComputeGraph(canvasModel);
+    //       const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
+    //       invariant(templateComputeNode, 'Template compute node was not created.');
+    //       templateComputeNode.value = templateContent.join('\n');
+    //       const extendedSchema = Schema.extend(EmailTriggerOutput, Schema.Struct({ text: Schema.String }));
+    //       templateComputeNode.inputSchema = Type.toJsonSchema(extendedSchema);
+    //       attachTrigger(functionTrigger, computeModel);
+    //       return addToSpace(PresetName.EMAIL_WITH_SUMMARY, space, canvasModel, computeModel);
+    //     });
+    //     cb?.(objects);
+    //     return objects;
+    //   },
+    // ],
+    [
+      "forex-function-call",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          canvasModel.builder.call((builder) => {
+            const sourceCurrency = canvasModel.createNode(createConstant({
+              value: "USD",
+              ...position({
+                x: -10,
+                y: -5
+              })
+            }));
+            const targetCurrency = canvasModel.createNode(createConstant({
+              value: "EUR",
+              ...position({
+                x: -10,
+                y: 5
+              })
+            }));
+            const converter = canvasModel.createNode(createFunction(position({
+              x: 0,
+              y: 0
+            })));
+            const view = canvasModel.createNode(createSurface(position({
+              x: 12,
+              y: 0
+            })));
+            builder.createEdge({
+              source: sourceCurrency.id,
+              target: converter.id,
+              input: "from"
+            }).createEdge({
+              source: targetCurrency.id,
+              target: converter.id,
+              input: "to"
+            }).createEdge({
+              source: converter.id,
+              target: view.id,
+              output: "rate"
+            });
+          });
+          const computeModel = createComputeGraph(canvasModel);
+          return addToSpace("forex-function-call", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    [
+      "discord-messages",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          let functionTrigger;
+          canvasModel.builder.call((builder) => {
+            const triggerShape = createTrigger({
+              spaceId: space.id,
+              triggerKind: "timer",
+              ...position({
+                x: -10,
+                y: -5
+              })
+            });
+            const trigger = canvasModel.createNode(triggerShape);
+            const channelId = canvasModel.createNode(createConstant({
+              value: "1088569858767212554",
+              ...position({
+                x: -10,
+                y: 0
+              })
+            }));
+            const queueId = canvasModel.createNode(createConstant({
+              value: new DXN2(DXN2.kind.QUEUE, [
+                "data",
+                space.id,
+                Key2.ObjectId.random()
+              ]).toString(),
+              ...position({
+                x: -10,
+                y: 5
+              })
+            }));
+            const converter = canvasModel.createNode(createFunction(position({
+              x: 0,
+              y: 0
+            })));
+            const view = canvasModel.createNode(createText(position({
+              x: 12,
+              y: 0
+            })));
+            const queue = canvasModel.createNode(createQueue(position({
+              x: 0,
+              y: 12
+            })));
+            builder.createEdge({
+              source: trigger.id,
+              target: converter.id,
+              input: "tick"
+            }).createEdge({
+              source: channelId.id,
+              target: converter.id,
+              input: "channelId"
+            }).createEdge({
+              source: queueId.id,
+              target: converter.id,
+              input: "queueId"
+            }).createEdge({
+              source: converter.id,
+              target: view.id,
+              output: "newMessages"
+            }).createEdge({
+              source: queueId.id,
+              target: queue.id,
+              input: "input"
+            });
+            functionTrigger = triggerShape.functionTrigger.target;
+          });
+          const computeModel = createComputeGraph(canvasModel);
+          attachTrigger(functionTrigger, computeModel);
+          return addToSpace("discord-messages", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ]
+  ]
+});
+var createQueueSinkPreset = (space, triggerKind, initSpec, triggerOutputName) => {
+  const canvasModel = CanvasGraphModel.create();
+  const template = canvasModel.createNode(createTemplate({
+    valueType: "object",
+    ...rawPosition({
+      centerX: -64,
+      centerY: -79,
+      width: 320,
+      height: 320
+    })
+  }));
+  let functionTrigger;
+  canvasModel.builder.call((builder) => {
+    const triggerShape = createTrigger({
+      spaceId: space.id,
+      triggerKind,
+      ...rawPosition({
+        centerX: -578,
+        centerY: -187,
+        height: 320,
+        width: 320
+      })
+    });
+    const trigger = canvasModel.createNode(triggerShape);
+    const { queueId } = setupQueue(space, canvasModel, {
+      queuePosition: {
+        centerX: -80,
+        centerY: 378,
+        width: 320,
+        height: 448
+      }
+    });
+    const append = canvasModel.createNode(createAppend(rawPosition({
+      centerX: 320,
+      centerY: 192,
+      width: 128,
+      height: 122
+    })));
+    const random = canvasModel.createNode(createRandom(rawPosition({
+      centerX: -509,
+      centerY: -30,
+      width: 64,
+      height: 64
+    })));
+    builder.createEdge({
+      source: queueId.id,
+      target: append.id,
+      input: "id"
+    }).createEdge({
+      source: template.id,
+      target: append.id,
+      input: "items"
+    }).createEdge({
+      source: trigger.id,
+      target: template.id,
+      output: triggerOutputName,
+      input: "type"
+    }).createEdge({
+      source: random.id,
+      target: template.id,
+      input: "changeId"
+    });
+    functionTrigger = triggerShape.functionTrigger.target;
+    const triggerSpec = functionTrigger.spec;
+    invariant(triggerSpec && triggerSpec.kind === triggerKind, "No trigger spec.", {
+      F: __dxlog_file,
+      L: 756,
+      S: void 0,
+      A: [
+        "triggerSpec && triggerSpec.kind === triggerKind",
+        "'No trigger spec.'"
+      ]
+    });
+    Obj.change(functionTrigger, (ft) => {
+      initSpec(ft.spec);
+    });
+  });
+  const computeModel = createComputeGraph(canvasModel);
+  const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
+  invariant(templateComputeNode, "Template compute node was not created.", {
+    F: __dxlog_file,
+    L: 765,
+    S: void 0,
+    A: [
+      "templateComputeNode",
+      "'Template compute node was not created.'"
+    ]
+  });
+  templateComputeNode.value = [
+    "{",
+    '  "@type": "{{type}}",',
+    '  "id": "@{{changeId}}"',
+    "}"
+  ].join("\n");
+  templateComputeNode.inputSchema = Type.toJsonSchema(Schema.Struct({
+    type: Schema.String,
+    changeId: Schema.String
+  }));
+  attachTrigger(functionTrigger, computeModel);
+  return {
+    canvasModel,
+    computeModel
+  };
+};
+var addToSpace = (name, space, canvas, compute) => {
+  return space.db.add(Obj.make(CanvasBoard.CanvasBoard, {
+    name,
+    computeGraph: Ref.make(compute.root),
+    layout: canvas.graph
+  }));
+};
+var setupQueue = (space, canvasModel, args) => {
+  const queueId = canvasModel.createNode(createConstant({
+    value: new DXN2(DXN2.kind.QUEUE, [
+      "data",
+      space.id,
+      Key2.ObjectId.random()
+    ]).toString(),
+    ...args?.idPosition ? rawPosition(args.idPosition) : position({
+      x: -18,
+      y: 5,
+      width: 8,
+      height: 6
+    })
+  }));
+  const queue = canvasModel.createNode(createQueue(args?.queuePosition ? rawPosition(args.queuePosition) : position({
+    x: -3,
+    y: 3,
+    width: 14,
+    height: 10
+  })));
+  canvasModel.createEdge({
+    source: queueId.id,
+    target: queue.id
+  });
+  return {
+    queue,
+    queueId
+  };
+};
+var attachTrigger = (functionTrigger, computeModel) => {
+  invariant(functionTrigger, void 0, {
+    F: __dxlog_file,
+    L: 805,
+    S: void 0,
+    A: [
+      "functionTrigger",
+      ""
+    ]
+  });
+  const inputNode = computeModel.nodes.find((node) => node.type === NODE_INPUT2);
+  Obj.change(functionTrigger, (t) => {
+    t.function = Ref.make(computeModel.root);
+    t.inputNodeId = inputNode.id;
+  });
+};
+var rawPosition = (args) => {
+  return {
+    center: {
+      x: args.centerX,
+      y: args.centerY
+    },
+    size: {
+      width: args.width,
+      height: args.height
+    }
+  };
+};
+var position = (rect) => {
+  const snap = 32;
+  const [center, size] = rectToPoints({
+    width: 0,
+    height: 0,
+    ...rect
+  });
+  const { x, y, width, height } = pointsToRect([
+    pointMultiply(center, snap),
+    pointMultiply(size, snap)
+  ]);
+  if (width && height) {
+    return {
+      center: {
+        x,
+        y
+      },
+      size: width && height ? {
+        width,
+        height
+      } : void 0
+    };
+  } else {
+    return {
+      center: {
+        x,
+        y
+      }
+    };
+  }
+};
+
+// src/components/SpaceGenerator/SchemaTable.tsx
+import React from "react";
+import { IconButton } from "@dxos/react-ui";
+var SchemaTable = ({ types, objects = {}, label, onClick }) => {
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "grid grid-cols-[1fr_80px_40px] gap-1 overflow-none"
+  }, /* @__PURE__ */ React.createElement("h2", {
+    className: "p-2"
+  }, label), types.map((type) => /* @__PURE__ */ React.createElement("div", {
+    key: type.typename,
+    className: "grid grid-cols-subgrid col-span-3 items-center"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "pli-2 text-sm font-mono text-subdued"
+  }, type.typename), /* @__PURE__ */ React.createElement("div", {
+    className: "pli-2 text-right font-mono"
+  }, objects[type.typename] ?? 0), /* @__PURE__ */ React.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--plus--regular",
+    iconOnly: true,
+    label: "Create data",
+    onClick: () => onClick(type.typename)
+  }))));
+};
+
+// src/components/SpaceGenerator/SpaceGenerator.tsx
+var SpaceGenerator = ({ space, onCreateObjects }) => {
+  const { invokePromise } = useOperationInvoker();
+  const client = useClient();
+  const staticTypes = [
+    Markdown3.Document,
+    Diagram2.Diagram,
+    Sheet2.Sheet,
+    ComputeGraph2
+  ];
+  const recordTypes = [
+    Organization2.Organization,
+    Person2.Person,
+    Task.Task
+  ];
+  const [count, setCount] = useState(1);
+  const [info, setInfo] = useState({});
+  const presets = useMemo(() => generator2(), []);
+  useAsyncEffect(async () => {
+    await client.addTypes([
+      ...staticTypes,
+      ...recordTypes,
+      ...presets.schemas
+    ]);
+  }, [
+    client
+  ]);
+  const typeMap = useMemo(() => {
+    const recordGenerators = new Map(recordTypes.map((type) => [
+      type.typename,
+      createGenerator(client, invokePromise, type)
+    ]));
+    return new Map([
+      ...staticGenerators,
+      ...presets.items,
+      ...recordGenerators
+    ]);
+  }, [
+    client,
+    recordTypes,
+    invokePromise
+  ]);
+  const updateInfo = async () => {
+    const echoSchema = await space.db.schemaRegistry.query().run();
+    const staticSchema = await space.db.graph.schemaRegistry.query().run();
+    const objects = await space.db.query(Filter3.everything()).run();
+    const objectMap = sortKeys(objects.reduce((map, obj) => {
+      const type = Obj2.getTypename(obj);
+      if (type) {
+        const count2 = map[type] ?? 0;
+        map[type] = count2 + 1;
+      }
+      return map;
+    }, {}));
+    setInfo({
+      schema: {
+        static: staticSchema.length,
+        mutable: echoSchema.length
+      },
+      objects: objectMap
+    });
+  };
+  useAsyncEffect(updateInfo, [
+    space
+  ]);
+  const handleCreateData = useCallback(async (typename) => {
+    const constructor = typeMap.get(typename);
+    if (constructor) {
+      await constructor(space, count, onCreateObjects);
+      await updateInfo();
+    }
+  }, [
+    typeMap,
+    count
+  ]);
+  return /* @__PURE__ */ React2.createElement(Layout.Main, {
+    toolbar: true
+  }, /* @__PURE__ */ React2.createElement(Toolbar.Root, null, /* @__PURE__ */ React2.createElement(IconButton2, {
+    icon: "ph--arrow-clockwise--regular",
+    iconOnly: true,
+    label: "Refresh",
+    onClick: updateInfo
+  }), /* @__PURE__ */ React2.createElement(Toolbar.Separator, {
+    variant: "gap"
+  }), /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.TextInput, {
+    type: "number",
+    placeholder: "Count",
+    classNames: "is-[4rem] text-right",
+    min: 1,
+    max: 100,
+    size: 8,
+    value: count,
+    onChange: (event) => setCount(parseInt(event.target.value))
+  }))), /* @__PURE__ */ React2.createElement(ScrollArea.Root, {
+    thin: true,
+    orientation: "vertical"
+  }, /* @__PURE__ */ React2.createElement(ScrollArea.Viewport, {
+    classNames: "gap-4 divide-y divide-subduedSeparator"
+  }, /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: staticTypes,
+    objects: info.objects,
+    label: "Static Types",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: recordTypes,
+    objects: info.objects,
+    label: "Record Types",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: presets.types,
+    objects: info.objects,
+    label: "Presets",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SyntaxHighlighter, {
+    language: "json",
+    classNames: "text-xs"
+  }, JSON.stringify({
+    space,
+    ...info
+  }, jsonKeyReplacer({
+    truncate: true
+  }), 2)))));
+};
+
+// src/components/SpaceGenerator/index.ts
+var SpaceGenerator_default = SpaceGenerator;
+export {
+  SpaceGenerator_default as default
+};
+//# sourceMappingURL=SpaceGenerator-W3LJORYT.mjs.map