@powerhousedao/reactor-api 6.2.3-dev.40 → 6.2.3-dev.41

package/dist/index.mjs

@@ -1,7 +1,8 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a50faed2-4e40-54ba-873f-1808cedc1e5c")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="65e47e18-15f4-5a67-b94b-f6e795c1eb9b")}catch(e){}}();
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { A as RefusalNotRecordedError, C as AuthorizationPolicy, D as AuthenticationRequiredError, E as AuthEvaluationUnsupportedError, O as ForbiddenError, S as createCanonicalDocumentIdResolver, T as createAuthorizationService, _ as loadProcessors, a as pieceListLocation, b as callerSubject, c as buildGraphQlDocument, d as buildGraphqlOperations, f as isSubgraphClass, g as loadDocumentModels, k as MalformedStoredOperationError, l as buildGraphQlDriveDocument, m as extractUpgradeManifests, o as piecesFromCdnList, p as debounce, r as PIECE_SOURCE_LIST, s as piecesFromListModule, u as buildGraphqlOperation, v as loadSubgraphs, w as AuthorizedDocumentHandle, x as CanonicalDocumentIdResolutionError, y as BaseSubgraph } from "./pieces-DRY6haAO.mjs";
+import { findPackageJSON, isBuiltin } from "node:module";
 import { AnalyticsQueryEngine } from "@powerhousedao/analytics-engine-core";
 import { AnalyticsModel, AnalyticsResolvers, typedefs } from "@powerhousedao/analytics-engine-graphql";
 import { gql } from "graphql-tag";
@@ -15,7 +16,7 @@ import posix from "node:path/posix";
 import { Readable } from "node:stream";
 import fs, { existsSync, readFileSync, watchFile } from "node:fs";
 import { pipeline } from "node:stream/promises";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { pathToFileURL } from "node:url";
 import { buildSubgraphSchema } from "@apollo/subgraph";
 import { typeDefs } from "@powerhousedao/document-engineering/graphql";
@@ -28,6 +29,8 @@ import lzString from "lz-string";
 import { PubSub, withFilter } from "graphql-subscriptions";
 import dotenv from "dotenv";
 import { buildTreeUrl } from "@powerhousedao/shared";
+import { init, parse as parse$1 } from "es-module-lexer";
+import { chmod, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { getConfig } from "@powerhousedao/config/node";
 import { reactorDriveDocumentModelModule } from "@powerhousedao/reactor-drive";
 import { ReactorGroupV1 } from "@powerhousedao/reactor-group";
@@ -37,7 +40,6 @@ import { PostgresAnalyticsStore } from "@powerhousedao/analytics-engine-pg";
 import { AttachmentBuilder, AttachmentNotFound, AttachmentReferenceIndexBuilder, createRef, createS3AttachmentBackend, parseAttachmentStorageConfig, parseRef, validateReserveMetadata } from "@powerhousedao/reactor-attachments";
 import { createAttachmentClient } from "@powerhousedao/reactor-attachments/client";
 import { setupMcpServer } from "@powerhousedao/reactor-mcp";
-import { mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { WebSocketServer } from "ws";
 import { createRelationalDb } from "@powerhousedao/shared/processors";
@@ -6824,10 +6826,10 @@ const ADMIN_USERS = getAdminUsers();
 //#endregion
 //#region src/graphql/system/version.ts
 function getVersion() {
-	return "6.2.3-dev.40";
+	return "6.2.3-dev.41";
 }
 function getGitHash() {
-	return "9a25fe4dcac53275b3e4e818fa6259f56a2532bb";
+	return "84f56c54bfdb09f7789448e0c77f6c57454a47a6";
 }
 function getGitUrl() {
 	return buildTreeUrl(getGitHash());
@@ -6855,11 +6857,446 @@ var SystemSubgraph = class extends BaseSubgraph {
 	}) } };
 };
 //#endregion
-//#region src/packages/http-loader.ts
+//#region src/packages/registry-cache.ts
+/** Entry files a registry package's node build is served from, CDN-relative. */
+const PACKAGE_ENTRIES = {
+	documentModels: "node/document-models/index.mjs",
+	subgraphs: "node/subgraphs/index.mjs",
+	processors: "node/processors/index.mjs"
+};
+const REGISTRY_ENTRY_ABSENT = "ERR_REGISTRY_ENTRY_ABSENT";
+const MANIFEST_FILE = "manifest.json";
+function defaultRegistryCacheDir(cwd = process.cwd()) {
+	return path.join(cwd, ".ph", "registry-packages");
+}
 const EXACT_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const PACKAGE_NAME = /^(@[a-z0-9][-a-z0-9._]*\/)?[a-z0-9][-a-z0-9._]*$/i;
+function isValidPackageName(name) {
+	return PACKAGE_NAME.test(name) && !name.includes("..") && name.length <= 214;
+}
+const MAX_FILE_BYTES = 16777216;
+const MAX_TOTAL_BYTES = 134217728;
+const MAX_FILES = 2e3;
+const MAX_IN_FLIGHT = 4;
+const FETCH_TIMEOUT_MS = 3e4;
+const DEAD_PID_GRACE_MS = 6e4;
+const ABANDONED_AFTER_MS = 36e5;
+const LEFTOVER = /\.(?:tmp|stale)-(\d+)-[0-9a-f]{8}$/;
+const STATIC_IMPORT = 1;
+const DYNAMIC_IMPORT = 2;
+var RegistryPackageCache = class {
+	cacheDir;
+	registryUrl;
+	logger;
+	fetchTimeoutMs;
+	inFlight = /* @__PURE__ */ new Map();
+	verified = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.registryUrl = options.registryUrl.endsWith("/") ? options.registryUrl : `${options.registryUrl}/`;
+		this.cacheDir = path.resolve(options.cacheDir ?? defaultRegistryCacheDir());
+		this.logger = options.logger ?? childLogger(["reactor-api", "registry-cache"]);
+		this.fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+	}
+	/** Base URL every file of `name@version` is fetched under. */
+	baseUrl(name, version) {
+		return `${this.registryUrl}-/cdn/${name}@${version}/`;
+	}
+	entryDir(name, version) {
+		assertCoordinate(name, version);
+		const dir = path.join(this.cacheDir, `${name}@${version}`);
+		assertWithin(dir, this.cacheDir);
+		return dir;
+	}
+	/** Complete cached versions of `name`, newest-agnostic. */
+	async cachedVersions(name) {
+		if (!isValidPackageName(name)) return [];
+		const parent = path.dirname(path.join(this.cacheDir, `${name}@0.0.0`));
+		const leaf = path.basename(name);
+		let names;
+		try {
+			names = await readdir(parent);
+		} catch {
+			return [];
+		}
+		const versions = [];
+		for (const entry of names) {
+			if (!entry.startsWith(`${leaf}@`)) continue;
+			const version = entry.slice(leaf.length + 1);
+			if (!EXACT_VERSION.test(version)) continue;
+			try {
+				await stat(path.join(parent, entry, MANIFEST_FILE));
+				versions.push(version);
+			} catch {}
+		}
+		return versions;
+	}
+	async ensurePackage(name, version) {
+		const dir = this.entryDir(name, version);
+		const done = this.verified.get(dir);
+		if (done) return {
+			...done,
+			source: "cache"
+		};
+		const pending = this.inFlight.get(dir);
+		if (pending) return pending;
+		const started = this.resolveEntry(name, version, dir).finally(() => this.inFlight.delete(dir));
+		this.inFlight.set(dir, started);
+		return started;
+	}
+	async resolveEntry(name, version, dir) {
+		let manifest = await this.verify(dir, name, version);
+		let source = "cache";
+		if (!manifest) {
+			manifest = await this.fill(name, version, dir);
+			source = "download";
+		}
+		await this.linkBareImports(manifest.bareImports);
+		const entries = {};
+		for (const [kind, rel] of Object.entries(manifest.entries)) entries[kind] = path.join(dir, rel);
+		const result = {
+			name,
+			version,
+			dir,
+			entries,
+			source
+		};
+		this.verified.set(dir, result);
+		return result;
+	}
+	/** The manifest when every listed file is present and hashes to it. */
+	async verify(dir, name, version) {
+		let manifest;
+		try {
+			manifest = parseManifest(await readFile(path.join(dir, MANIFEST_FILE), "utf8"));
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			this.logger.warn("Unreadable cache manifest in @dir: @error", dir, error);
+			await this.discard(dir);
+			return null;
+		}
+		if (manifest.name !== name || manifest.version !== version || Object.values(manifest.entries).some((rel) => !(rel in manifest.files))) {
+			this.logger.warn("Cache manifest in @dir names another package", dir);
+			await this.discard(dir);
+			return null;
+		}
+		for (const [rel, expected] of Object.entries(manifest.files)) {
+			let actual;
+			try {
+				const file = path.join(dir, rel);
+				assertWithin(file, dir);
+				actual = sha256(await readFile(file));
+			} catch {
+				actual = null;
+			}
+			if (actual !== expected) {
+				this.logger.warn("Cached @file of @package failed verification; fetching it again", rel, `${name}@${version}`);
+				await this.discard(dir);
+				return null;
+			}
+		}
+		return manifest;
+	}
+	async discard(dir) {
+		const aside = `${dir}.stale-${process.pid}-${randomUUID().slice(0, 8)}`;
+		try {
+			await rename(dir, aside);
+		} catch {
+			return;
+		}
+		await rm(aside, {
+			recursive: true,
+			force: true
+		});
+	}
+	async fill(name, version, dir) {
+		const staging = `${dir}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+		assertWithin(staging, this.cacheDir);
+		await sweepLeftovers(path.dirname(dir));
+		await mkdir(staging, { recursive: true });
+		try {
+			const manifest = await this.download(name, version, staging);
+			await writeFile(path.join(staging, MANIFEST_FILE), JSON.stringify(manifest, null, 2));
+			await chmod(staging, 493);
+			try {
+				await rename(staging, dir);
+			} catch {
+				const theirs = await this.verify(dir, name, version);
+				if (theirs) return theirs;
+				await this.discard(dir);
+				await rename(staging, dir);
+			}
+			return manifest;
+		} finally {
+			await rm(staging, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async download(name, version, staging) {
+		await init;
+		const base = this.baseUrl(name, version);
+		const files = {};
+		const bare = /* @__PURE__ */ new Set();
+		const entryRels = new Set(Object.values(PACKAGE_ENTRIES));
+		const queue = [...entryRels];
+		const seen = new Set(queue);
+		let totalBytes = 0;
+		const processOne = async (rel) => {
+			const url = new URL(rel, base).href;
+			const body = await this.fetchBounded(url, entryRels.has(rel));
+			if (!body) return;
+			totalBytes += body.byteLength;
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error(`${name}@${version} exceeds the ${MAX_TOTAL_BYTES}-byte cache cap`);
+			const target = path.join(staging, rel);
+			assertWithin(target, staging);
+			for (const dep of this.dependenciesOf(body.toString("utf8"), url, base)) {
+				if (dep.kind === "bare") {
+					bare.add(dep.specifier);
+					continue;
+				}
+				if (seen.has(dep.rel)) continue;
+				if (seen.size >= MAX_FILES) throw new Error(`${name}@${version} imports more than ${MAX_FILES} files`);
+				seen.add(dep.rel);
+				queue.push(dep.rel);
+			}
+			files[rel] = sha256(body);
+			await mkdir(path.dirname(target), { recursive: true });
+			await writeFile(target, body);
+		};
+		const active = /* @__PURE__ */ new Set();
+		let failure;
+		while ((queue.length > 0 || active.size > 0) && failure === void 0) {
+			while (queue.length > 0 && active.size < MAX_IN_FLIGHT) {
+				const task = processOne(queue.shift()).then(() => {
+					active.delete(task);
+				}, (error) => {
+					active.delete(task);
+					failure ??= error instanceof Error ? error : new Error(String(error));
+				});
+				active.add(task);
+			}
+			if (active.size > 0) await Promise.race(active);
+		}
+		if (failure !== void 0) {
+			await Promise.allSettled(active);
+			throw failure;
+		}
+		const entries = {};
+		for (const [kind, rel] of Object.entries(PACKAGE_ENTRIES)) if (rel in files) entries[kind] = rel;
+		if (Object.keys(entries).length === 0) throw new Error(`${name}@${version} serves no document models, subgraphs or processors`);
+		return {
+			name,
+			version,
+			entries,
+			files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b))),
+			bareImports: [...bare].sort()
+		};
+	}
+	dependenciesOf(source, url, base) {
+		const [imports] = parse$1(source, url);
+		const deps = [];
+		for (const imp of imports) {
+			const kind = imp.t;
+			if (kind !== STATIC_IMPORT && kind !== DYNAMIC_IMPORT) continue;
+			const specifier = imp.n;
+			if (specifier === void 0) {
+				if (kind === DYNAMIC_IMPORT) this.logger.warn("Non-literal dynamic import in @url is not cached: @expr", url, source.slice(imp.s, imp.e));
+				continue;
+			}
+			if (isBuiltin(specifier)) continue;
+			if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || /^https?:\/\//i.test(specifier)) {
+				deps.push({
+					kind: "file",
+					rel: relativeTo(base, specifier, url)
+				});
+				continue;
+			}
+			if (/^[a-z][a-z0-9+.-]*:/i.test(specifier)) throw new Error(`${url} imports an unsupported URL: ${specifier}`);
+			deps.push({
+				kind: "bare",
+				specifier
+			});
+		}
+		return deps;
+	}
+	async fetchBounded(url, optional = false) {
+		const response = await fetch(url, { signal: AbortSignal.timeout(this.fetchTimeoutMs) });
+		if (optional && response.status === 404) {
+			await response.body?.cancel();
+			return null;
+		}
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new Error(`${url} responded ${response.status}`);
+		}
+		const declared = response.headers.get("content-length");
+		if (declared && Number(declared) > MAX_FILE_BYTES) {
+			await response.body?.cancel();
+			throw new Error(`${url} exceeds the ${MAX_FILE_BYTES}-byte file cap`);
+		}
+		if (!response.body) return Buffer.from(await response.arrayBuffer());
+		const reader = response.body.getReader();
+		const chunks = [];
+		let total = 0;
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > MAX_FILE_BYTES) {
+				await reader.cancel();
+				throw new Error(`${url} exceeds the ${MAX_FILE_BYTES}-byte file cap`);
+			}
+			chunks.push(value);
+		}
+		return Buffer.concat(chunks);
+	}
+	async linkBareImports(specifiers) {
+		const outsideUrl = pathToFileURL(path.join(path.dirname(this.cacheDir), "/")).href;
+		const linkRoot = path.join(this.cacheDir, "node_modules");
+		for (const specifier of specifiers) {
+			const pkg = packageNameOf(specifier);
+			if (!pkg || !isValidPackageName(pkg)) continue;
+			const link = path.join(linkRoot, pkg);
+			assertWithin(link, linkRoot);
+			if (packageRoot(specifier, pkg, outsideUrl)) {
+				await removeLink(link);
+				continue;
+			}
+			const fallback = packageRoot(specifier, pkg, import.meta.url);
+			if (!fallback) {
+				this.logger.warn("Registry package import @specifier resolves from neither the project nor reactor-api", specifier);
+				continue;
+			}
+			try {
+				await ensureLink(link, await realpath(fallback));
+			} catch (error) {
+				this.logger.warn("Could not link @pkg for cached registry packages: @error", pkg, error);
+			}
+		}
+	}
+};
+function sha256(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+function assertCoordinate(name, version) {
+	if (!isValidPackageName(name)) throw new Error(`Invalid registry package name: ${name}`);
+	if (!EXACT_VERSION.test(version)) throw new Error(`Invalid registry package version: ${version}`);
+}
+function assertWithin(target, root) {
+	const resolvedRoot = path.resolve(root);
+	const resolved = path.resolve(target);
+	if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) throw new Error(`Path escapes the registry cache: ${target}`);
+}
+function relativeTo(base, specifier, fromUrl) {
+	const resolved = new URL(specifier, fromUrl);
+	resolved.search = "";
+	resolved.hash = "";
+	if (!resolved.href.startsWith(base)) throw new Error(`${fromUrl} imports ${specifier}, which is outside the package`);
+	const rel = decodeURIComponent(resolved.href.slice(base.length));
+	if (rel === "" || rel === "manifest.json" || rel.includes("\\") || rel.includes("\0") || rel.split("/").some((s) => s === "" || s === "." || s === "..")) throw new Error(`${fromUrl} imports an unusable path: ${specifier}`);
+	return rel;
+}
+function parseManifest(raw) {
+	const value = JSON.parse(raw);
+	if (typeof value.name !== "string" || typeof value.version !== "string" || typeof value.entries !== "object" || value.entries === null || typeof value.files !== "object" || value.files === null || !Array.isArray(value.bareImports)) throw new Error("malformed manifest");
+	return value;
+}
+function packageNameOf(specifier) {
+	const parts = specifier.split("/");
+	if (specifier.startsWith("@")) return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+	return parts[0] || null;
+}
+function packageRoot(specifier, pkg, base) {
+	let found;
+	try {
+		found = findPackageJSON(specifier, base);
+	} catch {
+		return null;
+	}
+	if (!found) return null;
+	let dir = path.dirname(found);
+	for (let i = 0; i < 16; i++) {
+		if (dir.endsWith(`${path.sep}node_modules${path.sep}${pkg}`)) return dir;
+		if (readPackageName(path.join(dir, "package.json")) === pkg) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function readPackageName(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8")).name;
+	} catch {
+		return;
+	}
+}
+async function sweepLeftovers(parent) {
+	let names;
+	try {
+		names = await readdir(parent);
+	} catch {
+		return;
+	}
+	const now = Date.now();
+	for (const name of names) {
+		const match = LEFTOVER.exec(name);
+		if (!match) continue;
+		const pid = Number(match[1]);
+		if (pid === process.pid) continue;
+		const full = path.join(parent, name);
+		let age;
+		try {
+			age = now - (await lstat(full)).mtimeMs;
+		} catch {
+			continue;
+		}
+		if (age > ABANDONED_AFTER_MS || age > DEAD_PID_GRACE_MS && !isAlive(pid)) await rm(full, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function isAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+async function ensureLink(link, target) {
+	try {
+		if (await readlink(link) === target) return;
+	} catch {}
+	await mkdir(path.dirname(link), { recursive: true });
+	await sweepLeftovers(path.dirname(link));
+	const temp = `${link}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+	await symlink(target, temp, "junction");
+	try {
+		await rename(temp, link);
+	} catch (error) {
+		await rm(temp, { force: true });
+		throw error;
+	}
+}
+async function removeLink(link) {
+	try {
+		await readlink(link);
+	} catch {
+		return;
+	}
+	await rm(link, { force: true });
+}
+//#endregion
+//#region src/packages/http-loader.ts
 function piecesBaseUrl(registryUrl, packageName, version) {
 	return `${registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`}-/cdn/${packageName}@${version}/node/pieces/`;
 }
+function documentModelsOf(module) {
+	return Object.values(module).filter((m) => m !== null && typeof m === "object" && "documentModel" in m && m.documentModel !== null);
+}
 /**
 * Extract subgraph classes from the imported subgraphs/index.mjs module shape.
 *
@@ -6886,8 +7323,14 @@ var HttpPackageLoader = class {
 	logger = childLogger(["reactor-api", "http-loader"]);
 	name = "HttpPackageLoader";
 	documentModelLoader;
+	cache;
+	versions = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.registryUrl = options.registryUrl.endsWith("/") ? options.registryUrl : `${options.registryUrl}/`;
+		this.cache = new RegistryPackageCache({
+			registryUrl: this.registryUrl,
+			cacheDir: options.cacheDir
+		});
 		this.documentModelLoader = new HttpDocumentModelLoader(this);
 	}
 	/**
@@ -6919,39 +7362,95 @@ var HttpPackageLoader = class {
 			tag: void 0
 		};
 	}
+	resolveVersion(packageSpec) {
+		const known = this.versions.get(packageSpec);
+		if (known) return known;
+		const lookup = this.lookUpVersion(packageSpec).then((version) => {
+			if (!version) this.versions.delete(packageSpec);
+			return version;
+		});
+		this.versions.set(packageSpec, lookup);
+		return lookup;
+	}
+	async lookUpVersion(packageSpec) {
+		const { name, tag } = this.parsePackageSpec(packageSpec);
+		if (tag && EXACT_VERSION.test(tag)) return tag;
+		const version = await this.packageVersion(packageSpec);
+		if (version) return version;
+		const cached = await this.cache.cachedVersions(name);
+		if (cached.length === 1) {
+			this.logger.warn("Could not resolve a version for @package; using cached @version", packageSpec, cached[0]);
+			return cached[0];
+		}
+	}
+	/** Caches the pinned version of `packageSpec` on disk. */
+	async cachePackage(packageSpec) {
+		const { name: packageName } = this.parsePackageSpec(packageSpec);
+		if (!isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
+		const version = await this.resolveVersion(packageSpec);
+		if (!version) throw new Error(`No exact version found for ${packageSpec}`);
+		const cached = await this.cache.ensurePackage(packageName, version);
+		this.logger.verbose(`Package ${packageName}@${version} at ${cached.dir} (${cached.source})`);
+		return cached;
+	}
+	/** One entry module of the package, plus the cached file it came from. */
+	async importEntry(packageSpec, kind) {
+		const { name: packageName } = this.parsePackageSpec(packageSpec);
+		if (!isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
+		const version = await this.resolveVersion(packageSpec);
+		let cached;
+		if (version) try {
+			cached = await this.cache.ensurePackage(packageName, version);
+		} catch (error) {
+			this.logger.warn("Could not cache @package, importing it over HTTP: @error", packageSpec, error);
+		}
+		if (cached) {
+			const filePath = cached.entries[kind];
+			if (!filePath) throw Object.assign(/* @__PURE__ */ new Error(`${packageName}@${cached.version} serves no ${kind}`), { code: REGISTRY_ENTRY_ABSENT });
+			return {
+				module: await import(
+					/* @vite-ignore */
+					pathToFileURL(filePath).href
+),
+				filePath
+			};
+		}
+		const pinned = version ? `${packageName}@${version}` : packageSpec;
+		const url = `${this.registryUrl}-/cdn/${pinned}/${PACKAGE_ENTRIES[kind]}`;
+		this.logger.verbose(`Importing ${kind} from: ${url}`);
+		return { module: await import(
+			/* @vite-ignore */
+			url
+) };
+	}
+	importDocumentModels(packageSpec) {
+		return this.importEntry(packageSpec, "documentModels");
+	}
 	async loadDocumentModels(packageSpec) {
 		const { name: packageName } = this.parsePackageSpec(packageSpec);
-		if (!this.isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
-		const url = `${this.registryUrl}-/cdn/${packageSpec}/node/document-models/index.mjs`;
-		this.logger.verbose(`Importing document-models from: ${url}`);
-		const module = await import(url);
-		const models = Object.values(module).filter((m) => m !== null && typeof m === "object" && "documentModel" in m && m.documentModel !== null);
+		const { module } = await this.importDocumentModels(packageSpec);
+		const models = documentModelsOf(module);
 		this.logger.verbose(`Loaded ${models.length} document models from ${packageName}`);
 		return models;
 	}
 	async loadUpgradeManifests(packageSpec) {
 		const { name: packageName } = this.parsePackageSpec(packageSpec);
-		if (!this.isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
-		const module = await import(`${this.registryUrl}-/cdn/${packageSpec}/node/document-models/index.mjs`);
+		const { module } = await this.importDocumentModels(packageSpec);
 		const manifests = extractUpgradeManifests(module);
 		if (manifests.length > 0) this.logger.verbose(`Loaded ${manifests.length} upgrade manifests from ${packageName}`);
 		return manifests;
 	}
 	async loadSubgraphs(packageSpec) {
 		const { name: packageName } = this.parsePackageSpec(packageSpec);
-		if (!this.isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
-		const url = `${this.registryUrl}-/cdn/${packageSpec}/node/subgraphs/index.mjs`;
-		this.logger.verbose(`Importing subgraphs from: ${url}`);
-		const subgraphs = extractSubgraphsFromModule(await import(url));
+		const { module } = await this.importEntry(packageSpec, "subgraphs");
+		const subgraphs = extractSubgraphsFromModule(module);
 		this.logger.verbose(`Loaded ${subgraphs.length} subgraphs from ${packageName}`);
 		return subgraphs;
 	}
 	async loadProcessors(packageSpec) {
 		const { name: packageName } = this.parsePackageSpec(packageSpec);
-		if (!this.isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
-		const url = `${this.registryUrl}-/cdn/${packageSpec}/node/processors/index.mjs`;
-		this.logger.verbose(`Importing processors from: ${url}`);
-		const factory = (await import(url)).processorFactory;
+		const { module } = await this.importEntry(packageSpec, "processors");
+		const factory = module.processorFactory;
 		if (factory && typeof factory === "function") {
 			this.logger.verbose(`Loaded processor factory from ${packageName}`);
 			return factory;
@@ -6961,8 +7460,8 @@ var HttpPackageLoader = class {
 	}
 	async loadPieces(packageSpec) {
 		const { name: packageName } = this.parsePackageSpec(packageSpec);
-		if (!this.isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
-		const version = await this.packageVersion(packageSpec);
+		if (!isValidPackageName(packageName)) throw new Error(`Invalid package name: ${packageName}`);
+		const version = await this.resolveVersion(packageSpec);
 		if (!version) {
 			this.logger.verbose(`No package version found for: ${packageSpec}`);
 			return [];
@@ -7013,21 +7512,13 @@ var HttpPackageLoader = class {
 			return;
 		}
 	}
-	isValidPackageName(name) {
-		return /^(@[a-z0-9][-a-z0-9._]*\/)?[a-z0-9][-a-z0-9._]*$/i.test(name) && !name.includes("..") && name.length <= 214;
-	}
 };
-/**
-* Returns live modules (host-only sources): dynamically loaded models are
-* registered on the host registry but never reach executor worker threads.
-* Making them worker-executable means returning an importable source here
-* (the CDN URL as a package specifier, given process-wide https hooks).
-*/
 var HttpDocumentModelLoader = class {
 	loader;
 	logger = childLogger(["reactor-api", "http-document-model-loader"]);
 	documentTypeCache = /* @__PURE__ */ new Map();
 	packageModulesCache = /* @__PURE__ */ new Map();
+	packageFileCache = /* @__PURE__ */ new Map();
 	onModelLoaded;
 	constructor(loader) {
 		this.loader = loader;
@@ -7038,15 +7529,16 @@ var HttpDocumentModelLoader = class {
 	clearCache() {
 		this.documentTypeCache.clear();
 		this.packageModulesCache.clear();
+		this.packageFileCache.clear();
 	}
 	async load(documentType) {
 		const packageName = await this.findPackageByDocumentType(documentType);
-		let models;
-		const cachedModels = this.packageModulesCache.get(packageName);
-		if (cachedModels) models = cachedModels;
-		else {
-			models = await this.loader.loadDocumentModels(packageName);
+		let models = this.packageModulesCache.get(packageName);
+		if (!models) {
+			const { module, filePath } = await this.loader.importDocumentModels(packageName);
+			models = documentModelsOf(module);
 			this.packageModulesCache.set(packageName, models);
+			if (filePath) this.packageFileCache.set(packageName, filePath);
 		}
 		const model = models.find((m) => m.documentModel.global.id === documentType);
 		if (!model) {
@@ -7055,7 +7547,8 @@ var HttpDocumentModelLoader = class {
 		}
 		this.logger.info(`Loaded document model "${documentType}" from package "${packageName}"`);
 		if (this.onModelLoaded) this.onModelLoaded(model);
-		return model;
+		const filePath = this.packageFileCache.get(packageName);
+		return filePath ? { filePath } : model;
 	}
 	async findPackageByDocumentType(documentType) {
 		const cached = this.documentTypeCache.get(documentType);
@@ -7078,6 +7571,7 @@ var HttpDocumentModelLoader = class {
 	}
 	removeFromCache(packageName) {
 		this.packageModulesCache.delete(packageName);
+		this.packageFileCache.delete(packageName);
 		for (const [docType, pkg] of this.documentTypeCache) if (pkg === packageName) this.documentTypeCache.delete(docType);
 	}
 };
@@ -7180,6 +7674,7 @@ function isExpectedLoaderMiss(error, pkg, subPath) {
 	if (!(error instanceof Error)) return false;
 	const code = error.code;
 	if (code === "ERR_UNSUPPORTED_DIR_IMPORT") return true;
+	if (code === "ERR_REGISTRY_ENTRY_ABSENT") return true;
 	if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED" && subPath !== void 0 && error.message.includes(`'./${subPath}'`)) return true;
 	if (subPath !== void 0 && new RegExp(`^Failed to fetch \\S*/${subPath}/index\\.mjs: 404$`).test(error.message)) return true;
 	if (error.message.startsWith("Invalid package name:")) return true;
@@ -9598,4 +10093,4 @@ var PackageManagementService = class {
 export { ADMIN_USERS, ActionCandidateInputSchema, ActionContextInputSchema, ActionInputSchema, AddRelationshipDocument, AnalyticsSubgraph, AttachmentAccessFailed, AttachmentAccessService, AttachmentAccessUnavailable, AttachmentClientProvider, AuthDecision, AuthDecisionSchema, AuthEvaluationUnsupportedError, AuthService, AuthSubgraph, AuthenticationRequiredError, AuthorizationPolicy, AuthorizedAttachmentService, AuthorizedDocumentHandle, BaseSubgraph, CORE_PACKAGE_NAME, CanonicalDocumentIdResolutionError, ChannelMetaInputSchema, CreateDocumentDocument, CreateEmptyDocumentDocument, DeleteDocumentDocument, DeleteDocumentsDocument, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentOperationsFilterInputSchema, DocumentPermissionService, DocumentRelationshipFieldsFragmentDoc, EvaluateActionsDocument, FindDocumentsDocument, ForbiddenError, GetDocumentDocument, GetDocumentIncomingRelationshipEdgesDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentModelsDocument, GetDocumentOperationsDocument, GetDocumentOutgoingRelationshipEdgesDocument, GetDocumentOutgoingRelationshipsDocument, GetDocumentWithOperationsDocument, GetJobStatusDocument, GraphQLManager, HttpDocumentModelLoader, HttpPackageLoader, HttpRouteService, ImportPackageLoader, InMemoryPackageStorage, InvalidNamespaceError, JobChangesDocument, MalformedStoredOperationError, MemoryWebhookStore, MoveRelationshipDocument, MutateDocumentAsyncDocument, MutateDocumentDocument, OperationContextInputSchema, OperationInputSchema, OperationWithContextInputSchema, OperationsFilterInputSchema, PACKAGE_ROUTE_SEGMENT, PGLITE_UTC_PARSERS, PackageManagementService, PackageManager, PackagesSubgraph, PagingInputSchema, PhDocumentFieldsFragmentDoc, PollSyncEnvelopesDocument, PrivacyPermissionAdapter, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, ReactorSignerAppInputSchema, ReactorSignerInputSchema, ReactorSignerUserInputSchema, ReactorSubgraph, RefusalNotRecordedError, RelationalWebhookStore, RemoteCursorInputSchema, RemoteFilterInputSchema, RemoveRelationshipDocument, RenameDocumentDocument, SearchFilterInputSchema, SetPreferredEditorDocument, SyncEnvelopeInputSchema, SyncEnvelopeType, SyncEnvelopeTypeSchema, SyncRefusalInputSchema, SystemSubgraph, TouchChannelDocument, TouchChannelInputSchema, UpdateRelationshipDocument, ViewFilterInputSchema, WEBHOOK_SEGMENT, WS_AUTH_CLOSE_REASONS, WS_CLOSE_REASON_AUTHENTICATION_REQUIRED, WS_CLOSE_REASON_BEARER_REJECTED, WebhookService, assertAttachmentPolicyReadsAllowed, assertAuthRequiredForDocumentPermissions, assertCredentialVerifierForSource, assertHostMountPath, assertRequireAuthenticatedCallerAllowed, assertSkipCredentialVerificationAllowed, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, callerSubject, createAuthFetchMiddleware, createCanonicalDocumentIdResolver, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createRenownCredentialVerifier, createSchema, createWsAuthHandlers, decodeExplorerUrlState, definedNonNullAnySchema, driveIdFromUrl, extractSubgraphsFromModule, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getExplorerPrefix, getGitHash, getGitUrl, getSdk, getUniqueDocumentModels, getUniqueUpgradeManifests, getVersion, initAnalyticsStoreSql, initializeAndStartAPI, isDefinedNonNullAny, isExpectedLoaderMiss, isSubgraphClass, namespacePath, namespaceSegments, newWebhookToken, parseDriveUrl, parseWebhookBody, piecesBaseUrl, redactHeaders, renderGraphqlPlayground, resolvePackageName, resolveRenownConfig, verifyWebhook };
 
 //# sourceMappingURL=index.mjs.map
-//# debugId=a50faed2-4e40-54ba-873f-1808cedc1e5c
+//# debugId=65e47e18-15f4-5a67-b94b-f6e795c1eb9b