@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-ST6LROUG.js

@@ -0,0 +1,267 @@
+import {
+  setEmbeddedCompiler,
+  setProjectModuleCompiler
+} from "./chunk-2KXB47FP.js";
+import {
+  installHeadlessCanvas
+} from "./chunk-EZRWJ4G2.js";
+import {
+  parseFrameSpec
+} from "./chunk-BP7UKF36.js";
+import {
+  encodeMp4,
+  timelineFrameSpec
+} from "./chunk-7QE2ZNSN.js";
+import {
+  applyEnv
+} from "./chunk-ZL4JTG5Y.js";
+import {
+  RunTrace,
+  captureNodeConsole,
+  checkProjectGraph,
+  cookingNode,
+  inspectProjectGraph,
+  installProjectIo,
+  installProjectStages,
+  renderDeterministicProjectFrames,
+  runDeterministicProjectGraph,
+  saveStillImages,
+  validateProjectGraph
+} from "./chunk-MP653A5O.js";
+import {
+  graphSeed
+} from "./chunk-L6B6FUQP.js";
+import {
+  frameRange
+} from "./chunk-CO22XHNG.js";
+import {
+  compileEmbedded,
+  compileProjectModule
+} from "./chunk-EU4ZFZ7Y.js";
+import {
+  cascadeVersion,
+  formatStageTrace
+} from "./chunk-5ORUQ6ES.js";
+import {
+  ProjectRoot
+} from "./chunk-2JEU3MGB.js";
+
+// src/cli/runner.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { existsSync } from "node:fs";
+var RENDER_SUGGESTION_FRAMES = 30;
+function renderSuggestion(file, frames, count) {
+  if (count < RENDER_SUGGESTION_FRAMES) return null;
+  return `${count} frames in one process. cascade render ${file} --frames ${frames} renders them across worker processes (and encodes a preview mp4; --no-video for frames only).`;
+}
+async function runGraph(options) {
+  const { file, entryNode, nodes, validateOnly, checkOnly, inspectOnly, strict, verbose, frames, fps, out } = options;
+  if (verbose) {
+    console.log(`Loading graph from: ${file}`);
+  }
+  let graphData;
+  try {
+    const filePath = path.resolve(file);
+    const content = await fs.readFile(filePath, "utf-8");
+    graphData = JSON.parse(content);
+    if (options.seed !== void 0) graphData.seed = options.seed;
+  } catch (error) {
+    console.error(`Failed to load graph file: ${error.message}`);
+    process.exit(1);
+  }
+  const projectRoot = path.dirname(path.resolve(file));
+  if (validateOnly || checkOnly) {
+    const unresolved = checkOnly ? await checkProjectGraph(file, graphData, strict) : await validateProjectGraph(file, graphData, strict);
+    const headline = checkOnly ? "Static check passed" : "Graph validation passed";
+    console.log(
+      unresolved > 0 ? `${headline} with ${unresolved} unresolved ${unresolved === 1 ? "module" : "modules"} \u2014 run with --strict to fail on these` : `${headline}!`
+    );
+    return;
+  }
+  if (inspectOnly) {
+    console.log(JSON.stringify(await inspectProjectGraph(file, graphData), null, 2));
+    return;
+  }
+  let disposeStageBridge;
+  let disposeIoBridge;
+  let canvasHost;
+  let canvasError = null;
+  let project;
+  const trace = new RunTrace(path.resolve(file), cascadeVersion(), graphSeed(graphData));
+  const observe = (graph) => trace.attach(graph);
+  const writeTrace = () => {
+    if (!project || !existsSync(path.resolve(file))) return void 0;
+    try {
+      return trace.write(project.root);
+    } catch (error) {
+      console.warn(`Could not write the run trace: ${error instanceof Error ? error.message : error}`);
+      return void 0;
+    }
+  };
+  try {
+    project = new ProjectRoot(path.dirname(path.resolve(file)));
+    setProjectModuleCompiler(async (folderName) => (await compileProjectModule(project, folderName)).code);
+    setEmbeddedCompiler(async (code) => (await compileEmbedded(project, code)).code);
+    disposeStageBridge = installProjectStages(project, {
+      verbose,
+      // A render worker starts Python while the probe frames run.
+      prewarm: Boolean(options.worker),
+      // A render worker is already one of several processes: one Python each.
+      ...options.worker ? { poolSize: 1 } : {},
+      onTrace: (stage) => {
+        trace.recordStage(stage);
+        if (verbose) console.log(`[stage] ${formatStageTrace(stage)}`);
+      },
+      // What a stage prints goes into the trace against the node that called
+      // it, always; on the terminal too with --verbose (the console capture
+      // below records that copy, so it is not recorded twice).
+      onOutput: (stage, stream, line) => {
+        const text = `[${stage ?? "stage-worker"}] ${line}`;
+        if (verbose) (stream === "stderr" ? console.warn : console.log)(text);
+        else if (stage === null) cookingNode.exit(() => trace.recordLog(stream, text));
+        else trace.recordLog(stream, text);
+      }
+    });
+    disposeIoBridge = installProjectIo(project, { resident: true });
+  } catch (error) {
+    if (verbose) console.warn(`No project context for ${file}: ${error instanceof Error ? error.message : error}`);
+  }
+  try {
+    canvasHost = await installHeadlessCanvas();
+    if (verbose) console.log(`Canvas: ${canvasHost.renderer}`);
+  } catch (error) {
+    canvasError = error instanceof Error ? error : new Error(String(error));
+    if (verbose) console.warn(canvasError.message);
+  }
+  const frameSpec = frames ? frames === "timeline" ? timelineFrameSpec(graphData) : parseFrameSpec(frames) : null;
+  if (frameSpec && frames && !options.worker) {
+    const hint = renderSuggestion(file, frames, frameRange(frameSpec.start, frameSpec.end, frameSpec.step ?? 1).length);
+    if (hint) (options.json ? console.error : console.log)(hint);
+  }
+  const restoreConsole = captureNodeConsole(trace);
+  const restoreEnv = applyEnv(options.env);
+  if (options.env) trace.setEnvNames(Object.keys(options.env));
+  let hostReleased = false;
+  const releaseHost = () => {
+    if (hostReleased) return;
+    hostReleased = true;
+    const errors = [];
+    for (const dispose of [
+      restoreConsole,
+      disposeStageBridge,
+      restoreEnv,
+      disposeIoBridge,
+      canvasHost ? () => canvasHost.dispose() : void 0,
+      () => setProjectModuleCompiler(null),
+      () => setEmbeddedCompiler(null)
+    ]) {
+      try {
+        dispose?.();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length) throw errors[0];
+  };
+  try {
+    if (frameSpec) {
+      const rendered = await renderDeterministicProjectFrames(file, graphData, {
+        ...frameSpec,
+        ...fps === void 0 ? {} : { fps },
+        out: out ?? "renders",
+        ...entryNode ? { entryNode } : {},
+        ...nodes?.length ? { nodes } : {},
+        ...options.outNodes?.length ? { outNodes: options.outNodes } : {},
+        ...verbose ? { verbose } : {},
+        ...options.fresh ? { fresh: true } : {},
+        ...options.worker ? { frameSource: options.worker.frameSource } : {},
+        onFrame: async (frame) => {
+          trace.recordSaved(frame.durationMs);
+          await options.worker?.onFrame(frame);
+        },
+        observe
+      });
+      if (rendered && options.worker) {
+        releaseHost();
+        return;
+      }
+      if (rendered) {
+        releaseHost();
+        const tracePath = writeTrace();
+        const video = options.mp4 && !rendered.aborted ? await encodeMp4({ root: projectRoot, files: rendered.files, frames: rendered.frames, fps: rendered.fps, file: options.mp4, ...options.crf === void 0 ? {} : { crf: options.crf } }) : void 0;
+        if (options.json) {
+          process.stdout.write(JSON.stringify({
+            status: "completed",
+            graph: path.resolve(file),
+            ...rendered,
+            ...video ? { video } : {},
+            seed: graphSeed(graphData),
+            ...tracePath ? { trace: tracePath } : {},
+            stages: trace.stages(),
+            logs: trace.logs()
+          }) + "\n");
+        } else {
+          console.log(`Rendered ${rendered.frames.length} frames, ${rendered.files.length} files -> ${out ?? "renders"}/`);
+          if (video) console.log(`Encoded ${video.file} (H.264 yuv420p, crf ${video.crf}, ${video.fps} fps)`);
+        }
+        return;
+      }
+      if (options.json) throw new Error("--json rendering requires a fully definition-v1 graph");
+    } else {
+      const started = performance.now();
+      let images = [];
+      const target = options.outNodes?.length || (nodes?.length ?? 0) > 1 ? void 0 : nodes?.[0] ?? entryNode;
+      const saveImages = async (graph) => {
+        if (!project) return;
+        const saving = performance.now();
+        images = await saveStillImages(graph, project, {
+          ...out ? { out } : {},
+          ...nodes?.length ? { nodes } : entryNode ? { nodes: [entryNode] } : {},
+          ...options.outNodes?.length ? { extra: options.outNodes } : {}
+        });
+        const runs = trace.toJSON().runs;
+        const cook = runs[runs.length - 1]?.ms;
+        if (cook !== void 0) trace.recordSaved(cook + performance.now() - saving);
+      };
+      if (await runDeterministicProjectGraph(file, graphData, target, observe, saveImages)) {
+        if (verbose) console.log("Graph execution completed");
+        releaseHost();
+        const tracePath = writeTrace();
+        if (options.json) {
+          process.stdout.write(JSON.stringify({
+            status: "completed",
+            graph: path.resolve(file),
+            durationMs: performance.now() - started,
+            seed: graphSeed(graphData),
+            images,
+            ...out ? { files: images.map((image) => image.file) } : {},
+            ...tracePath ? { trace: tracePath } : {},
+            stages: trace.stages(),
+            logs: trace.logs()
+          }) + "\n");
+        } else if (out) {
+          console.log(`Saved ${images.length} ${images.length === 1 ? "image" : "images"} -> ${out}/`);
+        }
+        return;
+      }
+    }
+  } catch (error) {
+    releaseHost();
+    const tracePath = options.worker ? void 0 : writeTrace();
+    if (tracePath && error instanceof Error) error.message += `
+Run trace: ${tracePath}`;
+    throw error;
+  }
+  releaseHost();
+  throw new Error(
+    `${path.resolve(file)} has no definition-v1 nodes, and the dynamic executor was removed in 0.7. Every node needs a static \`export const definition\` \u2014 see doc/NODE_AUTHORING.md.`
+  );
+}
+
+export {
+  RENDER_SUGGESTION_FRAMES,
+  renderSuggestion,
+  runGraph
+};
+//# sourceMappingURL=chunk-ST6LROUG.js.map

package/dist/cli/chunk-TJW67QSI.js

@@ -0,0 +1,225 @@
+import {
+  browserAssetCapability
+} from "./chunk-ZSCUZE6I.js";
+import {
+  attachDefinition
+} from "./chunk-BPODRH52.js";
+import {
+  createGpuHost,
+  requestDeviceWithAdapterLimits
+} from "./chunk-L6B6FUQP.js";
+import {
+  validateNodeDefinition
+} from "./chunk-NJFMDXHR.js";
+
+// src/nodes/definition/browserShellCapability.ts
+var capability = null;
+function forgetShellCapability() {
+  capability = null;
+}
+async function token() {
+  if (capability) return capability;
+  const response = await fetch("/api/shell/capability", { cache: "no-store" });
+  if (!response.ok) {
+    throw new Error(
+      response.status === 404 ? "The shell capability is disabled on this server. It is available on a loopback server, or one started with an explicit trusted host." : `Could not obtain the shell capability (${response.status})`
+    );
+  }
+  const { capability: issued } = await response.json();
+  if (typeof issued !== "string" || !issued) {
+    throw new Error("Server issued no shell capability");
+  }
+  capability = issued;
+  return issued;
+}
+function domSignal(signal) {
+  if (!signal) return void 0;
+  const controller = new AbortController();
+  if (signal.aborted) controller.abort(signal.reason);
+  else signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  return controller.signal;
+}
+async function post(body, signal) {
+  const bridged = domSignal(signal);
+  const send = async (issued) => fetch("/api/shell", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Cascade-Shell-Capability": issued
+    },
+    body: JSON.stringify(body),
+    ...bridged ? { signal: bridged } : {}
+  });
+  let response = await send(await token());
+  if (response.status === 403) {
+    capability = null;
+    response = await send(await token());
+  }
+  return response;
+}
+function requestBody(command, args, options) {
+  const { signal: _signal, ...rest } = options ?? {};
+  return {
+    command,
+    ...args ? { args } : {},
+    // `/api/shell` has always accepted execution options at the top level;
+    // keep the Studio adapter on that wire contract. Nesting them under
+    // `options` silently drops stdin, timeout, cwd and env in the route parser.
+    ...rest
+  };
+}
+async function fail(response) {
+  let payload = null;
+  try {
+    payload = await response.json();
+  } catch {
+  }
+  const message = typeof payload?.error === "string" ? payload.error : `Shell request failed (${response.status})`;
+  if (payload?.code === "COMMAND_NOT_ALLOWED") {
+    throw new Error(`${message}. Add it under Allowed Commands in Project Settings.`);
+  }
+  throw new Error(message);
+}
+var browserShellCapability = {
+  async run(command, args, options) {
+    const response = await post(requestBody(command, args, options), options?.signal);
+    if (!response.ok) await fail(response);
+    const { ok: _ok, ...result } = await response.json();
+    return result;
+  },
+  async runJson(command, args, options) {
+    const result = await this.run(command, args, options);
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      throw new Error(`${command} did not print JSON`);
+    }
+  }
+};
+async function shellRouteAvailable() {
+  const forget = () => {
+    forgetShellCapability();
+    return false;
+  };
+  if (typeof fetch !== "function") return forget();
+  try {
+    const response = await fetch("/api/shell/capability", { cache: "no-store" });
+    if (!response.ok) return forget();
+    const { capability: issued } = await response.json();
+    if (typeof issued !== "string" || !issued) return forget();
+    capability = issued;
+    return true;
+  } catch {
+    return forget();
+  }
+}
+
+// src/browser/gpu.ts
+function createBrowserGpuHost() {
+  const gpu = globalThis.navigator?.gpu;
+  if (!gpu) return void 0;
+  return createGpuHost({
+    async acquire() {
+      const adapter = await gpu.requestAdapter();
+      if (!adapter) {
+        throw new Error(
+          "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
+        );
+      }
+      const device = await requestDeviceWithAdapterLimits(adapter);
+      const info = adapter.info;
+      return {
+        device,
+        info: {
+          vendor: info?.vendor ?? "",
+          architecture: info?.architecture ?? "",
+          device: info?.device ?? "",
+          description: info?.description ?? ""
+        },
+        limits: device.limits ?? adapter.limits
+      };
+    }
+  });
+}
+
+// src/nodes/definition/projectDefinition.ts
+var studioCapabilities = {
+  assets: browserAssetCapability,
+  // Installed only where the browser has WebGPU, and absent rather than
+  // stubbed otherwise. That is what makes the failure a sentence: the preflight
+  // reports `runtime/missing-capability` and the adapter throws "requires the
+  // Studio gpu capability", both naming what is missing. A stub that threw on
+  // first use would name nothing.
+  ...gpuCapabilityIfAvailable(),
+  /**
+   * Shell is present up front and withdrawn if the route turns out not to be
+   * there, which is the opposite way round from gpu and worth the sentence.
+   *
+   * `navigator.gpu` is a synchronous check, so gpu can be absent from the map
+   * before anything reads it. Whether the shell route exists takes a fetch, and
+   * this object is a module-level const read by three default parameters — so
+   * the choice is between delaying Studio's boot on a request, racing the
+   * probe, or installing and withdrawing. Installing is the one where the
+   * common case (a loopback server, where the route is always there) has no
+   * race at all and no cost.
+   *
+   * What it costs: on a server that does NOT offer the route, a cook in the
+   * first few milliseconds after boot sees the capability present and fails at
+   * the fetch instead of at the gate. That failure still names itself — *"the
+   * shell capability is disabled on this server"* — so it is a worse-shaped
+   * error rather than a silent one, and once the probe lands the preflight is
+   * correct from then on.
+   */
+  shell: browserShellCapability
+};
+void shellRouteAvailable().then((available) => {
+  if (!available) delete studioCapabilities.shell;
+});
+function gpuCapabilityIfAvailable() {
+  const gpu = createBrowserGpuHost();
+  return gpu ? { gpu } : {};
+}
+function declaresDefinitionV1(value) {
+  return typeof value === "object" && value !== null && value.apiVersion === 1;
+}
+function definitionAdapterError(value) {
+  const diagnostics = validateNodeDefinition(value);
+  if (!diagnostics.length) return null;
+  return diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n");
+}
+function missingStudioCapabilities(definition, capabilities = studioCapabilities) {
+  const declared = definition?.capabilities;
+  if (!Array.isArray(declared)) return [];
+  return declared.filter((name) => typeof name === "string").filter((name) => !capabilities[name]);
+}
+function moduleNodeFunction(node, moduleId, modulePromise, capabilities = studioCapabilities) {
+  const prepared = modulePromise.then((module) => adaptModule(node, moduleId, module, capabilities));
+  prepared.catch(() => {
+  });
+  return (n, g) => prepared.then((fn) => fn(n, g));
+}
+function adaptModule(node, moduleId, module, capabilities = studioCapabilities) {
+  if (!declaresDefinitionV1(module.definition)) {
+    return (n, g) => module.execute(n, g);
+  }
+  const invalid = definitionAdapterError(module.definition);
+  if (invalid) throw new Error(`${moduleId} exports an invalid definition-v1 literal:
+${invalid}`);
+  const registration = {
+    kind: "definition-v1",
+    moduleId,
+    definition: module.definition,
+    loadExecute: async () => module.execute
+  };
+  return attachDefinition(node, registration, capabilities);
+}
+
+export {
+  studioCapabilities,
+  declaresDefinitionV1,
+  definitionAdapterError,
+  missingStudioCapabilities,
+  moduleNodeFunction,
+  adaptModule
+};
+//# sourceMappingURL=chunk-TJW67QSI.js.map

package/dist/cli/chunk-WD62JIP6.js

@@ -0,0 +1,118 @@
+// server/src/pythonEnv.ts
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var RELATIVE_DIRECTORY = path.join(".cascade-cache", "python", "venv");
+var MARKER = "cascade-env.json";
+function pythonEnvDirectory(root) {
+  return path.join(root, RELATIVE_DIRECTORY);
+}
+function pythonEnvInterpreter(root) {
+  const directory = pythonEnvDirectory(root);
+  return process.platform === "win32" ? path.join(directory, "Scripts", "python.exe") : path.join(directory, "bin", "python");
+}
+function readPythonEnv(root) {
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(path.join(root, "cascade.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  const value = raw?.python;
+  if (value === void 0) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error('cascade.json python must be an object: { "requirements": ["numpy", ...] | "requirements.txt", "interpreter"?: "python3" }');
+  }
+  const { requirements, interpreter } = value;
+  const list = Array.isArray(requirements) && requirements.every((item) => typeof item === "string" && item.trim());
+  if (!list && !(typeof requirements === "string" && requirements.trim())) {
+    throw new Error("cascade.json python.requirements must be a list of pip requirements or a project-relative requirements file");
+  }
+  if (typeof requirements === "string") containedPath(root, requirements, "python.requirements");
+  if (interpreter !== void 0 && (typeof interpreter !== "string" || !/^[A-Za-z0-9._/-]+$/.test(interpreter))) {
+    throw new Error("cascade.json python.interpreter must be an executable name such as python3.12");
+  }
+  return { requirements, interpreter: interpreter ?? "python3" };
+}
+function pythonEnvKey(root, spec) {
+  const requirements = typeof spec.requirements === "string" ? `file ${spec.requirements}
+${fs.readFileSync(containedPath(root, spec.requirements, "python.requirements"), "utf8")}` : `list
+${spec.requirements.join("\n")}`;
+  return crypto.createHash("sha256").update(`${spec.interpreter}\0${requirements}`).digest("hex");
+}
+function pythonEnvStatus(root) {
+  const directory = pythonEnvDirectory(root);
+  const python = pythonEnvInterpreter(root);
+  const spec = readPythonEnv(root);
+  if (!spec) return { declared: false, directory, python, state: "none" };
+  if (!fs.existsSync(python)) return { declared: true, directory, python, state: "missing", reason: `no environment at ${path.relative(root, directory)}` };
+  let marker = {};
+  try {
+    marker = JSON.parse(fs.readFileSync(path.join(directory, MARKER), "utf8"));
+  } catch {
+  }
+  let key;
+  try {
+    key = pythonEnvKey(root, spec);
+  } catch (error) {
+    return { declared: true, directory, python, state: "stale", reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (marker.key !== key) return { declared: true, directory, python, state: "stale", reason: "cascade.json python changed since the environment was built" };
+  return { declared: true, directory, python, state: "current" };
+}
+async function provisionPythonEnv(root, log = () => {
+}) {
+  const spec = readPythonEnv(root);
+  if (!spec) throw new Error('cascade.json declares no python environment ("python": { "requirements": [...] })');
+  const before = pythonEnvStatus(root);
+  if (before.state === "current") return before;
+  const directory = pythonEnvDirectory(root);
+  if (fs.existsSync(directory)) {
+    const archive = path.join(path.dirname(directory), "_archive");
+    fs.mkdirSync(archive, { recursive: true });
+    fs.renameSync(directory, path.join(archive, `venv-${Date.now()}`));
+  }
+  fs.mkdirSync(path.dirname(directory), { recursive: true });
+  const file = typeof spec.requirements === "string" ? containedPath(root, spec.requirements, "python.requirements") : void 0;
+  const fileHasRequirements = file !== void 0 && fs.readFileSync(file, "utf8").split("\n").some((line) => line.trim() && !line.trim().startsWith("#"));
+  const requirements = file !== void 0 ? fileHasRequirements ? ["-r", file] : [] : [...spec.requirements];
+  log(`Creating ${path.relative(root, directory)} with ${spec.interpreter}`);
+  await run(spec.interpreter, ["-m", "venv", ...requirements.length ? [] : ["--without-pip"], directory], root);
+  if (requirements.length) {
+    log(`Installing ${typeof spec.requirements === "string" ? spec.requirements : spec.requirements.join(", ")}`);
+    await run(pythonEnvInterpreter(root), ["-m", "pip", "install", "--disable-pip-version-check", "--quiet", ...requirements], root);
+  }
+  fs.writeFileSync(path.join(directory, MARKER), `${JSON.stringify({ key: pythonEnvKey(root, spec), requirements: spec.requirements, interpreter: spec.interpreter, builtAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`);
+  return pythonEnvStatus(root);
+}
+function declaredStagePython(root) {
+  const status = pythonEnvStatus(root);
+  if (status.state === "none") return void 0;
+  if (status.state !== "current") {
+    throw new Error(`This project declares a Python environment (cascade.json "python") that is ${status.state}: ${status.reason}. Run \`cascade doctor --fix\` in ${root} to build it.`);
+  }
+  return status.python;
+}
+function containedPath(root, file, name) {
+  const resolved = path.resolve(root, file);
+  const relative = path.relative(root, resolved);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`cascade.json ${name} must be a project-relative path`);
+  return resolved;
+}
+function run(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile(command, [...args], { cwd, maxBuffer: 16 * 1024 * 1024, timeout: 20 * 6e4 }, (error, _stdout, stderr) => {
+      if (error) reject(new Error(`${path.basename(command)} ${args.slice(0, 3).join(" ")} failed: ${(stderr || error.message).trim().slice(-2e3)}`));
+      else resolve();
+    });
+  });
+}
+
+export {
+  pythonEnvStatus,
+  provisionPythonEnv,
+  declaredStagePython
+};
+//# sourceMappingURL=chunk-WD62JIP6.js.map