@dxos/plugin-debug 0.7.5-main.e9bb01b → 0.7.5-staging.2ff1350

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

@@ -0,0 +1,1238 @@
+// packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx
+import React2, { useCallback, useMemo, useState } from "react";
+import { createIntent, useIntentDispatcher } from "@dxos/app-framework";
+import { ComputeGraph as ComputeGraph2 } from "@dxos/conductor";
+import { toEffectSchema } from "@dxos/echo-schema";
+import { create as create3 } from "@dxos/live-object";
+import { log } from "@dxos/log";
+import { DocumentType as DocumentType2 } from "@dxos/plugin-markdown/types";
+import { SheetType as SheetType2 } from "@dxos/plugin-sheet/types";
+import { DiagramType as DiagramType2 } from "@dxos/plugin-sketch/types";
+import { SpaceAction } from "@dxos/plugin-space/types";
+import { useClient } from "@dxos/react-client";
+import { getTypename } from "@dxos/react-client/echo";
+import { IconButton as IconButton2, Input, Toolbar, useAsyncEffect } from "@dxos/react-ui";
+import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { initializeTable, TableType as TableType3 } from "@dxos/react-ui-table";
+import { Testing } from "@dxos/schema/testing";
+import { jsonKeyReplacer, sortKeys } from "@dxos/util";
+
+// packages/plugins/plugin-debug/src/components/SpaceGenerator/ObjectGenerator.tsx
+import { addressToA1Notation } from "@dxos/compute";
+import { ComputeGraph, ComputeGraphModel, DEFAULT_OUTPUT, NODE_INPUT, NODE_OUTPUT } from "@dxos/conductor";
+import { ObjectId } from "@dxos/echo-schema";
+import { DXN } from "@dxos/keys";
+import { create, makeRef } from "@dxos/live-object";
+import { DocumentType } from "@dxos/plugin-markdown/types";
+import { createSheet } from "@dxos/plugin-sheet/types";
+import { SheetType } from "@dxos/plugin-sheet/types";
+import { CanvasType, DiagramType } from "@dxos/plugin-sketch/types";
+import { faker } from "@dxos/random";
+import { Filter } from "@dxos/react-client/echo";
+import { TableType } from "@dxos/react-ui-table";
+import { createView, TextType } from "@dxos/schema";
+import { createAsyncGenerator } from "@dxos/schema/testing";
+import { range } from "@dxos/util";
+var generator = faker;
+var staticGenerators = /* @__PURE__ */ new Map([
+  [
+    DocumentType.typename,
+    async (space, n, cb) => {
+      const objects = range(n).map(() => {
+        return space.db.add(create(DocumentType, {
+          name: faker.commerce.productName(),
+          content: makeRef(create(TextType, {
+            content: faker.lorem.sentences(5)
+          })),
+          threads: []
+        }));
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ],
+  [
+    DiagramType.typename,
+    async (space, n, cb) => {
+      const objects = range(n).map(() => {
+        const obj = space.db.add(create(DiagramType, {
+          name: faker.commerce.productName(),
+          canvas: makeRef(create(CanvasType, {
+            content: {}
+          }))
+        }));
+        return obj;
+      });
+      cb?.(objects);
+      return objects;
+    }
+  ],
+  // TODO(burdon): Create unit tests.
+  [
+    SheetType.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(createSheet({
+          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,
+            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;
+    }
+  ]
+]);
+var createGenerator = (type) => {
+  return async (space, n, cb) => {
+    const schema = await space.db.schemaRegistry.query({
+      typename: type.typename
+    }).firstOrUndefined() ?? (await space.db.schemaRegistry.register([
+      type
+    ]))[0];
+    const generate = createAsyncGenerator(generator, schema.getSchemaSnapshot(), {
+      db: space.db
+    });
+    const objects = await generate.createObjects(n);
+    const { objects: tables } = await space.db.query(Filter.schema(TableType)).run();
+    const table = tables.find((table2) => table2.view?.target?.query?.type === type.typename);
+    if (!table) {
+      const name = type.typename.split("/").pop() ?? type.typename;
+      const view = createView({
+        name,
+        typename: type.typename,
+        jsonSchema: schema.jsonSchema
+      });
+      const table2 = space.db.add(create(TableType, {
+        name,
+        view: makeRef(view)
+      }));
+      cb?.([
+        table2
+      ]);
+    }
+    return objects;
+  };
+};
+
+// packages/plugins/plugin-debug/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-hidden"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "grid grid-cols-subgrid col-span-3"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "px-2 text-sm text-primary-500"
+  }, label), /* @__PURE__ */ React.createElement("div", {
+    className: "px-2 text-xs text-subdued text-right"
+  }, "count")), 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: "px-2 text-sm font-mono text-green-500"
+  }, type.typename), /* @__PURE__ */ React.createElement("div", {
+    className: "px-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)
+  }))));
+};
+
+// packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts
+import { EmailTriggerOutput, NODE_INPUT as NODE_INPUT2 } from "@dxos/conductor";
+import { AST, ObjectId as ObjectId2, S, toJsonSchema } from "@dxos/echo-schema";
+import { FunctionTrigger, TriggerKind } from "@dxos/functions/types";
+import { invariant } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
+import { create as create2, makeRef as makeRef2 } from "@dxos/live-object";
+import { Filter as Filter2 } from "@dxos/react-client/echo";
+import { createAppend, createChat, createComputeGraph, createConstant, createFunction, createGpt, createQueue, createSurface, createRandom, createTemplate, createText, createTrigger } from "@dxos/react-ui-canvas-compute";
+import { CanvasBoardType, CanvasGraphModel, pointMultiply, pointsToRect, rectToPoints } from "@dxos/react-ui-canvas-editor";
+import { TableType as TableType2 } from "@dxos/react-ui-table";
+import { range as range2 } from "@dxos/util";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts";
+var PresetName;
+(function(PresetName2) {
+  PresetName2["EMAIL_TABLE"] = "email-table";
+  PresetName2["GPT_QUEUE"] = "webhook-gpt-queue";
+  PresetName2["CHAT_GPT"] = "chat-gpt-text";
+  PresetName2["EMAIL_WITH_SUMMARY"] = "email-gptSummary-table";
+  PresetName2["OBJECT_CHANGE_QUEUE"] = "objectChange-queue";
+  PresetName2["FOREX_FUNCTION_CALL"] = "forex-function-call";
+  PresetName2["TIMER_TICK_QUEUE"] = "timerTick-queue";
+  PresetName2["DISCORD_MESSAGES"] = "discord-messages";
+  PresetName2["KANBAN_QUEUE"] = "kanban-queue";
+})(PresetName || (PresetName = {}));
+var presets = {
+  schemas: [
+    CanvasBoardType,
+    FunctionTrigger
+  ],
+  types: Object.values(PresetName).map((name) => ({
+    typename: name
+  })),
+  items: [
+    [
+      "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: 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, TriggerKind.Subscription, (triggerSpec) => triggerSpec.filter = {
+            type: "dxn:type:dxos.org/type/Chess"
+          }, "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, TriggerKind.Timer, (triggerSpec) => triggerSpec.cron = "*/5 * * * * *", "result");
+          return addToSpace("timerTick-queue", space, canvasModel, computeModel);
+        });
+        cb?.(objects);
+        return objects;
+      }
+    ],
+    [
+      "email-table",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          const results = space.db.query(Filter2.schema(TableType2)).runSync();
+          const emailTable = results.find((r) => r.object?.view?.target?.query?.type?.endsWith("Email"));
+          invariant(emailTable, "Email table not found.", {
+            F: __dxlog_file,
+            L: 136,
+            S: void 0,
+            A: [
+              "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;
+          canvasModel.builder.call((builder) => {
+            const triggerShape = createTrigger({
+              spaceId: space.id,
+              triggerKind: TriggerKind.Email,
+              ...position({
+                x: -18,
+                y: -2
+              })
+            });
+            const trigger = canvasModel.createNode(triggerShape);
+            const tableId = canvasModel.createNode(createConstant({
+              value: DXN2.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 = AST.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((n2) => n2.id === template.node);
+          invariant(templateComputeNode, "Template compute node was not created.", {
+            F: __dxlog_file,
+            L: 182,
+            S: void 0,
+            A: [
+              "templateComputeNode",
+              "'Template compute node was not created.'"
+            ]
+          });
+          templateComputeNode.value = templateContent.join("\n");
+          templateComputeNode.inputSchema = toJsonSchema(EmailTriggerOutput);
+          attachTrigger(functionTrigger, computeModel);
+          return addToSpace("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;
+      }
+    ],
+    [
+      "email-gptSummary-table",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          const results = space.db.query(Filter2.schema(TableType2)).runSync();
+          const emailTable = results.find((r) => r.object?.view?.target?.query?.type?.endsWith("Email"));
+          invariant(emailTable, "Email table not found.", {
+            F: __dxlog_file,
+            L: 233,
+            S: void 0,
+            A: [
+              "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;
+          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: 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: DXN2.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 = AST.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((n2) => n2.id === template.node);
+          invariant(templateComputeNode, "Template compute node was not created.", {
+            F: __dxlog_file,
+            L: 305,
+            S: void 0,
+            A: [
+              "templateComputeNode",
+              "'Template compute node was not created.'"
+            ]
+          });
+          templateComputeNode.value = templateContent.join("\n");
+          const extendedSchema = S.extend(EmailTriggerOutput, S.Struct({
+            text: S.String
+          }));
+          templateComputeNode.inputSchema = toJsonSchema(extendedSchema);
+          attachTrigger(functionTrigger, computeModel);
+          return addToSpace("email-gptSummary-table", 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: 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,
+                ObjectId2.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;
+      }
+    ],
+    [
+      "kanban-queue",
+      async (space, n, cb) => {
+        const objects = range2(n, () => {
+          const canvasModel = CanvasGraphModel.create();
+          const results = space.db.query(Filter2.schema(TableType2)).runSync();
+          const messages = results.find((r) => r.object?.view?.target?.query?.type?.endsWith("Message"));
+          invariant(messages, "Table not found.", {
+            F: __dxlog_file,
+            L: 411,
+            S: void 0,
+            A: [
+              "messages",
+              "'Table not found.'"
+            ]
+          });
+          let functionTrigger;
+          canvasModel.builder.call((builder) => {
+            const triggerShape = createTrigger({
+              spaceId: space.id,
+              triggerKind: TriggerKind.Queue,
+              ...position({
+                x: -10,
+                y: -5
+              })
+            });
+            const trigger = canvasModel.createNode(triggerShape);
+            const tableId = canvasModel.createNode(createConstant({
+              value: DXN2.fromLocalObjectId(messages.id).toString(),
+              ...position({
+                x: -10,
+                y: 5
+              })
+            }));
+            const appendToTable = canvasModel.createNode(createAppend(position({
+              x: 10,
+              y: 0
+            })));
+            builder.createEdge({
+              source: tableId.id,
+              target: appendToTable.id,
+              input: "id"
+            }).createEdge({
+              source: trigger.id,
+              target: appendToTable.id,
+              input: "items",
+              output: "item"
+            });
+            functionTrigger = triggerShape.functionTrigger.target;
+          });
+          const computeModel = createComputeGraph(canvasModel);
+          attachTrigger(functionTrigger, computeModel);
+          return addToSpace("kanban-queue", 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.type === triggerKind, "No trigger spec.", {
+      F: __dxlog_file,
+      L: 494,
+      S: void 0,
+      A: [
+        "triggerSpec && triggerSpec.type === triggerKind",
+        "'No trigger spec.'"
+      ]
+    });
+    initSpec(triggerSpec);
+  });
+  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: 501,
+    S: void 0,
+    A: [
+      "templateComputeNode",
+      "'Template compute node was not created.'"
+    ]
+  });
+  templateComputeNode.value = [
+    "{",
+    '  "@type": "{{type}}",',
+    '  "id": "@{{changeId}}"',
+    "}"
+  ].join("\n");
+  templateComputeNode.inputSchema = toJsonSchema(S.Struct({
+    type: S.String,
+    changeId: S.String
+  }));
+  attachTrigger(functionTrigger, computeModel);
+  return {
+    canvasModel,
+    computeModel
+  };
+};
+var addToSpace = (name, space, canvas, compute) => {
+  return space.db.add(create2(CanvasBoardType, {
+    name,
+    computeGraph: makeRef2(compute.root),
+    layout: canvas.graph
+  }));
+};
+var setupQueue = (space, canvasModel, args) => {
+  const queueId = canvasModel.createNode(createConstant({
+    value: new DXN2(DXN2.kind.QUEUE, [
+      "data",
+      space.id,
+      ObjectId2.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: 541,
+    S: void 0,
+    A: [
+      "functionTrigger",
+      ""
+    ]
+  });
+  functionTrigger.function = DXN2.fromLocalObjectId(computeModel.root.id).toString();
+  functionTrigger.meta ??= {};
+  const inputNode = computeModel.nodes.find((node) => node.type === NODE_INPUT2);
+  functionTrigger.meta.computeNodeId = 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
+      }
+    };
+  }
+};
+
+// packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx";
+var SpaceGenerator = ({ space, onCreateObjects }) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const client = useClient();
+  const staticTypes = [
+    DocumentType2,
+    DiagramType2,
+    SheetType2,
+    ComputeGraph2
+  ];
+  const mutableTypes = [
+    Testing.OrgType,
+    Testing.ProjectType,
+    Testing.ContactType,
+    Testing.EmailType,
+    Testing.MessageType
+  ];
+  const [count, setCount] = useState(1);
+  const [info, setInfo] = useState({});
+  const typeMap = useMemo(() => {
+    client.addTypes([
+      ...staticTypes,
+      ...presets.schemas
+    ]);
+    const mutableGenerators = new Map(mutableTypes.map((type) => [
+      type.typename,
+      createGenerator(type)
+    ]));
+    return new Map([
+      ...staticGenerators,
+      ...presets.items,
+      ...mutableGenerators
+    ]);
+  }, [
+    client,
+    mutableTypes
+  ]);
+  const updateInfo = async () => {
+    const echoSchema = await space.db.schemaRegistry.query().run();
+    const staticSchema = space.db.graph.schemaRegistry.schemas;
+    const { objects } = await space.db.query().run();
+    const objectMap = sortKeys(objects.reduce((map, obj) => {
+      const type = 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
+  ]);
+  const handleLoadTables = useCallback(async () => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = ".json";
+    input.onchange = async (e) => {
+      const file = e.target.files?.[0];
+      if (!file) {
+        return;
+      }
+      try {
+        const content = await file.text();
+        const data = JSON.parse(content);
+        const schemas = await space.db.schemaRegistry.register(data.schemas.map(toEffectSchema));
+        await Promise.all(schemas.map(async (schema) => {
+          const parts = schema.typename.split("/");
+          const name = parts[parts.length - 1];
+          const table = create3(TableType3, {
+            name,
+            threads: []
+          });
+          await initializeTable({
+            space,
+            table,
+            initialSchema: schema.typename
+          });
+          await dispatch(createIntent(SpaceAction.AddObject, {
+            target: space,
+            object: table
+          }));
+          return table;
+        }));
+        await Promise.all(data.objects.map(async ({ id, "@type": typename, ...fields }) => {
+          const schema = schemas.find((s) => `dxn:type:${s.typename}:${s.version}` === typename);
+          if (!schema) {
+            log.warn("Missing schema for object", {
+              id,
+              typename
+            }, {
+              F: __dxlog_file2,
+              L: 131,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            return;
+          }
+          const object = create3(schema, fields);
+          space.db.add(object);
+          return object;
+        }));
+      } catch (err) {
+        log.catch(err, void 0, {
+          F: __dxlog_file2,
+          L: 140,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    input.click();
+  }, []);
+  return /* @__PURE__ */ React2.createElement("div", {
+    role: "none",
+    className: "flex flex-col divide-y divide-separator"
+  }, /* @__PURE__ */ React2.createElement(Toolbar.Root, {
+    classNames: "p-1"
+  }, /* @__PURE__ */ React2.createElement(IconButton2, {
+    icon: "ph--arrow-clockwise--regular",
+    iconOnly: true,
+    label: "Refresh",
+    onClick: updateInfo
+  }), /* @__PURE__ */ React2.createElement(IconButton2, {
+    icon: "ph--file-arrow-up--regular",
+    iconOnly: true,
+    label: "Load tables from JSON",
+    onClick: handleLoadTables
+  }), /* @__PURE__ */ React2.createElement(Toolbar.Separator, {
+    variant: "gap"
+  }), /* @__PURE__ */ React2.createElement("div", {
+    className: "flex"
+  }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.TextInput, {
+    type: "number",
+    min: 1,
+    max: 100,
+    placeholder: "Count",
+    classNames: "w-[80px]",
+    value: count,
+    onChange: (ev) => setCount(parseInt(ev.target.value))
+  })))), /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: staticTypes,
+    objects: info.objects,
+    label: "Static Types",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: mutableTypes,
+    objects: info.objects,
+    label: "Mutable Types",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SchemaTable, {
+    types: presets.types,
+    objects: info.objects,
+    label: "Presets",
+    onClick: handleCreateData
+  }), /* @__PURE__ */ React2.createElement(SyntaxHighlighter, {
+    classNames: "flex text-xs",
+    language: "json"
+  }, JSON.stringify({
+    space,
+    ...info
+  }, jsonKeyReplacer({
+    truncate: true
+  }), 2)));
+};
+
+// packages/plugins/plugin-debug/src/components/SpaceGenerator/index.ts
+var SpaceGenerator_default = SpaceGenerator;
+export {
+  SpaceGenerator_default as default
+};
+//# sourceMappingURL=SpaceGenerator-BPZGOSH4.mjs.map