@powerhousedao/workflow 6.2.3-dev.11

package/dist/browser/assets/projection-entry-Bzn-Fath.js

@@ -0,0 +1,404 @@
+import { _ as DocumentMetaCache, c as KyselyKeyframeStore, g as KyselyOperationIndex, h as KyselyWriteCache, l as DocumentModelRegistry, m as EventBus, n as REACTOR_SCHEMA, o as instrumentPgPool, s as KyselyOperationStore, v as CollectionMembershipCache } from "./drive-container-types-DrTN96J-.js";
+import { n as ReactorEventTypes } from "./types-DMKLa0Ok.js";
+import { i as KyselyDocumentView, n as ConsistencyTracker, s as ReadModelCoordinator, t as KyselyDocumentIndexer } from "./document-indexer-wbaTFAeJ.js";
+import { n as errorToInfo, t as createForwardingLogger } from "./forwarding-logger-BBkMSxuJ.js";
+import { n as defaultLoadFactory } from "./build-worker-executor-D4se2bJ0.js";
+import { ConsoleLogger } from "document-model";
+import { isMainThread, parentPort } from "node:worker_threads";
+//#region src/projection/projection-worker/build-projection-stack.ts
+async function loadModelManifest(entries, loadFactory, registry, logger) {
+	for (const entry of entries) {
+		let module;
+		try {
+			module = await loadFactory(entry.spec);
+		} catch (error) {
+			logger.error("projection worker failed to load document model: @entry @error", entry, error);
+			throw error;
+		}
+		const [result] = registry.registerModules(module);
+		if (result.status === "error") {
+			logger.error("projection worker failed to register document model: @entry @error", entry, result.error);
+			throw result.error;
+		}
+	}
+}
+function instantiateReadModel(kind, database, operationStore, operationIndex, writeCache) {
+	switch (kind) {
+		case "document-view": return new KyselyDocumentView(database, operationStore, operationIndex, writeCache, new ConsistencyTracker(), false);
+		case "document-indexer": return new KyselyDocumentIndexer(database, operationIndex, writeCache, new ConsistencyTracker());
+		default: {
+			const exhaustive = kind;
+			throw new Error(`unknown built-in read model kind: ${String(exhaustive)}`);
+		}
+	}
+}
+async function initReadModels(models, logger) {
+	for (const model of models) {
+		const maybeInit = model;
+		if (typeof maybeInit.init !== "function") continue;
+		try {
+			await maybeInit.init();
+		} catch (error) {
+			logger.error("projection worker read model init failed: @name @error", model.name, error);
+			throw error;
+		}
+	}
+}
+async function buildProjectionStack(options) {
+	const { init, database: baseDatabase, logger, events } = options;
+	const loadFactory = options.loadFactory ?? defaultLoadFactory;
+	const registry = new DocumentModelRegistry();
+	await loadModelManifest(init.models, loadFactory, registry, logger);
+	const database = baseDatabase.withSchema(REACTOR_SCHEMA);
+	const operationStore = new KyselyOperationStore(database);
+	const writeCache = new KyselyWriteCache(new KyselyKeyframeStore(database), operationStore, registry, {
+		maxDocuments: 100,
+		ringBufferSize: 10,
+		keyframeInterval: 10
+	});
+	await writeCache.startup();
+	const operationIndex = new KyselyOperationIndex(database);
+	await new DocumentMetaCache(operationStore, { maxDocuments: 1e3 }).startup();
+	new CollectionMembershipCache(operationIndex);
+	const preReady = init.preReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache));
+	const postReady = init.postReadyKinds.map((kind) => instantiateReadModel(kind, database, operationStore, operationIndex, writeCache));
+	await initReadModels([...preReady, ...postReady], logger);
+	const eventBus = new EventBus();
+	const subscriptions = [];
+	subscriptions.push(eventBus.subscribe(ReactorEventTypes.JOB_READ_READY, (_t, event) => {
+		events.onReadReady(event);
+	}));
+	subscriptions.push(eventBus.subscribe(ReactorEventTypes.READMODEL_INDEXED, (_t, event) => {
+		events.onReadModelIndexed(event);
+	}));
+	subscriptions.push(eventBus.subscribe(ReactorEventTypes.READMODEL_BATCH_COMPLETED, (_t, event) => {
+		events.onBatchCompleted(event);
+	}));
+	const coordinator = new ReadModelCoordinator(eventBus, preReady, postReady);
+	coordinator.start();
+	return {
+		registry,
+		coordinator,
+		eventBus,
+		async relayWriteReady(event) {
+			await eventBus.emit(ReactorEventTypes.JOB_WRITE_READY, event);
+		},
+		getChainDepth() {
+			return coordinator.getChainDepth();
+		},
+		async drain() {
+			await coordinator.drain();
+		},
+		shutdown() {
+			coordinator.stop();
+			for (const unsub of subscriptions) unsub();
+			return Promise.resolve();
+		}
+	};
+}
+//#endregion
+//#region src/projection/projection-worker/run-projection-worker.ts
+const POOL_SAMPLE_INTERVAL_MS = 1e3;
+async function defaultCreateDatabase(config, shardId) {
+	const { Kysely, PostgresDialect } = await import("kysely");
+	const Pool = (await import("pg")).default.Pool;
+	const pool = new Pool({
+		host: config.host,
+		port: config.port,
+		database: config.database,
+		user: config.user,
+		password: config.password,
+		ssl: config.ssl ? { rejectUnauthorized: false } : void 0,
+		application_name: config.applicationName ?? shardId,
+		max: config.poolSize,
+		connectionTimeoutMillis: config.connectionTimeoutMillis,
+		idleTimeoutMillis: config.idleTimeoutMillis
+	});
+	const poolInstrumentation = instrumentPgPool(pool, shardId);
+	const kysely = new Kysely({ dialect: new PostgresDialect({ pool }) });
+	return {
+		kysely,
+		poolInstrumentation,
+		async shutdown() {
+			try {
+				await kysely.destroy();
+			} catch {}
+			try {
+				await pool.end();
+			} catch {}
+		}
+	};
+}
+/**
+* Drives the projection worker's message loop. Owns lifecycle of the
+* database handle and the projection stack. The default factory builds a
+* real Postgres pool; tests inject overrides for an in-process PGlite path.
+*/
+function runProjectionWorker(parentPort, overrides = {}) {
+	let shardId = "";
+	let initCompleted = false;
+	let stack = null;
+	let database = null;
+	let depthTimer = null;
+	let lastReportedDepth = -1;
+	let poolSampleTimer = null;
+	let pendingPoolSamples = [];
+	let detachPoolListener = null;
+	function post(msg) {
+		parentPort.postMessage(msg);
+	}
+	function startPoolReporter(instrumentation) {
+		detachPoolListener = instrumentation.onAcquire((durationMs) => {
+			pendingPoolSamples.push(durationMs);
+		});
+		poolSampleTimer = setInterval(() => {
+			if (pendingPoolSamples.length === 0) return;
+			const durations = pendingPoolSamples;
+			pendingPoolSamples = [];
+			const stats = instrumentation.getStats();
+			post({
+				type: "pool-acquire-samples",
+				shardId,
+				poolName: instrumentation.name,
+				timestamp: Date.now(),
+				durations,
+				size: stats.size,
+				idle: stats.idle,
+				waiting: stats.waiting
+			});
+		}, POOL_SAMPLE_INTERVAL_MS);
+		poolSampleTimer.unref();
+	}
+	function stopPoolReporter() {
+		if (detachPoolListener) {
+			detachPoolListener();
+			detachPoolListener = null;
+		}
+		if (poolSampleTimer) {
+			clearInterval(poolSampleTimer);
+			poolSampleTimer = null;
+		}
+		pendingPoolSamples = [];
+	}
+	const logger = createForwardingLogger((msg) => post({
+		...msg,
+		shardId
+	}));
+	process.on("uncaughtException", (err) => {
+		try {
+			post({
+				type: "log",
+				shardId,
+				level: "error",
+				message: "projection worker uncaughtException",
+				args: [errorToInfo(err)],
+				timestamp: Date.now()
+			});
+		} catch {}
+		throw err;
+	});
+	process.on("unhandledRejection", (reason) => {
+		try {
+			post({
+				type: "log",
+				shardId,
+				level: "error",
+				message: "projection worker unhandledRejection",
+				args: [errorToInfo(reason)],
+				timestamp: Date.now()
+			});
+		} catch {}
+	});
+	function startDepthReporter(intervalMs) {
+		if (intervalMs <= 0) return;
+		depthTimer = setInterval(() => {
+			if (!stack) return;
+			const depth = stack.getChainDepth();
+			if (depth === lastReportedDepth) return;
+			lastReportedDepth = depth;
+			post({
+				type: "chain-depth",
+				shardId,
+				depth,
+				timestamp: Date.now()
+			});
+		}, intervalMs);
+		depthTimer.unref();
+	}
+	function stopDepthReporter() {
+		if (depthTimer) {
+			clearInterval(depthTimer);
+			depthTimer = null;
+		}
+	}
+	async function handleInit(msg) {
+		shardId = msg.shardId;
+		database = await (overrides.createDatabase ?? defaultCreateDatabase)(msg.db, msg.shardId);
+		if (overrides.beforeBuildStack) await overrides.beforeBuildStack(database.kysely);
+		stack = await buildProjectionStack({
+			init: msg,
+			database: database.kysely,
+			logger: new ConsoleLogger([`projection-shard:${msg.shardId}`]),
+			loadFactory: overrides.loadFactory,
+			events: {
+				onReadReady: (event) => {
+					post({
+						type: "read-ready",
+						shardId,
+						jobId: event.jobId,
+						operations: event.operations
+					});
+				},
+				onReadModelIndexed: (event) => {
+					post({
+						type: "readmodel-indexed",
+						shardId,
+						jobId: event.jobId,
+						readModelName: event.readModelName,
+						stage: event.stage,
+						durationMs: event.durationMs,
+						operationCount: event.operationCount,
+						success: event.success
+					});
+				},
+				onBatchCompleted: (event) => {
+					post({
+						type: "readmodel-batch-completed",
+						shardId,
+						jobId: event.jobId,
+						batchSize: event.batchSize,
+						chainWaitDurationMs: event.chainWaitDurationMs,
+						preReadyDurationMs: event.preReadyDurationMs,
+						emitDurationMs: event.emitDurationMs,
+						postReadyDurationMs: event.postReadyDurationMs
+					});
+				}
+			}
+		});
+		initCompleted = true;
+		startDepthReporter(msg.chainDepthReportIntervalMs);
+		if (database.poolInstrumentation) startPoolReporter(database.poolInstrumentation);
+		logger.info("projection worker initialized: @shardId", msg.shardId);
+		post({
+			type: "ready",
+			correlationId: msg.correlationId,
+			shardId
+		});
+	}
+	async function handleWriteReady(msg) {
+		if (!stack) {
+			logger.warn("write-ready received before init on shard @shardId", shardId);
+			return;
+		}
+		const event = {
+			jobId: msg.jobId,
+			operations: msg.operations,
+			jobMeta: msg.jobMeta,
+			collectionMemberships: msg.collectionMemberships
+		};
+		await stack.relayWriteReady(event);
+	}
+	async function handleDrain(correlationId) {
+		if (stack) await stack.drain();
+		post({
+			type: "drained",
+			correlationId,
+			shardId
+		});
+	}
+	async function shutdownStack() {
+		stopDepthReporter();
+		stopPoolReporter();
+		if (stack) {
+			try {
+				await stack.drain();
+			} catch (error) {
+				logger.warn("projection worker drain failed during shutdown: @error", error);
+			}
+			try {
+				await stack.shutdown();
+			} catch (error) {
+				logger.warn("projection worker stack shutdown failed: @error", error);
+			}
+			stack = null;
+		}
+		if (database) {
+			await database.shutdown();
+			database = null;
+		}
+	}
+	function handleParentMessage(msg) {
+		switch (msg.type) {
+			case "init":
+				handleInit(msg).catch((err) => {
+					post({
+						type: "init-failed",
+						correlationId: msg.correlationId,
+						shardId,
+						error: errorToInfo(err)
+					});
+				});
+				break;
+			case "write-ready":
+				if (!initCompleted) {
+					logger.warn("write-ready received before init on shard @shardId", shardId);
+					break;
+				}
+				handleWriteReady(msg).catch((err) => {
+					post({
+						type: "log",
+						shardId,
+						level: "error",
+						message: "projection worker write-ready failed",
+						args: [errorToInfo(err)],
+						timestamp: Date.now()
+					});
+				});
+				break;
+			case "drain":
+				handleDrain(msg.correlationId).catch((err) => {
+					post({
+						type: "log",
+						shardId,
+						level: "error",
+						message: "projection worker drain failed",
+						args: [errorToInfo(err)],
+						timestamp: Date.now()
+					});
+				});
+				break;
+			case "shutdown":
+				logger.info("projection worker shutting down: @shardId", shardId);
+				shutdownStack().finally(() => {
+					post({
+						type: "log",
+						shardId,
+						level: "info",
+						message: "projection worker shutdown",
+						args: [],
+						timestamp: Date.now()
+					});
+					process.exit(0);
+				});
+				break;
+			default: break;
+		}
+	}
+	parentPort.on("message", handleParentMessage);
+	parentPort.__reactorProjectionWorkerHarness = {
+		handleParentMessage,
+		get initCompleted() {
+			return initCompleted;
+		},
+		get shardId() {
+			return shardId;
+		}
+	};
+}
+//#endregion
+//#region src/projection/projection-worker/projection-entry.ts
+if (isMainThread || parentPort === null) throw new Error("projection-worker entry.ts must be run as a worker thread");
+runProjectionWorker(parentPort);
+//#endregion
+
+//# sourceMappingURL=projection-entry.js.map

package/dist/browser/chunk-BoAXSpZd.js

@@ -0,0 +1,33 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __exportAll as n, __toESM as r, __commonJSMin as t };

package/dist/browser/connection-DEe5aDuU.js

@@ -0,0 +1,90 @@
+import { a as utils, d as isConnectionDocument, l as assertIsConnectionDocument, t as Connection } from "./module-12vI18HY.js";
+import { PHDocumentController, createBaseState, defaultBaseState } from "document-model";
+import { useDocumentById, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useSelectedDocument } from "@powerhousedao/reactor-browser";
+//#region document-models/connection/v1/gen/controller.ts
+/**
+* WARNING: DO NOT EDIT
+* This file is auto-generated and updated by codegen
+*/
+const ConnectionController = PHDocumentController.forDocumentModel(Connection);
+//#endregion
+//#region document-models/connection/v1/gen/ph-factories.ts
+function defaultGlobalState() {
+	return {
+		name: "",
+		connectorId: "",
+		authType: "NONE",
+		config: {},
+		secretRefs: [],
+		status: "UNCONFIGURED",
+		lastCheckedAt: null,
+		lastError: null,
+		accountLabel: null
+	};
+}
+function defaultLocalState() {
+	return {};
+}
+function defaultPHState() {
+	return {
+		...defaultBaseState(),
+		global: defaultGlobalState(),
+		local: defaultLocalState()
+	};
+}
+function createGlobalState(state) {
+	return {
+		...defaultGlobalState(),
+		...state || {}
+	};
+}
+function createLocalState(state) {
+	return {
+		...defaultLocalState(),
+		...state || {}
+	};
+}
+function createState$1(baseState, globalState, localState) {
+	return {
+		...createBaseState(baseState?.auth, baseState?.document),
+		global: createGlobalState(globalState),
+		local: createLocalState(localState)
+	};
+}
+/**
+* Creates a ConnectionDocument with custom global and local state
+* This properly handles the PHBaseState requirements while allowing
+* document-specific state to be set.
+*/
+function createConnectionDocument(state) {
+	return utils.createDocument(createState$1(createBaseState(state?.auth, {
+		version: 1,
+		...state?.document
+	}), state?.global, state?.local));
+}
+//#endregion
+//#region document-models/connection/v1/hooks.ts
+/** Hook to get a Connection document by its id */
+function useConnectionDocumentById(documentId) {
+	const [document, dispatch] = useDocumentById(documentId);
+	if (!isConnectionDocument(document)) return [void 0, void 0];
+	return [document, dispatch];
+}
+/** Hook to get the selected Connection document */
+function useSelectedConnectionDocument() {
+	const [document, dispatch] = useSelectedDocument();
+	assertIsConnectionDocument(document);
+	return [document, dispatch];
+}
+/** Hook to get all Connection documents in the selected drive */
+function useConnectionDocumentsInSelectedDrive() {
+	return useDocumentsInSelectedDrive()?.filter(isConnectionDocument);
+}
+/** Hook to get all Connection documents in the selected folder */
+function useConnectionDocumentsInSelectedFolder() {
+	return useDocumentsInSelectedFolder()?.filter(isConnectionDocument);
+}
+//#endregion
+export { createConnectionDocument as a, defaultLocalState as c, useSelectedConnectionDocument as i, defaultPHState as l, useConnectionDocumentsInSelectedDrive as n, createState$1 as o, useConnectionDocumentsInSelectedFolder as r, defaultGlobalState as s, useConnectionDocumentById as t, ConnectionController as u };
+
+//# sourceMappingURL=connection-DEe5aDuU.js.map

package/dist/browser/connection-DEe5aDuU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-DEe5aDuU.js","names":["createState"],"sources":["../../document-models/connection/v1/gen/controller.ts","../../document-models/connection/v1/gen/ph-factories.ts","../../document-models/connection/v1/hooks.ts"],"sourcesContent":["/**\n * WARNING: DO NOT EDIT\n * This file is auto-generated and updated by codegen\n */\nimport { PHDocumentController } from \"document-model\";\nimport { Connection } from \"../module.js\";\nimport type { ConnectionAction, ConnectionPHState } from \"./types.js\";\n\nexport const ConnectionController = PHDocumentController.forDocumentModel<\n  ConnectionPHState,\n  ConnectionAction\n>(Connection);\n","/**\n * WARNING: DO NOT EDIT\n * This file is auto-generated and updated by codegen\n * Factory methods for creating ConnectionDocument instances\n */\nimport type { PHAuthState, PHBaseState, PHDocumentState } from \"document-model\";\nimport { createBaseState, defaultBaseState } from \"document-model\";\nimport type {\n  ConnectionDocument,\n  ConnectionGlobalState,\n  ConnectionLocalState,\n  ConnectionPHState,\n} from \"./types.js\";\nimport { utils } from \"./utils.js\";\n\nexport function defaultGlobalState(): ConnectionGlobalState {\n  return {\n    name: \"\",\n    connectorId: \"\",\n    authType: \"NONE\",\n    config: {},\n    secretRefs: [],\n    status: \"UNCONFIGURED\",\n    lastCheckedAt: null,\n    lastError: null,\n    accountLabel: null,\n  };\n}\n\nexport function defaultLocalState(): ConnectionLocalState {\n  return {};\n}\n\nexport function defaultPHState(): ConnectionPHState {\n  return {\n    ...defaultBaseState(),\n    global: defaultGlobalState(),\n    local: defaultLocalState(),\n  };\n}\n\nexport function createGlobalState(\n  state?: Partial<ConnectionGlobalState>,\n): ConnectionGlobalState {\n  return {\n    ...defaultGlobalState(),\n    ...(state || {}),\n  };\n}\n\nexport function createLocalState(\n  state?: Partial<ConnectionLocalState>,\n): ConnectionLocalState {\n  return {\n    ...defaultLocalState(),\n    ...(state || {}),\n  } as ConnectionLocalState;\n}\n\nexport function createState(\n  baseState?: Partial<PHBaseState>,\n  globalState?: Partial<ConnectionGlobalState>,\n  localState?: Partial<ConnectionLocalState>,\n): ConnectionPHState {\n  return {\n    ...createBaseState(baseState?.auth, baseState?.document),\n    global: createGlobalState(globalState),\n    local: createLocalState(localState),\n  };\n}\n\n/**\n * Creates a ConnectionDocument with custom global and local state\n * This properly handles the PHBaseState requirements while allowing\n * document-specific state to be set.\n */\nexport function createConnectionDocument(\n  state?: Partial<{\n    auth?: Partial<PHAuthState>;\n    document?: Partial<PHDocumentState>;\n    global?: Partial<ConnectionGlobalState>;\n    local?: Partial<ConnectionLocalState>;\n  }>,\n): ConnectionDocument {\n  const document = utils.createDocument(\n    createState(\n      createBaseState(state?.auth, { version: 1, ...state?.document }),\n      state?.global,\n      state?.local,\n    ),\n  );\n\n  return document;\n}\n","/**\n * WARNING: DO NOT EDIT\n * This file is auto-generated and updated by codegen\n */\nimport type { DocumentDispatch } from \"@powerhousedao/reactor-browser\";\nimport {\n  useDocumentById,\n  useDocumentsInSelectedDrive,\n  useDocumentsInSelectedFolder,\n  useSelectedDocument,\n} from \"@powerhousedao/reactor-browser\";\nimport type {\n  ConnectionAction,\n  ConnectionDocument,\n} from \"document-models/connection/v1\";\nimport {\n  assertIsConnectionDocument,\n  isConnectionDocument,\n} from \"./gen/document-schema.js\";\n\n/** Hook to get a Connection document by its id */\nexport function useConnectionDocumentById(\n  documentId: string | null | undefined,\n):\n  | [ConnectionDocument, DocumentDispatch<ConnectionAction>]\n  | [undefined, undefined] {\n  const [document, dispatch] = useDocumentById(documentId);\n  if (!isConnectionDocument(document)) return [undefined, undefined];\n  return [document, dispatch];\n}\n\n/** Hook to get the selected Connection document */\nexport function useSelectedConnectionDocument(): [\n  ConnectionDocument,\n  DocumentDispatch<ConnectionAction>,\n] {\n  const [document, dispatch] = useSelectedDocument();\n\n  assertIsConnectionDocument(document);\n  return [document, dispatch] as const;\n}\n\n/** Hook to get all Connection documents in the selected drive */\nexport function useConnectionDocumentsInSelectedDrive() {\n  const documentsInSelectedDrive = useDocumentsInSelectedDrive();\n  return documentsInSelectedDrive?.filter(isConnectionDocument);\n}\n\n/** Hook to get all Connection documents in the selected folder */\nexport function useConnectionDocumentsInSelectedFolder() {\n  const documentsInSelectedFolder = useDocumentsInSelectedFolder();\n  return documentsInSelectedFolder?.filter(isConnectionDocument);\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,uBAAuB,qBAAqB,iBAGvD,WAAW;;;ACIb,SAAgB,qBAA4C;AAC1D,QAAO;EACL,MAAM;EACN,aAAa;EACb,UAAU;EACV,QAAQ,EAAE;EACV,YAAY,EAAE;EACd,QAAQ;EACR,eAAe;EACf,WAAW;EACX,cAAc;EACf;;AAGH,SAAgB,oBAA0C;AACxD,QAAO,EAAE;;AAGX,SAAgB,iBAAoC;AAClD,QAAO;EACL,GAAG,kBAAkB;EACrB,QAAQ,oBAAoB;EAC5B,OAAO,mBAAmB;EAC3B;;AAGH,SAAgB,kBACd,OACuB;AACvB,QAAO;EACL,GAAG,oBAAoB;EACvB,GAAI,SAAS,EAAE;EAChB;;AAGH,SAAgB,iBACd,OACsB;AACtB,QAAO;EACL,GAAG,mBAAmB;EACtB,GAAI,SAAS,EAAE;EAChB;;AAGH,SAAgBA,cACd,WACA,aACA,YACmB;AACnB,QAAO;EACL,GAAG,gBAAgB,WAAW,MAAM,WAAW,SAAS;EACxD,QAAQ,kBAAkB,YAAY;EACtC,OAAO,iBAAiB,WAAW;EACpC;;;;;;;AAQH,SAAgB,yBACd,OAMoB;AASpB,QARiB,MAAM,eACrBA,cACE,gBAAgB,OAAO,MAAM;EAAE,SAAS;EAAG,GAAG,OAAO;EAAU,CAAC,EAChE,OAAO,QACP,OAAO,MACR,CACF;;;;;ACrEH,SAAgB,0BACd,YAGyB;CACzB,MAAM,CAAC,UAAU,YAAY,gBAAgB,WAAW;AACxD,KAAI,CAAC,qBAAqB,SAAS,CAAE,QAAO,CAAC,KAAA,GAAW,KAAA,EAAU;AAClE,QAAO,CAAC,UAAU,SAAS;;;AAI7B,SAAgB,gCAGd;CACA,MAAM,CAAC,UAAU,YAAY,qBAAqB;AAElD,4BAA2B,SAAS;AACpC,QAAO,CAAC,UAAU,SAAS;;;AAI7B,SAAgB,wCAAwC;AAEtD,QADiC,6BAA6B,EAC7B,OAAO,qBAAqB;;;AAI/D,SAAgB,yCAAyC;AAEvD,QADkC,8BAA8B,EAC9B,OAAO,qBAAqB"}