@powerhousedao/reactor-api 6.0.0-dev.2 → 6.0.0-dev.200

package/dist/src/packages/https-hooks.d.mts

@@ -0,0 +1,39 @@
+//#region src/packages/https-hooks.d.mts
+/**
+ * Node.js module loader hooks that enable importing from HTTP/HTTPS URLs.
+ * See: https://nodejs.org/docs/latest-v24.x/api/module.html#import-from-https
+ */
+type ResolveContext = {
+  parentURL?: string;
+  conditions?: string[];
+};
+type ResolveResult = {
+  url: string;
+  shortCircuit?: boolean;
+  format?: string;
+};
+type NextResolve = (specifier: string, context: ResolveContext) => Promise<ResolveResult>;
+type LoadContext = {
+  format?: string;
+};
+type LoadResult = {
+  format: string;
+  shortCircuit?: boolean;
+  source: string;
+};
+type NextLoad = (url: string, context: LoadContext) => Promise<LoadResult>;
+/**
+ * Resolve hook: resolves relative specifiers against HTTP/HTTPS parent URLs.
+ */
+declare function resolve(specifier: string, context: ResolveContext, nextResolve: NextResolve): Promise<ResolveResult>;
+/**
+ * Load hook: fetches module source from HTTP/HTTPS URLs.
+ */
+declare function load(url: string, context: LoadContext, nextLoad: NextLoad): Promise<LoadResult>;
+/**
+ * Path to this hooks file for use with node:module register()
+ */
+declare const httpsHooksPath: string;
+//#endregion
+export { httpsHooksPath, load, resolve };
+//# sourceMappingURL=https-hooks.d.mts.map

package/dist/src/packages/https-hooks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"https-hooks.d.mts","names":[],"sources":["../../../src/packages/https-hooks.mts"],"mappings":";;;;;KAQK,cAAA;EAAmB,SAAA;EAAoB,UAAA;AAAA;AAAA,KACvC,aAAA;EACH,GAAA;EACA,YAAA;EACA,MAAA;AAAA;AAAA,KAEG,WAAA,IACH,SAAA,UACA,OAAA,EAAS,cAAA,KACN,OAAA,CAAQ,aAAA;AAAA,KAER,WAAA;EAAgB,MAAA;AAAA;AAAA,KAChB,UAAA;EAAe,MAAA;EAAgB,YAAA;EAAwB,MAAA;AAAA;AAAA,KACvD,QAAA,IAAY,GAAA,UAAa,OAAA,EAAS,WAAA,KAAgB,OAAA,CAAQ,UAAA;;;;iBAKzC,OAAA,CACpB,SAAA,UACA,OAAA,EAAS,cAAA,EACT,WAAA,EAAa,WAAA,GACZ,OAAA,CAAQ,aAAA;;;;iBAsCW,IAAA,CACpB,GAAA,UACA,OAAA,EAAS,WAAA,EACT,QAAA,EAAU,QAAA,GACT,OAAA,CAAQ,UAAA;;;;cA0EE,cAAA"}

package/dist/src/packages/https-hooks.mjs

@@ -0,0 +1,79 @@
+import { get } from "node:http";
+import { get as get$1 } from "node:https";
+//#region src/packages/https-hooks.mts
+/**
+* Resolve hook: resolves relative specifiers against HTTP/HTTPS parent URLs.
+*/
+async function resolve(specifier, context, nextResolve) {
+	const { parentURL } = context;
+	if (specifier.startsWith("https://") || specifier.startsWith("http://")) return {
+		url: specifier,
+		shortCircuit: true,
+		format: "module"
+	};
+	if (parentURL && (parentURL.startsWith("https://") || parentURL.startsWith("http://")) && (specifier.startsWith("./") || specifier.startsWith("../"))) return {
+		url: new URL(specifier, parentURL).href,
+		shortCircuit: true,
+		format: "module"
+	};
+	if (parentURL && (parentURL.startsWith("https://") || parentURL.startsWith("http://"))) {
+		const { pathToFileURL } = await import("node:url");
+		const localParent = pathToFileURL(process.cwd() + "/").href;
+		return nextResolve(specifier, {
+			...context,
+			parentURL: localParent
+		});
+	}
+	return nextResolve(specifier, context);
+}
+/**
+* Load hook: fetches module source from HTTP/HTTPS URLs.
+*/
+async function load(url, context, nextLoad) {
+	if (url.startsWith("https://")) return {
+		format: "module",
+		shortCircuit: true,
+		source: patchCreateRequire(await fetchModule(url, get$1))
+	};
+	if (url.startsWith("http://")) return {
+		format: "module",
+		shortCircuit: true,
+		source: patchCreateRequire(await fetchModule(url, get))
+	};
+	return nextLoad(url, context);
+}
+/**
+* Rewrite `createRequire(import.meta.url)` in HTTP-loaded modules so that
+* `createRequire` receives a local file URL instead of an HTTP URL it cannot handle.
+*/
+function patchCreateRequire(source) {
+	return source.replace(/createRequire\(import\.meta\.url\)/g, `createRequire(new URL("file://" + process.cwd() + "/"))`);
+}
+function fetchModule(url, getter) {
+	return new Promise((resolve, reject) => {
+		getter(url, (res) => {
+			if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+				const redirectUrl = res.headers.location;
+				fetchModule(redirectUrl, redirectUrl.startsWith("https://") ? get$1 : get).then(resolve).catch(reject);
+				return;
+			}
+			if (res.statusCode && res.statusCode >= 400) {
+				reject(/* @__PURE__ */ new Error(`Failed to fetch ${url}: ${res.statusCode}`));
+				return;
+			}
+			let data = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => data += chunk);
+			res.on("end", () => resolve(data));
+			res.on("error", reject);
+		}).on("error", reject);
+	});
+}
+/**
+* Path to this hooks file for use with node:module register()
+*/
+const httpsHooksPath = import.meta.url;
+//#endregion
+export { httpsHooksPath, load, resolve };
+
+//# sourceMappingURL=https-hooks.mjs.map

package/dist/src/packages/https-hooks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"https-hooks.mjs","names":["get","httpGet"],"sources":["../../../src/packages/https-hooks.mts"],"sourcesContent":["import { get as httpGet } from \"node:http\";\nimport { get } from \"node:https\";\n\n/**\n * Node.js module loader hooks that enable importing from HTTP/HTTPS URLs.\n * See: https://nodejs.org/docs/latest-v24.x/api/module.html#import-from-https\n */\n\ntype ResolveContext = { parentURL?: string; conditions?: string[] };\ntype ResolveResult = {\n  url: string;\n  shortCircuit?: boolean;\n  format?: string;\n};\ntype NextResolve = (\n  specifier: string,\n  context: ResolveContext,\n) => Promise<ResolveResult>;\n\ntype LoadContext = { format?: string };\ntype LoadResult = { format: string; shortCircuit?: boolean; source: string };\ntype NextLoad = (url: string, context: LoadContext) => Promise<LoadResult>;\n\n/**\n * Resolve hook: resolves relative specifiers against HTTP/HTTPS parent URLs.\n */\nexport async function resolve(\n  specifier: string,\n  context: ResolveContext,\n  nextResolve: NextResolve,\n): Promise<ResolveResult> {\n  const { parentURL } = context;\n\n  // If the specifier is already an HTTP(S) URL, resolve it directly\n  if (specifier.startsWith(\"https://\") || specifier.startsWith(\"http://\")) {\n    return { url: specifier, shortCircuit: true, format: \"module\" };\n  }\n\n  // If the parent is an HTTP(S) URL and specifier is relative, resolve against it.\n  // Only handle relative specifiers (./ or ../), not bare package specifiers.\n  if (\n    parentURL &&\n    (parentURL.startsWith(\"https://\") || parentURL.startsWith(\"http://\")) &&\n    (specifier.startsWith(\"./\") || specifier.startsWith(\"../\"))\n  ) {\n    const resolved = new URL(specifier, parentURL).href;\n    return { url: resolved, shortCircuit: true, format: \"module\" };\n  }\n\n  // For bare specifiers (e.g. \"document-model\") imported from HTTP modules,\n  // Node's default resolver fails because it can't find node_modules from an HTTP parent.\n  // Fall back to resolving from the process's working directory instead.\n  if (\n    parentURL &&\n    (parentURL.startsWith(\"https://\") || parentURL.startsWith(\"http://\"))\n  ) {\n    const { pathToFileURL } = await import(\"node:url\");\n    const localParent = pathToFileURL(process.cwd() + \"/\").href;\n    return nextResolve(specifier, { ...context, parentURL: localParent });\n  }\n\n  // Let Node.js handle all other specifiers\n  return nextResolve(specifier, context);\n}\n\n/**\n * Load hook: fetches module source from HTTP/HTTPS URLs.\n */\nexport async function load(\n  url: string,\n  context: LoadContext,\n  nextLoad: NextLoad,\n): Promise<LoadResult> {\n  // Handle HTTPS URLs\n  if (url.startsWith(\"https://\")) {\n    const source = await fetchModule(url, get);\n    return {\n      format: \"module\",\n      shortCircuit: true,\n      source: patchCreateRequire(source),\n    };\n  }\n\n  // Handle HTTP URLs (for local development)\n  if (url.startsWith(\"http://\")) {\n    const source = await fetchModule(url, httpGet);\n    return {\n      format: \"module\",\n      shortCircuit: true,\n      source: patchCreateRequire(source),\n    };\n  }\n\n  // Let Node.js handle all other URLs\n  return nextLoad(url, context);\n}\n\n/**\n * Rewrite `createRequire(import.meta.url)` in HTTP-loaded modules so that\n * `createRequire` receives a local file URL instead of an HTTP URL it cannot handle.\n */\nfunction patchCreateRequire(source: string): string {\n  return source.replace(\n    /createRequire\\(import\\.meta\\.url\\)/g,\n    `createRequire(new URL(\"file://\" + process.cwd() + \"/\"))`,\n  );\n}\n\nfunction fetchModule(\n  url: string,\n  getter: typeof get | typeof httpGet,\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    getter(url, (res) => {\n      // Handle redirects\n      if (\n        res.statusCode &&\n        res.statusCode >= 300 &&\n        res.statusCode < 400 &&\n        res.headers.location\n      ) {\n        const redirectUrl = res.headers.location;\n        const redirectGetter = redirectUrl.startsWith(\"https://\")\n          ? get\n          : httpGet;\n        fetchModule(redirectUrl, redirectGetter).then(resolve).catch(reject);\n        return;\n      }\n\n      if (res.statusCode && res.statusCode >= 400) {\n        reject(new Error(`Failed to fetch ${url}: ${res.statusCode}`));\n        return;\n      }\n\n      let data = \"\";\n      res.setEncoding(\"utf8\");\n      res.on(\"data\", (chunk) => (data += chunk));\n      res.on(\"end\", () => resolve(data));\n      res.on(\"error\", reject);\n    }).on(\"error\", reject);\n  });\n}\n\n/**\n * Path to this hooks file for use with node:module register()\n */\nexport const httpsHooksPath: string = import.meta.url;\n"],"mappings":";;;;;;AA0BA,eAAsB,QACpB,WACA,SACA,aACwB;CACxB,MAAM,EAAE,cAAc;AAGtB,KAAI,UAAU,WAAW,WAAW,IAAI,UAAU,WAAW,UAAU,CACrE,QAAO;EAAE,KAAK;EAAW,cAAc;EAAM,QAAQ;EAAU;AAKjE,KACE,cACC,UAAU,WAAW,WAAW,IAAI,UAAU,WAAW,UAAU,MACnE,UAAU,WAAW,KAAK,IAAI,UAAU,WAAW,MAAM,EAG1D,QAAO;EAAE,KADQ,IAAI,IAAI,WAAW,UAAU,CAAC;EACvB,cAAc;EAAM,QAAQ;EAAU;AAMhE,KACE,cACC,UAAU,WAAW,WAAW,IAAI,UAAU,WAAW,UAAU,GACpE;EACA,MAAM,EAAE,kBAAkB,MAAM,OAAO;EACvC,MAAM,cAAc,cAAc,QAAQ,KAAK,GAAG,IAAI,CAAC;AACvD,SAAO,YAAY,WAAW;GAAE,GAAG;GAAS,WAAW;GAAa,CAAC;;AAIvE,QAAO,YAAY,WAAW,QAAQ;;;;;AAMxC,eAAsB,KACpB,KACA,SACA,UACqB;AAErB,KAAI,IAAI,WAAW,WAAW,CAE5B,QAAO;EACL,QAAQ;EACR,cAAc;EACd,QAAQ,mBAJK,MAAM,YAAY,KAAKA,MAAI,CAIN;EACnC;AAIH,KAAI,IAAI,WAAW,UAAU,CAE3B,QAAO;EACL,QAAQ;EACR,cAAc;EACd,QAAQ,mBAJK,MAAM,YAAY,KAAKC,IAAQ,CAIV;EACnC;AAIH,QAAO,SAAS,KAAK,QAAQ;;;;;;AAO/B,SAAS,mBAAmB,QAAwB;AAClD,QAAO,OAAO,QACZ,uCACA,0DACD;;AAGH,SAAS,YACP,KACA,QACiB;AACjB,QAAO,IAAI,SAAS,SAAS,WAAW;AACtC,SAAO,MAAM,QAAQ;AAEnB,OACE,IAAI,cACJ,IAAI,cAAc,OAClB,IAAI,aAAa,OACjB,IAAI,QAAQ,UACZ;IACA,MAAM,cAAc,IAAI,QAAQ;AAIhC,gBAAY,aAHW,YAAY,WAAW,WAAW,GACrDD,QACAC,IACoC,CAAC,KAAK,QAAQ,CAAC,MAAM,OAAO;AACpE;;AAGF,OAAI,IAAI,cAAc,IAAI,cAAc,KAAK;AAC3C,2BAAO,IAAI,MAAM,mBAAmB,IAAI,IAAI,IAAI,aAAa,CAAC;AAC9D;;GAGF,IAAI,OAAO;AACX,OAAI,YAAY,OAAO;AACvB,OAAI,GAAG,SAAS,UAAW,QAAQ,MAAO;AAC1C,OAAI,GAAG,aAAa,QAAQ,KAAK,CAAC;AAClC,OAAI,GAAG,SAAS,OAAO;IACvB,CAAC,GAAG,SAAS,OAAO;GACtB;;;;;AAMJ,MAAa,iBAAyB,OAAO,KAAK"}

package/dist/src/packages/vite-loader.d.mts

@@ -0,0 +1,29 @@
+import { a as ISubscribablePackageLoader, o as ISubscriptionOptions } from "../../types-Do4QTfT3.mjs";
+import { ILogger } from "document-model";
+import { DocumentModelModule } from "@powerhousedao/shared/document-model";
+import { Logger, ViteDevServer } from "vite";
+import { ProcessorFactoryBuilder, SubgraphClass } from "@powerhousedao/reactor-api";
+
+//#region src/packages/vite-loader.d.mts
+declare function createViteLogger(logger: ILogger, prefix?: string): Logger;
+declare class VitePackageLoader implements ISubscribablePackageLoader {
+  #private;
+  private readonly logger;
+  private readonly vite;
+  readonly name = "VitePackageLoader";
+  static build(vite: ViteDevServer): VitePackageLoader;
+  constructor(vite: ViteDevServer);
+  private getDocumentModelsPath;
+  private getSubgraphsPath;
+  private getProcessorsPath;
+  loadDocumentModels(identifier: string, immediate?: boolean): Promise<DocumentModelModule[]>;
+  loadSubgraphs(identifier: string): Promise<SubgraphClass[]>;
+  loadProcessors(identifier: string): Promise<ProcessorFactoryBuilder | null>;
+  onDocumentModelsChange(identifier: string, handler: (documentModels: DocumentModelModule[]) => void, options?: ISubscriptionOptions): () => void;
+  onSubgraphsChange(identifier: string, handler: (subgraphs: SubgraphClass[]) => void, options?: ISubscriptionOptions): () => void;
+  onProcessorsChange(identifier: string, handler: (processors: ProcessorFactoryBuilder | null) => void, options?: ISubscriptionOptions): () => void;
+}
+declare function startViteServer(root: string, logger?: Logger): Promise<ViteDevServer>;
+//#endregion
+export { VitePackageLoader, createViteLogger, startViteServer };
+//# sourceMappingURL=vite-loader.d.mts.map

package/dist/src/packages/vite-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-loader.d.mts","names":[],"sources":["../../../src/packages/vite-loader.mts"],"mappings":";;;;;;;iBAkBgB,gBAAA,CAAiB,MAAA,EAAQ,OAAA,EAAS,MAAA,YAAW,MAAA;AAAA,cAUhD,iBAAA,YAA6B,0BAAA;EAAA;mBACvB,MAAA;EAAA,iBAEA,IAAA;EAAA,SAER,IAAA;EAAA,OAEF,KAAA,CAAM,IAAA,EAAM,aAAA,GAAa,iBAAA;cAIpB,IAAA,EAAM,aAAA;EAAA,QAIV,qBAAA;EAAA,QAIA,gBAAA;EAAA,QAIA,iBAAA;EAID,kBAAA,CAAmB,UAAA,UAAoB,SAAA,aAAiB,OAAA,CAAA,mBAAA;EA2CzD,aAAA,CAAc,UAAA,WAAqB,OAAA,CAAQ,aAAA;EA4B3C,cAAA,CACJ,UAAA,WACC,OAAA,CAAQ,uBAAA;EA+BX,sBAAA,CACE,UAAA,UACA,OAAA,GAAU,cAAA,EAAgB,mBAAA,aAC1B,OAAA,GAAU,oBAAA;EAiBZ,iBAAA,CACE,UAAA,UACA,OAAA,GAAU,SAAA,EAAW,aAAA,aACrB,OAAA,GAAU,oBAAA;EAgBZ,kBAAA,CACE,UAAA,UACA,OAAA,GAAU,UAAA,EAAY,uBAAA,kBACtB,OAAA,GAAU,oBAAA;AAAA;AAAA,iBAiBQ,eAAA,CAAgB,IAAA,UAAc,MAAA,GAAS,MAAA,GAAM,OAAA,CAAA,aAAA"}

package/dist/src/packages/vite-loader.mjs

@@ -0,0 +1,142 @@
+import { a as isSubgraphClass, o as debounce, s as isSubpath } from "../../utils-DEEhP99G.mjs";
+import { childLogger } from "document-model";
+import path from "node:path";
+import { viteCommonjs } from "@originjs/vite-plugin-commonjs";
+import { readPackage } from "read-pkg";
+import { createLogger, createServer } from "vite";
+//#region src/packages/vite-loader.mts
+function createViteLogger(logger, prefix = "") {
+	const customLogger = createLogger("info", { prefix });
+	customLogger.info = logger.info;
+	customLogger.warn = logger.warn;
+	customLogger.error = logger.error;
+	return customLogger;
+}
+var VitePackageLoader = class VitePackageLoader {
+	logger = childLogger(["reactor-api", "vite-loader"]);
+	vite;
+	name = "VitePackageLoader";
+	static build(vite) {
+		return new VitePackageLoader(vite);
+	}
+	constructor(vite) {
+		this.vite = vite;
+	}
+	getDocumentModelsPath(identifier) {
+		return path.join(identifier, "./document-models");
+	}
+	getSubgraphsPath(identifier) {
+		return path.join(identifier, "./subgraphs");
+	}
+	getProcessorsPath(identifier) {
+		return path.join(identifier, "./processors");
+	}
+	loadDocumentModels(identifier, immediate = false) {
+		return this.#loadDocumentModelsWithDebounce(immediate, identifier);
+	}
+	#loadDocumentModelsWithDebounce = debounce(this.#loadDocumentModels.bind(this), 500);
+	async #loadDocumentModels(identifier) {
+		const fullPath = this.getDocumentModelsPath(identifier);
+		this.logger.debug("Loading document models from", fullPath);
+		try {
+			const localDMs = await this.vite.ssrLoadModule(fullPath);
+			const exports = Object.values(localDMs);
+			const documentModels = [];
+			for (const dm of exports) if (dm.documentModel) documentModels.push(dm);
+			this.logger.verbose(`  ➜  Loaded ${documentModels.length} Document Models from: ${identifier}`);
+			return documentModels;
+		} catch (e) {
+			this.logger.debug(`  ➜  No Document Models found for: ${identifier}`, e);
+		}
+		return [];
+	}
+	async loadSubgraphs(identifier) {
+		const fullPath = this.getSubgraphsPath(identifier);
+		this.logger.verbose("Loading subgraphs from", fullPath);
+		let localSubgraphs = {};
+		try {
+			localSubgraphs = await this.vite.ssrLoadModule(fullPath);
+		} catch (e) {
+			this.logger.debug(`  ➜  No Subgraphs found for: ${identifier}`, e);
+			return [];
+		}
+		const subgraphs = [];
+		for (const [name, subgraph] of Object.entries(localSubgraphs)) {
+			const SubgraphClass = subgraph[name];
+			if (isSubgraphClass(SubgraphClass)) subgraphs.push(SubgraphClass);
+		}
+		this.logger.debug(`  ➜  Loaded ${subgraphs.length} Subgraphs from: ${identifier}`);
+		return subgraphs;
+	}
+	async loadProcessors(identifier) {
+		const fullPath = this.getProcessorsPath(identifier);
+		this.logger.verbose("Loading processors from", fullPath);
+		try {
+			const factory = (await this.vite.ssrLoadModule(fullPath))?.processorFactory;
+			if (factory && typeof factory === "function") {
+				this.logger.verbose(`  ➜  Loaded Processor Factory from: ${identifier}`);
+				return factory;
+			}
+		} catch (e) {
+			this.logger.debug(`  ➜  No Processor Factory found for: ${identifier}`, e);
+		}
+		this.logger.verbose(`  ➜  No Processor Factory found for: ${identifier}`);
+		return null;
+	}
+	onDocumentModelsChange(identifier, handler, options) {
+		const listener = async (changedPath) => {
+			if (isSubpath(this.getDocumentModelsPath(identifier), changedPath)) handler(await this.loadDocumentModels(identifier));
+		};
+		this.vite.watcher.on("change", listener);
+		return () => {
+			this.vite.watcher.off("change", listener);
+		};
+	}
+	onSubgraphsChange(identifier, handler, options) {
+		const subgraphsPath = this.getSubgraphsPath(identifier);
+		const listener = debounce(async (changedPath) => {
+			if (isSubpath(subgraphsPath, changedPath)) handler(await this.loadSubgraphs(identifier));
+		}, options?.debounce ?? 100);
+		this.vite.watcher.on("change", listener);
+		return () => {
+			this.vite.watcher.off("change", listener);
+		};
+	}
+	onProcessorsChange(identifier, handler, options) {
+		const processorsPath = this.getProcessorsPath(identifier);
+		const listener = async (changedPath) => {
+			if (isSubpath(processorsPath, changedPath)) handler(await this.loadProcessors(identifier));
+		};
+		this.vite.watcher.on("change", listener);
+		return () => {
+			this.vite.watcher.off("change", listener);
+		};
+	}
+};
+async function startViteServer(root, logger) {
+	return await createServer({
+		root,
+		configFile: false,
+		logger,
+		server: {
+			middlewareMode: true,
+			watch: { ignored: ["**/.ph/**"] }
+		},
+		appType: "custom",
+		build: { rollupOptions: { input: [] } },
+		resolve: {
+			tsconfigPaths: true,
+			alias: { [(await readPackage({ cwd: root })).name]: root }
+		},
+		plugins: [viteCommonjs(), {
+			name: "suppress-hmr",
+			handleHotUpdate() {
+				return [];
+			}
+		}]
+	});
+}
+//#endregion
+export { VitePackageLoader, createViteLogger, startViteServer };
+
+//# sourceMappingURL=vite-loader.mjs.map

package/dist/src/packages/vite-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-loader.mjs","names":["#loadDocumentModelsWithDebounce","#loadDocumentModels"],"sources":["../../../src/packages/vite-loader.mts"],"sourcesContent":["import { viteCommonjs } from \"@originjs/vite-plugin-commonjs\";\nimport type {\n  ProcessorFactoryBuilder,\n  SubgraphClass,\n} from \"@powerhousedao/reactor-api\";\nimport type { DocumentModelModule } from \"@powerhousedao/shared/document-model\";\nimport { childLogger, type ILogger } from \"document-model\";\nimport path from \"node:path\";\nimport { readPackage } from \"read-pkg\";\nimport type { Logger, ViteDevServer } from \"vite\";\nimport { createLogger, createServer } from \"vite\";\nimport { isSubgraphClass } from \"../graphql/utils.js\";\nimport type {\n  ISubscribablePackageLoader,\n  ISubscriptionOptions,\n} from \"./types.js\";\nimport { debounce, isSubpath } from \"./util.js\";\n\nexport function createViteLogger(logger: ILogger, prefix = \"\") {\n  const customLogger = createLogger(\"info\", {\n    prefix,\n  });\n  customLogger.info = logger.info;\n  customLogger.warn = logger.warn;\n  customLogger.error = logger.error;\n  return customLogger;\n}\n\nexport class VitePackageLoader implements ISubscribablePackageLoader {\n  private readonly logger = childLogger([\"reactor-api\", \"vite-loader\"]);\n\n  private readonly vite: ViteDevServer;\n\n  readonly name = \"VitePackageLoader\";\n\n  static build(vite: ViteDevServer) {\n    return new VitePackageLoader(vite);\n  }\n\n  constructor(vite: ViteDevServer) {\n    this.vite = vite;\n  }\n\n  private getDocumentModelsPath(identifier: string): string {\n    return path.join(identifier, \"./document-models\");\n  }\n\n  private getSubgraphsPath(identifier: string): string {\n    return path.join(identifier, \"./subgraphs\");\n  }\n\n  private getProcessorsPath(identifier: string): string {\n    return path.join(identifier, \"./processors\");\n  }\n\n  public loadDocumentModels(identifier: string, immediate = false) {\n    return this.#loadDocumentModelsWithDebounce(immediate, identifier);\n  }\n\n  #loadDocumentModelsWithDebounce = debounce(\n    this.#loadDocumentModels.bind(this),\n    500,\n  );\n\n  async #loadDocumentModels(\n    identifier: string,\n  ): Promise<DocumentModelModule[]> {\n    const fullPath = this.getDocumentModelsPath(identifier);\n    this.logger.debug(\"Loading document models from\", fullPath);\n\n    try {\n      const localDMs = (await this.vite.ssrLoadModule(fullPath)) as Record<\n        string,\n        DocumentModelModule\n      >;\n\n      const exports = Object.values(localDMs);\n\n      // duck type\n      const documentModels: DocumentModelModule[] = [];\n      for (const dm of exports) {\n        if (dm.documentModel) {\n          documentModels.push(dm);\n        }\n      }\n\n      this.logger.verbose(\n        `  ➜  Loaded ${documentModels.length} Document Models from: ${identifier}`,\n      );\n\n      return documentModels;\n    } catch (e) {\n      this.logger.debug(`  ➜  No Document Models found for: ${identifier}`, e);\n    }\n\n    return [];\n  }\n\n  async loadSubgraphs(identifier: string): Promise<SubgraphClass[]> {\n    const fullPath = this.getSubgraphsPath(identifier);\n\n    this.logger.verbose(\"Loading subgraphs from\", fullPath);\n\n    let localSubgraphs: Record<string, Record<string, SubgraphClass>> = {};\n    try {\n      localSubgraphs = await this.vite.ssrLoadModule(fullPath);\n    } catch (e) {\n      this.logger.debug(`  ➜  No Subgraphs found for: ${identifier}`, e);\n      return [];\n    }\n\n    const subgraphs: SubgraphClass[] = [];\n    for (const [name, subgraph] of Object.entries(localSubgraphs)) {\n      const SubgraphClass = subgraph[name];\n      if (isSubgraphClass(SubgraphClass)) {\n        subgraphs.push(SubgraphClass);\n      }\n    }\n\n    this.logger.debug(\n      `  ➜  Loaded ${subgraphs.length} Subgraphs from: ${identifier}`,\n    );\n\n    return subgraphs;\n  }\n\n  async loadProcessors(\n    identifier: string,\n  ): Promise<ProcessorFactoryBuilder | null> {\n    const fullPath = this.getProcessorsPath(identifier);\n\n    this.logger.verbose(\"Loading processors from\", fullPath);\n\n    try {\n      const pkgModule = await this.vite.ssrLoadModule(fullPath);\n\n      const factory = (\n        pkgModule as Record<string, ProcessorFactoryBuilder | undefined>\n      )?.processorFactory;\n\n      if (factory && typeof factory === \"function\") {\n        this.logger.verbose(\n          `  ➜  Loaded Processor Factory from: ${identifier}`,\n        );\n        return factory;\n      }\n    } catch (e) {\n      this.logger.debug(\n        `  ➜  No Processor Factory found for: ${identifier}`,\n        e,\n      );\n    }\n\n    this.logger.verbose(`  ➜  No Processor Factory found for: ${identifier}`);\n\n    // return empty processor factory\n    return null;\n  }\n\n  onDocumentModelsChange(\n    identifier: string,\n    handler: (documentModels: DocumentModelModule[]) => void,\n    options?: ISubscriptionOptions,\n  ): () => void {\n    const listener = async (changedPath: string) => {\n      const documentModelsPath = this.getDocumentModelsPath(identifier);\n      if (isSubpath(documentModelsPath, changedPath)) {\n        const documentModels = await this.loadDocumentModels(identifier);\n        handler(documentModels);\n      }\n    };\n\n    this.vite.watcher.on(\"change\", listener);\n\n    return () => {\n      this.vite.watcher.off(\"change\", listener);\n    };\n  }\n\n  onSubgraphsChange(\n    identifier: string,\n    handler: (subgraphs: SubgraphClass[]) => void,\n    options?: ISubscriptionOptions,\n  ): () => void {\n    const subgraphsPath = this.getSubgraphsPath(identifier);\n    const listener = debounce(async (changedPath: string) => {\n      if (isSubpath(subgraphsPath, changedPath)) {\n        const subgraphs = await this.loadSubgraphs(identifier);\n        handler(subgraphs);\n      }\n    }, options?.debounce ?? 100);\n    this.vite.watcher.on(\"change\", listener);\n\n    return () => {\n      this.vite.watcher.off(\"change\", listener);\n    };\n  }\n\n  onProcessorsChange(\n    identifier: string,\n    handler: (processors: ProcessorFactoryBuilder | null) => void,\n    options?: ISubscriptionOptions,\n  ): () => void {\n    const processorsPath = this.getProcessorsPath(identifier);\n    const listener = async (changedPath: string) => {\n      if (isSubpath(processorsPath, changedPath)) {\n        const processors = await this.loadProcessors(identifier);\n        handler(processors);\n      }\n    };\n    this.vite.watcher.on(\"change\", listener);\n\n    return () => {\n      this.vite.watcher.off(\"change\", listener);\n    };\n  }\n}\n\nexport async function startViteServer(root: string, logger?: Logger) {\n  const packageJson = await readPackage({ cwd: root });\n\n  const vite = await createServer({\n    root,\n    configFile: false,\n    logger,\n    server: { middlewareMode: true, watch: { ignored: [\"**/.ph/**\"] } },\n    appType: \"custom\",\n    build: {\n      rollupOptions: {\n        input: [],\n      },\n    },\n    resolve: {\n      tsconfigPaths: true,\n      alias: {\n        [packageJson.name]: root,\n      },\n    },\n    plugins: [\n      viteCommonjs(),\n      {\n        name: \"suppress-hmr\",\n        handleHotUpdate() {\n          return []; // return empty array to suppress server refresh\n        },\n      },\n    ],\n  });\n\n  return vite;\n}\n"],"mappings":"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"}

package/dist/types-Do4QTfT3.d.mts

@@ -0,0 +1,37 @@
+import { ILogger } from "document-model";
+import { DocumentModelModule } from "@powerhousedao/shared/document-model";
+import { ProcessorFactoryBuilder, SubgraphClass } from "@powerhousedao/reactor-api";
+
+//#region src/packages/types.d.ts
+interface IPackageLoader {
+  name: string;
+  loadDocumentModels(identifier: string, immediate?: boolean): Promise<DocumentModelModule[]>;
+  loadSubgraphs(identifier: string, immediate?: boolean): Promise<SubgraphClass[]>;
+  loadProcessors(identifier: string, immediate?: boolean): Promise<ProcessorFactoryBuilder | null>;
+}
+interface ISubscriptionOptions {
+  debounce?: number;
+}
+interface ISubscribablePackageLoader extends IPackageLoader {
+  onDocumentModelsChange?(identifier: string, handler: (documentModels: DocumentModelModule[]) => void, options?: ISubscriptionOptions): () => void;
+  onSubgraphsChange?(identifier: string, handler: (subgraphs: SubgraphClass[]) => void, options?: ISubscriptionOptions): () => void;
+  onProcessorsChange?(identifier: string, handler: (processors: ProcessorFactoryBuilder | null) => void, options?: ISubscriptionOptions): () => void;
+}
+interface IPackageManager {
+  onDocumentModelsChange(handler: (documentModels: Record<string, DocumentModelModule[]>) => void): void;
+}
+type IPackageLoaderOptions = {
+  logger?: ILogger;
+};
+type IPackageManagerOptions = {
+  packages?: string[];
+  configFile?: string;
+};
+type PackageManagerResult = {
+  documentModels: DocumentModelModule[];
+  subgraphs: Map<string, SubgraphClass[]>;
+  processors: Map<string, ProcessorFactoryBuilder[]>;
+};
+//#endregion
+export { ISubscribablePackageLoader as a, IPackageManagerOptions as i, IPackageLoaderOptions as n, ISubscriptionOptions as o, IPackageManager as r, PackageManagerResult as s, IPackageLoader as t };
+//# sourceMappingURL=types-Do4QTfT3.d.mts.map

package/dist/types-Do4QTfT3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Do4QTfT3.d.mts","names":[],"sources":["../src/packages/types.ts"],"mappings":";;;;;UAOiB,cAAA;EACf,IAAA;EACA,kBAAA,CACE,UAAA,UACA,SAAA,aACC,OAAA,CAAQ,mBAAA;EACX,aAAA,CACE,UAAA,UACA,SAAA,aACC,OAAA,CAAQ,aAAA;EACX,cAAA,CACE,UAAA,UACA,SAAA,aACC,OAAA,CAAQ,uBAAA;AAAA;AAAA,UAGI,oBAAA;EACf,QAAA;AAAA;AAAA,UAGe,0BAAA,SAAmC,cAAA;EAClD,sBAAA,EACE,UAAA,UACA,OAAA,GAAU,cAAA,EAAgB,mBAAA,aAC1B,OAAA,GAAU,oBAAA;EAEZ,iBAAA,EACE,UAAA,UACA,OAAA,GAAU,SAAA,EAAW,aAAA,aACrB,OAAA,GAAU,oBAAA;EAEZ,kBAAA,EACE,UAAA,UACA,OAAA,GAAU,UAAA,EAAY,uBAAA,kBACtB,OAAA,GAAU,oBAAA;AAAA;AAAA,UAIG,eAAA;EACf,sBAAA,CACE,OAAA,GAAU,cAAA,EAAgB,MAAA,SAAe,mBAAA;AAAA;AAAA,KAIjC,qBAAA;EACV,MAAA,GAAS,OAAA;AAAA;AAAA,KAGC,sBAAA;EACV,QAAA;EACA,UAAA;AAAA;AAAA,KAWU,oBAAA;EACV,cAAA,EAAgB,mBAAA;EAChB,SAAA,EAAW,GAAA,SAAY,aAAA;EACvB,UAAA,EAAY,GAAA,SAAY,uBAAA;AAAA"}

package/dist/utils-DEEhP99G.mjs

@@ -0,0 +1,286 @@
+import { gql } from "graphql-tag";
+import { GraphQLError } from "graphql";
+import { childLogger } from "document-model";
+import path from "node:path";
+//#region src/graphql/base-subgraph.ts
+var BaseSubgraph = class {
+	name = "example";
+	path = "";
+	resolvers = { Query: { hello: () => this.name } };
+	typeDefs = gql`
+    type Query {
+      hello: String
+    }
+  `;
+	reactorClient;
+	graphqlManager;
+	relationalDb;
+	syncManager;
+	documentPermissionService;
+	authorizationService;
+	constructor(args) {
+		this.reactorClient = args.reactorClient;
+		this.graphqlManager = args.graphqlManager;
+		this.relationalDb = args.relationalDb;
+		this.syncManager = args.syncManager;
+		this.documentPermissionService = args.documentPermissionService;
+		this.authorizationService = args.authorizationService;
+		this.path = args.path ?? "";
+	}
+	async onSetup() {}
+	getParentIdsFn() {
+		return async (documentId) => {
+			try {
+				return (await this.reactorClient.getParents(documentId)).results.map((doc) => doc.header.id);
+			} catch {
+				return [];
+			}
+		};
+	}
+	hasGlobalAdminAccess(ctx) {
+		return !!ctx.isAdmin?.(ctx.user?.address ?? "");
+	}
+	async canReadDocument(documentId, ctx) {
+		if (this.authorizationService) return this.authorizationService.canRead(documentId, ctx.user?.address, this.getParentIdsFn());
+		if (this.hasGlobalAdminAccess(ctx)) return true;
+		if (this.documentPermissionService) return this.documentPermissionService.canRead(documentId, ctx.user?.address, this.getParentIdsFn());
+		return false;
+	}
+	async assertCanRead(documentId, ctx) {
+		if (this.authorizationService) {
+			if (!await this.authorizationService.canRead(documentId, ctx.user?.address, this.getParentIdsFn())) throw new GraphQLError("Forbidden: insufficient permissions to read this document");
+			return;
+		}
+		if (!this.hasGlobalAdminAccess(ctx)) if (this.documentPermissionService) {
+			if (!await this.documentPermissionService.canRead(documentId, ctx.user?.address, this.getParentIdsFn())) throw new GraphQLError("Forbidden: insufficient permissions to read this document");
+		} else throw new GraphQLError("Forbidden: insufficient permissions to read this document");
+	}
+	async assertCanWrite(documentId, ctx) {
+		if (this.authorizationService) {
+			if (!await this.authorizationService.canWrite(documentId, ctx.user?.address, this.getParentIdsFn())) throw new GraphQLError("Forbidden: insufficient permissions to write to this document");
+			return;
+		}
+		if (!this.hasGlobalAdminAccess(ctx)) if (this.documentPermissionService) {
+			if (!await this.documentPermissionService.canWrite(documentId, ctx.user?.address, this.getParentIdsFn())) throw new GraphQLError("Forbidden: insufficient permissions to write to this document");
+		} else throw new GraphQLError("Forbidden: insufficient permissions to write to this document");
+	}
+	async assertCanExecuteOperation(documentId, operationType, ctx) {
+		if (this.authorizationService) {
+			if (!await this.authorizationService.canMutate(documentId, operationType, ctx.user?.address, this.getParentIdsFn())) throw new GraphQLError(`Forbidden: insufficient permissions to execute operation "${operationType}" on this document`);
+			return;
+		}
+		if (!this.documentPermissionService) return;
+		if (ctx.isAdmin?.(ctx.user?.address ?? "")) return;
+		if (await this.documentPermissionService.isOperationRestricted(documentId, operationType)) {
+			if (!await this.documentPermissionService.canExecuteOperation(documentId, operationType, ctx.user?.address)) throw new GraphQLError(`Forbidden: insufficient permissions to execute operation "${operationType}" on this document`);
+		}
+	}
+};
+//#endregion
+//#region src/packages/import-resolver.ts
+/**
+* Attempts to import from suggested Node.js paths
+*/
+async function tryNodeSuggestedPaths(packageName, subPath) {
+	const suggestedPaths = [`${packageName}/dist/${subPath}/index.js`, `${packageName}/dist/${subPath}.js`];
+	for (const suggestedPath of suggestedPaths) try {
+		return await import(
+			/* @vite-ignore */
+			suggestedPath
+);
+	} catch {}
+	return null;
+}
+/**
+* Attempts to resolve package using import.meta.resolve
+*/
+async function tryImportMetaResolve(packageName, subPath) {
+	try {
+		const resolvedUrl = import.meta.resolve?.(`${packageName}/package.json`);
+		if (!resolvedUrl) return null;
+		const packageRoot = path.dirname(new URL(resolvedUrl).pathname);
+		const pathsToTry = [
+			path.join(packageRoot, "dist", subPath, "index.js"),
+			path.join(packageRoot, "dist", `${subPath}.js`),
+			path.join(packageRoot, subPath, "index.js"),
+			path.join(packageRoot, `${subPath}.js`)
+		];
+		for (const attemptPath of pathsToTry) try {
+			return await import(
+				/* @vite-ignore */
+				attemptPath
+);
+		} catch {}
+	} catch {}
+	return null;
+}
+/**
+* Resolves symlinks in node_modules to find the real package location
+*/
+async function resolveSymlinkedPaths(packageName, subPath) {
+	const packageBaseName = packageName.includes("/") ? packageName.split("/").pop() : packageName;
+	const nodeModulesPatterns = [path.join(process.cwd(), "node_modules", packageName), path.join(process.cwd(), "node_modules", packageBaseName || packageName)];
+	const workspacePatterns = [];
+	for (const nodeModulesPath of nodeModulesPatterns) try {
+		const fs = await import("node:fs");
+		if (fs.existsSync(nodeModulesPath)) {
+			const realPath = fs.realpathSync(nodeModulesPath);
+			workspacePatterns.push(path.join(realPath, "dist", subPath, "index.js"), path.join(realPath, "dist", `${subPath}.js`), path.join(realPath, subPath, "index.js"), path.join(realPath, `${subPath}.js`));
+		}
+	} catch {}
+	return workspacePatterns;
+}
+/**
+* Generates common workspace pattern paths
+*/
+function getCommonWorkspacePaths(packageName, subPath) {
+	const packageBaseName = packageName.includes("/") ? packageName.split("/").pop() : packageName;
+	const commonRoots = [process.cwd(), path.dirname(process.cwd())];
+	const workspacePatterns = [];
+	for (const root of commonRoots) workspacePatterns.push(path.join(root, "packages", packageBaseName || packageName, "dist", subPath, "index.js"), path.join(root, "packages", packageBaseName || packageName, "dist", `${subPath}.js`));
+	return workspacePatterns;
+}
+/**
+* Attempts to import from a list of workspace patterns
+*/
+async function tryWorkspacePatterns(patterns) {
+	for (const workspacePath of patterns) try {
+		return await import(
+			/* @vite-ignore */
+			workspacePath
+);
+	} catch {}
+	return null;
+}
+/**
+* Attempts to resolve linked packages using various fallback strategies
+*/
+async function resolveLinkedPackage(packageName, subPath) {
+	let result = await tryNodeSuggestedPaths(packageName, subPath);
+	if (result) return result;
+	result = await tryImportMetaResolve(packageName, subPath);
+	if (result) return result;
+	result = await tryWorkspacePatterns(await resolveSymlinkedPaths(packageName, subPath));
+	if (result) return result;
+	result = await tryWorkspacePatterns(getCommonWorkspacePaths(packageName, subPath));
+	if (result) return result;
+	return null;
+}
+//#endregion
+//#region src/packages/util.ts
+childLogger(["reactor-api", "packages/util"]);
+/**
+* Tries to import document models from a package. This function cannot throw.
+*/
+async function loadDocumentModels(packageName) {
+	return loadDependency(packageName, "document-models");
+}
+/**
+* Tries to import subgraphs from a package. This function cannot throw.
+*/
+async function loadSubgraphs(packageName) {
+	return loadDependency(packageName, "subgraphs");
+}
+/**
+* Tries to import processors from a package. This function cannot throw.
+*/
+async function loadProcessors(packageName) {
+	return loadDependency(packageName, "processors");
+}
+/**
+* Generic dependency loader - tries to import a dependency from a package. This function cannot throw.
+* Returns null if the dependency cannot be loaded.
+*/
+async function loadDependency(packageName, subPath) {
+	const fullPath = `${packageName}/${subPath}`;
+	try {
+		return await import(
+			/* @vite-ignore */
+			fullPath
+);
+	} catch (e) {
+		if (e instanceof Error && "code" in e && (e.code === "ERR_MODULE_NOT_FOUND" || e.code === "ERR_UNSUPPORTED_DIR_IMPORT")) {
+			const result = await resolveLinkedPackage(packageName, subPath);
+			if (result) return result;
+		}
+		throw e;
+	}
+}
+function debounce(func, delay = 250) {
+	let timer;
+	return (immediate = false, ...args) => {
+		if (timer) clearTimeout(timer);
+		return new Promise((resolve, reject) => {
+			if (immediate) func(...args).then(resolve).catch(reject);
+			else timer = setTimeout(() => {
+				func(...args).then(resolve).catch(reject);
+			}, delay);
+		});
+	};
+}
+function isSubpath(parent, dir) {
+	const relative = path.relative(parent, dir);
+	return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/graphql/utils.ts
+function isSubgraphClass(candidate) {
+	if (typeof candidate !== "function") return false;
+	let proto = Object.getPrototypeOf(candidate);
+	while (proto) {
+		if (Object.prototype.isPrototypeOf.call(proto, BaseSubgraph)) return true;
+		proto = Object.getPrototypeOf(proto);
+	}
+	return false;
+}
+function buildGraphqlOperations(operations, skip, first) {
+	return operations.slice(skip, skip + first).map(buildGraphqlOperation);
+}
+function buildGraphqlOperation(operation) {
+	const signer = operation.action.context?.signer;
+	return {
+		id: operation.id ?? "",
+		type: operation.action.type,
+		index: operation.index,
+		timestampUtcMs: operation.timestampUtcMs,
+		hash: operation.hash,
+		skip: operation.skip,
+		inputText: typeof operation.action.input === "string" ? operation.action.input : JSON.stringify(operation.action.input),
+		error: operation.error,
+		context: { signer: signer ? {
+			user: signer.user,
+			app: signer.app,
+			signatures: signer.signatures.map((sig) => Array.isArray(sig) ? sig.join(", ") : sig)
+		} : void 0 }
+	};
+}
+function buildGraphQlDocument(doc) {
+	const state = doc.state;
+	const initialState = doc.initialState;
+	const globalState = "global" in doc.state ? doc.state.global : {};
+	return {
+		id: doc.header.id,
+		name: doc.header.name,
+		documentType: doc.header.documentType,
+		revision: doc.header.revision.global || 0,
+		createdAtUtcIso: doc.header.createdAtUtcIso,
+		lastModifiedAtUtcIso: doc.header.lastModifiedAtUtcIso,
+		operations: [],
+		stateJSON: globalState,
+		state,
+		initialState
+	};
+}
+function buildGraphQlDriveDocument(doc) {
+	return {
+		...buildGraphQlDocument(doc),
+		meta: { preferredEditor: doc.header.meta?.preferredEditor },
+		slug: doc.header.slug,
+		state: doc.state.global,
+		initialState: doc.state.global
+	};
+}
+//#endregion
+export { isSubgraphClass as a, loadDocumentModels as c, BaseSubgraph as d, buildGraphqlOperations as i, loadProcessors as l, buildGraphQlDriveDocument as n, debounce as o, buildGraphqlOperation as r, isSubpath as s, buildGraphQlDocument as t, loadSubgraphs as u };
+
+//# sourceMappingURL=utils-DEEhP99G.mjs.map