@logixjs/cli 1.0.1

package/dist/chunk-TDQVD2IA.js

@@ -0,0 +1,1193 @@
+import {
+  stableStringifyJson
+} from "./chunk-RF7XSP3P.js";
+import {
+  asSerializableErrorSummary,
+  exitCodeFromErrorSummary,
+  makeCliError,
+  makeErrorCommandResult,
+  sortArtifactsByOutputKey
+} from "./chunk-6DZEO5HP.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Commands.ts
+var Commands_exports = {};
+__export(Commands_exports, {
+  formatCommandResult: () => formatCommandResult,
+  main: () => main,
+  printHelp: () => printHelp,
+  runCli: () => runCli
+});
+import { Effect as Effect3, Logger } from "effect";
+
+// src/internal/args.ts
+import path from "path";
+import { Effect } from "effect";
+var decapitalize = (s) => s.length === 0 ? s : `${s[0].toLowerCase()}${s.slice(1)}`;
+var parseConfigValue = (value) => {
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  const asNumber = Number(trimmed);
+  return Number.isFinite(asNumber) ? asNumber : trimmed;
+};
+var parseEntryRefFromOptions = (opts) => {
+  const entryRaw = typeof opts.entry === "string" ? opts.entry.trim() : void 0;
+  if (!entryRaw) {
+    return Effect.fail(
+      makeCliError({
+        code: "CLI_INVALID_ARGUMENT",
+        message: "\u7F3A\u5C11\u5165\u53E3\uFF1A\u8BF7\u63D0\u4F9B --entry <modulePath>#<exportName>"
+      })
+    );
+  }
+  const hash = entryRaw.lastIndexOf("#");
+  if (hash > 0 && hash < entryRaw.length - 1) {
+    return Effect.succeed({ modulePath: entryRaw.slice(0, hash), exportName: entryRaw.slice(hash + 1) });
+  }
+  return Effect.fail(
+    makeCliError({
+      code: "CLI_INVALID_ARGUMENT",
+      message: `--entry \u975E\u6CD5\uFF1A${entryRaw}\uFF08\u671F\u671B <modulePath>#<exportName>\uFF09`
+    })
+  );
+};
+var parseIrValidateInputFromOptions = (opts) => {
+  const dir = typeof opts.inDir === "string" ? opts.inDir.trim() : void 0;
+  const file = typeof opts.artifact === "string" ? opts.artifact.trim() : void 0;
+  if (dir && file) {
+    return Effect.fail(
+      makeCliError({
+        code: "CLI_INVALID_ARGUMENT",
+        message: "\u53C2\u6570\u4E92\u65A5\uFF1A\u8BF7\u4EC5\u63D0\u4F9B --in \u6216 --artifact\u3002"
+      })
+    );
+  }
+  if (dir) return Effect.succeed({ kind: "dir", dir });
+  if (file) return Effect.succeed({ kind: "file", file });
+  return Effect.fail(
+    makeCliError({
+      code: "CLI_INVALID_ARGUMENT",
+      message: "\u7F3A\u5C11\u8F93\u5165\uFF1A\u8BF7\u63D0\u4F9B --in <dir> \u6216 --artifact <file>"
+    })
+  );
+};
+var parseIrDiffInputFromOptions = (opts) => {
+  const before = typeof opts.before === "string" ? opts.before.trim() : void 0;
+  const after = typeof opts.after === "string" ? opts.after.trim() : void 0;
+  if (!before || !after) {
+    return Effect.fail(
+      makeCliError({
+        code: "CLI_INVALID_ARGUMENT",
+        message: "\u7F3A\u5C11\u8F93\u5165\uFF1A\u8BF7\u63D0\u4F9B --before <dir|file> \u4E0E --after <dir|file>"
+      })
+    );
+  }
+  return Effect.succeed({ before, after });
+};
+var booleanOptionNames = /* @__PURE__ */ new Set([
+  "allowWarn",
+  "includeAnchorAutofill",
+  "includeContextPack",
+  "includeTrace",
+  "includeUiKitRegistry",
+  "json",
+  "requireRulesManifest"
+]);
+var flagsWithValue = /* @__PURE__ */ new Set([
+  "--after",
+  "--artifact",
+  "--baseline",
+  "--before",
+  "--budgetBytes",
+  "--cliConfig",
+  "--config",
+  "--diagnosticsLevel",
+  "--entry",
+  "--host",
+  "--in",
+  "--inputs",
+  "--maxEvents",
+  "--maxRawMode",
+  "--maxUsedServices",
+  "--mode",
+  "--ops",
+  "--out",
+  "--outRoot",
+  "--packMaxBytes",
+  "--profile",
+  "--repoRoot",
+  "--runId",
+  "--timeout",
+  "--tsconfig"
+]);
+var isKnownBooleanFlag = (flag) => {
+  if (!flag.startsWith("--")) return false;
+  const name = flag.slice(2);
+  if (booleanOptionNames.has(name)) return true;
+  if (name.startsWith("no")) {
+    const canonical = decapitalize(name.slice(2));
+    return booleanOptionNames.has(canonical);
+  }
+  return false;
+};
+var canonicalOptionKey = (flag) => {
+  if (!flag.startsWith("--")) return void 0;
+  const name = flag.slice(2);
+  if (isKnownBooleanFlag(flag)) {
+    if (name.startsWith("no")) return decapitalize(name.slice(2));
+    return name;
+  }
+  return name;
+};
+var parseOptionOccurrences = (tokens) => {
+  const out = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("-")) {
+      const key = canonicalOptionKey(token);
+      const allowMultiple = key === "config";
+      if (flagsWithValue.has(token)) {
+        const value = tokens[i + 1];
+        if (value !== void 0) {
+          out.push({ key, tokens: [token, value], allowMultiple });
+          i += 1;
+          continue;
+        }
+        out.push({ key, tokens: [token], allowMultiple });
+        continue;
+      }
+      out.push({ key, tokens: [token], allowMultiple });
+      continue;
+    }
+    out.push({ tokens: [token], allowMultiple: true });
+  }
+  return out;
+};
+var dedupeOptionTokensLastWins = (tokens) => {
+  const occurrences = parseOptionOccurrences(tokens);
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (let i = occurrences.length - 1; i >= 0; i--) {
+    const occ = occurrences[i];
+    if (!occ.key || occ.allowMultiple) {
+      kept.push(occ);
+      continue;
+    }
+    if (seen.has(occ.key)) continue;
+    seen.add(occ.key);
+    kept.push(occ);
+  }
+  kept.reverse();
+  return kept.flatMap((o) => o.tokens);
+};
+var commandTokenShapes = [
+  ["describe"],
+  ["trialrun"],
+  ["ir", "export"],
+  ["ir", "validate"],
+  ["ir", "diff"],
+  ["contract-suite", "run"],
+  ["spy", "evidence"],
+  ["anchor", "index"],
+  ["anchor", "autofill"],
+  ["transform", "module"]
+];
+var findCommandTokens = (argv) => {
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token.startsWith("-")) {
+      if (flagsWithValue.has(token)) i += 1;
+      continue;
+    }
+    for (const shape of commandTokenShapes) {
+      if (shape[0] !== token) continue;
+      let ok = true;
+      for (let j = 1; j < shape.length; j++) {
+        if (argv[i + j] !== shape[j]) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) continue;
+      return { tokens: shape, indices: shape.map((_, j) => i + j) };
+    }
+  }
+  return void 0;
+};
+var normalizeArgvForEffectCli = (argv) => {
+  const extracted = findCommandTokens(argv);
+  if (!extracted) return dedupeOptionTokensLastWins(argv);
+  const drop = new Set(extracted.indices);
+  const rest = argv.filter((_, idx) => !drop.has(idx));
+  return [...extracted.tokens, ...dedupeOptionTokensLastWins(rest)];
+};
+var ANSI_CSI_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var renderValidationError = (err) => {
+  if (err instanceof Error && typeof err.message === "string" && err.message.length > 0) {
+    return err.message.replace(ANSI_CSI_REGEX, "").trim();
+  }
+  return typeof err === "string" ? err : "CLI validation failed";
+};
+var defaultParsedOptions = () => ({
+  host: "node",
+  repoRoot: ".",
+  diagnosticsLevel: "light",
+  includeTrace: false,
+  config: {},
+  allowWarn: false,
+  includeContextPack: false,
+  requireRulesManifest: false,
+  includeUiKitRegistry: false,
+  includeAnchorAutofill: false,
+  describeJson: false
+});
+var invalidArgument = (message, helpText) => makeCliError({
+  code: "CLI_INVALID_ARGUMENT",
+  message,
+  hint: helpText
+});
+var missingFlagError = (message, helpText) => makeCliError({
+  code: "CLI_INVALID_ARGUMENT",
+  message,
+  hint: helpText
+});
+var parseManualOptions = (tokens, helpText) => Effect.sync(() => {
+  const options = { ...defaultParsedOptions() };
+  const readValue = (flag, index) => {
+    const value = tokens[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw missingFlagError(`\u7F3A\u5C11\u53C2\u6570\u503C\uFF1A${flag}`, helpText);
+    }
+    return value;
+  };
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token.startsWith("--")) {
+      throw invalidArgument(`\u672A\u77E5\u53C2\u6570\uFF1A${token}`, helpText);
+    }
+    const valueFlag = flagsWithValue.has(token);
+    const key = canonicalOptionKey(token);
+    if (valueFlag) {
+      const value = readValue(token, i);
+      i += 1;
+      switch (key) {
+        case "runId":
+          options.runId = value;
+          break;
+        case "out":
+          options.out = value;
+          break;
+        case "outRoot":
+          options.outRoot = value;
+          break;
+        case "budgetBytes":
+          options.budgetBytes = Number(value);
+          break;
+        case "mode":
+          options.mode = value;
+          break;
+        case "tsconfig":
+          options.tsconfig = value;
+          break;
+        case "host":
+          options.host = value;
+          break;
+        case "cliConfig":
+          options.cliConfig = value;
+          break;
+        case "profile":
+          options.profile = value;
+          break;
+        case "repoRoot":
+          options.repoRoot = value;
+          break;
+        case "entry":
+          options.entry = value;
+          break;
+        case "in":
+          options.inDir = value;
+          break;
+        case "artifact":
+          options.artifact = value;
+          break;
+        case "before":
+          options.before = value;
+          break;
+        case "after":
+          options.after = value;
+          break;
+        case "ops":
+          options.opsPath = value;
+          break;
+        case "diagnosticsLevel":
+          options.diagnosticsLevel = value;
+          break;
+        case "maxEvents":
+          options.maxEvents = Number(value);
+          break;
+        case "timeout":
+          options.timeoutMs = Number(value);
+          break;
+        case "config": {
+          const eq = value.indexOf("=");
+          if (eq <= 0) {
+            throw invalidArgument(`\u975E\u6CD5 --config\uFF1A${value}\uFF08\u671F\u671B K=V\uFF09`, helpText);
+          }
+          const k = value.slice(0, eq);
+          const v = value.slice(eq + 1);
+          options.config = { ...options.config, [k]: parseConfigValue(v) };
+          break;
+        }
+        case "baseline":
+          options.baselineDir = value;
+          break;
+        case "packMaxBytes":
+          options.packMaxBytes = Number(value);
+          break;
+        case "inputs":
+          options.inputsFile = value;
+          break;
+        case "maxUsedServices":
+          options.maxUsedServices = Number(value);
+          break;
+        case "maxRawMode":
+          options.maxRawMode = Number(value);
+          break;
+        default:
+          throw invalidArgument(`\u672A\u77E5\u53C2\u6570\uFF1A${token}`, helpText);
+      }
+      continue;
+    }
+    switch (key) {
+      case "includeTrace":
+        options.includeTrace = !token.startsWith("--no");
+        break;
+      case "allowWarn":
+        options.allowWarn = !token.startsWith("--no");
+        break;
+      case "includeContextPack":
+        options.includeContextPack = !token.startsWith("--no");
+        break;
+      case "requireRulesManifest":
+        options.requireRulesManifest = !token.startsWith("--no");
+        break;
+      case "includeUiKitRegistry":
+        options.includeUiKitRegistry = !token.startsWith("--no");
+        break;
+      case "includeAnchorAutofill":
+        options.includeAnchorAutofill = !token.startsWith("--no");
+        break;
+      case "json":
+        options.describeJson = !token.startsWith("--no");
+        break;
+      default:
+        throw invalidArgument(`\u672A\u77E5\u53C2\u6570\uFF1A${token}`, helpText);
+    }
+  }
+  return options;
+});
+var parseManualLeaf = (argv, helpText) => Effect.gen(function* () {
+  const normalized = normalizeArgvForEffectCli(argv);
+  const extracted = findCommandTokens(normalized);
+  if (!extracted) {
+    return yield* Effect.fail(
+      makeCliError({
+        code: "CLI_INVALID_COMMAND",
+        message: "\u7F3A\u5C11\u547D\u4EE4\uFF1A\u8BF7\u63D0\u4F9B <group> <subcommand>\uFF08\u6216 trialrun\uFF09",
+        hint: helpText
+      })
+    );
+  }
+  const drop = new Set(extracted.indices);
+  const rest = normalized.filter((_, idx) => !drop.has(idx));
+  const options = yield* parseManualOptions(rest, helpText);
+  const commandKey = extracted.tokens.join(".");
+  switch (commandKey) {
+    case "describe":
+      if (!options.describeJson) {
+        return yield* Effect.fail(invalidArgument("describe \u4EC5\u652F\u6301\u673A\u5668\u53EF\u8BFB\u8F93\u51FA\uFF0C\u8BF7\u663E\u5F0F\u63D0\u4F9B --json", helpText));
+      }
+      return { command: "describe", options, format: "json" };
+    case "ir.export":
+      return { command: "ir.export", options, entry: yield* parseEntryRefFromOptions(options) };
+    case "ir.validate":
+      return { command: "ir.validate", options, input: yield* parseIrValidateInputFromOptions(options) };
+    case "ir.diff": {
+      const diff = yield* parseIrDiffInputFromOptions(options);
+      return { command: "ir.diff", options, before: diff.before, after: diff.after };
+    }
+    case "trialrun":
+      return {
+        command: "trialrun",
+        options,
+        entry: yield* parseEntryRefFromOptions(options),
+        diagnosticsLevel: options.diagnosticsLevel,
+        ...typeof options.maxEvents === "number" ? { maxEvents: options.maxEvents } : null,
+        ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : null,
+        includeTrace: options.includeTrace,
+        config: options.config
+      };
+    case "contract-suite.run":
+      return {
+        command: "contract-suite.run",
+        options,
+        entry: yield* parseEntryRefFromOptions(options),
+        diagnosticsLevel: options.diagnosticsLevel,
+        ...typeof options.maxEvents === "number" ? { maxEvents: options.maxEvents } : null,
+        ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : null,
+        includeTrace: options.includeTrace,
+        config: options.config,
+        allowWarn: options.allowWarn,
+        ...options.baselineDir ? { baselineDir: options.baselineDir } : null,
+        includeContextPack: options.includeContextPack,
+        ...typeof options.packMaxBytes === "number" ? { packMaxBytes: options.packMaxBytes } : null,
+        requireRulesManifest: options.requireRulesManifest,
+        ...options.inputsFile ? { inputsFile: options.inputsFile } : null,
+        includeUiKitRegistry: options.includeUiKitRegistry,
+        includeAnchorAutofill: options.includeAnchorAutofill,
+        repoRoot: options.repoRoot
+      };
+    case "spy.evidence":
+      return {
+        command: "spy.evidence",
+        options,
+        entry: yield* parseEntryRefFromOptions(options),
+        ...typeof options.maxUsedServices === "number" ? { maxUsedServices: options.maxUsedServices } : null,
+        ...typeof options.maxRawMode === "number" ? { maxRawMode: options.maxRawMode } : null,
+        ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : null
+      };
+    case "anchor.index":
+      return { command: "anchor.index", options, repoRoot: options.repoRoot };
+    case "anchor.autofill":
+      return { command: "anchor.autofill", options, repoRoot: options.repoRoot };
+    case "transform.module": {
+      const opsPath = typeof options.opsPath === "string" && options.opsPath.length > 0 ? options.opsPath : void 0;
+      if (!opsPath) {
+        return yield* Effect.fail(invalidArgument("\u7F3A\u5C11\u8F93\u5165\uFF1A\u8BF7\u63D0\u4F9B --ops <delta.json|->", helpText));
+      }
+      return { command: "transform.module", options, repoRoot: options.repoRoot, opsPath };
+    }
+    default:
+      return yield* Effect.fail(
+        makeCliError({
+          code: "CLI_INVALID_COMMAND",
+          message: `\u672A\u77E5\u547D\u4EE4\uFF1A${commandKey}`,
+          hint: helpText
+        })
+      );
+  }
+});
+var parseCliInvocation = (argv, options) => {
+  if (argv.includes("-h") || argv.includes("--help") || argv.length === 0) {
+    return Effect.succeed({ kind: "help", text: options.helpText });
+  }
+  return parseManualLeaf(argv, options.helpText).pipe(
+    Effect.flatMap((leaf) => {
+      const runId = typeof leaf.options.runId === "string" ? leaf.options.runId.trim() : void 0;
+      if (!runId) {
+        return Effect.fail(makeCliError({ code: "CLI_MISSING_RUNID", message: "\u7F3A\u5C11 --runId\uFF08\u5FC5\u987B\u663E\u5F0F\u63D0\u4F9B\uFF09" }));
+      }
+      const outDirExplicit = typeof leaf.options.out === "string" ? leaf.options.out.trim() : void 0;
+      const outRoot = typeof leaf.options.outRoot === "string" ? leaf.options.outRoot.trim() : void 0;
+      const outDir = outDirExplicit ?? (outRoot ? path.join(outRoot, leaf.command, runId) : void 0);
+      const budgetBytes = typeof leaf.options.budgetBytes === "number" ? leaf.options.budgetBytes : void 0;
+      const mode = leaf.options.mode;
+      const tsconfig = typeof leaf.options.tsconfig === "string" ? leaf.options.tsconfig.trim() : void 0;
+      const global = {
+        runId,
+        ...outDir ? { outDir } : null,
+        ...budgetBytes ? { budgetBytes } : null,
+        ...mode ? { mode } : null,
+        ...tsconfig ? { tsconfig } : null,
+        host: leaf.options.host
+      };
+      switch (leaf.command) {
+        case "describe":
+          return Effect.succeed({ kind: "command", command: "describe", global, format: leaf.format });
+        case "ir.export":
+          return Effect.succeed({ kind: "command", command: "ir.export", global, entry: leaf.entry });
+        case "ir.validate":
+          return Effect.succeed({ kind: "command", command: "ir.validate", global, input: leaf.input });
+        case "ir.diff":
+          return Effect.succeed({ kind: "command", command: "ir.diff", global, before: leaf.before, after: leaf.after });
+        case "trialrun":
+          return Effect.succeed({
+            kind: "command",
+            command: "trialrun",
+            global,
+            entry: leaf.entry,
+            diagnosticsLevel: leaf.diagnosticsLevel,
+            ...typeof leaf.maxEvents === "number" ? { maxEvents: leaf.maxEvents } : null,
+            ...typeof leaf.timeoutMs === "number" ? { timeoutMs: leaf.timeoutMs } : null,
+            includeTrace: leaf.includeTrace,
+            config: leaf.config
+          });
+        case "contract-suite.run":
+          return Effect.succeed({
+            kind: "command",
+            command: "contract-suite.run",
+            global,
+            entry: leaf.entry,
+            diagnosticsLevel: leaf.diagnosticsLevel,
+            ...typeof leaf.maxEvents === "number" ? { maxEvents: leaf.maxEvents } : null,
+            ...typeof leaf.timeoutMs === "number" ? { timeoutMs: leaf.timeoutMs } : null,
+            includeTrace: leaf.includeTrace,
+            config: leaf.config,
+            allowWarn: leaf.allowWarn,
+            ...leaf.baselineDir ? { baselineDir: leaf.baselineDir } : null,
+            includeContextPack: leaf.includeContextPack,
+            ...typeof leaf.packMaxBytes === "number" ? { packMaxBytes: leaf.packMaxBytes } : null,
+            requireRulesManifest: leaf.requireRulesManifest,
+            ...leaf.inputsFile ? { inputsFile: leaf.inputsFile } : null,
+            includeUiKitRegistry: leaf.includeUiKitRegistry,
+            includeAnchorAutofill: leaf.includeAnchorAutofill,
+            repoRoot: leaf.repoRoot
+          });
+        case "spy.evidence":
+          return Effect.succeed({
+            kind: "command",
+            command: "spy.evidence",
+            global,
+            entry: leaf.entry,
+            ...typeof leaf.maxUsedServices === "number" ? { maxUsedServices: leaf.maxUsedServices } : null,
+            ...typeof leaf.maxRawMode === "number" ? { maxRawMode: leaf.maxRawMode } : null,
+            ...typeof leaf.timeoutMs === "number" ? { timeoutMs: leaf.timeoutMs } : null
+          });
+        case "anchor.index":
+          return Effect.succeed({ kind: "command", command: "anchor.index", global, repoRoot: leaf.repoRoot });
+        case "anchor.autofill":
+          return Effect.succeed({ kind: "command", command: "anchor.autofill", global, repoRoot: leaf.repoRoot });
+        case "transform.module":
+          return Effect.succeed(
+            { kind: "command", command: "transform.module", global, repoRoot: leaf.repoRoot, opsPath: leaf.opsPath }
+          );
+      }
+    }),
+    Effect.catch(
+      (cause) => Effect.fail(
+        makeCliError({
+          code: "CLI_INVALID_ARGUMENT",
+          message: renderValidationError(cause),
+          hint: options.helpText,
+          cause
+        })
+      )
+    )
+  );
+};
+
+// src/internal/cliConfig.ts
+import { Effect as Effect2 } from "effect";
+import fs from "fs/promises";
+import path2 from "path";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var asPositiveInt = (value) => {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  return Math.floor(n);
+};
+var capitalize = (s) => s.length === 0 ? s : `${s[0].toUpperCase()}${s.slice(1)}`;
+var readJsonFile = (filePath) => Effect2.tryPromise({
+  try: async () => JSON.parse(await fs.readFile(filePath, "utf8")),
+  catch: (cause) => makeCliError({
+    code: "CLI_INVALID_INPUT",
+    message: `[Logix][CLI] \u65E0\u6CD5\u8BFB\u53D6/\u89E3\u6790\u914D\u7F6E\u6587\u4EF6\uFF1A${filePath}`,
+    cause
+  })
+});
+var statExists = (filePath) => Effect2.tryPromise({
+  try: async () => {
+    await fs.stat(filePath);
+    return true;
+  },
+  catch: (cause) => cause
+}).pipe(Effect2.catch(() => Effect2.succeed(false)));
+var findUp = (startDir, fileName) => Effect2.gen(function* () {
+  let dir = path2.resolve(startDir);
+  while (true) {
+    const candidate = path2.join(dir, fileName);
+    if (yield* statExists(candidate)) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+});
+var getFlag = (argv, name) => {
+  const idx = argv.lastIndexOf(`--${name}`);
+  if (idx < 0) return void 0;
+  const next = argv[idx + 1];
+  if (!next || next.startsWith("--")) {
+    throw makeCliError({ code: "CLI_INVALID_ARGUMENT", message: `--${name} \u7F3A\u5C11\u53C2\u6570` });
+  }
+  return next;
+};
+var parseCliConfigPath = (argv) => getFlag(argv, "cliConfig") ?? void 0;
+var parseProfile = (argv) => {
+  const raw = getFlag(argv, "profile");
+  return asNonEmptyString(raw);
+};
+var validateDefaults = (input, label) => {
+  if (!isRecord(input)) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label} \u5FC5\u987B\u662F\u5BF9\u8C61` });
+  }
+  const knownKeys = /* @__PURE__ */ new Set([
+    "outRoot",
+    "repoRoot",
+    "tsconfig",
+    "host",
+    "budgetBytes",
+    "diagnosticsLevel",
+    "maxEvents",
+    "timeout",
+    "baseline",
+    "inputs",
+    "packMaxBytes",
+    "allowWarn",
+    "includeTrace",
+    "includeContextPack",
+    "includeUiKitRegistry",
+    "requireRulesManifest",
+    "includeAnchorAutofill",
+    "entry"
+  ]);
+  for (const key of Object.keys(input)) {
+    if (!knownKeys.has(key)) {
+      throw makeCliError({
+        code: "CLI_INVALID_INPUT",
+        message: `[Logix][CLI] ${label} \u5305\u542B\u672A\u77E5\u5B57\u6BB5\uFF1A${key}`,
+        hint: "\u8BF7\u66F4\u65B0\u914D\u7F6E\u6587\u4EF6\u6216\u5347\u7EA7 CLI\uFF1B\u914D\u7F6E schemaVersion=1 \u4E0D\u5141\u8BB8\u672A\u77E5\u5B57\u6BB5\u3002"
+      });
+    }
+  }
+  const diagnosticsLevel = input.diagnosticsLevel;
+  if (diagnosticsLevel !== void 0 && diagnosticsLevel !== "off" && diagnosticsLevel !== "light" && diagnosticsLevel !== "full") {
+    throw makeCliError({
+      code: "CLI_INVALID_INPUT",
+      message: `[Logix][CLI] ${label}.diagnosticsLevel \u975E\u6CD5\uFF1A${String(diagnosticsLevel)}\uFF08\u671F\u671B off|light|full\uFF09`
+    });
+  }
+  const allowWarn = input.allowWarn;
+  if (allowWarn !== void 0 && typeof allowWarn !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.allowWarn \u5FC5\u987B\u662F boolean` });
+  }
+  const includeTrace = input.includeTrace;
+  if (includeTrace !== void 0 && typeof includeTrace !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.includeTrace \u5FC5\u987B\u662F boolean` });
+  }
+  const includeContextPack = input.includeContextPack;
+  if (includeContextPack !== void 0 && typeof includeContextPack !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.includeContextPack \u5FC5\u987B\u662F boolean` });
+  }
+  const includeUiKitRegistry = input.includeUiKitRegistry;
+  if (includeUiKitRegistry !== void 0 && typeof includeUiKitRegistry !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.includeUiKitRegistry \u5FC5\u987B\u662F boolean` });
+  }
+  const requireRulesManifest = input.requireRulesManifest;
+  if (requireRulesManifest !== void 0 && typeof requireRulesManifest !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.requireRulesManifest \u5FC5\u987B\u662F boolean` });
+  }
+  const includeAnchorAutofill = input.includeAnchorAutofill;
+  if (includeAnchorAutofill !== void 0 && typeof includeAnchorAutofill !== "boolean") {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.includeAnchorAutofill \u5FC5\u987B\u662F boolean` });
+  }
+  const budgetBytes = input.budgetBytes;
+  if (budgetBytes !== void 0 && asPositiveInt(budgetBytes) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.budgetBytes \u5FC5\u987B\u662F\u6B63\u6574\u6570` });
+  }
+  const maxEvents = input.maxEvents;
+  if (maxEvents !== void 0 && asPositiveInt(maxEvents) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.maxEvents \u5FC5\u987B\u662F\u6B63\u6574\u6570` });
+  }
+  const timeout = input.timeout;
+  if (timeout !== void 0 && asPositiveInt(timeout) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.timeout \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08ms\uFF09` });
+  }
+  const packMaxBytes = input.packMaxBytes;
+  if (packMaxBytes !== void 0 && asPositiveInt(packMaxBytes) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.packMaxBytes \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08bytes\uFF09` });
+  }
+  const outRoot = input.outRoot;
+  if (outRoot !== void 0 && asNonEmptyString(outRoot) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.outRoot \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  const repoRoot = input.repoRoot;
+  if (repoRoot !== void 0 && asNonEmptyString(repoRoot) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.repoRoot \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  const tsconfig = input.tsconfig;
+  if (tsconfig !== void 0 && asNonEmptyString(tsconfig) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.tsconfig \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  const host = input.host;
+  if (host !== void 0 && host !== "node" && host !== "browser-mock") {
+    throw makeCliError({
+      code: "CLI_INVALID_INPUT",
+      message: `[Logix][CLI] ${label}.host \u975E\u6CD5\uFF1A${String(host)}\uFF08\u671F\u671B node|browser-mock\uFF09`
+    });
+  }
+  const baseline = input.baseline;
+  if (baseline !== void 0 && asNonEmptyString(baseline) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.baseline \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  const inputs = input.inputs;
+  if (inputs !== void 0 && asNonEmptyString(inputs) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.inputs \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  const entry = input.entry;
+  if (entry !== void 0 && asNonEmptyString(entry) === void 0) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] ${label}.entry \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32` });
+  }
+  return {
+    ...outRoot !== void 0 ? { outRoot: asNonEmptyString(outRoot) } : null,
+    ...repoRoot !== void 0 ? { repoRoot: asNonEmptyString(repoRoot) } : null,
+    ...tsconfig !== void 0 ? { tsconfig: asNonEmptyString(tsconfig) } : null,
+    ...host !== void 0 ? { host } : null,
+    ...budgetBytes !== void 0 ? { budgetBytes: asPositiveInt(budgetBytes) } : null,
+    ...diagnosticsLevel !== void 0 ? { diagnosticsLevel } : null,
+    ...maxEvents !== void 0 ? { maxEvents: asPositiveInt(maxEvents) } : null,
+    ...timeout !== void 0 ? { timeout: asPositiveInt(timeout) } : null,
+    ...baseline !== void 0 ? { baseline: asNonEmptyString(baseline) } : null,
+    ...inputs !== void 0 ? { inputs: asNonEmptyString(inputs) } : null,
+    ...packMaxBytes !== void 0 ? { packMaxBytes: asPositiveInt(packMaxBytes) } : null,
+    ...allowWarn !== void 0 ? { allowWarn } : null,
+    ...includeTrace !== void 0 ? { includeTrace } : null,
+    ...includeContextPack !== void 0 ? { includeContextPack } : null,
+    ...includeUiKitRegistry !== void 0 ? { includeUiKitRegistry } : null,
+    ...requireRulesManifest !== void 0 ? { requireRulesManifest } : null,
+    ...includeAnchorAutofill !== void 0 ? { includeAnchorAutofill } : null,
+    ...entry !== void 0 ? { entry: asNonEmptyString(entry) } : null
+  };
+};
+var validateConfigFile = (input, filePath) => {
+  if (!isRecord(input)) {
+    throw makeCliError({ code: "CLI_INVALID_INPUT", message: `[Logix][CLI] \u914D\u7F6E\u6587\u4EF6\u5FC5\u987B\u662F JSON object\uFF1A${filePath}` });
+  }
+  const schemaVersion = input.schemaVersion;
+  if (schemaVersion !== 1) {
+    throw makeCliError({
+      code: "CLI_INVALID_INPUT",
+      message: `[Logix][CLI] \u914D\u7F6E\u6587\u4EF6 schemaVersion \u975E\u6CD5\uFF1A${String(schemaVersion)}\uFF08\u671F\u671B 1\uFF09`
+    });
+  }
+  const defaultsRaw = input.defaults;
+  const profilesRaw = input.profiles;
+  const defaults = defaultsRaw !== void 0 ? validateDefaults(defaultsRaw, "defaults") : void 0;
+  let profiles;
+  if (profilesRaw !== void 0) {
+    if (!isRecord(profilesRaw)) {
+      throw makeCliError({ code: "CLI_INVALID_INPUT", message: "[Logix][CLI] profiles \u5FC5\u987B\u662F\u5BF9\u8C61\uFF08Record<string, defaults>\uFF09" });
+    }
+    profiles = {};
+    for (const [name, raw] of Object.entries(profilesRaw)) {
+      const key = asNonEmptyString(name);
+      if (!key) continue;
+      profiles[key] = validateDefaults(raw, `profiles.${key}`);
+    }
+  }
+  return {
+    schemaVersion: 1,
+    ...defaults ? { defaults } : null,
+    ...profiles ? { profiles } : null
+  };
+};
+var toArgvPrefix = (defaults) => {
+  const tokens = [];
+  if (defaults.outRoot) tokens.push("--outRoot", defaults.outRoot);
+  if (defaults.repoRoot) tokens.push("--repoRoot", defaults.repoRoot);
+  if (defaults.tsconfig) tokens.push("--tsconfig", defaults.tsconfig);
+  if (defaults.host) tokens.push("--host", defaults.host);
+  if (defaults.budgetBytes) tokens.push("--budgetBytes", String(defaults.budgetBytes));
+  if (defaults.diagnosticsLevel) tokens.push("--diagnosticsLevel", defaults.diagnosticsLevel);
+  if (defaults.maxEvents) tokens.push("--maxEvents", String(defaults.maxEvents));
+  if (defaults.timeout) tokens.push("--timeout", String(defaults.timeout));
+  if (defaults.baseline) tokens.push("--baseline", defaults.baseline);
+  if (defaults.inputs) tokens.push("--inputs", defaults.inputs);
+  if (defaults.packMaxBytes) tokens.push("--packMaxBytes", String(defaults.packMaxBytes));
+  if (defaults.entry) tokens.push("--entry", defaults.entry);
+  const bool = (key, flag) => {
+    const value = defaults[key];
+    if (value === true) tokens.push(`--${flag}`);
+    if (value === false) tokens.push(`--no${capitalize(flag)}`);
+  };
+  bool("allowWarn", "allowWarn");
+  bool("includeTrace", "includeTrace");
+  bool("includeContextPack", "includeContextPack");
+  bool("includeUiKitRegistry", "includeUiKitRegistry");
+  bool("requireRulesManifest", "requireRulesManifest");
+  bool("includeAnchorAutofill", "includeAnchorAutofill");
+  return tokens;
+};
+var resolveCliConfigArgvPrefixResolution = (argv) => Effect2.gen(function* () {
+  const explicitPathRaw = parseCliConfigPath(argv);
+  const profile = parseProfile(argv);
+  const configPath = explicitPathRaw ? path2.resolve(process.cwd(), explicitPathRaw) : yield* findUp(process.cwd(), "logix.cli.json");
+  if (!configPath) {
+    if (profile) {
+      throw makeCliError({
+        code: "CLI_INVALID_INPUT",
+        message: `[Logix][CLI] \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u4F46\u6307\u5B9A\u4E86 --profile ${profile}`,
+        hint: "\u8BF7\u5728\u5F53\u524D\u76EE\u5F55\u6216\u4E0A\u5C42\u76EE\u5F55\u653E\u7F6E logix.cli.json\uFF0C\u6216\u4F7F\u7528 --cliConfig <path> \u6307\u5B9A\u3002"
+      });
+    }
+    return {
+      prefix: [],
+      ...explicitPathRaw ? { cliConfigPathArg: explicitPathRaw } : null,
+      ...profile ? { profile } : null,
+      layers: [],
+      discovery: { found: false }
+    };
+  }
+  if (explicitPathRaw && !(yield* statExists(configPath))) {
+    throw makeCliError({
+      code: "CLI_INVALID_INPUT",
+      message: `[Logix][CLI] \u6307\u5B9A\u7684\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${explicitPathRaw}`
+    });
+  }
+  const raw = yield* readJsonFile(configPath);
+  const config = validateConfigFile(raw, configPath);
+  const layers = [];
+  if (config.defaults) {
+    layers.push({
+      source: "defaults",
+      tokens: toArgvPrefix(config.defaults)
+    });
+  }
+  if (profile) {
+    const profileDefaults = config.profiles?.[profile];
+    if (!profileDefaults) {
+      throw makeCliError({
+        code: "CLI_INVALID_INPUT",
+        message: `[Logix][CLI] \u672A\u627E\u5230 profile\uFF1A${profile}`
+      });
+    }
+    layers.push({
+      source: "profile",
+      profile,
+      tokens: toArgvPrefix(profileDefaults)
+    });
+  }
+  return {
+    prefix: layers.flatMap((layer) => layer.tokens),
+    ...explicitPathRaw ? { cliConfigPathArg: explicitPathRaw } : null,
+    ...profile ? { profile } : null,
+    discoveredPath: configPath,
+    layers,
+    discovery: {
+      found: true,
+      path: configPath,
+      ok: true,
+      config,
+      profiles: Object.keys(config.profiles ?? {}).sort()
+    }
+  };
+});
+var resolveCliConfigArgvPrefix = (argv) => resolveCliConfigArgvPrefixResolution(argv).pipe(Effect2.map((resolved) => resolved.prefix));
+
+// src/Commands.ts
+var formatCommandResult = (result) => stableStringifyJson(result);
+var printHelp = () => `logix
+
+\u7528\u6CD5:
+  logix describe --runId <id> --json [--out <dir>]
+  logix ir export --runId <id> --entry <modulePath>#<exportName> [--out <dir>]
+  logix ir validate --runId <id> --in <dir> [--out <dir>]
+  logix ir diff --runId <id> --before <dir|file> --after <dir|file> [--out <dir>]
+  logix trialrun --runId <id> --entry <modulePath>#<exportName> [--out <dir>] [--diagnosticsLevel off|light|full] [--maxEvents <n>] [--timeout <ms>] [--includeTrace]
+  logix contract-suite run --runId <id> --entry <modulePath>#<exportName> [--baseline <dir>] [--out <dir>] [--allowWarn] [--includeContextPack] [--inputs <file|->] [--includeUiKitRegistry] [--packMaxBytes <n>] [--requireRulesManifest] [--includeAnchorAutofill] [--repoRoot <dir>] [--diagnosticsLevel off|light|full] [--maxEvents <n>] [--timeout <ms>] [--includeTrace]
+  logix spy evidence --runId <id> --entry <modulePath>#<exportName> [--out <dir>] [--maxUsedServices <n>] [--maxRawMode <n>] [--timeout <ms>]
+  logix anchor index --runId <id> [--repoRoot <dir>] [--out <dir>]
+  logix anchor autofill --runId <id> [--repoRoot <dir>] [--mode report|write] [--tsconfig <path>] [--out <dir>]
+  logix transform module --runId <id> --ops <delta.json|-> [--mode report|write] [--repoRoot <dir>] [--tsconfig <path>] [--out <dir>]
+
+\u5168\u5C40\u53C2\u6570:
+  --runId <string>     \u5FC5\u987B\u663E\u5F0F\u63D0\u4F9B\uFF08\u7528\u4E8E\u786E\u5B9A\u6027\u5DE5\u4EF6\u547D\u540D\u4E0E\u5173\u8054\uFF09
+  --out <dir>          \u53EF\u9009\uFF1A\u7A33\u5B9A\u843D\u76D8\u76EE\u5F55\uFF08stdout \u4ECD\u8F93\u51FA CommandResult@v1\uFF09
+  --outRoot <dir>      \u53EF\u9009\uFF1A\u5F53\u672A\u663E\u5F0F --out \u65F6\uFF0C\u81EA\u52A8\u843D\u76D8\u5230 <outRoot>/<command>/<runId>
+  --budgetBytes <n>    \u53EF\u9009\uFF1Astdout inline artifact \u7684\u9884\u7B97\u4E0A\u9650\uFF08\u8D85\u9650\u4F1A\u622A\u65AD\u5E76\u6807\u8BB0\uFF09
+  --mode report|write  \u53EF\u9009\uFF1A\u5199\u56DE\u6A21\u5F0F\uFF08\u9ED8\u8BA4 report\uFF1B\u4EC5\u5BF9\u53EF\u5199\u56DE\u547D\u4EE4\u751F\u6548\uFF09
+  --tsconfig <path>    \u53EF\u9009\uFF1Ats-morph \u89E3\u6790/\u6539\u5199\u6240\u7528 tsconfig\uFF08\u9ED8\u8BA4\u81EA\u52A8\u63A2\u6D4B/\u964D\u7EA7\uFF09
+  --host <name>        \u53EF\u9009\uFF1A\u6267\u884C\u5BBF\u4E3B\uFF08node|browser-mock\uFF1B\u9ED8\u8BA4 node\uFF1B\u5F71\u54CD\u5165\u53E3\u52A0\u8F7D/\u8BD5\u8DD1\uFF09
+  --cliConfig <path>   \u53EF\u9009\uFF1A\u663E\u5F0F\u6307\u5B9A logix.cli.json\uFF08\u4E0D\u63D0\u4F9B\u5219\u4ECE cwd \u5411\u4E0A\u67E5\u627E\uFF09
+  --profile <name>     \u53EF\u9009\uFF1A\u9009\u62E9\u914D\u7F6E\u6587\u4EF6\u4E2D\u7684 profile\uFF08\u5728 defaults \u4E4B\u4E0A\u53E0\u52A0\uFF09
+  --config <K=V>       \u53EF\u9009\uFF1A\u6CE8\u5165\u8FD0\u884C\u73AF\u5883 config\uFF08\u53EF\u91CD\u590D\uFF1B\u4EC5 trialrun/contract-suite \u6D88\u8D39\uFF09
+  -h, --help           \u663E\u793A\u5E2E\u52A9
+`;
+var EMPTY_CLI_CONFIG_RESOLUTION = {
+  prefix: [],
+  layers: [],
+  discovery: { found: false }
+};
+var runIrExport = (inv) => Effect3.tryPromise({
+  try: () => import("./irExport-EI2VYIMT.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Air.export",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runIrExport(inv)));
+var runDescribe = (inv, ctx) => Effect3.tryPromise({
+  try: () => import("./describe-5MFSLD7R.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Adescribe",
+    cause
+  })
+}).pipe(
+  Effect3.flatMap(
+    (mod) => mod.runDescribe(inv, {
+      argv: ctx.argv,
+      argvWithConfigPrefix: ctx.argvWithConfigPrefix,
+      cliConfig: ctx.cliConfig
+    })
+  )
+);
+var runTrialRun = (inv) => Effect3.tryPromise({
+  try: () => import("./trialRun-SWVYG67P.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Atrialrun",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runTrialRun(inv)));
+var runContractSuiteRun = (inv) => Effect3.tryPromise({
+  try: () => import("./contractSuiteRun-5Y7LVI72.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Acontract-suite.run",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runContractSuiteRun(inv)));
+var runSpyEvidence = (inv) => Effect3.tryPromise({
+  try: () => import("./spyEvidence-JTJDS2WN.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Aspy.evidence",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runSpyEvidence(inv)));
+var runIrValidate = (inv) => Effect3.tryPromise({
+  try: () => import("./irValidate-JEQGVRL5.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Air.validate",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runIrValidate(inv)));
+var runIrDiff = (inv) => Effect3.tryPromise({
+  try: () => import("./irDiff-WYXZEVA7.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Air.diff",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runIrDiff(inv)));
+var runAnchorIndex = (inv) => Effect3.tryPromise({
+  try: () => import("./anchorIndex-IEFARUZM.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Aanchor.index",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runAnchorIndex(inv)));
+var runAnchorAutofill = (inv) => Effect3.tryPromise({
+  try: () => import("./anchorAutofill-V6CAXQHT.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Aanchor.autofill",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runAnchorAutofill(inv)));
+var runTransformModule = (inv) => Effect3.tryPromise({
+  try: () => import("./transformModule-D6YE3U5W.js"),
+  catch: (cause) => makeCliError({
+    code: "CLI_COMMAND_IMPORT_FAILED",
+    message: "[Logix][CLI] \u52A0\u8F7D\u547D\u4EE4\u5931\u8D25\uFF1Atransform.module",
+    cause
+  })
+}).pipe(Effect3.flatMap((mod) => mod.runTransformModule(inv)));
+var runCommand = (inv, ctx) => {
+  switch (inv.command) {
+    case "describe":
+      return runDescribe(inv, ctx);
+    case "ir.export":
+      return runIrExport(inv);
+    case "ir.validate":
+      return runIrValidate(inv);
+    case "ir.diff":
+      return runIrDiff(inv);
+    case "trialrun":
+      return runTrialRun(inv);
+    case "contract-suite.run":
+      return runContractSuiteRun(inv);
+    case "spy.evidence":
+      return runSpyEvidence(inv);
+    case "anchor.index":
+      return runAnchorIndex(inv);
+    case "anchor.autofill":
+      return runAnchorAutofill(inv);
+    case "transform.module":
+      return runTransformModule(inv);
+  }
+};
+var isHelp = (x) => x.kind === "help";
+var tryGetRunId = (argv) => {
+  const idx = argv.lastIndexOf("--runId");
+  if (idx < 0) return void 0;
+  const next = argv[idx + 1];
+  if (!next || next.startsWith("--")) return void 0;
+  return typeof next === "string" && next.length > 0 ? next : void 0;
+};
+var resolveRunIdForFailure = (argv) => {
+  const fromArgv = tryGetRunId(argv);
+  if (fromArgv) return Effect3.succeed(fromArgv);
+  return resolveCliConfigArgvPrefix(argv).pipe(
+    Effect3.map((prefix) => prefix.length > 0 ? [...prefix, ...argv] : argv),
+    Effect3.map((argv2) => tryGetRunId(argv2) ?? "missing-runId"),
+    Effect3.catch(() => Effect3.succeed("missing-runId"))
+  );
+};
+var isHostErrorCode = (code) => code === "CLI_HOST_MISSING_BROWSER_GLOBAL" || code === "CLI_HOST_MISMATCH";
+var stripHostFromArgv = (argv) => {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--host") {
+      i += 1;
+      continue;
+    }
+    if (token.startsWith("--host=")) continue;
+    out.push(token);
+  }
+  return out;
+};
+var makeCliDiagnosticsArtifact = (args) => {
+  const argvNoHost = stripHostFromArgv(args.argv);
+  const command = `logix --host browser-mock ${argvNoHost.join(" ")}`.trim();
+  return {
+    outputKey: "cliDiagnostics",
+    kind: "CliDiagnostics",
+    schemaVersion: 1,
+    ok: true,
+    inline: {
+      schemaVersion: 1,
+      kind: "CliDiagnostics",
+      diagnostics: [
+        {
+          severity: "error",
+          code: args.errorCode,
+          message: args.errorCode === "CLI_HOST_MISSING_BROWSER_GLOBAL" ? "\u5165\u53E3\u9700\u8981\u6D4F\u89C8\u5668\u5168\u5C40\uFF08window/document/navigator \u7B49\uFF09\uFF1B\u8BF7\u7528 browser-mock host \u91CD\u8DD1\uFF0C\u6216\u628A\u6D4F\u89C8\u5668\u4EE3\u7801\u79FB\u51FA\u6A21\u5757\u9876\u5C42\u3002" : "host \u53EF\u80FD\u4E0D\u5339\u914D\uFF1B\u8BF7\u5C1D\u8BD5 browser-mock\uFF0C\u6216\u628A\u6D4F\u89C8\u5668\u4EE3\u7801\u79FB\u51FA\u6A21\u5757\u9876\u5C42\u3002",
+          action: { kind: "run.command", command }
+        }
+      ]
+    }
+  };
+};
+var withHostDiagnosticsIfNeeded = (result, argv) => {
+  if (result.ok) return result;
+  const code = result.error?.code;
+  if (!isHostErrorCode(code)) return result;
+  if (result.artifacts.some((a) => a.outputKey === "cliDiagnostics")) return result;
+  return {
+    ...result,
+    artifacts: [...result.artifacts, makeCliDiagnosticsArtifact({ errorCode: code, argv })]
+  };
+};
+var runCli = (argv) => (argv.includes("-h") || argv.includes("--help") || argv.length === 0 ? Effect3.succeed({
+  argv2: argv,
+  cliConfig: EMPTY_CLI_CONFIG_RESOLUTION
+}) : resolveCliConfigArgvPrefixResolution(argv).pipe(
+  Effect3.map((resolved) => ({
+    argv2: resolved.prefix.length > 0 ? [...resolved.prefix, ...argv] : argv,
+    cliConfig: resolved
+  }))
+)).pipe(
+  Effect3.flatMap(
+    ({ argv2, cliConfig }) => parseCliInvocation(argv2, {
+      helpText: printHelp()
+    }).pipe(Effect3.map((parsed) => ({ argv2, parsed, cliConfig })))
+  ),
+  Effect3.matchEffect({
+    onFailure: (cause) => {
+      const error = asSerializableErrorSummary(cause);
+      return resolveRunIdForFailure(argv).pipe(
+        Effect3.map((runId) => ({
+          kind: "result",
+          result: makeErrorCommandResult({ runId, command: "unknown", error }),
+          exitCode: exitCodeFromErrorSummary(error)
+        }))
+      );
+    },
+    onSuccess: ({ argv2, parsed, cliConfig }) => {
+      if (isHelp(parsed)) {
+        return Effect3.succeed({ kind: "help", text: parsed.text, exitCode: 0 });
+      }
+      return runCommand(parsed, {
+        argv,
+        argvWithConfigPrefix: argv2,
+        cliConfig
+      }).pipe(
+        Effect3.map(
+          (result) => {
+            const result2 = withHostDiagnosticsIfNeeded(result, argv2);
+            return {
+              kind: "result",
+              result: {
+                ...result2,
+                artifacts: sortArtifactsByOutputKey(result2.artifacts)
+              },
+              exitCode: result2.ok ? 0 : exitCodeFromErrorSummary(result2.error)
+            };
+          }
+        ),
+        Effect3.catchCause((cause) => {
+          const error = asSerializableErrorSummary(
+            makeCliError({
+              code: "CLI_COMMAND_FAILED",
+              message: `[Logix][CLI] \u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${parsed.command}`,
+              cause
+            })
+          );
+          const result = makeErrorCommandResult({
+            runId: parsed.global.runId,
+            command: parsed.command,
+            error
+          });
+          return Effect3.succeed({ kind: "result", result, exitCode: 1 });
+        })
+      );
+    }
+  }),
+  Effect3.catchCause((cause) => {
+    const error = asSerializableErrorSummary(
+      makeCliError({
+        code: "CLI_INTERNAL",
+        message: "[Logix][CLI] \u5165\u53E3\u6267\u884C\u5931\u8D25",
+        cause
+      })
+    );
+    return resolveRunIdForFailure(argv).pipe(
+      Effect3.map((runId) => ({
+        kind: "result",
+        result: makeErrorCommandResult({ runId, command: "unknown", error }),
+        exitCode: 1
+      }))
+    );
+  }),
+  // CLI stdout is a strict protocol (CommandResult@v1); silence Effect logs to avoid polluting stdout/stderr.
+  Effect3.provide(Logger.layer([Logger.make(() => {
+  })]))
+);
+var main = runCli;
+
+export {
+  formatCommandResult,
+  printHelp,
+  runCli,
+  main,
+  Commands_exports
+};
+//# sourceMappingURL=chunk-TDQVD2IA.js.map