@powerhousedao/reactor-workflow 6.2.3-dev.11

package/dist/piece-registry-BWWihLyp.js

@@ -0,0 +1,1419 @@
+import { A as REACTOR_MODEL, C as jsonSafe, D as REACTOR_EXECUTE, E as REACTOR_CREATE, M as STORE_DELETE, N as STORE_GET, O as REACTOR_FIND, P as STORE_PUT, T as OUTPUT_UPDATE, a as redactMessage, c as DEFAULT_EGRESS_POLICY, g as rewriteFileRefs, i as redactError, j as REACTOR_MODELS, k as REACTOR_GET, n as containsRedactedMarker, o as rememberSecrets, r as redact, s as secretsFor, t as collectSecretValues, w as LOG_WRITE } from "./redact-C7LWgAyD.js";
+import { createRequire } from "node:module";
+import { AppConnectionType } from "@powerhousedao/pieces-framework";
+import { execFile, fork } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path, { dirname, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+import { gunzip } from "node:zlib";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { randomUUID } from "node:crypto";
+import { childLogger } from "document-model";
+//#region src/pieces/activepieces/fetch.ts
+const gunzip$1 = promisify(gunzip);
+const CDN_PIECES_URL = "https://cdn.activepieces.com/pieces/bundled/";
+const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+function cdnTarballUrl(name, version) {
+	return `${CDN_PIECES_URL}${name.replace("/", "-")}-${version}.tgz`;
+}
+function npmTarballUrl(name, version) {
+	return `${NPM_REGISTRY_URL}/${name}/-/${name.startsWith("@") ? name.split("/")[1] : name}-${version}.tgz`;
+}
+const NPM_NAME_RE = /^(@[a-z0-9][a-z0-9-_.]*\/)?[a-z0-9][a-z0-9-_.]*$/;
+const NPM_VERSION_RE = /^[A-Za-z0-9][A-Za-z0-9.+-]*$/;
+function assertValidPackageCoordinate(name, version) {
+	if (!NPM_NAME_RE.test(name)) throw new Error(`Invalid piece package name: ${name}`);
+	if (!NPM_VERSION_RE.test(version)) throw new Error(`Invalid piece package version: ${version}`);
+}
+function assertWithinCacheDir(dir, cacheDir) {
+	const root = path.resolve(cacheDir);
+	const resolved = path.resolve(dir);
+	if (resolved !== root && !resolved.startsWith(root + path.sep)) throw new Error(`Resolved piece cache path escapes cacheDir: ${dir}`);
+}
+function readString(header, offset, length) {
+	const slice = header.subarray(offset, offset + length);
+	const nul = slice.indexOf(0);
+	return slice.subarray(0, nul === -1 ? length : nul).toString("utf8");
+}
+const MAX_EXTRACTED_BYTES = 64 * 1024 * 1024;
+const MAX_COMPRESSED_BYTES = 64 * 1024 * 1024;
+async function extractTarball(tgz, dest) {
+	const tar = await gunzip$1(tgz, { maxOutputLength: MAX_EXTRACTED_BYTES }).catch((error) => {
+		throw new Error(`Failed to decompress piece bundle: ${String(error)}`);
+	});
+	let offset = 0;
+	while (offset + 512 <= tar.length) {
+		const header = tar.subarray(offset, offset + 512);
+		if (header.every((byte) => byte === 0)) break;
+		const name = readString(header, 0, 100);
+		const prefix = readString(header, 345, 155);
+		const size = parseInt(readString(header, 124, 12).trim() || "0", 8);
+		const type = String.fromCharCode(header[156]);
+		offset += 512;
+		if ((type === "0" || type === "\0" || type === "") && size >= 0) {
+			const rel = (prefix ? `${prefix}/${name}` : name).replace(/^[^/]+\//, "");
+			const target = path.resolve(dest, rel);
+			if (rel && target.startsWith(path.resolve(dest) + path.sep)) {
+				await mkdir(path.dirname(target), { recursive: true });
+				await writeFile(target, tar.subarray(offset, offset + size));
+			}
+		}
+		offset += Math.ceil(size / 512) * 512;
+	}
+}
+async function readBoundedBody(response, url) {
+	const declared = response.headers.get("content-length");
+	if (declared && Number(declared) > MAX_COMPRESSED_BYTES) throw new Error(`${url} exceeds the ${MAX_COMPRESSED_BYTES}-byte compressed size cap (Content-Length: ${declared})`);
+	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_COMPRESSED_BYTES) {
+			await reader.cancel();
+			throw new Error(`${url} exceeds the ${MAX_COMPRESSED_BYTES}-byte compressed size cap`);
+		}
+		chunks.push(value);
+	}
+	return Buffer.concat(chunks);
+}
+async function downloadTarball(name, version, timeoutMs) {
+	const sources = [{
+		source: "cdn",
+		url: cdnTarballUrl(name, version)
+	}, {
+		source: "npm",
+		url: npmTarballUrl(name, version)
+	}];
+	let lastError;
+	for (const { source, url } of sources) try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+		if (!response.ok) {
+			lastError = /* @__PURE__ */ new Error(`${url} responded ${response.status}`);
+			continue;
+		}
+		return {
+			tgz: await readBoundedBody(response, url),
+			source
+		};
+	} catch (error) {
+		lastError = error;
+	}
+	throw new Error(`Failed to fetch piece bundle ${name}@${version}: ${String(lastError)}`);
+}
+async function fetchPieceBundle(options) {
+	const { name, version, cacheDir, timeoutMs = 3e4 } = options;
+	assertValidPackageCoordinate(name, version);
+	const dir = path.join(cacheDir, `${name.replace("/", "-")}-${version}`);
+	assertWithinCacheDir(dir, cacheDir);
+	if (existsSync(path.join(dir, "package.json"))) return {
+		dir,
+		source: "cache",
+		dependencies: await readDependencies(dir),
+		installed: false
+	};
+	const { tgz, source } = await downloadTarball(name, version, timeoutMs);
+	const staging = `${dir}.tmp-${process.pid}`;
+	await rm(staging, {
+		recursive: true,
+		force: true
+	});
+	await extractTarball(tgz, staging);
+	await rm(dir, {
+		recursive: true,
+		force: true
+	});
+	try {
+		await rename(staging, dir);
+	} catch (error) {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		if (!existsSync(path.join(dir, "package.json"))) throw error;
+	}
+	return {
+		dir,
+		source,
+		dependencies: await readDependencies(dir),
+		installed: false
+	};
+}
+async function installPieceBundle(options) {
+	const { name, version, cacheDir, timeoutMs = 12e4 } = options;
+	assertValidPackageCoordinate(name, version);
+	const workspace = path.join(cacheDir, `${name.replace("/", "-")}-${version}.install`);
+	assertWithinCacheDir(workspace, cacheDir);
+	const dir = path.join(workspace, "node_modules", name);
+	if (existsSync(path.join(workspace, "ready")) && existsSync(path.join(dir, "package.json"))) return {
+		dir,
+		source: "cache",
+		dependencies: await readDependencies(dir),
+		installed: true
+	};
+	const { tgz, source } = await downloadTarball(name, version, timeoutMs);
+	await rm(workspace, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(workspace, { recursive: true });
+	await writeFile(path.join(workspace, "bundle.tgz"), tgz);
+	await writeFile(path.join(workspace, "package.json"), JSON.stringify({
+		name: "piece-workspace",
+		version: "1.0.0",
+		private: true,
+		dependencies: { [name]: "file:./bundle.tgz" }
+	}));
+	await runNpmInstall(workspace, timeoutMs);
+	await writeFile(path.join(workspace, "ready"), "true");
+	return {
+		dir,
+		source,
+		dependencies: await readDependencies(dir),
+		installed: true
+	};
+}
+const inFlight = /* @__PURE__ */ new Map();
+async function ensurePieceBundle(options) {
+	const key = `${options.cacheDir}\u0000${options.name}@${options.version}`;
+	const pending = inFlight.get(key);
+	if (pending) return pending;
+	const started = resolveBundle(options).finally(() => inFlight.delete(key));
+	inFlight.set(key, started);
+	return started;
+}
+async function resolveBundle(options) {
+	const fetched = await fetchPieceBundle(options);
+	if (Object.keys(fetched.dependencies).length === 0) return fetched;
+	return installPieceBundle(options);
+}
+async function runNpmInstall(cwd, timeoutMs) {
+	const windows = process.platform === "win32";
+	await new Promise((resolve, reject) => {
+		execFile(windows ? "npm.cmd" : "npm", [
+			"install",
+			"--ignore-scripts",
+			"--no-audit",
+			"--no-fund",
+			"--loglevel=error"
+		], {
+			cwd,
+			timeout: timeoutMs,
+			shell: windows
+		}, (error, _stdout, stderr) => {
+			if (error) reject(/* @__PURE__ */ new Error(`npm install failed in ${cwd}: ${stderr || error.message}`));
+			else resolve();
+		});
+	});
+}
+async function readDependencies(dir) {
+	const raw = await readFile(path.join(dir, "package.json"), "utf8");
+	return JSON.parse(raw).dependencies ?? {};
+}
+//#endregion
+//#region src/pieces/activepieces/resolver.ts
+function bundleResolver(options) {
+	return { async resolve(name, version) {
+		return {
+			name,
+			version,
+			bundleDir: (await ensurePieceBundle({
+				name,
+				version,
+				cacheDir: options.cacheDir,
+				...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {}
+			})).dir,
+			local: false
+		};
+	} };
+}
+function localFirstResolver(lookup, fallback) {
+	return { async resolve(name, version) {
+		const local = await lookup(name);
+		if (!local) return fallback.resolve(name, version);
+		return {
+			name,
+			version: local.version,
+			...local.entryPath ? { entryPath: local.entryPath } : {},
+			...local.bundleDir ? { bundleDir: local.bundleDir } : {},
+			local: true
+		};
+	} };
+}
+function pieceModuleRef(piece) {
+	return piece.entryPath ? { entryPath: piece.entryPath } : { bundleDir: piece.bundleDir };
+}
+//#endregion
+//#region src/pieces/activepieces/worker/transport.ts
+function defaultEntryPath() {
+	let dir = path.dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(path.join(dir, "package.json"))) {
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new Error("Could not locate package root");
+		dir = parent;
+	}
+	const entry = path.join(dir, "dist", "worker-entry.js");
+	if (!existsSync(entry)) throw new Error(`Worker entry not built at ${entry} — run pnpm build`);
+	return entry;
+}
+function createForkTransport(entryPath) {
+	const child = fork(entryPath, [], {
+		env: {},
+		execArgv: [],
+		serialization: "advanced",
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore",
+			"ipc"
+		]
+	});
+	const exitListeners = /* @__PURE__ */ new Map();
+	return {
+		get connected() {
+			return child.connected;
+		},
+		send(message) {
+			child.send(message);
+		},
+		on(event, listener) {
+			if (event === "exit") {
+				const adapted = (code, signal) => listener({
+					code,
+					signal
+				});
+				exitListeners.set(listener, adapted);
+				child.on("exit", adapted);
+				return;
+			}
+			child.on("message", listener);
+		},
+		off(event, listener) {
+			if (event === "exit") {
+				const adapted = exitListeners.get(listener);
+				if (adapted) {
+					child.off("exit", adapted);
+					exitListeners.delete(listener);
+				}
+				return;
+			}
+			child.off("message", listener);
+		},
+		kill() {
+			child.kill("SIGKILL");
+		}
+	};
+}
+//#endregion
+//#region src/pieces/activepieces/worker/host.ts
+var PieceWorkerError = class extends Error {
+	serialized;
+	constructor(serialized) {
+		super(`${serialized.name}: ${serialized.message}`);
+		this.name = "PieceWorkerError";
+		this.serialized = serialized;
+	}
+};
+var PieceWorkerTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Piece action timed out after ${timeoutMs}ms; worker was replaced`);
+		this.name = "PieceWorkerTimeoutError";
+	}
+};
+var PieceWorkerExitError = class extends Error {
+	constructor(code, signal) {
+		super(`Piece worker exited unexpectedly (code=${code}, signal=${signal})`);
+		this.name = "PieceWorkerExitError";
+	}
+};
+function serveNotify(message, handlers) {
+	const handler = handlers?.[message.method];
+	if (!handler) return;
+	try {
+		Promise.resolve(handler(message.payload)).catch(() => void 0);
+	} catch {}
+}
+var PieceWorker = class {
+	connect;
+	defaultTimeoutMs;
+	worker;
+	queue = Promise.resolve();
+	nextId = 1;
+	constructor(options = {}) {
+		const entryPath = options.entryPath;
+		this.connect = options.transport ?? (() => createForkTransport(entryPath ?? defaultEntryPath()));
+		this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
+	}
+	runAction(request, options = {}) {
+		return this.enqueue("run", request, options.timeoutMs, options);
+	}
+	resolveOptions(request, options = {}) {
+		return this.enqueue("resolve-options", request, options.timeoutMs, options);
+	}
+	checkConnection(request, options = {}) {
+		return this.enqueue("check-connection", request, options.timeoutMs);
+	}
+	describePiece(request, options = {}) {
+		return this.enqueue("describe", request, options.timeoutMs);
+	}
+	runTriggerHook(request, options = {}) {
+		return this.enqueue("trigger-hook", request, options.timeoutMs, options);
+	}
+	enqueue(type, request, timeoutMs, taps = {}) {
+		const run = this.queue.then(() => this.execute(type, request, timeoutMs ?? this.defaultTimeoutMs, taps));
+		this.queue = run.catch(() => void 0);
+		return run;
+	}
+	dispose() {
+		this.worker?.kill();
+		this.worker = void 0;
+	}
+	spawn() {
+		if (this.worker) return this.worker;
+		const worker = this.connect();
+		const forget = () => {
+			if (this.worker === worker) this.worker = void 0;
+			worker.off("exit", forget);
+		};
+		worker.on("exit", forget);
+		this.worker = worker;
+		return worker;
+	}
+	execute(type, request, timeoutMs, taps) {
+		const worker = this.spawn();
+		const id = this.nextId++;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				cleanup();
+				worker.kill();
+				this.worker = void 0;
+				reject(new PieceWorkerTimeoutError(timeoutMs));
+			}, timeoutMs);
+			const onMessage = (value) => {
+				const response = value;
+				if (response.type === "host-call" || response.type === "host-notify") return;
+				if (response.id !== id) return;
+				cleanup();
+				if (response.type === "result") resolve({
+					output: response.output,
+					touched: response.touched,
+					tlsPoisoned: response.tlsPoisoned,
+					files: response.files,
+					storeState: response.storeState,
+					schedules: response.schedules,
+					listeners: response.listeners
+				});
+				else reject(new PieceWorkerError(response.error));
+			};
+			const onExit = ({ code, signal }) => {
+				cleanup();
+				reject(new PieceWorkerExitError(code, signal));
+			};
+			const onHostCall = (value) => {
+				const message = value;
+				if (message.type === "host-call") {
+					this.serveHostCall(worker, message, taps.hostCalls);
+					return;
+				}
+				if (message.type === "host-notify") serveNotify(message, taps.notifications);
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				worker.off("message", onMessage);
+				worker.off("message", onHostCall);
+				worker.off("exit", onExit);
+			};
+			worker.on("message", onMessage);
+			worker.on("message", onHostCall);
+			worker.on("exit", onExit);
+			worker.send(jsonSafe({
+				id,
+				type,
+				request
+			}));
+		});
+	}
+	async serveHostCall(worker, message, handlers) {
+		let response;
+		try {
+			const handler = handlers?.[message.method];
+			if (!handler) throw new Error(`No host handler for "${message.method}"`);
+			response = {
+				id: message.id,
+				type: "host-result",
+				value: await handler(message.payload)
+			};
+		} catch (error) {
+			response = {
+				id: message.id,
+				type: "host-result",
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (worker.connected) worker.send(response);
+	}
+};
+//#endregion
+//#region src/pieces/activepieces/worker/pool.ts
+var PieceWorkerPoolBusyError = class extends Error {
+	constructor(size, waiting) {
+		super(`All ${size} piece workers are busy and ${waiting} runs are already waiting`);
+		this.name = "PieceWorkerPoolBusyError";
+	}
+};
+var PieceWorkerSessionClosedError = class extends Error {
+	constructor() {
+		super("This piece worker session is closed");
+		this.name = "PieceWorkerSessionClosedError";
+	}
+};
+const DEFAULT_SIZE = 4;
+var PieceWorkerSession = class {
+	worker;
+	taking;
+	held = false;
+	closed = false;
+	constructor(pool) {
+		this.pool = pool;
+	}
+	runAction(request, options) {
+		return this.request((worker) => worker.runAction(request, options));
+	}
+	resolveOptions(request, options) {
+		return this.request((worker) => worker.resolveOptions(request, options));
+	}
+	checkConnection(request, options) {
+		return this.request((worker) => worker.checkConnection(request, options));
+	}
+	describePiece(request, options) {
+		return this.request((worker) => worker.describePiece(request, options));
+	}
+	runTriggerHook(request, options) {
+		return this.request((worker) => worker.runTriggerHook(request, options));
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.pool.cancel(this);
+		this.worker?.dispose();
+		this.worker = void 0;
+		this.pool.forget(this);
+		this.giveBack();
+	}
+	dispose() {
+		this.close();
+	}
+	async request(fn) {
+		const worker = await this.take();
+		if (this.closed) throw new PieceWorkerSessionClosedError();
+		return fn(worker);
+	}
+	take() {
+		if (this.closed) return Promise.reject(new PieceWorkerSessionClosedError());
+		if (this.worker) return Promise.resolve(this.worker);
+		this.taking ??= this.acquire();
+		return this.taking;
+	}
+	async acquire() {
+		await this.pool.acquire(this);
+		this.held = true;
+		if (this.closed) {
+			this.giveBack();
+			throw new PieceWorkerSessionClosedError();
+		}
+		this.worker = this.pool.build();
+		return this.worker;
+	}
+	giveBack() {
+		if (!this.held) return;
+		this.held = false;
+		this.pool.release();
+	}
+};
+var PieceWorkerPool = class {
+	size;
+	maxQueueDepth;
+	createWorker;
+	workerOptions;
+	sessions = /* @__PURE__ */ new Set();
+	waiters = [];
+	inUse = 0;
+	disposed = false;
+	constructor(options = {}) {
+		const { size, maxQueueDepth, createWorker, ...workerOptions } = options;
+		this.size = Math.max(1, Math.trunc(size ?? DEFAULT_SIZE));
+		this.maxQueueDepth = Math.max(0, Math.trunc(maxQueueDepth ?? 0));
+		this.createWorker = createWorker ?? ((o) => new PieceWorker(o));
+		this.workerOptions = workerOptions;
+	}
+	session() {
+		if (this.disposed) throw new Error("Piece worker pool is disposed");
+		const session = new PieceWorkerSession(this);
+		this.sessions.add(session);
+		return session;
+	}
+	stats() {
+		return {
+			size: this.size,
+			active: this.inUse,
+			waiting: this.waiters.length
+		};
+	}
+	dispose() {
+		this.disposed = true;
+		for (const waiter of this.waiters.splice(0)) waiter.reject(/* @__PURE__ */ new Error("Piece worker pool is disposed"));
+		for (const session of [...this.sessions]) session.close();
+		this.sessions.clear();
+	}
+	/** @internal — a session taking its slot. */
+	acquire(session) {
+		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error("Piece worker pool is disposed"));
+		if (this.inUse < this.size) {
+			this.inUse++;
+			return Promise.resolve();
+		}
+		if (this.maxQueueDepth > 0 && this.waiters.length >= this.maxQueueDepth) return Promise.reject(new PieceWorkerPoolBusyError(this.size, this.waiters.length));
+		return new Promise((resolve, reject) => {
+			this.waiters.push({
+				session,
+				resolve,
+				reject
+			});
+		});
+	}
+	/** @internal — a session that closed while queueing. */
+	cancel(session) {
+		const index = this.waiters.findIndex((w) => w.session === session);
+		if (index < 0) return;
+		const [waiter] = this.waiters.splice(index, 1);
+		waiter.reject(new PieceWorkerSessionClosedError());
+	}
+	/** @internal — a session giving its slot back. */
+	release() {
+		const next = this.waiters.shift();
+		if (next) {
+			next.resolve();
+			return;
+		}
+		this.inUse = Math.max(0, this.inUse - 1);
+	}
+	/** @internal — one child for one session. */
+	build() {
+		return this.createWorker(this.workerOptions);
+	}
+	/** @internal — a session that closed itself. */
+	forget(session) {
+		this.sessions.delete(session);
+	}
+};
+//#endregion
+//#region src/pieces/engine/secrets.ts
+const SECRET_REF_PREFIX = "secret://v1:";
+const SECRET_ID_PATTERN = /^[0-9a-f]{32}$/;
+var SecretNotFoundError = class extends Error {
+	constructor(ref) {
+		super(`No secret found for ref "${ref}"`);
+		this.name = "SecretNotFoundError";
+	}
+};
+var SecretDeletedError = class extends Error {
+	constructor(ref) {
+		super(`Secret "${ref}" has been deleted`);
+		this.name = "SecretDeletedError";
+	}
+};
+var InvalidSecretRefError = class extends Error {
+	constructor(ref) {
+		super(`Invalid secret ref "${ref}"; expected ${SECRET_REF_PREFIX}<32 hex chars>`);
+		this.name = "InvalidSecretRefError";
+	}
+};
+function isSecretRef(ref) {
+	return ref.startsWith("secret://v1:") && SECRET_ID_PATTERN.test(ref.slice(12));
+}
+function parseSecretRef(ref) {
+	if (!isSecretRef(ref)) throw new InvalidSecretRefError(ref);
+	return ref.slice(12);
+}
+function secretRefFromId(id) {
+	if (!SECRET_ID_PATTERN.test(id)) throw new InvalidSecretRefError(id);
+	return `${SECRET_REF_PREFIX}${id}`;
+}
+var InMemorySecretProvider = class {
+	secrets;
+	constructor(secrets) {
+		this.secrets = new Map(Object.entries(secrets));
+	}
+	get(ref) {
+		const value = this.secrets.get(ref);
+		if (value === void 0) return Promise.reject(new SecretNotFoundError(ref));
+		return Promise.resolve(value);
+	}
+};
+//#endregion
+//#region src/pieces/engine/expressions.ts
+const WHOLE_EXPRESSION = /^\{\{\s*([^{}]+?)\s*\}\}$/;
+const EMBEDDED_EXPRESSION = /\{\{\s*([^{}]+?)\s*\}\}/g;
+function lookupPath(scope, path) {
+	let current = scope;
+	for (const segment of path.split(".")) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+const STRING_LITERAL = /^(['"])(.*)\1$/;
+function resolveExpression(scope, expression) {
+	for (const term of expression.split("||")) {
+		const trimmed = term.trim();
+		if (!trimmed) continue;
+		const literal = STRING_LITERAL.exec(trimmed);
+		const value = literal ? literal[2] : lookupPath(scope, trimmed);
+		if (value !== void 0 && value !== null && value !== "") return value;
+	}
+}
+function interpolate(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+function resolveExpressions(value, scope) {
+	if (typeof value === "string") {
+		const whole = WHOLE_EXPRESSION.exec(value);
+		if (whole) return resolveExpression(scope, whole[1]);
+		return value.replaceAll(EMBEDDED_EXPRESSION, (_, path) => interpolate(resolveExpression(scope, path)));
+	}
+	if (Array.isArray(value)) return value.map((item) => resolveExpressions(item, scope));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, resolveExpressions(entry, scope)]));
+	return value;
+}
+function evaluateCondition(condition, scope) {
+	const resolved = resolveExpressions(condition, scope);
+	if (resolved === "false" || resolved === "0") return false;
+	return Boolean(resolved);
+}
+//#endregion
+//#region src/pieces/engine/connections.ts
+var ConnectionNotFoundError = class extends Error {
+	constructor(connectionId) {
+		super(`No connection registered for id "${connectionId}"`);
+		this.name = "ConnectionNotFoundError";
+	}
+};
+var ConnectionNotBoundError = class extends Error {
+	constructor(connectionId) {
+		super(`Connection "${connectionId}" is not bound to this workflow`);
+		this.name = "ConnectionNotBoundError";
+	}
+};
+var UnsupportedAuthTypeError = class extends Error {
+	constructor(authType) {
+		super(`Auth type "${authType}" is not supported yet`);
+		this.name = "UnsupportedAuthTypeError";
+	}
+};
+async function resolveSecrets(source, secrets) {
+	const entries = await Promise.all((source.secretRefs ?? []).map(async ({ name, ref }) => [name, await secrets.get(ref)]));
+	return Object.fromEntries(entries);
+}
+async function shapeConnection(source, secrets) {
+	const resolved = await resolveSecrets(source, secrets);
+	return {
+		auth: shapeAuth(source, resolved),
+		secretValues: Object.values(resolved)
+	};
+}
+function shapeAuth(source, resolved) {
+	switch (source.authType) {
+		case "NONE": return;
+		case "SECRET_TEXT": {
+			const values = Object.values(resolved);
+			if (values.length !== 1) throw new Error(`SECRET_TEXT connection must have exactly one secret ref, got ${values.length}`);
+			return {
+				type: AppConnectionType.SECRET_TEXT,
+				secret_text: values[0]
+			};
+		}
+		case "BASIC_AUTH": {
+			const props = {
+				...source.config,
+				...resolved
+			};
+			return {
+				type: AppConnectionType.BASIC_AUTH,
+				username: props.username,
+				password: props.password
+			};
+		}
+		case "CUSTOM_AUTH": return {
+			type: AppConnectionType.CUSTOM_AUTH,
+			props: {
+				...source.config,
+				...resolved
+			}
+		};
+		default: throw new UnsupportedAuthTypeError(source.authType);
+	}
+}
+var StaticConnectionResolver = class {
+	connections;
+	constructor(connections, secrets) {
+		this.secrets = secrets;
+		this.connections = new Map(Object.entries(connections));
+	}
+	resolve(connectionId) {
+		return this.resolveWithSecrets(connectionId).then((resolved) => resolved.auth);
+	}
+	resolveWithSecrets(connectionId) {
+		const source = this.connections.get(connectionId);
+		if (!source) return Promise.reject(new ConnectionNotFoundError(connectionId));
+		return shapeConnection(source, this.secrets);
+	}
+};
+function declaredConnectionIds(definition) {
+	const declared = /* @__PURE__ */ new Set();
+	const declare = (connectionId) => {
+		if (connectionId && !connectionId.includes("{{")) declared.add(connectionId);
+	};
+	declare(definition.trigger?.connectionId);
+	for (const step of definition.steps) declare(step.connectionId);
+	return declared;
+}
+var BoundConnectionResolver = class {
+	resolveWithSecrets;
+	constructor(inner, binding, onRefused) {
+		this.inner = inner;
+		this.binding = binding;
+		this.onRefused = onRefused;
+		const withSecrets = inner.resolveWithSecrets?.bind(inner);
+		if (!withSecrets) return;
+		this.resolveWithSecrets = (connectionId, request) => this.bound(connectionId, request) ? withSecrets(connectionId, request) : Promise.reject(new ConnectionNotBoundError(connectionId));
+	}
+	resolve(connectionId, request) {
+		if (!this.bound(connectionId, request)) return Promise.reject(new ConnectionNotBoundError(connectionId));
+		return this.inner.resolve(connectionId, request);
+	}
+	bound(connectionId, request) {
+		if (this.binding()?.has(connectionId)) return true;
+		this.onRefused?.(connectionId, request);
+		return false;
+	}
+};
+//#endregion
+//#region src/pieces/engine/blocks.ts
+var UnknownBlockTypeError = class extends Error {
+	constructor(blockType) {
+		super(`No executor registered for block type "${blockType}"`);
+		this.name = "UnknownBlockTypeError";
+	}
+};
+var TriggerBlockAsStepError = class extends Error {
+	constructor(blockType) {
+		super(`Trigger block type "${blockType}" cannot run as a workflow step`);
+		this.name = "TriggerBlockAsStepError";
+	}
+};
+var CoreBlockExecutor = class {
+	static handles(blockType) {
+		return blockType.startsWith("core#");
+	}
+	execute(execution) {
+		if (execution.blockType === "core#branch") {
+			const { condition, equals } = execution.config;
+			const normalize = (value) => (typeof value === "string" ? value : value === void 0 || value === null ? "" : JSON.stringify(value)).trim().toLowerCase();
+			const taken = typeof equals === "string" ? normalize(condition) === normalize(equals) : Boolean(condition) && condition !== "false" && condition !== "0";
+			return Promise.resolve({
+				output: { condition: condition ?? null },
+				port: taken ? "true" : "false"
+			});
+		}
+		if (execution.blockType === "core#assert") return this.assert(execution);
+		return Promise.reject(new UnknownBlockTypeError(execution.blockType));
+	}
+	assert(execution) {
+		const { value, rejectValues, allowValues, allowEmpty, message } = execution.config;
+		const trimmed = (typeof value === "string" ? value : value === void 0 || value === null ? "" : JSON.stringify(value)).trim();
+		const fail = (reason) => Promise.reject(new Error(typeof message === "string" && message ? message : `core#assert: ${reason}`));
+		if (!trimmed && allowEmpty !== true) return fail("value is empty");
+		const normalizeList = (entries) => (typeof entries === "string" ? [entries] : Array.isArray(entries) ? entries : []).map((entry) => String(entry).trim().toLowerCase()).filter(Boolean);
+		if (normalizeList(rejectValues).includes(trimmed.toLowerCase())) return fail(`value is a rejected value ("${trimmed}")`);
+		const allowed = normalizeList(allowValues);
+		if (allowed.length > 0 && !allowed.includes(trimmed.toLowerCase())) return fail(`value "${trimmed}" is not one of the allowed values (${allowed.join(", ")})`);
+		return Promise.resolve({
+			output: { value },
+			port: "next"
+		});
+	}
+};
+const ATTACHMENT_REF = /^attachment:\/\//i;
+function collectRefs(value, found) {
+	if (typeof value === "string") {
+		if (ATTACHMENT_REF.test(value)) found.add(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) collectRefs(entry, found);
+		return;
+	}
+	if (typeof value === "object" && value !== null) for (const entry of Object.values(value)) collectRefs(entry, found);
+}
+function storeScopeOf(payload) {
+	return payload?.scope === "PROJECT" ? "PROJECT" : "FLOW";
+}
+function storeKeyOf(payload) {
+	const key = payload?.key;
+	if (typeof key !== "string" || key === "") throw new Error("Store call carried no key");
+	return key;
+}
+function reactorInput(payload) {
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) throw new Error("Reactor call carried no input object");
+	return payload;
+}
+function requiredString(payload, field) {
+	const value = payload[field];
+	if (typeof value !== "string" || value === "") throw new Error(`Reactor call carried no "${field}"`);
+	return value;
+}
+function optionalString(payload, field) {
+	const value = payload[field];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function reactorActions(payload) {
+	const actions = payload.actions;
+	if (!Array.isArray(actions) || actions.length === 0) throw new Error("Reactor call carried no actions");
+	return actions.map((entry, index) => {
+		const action = entry;
+		if (!action || typeof action.type !== "string") throw new Error(`Reactor call: actions[${index}] needs a string "type"`);
+		return {
+			type: action.type,
+			input: action.input,
+			...typeof action.scope === "string" ? { scope: action.scope } : {}
+		};
+	});
+}
+const MAX_FIND_LIMIT = 100;
+function findLimit(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return Math.min(Math.max(Math.floor(value), 1), MAX_FIND_LIMIT);
+}
+function findMatch(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	const path = record.path;
+	const wanted = record.value;
+	if (typeof path !== "string" || path.trim() === "") return void 0;
+	if (typeof wanted !== "string") return void 0;
+	return {
+		path: path.trim(),
+		value: wanted
+	};
+}
+function reactorHandlers(port) {
+	return {
+		[REACTOR_MODELS]: () => port.models(),
+		[REACTOR_MODEL]: (payload) => port.model(requiredString(reactorInput(payload), "documentType")),
+		[REACTOR_GET]: (payload) => {
+			const input = reactorInput(payload);
+			return port.get({
+				documentId: requiredString(input, "documentId"),
+				...optionalString(input, "branch") ? { branch: optionalString(input, "branch") } : {}
+			});
+		},
+		[REACTOR_FIND]: (payload) => {
+			const input = reactorInput(payload);
+			return port.find({
+				...optionalString(input, "documentType") ? { documentType: optionalString(input, "documentType") } : {},
+				...optionalString(input, "parentId") ? { parentId: optionalString(input, "parentId") } : {},
+				...findLimit(input.limit) !== void 0 ? { limit: findLimit(input.limit) } : {},
+				...findMatch(input.match) ? { match: findMatch(input.match) } : {},
+				...input.withState === true ? { withState: true } : {}
+			});
+		},
+		[REACTOR_CREATE]: (payload) => {
+			const input = reactorInput(payload);
+			return port.create({
+				documentType: requiredString(input, "documentType"),
+				...optionalString(input, "name") ? { name: optionalString(input, "name") } : {},
+				...optionalString(input, "parentId") ? { parentId: optionalString(input, "parentId") } : {}
+			});
+		},
+		[REACTOR_EXECUTE]: (payload) => {
+			const input = reactorInput(payload);
+			return port.execute({
+				documentId: requiredString(input, "documentId"),
+				...optionalString(input, "branch") ? { branch: optionalString(input, "branch") } : {},
+				actions: reactorActions(input)
+			});
+		}
+	};
+}
+function storeHandlers(port) {
+	return {
+		[STORE_GET]: (payload) => port.get(storeKeyOf(payload), storeScopeOf(payload)),
+		[STORE_PUT]: async (payload) => {
+			await port.put(storeKeyOf(payload), payload.value, storeScopeOf(payload));
+			return null;
+		},
+		[STORE_DELETE]: async (payload) => {
+			await port.delete(storeKeyOf(payload), storeScopeOf(payload));
+			return null;
+		}
+	};
+}
+function stepTaps(options, execution, values) {
+	const { onPieceLog, onPartialOutput } = options;
+	if (!onPieceLog && !onPartialOutput) return void 0;
+	const handlers = {};
+	if (onPieceLog) handlers[LOG_WRITE] = (payload) => {
+		const entry = payload;
+		return onPieceLog({
+			...entry,
+			message: redactMessage(entry.message, { values })
+		}, execution);
+	};
+	if (onPartialOutput) handlers[OUTPUT_UPDATE] = (payload) => onPartialOutput(payload, execution);
+	return handlers;
+}
+function redactThrown(error, values) {
+	if (error instanceof Error) {
+		error.message = redactMessage(error.message, { values });
+		if (error.stack) error.stack = redactMessage(error.stack, { values });
+		return rememberSecrets(error, values);
+	}
+	return rememberSecrets(redactError(error, { values }), values);
+}
+const TRIGGER_FRAGMENT = "trigger:";
+function parseBlockType(blockType, packages = {}) {
+	const separator = blockType.lastIndexOf("#");
+	if (separator <= 0) return void 0;
+	const packageSpec = blockType.slice(0, separator);
+	const fragment = blockType.slice(separator + 1);
+	const isTrigger = fragment.startsWith(TRIGGER_FRAGMENT);
+	const name = isTrigger ? fragment.slice(8) : fragment;
+	if (!name) return void 0;
+	const kind = isTrigger ? "trigger" : "action";
+	const versionAt = packageSpec.indexOf("@", 1);
+	if (versionAt > 0) return {
+		packageName: packageSpec.slice(0, versionAt),
+		version: packageSpec.slice(versionAt + 1),
+		kind,
+		name
+	};
+	const version = packages[packageSpec];
+	if (!version) return void 0;
+	return {
+		packageName: packageSpec,
+		version,
+		kind,
+		name
+	};
+}
+var ActivepiecesBlockExecutor = class {
+	own;
+	resolver;
+	constructor(options) {
+		this.options = options;
+		this.resolver = options.resolver ?? bundleResolver({ cacheDir: options.cacheDir });
+	}
+	worker() {
+		const supplied = this.options.worker;
+		if (typeof supplied === "function") {
+			const worker = supplied();
+			if (worker) return worker;
+		} else if (supplied) return supplied;
+		return this.own ??= new PieceWorker();
+	}
+	packages() {
+		const supplied = this.options.packages;
+		return Promise.resolve(typeof supplied === "function" ? supplied() : supplied ?? {});
+	}
+	async execute(execution) {
+		const parsed = parseBlockType(execution.blockType, await this.packages());
+		if (!parsed) throw new UnknownBlockTypeError(execution.blockType);
+		if (parsed.kind !== "action") throw new TriggerBlockAsStepError(execution.blockType);
+		const stagingDir = this.options.stagingRoot ? path.join(this.options.stagingRoot, randomUUID()) : void 0;
+		let redactValues = [];
+		try {
+			const piece = await this.resolver.resolve(parsed.packageName, parsed.version);
+			const connection = await this.resolveConnection(execution.connectionId, {
+				blockType: execution.blockType,
+				piecePackage: parsed.packageName,
+				stepId: execution.step.id,
+				stepKey: execution.step.key
+			});
+			const auth = connection?.auth;
+			redactValues = connection?.secretValues ?? [];
+			const timeoutMs = execution.step.timeoutSeconds ? execution.step.timeoutSeconds * 1e3 : this.options.defaultTimeoutMs;
+			const stagedInputs = await this.stageInputs(execution.config, stagingDir);
+			const pieceStore = this.options.pieceStore;
+			const notifications = stepTaps(this.options, execution, redactValues);
+			const egress = this.options.egress === void 0 ? DEFAULT_EGRESS_POLICY : this.options.egress;
+			const reactor = piece.local ? this.options.reactor : void 0;
+			const result = await this.worker().runAction({
+				...pieceModuleRef(piece),
+				actionName: parsed.name,
+				propsValue: execution.config,
+				auth,
+				...redactValues.length > 0 ? { redactValues } : {},
+				...stagingDir ? { stagingDir } : {},
+				...stagedInputs ? { stagedInputs } : {},
+				...pieceStore ? { durableStore: true } : {},
+				...reactor ? { reactorAccess: true } : {},
+				...this.options.onPieceLog ? { captureLogs: true } : {},
+				...this.options.onPartialOutput ? { liveOutput: true } : {},
+				...egress ? { egress } : {}
+			}, {
+				...timeoutMs ? { timeoutMs } : {},
+				...pieceStore || reactor ? { hostCalls: {
+					...pieceStore ? storeHandlers(pieceStore) : {},
+					...reactor ? reactorHandlers(reactor) : {}
+				} } : {},
+				...notifications ? { notifications } : {}
+			});
+			return {
+				output: await this.ingestFiles(result.output, result.files),
+				redactValues
+			};
+		} catch (error) {
+			throw redactThrown(error, redactValues);
+		} finally {
+			if (stagingDir) await rm(stagingDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async resolveConnection(connectionId, request) {
+		const connections = this.options.connections;
+		if (!connectionId || !connections) return void 0;
+		if (connections.resolveWithSecrets) return connections.resolveWithSecrets(connectionId, request);
+		const auth = await connections.resolve(connectionId, request);
+		return {
+			auth,
+			secretValues: [...collectSecretValues(auth)]
+		};
+	}
+	async stageInputs(config, stagingDir) {
+		const port = this.options.attachments;
+		if (!stagingDir || !port) return void 0;
+		const refs = /* @__PURE__ */ new Set();
+		collectRefs(config, refs);
+		if (refs.size === 0) return void 0;
+		await mkdir(stagingDir, { recursive: true });
+		const staged = [];
+		let index = 0;
+		for (const ref of refs) {
+			const destPath = path.join(stagingDir, `in-${index++}`);
+			const meta = await port.read(ref, destPath);
+			staged.push({
+				ref,
+				path: destPath,
+				...meta
+			});
+		}
+		return staged;
+	}
+	async ingestFiles(output, files) {
+		if (!files || files.length === 0) return output;
+		const port = this.options.attachments;
+		if (!port) throw new Error(`The action wrote ${files.length} file(s) through ctx.files, but no attachment store is configured for this reactor`);
+		const refs = /* @__PURE__ */ new Map();
+		for (const file of files) refs.set(file.token, await port.write({
+			path: file.path,
+			fileName: file.fileName,
+			size: file.size,
+			contentType: file.contentType
+		}));
+		return rewriteFileRefs(output, refs);
+	}
+	dispose() {
+		this.own?.dispose();
+		this.own = void 0;
+	}
+};
+var CompositeBlockExecutor = class {
+	core = new CoreBlockExecutor();
+	constructor(pieces, handlers = {}) {
+		this.pieces = pieces;
+		this.handlers = handlers;
+	}
+	execute(execution) {
+		const handler = this.handlers[execution.blockType];
+		if (handler) return handler.execute(execution);
+		if (CoreBlockExecutor.handles(execution.blockType)) return this.core.execute(execution);
+		return this.pieces.execute(execution);
+	}
+};
+//#endregion
+//#region src/pieces/engine/coordinator.ts
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function journaled(value, values) {
+	return value === void 0 ? void 0 : redact(value, { values });
+}
+async function runWorkflow(options) {
+	const { definition, executor } = options;
+	const scope = {
+		trigger: { payload: options.triggerPayload },
+		steps: {},
+		variables: Object.fromEntries((definition.variables ?? []).map((v) => [v.key, v.value ?? null]))
+	};
+	const records = /* @__PURE__ */ new Map();
+	const edgeDecisions = /* @__PURE__ */ new Map();
+	let runFailed;
+	let executedCount = 0;
+	const journal = async (record) => {
+		if (!options.onStep) return;
+		const ordinal = executedCount++;
+		try {
+			await options.onStep(record, ordinal);
+		} catch {}
+	};
+	const decideOutgoing = (sourceId, port) => {
+		for (const edge of definition.edges) {
+			if (edge.from !== sourceId) continue;
+			const taken = port !== void 0 && edge.port === port && (!edge.condition || evaluateCondition(edge.condition, scope));
+			edgeDecisions.set(edge.id, taken);
+		}
+	};
+	if (definition.trigger) decideOutgoing(definition.trigger.id, "next");
+	const inboundEdges = (step) => definition.edges.filter((edge) => edge.to === step.id);
+	const isEntryStep = (step) => !definition.trigger && inboundEdges(step).length === 0;
+	const skipStep = (step) => {
+		records.set(step.id, {
+			stepId: step.id,
+			key: step.key,
+			blockType: step.blockType,
+			status: "SKIPPED"
+		});
+		decideOutgoing(step.id, void 0);
+	};
+	const refuseReplay = (step) => {
+		const error = `Journaled output of step "${step.key}" was redacted and cannot be replayed; fire the workflow again instead of rerunning it`;
+		records.set(step.id, {
+			stepId: step.id,
+			key: step.key,
+			blockType: step.blockType,
+			status: "FAILED",
+			error
+		});
+		runFailed = error;
+	};
+	const executeStep = async (step) => {
+		const replay = options.completedSteps?.get(step.id);
+		if (replay) {
+			if (containsRedactedMarker(replay.output)) {
+				refuseReplay(step);
+				return;
+			}
+			const port = replay.port ?? "next";
+			const record = {
+				stepId: step.id,
+				key: step.key,
+				blockType: step.blockType,
+				status: "REPLAYED",
+				output: replay.output,
+				port
+			};
+			records.set(step.id, record);
+			await journal(record);
+			scope.steps[step.key] = { output: replay.output };
+			decideOutgoing(step.id, port);
+			return;
+		}
+		const input = resolveExpressions(step.config, scope);
+		try {
+			const result = await executor.execute({
+				blockType: step.blockType,
+				config: input,
+				connectionId: step.connectionId,
+				step
+			});
+			const port = result.port ?? "next";
+			const record = {
+				stepId: step.id,
+				key: step.key,
+				blockType: step.blockType,
+				status: "SUCCEEDED",
+				input: journaled(input, result.redactValues),
+				output: journaled(result.output, result.redactValues),
+				port
+			};
+			records.set(step.id, record);
+			await journal(record);
+			scope.steps[step.key] = { output: result.output };
+			decideOutgoing(step.id, port);
+		} catch (error) {
+			const values = secretsFor(error);
+			const detail = redactMessage(errorMessage(error), { values });
+			const record = {
+				stepId: step.id,
+				key: step.key,
+				blockType: step.blockType,
+				status: "FAILED",
+				input: journaled(input, values),
+				error: detail
+			};
+			records.set(step.id, record);
+			await journal(record);
+			decideOutgoing(step.id, "error");
+			if (!definition.edges.some((edge) => edge.from === step.id && edgeDecisions.get(edge.id))) runFailed = `Step "${step.key}" failed: ${detail}`;
+		}
+	};
+	let progressed = true;
+	while (progressed && !runFailed) {
+		progressed = false;
+		for (const step of definition.steps) {
+			if (records.has(step.id)) continue;
+			const inbound = inboundEdges(step);
+			if (isEntryStep(step)) {
+				await executeStep(step);
+				progressed = true;
+				if (runFailed) break;
+				continue;
+			}
+			if (inbound.length === 0) continue;
+			if (!inbound.every((edge) => edgeDecisions.has(edge.id))) continue;
+			if (inbound.some((edge) => edgeDecisions.get(edge.id))) await executeStep(step);
+			else skipStep(step);
+			progressed = true;
+			if (runFailed) break;
+		}
+	}
+	for (const step of definition.steps) if (!records.has(step.id)) skipStep(step);
+	const steps = definition.steps.map((step) => records.get(step.id));
+	return runFailed ? {
+		status: "FAILED",
+		steps,
+		error: runFailed
+	} : {
+		status: "SUCCEEDED",
+		steps
+	};
+}
+//#endregion
+//#region src/reactor/piece-registry.ts
+const logger = childLogger(["workflow", "piece-registry"]);
+const MANIFEST_CANDIDATES = ["dist/node/pieces/index.mjs", "pieces/index.ts"];
+const require = createRequire(import.meta.url);
+function packageRoot(packageName) {
+	try {
+		return dirname(require.resolve(`${packageName}/package.json`));
+	} catch {}
+	try {
+		let dir = dirname(require.resolve(packageName));
+		while (!existsSync(join(dir, "package.json"))) {
+			const parent = dirname(dir);
+			if (parent === dir) return void 0;
+			dir = parent;
+		}
+		return dir;
+	} catch {
+		return;
+	}
+}
+function configuredPackages(projectRoot) {
+	const file = join(projectRoot, "powerhouse.config.json");
+	try {
+		return (JSON.parse(readFileSync(file, "utf8")).packages ?? []).map((entry) => entry.packageName).filter((name) => typeof name === "string" && name !== "");
+	} catch {
+		return [];
+	}
+}
+async function readManifest(root) {
+	for (const candidate of MANIFEST_CANDIDATES) {
+		const file = join(root, candidate);
+		if (!existsSync(file)) continue;
+		const module = await import(
+			/* @vite-ignore */
+			pathToFileURL(file).href
+);
+		const declared = module.pieces ?? module.default;
+		if (Array.isArray(declared)) return declared;
+		logger.warn(`${file} exports no "pieces" array; ignoring it`);
+		return [];
+	}
+	return [];
+}
+function locate(declared, root, source) {
+	const where = declared.entry ?? declared.bundle;
+	if (!where) {
+		logger.warn(`Piece "${declared.name}" from ${source} declares no bundle or entry`);
+		return;
+	}
+	const path = isAbsolute(where) ? where : join(root, where);
+	if (!(declared.entry ? existsSync(path) : existsSync(join(path, "package.json")))) {
+		logger.warn(`Piece "${declared.name}" from ${source} is declared but not built at ${path}`);
+		return;
+	}
+	return {
+		name: declared.name,
+		version: declared.version,
+		...declared.entry ? { entryPath: path } : { bundleDir: path }
+	};
+}
+var PieceRegistry = class {
+	byName = /* @__PURE__ */ new Map();
+	loading;
+	load(projectRoot = process.cwd()) {
+		return this.loading = this.discover(projectRoot);
+	}
+	async discover(projectRoot) {
+		const found = /* @__PURE__ */ new Map();
+		const sources = [{
+			source: "this project",
+			root: projectRoot
+		}, ...configuredPackages(projectRoot).flatMap((name) => {
+			const root = packageRoot(name);
+			if (!root) {
+				logger.warn(`Package "${name}" is configured but not resolvable`);
+				return [];
+			}
+			return [{
+				source: name,
+				root
+			}];
+		})];
+		for (const { source, root } of sources) {
+			let declared;
+			try {
+				declared = await readManifest(root);
+			} catch (error) {
+				logger.warn(`Could not read the pieces of ${source}: ${String(error)}`);
+				continue;
+			}
+			for (const entry of declared) {
+				if (found.has(entry.name)) continue;
+				const piece = locate(entry, root, source);
+				if (piece) found.set(entry.name, piece);
+			}
+		}
+		this.byName = found;
+		if (found.size > 0) logger.info(`Loaded ${found.size} package piece(s): ${[...found.keys()].join(", ")}`);
+	}
+	ready(projectRoot = process.cwd()) {
+		return this.loading ??= this.discover(projectRoot);
+	}
+	lookup = (name) => this.byName.get(name);
+	entries() {
+		return [...this.byName.values()];
+	}
+	versions() {
+		return Object.fromEntries([...this.byName.values()].map((piece) => [piece.name, piece.version]));
+	}
+	reset() {
+		this.byName = /* @__PURE__ */ new Map();
+		this.loading = void 0;
+	}
+};
+const packagePieces = new PieceRegistry();
+//#endregion
+export { pieceModuleRef as C, localFirstResolver as S, fetchPieceBundle as T, secretRefFromId as _, CompositeBlockExecutor as a, PieceWorkerError as b, storeHandlers as c, declaredConnectionIds as d, shapeConnection as f, parseSecretRef as g, SecretNotFoundError as h, ActivepiecesBlockExecutor as i, BoundConnectionResolver as l, SecretDeletedError as m, packagePieces as n, parseBlockType as o, InMemorySecretProvider as p, runWorkflow as r, reactorHandlers as s, PieceRegistry as t, StaticConnectionResolver as u, PieceWorkerPool as v, ensurePieceBundle as w, PieceWorkerTimeoutError as x, PieceWorker as y };
+
+//# sourceMappingURL=piece-registry-BWWihLyp.js.map