@lark-apaas/fullstack-cli 1.1.59-alpha.20260719124023 → 1.1.59-alpha.3

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs37 from "fs";
-import path33 from "path";
+import fs29 from "fs";
+import path25 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -4921,7 +4921,7 @@ var PROMPT_PATTERNS = [
   { pattern: /proceed\?/i, answer: "y\n" }
 ];
 async function executeShadcnAdd(registryItemPath) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve2) => {
     let output = "";
     const args = ["--yes", "shadcn@3.8.2", "add", registryItemPath];
     const ptyProcess = pty.spawn("npx", args, {
@@ -4947,7 +4947,7 @@ async function executeShadcnAdd(registryItemPath) {
     });
     const timeoutId = setTimeout(() => {
       ptyProcess.kill();
-      resolve9({
+      resolve2({
         success: false,
         files: [],
         error: "\u6267\u884C\u8D85\u65F6"
@@ -4958,7 +4958,7 @@ async function executeShadcnAdd(registryItemPath) {
       const success = exitCode === 0;
       const filePaths = parseOutput(output);
       const files = filePaths.map(toFileInfo);
-      resolve9({
+      resolve2({
         success,
         files,
         error: success ? void 0 : output || `Process exited with code ${exitCode}`
@@ -4969,12 +4969,12 @@ async function executeShadcnAdd(registryItemPath) {
 
 // src/commands/component/add.handler.ts
 function runActionPluginInit() {
-  return new Promise((resolve9) => {
+  return new Promise((resolve2) => {
     execFile("fullstack-cli", ["action-plugin", "init"], { cwd: process.cwd(), stdio: "ignore" }, (error) => {
       if (error) {
         debug("action-plugin init \u5931\u8D25: %s", error.message);
       }
-      resolve9();
+      resolve2();
     });
   });
 }
@@ -8098,1951 +8098,21 @@ async function preUploadStatic(options) {
   }
 }
 
-// src/commands/build/preview-server-artifact.handler.ts
-import * as fs29 from "fs";
-import * as os3 from "os";
-import * as path25 from "path";
-import { builtinModules, createRequire as createRequire3 } from "module";
-import { build } from "esbuild";
-import { parse as parse2 } from "acorn";
-import { simple as walkSimple } from "acorn-walk";
-var STATIC_PLUGIN_REGISTRY_SYMBOL = "@lark-apaas/nestjs-capability/static-plugin-registry";
-var STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION = 1;
-var OPTIONAL_DEPENDENCY_STUBS = [
-  "@nestjs/microservices",
-  "@nestjs/microservices/microservices-module",
-  "@nestjs/websockets/socket-module",
-  "fsevents"
-];
-var BUILTIN_MODULES = /* @__PURE__ */ new Set([
-  ...builtinModules,
-  ...builtinModules.map((moduleName) => `node:${moduleName}`)
-]);
-function toAbsolutePath(projectRoot, candidate) {
-  return path25.isAbsolute(candidate) ? candidate : path25.resolve(projectRoot, candidate);
-}
-function readJson(filePath) {
-  return JSON.parse(fs29.readFileSync(filePath, "utf8"));
-}
-function findPackageRoot(entryPath) {
-  let current = path25.dirname(entryPath);
-  const filesystemRoot = path25.parse(current).root;
-  while (current !== filesystemRoot) {
-    if (fs29.existsSync(path25.join(current, "package.json"))) {
-      return current;
-    }
-    current = path25.dirname(current);
-  }
-  return null;
-}
-function findNativeAddons(root) {
-  const nativeAddons = [];
-  const pending = [root];
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (!current) {
-      continue;
-    }
-    for (const entry of fs29.readdirSync(current, { withFileTypes: true })) {
-      const entryPath = path25.join(current, entry.name);
-      if (entry.isSymbolicLink()) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        pending.push(entryPath);
-      } else if (entry.isFile() && entry.name.endsWith(".node")) {
-        nativeAddons.push(entryPath);
-      }
-    }
-  }
-  return nativeAddons.sort();
-}
-function resolveActionPlugins(projectRoot, packageJson) {
-  const configuredPlugins = packageJson.actionPlugins;
-  if (!configuredPlugins || typeof configuredPlugins !== "object") {
-    return { plugins: [], reasons: [] };
-  }
-  const projectRequire = createRequire3(path25.join(projectRoot, "package.json"));
-  const plugins = [];
-  const reasons = [];
-  for (const name of Object.keys(configuredPlugins).sort()) {
-    let entryPath;
-    try {
-      entryPath = projectRequire.resolve(name);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      reasons.push(`Action Plugin ${name} \u65E0\u6CD5\u89E3\u6790: ${message}`);
-      continue;
-    }
-    const packageRoot = findPackageRoot(entryPath);
-    if (!packageRoot) {
-      reasons.push(`Action Plugin ${name} \u65E0\u6CD5\u5B9A\u4F4D package.json: ${entryPath}`);
-      continue;
-    }
-    const nativeAddons = findNativeAddons(packageRoot);
-    if (nativeAddons.length > 0) {
-      const relativeAddons = nativeAddons.map(
-        (filePath) => path25.relative(packageRoot, filePath)
-      );
-      reasons.push(
-        `Action Plugin ${name} \u5305\u542B\u539F\u751F\u6269\u5C55\uFF0C\u4E0D\u80FD\u751F\u6210\u8DE8\u6C99\u7BB1\u5355 bundle: ${relativeAddons.join(", ")}`
-      );
-      continue;
-    }
-    const manifestPath = path25.join(packageRoot, "manifest.json");
-    let manifest;
-    if (fs29.existsSync(manifestPath)) {
-      try {
-        manifest = readJson(manifestPath);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        reasons.push(
-          `Action Plugin ${name} \u7684 manifest.json \u65E0\u6CD5\u89E3\u6790: ${message}`
-        );
-        continue;
-      }
-    }
-    plugins.push({ name, entryPath, manifest });
-  }
-  if (reasons.length === 0 && plugins.length > 0) {
-    try {
-      const capabilityRuntime = projectRequire(
-        "@lark-apaas/nestjs-capability"
-      );
-      if (capabilityRuntime.STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION !== STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION) {
-        reasons.push(
-          `@lark-apaas/nestjs-capability \u672A\u63D0\u4F9B\u517C\u5BB9\u7684 STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION=${STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION}`
-        );
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      reasons.push(
-        `@lark-apaas/nestjs-capability \u65E0\u6CD5\u52A0\u8F7D\uFF0C\u7F3A\u5C11 STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION=${STATIC_PLUGIN_REGISTRY_PROTOCOL_VERSION}: ${message}`
-      );
-    }
-  }
-  return { plugins, reasons };
-}
-function generateBootstrap(entryPath, plugins) {
-  const lines = [`'use strict';`, `const __staticPluginRegistry = new Map();`];
-  plugins.forEach((plugin, index) => {
-    const moduleVariable = `__staticPlugin${index}`;
-    lines.push(
-      `const ${moduleVariable} = require(${JSON.stringify(plugin.entryPath)});`
-    );
-    lines.push(
-      `__staticPluginRegistry.set(${JSON.stringify(plugin.name)}, { module: ${moduleVariable}, manifest: ${JSON.stringify(plugin.manifest ?? null)} });`
-    );
-  });
-  lines.push(
-    `globalThis[Symbol.for(${JSON.stringify(STATIC_PLUGIN_REGISTRY_SYMBOL)})] = __staticPluginRegistry;`,
-    `if (process.env.PREVIEW_ARTIFACT_PROBE_REGISTRY_FILE) {`,
-    `  require('node:fs').writeFileSync(process.env.PREVIEW_ARTIFACT_PROBE_REGISTRY_FILE, JSON.stringify(Array.from(__staticPluginRegistry.keys()).sort()));`,
-    `}`,
-    `require(${JSON.stringify(entryPath)});`,
-    ""
-  );
-  return lines.join("\n");
-}
-function classTransformerStorageResolver(projectRoot) {
-  const projectRequire = createRequire3(path25.join(projectRoot, "package.json"));
-  return {
-    name: "class-transformer-storage-resolver",
-    setup(esbuild) {
-      esbuild.onResolve({ filter: /^class-transformer\/storage$/ }, () => {
-        try {
-          return {
-            path: projectRequire.resolve("class-transformer/cjs/storage.js")
-          };
-        } catch {
-          return void 0;
-        }
-      });
-    }
-  };
-}
-function optionalDependencyStubPlugin() {
-  const stubbedDependencies = /* @__PURE__ */ new Set();
-  const escapedNames = OPTIONAL_DEPENDENCY_STUBS.map(
-    (name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-  );
-  const filter = new RegExp(`^(?:${escapedNames.join("|")})$`);
-  return {
-    stubbedDependencies,
-    plugin: {
-      name: "preview-optional-dependency-stubs",
-      setup(esbuild) {
-        esbuild.onResolve({ filter }, (args) => {
-          stubbedDependencies.add(args.path);
-          return {
-            path: args.path,
-            namespace: "preview-optional-dependency"
-          };
-        });
-        esbuild.onLoad(
-          { filter: /.*/, namespace: "preview-optional-dependency" },
-          (args) => ({
-            contents: `
-              const error = new Error(${JSON.stringify(
-              `Optional dependency is unavailable in Preview Artifact: ${args.path}`
-            )});
-              error.code = 'MODULE_NOT_FOUND';
-              throw error;
-            `,
-            loader: "js"
-          })
-        );
-      }
-    }
-  };
-}
-function isStaticString(node) {
-  if (!node) {
-    return false;
-  }
-  if (node.type === "Literal") {
-    return typeof node.value === "string";
-  }
-  return node.type === "TemplateLiteral" && node.expressions.length === 0;
-}
-function staticPropertyName(node) {
-  if (node.type !== "MemberExpression") {
-    return void 0;
-  }
-  if (!node.computed && node.property.type === "Identifier") {
-    return node.property.name;
-  }
-  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
-    return node.property.value;
-  }
-  return void 0;
-}
-function auditBundleClosure(outfile, stubbedDependencies) {
-  const ast = parse2(fs29.readFileSync(outfile, "utf8"), {
-    ecmaVersion: "latest",
-    sourceType: "script",
-    allowHashBang: true
-  });
-  let dynamicRequireCount = 0;
-  let dynamicImportCount = 0;
-  let createRequireCount = 0;
-  let requireResolveCount = 0;
-  let runtimeFileReadCount = 0;
-  const runtimeFileReads = /* @__PURE__ */ new Set([
-    "access",
-    "accessSync",
-    "createReadStream",
-    "open",
-    "openSync",
-    "readFile",
-    "readFileSync",
-    "readdir",
-    "readdirSync",
-    "stat",
-    "statSync"
-  ]);
-  walkSimple(ast, {
-    CallExpression(node) {
-      if (node.callee.type === "Identifier" && node.callee.name === "require" && !isStaticString(node.arguments[0])) {
-        dynamicRequireCount += 1;
-      }
-      if (node.callee.type === "Identifier" && node.callee.name === "createRequire" || staticPropertyName(node.callee) === "createRequire") {
-        createRequireCount += 1;
-      }
-      const propertyName = staticPropertyName(node.callee);
-      if (propertyName === "resolve" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "require") {
-        requireResolveCount += 1;
-      }
-      if (propertyName && runtimeFileReads.has(propertyName)) {
-        runtimeFileReadCount += 1;
-      }
-    },
-    ImportExpression(node) {
-      if (!isStaticString(node.source)) {
-        dynamicImportCount += 1;
-      }
-    }
-  });
-  const risks = [];
-  if (dynamicRequireCount > 0) {
-    risks.push(`bundle retains ${dynamicRequireCount} dynamic require call(s)`);
-  }
-  if (dynamicImportCount > 0) {
-    risks.push(`bundle retains ${dynamicImportCount} dynamic import call(s)`);
-  }
-  if (createRequireCount > 0 || requireResolveCount > 0) {
-    risks.push(
-      `bundle retains runtime module resolution (createRequire=${createRequireCount}, require.resolve=${requireResolveCount})`
-    );
-  }
-  if (runtimeFileReadCount > 0) {
-    risks.push(
-      `bundle retains ${runtimeFileReadCount} runtime filesystem read call(s)`
-    );
-  }
-  if (stubbedDependencies.length > 0) {
-    risks.push(
-      `bundle stubs optional dependencies: ${stubbedDependencies.join(", ")}`
-    );
-  }
-  return risks;
-}
-function collectExternalImports(metafile, outfile) {
-  const normalizedOutfile = path25.resolve(outfile);
-  const output = Object.entries(metafile.outputs).find(
-    ([outputPath]) => path25.resolve(outputPath) === normalizedOutfile
-  )?.[1];
-  if (!output) {
-    return [];
-  }
-  return Array.from(
-    new Set(
-      output.imports.filter((importRecord) => importRecord.external).map((importRecord) => importRecord.path).filter(
-        (importPath) => !BUILTIN_MODULES.has(importPath) && !importPath.startsWith("node:")
-      )
-    )
-  ).sort();
-}
-function formatBuildError(error) {
-  if (!error || typeof error !== "object" || !("errors" in error)) {
-    return [error instanceof Error ? error.message : String(error)];
-  }
-  const errors = error.errors;
-  if (!errors || errors.length === 0) {
-    return [error instanceof Error ? error.message : String(error)];
-  }
-  return errors.map((item) => {
-    const location = item.location?.file ? `${item.location.file}${item.location.line ? `:${item.location.line}` : ""}: ` : "";
-    return `${location}${item.text ?? "unknown esbuild error"}`;
-  });
-}
-function removePublishedArtifact(outfile, metadataFile) {
-  fs29.rmSync(outfile, { force: true });
-  fs29.rmSync(metadataFile, { force: true });
-}
-function bestEffortRemove(targetPath, options = {}) {
-  if (!targetPath) {
-    return;
-  }
-  try {
-    fs29.rmSync(targetPath, { force: true, recursive: options.recursive });
-  } catch {
-  }
-}
-function outputPathConflicts(entryPath, packageJsonPath, outfile, metadataFile) {
-  const reasons = [];
-  if (outfile === metadataFile) {
-    reasons.push("bundle \u4E0E metadata \u8F93\u51FA\u8DEF\u5F84\u4E0D\u80FD\u76F8\u540C");
-  }
-  const protectedInputs = /* @__PURE__ */ new Map([
-    [entryPath, "Nest \u7F16\u8BD1\u5165\u53E3"],
-    [packageJsonPath, "package.json"]
-  ]);
-  for (const [outputPath, outputName] of [
-    [outfile, "bundle"],
-    [metadataFile, "metadata"]
-  ]) {
-    const protectedName = protectedInputs.get(outputPath);
-    if (protectedName) {
-      reasons.push(
-        `${outputName} \u8F93\u51FA\u8DEF\u5F84\u4E0D\u80FD\u8986\u76D6 ${protectedName}: ${outputPath}`
-      );
-    }
-  }
-  return reasons;
-}
-async function buildPreviewServerArtifact(options) {
-  const startedAt = Date.now();
-  const projectRoot = path25.resolve(options.projectRoot);
-  const entryPath = toAbsolutePath(
-    projectRoot,
-    options.entry ?? "dist/main.js"
-  );
-  const outfile = toAbsolutePath(
-    projectRoot,
-    options.outfile ?? ".preview-artifact/server.bundle.cjs"
-  );
-  const metadataFile = toAbsolutePath(
-    projectRoot,
-    options.metadataFile ?? `${outfile}.meta.json`
-  );
-  const packageJsonPath = path25.join(projectRoot, "package.json");
-  let pluginCount = 0;
-  let outputCleared = false;
-  let phase = "\u6821\u9A8C\u8F93\u5165";
-  let tempRoot;
-  let tempOutputRoot;
-  let tempMetadataFile;
-  const failed = (reasons) => ({
-    built: false,
-    elapsedMs: Date.now() - startedAt,
-    pluginCount,
-    reasons
-  });
-  const pathConflicts = outputPathConflicts(
-    entryPath,
-    packageJsonPath,
-    outfile,
-    metadataFile
-  );
-  if (pathConflicts.length > 0) {
-    return failed(pathConflicts);
-  }
-  if (!fs29.existsSync(entryPath)) {
-    return failed([`Nest \u7F16\u8BD1\u5165\u53E3\u4E0D\u5B58\u5728: ${entryPath}`]);
-  }
-  if (!fs29.existsSync(packageJsonPath)) {
-    return failed([`package.json \u4E0D\u5B58\u5728: ${packageJsonPath}`]);
-  }
-  try {
-    phase = `\u89E3\u6790 ${packageJsonPath}`;
-    const packageJson = readJson(packageJsonPath);
-    phase = "\u89E3\u6790 Action Plugin";
-    const { plugins, reasons } = resolveActionPlugins(projectRoot, packageJson);
-    pluginCount = plugins.length;
-    phase = "\u6E05\u7406\u65E7 Preview Artifact";
-    removePublishedArtifact(outfile, metadataFile);
-    outputCleared = true;
-    if (reasons.length > 0) {
-      return failed(reasons);
-    }
-    phase = "\u521B\u5EFA Preview Artifact \u4E34\u65F6\u76EE\u5F55";
-    fs29.mkdirSync(path25.dirname(outfile), { recursive: true });
-    fs29.mkdirSync(path25.dirname(metadataFile), { recursive: true });
-    tempRoot = fs29.mkdtempSync(
-      path25.join(os3.tmpdir(), "preview-server-artifact-")
-    );
-    tempOutputRoot = fs29.mkdtempSync(
-      path25.join(path25.dirname(outfile), ".preview-server-artifact-")
-    );
-    const bootstrapPath = path25.join(tempRoot, "bootstrap.cjs");
-    const tempOutfile = path25.join(tempOutputRoot, path25.basename(outfile));
-    tempMetadataFile = path25.join(
-      path25.dirname(metadataFile),
-      `.${path25.basename(metadataFile)}.${process.pid}.${Date.now()}.tmp`
-    );
-    fs29.writeFileSync(bootstrapPath, generateBootstrap(entryPath, plugins));
-    const optionalDependencies = optionalDependencyStubPlugin();
-    const buildOptions = {
-      absWorkingDir: projectRoot,
-      entryPoints: [bootstrapPath],
-      outfile: tempOutfile,
-      bundle: true,
-      platform: "node",
-      format: "cjs",
-      target: "node22",
-      treeShaking: true,
-      keepNames: true,
-      legalComments: "none",
-      sourcemap: false,
-      metafile: true,
-      logLevel: "silent",
-      plugins: [
-        classTransformerStorageResolver(projectRoot),
-        optionalDependencies.plugin
-      ]
-    };
-    phase = "\u6267\u884C esbuild";
-    const buildResult2 = await build(buildOptions);
-    if (!buildResult2.metafile) {
-      throw new Error("esbuild \u672A\u8FD4\u56DE metafile");
-    }
-    const externalImports = collectExternalImports(
-      buildResult2.metafile,
-      tempOutfile
-    );
-    if (externalImports.length > 0) {
-      return failed([`bundle \u6B8B\u7559\u8FD0\u884C\u65F6\u4F9D\u8D56: ${externalImports.join(", ")}`]);
-    }
-    phase = "\u5BA1\u8BA1 bundle \u8FD0\u884C\u65F6\u95ED\u5305";
-    const stubbedOptionalDependencies = Array.from(
-      optionalDependencies.stubbedDependencies
-    ).sort();
-    const closureRisks = auditBundleClosure(
-      tempOutfile,
-      stubbedOptionalDependencies
-    );
-    const closureStatus = closureRisks.length === 0 ? "static-audit-clean" : "runtime-validation-required";
-    const metadata = {
-      version: 1,
-      entry: entryPath,
-      outfile,
-      bundleBytes: fs29.statSync(tempOutfile).size,
-      inputFiles: Object.keys(buildResult2.metafile.inputs).length,
-      externalImports,
-      actionPlugins: plugins.map((plugin) => plugin.name),
-      closureStatus,
-      closureRisks,
-      stubbedOptionalDependencies,
-      runtimeProbeStatus: "not-run",
-      consumable: false,
-      elapsedMs: Date.now() - startedAt
-    };
-    phase = "\u53D1\u5E03 bundle \u4E0E metadata";
-    fs29.writeFileSync(
-      tempMetadataFile,
-      `${JSON.stringify(metadata, null, 2)}
-`
-    );
-    fs29.renameSync(tempOutfile, outfile);
-    fs29.renameSync(tempMetadataFile, metadataFile);
-    return {
-      built: true,
-      outfile,
-      metadataFile,
-      bundleBytes: metadata.bundleBytes,
-      inputFiles: metadata.inputFiles,
-      externalImports,
-      pluginCount,
-      closureStatus,
-      closureRisks,
-      stubbedOptionalDependencies,
-      runtimeProbeStatus: "not-run",
-      consumable: false,
-      elapsedMs: metadata.elapsedMs
-    };
-  } catch (error) {
-    const reasons = formatBuildError(error).map(
-      (reason) => `${phase}: ${reason}`
-    );
-    if (outputCleared) {
-      try {
-        removePublishedArtifact(outfile, metadataFile);
-      } catch (cleanupError) {
-        reasons.push(
-          `\u6E05\u7406\u5931\u8D25\u4EA7\u7269: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
-        );
-      }
-    }
-    return failed(reasons);
-  } finally {
-    bestEffortRemove(tempRoot, { recursive: true });
-    bestEffortRemove(tempOutputRoot, { recursive: true });
-    bestEffortRemove(tempMetadataFile);
-  }
-}
-
-// src/commands/preview-artifact/producer.ts
-import * as crypto2 from "crypto";
-import * as fs34 from "fs";
-import * as path30 from "path";
-import { spawnSync as spawnSync8 } from "child_process";
-
-// src/commands/preview-artifact/generation.ts
-import * as crypto from "crypto";
-import * as fs30 from "fs";
-import * as path26 from "path";
-var PREVIEW_ARTIFACT_SCHEMA_VERSION = 2;
-var PREVIEW_ARTIFACT_PROTOCOL_VERSION = 2;
-var MANIFEST_FILE = "manifest.json";
-var PROBE_FILE = "probe.json";
-var SERVER_FILE = "server.bundle.cjs";
-var CLIENT_FILE = "client.zip";
-var RUNTIME_ONLY_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
-  "CLIENT_DEV_HOST",
-  "CLIENT_DEV_PORT",
-  "FORCE_AUTHN_ACCESS_KEY",
-  "FORCE_AUTHN_ACCESS_SECRET",
-  "FORCE_AUTHN_PREVIEW_SESSION_ID",
-  "MIAODA_HMR_WS_TOKEN",
-  "MIAODA_PREVIEW_RUN_ID",
-  "PREVIEW_RUN_ID",
-  "SANDBOX_COOKIE",
-  "SANDBOX_ID",
-  "SERVER_PORT",
-  "preview_run_id"
-]);
-var RUNTIME_ONLY_ENVIRONMENT_PREFIXES = ["PREVIEW_ARTIFACT_"];
-function previewArtifactBuildEnvironment(environment, appBasePath) {
-  const buildEnvironment = {};
-  for (const [key, value] of Object.entries(environment ?? {})) {
-    if (typeof value === "string" && !RUNTIME_ONLY_ENVIRONMENT_KEYS.has(key) && !RUNTIME_ONLY_ENVIRONMENT_PREFIXES.some((prefix) => key.startsWith(prefix))) {
-      buildEnvironment[key] = value;
-    }
-  }
-  buildEnvironment.CLIENT_BASE_PATH = appBasePath;
-  buildEnvironment.NODE_ENV = environment?.NODE_ENV ?? "production";
-  return buildEnvironment;
-}
-function previewArtifactBuildEnvironmentHash(environment, appBasePath) {
-  const buildEnvironment = previewArtifactBuildEnvironment(
-    environment,
-    appBasePath
-  );
-  const canonical = Object.fromEntries(
-    Object.entries(buildEnvironment).sort(
-      ([left], [right]) => left.localeCompare(right)
-    )
-  );
-  return crypto.createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
-}
-function parseNodeMajor(nodeVersion) {
-  const match = /^v?(\d+)(?:\.|$)/.exec(nodeVersion.trim());
-  if (!match) {
-    throw new Error(`invalid Node.js version: ${nodeVersion}`);
-  }
-  return Number(match[1]);
-}
-function sha256File(filePath) {
-  const hash = crypto.createHash("sha256");
-  hash.update(fs30.readFileSync(filePath));
-  return hash.digest("hex");
-}
-function fileIdentity(generationDir, relativePath) {
-  const filePath = path26.join(generationDir, relativePath);
-  const stat = fs30.lstatSync(filePath);
-  if (!stat.isFile() || stat.isSymbolicLink()) {
-    throw new Error(`artifact file must be a regular file: ${relativePath}`);
-  }
-  return {
-    path: relativePath,
-    bytes: stat.size,
-    sha256: sha256File(filePath)
-  };
-}
-function readJson2(filePath) {
-  return JSON.parse(fs30.readFileSync(filePath, "utf8"));
-}
-function writeJsonAtomic(filePath, value) {
-  fs30.mkdirSync(path26.dirname(filePath), { recursive: true });
-  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  fs30.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
-`, {
-    mode: 384
-  });
-  fs30.renameSync(temporaryPath, filePath);
-}
-function runtimeIdentity(nodeVersion, platform, arch) {
-  return { nodeMajor: parseNodeMajor(nodeVersion), platform, arch };
-}
-function sameRuntime(left, right) {
-  return left.nodeMajor === right.nodeMajor && left.platform === right.platform && left.arch === right.arch;
-}
-function createPreviewArtifactManifest(options) {
-  const generationDir = path26.resolve(options.generationDir);
-  const manifest = {
-    schemaVersion: PREVIEW_ARTIFACT_SCHEMA_VERSION,
-    protocolVersion: PREVIEW_ARTIFACT_PROTOCOL_VERSION,
-    generationId: options.generationId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    buildEnvironmentSha256: options.buildEnvironmentSha256,
-    runtime: runtimeIdentity(
-      options.nodeVersion,
-      options.platform,
-      options.arch
-    ),
-    files: {
-      server: fileIdentity(generationDir, SERVER_FILE),
-      client: fileIdentity(generationDir, CLIENT_FILE)
-    },
-    actionPlugins: Array.from(new Set(options.actionPlugins ?? [])).sort(),
-    runtimeProbeStatus: "not-run",
-    consumable: false
-  };
-  writeJsonAtomic(path26.join(generationDir, MANIFEST_FILE), manifest);
-  fs30.rmSync(path26.join(generationDir, PROBE_FILE), { force: true });
-  return manifest;
-}
-function recordPreviewArtifactProbe(options) {
-  const generationDir = path26.resolve(options.generationDir);
-  const manifest = readJson2(
-    path26.join(generationDir, MANIFEST_FILE)
-  );
-  const probe = {
-    schemaVersion: PREVIEW_ARTIFACT_SCHEMA_VERSION,
-    generationId: manifest.generationId,
-    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    success: options.success,
-    reasons: options.reasons ?? [],
-    runtime: runtimeIdentity(
-      options.nodeVersion,
-      options.platform,
-      options.arch
-    ),
-    serverSha256: sha256File(path26.join(generationDir, SERVER_FILE)),
-    clientSha256: sha256File(path26.join(generationDir, CLIENT_FILE)),
-    coverage: {
-      html: options.coverage.html,
-      businessApi: options.coverage.businessApi,
-      clientAssets: Array.from(new Set(options.coverage.clientAssets)).sort(),
-      actionPlugins: Array.from(new Set(options.coverage.actionPlugins)).sort()
-    }
-  };
-  writeJsonAtomic(path26.join(generationDir, PROBE_FILE), probe);
-  return probe;
-}
-function promotePreviewArtifactGeneration(generationDirInput) {
-  const generationDir = path26.resolve(generationDirInput);
-  const reasons = [];
-  let manifest;
-  let probe;
-  try {
-    manifest = readJson2(
-      path26.join(generationDir, MANIFEST_FILE)
-    );
-    probe = readJson2(
-      path26.join(generationDir, PROBE_FILE)
-    );
-  } catch (error) {
-    return {
-      promoted: false,
-      reasons: [
-        `probe evidence missing or invalid: ${error instanceof Error ? error.message : String(error)}`
-      ]
-    };
-  }
-  if (manifest.schemaVersion !== PREVIEW_ARTIFACT_SCHEMA_VERSION || probe.schemaVersion !== PREVIEW_ARTIFACT_SCHEMA_VERSION) {
-    reasons.push("schema version mismatch");
-  }
-  if (probe.generationId !== manifest.generationId) {
-    reasons.push("probe generation identity mismatch");
-  }
-  if (!probe.success) {
-    reasons.push(`probe failed: ${probe.reasons.join("; ") || "unknown"}`);
-  }
-  if (!sameRuntime(manifest.runtime, probe.runtime)) {
-    reasons.push(
-      "probe runtime identity does not match build runtime identity"
-    );
-  }
-  const currentServerHash = sha256File(path26.join(generationDir, SERVER_FILE));
-  const currentClientHash = sha256File(path26.join(generationDir, CLIENT_FILE));
-  if (currentServerHash !== manifest.files.server.sha256 || currentServerHash !== probe.serverSha256) {
-    reasons.push("server.bundle.cjs hash does not match probe identity");
-  }
-  if (currentClientHash !== manifest.files.client.sha256 || currentClientHash !== probe.clientSha256) {
-    reasons.push("client.zip hash does not match probe identity");
-  }
-  if (!probe.coverage.html) {
-    reasons.push("probe did not verify HTML");
-  }
-  if (!probe.coverage.businessApi) {
-    reasons.push("probe did not verify business API");
-  }
-  if (!Array.isArray(probe.coverage.clientAssets) || probe.coverage.clientAssets.length === 0) {
-    reasons.push("probe did not verify client entry assets");
-  }
-  const verifiedPlugins = new Set(probe.coverage.actionPlugins);
-  const missingPlugins = manifest.actionPlugins.filter(
-    (plugin) => !verifiedPlugins.has(plugin)
-  );
-  if (missingPlugins.length > 0) {
-    reasons.push(
-      `probe did not verify Action Plugin: ${missingPlugins.join(", ")}`
-    );
-  }
-  if (reasons.length > 0) {
-    return { promoted: false, reasons };
-  }
-  const promotedManifest = {
-    ...manifest,
-    runtimeProbeStatus: "passed",
-    consumable: true
-  };
-  writeJsonAtomic(path26.join(generationDir, MANIFEST_FILE), promotedManifest);
-  return { promoted: true, manifest: promotedManifest };
-}
-
-// src/commands/preview-artifact/probe.ts
-import * as fs31 from "fs";
-import * as net from "net";
-import * as os4 from "os";
-import * as path27 from "path";
-import { spawn as spawn2, spawnSync as spawnSync7 } from "child_process";
-
-// src/commands/preview-artifact/readiness.ts
-function isPreviewBusinessResponseReady(response) {
-  if (response.status === 401 || response.status === 403) return true;
-  return response.status !== 404 && response.status < 500 && !response.headers.get("content-type")?.includes("text/html");
-}
-
-// src/commands/preview-artifact/probe.ts
-function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
-}
-async function reservePort() {
-  return new Promise((resolve9, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("unable to reserve probe port")));
-        return;
-      }
-      server.close((error) => {
-        if (error) reject(error);
-        else resolve9(address.port);
-      });
-    });
-  });
-}
-function archiveEntries(archivePath) {
-  const listing = spawnSync7("unzip", ["-Z1", archivePath], {
-    encoding: "utf8"
-  });
-  if (listing.status !== 0) {
-    throw new Error(`client archive listing failed: ${listing.stderr.trim()}`);
-  }
-  const entries = listing.stdout.split("\n").filter(Boolean);
-  for (const entry of entries) {
-    const normalized = path27.posix.normalize(entry.replaceAll("\\", "/"));
-    if (path27.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
-      throw new Error(`client archive contains unsafe path: ${entry}`);
-    }
-  }
-  return entries;
-}
-function rejectArchivedSymlinks(archivePath) {
-  const listing = spawnSync7("unzip", ["-Z", "-l", archivePath], {
-    encoding: "utf8"
-  });
-  if (listing.status !== 0) {
-    throw new Error(
-      `client archive metadata listing failed: ${listing.stderr.trim()}`
-    );
-  }
-  for (const line of listing.stdout.split("\n")) {
-    if (/^l[rwxstST-]{9}\s/.test(line.trimStart())) {
-      throw new Error("client archive contains symlink");
-    }
-  }
-}
-function rejectSymlinks(root) {
-  const pending = [root];
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (!current) continue;
-    for (const entry of fs31.readdirSync(current, { withFileTypes: true })) {
-      const entryPath = path27.join(current, entry.name);
-      const stat = fs31.lstatSync(entryPath);
-      if (stat.isSymbolicLink()) {
-        throw new Error(`client archive contains symlink: ${entry.name}`);
-      }
-      if (stat.isDirectory()) pending.push(entryPath);
-    }
-  }
-}
-function isPathInside(parent, candidate) {
-  const relative5 = path27.relative(parent, candidate);
-  return relative5 !== "" && relative5 !== ".." && !relative5.startsWith(`..${path27.sep}`) && !path27.isAbsolute(relative5);
-}
-function clientEntryAssetReferences(html, appBasePath) {
-  const local = /* @__PURE__ */ new Set();
-  const localExecutable = /* @__PURE__ */ new Set();
-  const unsupportedExternal = /* @__PURE__ */ new Set();
-  const tags = /<(script|link)\b[^>]*>/gi;
-  const readAttribute = (tag, name) => new RegExp(`\\b${name}=["']([^"']+)["']`, "i").exec(tag)?.[1];
-  const base = new URL(appBasePath, "http://preview.local");
-  for (const match of html.matchAll(tags)) {
-    const tagName = match[1]?.toLowerCase();
-    const tag = match[0];
-    let linkRel = [];
-    if (tagName === "link") {
-      linkRel = readAttribute(tag, "rel")?.toLowerCase().split(/\s+/) ?? [];
-      if (!linkRel.some(
-        (value2) => [
-          "stylesheet",
-          "modulepreload",
-          "preload",
-          "icon",
-          "manifest"
-        ].includes(value2)
-      )) {
-        continue;
-      }
-    }
-    const value = readAttribute(
-      tag,
-      tagName === "script" ? "src" : "href"
-    )?.trim();
-    if (!value || value.startsWith("data:") || value.startsWith("#")) continue;
-    const resolved = new URL(value, base);
-    if (resolved.origin !== base.origin) {
-      if (tagName === "script" || linkRel.some(
-        (value2) => ["stylesheet", "modulepreload", "preload"].includes(value2)
-      )) {
-        unsupportedExternal.add(resolved.toString());
-      }
-      continue;
-    }
-    local.add(resolved.pathname);
-    if (tagName === "script") localExecutable.add(resolved.pathname);
-  }
-  return {
-    local: Array.from(local).sort(),
-    localExecutable: Array.from(localExecutable).sort(),
-    unsupportedExternal: Array.from(unsupportedExternal).sort()
-  };
-}
-function resolveClientEntryAsset(clientRoot, appBasePath, requestPath) {
-  let decoded;
-  try {
-    decoded = decodeURIComponent(requestPath);
-  } catch {
-    return void 0;
-  }
-  const normalizedBase = appBasePath.endsWith("/") ? appBasePath : `${appBasePath}/`;
-  const relative5 = decoded.startsWith(normalizedBase) ? decoded.slice(normalizedBase.length) : decoded.replace(/^\/+/, "");
-  if (!relative5 || relative5 === "index.html") return void 0;
-  const candidate = path27.resolve(clientRoot, relative5);
-  if (!isPathInside(clientRoot, candidate)) return void 0;
-  try {
-    const stat = fs31.lstatSync(candidate);
-    return stat.isFile() && !stat.isSymbolicLink() ? candidate : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function extractClientArchive(archivePath, destination) {
-  if (fs31.existsSync(destination)) {
-    throw new Error("client archive destination must not already exist");
-  }
-  archiveEntries(archivePath);
-  rejectArchivedSymlinks(archivePath);
-  fs31.mkdirSync(destination, { recursive: true });
-  try {
-    const extraction = spawnSync7(
-      "unzip",
-      ["-q", archivePath, "-d", destination],
-      { encoding: "utf8" }
-    );
-    if (extraction.status !== 0) {
-      throw new Error(
-        `client archive extraction failed: ${extraction.stderr.trim()}`
-      );
-    }
-    rejectSymlinks(destination);
-  } catch (error) {
-    fs31.rmSync(destination, { recursive: true, force: true });
-    throw error;
-  }
-}
-async function fetchUntil(url, timeoutAt) {
-  while (Date.now() < timeoutAt) {
-    try {
-      return await fetch(url, {
-        redirect: "manual",
-        signal: AbortSignal.timeout(1e3)
-      });
-    } catch {
-      await sleep(50);
-    }
-  }
-  return null;
-}
-function stopProcessGroup(pid) {
-  if (!pid) return;
-  try {
-    process.kill(-pid, "SIGTERM");
-  } catch {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      return;
-    }
-  }
-}
-async function runPreviewArtifactProbe(options) {
-  const generationDir = path27.resolve(options.generationDir);
-  const runtimeRoot = fs31.mkdtempSync(
-    path27.join(os4.tmpdir(), "preview-artifact-probe-")
-  );
-  const coverage = {
-    html: false,
-    businessApi: false,
-    clientAssets: [],
-    actionPlugins: []
-  };
-  const reasons = [];
-  const registryFile = path27.join(runtimeRoot, "plugin-registry.json");
-  let isolatedNodeModulesPresent = false;
-  let child;
-  try {
-    const runtimeBundle = path27.join(runtimeRoot, "server.bundle.cjs");
-    fs31.copyFileSync(
-      path27.join(generationDir, "server.bundle.cjs"),
-      runtimeBundle
-    );
-    const clientRoot = path27.join(runtimeRoot, "dist", "client");
-    extractClientArchive(path27.join(generationDir, "client.zip"), clientRoot);
-    isolatedNodeModulesPresent = fs31.existsSync(
-      path27.join(runtimeRoot, "node_modules")
-    );
-    if (isolatedNodeModulesPresent) {
-      reasons.push("isolated runtime unexpectedly contains node_modules");
-    }
-    const port = await reservePort();
-    const timeoutAt = Date.now() + (options.timeoutMs ?? 12e4);
-    child = spawn2(process.execPath, [runtimeBundle], {
-      cwd: runtimeRoot,
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        ...options.environment,
-        SERVER_PORT: String(port),
-        PREVIEW_ARTIFACT_PROBE_REGISTRY_FILE: registryFile
-      }
-    });
-    const origin = `http://127.0.0.1:${port}`;
-    const htmlResponse = await fetchUntil(
-      new URL(options.appBasePath, origin).toString(),
-      timeoutAt
-    );
-    coverage.html = htmlResponse?.status === 200;
-    if (!coverage.html) {
-      reasons.push(
-        `HTML probe failed with status ${htmlResponse?.status ?? "unreachable"}`
-      );
-    }
-    if (coverage.html && htmlResponse) {
-      const html = await htmlResponse.text();
-      const entryReferences = clientEntryAssetReferences(
-        html,
-        options.appBasePath
-      );
-      const entryAssets = entryReferences.local;
-      coverage.clientAssets = entryReferences.localExecutable;
-      if (entryReferences.localExecutable.length === 0) {
-        reasons.push("client HTML has no local executable entry asset");
-        for (const externalAsset of entryReferences.unsupportedExternal) {
-          reasons.push(
-            `external client entry asset is unsupported: ${externalAsset}`
-          );
-        }
-      }
-      for (const entryAsset of entryAssets) {
-        if (!resolveClientEntryAsset(clientRoot, options.appBasePath, entryAsset)) {
-          reasons.push(`client entry asset is unavailable: ${entryAsset}`);
-        }
-      }
-    }
-    const apiResponse = await fetchUntil(
-      new URL(options.businessApiPath, origin).toString(),
-      timeoutAt
-    );
-    coverage.businessApi = Boolean(
-      apiResponse && isPreviewBusinessResponseReady(apiResponse)
-    );
-    if (!coverage.businessApi) {
-      reasons.push(
-        `business API returned ${apiResponse?.status ?? "unreachable"}`
-      );
-    }
-    while (!fs31.existsSync(registryFile) && Date.now() < timeoutAt) {
-      await sleep(25);
-    }
-    if (fs31.existsSync(registryFile)) {
-      const parsed = JSON.parse(
-        fs31.readFileSync(registryFile, "utf8")
-      );
-      if (Array.isArray(parsed) && parsed.every((value) => typeof value === "string")) {
-        coverage.actionPlugins = parsed.filter((value) => typeof value === "string").sort();
-      } else {
-        reasons.push("Action Plugin registry evidence is invalid");
-      }
-    } else {
-      reasons.push("Action Plugin registry evidence is unavailable");
-    }
-  } catch (error) {
-    reasons.push(error instanceof Error ? error.message : String(error));
-  } finally {
-    stopProcessGroup(child?.pid);
-  }
-  const probe = recordPreviewArtifactProbe({
-    generationDir,
-    success: reasons.length === 0,
-    reasons,
-    nodeVersion: process.version,
-    platform: process.platform,
-    arch: process.arch,
-    coverage
-  });
-  fs31.rmSync(runtimeRoot, { recursive: true, force: true });
-  return { ...probe, isolatedNodeModulesPresent };
-}
-
-// src/commands/preview-artifact/environment.ts
-import * as fs32 from "fs";
-import * as path28 from "path";
-var ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function readPreviewArtifactEnvironmentFile(filePath) {
-  const resolved = path28.resolve(filePath);
-  const parsed = JSON.parse(fs32.readFileSync(resolved, "utf8"));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("preview artifact environment file must contain an object");
-  }
-  const environment = {};
-  for (const [key, value] of Object.entries(parsed)) {
-    if (!ENVIRONMENT_NAME.test(key) || typeof value !== "string") {
-      throw new Error(`invalid environment variable in ${resolved}: ${key}`);
-    }
-    environment[key] = value;
-  }
-  return environment;
-}
-function previewArtifactRuntimeEnvironment(environment) {
-  return {
-    ...environment,
-    NODE_ENV: environment?.NODE_ENV ?? "production",
-    // Probe and switcher connect through 127.0.0.1. Linux may resolve
-    // `localhost` to IPv6-only ::1, so the isolated Nest process must bind to
-    // the same explicit private endpoint instead of inheriting app defaults.
-    SERVER_HOST: "127.0.0.1"
-  };
-}
-
-// src/commands/preview-artifact/store.ts
-import * as fs33 from "fs";
-import * as path29 from "path";
-var GENERATION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-function readCurrentPointer(storeRoot) {
-  try {
-    const pointer = readJson3(
-      path29.join(storeRoot, "current.json")
-    );
-    return pointer.schemaVersion === PREVIEW_ARTIFACT_SCHEMA_VERSION && GENERATION_ID_PATTERN.test(pointer.generationId) ? pointer : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function readJson3(filePath) {
-  return JSON.parse(fs33.readFileSync(filePath, "utf8"));
-}
-function writeJsonAtomic2(filePath, value) {
-  fs33.mkdirSync(path29.dirname(filePath), { recursive: true });
-  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  fs33.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}
-`, {
-    mode: 384
-  });
-  fs33.renameSync(temporaryPath, filePath);
-}
-function pruneSupersededGenerations(generationsRoot, retainedGenerationIds) {
-  const retained = new Set(retainedGenerationIds);
-  for (const entry of fs33.readdirSync(generationsRoot, {
-    withFileTypes: true
-  })) {
-    if (retained.has(entry.name)) continue;
-    try {
-      fs33.rmSync(path29.join(generationsRoot, entry.name), {
-        recursive: true,
-        force: true
-      });
-    } catch {
-    }
-  }
-}
-function parseNodeMajor2(nodeVersion) {
-  const match = /^v?(\d+)(?:\.|$)/.exec(nodeVersion.trim());
-  return match ? Number(match[1]) : null;
-}
-function isPathInside2(parent, candidate) {
-  const relative5 = path29.relative(parent, candidate);
-  return relative5 !== "" && !relative5.startsWith(`..${path29.sep}`) && relative5 !== ".." && !path29.isAbsolute(relative5);
-}
-function validateRegularDirectory(directoryPath, label) {
-  try {
-    const stat = fs33.lstatSync(directoryPath);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-      return [`${label} must be a regular directory`];
-    }
-    return [];
-  } catch (error) {
-    return [
-      `${label} is unavailable: ${error instanceof Error ? error.message : String(error)}`
-    ];
-  }
-}
-function validateGeneration(generationDir, runtime) {
-  const reasons = validateRegularDirectory(
-    generationDir,
-    "generation directory"
-  );
-  if (reasons.length > 0) return { reasons };
-  let manifest;
-  let probe;
-  try {
-    manifest = readJson3(
-      path29.join(generationDir, "manifest.json")
-    );
-    probe = readJson3(
-      path29.join(generationDir, "probe.json")
-    );
-  } catch (error) {
-    return {
-      reasons: [
-        `generation metadata is invalid: ${error instanceof Error ? error.message : String(error)}`
-      ]
-    };
-  }
-  if (manifest.schemaVersion !== PREVIEW_ARTIFACT_SCHEMA_VERSION || manifest.protocolVersion !== PREVIEW_ARTIFACT_PROTOCOL_VERSION || probe.schemaVersion !== PREVIEW_ARTIFACT_SCHEMA_VERSION) {
-    reasons.push("generation schema version is incompatible");
-  }
-  if (!GENERATION_ID_PATTERN.test(manifest.generationId) || probe.generationId !== manifest.generationId) {
-    reasons.push("generation ID is invalid or inconsistent");
-  }
-  if (!manifest.consumable || manifest.runtimeProbeStatus !== "passed") {
-    reasons.push("generation is not consumable");
-  }
-  if (!probe.success) {
-    reasons.push("generation runtime probe did not pass");
-  }
-  if (!Array.isArray(probe.coverage?.clientAssets) || probe.coverage.clientAssets.length === 0) {
-    reasons.push("generation client asset evidence is invalid");
-  }
-  if (!/^[a-f0-9]{64}$/.test(manifest.buildEnvironmentSha256)) {
-    reasons.push("build environment identity is invalid");
-  }
-  const serverPath = path29.join(generationDir, "server.bundle.cjs");
-  const clientPath = path29.join(generationDir, "client.zip");
-  try {
-    if (sha256File(serverPath) !== manifest.files.server.sha256) {
-      reasons.push("server.bundle.cjs hash does not match manifest");
-    }
-    if (sha256File(clientPath) !== manifest.files.client.sha256) {
-      reasons.push("client.zip hash does not match manifest");
-    }
-  } catch (error) {
-    reasons.push(
-      `generation files are unavailable: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (probe.serverSha256 !== manifest.files.server.sha256 || probe.clientSha256 !== manifest.files.client.sha256) {
-    reasons.push("probe file identity does not match manifest");
-  }
-  if (runtime && (runtime.nodeMajor !== manifest.runtime.nodeMajor || runtime.platform !== manifest.runtime.platform || runtime.arch !== manifest.runtime.arch)) {
-    reasons.push("runtime identity is incompatible with generation");
-  }
-  return { manifest, reasons };
-}
-function publishPreviewArtifactGeneration(options) {
-  const storeRoot = path29.resolve(options.storeRoot);
-  const previousPointer = readCurrentPointer(storeRoot);
-  const stagingRoot = path29.join(storeRoot, ".staging");
-  const stagingDir = path29.resolve(options.stagingDir);
-  if (!isPathInside2(stagingRoot, stagingDir)) {
-    return {
-      published: false,
-      reasons: [
-        "staging directory must be inside the store .staging directory"
-      ]
-    };
-  }
-  const validation = validateGeneration(stagingDir);
-  if (!validation.manifest || validation.reasons.length > 0) {
-    return { published: false, reasons: validation.reasons };
-  }
-  const generationId = validation.manifest.generationId;
-  const generationsRoot = path29.join(storeRoot, "generations");
-  const generationDir = path29.join(generationsRoot, generationId);
-  fs33.mkdirSync(generationsRoot, { recursive: true });
-  if (fs33.existsSync(generationDir)) {
-    return {
-      published: false,
-      reasons: [`generation already exists: ${generationId}`]
-    };
-  }
-  try {
-    fs33.renameSync(stagingDir, generationDir);
-    const pointer = {
-      schemaVersion: PREVIEW_ARTIFACT_SCHEMA_VERSION,
-      generationId,
-      publishedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeJsonAtomic2(path29.join(storeRoot, "current.json"), pointer);
-    pruneSupersededGenerations(
-      generationsRoot,
-      [generationId, previousPointer?.generationId].filter(
-        (value) => Boolean(value)
-      )
-    );
-    return { published: true, generationId, generationDir };
-  } catch (error) {
-    return {
-      published: false,
-      reasons: [
-        `generation publication failed: ${error instanceof Error ? error.message : String(error)}`
-      ]
-    };
-  }
-}
-function resolveCurrentPreviewArtifact(options) {
-  const storeRoot = path29.resolve(options.storeRoot);
-  let pointer;
-  try {
-    pointer = readJson3(path29.join(storeRoot, "current.json"));
-  } catch (error) {
-    return {
-      resolved: false,
-      reasons: [
-        `current pointer is unavailable: ${error instanceof Error ? error.message : String(error)}`
-      ]
-    };
-  }
-  if (pointer.schemaVersion !== PREVIEW_ARTIFACT_SCHEMA_VERSION || !GENERATION_ID_PATTERN.test(pointer.generationId)) {
-    return {
-      resolved: false,
-      reasons: ["current generation ID or schema version is invalid"]
-    };
-  }
-  const nodeMajor = parseNodeMajor2(options.nodeVersion);
-  if (nodeMajor == null) {
-    return { resolved: false, reasons: ["runtime Node.js version is invalid"] };
-  }
-  const generationDir = path29.join(
-    storeRoot,
-    "generations",
-    pointer.generationId
-  );
-  const validation = validateGeneration(generationDir, {
-    nodeMajor,
-    platform: options.platform,
-    arch: options.arch
-  });
-  if (!validation.manifest || validation.reasons.length > 0) {
-    return { resolved: false, reasons: validation.reasons };
-  }
-  if (validation.manifest.generationId !== pointer.generationId) {
-    return {
-      resolved: false,
-      reasons: ["current pointer does not match generation manifest"]
-    };
-  }
-  if (validation.manifest.buildEnvironmentSha256 !== options.buildEnvironmentSha256) {
-    return {
-      resolved: false,
-      reasons: ["build environment is incompatible with generation"]
-    };
-  }
-  return {
-    resolved: true,
-    generationId: pointer.generationId,
-    generationDir,
-    manifest: validation.manifest
-  };
-}
-
-// src/commands/preview-artifact/producer.ts
-function defaultGenerationId() {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "");
-  return `${timestamp}-${crypto2.randomBytes(5).toString("hex")}`;
-}
-function runBuildCommand(projectRoot, buildCommand, environment) {
-  const result = spawnSync8(buildCommand.command, buildCommand.args, {
-    cwd: projectRoot,
-    env: { ...process.env, ...environment },
-    encoding: "utf8",
-    maxBuffer: 10 * 1024 * 1024
-  });
-  if (result.status === 0) return [];
-  return [`production build failed with exit ${result.status ?? "unknown"}`];
-}
-function createClientArchive(clientDir, archivePath) {
-  if (!fs34.existsSync(path30.join(clientDir, "index.html"))) {
-    return [`client build output is missing: ${clientDir}`];
-  }
-  const result = spawnSync8("zip", ["-qry", archivePath, "."], {
-    cwd: clientDir,
-    encoding: "utf8"
-  });
-  if (result.status === 0 && fs34.existsSync(archivePath)) return [];
-  return [`client archive failed with exit ${result.status ?? "unknown"}`];
-}
-function readActionPlugins2(metadataFile) {
-  const metadata = JSON.parse(fs34.readFileSync(metadataFile, "utf8"));
-  if (!Array.isArray(metadata.actionPlugins)) return [];
-  return metadata.actionPlugins.filter((value) => typeof value === "string").sort();
-}
-async function producePreviewArtifactGeneration(options) {
-  const startedAt = Date.now();
-  const projectRoot = path30.resolve(options.projectRoot);
-  const storeRoot = path30.resolve(options.storeRoot);
-  const generationId = options.generationId ?? defaultGenerationId();
-  const stagingDir = path30.join(
-    storeRoot,
-    ".staging",
-    `${generationId}.${process.pid}.${Date.now()}`
-  );
-  const failed = (reasons, probe) => ({
-    published: false,
-    generationId,
-    elapsedMs: Date.now() - startedAt,
-    reasons,
-    ...probe ? { probe } : {}
-  });
-  fs34.mkdirSync(stagingDir, { recursive: true });
-  try {
-    const buildEnvironment = previewArtifactBuildEnvironment(
-      options.environment,
-      options.appBasePath
-    );
-    const buildReasons = runBuildCommand(
-      projectRoot,
-      options.buildCommand ?? { command: "npm", args: ["run", "build:prod"] },
-      buildEnvironment
-    );
-    if (buildReasons.length > 0) return failed(buildReasons);
-    const serverOutfile = path30.join(stagingDir, "server.bundle.cjs");
-    const serverMetadataFile = path30.join(stagingDir, "server-build.json");
-    const serverResult = await buildPreviewServerArtifact({
-      projectRoot,
-      entry: "dist/main.js",
-      outfile: serverOutfile,
-      metadataFile: serverMetadataFile
-    });
-    if (!serverResult.built) return failed(serverResult.reasons);
-    const archiveReasons = createClientArchive(
-      path30.join(projectRoot, "dist", "client"),
-      path30.join(stagingDir, "client.zip")
-    );
-    if (archiveReasons.length > 0) return failed(archiveReasons);
-    const actionPlugins = readActionPlugins2(serverMetadataFile);
-    fs34.rmSync(serverMetadataFile, { force: true });
-    createPreviewArtifactManifest({
-      generationDir: stagingDir,
-      generationId,
-      nodeVersion: process.version,
-      platform: process.platform,
-      arch: process.arch,
-      buildEnvironmentSha256: previewArtifactBuildEnvironmentHash(
-        options.environment,
-        options.appBasePath
-      ),
-      actionPlugins
-    });
-    const probe = await runPreviewArtifactProbe({
-      generationDir: stagingDir,
-      appBasePath: options.appBasePath,
-      businessApiPath: options.businessApiPath,
-      environment: previewArtifactRuntimeEnvironment(options.environment)
-    });
-    if (!probe.success) return failed(probe.reasons, probe);
-    const promotion = promotePreviewArtifactGeneration(stagingDir);
-    if (!promotion.promoted) return failed(promotion.reasons, probe);
-    const publication = publishPreviewArtifactGeneration({
-      storeRoot,
-      stagingDir
-    });
-    if (!publication.published) return failed(publication.reasons, probe);
-    return {
-      published: true,
-      generationId,
-      generationDir: publication.generationDir,
-      elapsedMs: Date.now() - startedAt,
-      probe
-    };
-  } catch (error) {
-    return failed([error instanceof Error ? error.message : String(error)]);
-  } finally {
-    fs34.rmSync(stagingDir, { recursive: true, force: true });
-  }
-}
-
-// src/commands/preview-artifact/runtime.ts
-import * as fs36 from "fs";
-import * as net3 from "net";
-import * as path32 from "path";
-import { spawn as spawn3 } from "child_process";
-
-// src/commands/preview-artifact/switcher.ts
-import * as http from "http";
-import * as net2 from "net";
-import * as fs35 from "fs";
-import * as path31 from "path";
-function targetOrigin(target) {
-  return `http://${target.host}:${target.port}`;
-}
-function proxyHttpRequest(target, request2, response, fallback) {
-  const upstream = http.request(
-    {
-      host: target.host,
-      port: target.port,
-      method: request2.method,
-      path: request2.url,
-      headers: request2.headers
-    },
-    (upstreamResponse) => {
-      const upstreamContentType = upstreamResponse.headers["content-type"];
-      const isHtmlFallback = typeof upstreamContentType === "string" && upstreamContentType.toLowerCase().includes("text/html");
-      if (fallback && (upstreamResponse.statusCode === 404 || isHtmlFallback)) {
-        upstreamResponse.resume();
-        fallback();
-        return;
-      }
-      response.writeHead(
-        upstreamResponse.statusCode ?? 502,
-        upstreamResponse.headers
-      );
-      upstreamResponse.pipe(response);
-    }
-  );
-  upstream.on("error", (error) => {
-    if (!response.headersSent) {
-      response.writeHead(502, { "content-type": "application/json" });
-    }
-    response.end(
-      JSON.stringify({
-        ready: false,
-        error: error.code ?? "upstream"
-      })
-    );
-  });
-  request2.pipe(upstream);
-}
-function cachedAssetFile(request2, cachedAssetFiles) {
-  if (request2.method !== "GET" && request2.method !== "HEAD") return void 0;
-  if (!cachedAssetFiles) return void 0;
-  const pathname = new URL(request2.url ?? "/", "http://preview.local").pathname;
-  return cachedAssetFiles.get(pathname);
-}
-function contentType(filePath) {
-  switch (path31.extname(filePath).toLowerCase()) {
-    case ".js":
-    case ".mjs":
-      return "text/javascript; charset=utf-8";
-    case ".css":
-      return "text/css; charset=utf-8";
-    case ".json":
-    case ".map":
-      return "application/json; charset=utf-8";
-    case ".svg":
-      return "image/svg+xml";
-    case ".png":
-      return "image/png";
-    case ".jpg":
-    case ".jpeg":
-      return "image/jpeg";
-    case ".gif":
-      return "image/gif";
-    case ".webp":
-      return "image/webp";
-    case ".ico":
-      return "image/x-icon";
-    case ".woff":
-      return "font/woff";
-    case ".woff2":
-      return "font/woff2";
-    case ".ttf":
-      return "font/ttf";
-    case ".wasm":
-      return "application/wasm";
-    default:
-      return "application/octet-stream";
-  }
-}
-function serveCachedAsset(request2, response, filePath) {
-  let stat;
-  try {
-    stat = fs35.lstatSync(filePath);
-  } catch {
-    response.writeHead(404).end();
-    return;
-  }
-  if (!stat.isFile() || stat.isSymbolicLink()) {
-    response.writeHead(404).end();
-    return;
-  }
-  response.writeHead(200, {
-    "content-type": contentType(filePath),
-    "content-length": stat.size,
-    "cache-control": "no-store"
-  });
-  if (request2.method === "HEAD") {
-    response.end();
-    return;
-  }
-  const stream = fs35.createReadStream(filePath);
-  stream.on("error", () => response.destroy());
-  stream.pipe(response);
-}
-function proxyUpgrade(target, request2, socket, head) {
-  const upstream = net2.connect(target.port, target.host, () => {
-    const headers = Object.entries(request2.headers).flatMap(([name, value]) => {
-      if (Array.isArray(value)) return value.map((item) => `${name}: ${item}`);
-      return value == null ? [] : [`${name}: ${value}`];
-    }).join("\r\n");
-    upstream.write(
-      `${request2.method ?? "GET"} ${request2.url ?? "/"} HTTP/${request2.httpVersion}\r
-${headers}\r
-\r
-`
-    );
-    if (head.length > 0) upstream.write(head);
-    socket.pipe(upstream).pipe(socket);
-  });
-  upstream.on("error", () => socket.destroy());
-  socket.on("error", () => upstream.destroy());
-}
-async function freshTargetReady(target, healthPath, businessPath) {
-  try {
-    const response = await fetch(new URL(healthPath, targetOrigin(target)), {
-      signal: AbortSignal.timeout(1e3)
-    });
-    if (response.status !== 200) return false;
-    const body = await response.json();
-    if (body.ready !== true) return false;
-    const businessResponse = await fetch(
-      new URL(businessPath, targetOrigin(target)),
-      { signal: AbortSignal.timeout(1e3), redirect: "manual" }
-    );
-    return isPreviewBusinessResponseReady(businessResponse);
-  } catch {
-    return false;
-  }
-}
-function createPreviewArtifactSwitcher(options) {
-  const listenHost = options.listenHost ?? "127.0.0.1";
-  const healthPath = options.freshHealthPath ?? "/dev/health";
-  const pollIntervalMs = options.pollIntervalMs ?? 100;
-  let active = "cached";
-  let closed = false;
-  let pollTimer;
-  let settleCutover;
-  const cutover = new Promise((resolve9) => {
-    settleCutover = resolve9;
-  });
-  const currentTarget = () => active === "cached" ? options.cachedTarget : options.freshTarget;
-  const server = http.createServer((request2, response) => {
-    if (request2.url?.split("?")[0] === "/dev/health") {
-      response.writeHead(200, { "content-type": "application/json" });
-      response.end(
-        JSON.stringify({
-          ready: true,
-          active,
-          generationId: options.generationId
-        })
-      );
-      return;
-    }
-    const assetFile = cachedAssetFile(request2, options.cachedAssetFiles);
-    if (active === "cached" && assetFile) {
-      serveCachedAsset(request2, response, assetFile);
-      return;
-    }
-    const target = currentTarget();
-    const fallback = active === "fresh" && assetFile ? () => serveCachedAsset(request2, response, assetFile) : void 0;
-    proxyHttpRequest(target, request2, response, fallback);
-  });
-  server.on("upgrade", (request2, socket, head) => {
-    proxyUpgrade(currentTarget(), request2, socket, head);
-  });
-  const schedulePoll = () => {
-    if (closed || active === "fresh") return;
-    pollTimer = setTimeout(async () => {
-      if (await freshTargetReady(
-        options.freshTarget,
-        healthPath,
-        options.freshBusinessPath
-      )) {
-        active = "fresh";
-        settleCutover?.({
-          switched: true,
-          active,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        settleCutover = void 0;
-        return;
-      }
-      schedulePoll();
-    }, pollIntervalMs);
-    pollTimer.unref();
-  };
-  return {
-    get active() {
-      return active;
-    },
-    cutover,
-    start() {
-      return new Promise((resolve9, reject) => {
-        server.once("error", reject);
-        server.listen(options.listenPort, listenHost, () => {
-          const address = server.address();
-          if (!address || typeof address === "string") {
-            reject(new Error("switcher did not expose a TCP address"));
-            return;
-          }
-          schedulePoll();
-          resolve9({
-            host: listenHost,
-            port: address.port,
-            origin: `http://${listenHost}:${address.port}`
-          });
-        });
-      });
-    },
-    close() {
-      closed = true;
-      if (pollTimer) clearTimeout(pollTimer);
-      if (settleCutover) {
-        settleCutover({
-          switched: false,
-          active,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        settleCutover = void 0;
-      }
-      return new Promise((resolve9) => {
-        server.close(() => resolve9());
-        server.closeAllConnections?.();
-      });
-    }
-  };
-}
-
-// src/commands/preview-artifact/runtime.ts
-function sleep2(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
-}
-async function reservePort2() {
-  return new Promise((resolve9, reject) => {
-    const server = net3.createServer();
-    server.unref();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("unable to reserve runtime port")));
-        return;
-      }
-      server.close((error) => {
-        if (error) reject(error);
-        else resolve9(address.port);
-      });
-    });
-  });
-}
-function stopProcessGroup2(child) {
-  if (!child?.pid) return;
-  try {
-    process.kill(-child.pid, "SIGTERM");
-  } catch {
-    try {
-      child.kill("SIGTERM");
-    } catch {
-      return;
-    }
-  }
-}
-function isPathInside3(parent, candidate) {
-  const relative5 = path32.relative(parent, candidate);
-  return relative5 !== "" && relative5 !== ".." && !relative5.startsWith(`..${path32.sep}`) && !path32.isAbsolute(relative5);
-}
-function ensureRegularRuntimeRoot(runtimeRoot) {
-  fs36.mkdirSync(runtimeRoot, { recursive: true });
-  const stat = fs36.lstatSync(runtimeRoot);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error("runtime root must be a regular directory");
-  }
-}
-function collectCachedAssetFiles(clientRoot, appBasePath) {
-  const files = /* @__PURE__ */ new Map();
-  const basePath = appBasePath.endsWith("/") ? appBasePath : `${appBasePath}/`;
-  const visit = (directory) => {
-    for (const entry of fs36.readdirSync(directory, { withFileTypes: true })) {
-      const absolute = path32.join(directory, entry.name);
-      if (entry.isDirectory()) {
-        visit(absolute);
-        continue;
-      }
-      if (!entry.isFile() || entry.isSymbolicLink()) continue;
-      const relative5 = path32.relative(clientRoot, absolute).split(path32.sep).join("/");
-      if (relative5 === "index.html") continue;
-      files.set(
-        new URL(`/${relative5}`, "http://preview.local").pathname,
-        absolute
-      );
-      files.set(
-        new URL(relative5, `http://preview.local${basePath}`).pathname,
-        absolute
-      );
-    }
-  };
-  visit(clientRoot);
-  return files;
-}
-function writeMarkerAtomic(markerFile, marker) {
-  fs36.mkdirSync(path32.dirname(markerFile), { recursive: true });
-  const temporaryFile = `${markerFile}.${process.pid}.${Date.now()}.tmp`;
-  fs36.writeFileSync(temporaryFile, `${JSON.stringify(marker, null, 2)}
-`, {
-    mode: 384
-  });
-  fs36.renameSync(temporaryFile, markerFile);
-}
-async function waitForCachedRuntime(origin, appBasePath, businessApiPath, timeoutMs, child) {
-  const timeoutAt = Date.now() + timeoutMs;
-  while (Date.now() < timeoutAt) {
-    if (child.exitCode != null || child.signalCode != null) {
-      throw new Error(
-        `cached runtime exited before readiness: ${child.exitCode ?? child.signalCode}`
-      );
-    }
-    try {
-      const response = await fetch(new URL(appBasePath, origin), {
-        redirect: "manual",
-        signal: AbortSignal.timeout(1e3)
-      });
-      if (response.status === 200) {
-        const businessResponse = await fetch(new URL(businessApiPath, origin), {
-          redirect: "manual",
-          signal: AbortSignal.timeout(1e3)
-        });
-        if (isPreviewBusinessResponseReady(businessResponse)) {
-          return;
-        }
-      }
-    } catch {
-    }
-    await sleep2(50);
-  }
-  throw new Error("cached runtime readiness timed out");
-}
-async function startPreviewArtifactRuntime(options) {
-  const resolved = resolveCurrentPreviewArtifact({
-    storeRoot: options.storeRoot,
-    nodeVersion: process.version,
-    platform: process.platform,
-    arch: process.arch,
-    buildEnvironmentSha256: previewArtifactBuildEnvironmentHash(
-      options.environment,
-      options.appBasePath
-    )
-  });
-  if (!resolved.resolved) return { started: false, reasons: resolved.reasons };
-  const runtimeRoot = path32.resolve(options.runtimeRoot);
-  const markerFile = path32.resolve(options.markerFile);
-  let runtimeDir;
-  let cachedRuntime;
-  let switcher;
-  let closed = false;
-  const cleanup = async () => {
-    if (closed) return;
-    closed = true;
-    stopProcessGroup2(cachedRuntime);
-    await switcher?.close();
-    fs36.rmSync(markerFile, { force: true });
-    if (runtimeDir) fs36.rmSync(runtimeDir, { recursive: true, force: true });
-  };
-  try {
-    ensureRegularRuntimeRoot(runtimeRoot);
-    if (!isPathInside3(runtimeRoot, markerFile)) {
-      throw new Error("runtime marker must be inside the runtime root");
-    }
-    runtimeDir = fs36.mkdtempSync(
-      path32.join(runtimeRoot, `${resolved.generationId}-`)
-    );
-    const runtimeBundle = path32.join(runtimeDir, "server.bundle.cjs");
-    fs36.copyFileSync(
-      path32.join(resolved.generationDir, "server.bundle.cjs"),
-      runtimeBundle
-    );
-    const clientRoot = path32.join(runtimeDir, "dist", "client");
-    extractClientArchive(
-      path32.join(resolved.generationDir, "client.zip"),
-      clientRoot
-    );
-    const cachedServerPort = options.cachedServerPort === 0 ? await reservePort2() : options.cachedServerPort;
-    cachedRuntime = spawn3(process.execPath, [runtimeBundle], {
-      cwd: runtimeDir,
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        ...previewArtifactRuntimeEnvironment(options.environment),
-        SERVER_PORT: String(cachedServerPort)
-      }
-    });
-    const cachedOrigin = `http://127.0.0.1:${cachedServerPort}`;
-    await waitForCachedRuntime(
-      cachedOrigin,
-      options.appBasePath,
-      options.businessApiPath,
-      options.startupTimeoutMs ?? 3e4,
-      cachedRuntime
-    );
-    switcher = createPreviewArtifactSwitcher({
-      listenHost: options.listenHost,
-      listenPort: options.listenPort,
-      generationId: resolved.generationId,
-      cachedTarget: { host: "127.0.0.1", port: cachedServerPort },
-      freshTarget: { host: "127.0.0.1", port: options.freshClientPort },
-      freshBusinessPath: options.businessApiPath,
-      cachedAssetFiles: collectCachedAssetFiles(
-        clientRoot,
-        options.appBasePath
-      ),
-      pollIntervalMs: options.pollIntervalMs
-    });
-    const address = await switcher.start();
-    const runtimeMarker = {
-      schemaVersion: 1,
-      status: "cached-serving",
-      generationId: resolved.generationId,
-      publicPort: address.port,
-      cachedServerPort,
-      freshServerPort: options.freshServerPort,
-      freshClientPort: options.freshClientPort,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeMarkerAtomic(markerFile, runtimeMarker);
-    const cutover = switcher.cutover.then(async (result) => {
-      if (result.switched) {
-        runtimeMarker.status = "fresh-serving";
-        runtimeMarker.cutoverAt = result.at;
-        writeMarkerAtomic(markerFile, runtimeMarker);
-      }
-      return result;
-    });
-    return {
-      started: true,
-      generationId: resolved.generationId,
-      origin: address.origin,
-      port: address.port,
-      runtimeDir,
-      cutover,
-      close: cleanup
-    };
-  } catch (error) {
-    await cleanup();
-    return {
-      started: false,
-      reasons: [error instanceof Error ? error.message : String(error)]
-    };
-  }
-}
-
 // src/commands/build/index.ts
 var getTokenCommand = {
   name: "get-token",
   description: "Get artifact upload credential (STI token)",
   register(program) {
-    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").requiredOption("--scene <scene>", "Build scene (pipeline, static)").option("--commit-id <id>", "Git commit ID (required for pipeline scene)").action(
-      async (options) => {
-        await getToken(options);
-      }
-    );
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").requiredOption("--scene <scene>", "Build scene (pipeline, static)").option("--commit-id <id>", "Git commit ID (required for pipeline scene)").action(async (options) => {
+      await getToken(options);
+    });
   }
 };
 var uploadStaticCommand = {
   name: "upload-static",
   description: "Upload shared/static files to TOS",
   register(program) {
-    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").option(
-      "--static-dir <dir>",
-      "Static files directory",
-      UPLOAD_STATIC_DEFAULTS.staticDir
-    ).option(
-      "--tosutil-path <path>",
-      "Path to tosutil binary",
-      UPLOAD_STATIC_DEFAULTS.tosutilPath
-    ).option(
-      "--endpoint <endpoint>",
-      "TOS endpoint",
-      UPLOAD_STATIC_DEFAULTS.endpoint
-    ).option("--region <region>", "TOS region", UPLOAD_STATIC_DEFAULTS.region).action(async (options) => {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").option("--static-dir <dir>", "Static files directory", UPLOAD_STATIC_DEFAULTS.staticDir).option("--tosutil-path <path>", "Path to tosutil binary", UPLOAD_STATIC_DEFAULTS.tosutilPath).option("--endpoint <endpoint>", "TOS endpoint", UPLOAD_STATIC_DEFAULTS.endpoint).option("--region <region>", "TOS region", UPLOAD_STATIC_DEFAULTS.region).action(async (options) => {
       await uploadStatic(options);
     });
   }
@@ -10056,142 +8126,10 @@ var preUploadStaticCommand = {
     });
   }
 };
-var previewServerArtifactCommand = {
-  name: "preview-server-artifact",
-  description: "Build and audit a single-file Nest preview server artifact",
-  register(program) {
-    program.command(this.name).description(this.description).option("--project-root <dir>", "Application project root", process.cwd()).option("--entry <file>", "Compiled Nest entry", "dist/main.js").option(
-      "--outfile <file>",
-      "Output bundle",
-      ".preview-artifact/server.bundle.cjs"
-    ).option("--metadata-file <file>", "Output build metadata file").action(
-      async (options) => {
-        const result = await buildPreviewServerArtifact(options);
-        console.log(JSON.stringify(result));
-        if (!result.built) {
-          process.exitCode = 2;
-        }
-      }
-    );
-  }
-};
-var previewArtifactGenerationCommand = {
-  name: "preview-artifact-generation",
-  description: "Build, probe, promote, and atomically publish a Preview Artifact generation",
-  register(program) {
-    program.command(this.name).description(this.description).option("--project-root <dir>", "Application project root", process.cwd()).requiredOption("--store-root <dir>", "Immutable generation store root").option("--generation-id <id>", "Explicit immutable generation ID").requiredOption("--app-base-path <path>", "Application HTML probe path").requiredOption(
-      "--business-api-path <path>",
-      "Business API probe path that must not return 404/5xx"
-    ).requiredOption(
-      "--environment-file <file>",
-      "JSON application environment passed only to build/probe children"
-    ).action(
-      async (options) => {
-        const result = await producePreviewArtifactGeneration({
-          ...options,
-          environment: readPreviewArtifactEnvironmentFile(
-            options.environmentFile
-          )
-        });
-        console.log(JSON.stringify(result));
-        if (!result.published) process.exitCode = 2;
-      }
-    );
-  }
-};
-function parseTcpPort(value) {
-  const port = Number(value);
-  if (!Number.isInteger(port) || port < 0 || port > 65535) {
-    throw new Error(`invalid TCP port: ${value}`);
-  }
-  return port;
-}
-var previewArtifactRuntimeCommand = {
-  name: "preview-artifact-runtime",
-  description: "Serve a verified Preview Artifact and switch to the fresh dev service",
-  register(program) {
-    program.command(this.name).description(this.description).requiredOption("--store-root <dir>", "Immutable generation store root").option(
-      "--runtime-root <dir>",
-      "Ephemeral runtime root",
-      "/tmp/preview-artifact"
-    ).option(
-      "--marker-file <file>",
-      "Atomic runtime marker file",
-      "/tmp/preview-artifact/runtime.json"
-    ).option(
-      "--listen-port <port>",
-      "Stable public preview port",
-      parseTcpPort,
-      8001
-    ).option(
-      "--cached-server-port <port>",
-      "Isolated cached Nest server port, 0 selects a free port",
-      parseTcpPort,
-      0
-    ).option(
-      "--fresh-server-port <port>",
-      "Fresh Nest shadow port recorded for dev startup",
-      parseTcpPort,
-      3001
-    ).option(
-      "--fresh-client-port <port>",
-      "Fresh Vite shadow port used as the cutover target",
-      parseTcpPort,
-      8002
-    ).requiredOption(
-      "--app-base-path <path>",
-      "Application HTML readiness path"
-    ).requiredOption(
-      "--business-api-path <path>",
-      "Business API path revalidated with the current runtime environment"
-    ).requiredOption(
-      "--environment-file <file>",
-      "JSON application environment passed only to cached application child"
-    ).action(
-      async (options) => {
-        const runtime = await startPreviewArtifactRuntime({
-          ...options,
-          environment: readPreviewArtifactEnvironmentFile(
-            options.environmentFile
-          )
-        });
-        if (!runtime.started) {
-          console.log(JSON.stringify(runtime));
-          process.exitCode = 2;
-          return;
-        }
-        console.log(
-          JSON.stringify({
-            started: true,
-            generationId: runtime.generationId,
-            origin: runtime.origin,
-            runtimeDir: runtime.runtimeDir
-          })
-        );
-        void runtime.cutover.then((result) => {
-          console.log(JSON.stringify({ event: "fresh-cutover", ...result }));
-        });
-        const shutdown = async () => {
-          await runtime.close();
-          process.exit(0);
-        };
-        process.once("SIGTERM", () => void shutdown());
-        process.once("SIGINT", () => void shutdown());
-      }
-    );
-  }
-};
 var buildCommandGroup = {
   name: "build",
   description: "Build related commands",
-  commands: [
-    getTokenCommand,
-    uploadStaticCommand,
-    preUploadStaticCommand,
-    previewServerArtifactCommand,
-    previewArtifactGenerationCommand,
-    previewArtifactRuntimeCommand
-  ]
+  commands: [getTokenCommand, uploadStaticCommand, preUploadStaticCommand]
 };
 
 // src/commands/index.ts
@@ -10208,12 +8146,12 @@ var commands = [
 ];
 
 // src/index.ts
-var envPath = path33.join(process.cwd(), ".env");
-if (fs37.existsSync(envPath)) {
+var envPath = path25.join(process.cwd(), ".env");
+if (fs29.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path33.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs37.readFileSync(path33.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path25.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs29.readFileSync(path25.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();