@dxos/plugin-debug 0.10.0 → 0.11.1

package/dist/lib/components.mjs

@@ -0,0 +1,763 @@
+import { range, trim } from "@dxos/util";
+import "react";
+import * as Schema from "effect/Schema";
+import { IconButton } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { RunInstructions, WebSearchSkill } from "@dxos/assistant-toolkit";
+import { Instructions, Operation, Trigger } from "@dxos/compute";
+import { ComputeGraph, ComputeGraphModel, DEFAULT_OUTPUT, NODE_INPUT, NODE_OUTPUT } from "@dxos/conductor";
+import { EID, Feed, Filter, JsonSchema, Key, Obj, Query, Ref, Scope, Tag, Type, View } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { DXN, EID as EID$1 } from "@dxos/keys";
+import { InboxOperation, Mailbox } from "@dxos/plugin-inbox";
+import { Markdown } from "@dxos/plugin-markdown";
+import { createAppend, createChat, createComputeGraph, createConstant, createFeed, createFunction, createGpt, createRandom, createSurface, createTemplate, createText, createTrigger } from "@dxos/react-ui-canvas-compute";
+import { CanvasBoard, CanvasGraphModel, pointMultiply, pointsToRect, rectToPoints } from "@dxos/react-ui-canvas-editor";
+import { ViewModel, getTypeURIFromQuery } from "@dxos/schema";
+import { Message, Organization, Person, Pipeline } from "@dxos/types";
+import { addressToA1Notation } from "@dxos/compute-hyperformula";
+import { Drawing } from "@dxos/plugin-illustrator";
+import { Sheet } from "@dxos/plugin-sheet";
+import { SpaceOperation } from "@dxos/plugin-space";
+import { Tldraw } from "@dxos/plugin-tldraw";
+import { random } from "@dxos/random";
+import { createAsyncGenerator } from "@dxos/schema/testing";
+//#region src/components/SchemaTable/SchemaTable.tsx
+var SchemaTable = ({ classNames, types, objects = {}, label, onClick }) => {
+	return /* @__PURE__ */ jsxs("div", {
+		className: mx("grid grid-cols-[1fr_80px_40px] gap-1 overflow-none", classNames),
+		children: [/* @__PURE__ */ jsx("h2", {
+			className: "p-2",
+			children: label
+		}), types.map((type) => /* @__PURE__ */ jsxs("div", {
+			className: "grid grid-cols-subgrid col-span-3 items-center",
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "px-2 text-sm font-mono text-subdued",
+					children: type.typename
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "px-2 text-right font-mono",
+					children: objects[type.typename] ?? 0
+				}),
+				/* @__PURE__ */ jsx(IconButton, {
+					variant: "ghost",
+					icon: "ph--plus--regular",
+					iconOnly: true,
+					label: "Create data",
+					onClick: () => onClick(type.typename)
+				})
+			]
+		}, type.typename))]
+	});
+};
+//#endregion
+//#region src/components/SpaceGenerator/presets.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts";
+var PresetName = /* @__PURE__ */ function(PresetName) {
+	PresetName["DXOS_TEAM"] = "dxos-team";
+	PresetName["ORG_RESEARCH_PROJECT"] = "org-research-project";
+	PresetName["GPT_QUEUE"] = "webhook-gpt-queue";
+	PresetName["CHAT_GPT"] = "chat-gpt-text";
+	PresetName["OBJECT_CHANGE_QUEUE"] = "objectChange-queue";
+	PresetName["TIMER_TICK_QUEUE"] = "timerTick-queue";
+	PresetName["FOREX_FUNCTION_CALL"] = "forex-function-call";
+	PresetName["DISCORD_MESSAGES"] = "discord-messages";
+	return PresetName;
+}({});
+var generator = () => ({
+	schemas: [CanvasBoard.CanvasBoard, Trigger.Trigger],
+	types: Object.values(PresetName).map((name) => ({ typename: name })),
+	items: [
+		["dxos-team", async (space, n, cb) => {
+			const objects = range(n, () => {
+				const org = space.db.add(Obj.make(Organization.Organization, {
+					name: "DXOS",
+					website: "https://dxos.org"
+				}));
+				const doc = space.db.add(Markdown.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 tagRef = Ref.make(tag);
+				Obj.update(doc, (doc) => {
+					Obj.getMeta(doc).tags = [tagRef];
+				});
+				space.db.add(Obj.make(Person.Person, {
+					[Obj.Meta]: { tags: [tagRef] },
+					fullName: "Rich",
+					organization: Ref.make(org)
+				}));
+				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(Filter.type(Mailbox.Mailbox)).run())[0];
+			invariant(mailbox, "Mailbox not found", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 121,
+				S: void 0,
+				A: ["mailbox", "'Mailbox not found'"]
+			});
+			const mailboxFeed = await mailbox.feed?.tryLoad();
+			invariant(mailboxFeed, "Mailbox missing feed reference", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 123,
+				S: void 0,
+				A: ["mailboxFeed", "'Mailbox missing feed reference'"]
+			});
+			invariant(Feed.getFeedUri(mailboxFeed), "Mailbox feed missing feed URI", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 125,
+				S: void 0,
+				A: ["feedUri", "'Mailbox feed missing feed URI'"]
+			});
+			const tag = await space.db.query(Filter.type(Tag.Tag, { label: "Investor" })).first();
+			const tagUri = Obj.getURI(tag);
+			const objects = range(n, () => {
+				const contactsQuery = Query.select(Filter.type(Person.Person)).select(Filter.tag(tagUri));
+				const organizationsQuery = Query.select(Filter.type(Organization.Organization)).select(Filter.tag(tagUri));
+				const notesQuery = Query.select(Filter.type(Markdown.Document)).select(Filter.tag(tagUri));
+				space.db.add(Trigger.make({
+					enabled: true,
+					spec: Trigger.specTimer("* * * * *"),
+					runnable: Ref.make(Operation.serialize(InboxOperation.GoogleMailSync)),
+					input: { mailbox: Ref.make(mailbox) }
+				}));
+				const researchPrompt = space.db.add(Instructions.make({
+					name: "Research",
+					description: "Research organization",
+					text: trim`
+                Research the organization provided as input.
+                Create a research note for it at the end.
+                NOTE: Do mocked reseach (set mockSearch to true).
+              `,
+					skills: [Ref.make(WebSearchSkill.make())]
+				}));
+				space.db.add(Trigger.make({
+					enabled: true,
+					spec: Trigger.specSubscription(organizationsQuery),
+					runnable: Ref.make(Operation.serialize(RunInstructions)),
+					input: {
+						instructions: Ref.make(researchPrompt),
+						input: "{{event.subject}}"
+					}
+				}));
+				const mailboxView = ViewModel.make({
+					query: Query.select(Filter.type(Message.Message, { properties: { labels: Filter.contains("investor") } })).from(Scope.feed(Obj.getURI(mailboxFeed))),
+					jsonSchema: JsonSchema.toJsonSchema(Message.Message)
+				});
+				const contactsView = ViewModel.make({
+					query: contactsQuery,
+					jsonSchema: JsonSchema.toJsonSchema(Person.Person)
+				});
+				const organizationsView = ViewModel.make({
+					query: organizationsQuery,
+					jsonSchema: JsonSchema.toJsonSchema(Organization.Organization)
+				});
+				const notesView = ViewModel.make({
+					query: notesQuery,
+					jsonSchema: JsonSchema.toJsonSchema(Markdown.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 = range(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 = range(n, () => {
+				const { canvasModel, computeModel } = createQueueSinkPreset(space, "subscription", (triggerSpec) => triggerSpec.query = { ast: Query.select(Filter.type(DXN.make("org.dxos.type.chess"))).ast }, "type");
+				return addToSpace("objectChange-queue", space, canvasModel, computeModel);
+			});
+			cb?.(objects);
+			return objects;
+		}],
+		["timerTick-queue", async (space, n, cb) => {
+			const objects = range(n, () => {
+				const { canvasModel, computeModel } = createQueueSinkPreset(space, "timer", (triggerSpec) => triggerSpec.cron = "*/5 * * * * *", "result");
+				return addToSpace("timerTick-queue", space, canvasModel, computeModel);
+			});
+			cb?.(objects);
+			return objects;
+		}],
+		["chat-gpt-text", async (space, n, cb) => {
+			const objects = range(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"
+					});
+				});
+				return addToSpace("chat-gpt-text", space, canvasModel, createComputeGraph(canvasModel));
+			});
+			cb?.(objects);
+			return objects;
+		}],
+		["forex-function-call", async (space, n, cb) => {
+			const objects = range(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"
+					});
+				});
+				return addToSpace("forex-function-call", space, canvasModel, createComputeGraph(canvasModel));
+			});
+			cb?.(objects);
+			return objects;
+		}],
+		["discord-messages", async (space, n, cb) => {
+			const objects = range(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: EID$1.make({
+							spaceId: space.id,
+							entityId: Key.EntityId.random()
+						}),
+						...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(createFeed(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.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 735,
+			S: void 0,
+			A: ["triggerSpec && triggerSpec.kind === triggerKind", "'No trigger spec.'"]
+		});
+		Obj.update(functionTrigger, (functionTrigger) => {
+			initSpec(functionTrigger.spec);
+		});
+	});
+	const computeModel = createComputeGraph(canvasModel);
+	const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
+	invariant(templateComputeNode, "Template compute node was not created.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 744,
+		S: void 0,
+		A: ["templateComputeNode", "'Template compute node was not created.'"]
+	});
+	templateComputeNode.value = [
+		"{",
+		"  \"@type\": \"{{type}}\",",
+		"  \"id\": \"@{{changeId}}\"",
+		"}"
+	].join("\n");
+	templateComputeNode.inputSchema = JsonSchema.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: EID$1.make({
+			spaceId: space.id,
+			entityId: Key.EntityId.random()
+		}),
+		...args?.idPosition ? rawPosition(args.idPosition) : position({
+			x: -18,
+			y: 5,
+			width: 8,
+			height: 6
+		})
+	}));
+	const queue = canvasModel.createNode(createFeed(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, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 786,
+		S: void 0,
+		A: ["functionTrigger", ""]
+	});
+	const inputNode = computeModel.nodes.find((node) => node.type === NODE_INPUT);
+	Obj.update(functionTrigger, (functionTrigger) => {
+		functionTrigger.runnable = Ref.make(computeModel.root);
+		functionTrigger.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
+	} };
+};
+//#endregion
+//#region src/components/SpaceGenerator/ObjectGenerator.tsx
+var generator$1 = random;
+var findViewByTypeUri = async (views, typeUri) => {
+	return views.find((view) => getTypeURIFromQuery(view.query.ast) === typeUri);
+};
+var createGenerator = (client, invokePromise, schema) => {
+	return async (space, n) => {
+		const typename = Type.getTypename(schema);
+		const view = await findViewByTypeUri(await space.db.query(Filter.type(View.View)).run(), Type.getURI(schema));
+		const staticSchema = client ? client.graph.registry.list().filter(Type.isType).find((s) => Type.getTypename(s) === typename) : void 0;
+		if (!view && !staticSchema) await invokePromise(SpaceOperation.AddType, {
+			db: space.db,
+			type: schema,
+			show: false
+		});
+		return createAsyncGenerator(generator$1, schema, { db: space.db }).createObjects(n);
+	};
+};
+var staticGenerators = /* @__PURE__ */ new Map([
+	[Type.getTypename(Markdown.Document), async (space, n, cb) => {
+		const objects = range(n).map(() => {
+			return space.db.add(Markdown.make({
+				name: random.commerce.productName(),
+				content: random.lorem.sentences(5)
+			}));
+		});
+		cb?.(objects);
+		return objects;
+	}],
+	[Type.getTypename(Drawing.Drawing), async (space, n, cb) => {
+		const objects = range(n).map(() => {
+			return space.db.add(Drawing.make({
+				name: random.commerce.productName(),
+				canvas: Drawing.makeCanvas({ schema: Tldraw.TLDRAW_SCHEMA })
+			}));
+		});
+		cb?.(objects);
+		return objects;
+	}],
+	[Type.getTypename(Sheet.Sheet), 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) cells[cell] = { value: `=SUM(${addressToA1Notation({
+					col,
+					row: 2
+				})}:${addressToA1Notation({
+					col,
+					row: rows - 1
+				})})` };
+				else if (row > 2 && row < rows - 1) cells[cell] = { value: Math.floor(Math.random() * 1e4) };
+			}
+			return space.db.add(Sheet.make({
+				name: random.commerce.productName(),
+				cells
+			}));
+		});
+		cb?.(objects);
+		return objects;
+	}],
+	[Type.getTypename(ComputeGraph), 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: EID.make({
+					spaceId: space.id,
+					entityId: Key.EntityId.random()
+				})
+			}).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;
+	}]
+]);
+//#endregion
+export { PresetName, SchemaTable, createGenerator, generator, staticGenerators };
+
+//# sourceMappingURL=components.mjs.map