deepline 0.3.461 → 0.3.463

package/dist/cli/chunk-3BVLLJ3H.mjs

@@ -0,0 +1,1038 @@
+import {
+  resolveEnabledExecutionProfile
+} from "./chunk-F6QV42MC.mjs";
+import {
+  parseLogLevel
+} from "./chunk-RD6IQ2JY.mjs";
+import {
+  setDottedInputValue
+} from "./chunk-FAG4DFUC.mjs";
+import {
+  argsWantJson,
+  jsonFieldArgs,
+  parseJsonFields
+} from "./chunk-WUMIYOXQ.mjs";
+import {
+  DeeplineError
+} from "./chunk-HBL4PM5Q.mjs";
+
+// ../play-runtime/governor/policy.ts
+var DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS = 64;
+var MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS = 1e3;
+var MAX_CONFIGURABLE_CONCURRENT_ROWS = 1e3;
+function resolveMaxConcurrentExternalCalls(requested) {
+  if (requested === void 0 || requested === null) {
+    return DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS;
+  }
+  if (!Number.isSafeInteger(requested) || requested < 1 || requested > MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS) {
+    throw new Error(
+      `maxConcurrentExternalCalls must be a whole number from 1 through ${MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS}.`
+    );
+  }
+  return requested;
+}
+function resolveMaxConcurrentRows(requested) {
+  if (requested === void 0 || requested === null) return null;
+  if (!Number.isSafeInteger(requested) || requested < 1 || requested > MAX_CONFIGURABLE_CONCURRENT_ROWS) {
+    throw new Error(
+      `maxConcurrentRows must be a whole number from 1 through ${MAX_CONFIGURABLE_CONCURRENT_ROWS}.`
+    );
+  }
+  return requested;
+}
+
+// src/cli/operations/play-run-options.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+// ../play-runtime/fixture-behavior.ts
+var FIXTURE_BEHAVIOR_VERSION = 1;
+var FIXTURE_BEHAVIOR_RESPONSE_VERSION = 2;
+var FIXTURE_BEHAVIOR_REPLAY_VERSION = 3;
+var MAX_FIXTURE_RESPONSE_DELAY_SAMPLES = 256;
+var MAX_FIXTURE_RESPONSE_DELAY_MS = 8 * 6e4;
+var MAX_FIXTURE_RESPONSE_ERROR_MESSAGE_LENGTH = 500;
+var MAX_FIXTURE_RETRY_AFTER_MS = 60 * 6e4;
+var FIXTURE_RATE_WINDOWS = [
+  { field: "requestsPerSecond", name: "rps", windowMs: 1e3 },
+  { field: "requestsPerMinute", name: "rpm", windowMs: 6e4 },
+  { field: "requestsPerHour", name: "rph", windowMs: 36e5 }
+];
+function isFixtureReplaySelectionSeed(value) {
+  return typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value);
+}
+function validateFixtureBehavior(value) {
+  if (value === void 0 || value === null) {
+    return { ok: true, behavior: null };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, error: "fixtureBehavior must be a JSON object." };
+  }
+  const record = value;
+  const supportedKeys = record.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? /* @__PURE__ */ new Set([
+    "version",
+    "responseSamples",
+    "transient429",
+    "sharedRateLimit",
+    ...record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION ? ["replayBundle"] : []
+  ]) : /* @__PURE__ */ new Set(["version", "responseDelaySamplesMs"]);
+  const unknownKeys = Object.keys(record).filter(
+    (key) => !supportedKeys.has(key)
+  );
+  if (unknownKeys.length > 0) {
+    return {
+      ok: false,
+      error: `Unsupported fixtureBehavior field "${unknownKeys[0]}".`
+    };
+  }
+  if (record.version !== FIXTURE_BEHAVIOR_VERSION && record.version !== FIXTURE_BEHAVIOR_RESPONSE_VERSION && record.version !== FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    return {
+      ok: false,
+      error: `fixtureBehavior.version must be ${FIXTURE_BEHAVIOR_VERSION} or ${FIXTURE_BEHAVIOR_RESPONSE_VERSION}, or ${FIXTURE_BEHAVIOR_REPLAY_VERSION}.`
+    };
+  }
+  if (record.version === FIXTURE_BEHAVIOR_RESPONSE_VERSION || record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+    if (!Array.isArray(record.responseSamples) || record.responseSamples.length === 0 || record.responseSamples.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+      return {
+        ok: false,
+        error: `fixtureBehavior.responseSamples must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
+      };
+    }
+    const samples2 = [];
+    for (let index = 0; index < record.responseSamples.length; index += 1) {
+      const value2 = record.responseSamples[index];
+      if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+        return {
+          ok: false,
+          error: `fixtureBehavior.responseSamples[${index}] must be an object.`
+        };
+      }
+      const sample = value2;
+      const sampleUnknownKeys = Object.keys(sample).filter(
+        (key) => key !== "delayMs" && key !== "when" && key !== "httpError"
+      );
+      if (sampleUnknownKeys.length > 0) {
+        return {
+          ok: false,
+          error: `Unsupported fixtureBehavior.responseSamples[${index}] field "${sampleUnknownKeys[0]}".`
+        };
+      }
+      if (typeof sample.delayMs !== "number" || !Number.isSafeInteger(sample.delayMs) || sample.delayMs < 0 || sample.delayMs > MAX_FIXTURE_RESPONSE_DELAY_MS) {
+        return {
+          ok: false,
+          error: `fixtureBehavior.responseSamples[${index}].delayMs must be an integer between 0 and ${MAX_FIXTURE_RESPONSE_DELAY_MS}.`
+        };
+      }
+      let when;
+      if (sample.when !== void 0) {
+        if (!sample.when || typeof sample.when !== "object" || Array.isArray(sample.when)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].when must be an object.`
+          };
+        }
+        const condition = sample.when;
+        const conditionUnknownKeys = Object.keys(condition).filter(
+          (key) => key !== "provider" && key !== "operation"
+        );
+        if (conditionUnknownKeys.length > 0) {
+          return {
+            ok: false,
+            error: `Unsupported fixtureBehavior.responseSamples[${index}].when field "${conditionUnknownKeys[0]}".`
+          };
+        }
+        const provider = normalizeFixtureScopeValue(condition.provider, 100);
+        const operation = normalizeFixtureScopeValue(condition.operation, 200);
+        if (provider.error || operation.error) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].when ` + (provider.error ?? operation.error)
+          };
+        }
+        if (!provider.value && !operation.value) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].when must select a provider or operation.`
+          };
+        }
+        when = {
+          ...provider.value ? { provider: provider.value } : {},
+          ...operation.value ? { operation: operation.value } : {}
+        };
+      }
+      let httpError;
+      if (sample.httpError !== void 0) {
+        if (!sample.httpError || typeof sample.httpError !== "object" || Array.isArray(sample.httpError)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError must be an object.`
+          };
+        }
+        const error = sample.httpError;
+        const errorUnknownKeys = Object.keys(error).filter(
+          (key) => key !== "status" && key !== "message" && key !== "retryAfterMs" && key !== "retryAfterFormat" && key !== "failuresBeforeSuccess"
+        );
+        if (errorUnknownKeys.length > 0) {
+          return {
+            ok: false,
+            error: `Unsupported fixtureBehavior.responseSamples[${index}].httpError field "${errorUnknownKeys[0]}".`
+          };
+        }
+        if (typeof error.status !== "number" || !Number.isSafeInteger(error.status) || error.status < 400 || error.status > 599) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.status must be an integer between 400 and 599.`
+          };
+        }
+        if (typeof error.message !== "string" || !error.message.trim() || error.message.length > MAX_FIXTURE_RESPONSE_ERROR_MESSAGE_LENGTH) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.message must contain 1-${MAX_FIXTURE_RESPONSE_ERROR_MESSAGE_LENGTH} characters.`
+          };
+        }
+        if (error.retryAfterMs !== void 0 && (error.status !== 429 || typeof error.retryAfterMs !== "number" || !Number.isSafeInteger(error.retryAfterMs) || error.retryAfterMs < 1 || error.retryAfterMs > MAX_FIXTURE_RETRY_AFTER_MS)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.retryAfterMs requires status 429 and an integer from 1 through ${MAX_FIXTURE_RETRY_AFTER_MS}.`
+          };
+        }
+        if (error.retryAfterFormat !== void 0 && (error.status !== 429 || error.retryAfterFormat !== "delta_seconds" && error.retryAfterFormat !== "http_date")) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.retryAfterFormat requires status 429 and delta_seconds or http_date.`
+          };
+        }
+        if (error.failuresBeforeSuccess !== void 0 && (![429, 500, 502, 503, 504].includes(error.status) || typeof error.failuresBeforeSuccess !== "number" || !Number.isSafeInteger(error.failuresBeforeSuccess) || error.failuresBeforeSuccess < 1 || error.failuresBeforeSuccess > 20)) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.responseSamples[${index}].httpError.failuresBeforeSuccess requires status 429, 500, 502, 503, or 504 and an integer from 1 through 20.`
+          };
+        }
+        httpError = {
+          status: error.status,
+          message: error.message.trim(),
+          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+          ...error.retryAfterFormat !== void 0 ? {
+            retryAfterFormat: error.retryAfterFormat
+          } : {},
+          ...error.failuresBeforeSuccess !== void 0 ? { failuresBeforeSuccess: error.failuresBeforeSuccess } : {}
+        };
+      }
+      samples2.push({
+        delayMs: sample.delayMs,
+        ...when ? { when } : {},
+        ...httpError ? { httpError } : {}
+      });
+    }
+    let sharedRateLimit;
+    if (record.sharedRateLimit !== void 0) {
+      const plan = record.sharedRateLimit;
+      if (!plan || typeof plan !== "object" || Array.isArray(plan)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit must be an object."
+        };
+      }
+      const planRecord = plan;
+      const entries = Object.entries(planRecord);
+      const boundaryAfterMs = planRecord.requestsPerHourBoundaryAfterMs;
+      const quotaEntries = entries.filter(
+        ([name]) => name !== "requestsPerHourBoundaryAfterMs"
+      );
+      if (quotaEntries.length === 0 || quotaEntries.some(
+        ([name, limit]) => !FIXTURE_RATE_WINDOWS.some((window) => window.field === name) || typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 1
+      )) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit requires positive integer requestsPerSecond, requestsPerMinute, or requestsPerHour quotas."
+        };
+      }
+      if (boundaryAfterMs !== void 0 && (planRecord.requestsPerHour === void 0 || typeof boundaryAfterMs !== "number" || !Number.isSafeInteger(boundaryAfterMs) || boundaryAfterMs < 1e3 || boundaryAfterMs > 3e5)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.sharedRateLimit.requestsPerHourBoundaryAfterMs requires requestsPerHour and an integer from 1000 through 300000."
+        };
+      }
+      sharedRateLimit = Object.fromEntries(entries);
+    }
+    let transient429;
+    if (record.transient429 !== void 0) {
+      const selected = record.transient429;
+      if (!selected || typeof selected !== "object" || Array.isArray(selected)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.transient429 must be an object."
+        };
+      }
+      const fault = selected;
+      const unknownFaultKeys = Object.keys(fault).filter(
+        (key) => key !== "everyNthCall" && key !== "retryAfterMs" && key !== "failuresBeforeSuccess" && key !== "when"
+      );
+      if (unknownFaultKeys.length > 0) {
+        return {
+          ok: false,
+          error: `Unsupported fixtureBehavior.transient429 field "${unknownFaultKeys[0]}".`
+        };
+      }
+      for (const [name, value2, max] of [
+        ["everyNthCall", fault.everyNthCall, 1e4],
+        ["retryAfterMs", fault.retryAfterMs, MAX_FIXTURE_RETRY_AFTER_MS],
+        ["failuresBeforeSuccess", fault.failuresBeforeSuccess, 20]
+      ]) {
+        if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 1 || value2 > max) {
+          return {
+            ok: false,
+            error: `fixtureBehavior.transient429.${name} must be an integer from 1 through ${max}.`
+          };
+        }
+      }
+      let when;
+      if (fault.when !== void 0) {
+        if (!fault.when || typeof fault.when !== "object" || Array.isArray(fault.when)) {
+          return {
+            ok: false,
+            error: "fixtureBehavior.transient429.when must be an object."
+          };
+        }
+        const condition = fault.when;
+        const unknownConditionKeys = Object.keys(condition).filter(
+          (key) => key !== "provider" && key !== "operation"
+        );
+        if (unknownConditionKeys.length > 0) {
+          return {
+            ok: false,
+            error: `Unsupported fixtureBehavior.transient429.when field "${unknownConditionKeys[0]}".`
+          };
+        }
+        const provider = normalizeFixtureScopeValue(condition.provider, 100);
+        const operation = normalizeFixtureScopeValue(condition.operation, 200);
+        if (provider.error || operation.error || !provider.value && !operation.value) {
+          return {
+            ok: false,
+            error: "fixtureBehavior.transient429.when must select a valid provider or operation."
+          };
+        }
+        when = {
+          ...provider.value ? { provider: provider.value } : {},
+          ...operation.value ? { operation: operation.value } : {}
+        };
+      }
+      transient429 = {
+        everyNthCall: fault.everyNthCall,
+        retryAfterMs: fault.retryAfterMs,
+        failuresBeforeSuccess: fault.failuresBeforeSuccess,
+        ...when ? { when } : {}
+      };
+    }
+    let replayBundle;
+    if (record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+      if (!record.replayBundle || typeof record.replayBundle !== "object" || Array.isArray(record.replayBundle)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.replayBundle must be an object."
+        };
+      }
+      const replay = record.replayBundle;
+      const replayUnknownKeys = Object.keys(replay).filter(
+        (key) => key !== "bundleId" && key !== "manifestSha256" && key !== "syntheticFallbackToolIds" && key !== "selectionSeed"
+      );
+      if (replayUnknownKeys.length > 0) {
+        return {
+          ok: false,
+          error: `Unsupported fixtureBehavior.replayBundle field "${replayUnknownKeys[0]}".`
+        };
+      }
+      const digestPattern = /^[a-f0-9]{64}$/;
+      if (replay.selectionSeed !== void 0 && !isFixtureReplaySelectionSeed(replay.selectionSeed)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.replayBundle.selectionSeed must contain 1-128 letters, digits, dots, underscores, colons or hyphens."
+        };
+      }
+      if (typeof replay.bundleId !== "string" || !digestPattern.test(replay.bundleId)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.replayBundle.bundleId must be a lowercase SHA-256 digest."
+        };
+      }
+      if (typeof replay.manifestSha256 !== "string" || !digestPattern.test(replay.manifestSha256)) {
+        return {
+          ok: false,
+          error: "fixtureBehavior.replayBundle.manifestSha256 must be a lowercase SHA-256 digest."
+        };
+      }
+      let syntheticFallbackToolIds;
+      if (replay.syntheticFallbackToolIds !== void 0) {
+        if (!Array.isArray(replay.syntheticFallbackToolIds) || replay.syntheticFallbackToolIds.length === 0 || replay.syntheticFallbackToolIds.length > 32) {
+          return {
+            ok: false,
+            error: "fixtureBehavior.replayBundle.syntheticFallbackToolIds must contain 1-32 tool ids."
+          };
+        }
+        syntheticFallbackToolIds = [];
+        for (const rawToolId of replay.syntheticFallbackToolIds) {
+          if (typeof rawToolId !== "string" || rawToolId !== rawToolId.trim().toLowerCase() || !/^[a-z0-9][a-z0-9_.-]*$/.test(rawToolId) || rawToolId.length > 250 || syntheticFallbackToolIds.includes(rawToolId)) {
+            return {
+              ok: false,
+              error: "fixtureBehavior.replayBundle.syntheticFallbackToolIds contains an invalid tool id."
+            };
+          }
+          syntheticFallbackToolIds.push(rawToolId);
+        }
+      }
+      replayBundle = {
+        bundleId: replay.bundleId,
+        manifestSha256: replay.manifestSha256,
+        ...syntheticFallbackToolIds ? { syntheticFallbackToolIds } : {},
+        ...replay.selectionSeed !== void 0 ? { selectionSeed: replay.selectionSeed } : {}
+      };
+    }
+    if (record.version === FIXTURE_BEHAVIOR_REPLAY_VERSION) {
+      return {
+        ok: true,
+        behavior: {
+          version: FIXTURE_BEHAVIOR_REPLAY_VERSION,
+          responseSamples: samples2,
+          ...transient429 ? { transient429 } : {},
+          ...sharedRateLimit ? { sharedRateLimit } : {},
+          replayBundle
+        }
+      };
+    }
+    return {
+      ok: true,
+      behavior: {
+        version: FIXTURE_BEHAVIOR_RESPONSE_VERSION,
+        responseSamples: samples2,
+        ...transient429 ? { transient429 } : {},
+        ...sharedRateLimit ? { sharedRateLimit } : {}
+      }
+    };
+  }
+  if (!Array.isArray(record.responseDelaySamplesMs) || record.responseDelaySamplesMs.length === 0 || record.responseDelaySamplesMs.length > MAX_FIXTURE_RESPONSE_DELAY_SAMPLES) {
+    return {
+      ok: false,
+      error: `fixtureBehavior.responseDelaySamplesMs must contain between 1 and ${MAX_FIXTURE_RESPONSE_DELAY_SAMPLES} values.`
+    };
+  }
+  const samples = [];
+  for (let index = 0; index < record.responseDelaySamplesMs.length; index += 1) {
+    const value2 = record.responseDelaySamplesMs[index];
+    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 0 || value2 > MAX_FIXTURE_RESPONSE_DELAY_MS) {
+      return {
+        ok: false,
+        error: `fixtureBehavior.responseDelaySamplesMs[${index}] must be an integer between 0 and ${MAX_FIXTURE_RESPONSE_DELAY_MS}.`
+      };
+    }
+    samples.push(value2);
+  }
+  return {
+    ok: true,
+    behavior: {
+      version: FIXTURE_BEHAVIOR_VERSION,
+      responseDelaySamplesMs: samples
+    }
+  };
+}
+function normalizeFixtureScopeValue(value, maxLength) {
+  if (value === void 0) return {};
+  if (typeof value !== "string" || !value.trim()) {
+    return { error: "values must be non-empty strings." };
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length > maxLength) {
+    return { error: `values must be at most ${maxLength} characters.` };
+  }
+  return { value: normalized };
+}
+
+// src/cli/operations/play-run-options.ts
+var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "--dry-run",
+  "--json",
+  "--wait",
+  "--tail",
+  "--watch",
+  "--no-wait",
+  "--logs",
+  "--debug",
+  "--full",
+  "--force",
+  "--force-tool-refresh",
+  "--open",
+  "--debug-map-latency"
+]);
+var PLAY_RUN_HEADER_FLAG_USAGE = `--header requires "<name>: <value>", for example: --header 'x-deepline-absurd-release: 2026-09-07.1'`;
+var HTTP_HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9a-z]+$/;
+function parsePlayRunHeaderFlag(raw) {
+  const separator = raw.indexOf(":");
+  if (separator < 0) {
+    throw new Error(
+      `${PLAY_RUN_HEADER_FLAG_USAGE}. Got ${JSON.stringify(raw)} with no ":" separator.`
+    );
+  }
+  const name = raw.slice(0, separator).trim().toLowerCase();
+  const value = raw.slice(separator + 1).trim();
+  if (!name) {
+    throw new Error(
+      `${PLAY_RUN_HEADER_FLAG_USAGE}. Got ${JSON.stringify(raw)} with an empty header name.`
+    );
+  }
+  if (!HTTP_HEADER_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `${PLAY_RUN_HEADER_FLAG_USAGE}. ${JSON.stringify(name)} is not a valid HTTP header name.`
+    );
+  }
+  if (!value) {
+    throw new Error(
+      `${PLAY_RUN_HEADER_FLAG_USAGE}. Header ${JSON.stringify(name)} was given an empty value.`
+    );
+  }
+  if (/[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(
+      `${PLAY_RUN_HEADER_FLAG_USAGE}. Header ${JSON.stringify(name)} contains a control character.`
+    );
+  }
+  return { name, value };
+}
+function isBarePlayRunDebugFlag(args, index) {
+  return args[index] === "--debug" && (args[index + 1] === void 0 || args[index + 1].startsWith("--"));
+}
+function parseReferencedPlayTarget(target) {
+  const trimmed = target.trim();
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
+    return { ownerSlug: null, playName: trimmed, unqualifiedPlayName: trimmed };
+  }
+  return {
+    ownerSlug: trimmed.slice(0, slashIndex),
+    playName: trimmed,
+    unqualifiedPlayName: trimmed.slice(slashIndex + 1)
+  };
+}
+function isFileTarget(target) {
+  return existsSync(resolve(target));
+}
+function looksLikeFilePath(target) {
+  if (target.trim().toLowerCase().startsWith("prebuilt/")) {
+    return false;
+  }
+  if (target.startsWith("./") || target.startsWith("../") || target.startsWith("/") || target.startsWith("~/")) {
+    return true;
+  }
+  return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
+}
+function parsePositiveInteger(value, flagName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flagName} must be a positive integer.`);
+  }
+  return parsed;
+}
+function parseJsonInput(raw, flag = "--input") {
+  const source = raw.startsWith("@") ? readFileSync(resolve(raw.slice(1)), "utf-8") : raw;
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new DeeplineError(
+      `${flag} expects a valid JSON object or @input.json. A bare file path is not JSON.${flag === "--input" ? " Use the field names and run example from plays check <file> or deepline describe <play>. --csv contacts.csv supplies input.csv only when the Play declares that field." : ""}`,
+      void 0,
+      "INVALID_JSON"
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new DeeplineError(
+      `${flag} must be a JSON object.`,
+      void 0,
+      "INVALID_JSON"
+    );
+  }
+  return parsed;
+}
+function parseInputFieldFlag(rawFlag, nextArg) {
+  const flag = rawFlag.slice(2);
+  const equalsIndex = flag.indexOf("=");
+  if (equalsIndex > 0) {
+    const path = flag.slice(0, equalsIndex).trim();
+    const value = flag.slice(equalsIndex + 1);
+    if (!path) {
+      throw new Error(`Invalid play input flag: ${rawFlag}`);
+    }
+    return { path, value };
+  }
+  if (!nextArg || nextArg.startsWith("--")) {
+    throw new Error(`Play input flag ${rawFlag} requires a value.`);
+  }
+  return { path: flag, value: nextArg };
+}
+function parseInputFlagValue(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  if (trimmed === "true" || trimmed === "false" || trimmed === "null" || trimmed.startsWith("{") || trimmed.startsWith("[") || /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function parsePlayRunOptions(args, initialInput = null) {
+  const selection = parseJsonFields(args, "run");
+  args = selection.args;
+  const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--run-id-file <path>] [--no-wait] [--tail-timeout-ms 30000] [--force] [--open] [--full] [--<input> value]\n       deepline plays run <play-file.ts> [--input '{...}'] [--run-id-file <path>] [--no-wait] [--tail-timeout-ms 30000] [--force] [--open] [--full] [--<input> value]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--profile <id>] [--run-id-file <path>] [--no-wait] [--tail-timeout-ms 30000] [--force] [--open] [--full] [--<input> value]\n       deepline plays run --name <name> [--input '{...}'] [--profile <id>] [--live|--latest|--revision-id <id>] [--run-id-file <path>] [--no-wait] [--tail-timeout-ms 30000] [--force] [--open] [--json] [--full] [--<input> value]\n       Runs use the Absurd CJS runtime.\n       --header '<name>: <value>' may repeat; each is sent on every request for this run.\n       Unknown --<input> value flags, such as --limit 5, are passed into play input.\nRun `deepline plays run --help` for idempotent call caching and deepline.dataset guidance.";
+  let filePath = null;
+  let playName = null;
+  let input = initialInput === null ? null : structuredClone(initialInput);
+  let revisionId = null;
+  let workflowId = null;
+  let maxTotalCredits = null;
+  let revisionSelector = null;
+  const watch = !args.includes("--no-wait");
+  const dryRun = args.includes("--dry-run");
+  let jsonOutput = dryRun ? argsWantJson(args) : watch ? args.includes("--json") : argsWantJson(args);
+  const fullJson = args.includes("--full");
+  const force = args.includes("--force");
+  const forceToolRefresh = args.includes("--force-tool-refresh");
+  const open = args.includes("--open");
+  const debugMapLatency = args.includes("--debug-map-latency");
+  let logLevel = "info";
+  let hasExplicitLogLevel = false;
+  let waitTimeoutMs = null;
+  let maxConcurrentExternalCalls = null;
+  let maxConcurrentRows = null;
+  let profile = null;
+  let fixtureBehavior = null;
+  let runIdFile = null;
+  let headers = null;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--workflow-id") {
+      const value = args[++index];
+      if (!value || value.startsWith("--"))
+        throw new Error("--workflow-id requires the original caller run ID.");
+      workflowId = value;
+      continue;
+    }
+    if (arg === "--max-total-credits") {
+      const value = args[++index];
+      if (value === void 0 || value.trim() === "" || !Number.isFinite(Number(value)) || Number(value) < 0)
+        throw new Error(
+          "--max-total-credits requires a non-negative number, including zero."
+        );
+      maxTotalCredits = Number(value);
+      continue;
+    }
+    if (arg === "--header" || arg.startsWith("--header=")) {
+      const raw = arg === "--header" ? args[index + 1] : arg.slice("--header=".length);
+      if (raw === void 0 || arg === "--header" && raw.startsWith("--")) {
+        throw new Error(`${PLAY_RUN_HEADER_FLAG_USAGE}. No value was given.`);
+      }
+      const header = parsePlayRunHeaderFlag(raw);
+      headers ??= {};
+      headers[header.name] = header.value;
+      if (arg === "--header") index += 1;
+      continue;
+    }
+    if (arg === "--file" && args[index + 1]) {
+      filePath = args[++index];
+      continue;
+    }
+    if (arg === "--name" && args[index + 1]) {
+      playName = parseReferencedPlayTarget(args[++index]).playName;
+      continue;
+    }
+    if ((arg === "--input" || arg === "-i") && args[index + 1]) {
+      input = parseJsonInput(args[++index]);
+      continue;
+    }
+    if (arg === "--log-level" || arg.startsWith("--log-level=")) {
+      const value = arg === "--log-level" ? args[++index] : arg.slice("--log-level=".length);
+      if (!value || value.startsWith("--")) {
+        throw new Error(
+          "--log-level requires one of: debug, info, warn, error."
+        );
+      }
+      const parsed = parseLogLevel(value);
+      if (!parsed) {
+        throw new Error(
+          `Unsupported --log-level ${JSON.stringify(value)}. Use debug, info, warn, or error.`
+        );
+      }
+      logLevel = parsed;
+      hasExplicitLogLevel = true;
+      continue;
+    }
+    if (arg === "--run-id-file") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--run-id-file requires a destination path.");
+      }
+      runIdFile = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--run-id-file=")) {
+      const value = arg.slice("--run-id-file=".length);
+      if (!value) {
+        throw new Error("--run-id-file requires a destination path.");
+      }
+      runIdFile = value;
+      continue;
+    }
+    if (arg === "--revision-id" && args[index + 1]) {
+      revisionId = args[++index];
+      continue;
+    }
+    if (arg === "--profile") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("--profile requires an execution profile id.");
+      }
+      profile = value.trim();
+      resolveEnabledExecutionProfile(profile);
+      index += 1;
+      continue;
+    }
+    if (arg === "--max-concurrent-external-calls") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(
+          "--max-concurrent-external-calls requires a whole number."
+        );
+      }
+      if (!/^[1-9]\d*$/.test(value)) {
+        throw new Error(
+          "--max-concurrent-external-calls requires a positive whole number."
+        );
+      }
+      maxConcurrentExternalCalls = parsePositiveInteger(
+        value,
+        "--max-concurrent-external-calls"
+      );
+      resolveMaxConcurrentExternalCalls(maxConcurrentExternalCalls);
+      index += 1;
+      continue;
+    }
+    if (arg === "--max-concurrent-rows") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--max-concurrent-rows requires a whole number.");
+      }
+      if (!/^[1-9]\d*$/.test(value)) {
+        throw new Error(
+          "--max-concurrent-rows requires a positive whole number."
+        );
+      }
+      maxConcurrentRows = parsePositiveInteger(value, "--max-concurrent-rows");
+      resolveMaxConcurrentRows(maxConcurrentRows);
+      index += 1;
+      continue;
+    }
+    if (arg === "--fixture-behavior") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error(
+          "--fixture-behavior requires a JSON object or @file path."
+        );
+      }
+      const parsed = validateFixtureBehavior(
+        parseJsonInput(value, "--fixture-behavior")
+      );
+      if (!parsed.ok || !parsed.behavior) {
+        throw new Error(
+          parsed.ok ? "--fixture-behavior is required." : parsed.error
+        );
+      }
+      fixtureBehavior = parsed.behavior;
+      index += 1;
+      continue;
+    }
+    if (arg === "--live") {
+      revisionSelector = "live";
+      continue;
+    }
+    if (arg === "--latest") {
+      revisionSelector = "latest";
+      continue;
+    }
+    if (arg === "--out" || arg.startsWith("--out=")) {
+      throw new Error(
+        "--out is not a plays run flag. Run the play first, then export rows with: deepline runs export <run-id> --out output.csv"
+      );
+    }
+    if (arg === "--no-open" || arg.startsWith("--no-open=")) {
+      throw new Error(
+        "--no-open was removed for `plays run`. Play page URLs are printed by default; pass --open to launch a browser."
+      );
+    }
+    if (arg === "--poll-interval-ms" || arg === "--interval-ms") {
+      throw new Error(
+        `${arg} was removed. --watch polls the canonical run snapshot.`
+      );
+    }
+    if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
+      waitTimeoutMs = parsePositiveInteger(args[++index], arg);
+      continue;
+    }
+    if (arg === "--debug" && args[index + 1] && !args[index + 1].startsWith("--")) {
+      input ??= {};
+      setDottedInputValue(input, "debug", parseInputFlagValue(args[++index]));
+      continue;
+    }
+    if (arg.startsWith("--debug=")) {
+      input ??= {};
+      setDottedInputValue(
+        input,
+        "debug",
+        parseInputFlagValue(arg.slice("--debug=".length))
+      );
+      continue;
+    }
+    if (PLAY_RUN_RESERVED_BOOLEAN_FLAGS.has(arg)) {
+      if (arg === "--watch") {
+        continue;
+      }
+      if (arg === "--wait") {
+        continue;
+      }
+      if (arg === "--json") {
+        jsonOutput = true;
+        continue;
+      }
+      if (arg === "--tail") {
+        throw new Error(
+          "--tail is removed for `plays run`; run waits and streams completion output by default."
+        );
+      }
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const { path, value } = parseInputFieldFlag(arg, args[index + 1]);
+      input ??= {};
+      setDottedInputValue(input, path, parseInputFlagValue(value));
+      if (!arg.includes("=")) {
+        index += 1;
+      }
+      continue;
+    }
+    if (!arg.startsWith("--") && !filePath && !playName) {
+      if (isFileTarget(arg) || looksLikeFilePath(arg)) {
+        filePath = arg;
+      } else {
+        playName = parseReferencedPlayTarget(arg).playName;
+      }
+      continue;
+    }
+  }
+  if (filePath && playName || !filePath && !playName) {
+    throw new Error(usage);
+  }
+  const explicitRevisionSelectors = [
+    revisionId ? "--revision-id" : null,
+    revisionSelector === "live" ? "--live" : null,
+    revisionSelector === "latest" ? "--latest" : null
+  ].filter(Boolean);
+  if (explicitRevisionSelectors.length > 1) {
+    throw new Error(
+      `Choose only one revision selector: ${explicitRevisionSelectors.join(", ")}.`
+    );
+  }
+  if (filePath && explicitRevisionSelectors.length > 0) {
+    throw new Error(
+      "--live, --latest, and --revision-id only apply to named plays."
+    );
+  }
+  if (debugMapLatency && logLevel === "info") logLevel = "debug";
+  const usesDebugAlias = args.includes("--logs") || args.some((_, index) => isBarePlayRunDebugFlag(args, index));
+  if (usesDebugAlias && hasExplicitLogLevel && logLevel !== "debug") {
+    throw new Error(
+      "--debug/--logs conflicts with a non-debug --log-level. Use one level selector."
+    );
+  }
+  if (usesDebugAlias) logLevel = "debug";
+  const explicitDebugLogs = usesDebugAlias || logLevel === "debug";
+  const emitLogs = !jsonOutput || explicitDebugLogs || hasExplicitLogLevel;
+  const verboseLogs = explicitDebugLogs || debugMapLatency;
+  if (dryRun && !filePath)
+    throw new Error("--dry-run currently requires a local Play file.");
+  return {
+    dryRun,
+    target: filePath ? { kind: "file", path: filePath } : { kind: "name", name: playName },
+    input,
+    revisionId,
+    workflowId,
+    maxTotalCredits,
+    revisionSelector,
+    watch,
+    emitLogs,
+    verboseLogs,
+    logLevel,
+    jsonOutput,
+    fullJson,
+    jsonFields: selection.fields,
+    waitTimeoutMs,
+    force,
+    forceToolRefresh,
+    maxConcurrentExternalCalls,
+    maxConcurrentRows,
+    maxCredits: null,
+    open,
+    profile,
+    debugMapLatency,
+    fixtureBehavior,
+    runIdFile,
+    headers
+  };
+}
+function resolvePlayRunCliOptions(target, options, inputArgs = [], maintenancePolicy) {
+  const stringOption = (value, flag) => {
+    if (value !== void 0 && !value.trim())
+      throw new Error(`${flag} requires a non-empty value.`);
+    return value;
+  };
+  const file = stringOption(options.file, "--file");
+  const name = stringOption(options.name, "--name");
+  if (file !== void 0 && name !== void 0)
+    throw new Error("Choose only one target: --file or --name.");
+  const selectedTarget = file ?? name ?? target;
+  let initialInput = options.input === void 0 ? null : parseJsonInput(options.input);
+  if (typeof options.debug === "string") {
+    initialInput ??= {};
+    setDottedInputValue(
+      initialInput,
+      "debug",
+      parseInputFlagValue(options.debug)
+    );
+  }
+  const base = parsePlayRunOptions(
+    [...selectedTarget === void 0 ? [] : [selectedTarget], ...inputArgs],
+    initialInput
+  );
+  const resolvedTarget = file !== void 0 ? { kind: "file", path: file } : name !== void 0 ? {
+    kind: "name",
+    name: parseReferencedPlayTarget(name).playName
+  } : base.target;
+  const revisionId = stringOption(options.revisionId, "--revision-id") ?? base.revisionId;
+  const selectors = [
+    revisionId ? "--revision-id" : null,
+    options.live ? "--live" : null,
+    options.latest ? "--latest" : null
+  ].filter(Boolean);
+  if (selectors.length > 1)
+    throw new Error(
+      `Choose only one revision selector: ${selectors.join(", ")}.`
+    );
+  if (resolvedTarget.kind === "file" && selectors.length)
+    throw new Error(
+      "--live, --latest, and --revision-id only apply to named plays."
+    );
+  const dryRun = options.dryRun ?? base.dryRun;
+  const maxTotalCredits = options.maxTotalCredits === void 0 ? base.maxTotalCredits : Number(options.maxTotalCredits);
+  if (maxTotalCredits !== null && (!Number.isFinite(maxTotalCredits) || maxTotalCredits < 0 || options.maxTotalCredits?.trim() === ""))
+    throw new Error(
+      "--max-total-credits requires a non-negative number, including zero."
+    );
+  if (dryRun && resolvedTarget.kind !== "file")
+    throw new Error("--dry-run currently requires a local Play file.");
+  const profile = stringOption(options.profile, "--profile")?.trim() ?? base.profile;
+  if (profile !== null) resolveEnabledExecutionProfile(profile);
+  const countOption = (value, flag) => {
+    if (value === void 0) return void 0;
+    if (!/^[1-9]\d*$/.test(value))
+      throw new Error(`${flag} requires a positive whole number.`);
+    const count = Number(value);
+    if (!Number.isSafeInteger(count))
+      throw new Error(`${flag} requires a positive whole number.`);
+    return count;
+  };
+  const externalCalls = countOption(
+    options.maxConcurrentExternalCalls,
+    "--max-concurrent-external-calls"
+  ) ?? base.maxConcurrentExternalCalls;
+  if (externalCalls !== null) resolveMaxConcurrentExternalCalls(externalCalls);
+  const rows = countOption(options.maxConcurrentRows, "--max-concurrent-rows") ?? base.maxConcurrentRows;
+  if (rows !== null) resolveMaxConcurrentRows(rows);
+  const maxCredits = options.maxCredits === void 0 ? null : Number(options.maxCredits);
+  if (maxCredits !== null && !(maxCredits > 0 && isFinite(maxCredits)))
+    throw new Error("--max-credits must be a number greater than 0.");
+  const waitTimeoutMs = countOption(options.tailTimeoutMs, "--tail-timeout-ms") ?? base.waitTimeoutMs;
+  let fixtureBehavior = base.fixtureBehavior;
+  if (options.fixtureBehavior !== void 0) {
+    const parsed = validateFixtureBehavior(
+      parseJsonInput(options.fixtureBehavior, "--fixture-behavior")
+    );
+    if (!parsed.ok || !parsed.behavior)
+      throw new Error(
+        parsed.ok ? "--fixture-behavior is required." : parsed.error
+      );
+    fixtureBehavior = parsed.behavior;
+  }
+  const hasExplicitLogLevel = options.logLevel !== void 0 || inputArgs.some(
+    (arg) => arg === "--log-level" || arg.startsWith("--log-level=")
+  );
+  let logLevel = options.logLevel === void 0 ? base.logLevel : parseLogLevel(options.logLevel);
+  if (!logLevel)
+    throw new Error("--log-level requires one of: debug, info, warn, error.");
+  const debugAlias = options.logs || options.debug === true || inputArgs.some(
+    (arg, index) => arg === "--logs" || isBarePlayRunDebugFlag(inputArgs, index)
+  );
+  if (debugAlias && hasExplicitLogLevel && logLevel !== "debug")
+    throw new Error(
+      "--debug/--logs conflicts with a non-debug --log-level. Use one level selector."
+    );
+  const debugMapLatency = options.debugMapLatency ?? base.debugMapLatency;
+  if (debugAlias || debugMapLatency && logLevel === "info")
+    logLevel = "debug";
+  const fullJson = options.full ?? base.fullJson;
+  const jsonFields = options.json === void 0 ? base.jsonFields : parseJsonFields(
+    [...fullJson ? ["--full"] : [], ...jsonFieldArgs(options.json)],
+    "run"
+  ).fields;
+  const watch = options.wait === false ? false : base.watch;
+  const explicitJson = options.json !== void 0 ? options.json !== false : base.jsonOutput;
+  const jsonOutput = dryRun || !watch ? explicitJson || argsWantJson([]) : explicitJson;
+  const verboseLogs = Boolean(
+    debugAlias || logLevel === "debug" || debugMapLatency
+  );
+  return {
+    ...base,
+    ...maintenancePolicy ? { maintenancePolicy } : {},
+    target: resolvedTarget,
+    dryRun,
+    input: base.input,
+    revisionId,
+    workflowId: stringOption(options.workflowId, "--workflow-id") ?? base.workflowId,
+    maxTotalCredits,
+    revisionSelector: options.live ? "live" : options.latest ? "latest" : base.revisionSelector,
+    profile,
+    fixtureBehavior,
+    watch,
+    runIdFile: stringOption(options.runIdFile, "--run-id-file") ?? base.runIdFile,
+    logLevel,
+    emitLogs: !jsonOutput || verboseLogs || hasExplicitLogLevel,
+    verboseLogs,
+    jsonOutput,
+    fullJson,
+    jsonFields,
+    waitTimeoutMs,
+    force: options.force ?? base.force,
+    forceToolRefresh: options.forceToolRefresh ?? base.forceToolRefresh,
+    maxConcurrentExternalCalls: externalCalls,
+    maxConcurrentRows: rows,
+    maxCredits,
+    open: options.open ?? base.open,
+    debugMapLatency
+  };
+}
+
+export {
+  DEFAULT_MAX_CONCURRENT_EXTERNAL_CALLS,
+  MAX_CONFIGURABLE_CONCURRENT_EXTERNAL_CALLS,
+  MAX_CONFIGURABLE_CONCURRENT_ROWS,
+  parsePlayRunHeaderFlag,
+  looksLikeFilePath,
+  parsePlayRunOptions,
+  resolvePlayRunCliOptions
+};