openpond 0.1.1 → 0.2.1

package/dist/chunks/chunk-DLQQIWN2.js

@@ -1,648 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  external_exports
-} from "./chunk-FQS2QL5F.js";
-
-// ../../packages/sdk/dist/actions-local.js
-import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import { promises as fs5 } from "node:fs";
-import path5 from "node:path";
-import { promises as fs4 } from "node:fs";
-import path4 from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { build } from "esbuild";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { promises as fs2 } from "node:fs";
-import path2 from "node:path";
-import { createHash } from "node:crypto";
-import { promises as fs3 } from "node:fs";
-import { createRequire } from "node:module";
-import path3 from "node:path";
-function isProjectActionDefinition(value) {
-  return Boolean(
-    value && typeof value === "object" && value.kind === "openpond-project-action" && typeof value.id === "string" && typeof value.run === "function"
-  );
-}
-function projectActionJsonSchema(schema) {
-  return external_exports.toJSONSchema(schema, { unrepresentable: "any" });
-}
-function collectProjectActions(modules) {
-  const actions = [];
-  const seenObjects = /* @__PURE__ */ new Set();
-  const visit = (value) => {
-    if (seenObjects.has(value)) return;
-    if (value && (typeof value === "object" || typeof value === "function")) seenObjects.add(value);
-    if (isProjectActionDefinition(value)) {
-      actions.push(value);
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach(visit);
-      return;
-    }
-    if (value && typeof value === "object") Object.values(value).forEach(visit);
-  };
-  modules.forEach(visit);
-  const byId = /* @__PURE__ */ new Map();
-  for (const action of actions) {
-    if (byId.has(action.id)) throw new Error(`Duplicate Project Action id: ${action.id}`);
-    byId.set(action.id, action);
-  }
-  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
-}
-function createProjectActionRegistry(actions) {
-  return {
-    schemaVersion: "openpond.projectActionRegistry.v1",
-    actions: actions.map(toCatalogEntry)
-  };
-}
-function toCatalogEntry(action) {
-  return {
-    id: action.id,
-    sourceActionId: action.id,
-    name: action.id,
-    label: action.label,
-    description: action.description,
-    visibility: "default",
-    inputSchema: projectActionJsonSchema(action.inputSchema),
-    outputSchema: projectActionJsonSchema(action.outputSchema),
-    approvalPolicy: {
-      ...action.approval,
-      required: action.approval.mode === "always" || action.approval.mode === "sensitive" || action.approval.mode === "writes" && action.behavior === "write",
-      risk: action.behavior
-    },
-    artifactPolicy: {
-      outputArtifacts: [],
-      persistRunSummary: true,
-      persistTrace: true
-    },
-    setupRequirements: [...action.setup],
-    mcp: { enabled: false },
-    schedulePolicy: { enabled: false, allowAdHoc: true },
-    trace: { name: action.id, namespace: "project-actions" },
-    implementation: {
-      type: "openpond-project-action",
-      actionId: action.id,
-      behavior: action.behavior,
-      timeoutMs: action.timeoutMs,
-      concurrency: action.concurrency
-    },
-    invokesModel: action.invokesModel
-  };
-}
-var PROJECT_ACTION_CONFIG_PATH = "openpond/project-actions.json";
-var connectionSchema = external_exports.object({
-  values: external_exports.record(external_exports.string(), external_exports.unknown()).optional().default({}),
-  environment: external_exports.record(external_exports.string(), external_exports.string().trim().min(1)).optional().default({})
-}).strict();
-var configSchema = external_exports.object({
-  sourceDirectory: external_exports.string().trim().min(1).optional(),
-  outputDirectory: external_exports.string().trim().min(1).optional(),
-  environment: external_exports.record(external_exports.string(), external_exports.string().trim().min(1)).optional().default({}),
-  connections: external_exports.record(external_exports.string(), connectionSchema).optional().default({})
-}).strict();
-async function loadProjectActionConfiguration(projectRoot) {
-  const resolvedRoot = path.resolve(projectRoot);
-  const configPath = path.join(resolvedRoot, PROJECT_ACTION_CONFIG_PATH);
-  const raw = await fs.readFile(configPath, "utf8").catch((error) => {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  });
-  if (raw === null) return configSchema.parse({});
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`${PROJECT_ACTION_CONFIG_PATH} is not valid JSON: ${message}`);
-  }
-  return configSchema.parse(value);
-}
-function resolveProjectActionRuntime(config, hostEnvironment = process.env) {
-  const environment = {};
-  for (const [runtimeName, hostName] of Object.entries(config.environment)) {
-    const value = hostEnvironment[hostName];
-    if (value !== void 0) environment[runtimeName] = value;
-  }
-  const connections = {};
-  for (const [name, descriptor] of Object.entries(config.connections)) {
-    const value = { ...descriptor.values };
-    for (const [property, hostName] of Object.entries(descriptor.environment)) {
-      const environmentValue = hostEnvironment[hostName];
-      if (environmentValue !== void 0) value[property] = environmentValue;
-    }
-    connections[name] = value;
-  }
-  return { environment, connections };
-}
-var ACTION_FILE = /\.(?:[cm]?[jt]s)$/i;
-var IGNORED_FILE = /(?:\.d\.ts|\.test\.[cm]?[jt]s|\.spec\.[cm]?[jt]s)$/i;
-async function discoverProjectActionFiles(input) {
-  const projectRoot = path2.resolve(input.projectRoot);
-  const sourceRoot = path2.resolve(projectRoot, input.sourceDirectory ?? "openpond/actions");
-  if (!isWithin(projectRoot, sourceRoot)) {
-    throw new Error("Project Action source directory must stay inside the Project root.");
-  }
-  const stats = await fs2.stat(sourceRoot).catch(() => null);
-  if (!stats?.isDirectory()) {
-    throw new Error(`Project Action source directory does not exist: ${sourceRoot}`);
-  }
-  const files = await walk(sourceRoot);
-  const actions = files.filter((file) => ACTION_FILE.test(file) && !IGNORED_FILE.test(file)).map((file) => path2.relative(projectRoot, file).split(path2.sep).join("/")).sort();
-  if (actions.length === 0) {
-    throw new Error(`No Project Action files were found under ${sourceRoot}.`);
-  }
-  return { projectRoot, sourceRoot, files: actions };
-}
-async function walk(directory) {
-  const entries = await fs2.readdir(directory, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const target = path2.join(directory, entry.name);
-    if (entry.isDirectory()) files.push(...await walk(target));
-    else if (entry.isFile()) files.push(target);
-  }
-  return files;
-}
-function isWithin(root, target) {
-  const relative = path2.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
-}
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function canonicalJson(value) {
-  return `${JSON.stringify(sortValue(value), null, 2)}
-`;
-}
-function sortValue(value) {
-  if (Array.isArray(value)) return value.map(sortValue);
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(
-    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)])
-  );
-}
-async function validateProjectActionStaticSetup(projectRoot, requirements) {
-  for (const requirement of requirements) {
-    if (requirement.required === false) continue;
-    if (requirement.kind === "package") {
-      try {
-        createRequire(path3.join(projectRoot, "package.json")).resolve(requirement.name);
-      } catch {
-        throw new Error(`Project Action package is not installed: ${requirement.name}`);
-      }
-    }
-    if (requirement.kind === "native_tool" && !await executableExists(requirement.name)) {
-      throw new Error(`Project Action native tool is not installed: ${requirement.name}`);
-    }
-  }
-}
-async function validateProjectActionRunSetup(projectRoot, requirements, request) {
-  await validateProjectActionStaticSetup(projectRoot, requirements);
-  for (const requirement of requirements) {
-    if (requirement.required === false) continue;
-    if (requirement.kind === "connection" && !(requirement.name in (request.connections ?? {}))) {
-      throw new Error(`Project Action connection is not configured: ${requirement.name}`);
-    }
-    if (requirement.kind === "env" && !(requirement.name in (request.environment ?? {}))) {
-      throw new Error(`Project Action environment value is not configured: ${requirement.name}`);
-    }
-  }
-}
-async function executableExists(name) {
-  if (!name.trim() || name.includes("/") || name.includes("\\")) return false;
-  for (const directory of (process.env.PATH ?? "").split(path3.delimiter).filter(Boolean)) {
-    const candidates = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").map((extension) => path3.join(directory, `${name}${extension}`)) : [path3.join(directory, name)];
-    for (const candidate of candidates) {
-      if (await fs3.access(candidate).then(() => true).catch(() => false)) return true;
-    }
-  }
-  return false;
-}
-var DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY = ".openpond/actions";
-async function buildProjectActions(input) {
-  const configuration = await loadProjectActionConfiguration(input.projectRoot);
-  const discovered = await discoverProjectActionFiles({
-    projectRoot: input.projectRoot,
-    sourceDirectory: input.sourceDirectory ?? configuration.sourceDirectory
-  });
-  const outputDirectory = path4.resolve(
-    discovered.projectRoot,
-    input.outputDirectory ?? configuration.outputDirectory ?? DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY
-  );
-  assertWithinProject(discovered.projectRoot, outputDirectory);
-  await fs4.mkdir(outputDirectory, { recursive: true });
-  const entryPath = path4.join(outputDirectory, "entry.mjs");
-  const bundlePath = path4.join(outputDirectory, "bundle.mjs");
-  const runnerPath = path4.join(outputDirectory, "runner.mjs");
-  const registryPath = path4.join(outputDirectory, "action-registry.json");
-  const manifestPath = path4.join(outputDirectory, "build-manifest.json");
-  const imports = discovered.files.map((file, index) => {
-    const relative = path4.relative(outputDirectory, path4.join(discovered.projectRoot, file)).split(path4.sep).join("/");
-    const specifier = relative.startsWith(".") ? relative : `./${relative}`;
-    return `import * as actionModule${index} from ${JSON.stringify(specifier)};`;
-  });
-  const modules = discovered.files.map((_file, index) => `actionModule${index}`).join(", ");
-  await fs4.writeFile(
-    entryPath,
-    [
-      ...imports,
-      `export const projectActionModules = [${modules}];`,
-      "export default projectActionModules;",
-      ""
-    ].join("\n"),
-    "utf8"
-  );
-  await build({
-    entryPoints: [entryPath],
-    outfile: bundlePath,
-    bundle: true,
-    platform: "node",
-    format: "esm",
-    target: "node22.14",
-    sourcemap: false,
-    legalComments: "none",
-    logLevel: "silent",
-    nodePaths: dependencySearchPaths(discovered.projectRoot)
-  });
-  const cacheKey = `openpond_action_build=${Date.now()}_${Math.random().toString(16).slice(2)}`;
-  const loaded = await import(`${pathToFileURL(bundlePath).href}?${cacheKey}`);
-  const actions = collectProjectActions(loaded.projectActionModules ?? loaded.default ?? []);
-  for (const action of actions) {
-    await validateProjectActionStaticSetup(discovered.projectRoot, action.setup);
-  }
-  const registry = createProjectActionRegistry(actions);
-  await fs4.writeFile(registryPath, canonicalJson(registry), "utf8");
-  await fs4.writeFile(runnerPath, runtimeSource(), { encoding: "utf8", mode: 493 });
-  const bundleHash = sha256(await fs4.readFile(bundlePath));
-  const registryHash = sha256(canonicalJson(registry));
-  const manifest = {
-    schemaVersion: "openpond.projectActionBuild.v1",
-    sourceDirectory: path4.relative(discovered.projectRoot, discovered.sourceRoot).split(path4.sep).join("/"),
-    sourceFiles: discovered.files,
-    bundleFile: path4.basename(bundlePath),
-    runnerFile: path4.basename(runnerPath),
-    registryFile: path4.basename(registryPath),
-    bundleHash,
-    registryHash
-  };
-  await fs4.writeFile(manifestPath, canonicalJson(manifest), "utf8");
-  await fs4.rm(entryPath, { force: true });
-  return {
-    projectRoot: discovered.projectRoot,
-    outputDirectory,
-    bundlePath,
-    runnerPath,
-    registryPath,
-    manifestPath,
-    registry,
-    manifest
-  };
-}
-function dependencySearchPaths(projectRoot) {
-  const candidates = [];
-  let current = projectRoot;
-  while (true) {
-    candidates.push(path4.join(current, "node_modules"));
-    const parent = path4.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  candidates.push(path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "../../../node_modules"));
-  return [...new Set(candidates)];
-}
-function assertWithinProject(projectRoot, target) {
-  const relative = path4.relative(projectRoot, target);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
-    throw new Error("Project Action output directory must stay inside the Project root.");
-  }
-}
-function runtimeSource() {
-  return `#!/usr/bin/env node
-import { promises as fs } from "node:fs";
-import { stdin } from "node:process";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-let requestText = "";
-stdin.setEncoding("utf8");
-for await (const chunk of stdin) requestText += chunk;
-const request = JSON.parse(requestText);
-const bundlePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "bundle.mjs");
-const loaded = await import(pathToFileURL(bundlePath).href);
-const values = [];
-const seen = new Set();
-const visit = (value) => {
-  if (seen.has(value)) return;
-  if (value && (typeof value === "object" || typeof value === "function")) seen.add(value);
-  if (value?.kind === "openpond-project-action" && typeof value.run === "function") { values.push(value); return; }
-  if (Array.isArray(value)) { value.forEach(visit); return; }
-  if (value && typeof value === "object") Object.values(value).forEach(visit);
-};
-(loaded.projectActionModules ?? loaded.default ?? []).forEach(visit);
-const action = values.find((candidate) => candidate.id === request.actionId);
-if (!action) throw new Error(\`Unknown Project Action: \${request.actionId}\`);
-const controller = new AbortController();
-const timeoutMs = Math.min(request.timeoutMs ?? action.timeoutMs, action.timeoutMs);
-const timer = setTimeout(() => controller.abort(new Error(\`Project Action timed out after \${timeoutMs}ms.\`)), timeoutMs);
-const traces = [];
-const outputs = [];
-const env = request.environment ?? {};
-const connections = request.connections ?? {};
-const context = {
-  runId: request.runId,
-  actionId: action.id,
-  idempotencyKey: request.idempotencyKey ?? null,
-  projectRoot: request.projectRoot,
-  outputDirectory: request.outputDirectory,
-  signal: controller.signal,
-  env(name) { return Object.prototype.hasOwnProperty.call(env, name) ? env[name] : undefined; },
-  connection(name) {
-    if (!Object.prototype.hasOwnProperty.call(connections, name)) throw new Error(\`Project Action connection is not configured: \${name}\`);
-    return connections[name];
-  },
-  trace(name, payload) { traces.push({ name, ...(payload ? { payload } : {}), timestamp: new Date().toISOString() }); },
-  output(value) {
-    if (!value || typeof value.path !== "string" || !value.path.trim()) throw new Error("Project Action output requires a path.");
-    const outputPath = path.resolve(request.outputDirectory, value.path);
-    const relative = path.relative(request.outputDirectory, outputPath);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Project Action output must stay inside the run output directory.");
-    outputs.push({ ...value, path: relative.split(path.sep).join("/") });
-  },
-};
-try {
-  const input = action.inputSchema.parse(request.input ?? {});
-  const result = await Promise.race([
-    Promise.resolve(action.run(context, input)),
-    new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true })),
-  ]);
-  const output = action.outputSchema.parse(result);
-  for (const artifact of outputs) {
-    const stats = await fs.stat(path.resolve(request.outputDirectory, artifact.path)).catch(() => null);
-    if (!stats?.isFile()) throw new Error(\`Project Action output does not exist: \${artifact.path}\`);
-  }
-  await fs.writeFile(request.responseFile, JSON.stringify({ ok: true, output, traces, outputs }), "utf8");
-} finally {
-  clearTimeout(timer);
-}
-`;
-}
-var localConcurrency = /* @__PURE__ */ new Map();
-function createLocalActionRunner(options) {
-  const projectRoot = path5.resolve(options.projectRoot);
-  const buildPolicy = options.build ?? "if-missing";
-  let currentBuild = null;
-  const ensureBuild = async () => {
-    if (buildPolicy === "always") return runBuild();
-    if (currentBuild) return currentBuild;
-    if (buildPolicy === "never" || buildPolicy === "if-missing") {
-      const configuration = await loadProjectActionConfiguration(projectRoot);
-      const outputDirectory = path5.resolve(
-        projectRoot,
-        options.outputDirectory ?? configuration.outputDirectory ?? DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY
-      );
-      const loaded = await loadBuild(projectRoot, outputDirectory);
-      if (loaded) return currentBuild = loaded;
-      if (buildPolicy === "never") {
-        throw new Error(`Project Actions have not been built in ${outputDirectory}.`);
-      }
-    }
-    return runBuild();
-  };
-  const runBuild = async () => {
-    currentBuild = await buildProjectActions({
-      projectRoot,
-      sourceDirectory: options.sourceDirectory,
-      outputDirectory: options.outputDirectory
-    });
-    return currentBuild;
-  };
-  return {
-    build: runBuild,
-    async catalog() {
-      return (await ensureBuild()).registry;
-    },
-    async run(request) {
-      const built = await ensureBuild();
-      const catalogAction = built.registry.actions.find((action) => action.id === request.actionId);
-      if (!catalogAction) throw new Error(`Unknown Project Action: ${request.actionId}`);
-      const configuredRuntime = resolveProjectActionRuntime(
-        await loadProjectActionConfiguration(projectRoot)
-      );
-      const resolvedRequest = {
-        ...request,
-        environment: {
-          ...configuredRuntime.environment,
-          ...request.environment ?? {}
-        },
-        connections: {
-          ...configuredRuntime.connections,
-          ...request.connections ?? {}
-        }
-      };
-      await validateProjectActionRunSetup(projectRoot, catalogAction.setupRequirements, resolvedRequest);
-      const runId = request.runId?.trim() || randomUUID();
-      const actionOutputDirectory = path5.resolve(
-        request.outputDirectory ?? path5.join(projectRoot, ".openpond", "outputs", runId)
-      );
-      assertWithinProject2(projectRoot, actionOutputDirectory, "Project Action output directory");
-      await fs5.mkdir(actionOutputDirectory, { recursive: true });
-      const release = await acquireLocalActionSlot(
-        `${projectRoot}\0${request.actionId}`,
-        catalogAction.implementation.concurrency,
-        resolvedRequest.signal
-      );
-      const responseFile = path5.join(built.outputDirectory, `.run-${randomUUID()}.json`);
-      const startedAt = Date.now();
-      let childResult;
-      let payload;
-      try {
-        childResult = await executeChild({
-          runnerPath: built.runnerPath,
-          cwd: projectRoot,
-          signal: resolvedRequest.signal,
-          request: {
-            actionId: request.actionId,
-            input: resolvedRequest.input ?? {},
-            runId,
-            idempotencyKey: resolvedRequest.idempotencyKey ?? null,
-            timeoutMs: resolvedRequest.timeoutMs,
-            projectRoot,
-            outputDirectory: actionOutputDirectory,
-            responseFile,
-            environment: resolvedRequest.environment ?? {},
-            connections: resolvedRequest.connections ?? {}
-          }
-        });
-        payload = JSON.parse(await fs5.readFile(responseFile, "utf8"));
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(redactRuntimeValues(message, resolvedRequest));
-      } finally {
-        await fs5.rm(responseFile, { force: true }).catch(() => void 0);
-        release();
-      }
-      return {
-        runId,
-        actionId: request.actionId,
-        status: "succeeded",
-        output: payload.output,
-        stdout: redactRuntimeValues(childResult.stdout, resolvedRequest),
-        stderr: redactRuntimeValues(childResult.stderr, resolvedRequest),
-        traces: redactRuntimeValue(payload.traces, resolvedRequest),
-        outputs: redactRuntimeValue(payload.outputs, resolvedRequest),
-        outputDirectory: actionOutputDirectory,
-        durationMs: Date.now() - startedAt
-      };
-    }
-  };
-}
-async function acquireLocalActionSlot(key, limit, signal) {
-  if (limit === null) return () => void 0;
-  const state = localConcurrency.get(key) ?? { active: 0, waiting: [] };
-  localConcurrency.set(key, state);
-  if (state.active >= limit) {
-    await new Promise((resolve, reject) => {
-      const resume = () => {
-        signal?.removeEventListener("abort", abort);
-        resolve();
-      };
-      const abort = () => {
-        const index = state.waiting.indexOf(resume);
-        if (index >= 0) state.waiting.splice(index, 1);
-        reject(signal?.reason instanceof Error ? signal.reason : new Error("Project Action was cancelled."));
-      };
-      if (signal?.aborted) {
-        abort();
-        return;
-      }
-      state.waiting.push(resume);
-      signal?.addEventListener("abort", abort, { once: true });
-    });
-  } else {
-    state.active += 1;
-  }
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    const next = state.waiting.shift();
-    if (next) {
-      next();
-      return;
-    }
-    state.active -= 1;
-    if (state.active === 0 && state.waiting.length === 0) localConcurrency.delete(key);
-  };
-}
-async function loadBuild(projectRoot, outputDirectory) {
-  const manifestPath = path5.join(outputDirectory, "build-manifest.json");
-  const registryPath = path5.join(outputDirectory, "action-registry.json");
-  const [manifestText, registryText] = await Promise.all([
-    fs5.readFile(manifestPath, "utf8").catch(() => null),
-    fs5.readFile(registryPath, "utf8").catch(() => null)
-  ]);
-  if (!manifestText || !registryText) return null;
-  const manifest = JSON.parse(manifestText);
-  const registry = JSON.parse(registryText);
-  return {
-    projectRoot,
-    outputDirectory,
-    bundlePath: path5.join(outputDirectory, manifest.bundleFile),
-    runnerPath: path5.join(outputDirectory, manifest.runnerFile),
-    registryPath,
-    manifestPath,
-    registry,
-    manifest
-  };
-}
-function redactRuntimeValues(value, request) {
-  let redacted = value;
-  for (const secret of runtimeStringValues(request)) {
-    if (secret.length >= 4) redacted = redacted.split(secret).join("[REDACTED]");
-  }
-  return redacted;
-}
-function redactRuntimeValue(value, request) {
-  const serialized = JSON.stringify(value);
-  return JSON.parse(redactRuntimeValues(serialized, request));
-}
-function runtimeStringValues(request) {
-  const values = new Set(Object.values(request.environment ?? {}));
-  const visit = (value) => {
-    if (typeof value === "string") values.add(value);
-    else if (Array.isArray(value)) value.forEach(visit);
-    else if (value && typeof value === "object") Object.values(value).forEach(visit);
-  };
-  visit(request.connections ?? {});
-  return [...values].filter(Boolean).sort((left, right) => right.length - left.length);
-}
-function executeChild(input) {
-  return new Promise((resolve, reject) => {
-    if (input.signal?.aborted) {
-      reject(input.signal.reason instanceof Error ? input.signal.reason : new Error("Project Action was cancelled."));
-      return;
-    }
-    let requestJson;
-    try {
-      requestJson = JSON.stringify(input.request);
-    } catch (error) {
-      reject(new Error(`Project Action request is not serializable: ${error instanceof Error ? error.message : String(error)}`));
-      return;
-    }
-    const child = spawn(process.execPath, [input.runnerPath], {
-      cwd: input.cwd,
-      env: minimalEnvironment(),
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    const abort = () => child.kill("SIGTERM");
-    input.signal?.addEventListener("abort", abort, { once: true });
-    child.once("error", reject);
-    child.once("close", (code, signal) => {
-      input.signal?.removeEventListener("abort", abort);
-      if (input.signal?.aborted) {
-        reject(input.signal.reason instanceof Error ? input.signal.reason : new Error("Project Action was cancelled."));
-        return;
-      }
-      if (code !== 0) {
-        reject(new Error(`Project Action process failed (${code ?? signal ?? "unknown"}): ${stderr.trim() || stdout.trim()}`));
-        return;
-      }
-      resolve({ stdout, stderr });
-    });
-    child.stdin.end(requestJson);
-  });
-}
-function assertWithinProject2(projectRoot, target, label) {
-  const relative = path5.relative(projectRoot, target);
-  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
-    throw new Error(`${label} must stay inside the Project root.`);
-  }
-}
-function minimalEnvironment() {
-  const env = {};
-  for (const name of ["PATH", "SystemRoot", "WINDIR", "TMPDIR", "TEMP", "TMP"]) {
-    if (process.env[name] !== void 0) env[name] = process.env[name];
-  }
-  return env;
-}
-
-export {
-  PROJECT_ACTION_CONFIG_PATH,
-  loadProjectActionConfiguration,
-  buildProjectActions,
-  createLocalActionRunner
-};