@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/chunk-91p9vzcs.js

@@ -0,0 +1,1453 @@
+// @bun
+import {
+  ARTIFACT_SCHEMA_KEYWORD2
+} from "./chunk-56e4kp0a.js";
+import {
+  buildArtifactMarker2
+} from "./chunk-631ffb6r.js";
+import {
+  toolHealthCheckSchema2,
+  stepHealthChecksInputSchema2
+} from "./chunk-zpqyjgb4.js";
+import {
+  devcontainerConfigPathSchema2
+} from "./chunk-9s07v9r1.js";
+import {
+  MANAGED_RUNTIME_IDS2,
+  DEFAULT_CODE_STEP_RUNTIME_ID2
+} from "./chunk-s0gap8r8.js";
+import {
+  ENV_VAR_NAME_PATTERN2,
+  containsInputToken2,
+  isReservedEnvVarName2
+} from "./chunk-p6kc9wq8.js";
+import {
+  repoConfigInputSchema2,
+  repoRuntimeMismatch2
+} from "./chunk-b21233rt.js";
+import {
+  openCodeMcpLocalConfigSchema2,
+  openCodeMcpRemoteConfigSchema2,
+  openCodeMcpRefConfigSchema2,
+  isEnvPlaceholderValue2,
+  collectEnvPlaceholderNames2
+} from "./chunk-g0rdnn0r.js";
+import {
+  makeHandle,
+  stepNode,
+  stepCall
+} from "./chunk-eg1hcvhb.js";
+import {
+  createClient,
+  StepDefinitions2
+} from "./chunk-ynk2bjae.js";
+import {
+  ZodIssueCode,
+  setErrorMap,
+  getErrorMap,
+  ZodFirstPartyTypeKind,
+  fromJSONSchema,
+  exports_coerce,
+  exports_external,
+  BUILT_IN_ERRORS2
+} from "./chunk-5mmj03ah.js";
+import {
+  __export,
+  NEVER,
+  $brand,
+  config,
+  clone,
+  exports_util,
+  flattenError,
+  formatError,
+  treeifyError,
+  prettifyError,
+  exports_regexes,
+  exports_locales,
+  $output,
+  $input,
+  registry,
+  globalRegistry,
+  TimePrecision,
+  _lt,
+  _lte,
+  _gt,
+  _gte,
+  _positive,
+  _negative,
+  _nonpositive,
+  _nonnegative,
+  _multipleOf,
+  _maxSize,
+  _minSize,
+  _size,
+  _maxLength,
+  _minLength,
+  _length,
+  _regex,
+  _lowercase,
+  _uppercase,
+  _includes,
+  _startsWith,
+  _endsWith,
+  _property,
+  _mime,
+  _overwrite,
+  _normalize,
+  _trim,
+  _toLowerCase,
+  _toUpperCase,
+  _slugify,
+  toJSONSchema,
+  exports_core,
+  ZodISODateTime,
+  ZodISODate,
+  ZodISOTime,
+  ZodISODuration,
+  exports_iso,
+  ZodError,
+  ZodRealError,
+  parse,
+  parseAsync,
+  safeParse,
+  safeParseAsync,
+  encode,
+  decode,
+  encodeAsync,
+  decodeAsync,
+  safeEncode,
+  safeDecode,
+  safeEncodeAsync,
+  safeDecodeAsync,
+  ZodType,
+  _ZodString,
+  ZodString,
+  string,
+  ZodStringFormat,
+  ZodEmail,
+  email,
+  ZodGUID,
+  guid,
+  ZodUUID,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  ZodURL,
+  url,
+  httpUrl,
+  ZodEmoji,
+  emoji,
+  ZodNanoID,
+  nanoid,
+  ZodCUID,
+  cuid,
+  ZodCUID2,
+  cuid2,
+  ZodULID,
+  ulid,
+  ZodXID,
+  xid,
+  ZodKSUID,
+  ksuid,
+  ZodIPv4,
+  ipv4,
+  ZodMAC,
+  mac,
+  ZodIPv6,
+  ipv6,
+  ZodCIDRv4,
+  cidrv4,
+  ZodCIDRv6,
+  cidrv6,
+  ZodBase64,
+  base64,
+  ZodBase64URL,
+  base64url,
+  ZodE164,
+  e164,
+  ZodJWT,
+  jwt,
+  ZodCustomStringFormat,
+  stringFormat,
+  hostname,
+  hex,
+  hash,
+  ZodNumber,
+  number,
+  ZodNumberFormat,
+  int,
+  float32,
+  float64,
+  int32,
+  uint32,
+  ZodBoolean,
+  boolean,
+  ZodBigInt,
+  bigint,
+  ZodBigIntFormat,
+  int64,
+  uint64,
+  ZodSymbol,
+  symbol,
+  ZodUndefined,
+  _undefined,
+  ZodNull,
+  _null,
+  ZodAny,
+  any3,
+  ZodUnknown,
+  unknown,
+  ZodNever,
+  never,
+  ZodVoid,
+  _void,
+  ZodDate,
+  date,
+  ZodArray,
+  array,
+  keyof,
+  ZodObject,
+  object,
+  strictObject,
+  looseObject,
+  ZodUnion,
+  union,
+  ZodXor,
+  xor,
+  ZodDiscriminatedUnion,
+  discriminatedUnion,
+  ZodIntersection,
+  intersection,
+  ZodTuple,
+  tuple,
+  ZodRecord,
+  record,
+  partialRecord,
+  looseRecord,
+  ZodMap,
+  map,
+  ZodSet,
+  set,
+  ZodEnum,
+  _enum,
+  nativeEnum,
+  ZodLiteral,
+  literal,
+  ZodFile,
+  file,
+  ZodTransform,
+  transform,
+  ZodOptional,
+  optional,
+  ZodExactOptional,
+  exactOptional,
+  ZodNullable,
+  nullable,
+  nullish,
+  ZodDefault,
+  _default,
+  ZodPrefault,
+  prefault,
+  ZodNonOptional,
+  nonoptional,
+  ZodSuccess,
+  success,
+  ZodCatch,
+  _catch,
+  ZodNaN,
+  nan,
+  ZodPipe,
+  pipe,
+  ZodCodec,
+  codec,
+  invertCodec,
+  ZodPreprocess,
+  ZodReadonly,
+  readonly,
+  ZodTemplateLiteral,
+  templateLiteral,
+  ZodLazy,
+  lazy,
+  ZodPromise,
+  promise,
+  ZodFunction,
+  _function,
+  ZodCustom,
+  check,
+  custom,
+  refine,
+  superRefine,
+  describe,
+  meta,
+  _instanceof,
+  stringbool,
+  json,
+  preprocess
+} from "./chunk-dnn39qt4.js";
+
+// src/z.ts
+var exports_z = {};
+__export(exports_z, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default,
+  _function: () => _function,
+  any: () => any3,
+  array: () => array,
+  artifact: () => artifact2,
+  base64: () => base64,
+  base64url: () => base64url,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  catch: () => _catch,
+  check: () => check,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  custom: () => custom,
+  date: () => date,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  endsWith: () => _endsWith,
+  enum: () => _enum,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  fromJSONSchema: () => fromJSONSchema,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid,
+  hash: () => hash,
+  hex: () => hex,
+  hostname: () => hostname,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  meta: () => meta,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null,
+  nullable: () => nullable,
+  nullish: () => nullish,
+  number: () => number,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void,
+  xid: () => xid,
+  xor: () => xor,
+  z: () => exports_external
+});
+// src/definitions/artifacts/artifact.ts
+var ARTIFACT_BRAND2 = "ScarnArtifact";
+var ArtifactTypes2 = {
+  video: [".mp4", ".webm", ".mov"],
+  image: [".png", ".jpg", ".jpeg", ".gif", ".svg"]
+};
+var EXTENSION_PATTERN = /^\.[a-z0-9][a-z0-9_-]*(\.[a-z0-9][a-z0-9_-]*)*$/;
+function describeEntry(entry) {
+  const cleaned = entry.trim().toLowerCase().replace(/^\*?\.?/, "");
+  return cleaned && EXTENSION_PATTERN.test(`.${cleaned}`) ? ` Did you mean \`.${cleaned}\`?` : "";
+}
+function normalizeArtifactAccept2(accept) {
+  if (accept === undefined)
+    return [];
+  const problems = [];
+  const out = [];
+  for (const entry of accept) {
+    if (typeof entry !== "string") {
+      problems.push(`${JSON.stringify(entry)} is not a string.`);
+      continue;
+    }
+    if (!entry.startsWith(".")) {
+      problems.push(`"${entry}" must be a file extension starting with a dot.${describeEntry(entry)}`);
+      continue;
+    }
+    if (entry !== entry.toLowerCase()) {
+      problems.push(`"${entry}" must be lower-case.${describeEntry(entry)}`);
+      continue;
+    }
+    if (!EXTENSION_PATTERN.test(entry)) {
+      problems.push(`"${entry}" is not a valid file extension.`);
+      continue;
+    }
+    if (!out.includes(entry))
+      out.push(entry);
+  }
+  if (problems.length > 0) {
+    throw new Error(`artifact({ accept }): ${problems.join(" ")}`);
+  }
+  return out;
+}
+function artifact2(options = {}) {
+  const keyword = {
+    accept: normalizeArtifactAccept2(options.accept)
+  };
+  return string().brand().meta({ [ARTIFACT_SCHEMA_KEYWORD2]: keyword });
+}
+var toMarkerRef = (target) => typeof target === "string" ? { type: "path", pattern: target } : {
+  type: "signal",
+  stepKey: target.step.key,
+  signalKey: target.path
+};
+var Artifact2 = {
+  path(relativePath) {
+    return relativePath;
+  },
+  embed(target, options) {
+    return buildArtifactMarker2("embed", toMarkerRef(target), options.caption);
+  },
+  link(target, options) {
+    return buildArtifactMarker2("link", toMarkerRef(target), options.label);
+  }
+};
+// src/definitions/steps/prompt-template.ts
+function createPromptInputProxy2(path = []) {
+  const token = () => path.length ? `{{${path.join(".")}}}` : "";
+  return new Proxy(Object.freeze({}), {
+    get(_, key) {
+      if (key === Symbol.toPrimitive || key === "valueOf") {
+        return (_hint) => token();
+      }
+      if (key === "toString") {
+        return () => token();
+      }
+      if (typeof key !== "string")
+        return;
+      return createPromptInputProxy2([...path, key]);
+    }
+  });
+}
+function createPromptTemplateContext2() {
+  return {
+    input: createPromptInputProxy2(["input"]),
+    env: createPromptInputProxy2(["env"]),
+    scarn: {
+      artifactsDir: createPromptInputProxy2([
+        "scarn",
+        "artifactsDir"
+      ])
+    }
+  };
+}
+function renderPromptTemplate2(template, contextJson) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
+    const value = path.split(".").reduce((curr, key) => curr != null ? curr[key] : undefined, contextJson);
+    return value != null ? String(value) : "";
+  });
+}
+
+// src/definitions/steps/env.ts
+var SECRET_LOOKING_NAME = /SECRET|TOKEN|PASSWORD|PASSWD|API_?KEY|PRIVATE/i;
+function isSecretLookingEnvName2(name) {
+  return SECRET_LOOKING_NAME.test(name);
+}
+var helperEntries = new WeakSet;
+function brand(entry) {
+  helperEntries.add(entry);
+  return entry;
+}
+var Env2 = {
+  value(opts) {
+    return brand({
+      kind: "value",
+      value: opts.value,
+      secret: opts.secret ?? false,
+      unsafeAllowStatic: opts.unsafeAllowStatic ?? false,
+      applies: opts.applies ?? "agent"
+    });
+  },
+  inherit(opts) {
+    return brand({
+      kind: "inherit",
+      from: opts?.from,
+      secret: opts?.secret ?? false,
+      optional: opts?.optional ?? false,
+      default: opts?.default,
+      applies: opts?.applies ?? "agent"
+    });
+  }
+};
+function isHelperEntry(entry) {
+  return typeof entry === "object" && helperEntries.has(entry);
+}
+function assertNotStaticSecret(name, value, flags) {
+  if (containsInputToken2(value))
+    return;
+  if (flags.secret) {
+    throw new Error(`Env "${name}": a secret must interpolate an input token; a static secret would be stored in plaintext. Use Env.inherit({ secret: true }) to read it from the worker.`);
+  }
+  if (isSecretLookingEnvName2(name) && !flags.unsafeAllowStatic) {
+    throw new Error(`Env "${name}": a static value on a secret-looking name would be stored in plaintext. Use Env.inherit({ secret: true }) to read it from the worker, or Env.value({ value, unsafeAllowStatic: true }) if it is not actually secret.`);
+  }
+}
+function appliesField(applies) {
+  return applies === "agent" ? {} : { applies };
+}
+function toEnvVarSpec(name, entry) {
+  if (!isHelperEntry(entry)) {
+    const value = `${entry}`;
+    assertNotStaticSecret(name, value, {
+      secret: false,
+      unsafeAllowStatic: false
+    });
+    return { name, source: "value", value, secret: false };
+  }
+  if (entry.kind === "value") {
+    assertNotStaticSecret(name, entry.value, entry);
+    return {
+      name,
+      source: "value",
+      value: entry.value,
+      secret: entry.secret,
+      ...appliesField(entry.applies)
+    };
+  }
+  return {
+    name,
+    source: "inherit",
+    from: entry.from ?? name,
+    secret: entry.secret,
+    optional: entry.optional,
+    ...entry.default !== undefined ? { default: entry.default } : {},
+    ...appliesField(entry.applies)
+  };
+}
+function normalizeEnv2(fn) {
+  if (!fn)
+    return null;
+  const record = fn({ input: createPromptInputProxy2(["input"]) });
+  const specs = Object.entries(record).map(([name, entry]) => toEnvVarSpec(name, entry));
+  return specs.length > 0 ? specs : null;
+}
+
+// src/definitions/steps/repo.ts
+var Repo2 = {
+  none() {
+    return { mode: "none" };
+  },
+  readOnly() {
+    return { mode: "readOnly" };
+  },
+  readWrite(opts) {
+    return { mode: "readWrite", ...opts };
+  }
+};
+function executionModeOf(runtime) {
+  return runtime?.kind === "host" ? "no_workspace" : "workspace";
+}
+function compileRepo2(repo, runtime, ctx = {}) {
+  if (repo === undefined)
+    return;
+  const spec = typeof repo === "function" ? repo({
+    input: createPromptInputProxy2(["input"]),
+    result: createPromptInputProxy2(["result"])
+  }) : repo;
+  const where = ctx.stepKey ? `Step "${ctx.stepKey}" repo` : "repo";
+  const executionMode = executionModeOf(runtime);
+  const mismatch = repoRuntimeMismatch2(executionMode, spec.mode);
+  if (mismatch !== null) {
+    throw new Error(`${where} "${spec.mode}" cannot be used with executionMode "${executionMode}": ${mismatch}.`);
+  }
+  const config = spec.mode === "readWrite" ? toReadWriteConfig(spec) : { mode: spec.mode };
+  const parsed = repoConfigInputSchema2.safeParse(config);
+  if (!parsed.success) {
+    throw new Error(`${where}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "mode"} ${issue.message}`).join("; ")}`);
+  }
+  return config;
+}
+function toReadWriteConfig(spec) {
+  return {
+    mode: "readWrite",
+    ...spec.message !== undefined ? {
+      message: `${spec.message}`
+    } : {},
+    ...spec.onPushFailure !== undefined ? { onPushFailure: spec.onPushFailure } : {}
+  };
+}
+
+// src/definitions/steps/runtime.ts
+var managedRuntimeFactories = Object.fromEntries(MANAGED_RUNTIME_IDS2.map((id) => [id, () => ({ kind: "managed", id })]));
+var Runtime2 = {
+  managed: managedRuntimeFactories,
+  devcontainer(opts) {
+    if (opts?.config === undefined)
+      return { kind: "devcontainer" };
+    const parsed = devcontainerConfigPathSchema2.safeParse(opts.config);
+    if (!parsed.success) {
+      throw new Error(`Runtime.devcontainer config "${opts.config}": ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return { kind: "devcontainer", config: parsed.data };
+  },
+  host() {
+    return { kind: "host" };
+  }
+};
+function assertNoSetupVarsOnHost(envJson, runtime, stepKey) {
+  if (runtime?.kind !== "host")
+    return;
+  const setupVar = (envJson ?? []).find((entry) => (entry.applies ?? "agent") !== "agent");
+  if (!setupVar)
+    return;
+  throw new Error(`${stepKey ? `Step "${stepKey}" ` : ""}env "${setupVar.name}": applies "${String(setupVar.applies)}" needs a container to set up, but Runtime.host() has none. Use applies "agent" or Runtime.devcontainer().`);
+}
+function compileEnvironment2(environment, ctx = {}) {
+  const runtime = environment?.runtime ?? ctx.defaultRuntime;
+  const envJson = normalizeEnv2(environment?.vars);
+  assertNoSetupVarsOnHost(envJson, runtime, ctx.stepKey);
+  return {
+    executionMode: runtime?.kind === "host" ? "no_workspace" : "workspace",
+    devcontainerConfigPath: runtime?.kind === "devcontainer" ? runtime.config ?? null : null,
+    managedRuntime: runtime?.kind === "managed" ? runtime.id : null,
+    envJson,
+    repo: compileRepo2(environment?.repo, runtime, ctx)
+  };
+}
+
+// src/definitions/steps/mcp-server-config.ts
+var ownedFields = { type: true, disabled: true };
+var refFieldsSchema = openCodeMcpRefConfigSchema2.omit({
+  ...ownedFields,
+  name: true
+});
+var localFieldsSchema = openCodeMcpLocalConfigSchema2.omit(ownedFields);
+var remoteFieldsSchema = openCodeMcpRemoteConfigSchema2.omit(ownedFields);
+var commonConfigKeys = new Set([
+  "type",
+  "name",
+  "env",
+  "optionalEnv",
+  "healthChecks"
+]);
+function formatIssues(error) {
+  return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+function parseFields(name, schema, config) {
+  const fields = Object.fromEntries(Object.entries(config).filter(([key]) => !commonConfigKeys.has(key)));
+  const parsed = schema.safeParse(fields);
+  if (!parsed.success) {
+    throw new Error(`defineMcp "${name}": ${formatIssues(parsed.error)}`);
+  }
+  return parsed.data;
+}
+function assertPlaceholders(name, field, values) {
+  for (const [key, value] of Object.entries(values ?? {})) {
+    if (isEnvPlaceholderValue2(value))
+      continue;
+    throw new Error(`defineMcp "${name}": ${field}.${key} must be written as {env:VAR}; a literal ${field} value would be stored in plaintext.`);
+  }
+}
+function inferredMcpEnv(definition) {
+  return definition.type === "ref" ? [] : collectEnvPlaceholderNames2(definition.server);
+}
+function assertInferredEnv(definition) {
+  for (const variable of inferredMcpEnv(definition)) {
+    if (!ENV_VAR_NAME_PATTERN2.test(variable)) {
+      throw new Error(`defineMcp "${definition.name}": {env:${variable}} must name a variable matching ${String(ENV_VAR_NAME_PATTERN2)}.`);
+    }
+    if (isReservedEnvVarName2(variable)) {
+      throw new Error(`defineMcp "${definition.name}": {env:${variable}} reads a variable reserved for Scarn.`);
+    }
+  }
+}
+function parseMcpServer(config) {
+  if (typeof config.name !== "string" || config.name.trim().length === 0) {
+    throw new Error("defineMcp: name must be a non-empty string.");
+  }
+  const { name } = config;
+  let definition;
+  switch (config.type) {
+    case "ref":
+      definition = {
+        type: "ref",
+        name,
+        server: parseFields(name, refFieldsSchema, config)
+      };
+      break;
+    case "local": {
+      const server = parseFields(name, localFieldsSchema, config);
+      assertPlaceholders(name, "environment", server.environment);
+      definition = { type: "local", name, server };
+      break;
+    }
+    case "remote": {
+      const server = parseFields(name, remoteFieldsSchema, config);
+      assertPlaceholders(name, "headers", server.headers);
+      definition = { type: "remote", name, server };
+      break;
+    }
+    default:
+      throw new Error(`defineMcp "${name}": type must be "ref", "local" or "remote".`);
+  }
+  assertInferredEnv(definition);
+  return definition;
+}
+
+// src/definitions/steps/define-mcp.ts
+var mcpCheckInputSchema = toolHealthCheckSchema2.omit({ kind: true, mcp: true, name: true }).extend({ enabled: boolean().optional() }).strict();
+var mcpCheckPatchSchema = toolHealthCheckSchema2.pick({
+  tool: true,
+  args: true,
+  timeoutSeconds: true,
+  severity: true,
+  serialGroup: true
+}).partial().strict();
+var handles = new WeakSet;
+function isMcpHandle2(value) {
+  return typeof value === "object" && value !== null && handles.has(value);
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value))
+      deepFreeze(child);
+  }
+  return value;
+}
+function frozenCopy(value) {
+  return deepFreeze(structuredClone(value));
+}
+function formatIssues2(error) {
+  return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+}
+function assertCheckName(label, name) {
+  if (name.trim().length === 0 || name.includes(".")) {
+    throw new Error(`defineMcp "${label}": health check name "${name}" must be non-empty and contain no ".".`);
+  }
+}
+function assertCheckInput(label, name, check) {
+  assertCheckName(label, name);
+  const parsed = mcpCheckInputSchema.safeParse(check);
+  if (!parsed.success) {
+    throw new Error(`defineMcp "${label}" health check "${name}": ${formatIssues2(parsed.error)}`);
+  }
+}
+function assertEnvNames(label, env, optionalEnv) {
+  const seen = new Set;
+  for (const name of [...env, ...optionalEnv]) {
+    if (!ENV_VAR_NAME_PATTERN2.test(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" must match ${String(ENV_VAR_NAME_PATTERN2)}.`);
+    }
+    if (isReservedEnvVarName2(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" is reserved for Scarn.`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" is declared more than once.`);
+    }
+    seen.add(name);
+  }
+}
+function knownCheckNames(state) {
+  const names = new Set(Object.keys(state.checks));
+  for (const op of state.overrides) {
+    if (op.op === "add")
+      names.add(op.name);
+  }
+  return names;
+}
+function assertKnownCheck(state, method, name) {
+  const known = knownCheckNames(state);
+  if (known.has(name))
+    return;
+  throw new Error(`defineMcp "${state.name}".${method}: unknown health check "${name}". Known checks: ${known.size > 0 ? [...known].join(", ") : "(none)"}.`);
+}
+function withOp(state, op) {
+  return createHandle({
+    ...state,
+    overrides: Object.freeze([...state.overrides, deepFreeze(op)])
+  });
+}
+function createHandle(state) {
+  const handle = {
+    ...state,
+    overrideCheck: (name, patch) => {
+      assertKnownCheck(state, "overrideCheck", name);
+      const parsed = mcpCheckPatchSchema.safeParse(patch);
+      if (!parsed.success) {
+        throw new Error(`defineMcp "${state.name}".overrideCheck("${name}"): ${formatIssues2(parsed.error)}`);
+      }
+      return withOp(state, {
+        op: "override",
+        name,
+        patch: structuredClone(patch)
+      });
+    },
+    disableCheck: (name) => {
+      assertKnownCheck(state, "disableCheck", name);
+      return withOp(state, { op: "disable", name });
+    },
+    enableCheck: (name) => {
+      assertKnownCheck(state, "enableCheck", name);
+      return withOp(state, { op: "enable", name });
+    },
+    addCheck: (name, check) => {
+      assertCheckInput(state.name, name, check);
+      if (knownCheckNames(state).has(name)) {
+        throw new Error(`defineMcp "${state.name}".addCheck: health check "${name}" already exists; use overrideCheck to change it.`);
+      }
+      return withOp(state, { op: "add", name, check: structuredClone(check) });
+    },
+    disableAllChecks: () => withOp(state, { op: "disableAll" })
+  };
+  handles.add(handle);
+  return Object.freeze(handle);
+}
+function defineMcp2(config) {
+  const definition = parseMcpServer(config);
+  const env = config.env ?? [];
+  const optionalEnv = config.optionalEnv ?? [];
+  assertEnvNames(definition.name, env, optionalEnv);
+  const checks = config.healthChecks ?? {};
+  for (const [name, check] of Object.entries(checks)) {
+    assertCheckInput(definition.name, name, check);
+  }
+  return createHandle({
+    ...frozenCopy(definition),
+    env: frozenCopy([...env]),
+    optionalEnv: frozenCopy([...optionalEnv]),
+    checks: frozenCopy({ ...checks }),
+    overrides: Object.freeze([])
+  });
+}
+function resolveMcpChecks2(handle) {
+  const resolved = new Map;
+  for (const [name, check] of Object.entries(handle.checks)) {
+    resolved.set(name, { check: { ...check }, enabled: check.enabled ?? true });
+  }
+  for (const op of handle.overrides) {
+    if (op.op === "add") {
+      resolved.set(op.name, {
+        check: { ...op.check },
+        enabled: op.check.enabled ?? true
+      });
+    } else if (op.op === "disableAll") {
+      for (const entry of resolved.values())
+        entry.enabled = false;
+    } else {
+      const entry = resolved.get(op.name);
+      if (!entry)
+        continue;
+      if (op.op === "override")
+        entry.check = { ...entry.check, ...op.patch };
+      else
+        entry.enabled = op.op === "enable";
+    }
+  }
+  return [...resolved].map(([name, { check, enabled }]) => ({
+    name,
+    check,
+    enabled
+  }));
+}
+
+// src/definitions/steps/compile-mcps.ts
+function compileServer(key, handle) {
+  switch (handle.type) {
+    case "ref":
+      return {
+        type: "ref",
+        ...handle.name !== key ? { name: handle.name } : {},
+        ...structuredClone(handle.server)
+      };
+    case "local":
+      return { type: "local", ...structuredClone(handle.server) };
+    case "remote":
+      return { type: "remote", ...structuredClone(handle.server) };
+  }
+}
+function compileChecks(key, handle) {
+  return resolveMcpChecks2(handle).filter((resolved) => resolved.enabled).map(({ name, check }) => ({
+    kind: "tool",
+    mcp: key,
+    name: `${key}.${name}`,
+    tool: check.tool,
+    ...check.args !== undefined ? { args: check.args } : {},
+    ...check.timeoutSeconds !== undefined ? { timeoutSeconds: check.timeoutSeconds } : {},
+    serialGroup: check.serialGroup ?? key,
+    severity: check.severity ?? "required"
+  }));
+}
+function compileEnv(key, handle) {
+  const entry = (name, optional) => ({
+    source: "inherit",
+    name,
+    from: name,
+    secret: true,
+    optional,
+    mcp: key,
+    applies: "agent"
+  });
+  const listed = new Set([...handle.env, ...handle.optionalEnv]);
+  const inferred = inferredMcpEnv(handle).filter((name) => !listed.has(name));
+  return [
+    ...handle.env.map((name) => entry(name, false)),
+    ...inferred.map((name) => entry(name, false)),
+    ...handle.optionalEnv.map((name) => entry(name, true))
+  ];
+}
+function dedupeEnv(entries) {
+  const byName = new Map;
+  for (const entry of entries) {
+    const existing = byName.get(entry.name);
+    if (!existing) {
+      byName.set(entry.name, entry);
+      continue;
+    }
+    byName.set(entry.name, {
+      source: "inherit",
+      name: entry.name,
+      from: entry.from,
+      secret: true,
+      optional: existing.optional && entry.optional,
+      applies: "agent"
+    });
+  }
+  return [...byName.values()];
+}
+function compileMcps2(mcps, stepKey) {
+  const compiled = {
+    opencodeMcpJson: {},
+    healthChecks: [],
+    envEntries: []
+  };
+  for (const [key, handle] of Object.entries(mcps)) {
+    if (!isMcpHandle2(handle)) {
+      throw new Error(`Step "${stepKey}" mcps.${key}: expected a handle from defineMcp().`);
+    }
+    compiled.opencodeMcpJson[key] = compileServer(key, handle);
+    compiled.healthChecks.push(...compileChecks(key, handle));
+    compiled.envEntries.push(...compileEnv(key, handle));
+  }
+  compiled.envEntries = dedupeEnv(compiled.envEntries);
+  return compiled;
+}
+function nonEmpty(items) {
+  return items.length > 0 ? items : null;
+}
+function mergeStepMcps(stepKey, input) {
+  if (!input.mcps || Object.keys(input.mcps).length === 0) {
+    return {
+      opencodeMcpJson: null,
+      healthChecksJson: input.healthChecks ?? null,
+      envJson: input.envJson
+    };
+  }
+  const compiled = compileMcps2(input.mcps, stepKey);
+  const stepVars = input.envJson ?? [];
+  const stepVarNames = new Set(stepVars.map((entry) => entry.name));
+  return {
+    opencodeMcpJson: compiled.opencodeMcpJson,
+    healthChecksJson: nonEmpty([
+      ...compiled.healthChecks,
+      ...input.healthChecks ?? []
+    ]),
+    envJson: nonEmpty([
+      ...compiled.envEntries.filter((entry) => !stepVarNames.has(entry.name)),
+      ...stepVars
+    ])
+  };
+}
+
+// src/definitions/steps/step-handle.ts
+function compileStepErrors2(stepKey, errors) {
+  const names = [...errors ?? []];
+  const seen = new Set;
+  for (const name of names) {
+    if (name.trim() === "") {
+      throw new Error(`Step "${stepKey}": error names must not be empty.`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`Step "${stepKey}": error "${name}" is declared more than once.`);
+    }
+    seen.add(name);
+  }
+  return names;
+}
+function compileStepRetry2(stepKey, retry, errors) {
+  const known = new Set([...BUILT_IN_ERRORS2, ...errors]);
+  return (retry ?? []).map((entry) => {
+    if (entry.on.length === 0) {
+      throw new Error(`Step "${stepKey}": each retry must name an error.`);
+    }
+    const unknown = entry.on.find((name) => !known.has(name));
+    if (unknown !== undefined) {
+      throw new Error(`Step "${stepKey}": retry names "${unknown}", which is neither a built-in error nor one the step declares.`);
+    }
+    if (!Number.isInteger(entry.maxAttempts) || entry.maxAttempts <= 0) {
+      throw new Error(`Step "${stepKey}": retry maxAttempts must be a positive integer.`);
+    }
+    return { on: [...entry.on], maxAttempts: entry.maxAttempts };
+  });
+}
+function toStepHandle2(spec) {
+  const node = stepNode(spec);
+  const call = stepCall(node);
+  const { name, ...rest } = spec;
+  Object.defineProperty(call, "name", {
+    value: name,
+    enumerable: true
+  });
+  Object.assign(call, rest);
+  return makeHandle(call, node);
+}
+function toStepSpec2(step) {
+  return { ...step };
+}
+
+// src/definitions/steps/define-step.ts
+function assertStepMcpInput(config) {
+  if ("mcpServers" in config) {
+    throw new Error(`Step "${config.key}": mcpServers is not supported. Declare each MCP server with defineMcp({ type: "ref" | "local" | "remote", ... }) and list it under mcps.`);
+  }
+  if (config.healthChecks == null)
+    return;
+  const parsed = stepHealthChecksInputSchema2.safeParse(config.healthChecks);
+  if (parsed.success)
+    return;
+  const issues = parsed.error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.map(String).join(".")}: ${issue.message}` : issue.message).join("; ");
+  throw new Error(`Step "${config.key}" healthChecks: ${issues}. MCP health checks are declared on the server with defineMcp({ healthChecks }).`);
+}
+function defineStep2(config) {
+  const features = config.features ?? [];
+  let effectiveResult = config.result;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const basePrompt = typeof config.agentPrompt === "function" ? config.agentPrompt(createPromptTemplateContext2()) : config.agentPrompt;
+  let effectivePrompt = basePrompt;
+  for (const feature of features) {
+    if (feature._promptAddition) {
+      effectivePrompt = effectivePrompt ? `${effectivePrompt}
+
+${feature._promptAddition}` : feature._promptAddition;
+    }
+  }
+  const {
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    envJson,
+    repo
+  } = compileEnvironment2(config.environment, { stepKey: config.key });
+  assertStepMcpInput(config);
+  const mcpFields = mergeStepMcps(config.key, {
+    mcps: config.mcps,
+    healthChecks: config.healthChecks,
+    envJson
+  });
+  const resultSchemaJson = effectiveResult ? toJSONSchema(effectiveResult) : null;
+  const spec = {
+    key: config.key,
+    name: config.name,
+    description: config.description ?? null,
+    version: config.version ?? 1,
+    kind: "user_defined",
+    status: config.status ?? "active",
+    executionMode,
+    devcontainerConfigPath,
+    ...managedRuntime !== null ? { managedRuntime } : {},
+    prompt: effectivePrompt,
+    inputSchemaJson: config.additionalInput ? toJSONSchema(config.additionalInput) : null,
+    resultSchemaJson,
+    opencodeMcpJson: mcpFields.opencodeMcpJson,
+    healthChecksJson: mcpFields.healthChecksJson,
+    envJson: mcpFields.envJson,
+    ...repo !== undefined ? { repo } : {},
+    errors: compileStepErrors2(config.key, config.errors),
+    retryJson: compileStepRetry2(config.key, config.retry, config.errors ?? [])
+  };
+  return toStepHandle2(spec);
+}
+// src/definitions/steps/define-code-step.ts
+function codeStep2(config) {
+  const features = config.features ?? [];
+  let effectiveResult = config.resultSchema;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const {
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    envJson,
+    repo
+  } = compileEnvironment2(config.environment, {
+    stepKey: config.key,
+    defaultRuntime: Runtime2.managed[DEFAULT_CODE_STEP_RUNTIME_ID2]()
+  });
+  const spec = {
+    key: config.key,
+    name: config.name,
+    description: config.description ?? null,
+    version: config.version ?? 1,
+    kind: "code",
+    status: config.status ?? "active",
+    executionMode,
+    devcontainerConfigPath,
+    managedRuntime,
+    prompt: null,
+    inputSchemaJson: config.inputSchema ? toJSONSchema(config.inputSchema) : null,
+    resultSchemaJson: effectiveResult ? toJSONSchema(effectiveResult) : null,
+    opencodeMcpJson: null,
+    healthChecksJson: null,
+    envJson,
+    ...repo !== undefined ? { repo } : {},
+    errors: compileStepErrors2(config.key, config.errors),
+    retryJson: compileStepRetry2(config.key, config.retry, config.errors ?? []),
+    entrypoint: { fn: config.fn }
+  };
+  return toStepHandle2(spec);
+}
+// src/definitions/steps/step-definitions-client.ts
+var ANY_OBJECT_SCHEMA = { type: "object" };
+function createStepDefinitionsClient2(baseUrl) {
+  const client = createClient({ baseUrl });
+  return buildStepDefinitionsClient(new StepDefinitions2({ client }));
+}
+var buildStepDefinitionsClient = (stepDefinitions) => {
+  return {
+    listByProjectId: async (projectId, options) => {
+      const result = await stepDefinitions.listStepDefinitions({
+        query: { projectId },
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    create: async (body, options) => {
+      const result = await stepDefinitions.createStepDefinition({
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    upsertFromSpec: async (projectId, step, options) => {
+      const spec = toStepSpec2(step);
+      const body = {
+        key: spec.key,
+        name: spec.name,
+        description: spec.description,
+        prompt: spec.prompt ?? null,
+        version: spec.version,
+        kind: spec.kind,
+        entrypointJson: spec.entrypointJson ?? null,
+        executionMode: spec.executionMode,
+        devcontainerConfigPath: spec.devcontainerConfigPath,
+        managedRuntime: spec.managedRuntime,
+        repo: spec.repo,
+        inputSchemaJson: spec.inputSchemaJson ?? ANY_OBJECT_SCHEMA,
+        resultSchemaJson: spec.kind === "code" ? spec.resultSchemaJson ?? ANY_OBJECT_SCHEMA : spec.resultSchemaJson,
+        opencodeMcpJson: spec.opencodeMcpJson,
+        healthChecksJson: spec.healthChecksJson,
+        envJson: spec.envJson,
+        errors: [...spec.errors ?? []],
+        retry: (spec.retryJson ?? []).map((entry) => ({
+          on: [...entry.on],
+          maxAttempts: entry.maxAttempts
+        })),
+        status: spec.status,
+        projectId
+      };
+      const result = await stepDefinitions.upsertStepDefinition({
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    }
+  };
+};
+// src/definitions/steps/step-features.ts
+var notificationKindSchema = _enum([
+  "feedback_request",
+  "status_update",
+  "blocked",
+  "result_ready",
+  "warning"
+]);
+var notificationPrioritySchema = _enum(["low", "normal", "high", "urgent"]);
+var notificationChannelSchema = _enum([
+  "in_app",
+  "work_item_platform_comment",
+  "email",
+  "slack"
+]);
+var NOTIFICATION_RESULT_KEY = "$scarn_notifications_v1";
+var DEFAULT_NOTIFICATION_KIND = "status_update";
+var notificationItemSchema = object({
+  kind: notificationKindSchema.describe("The kind of user notification."),
+  title: string().optional().describe("Short, human-readable notification title."),
+  body: string().describe("The notification body / details."),
+  priority: notificationPrioritySchema.describe("How important this notification is for the user."),
+  suggestedChannels: array(notificationChannelSchema).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
+  payload: record(string(), unknown()).optional().describe('Kind-specific structured data. For "feedback_request": { category, urgency }.')
+}).describe("A single user notification emitted by the agent.");
+var notificationsFeature = {
+  _resultExtension: object({
+    [NOTIFICATION_RESULT_KEY]: array(notificationItemSchema).optional()
+  }),
+  _promptAddition: [
+    "## User Notifications",
+    "",
+    `If you need to communicate something to a human, populate the \`${NOTIFICATION_RESULT_KEY}\` array.`,
+    "Each item must include:",
+    "- **kind**: One of `feedback_request`, `status_update`, `blocked`, `result_ready`, `warning`.",
+    "- **title**: A short, human-readable title.",
+    "- **body**: The details of the notification.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **suggestedChannels** *(optional)*: Channels you think are worth using (e.g. `["in_app", "work_item_platform_comment"]`).',
+    "  You only *suggest* channels \u2014 the platform policy decides the final delivery channels.",
+    "  Suggesting `work_item_platform_comment` does NOT post anything directly: it always requires a human to review the exact text and explicitly approve it before it's posted to the work item's originating platform issue (e.g. GitHub) \u2014 it becomes a pending draft on that comment thread, not an immediate post.",
+    '- **payload** *(optional)*: Kind-specific data. For `feedback_request`, include `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational" }`.',
+    "",
+    "### Artifacts in comments",
+    "",
+    "A `work_item_platform_comment` body can show or link files this pipeline run produced, using artifact markers:",
+    "- `![caption](artifact:signal/<stepKey>/<resultPath>)` embeds the artifact field at `<resultPath>` in that step's result where the platform can show it, and links to it otherwise. `[label](artifact:signal/<stepKey>/<resultPath>)` links to it. If that artifact is unavailable, the comment is not drafted.",
+    "- `![caption](artifact:<name-or-glob>)` and `[label](artifact:<name-or-glob>)` do the same for any file under the artifacts folder, e.g. `artifact:screenshots/*.png`. If nothing matches, the marker's paragraph is left out.",
+    "Rules:",
+    "- One marker per paragraph: put each marker on its own line, with a blank line before and after. A marker inside a sentence is only linked.",
+    `- Don't refer to an artifact outside its marker (no "see the video below"). Put any description in the caption or label, so the comment still reads correctly if the marker is left out.`
+  ].join(`
+`)
+};
+var feedbackRequestsFeature = {
+  _resultExtension: object({
+    [NOTIFICATION_RESULT_KEY]: array(notificationItemSchema.extend({ kind: literal("feedback_request") })).optional()
+  }),
+  _promptAddition: [
+    "## Feedback Requests",
+    "",
+    `If you need to ask a human a clarifying question, populate the \`${NOTIFICATION_RESULT_KEY}\` array with items of kind \`"feedback_request"\`.`,
+    "Each item must include:",
+    "- **title**: A short, human-readable summary of the question.",
+    "- **body**: The full question.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **payload**: `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational" }`.'
+  ].join(`
+`)
+};
+var Features2 = {
+  notifications: () => notificationsFeature,
+  feedbackRequests: () => feedbackRequestsFeature
+};
+var Notify2 = {
+  create: (item) => ({
+    [NOTIFICATION_RESULT_KEY]: [item]
+  }),
+  inApp: (title, body, priority, options) => Notify2.create({
+    kind: options?.kind ?? DEFAULT_NOTIFICATION_KIND,
+    title,
+    body,
+    priority,
+    suggestedChannels: ["in_app"],
+    ...options?.payload ? { payload: options.payload } : {}
+  }),
+  feedbackRequest: (question, category, urgency) => Notify2.create({
+    kind: "feedback_request",
+    title: question,
+    body: question,
+    priority: "normal",
+    payload: { category, urgency }
+  }),
+  merge: (...fragments) => ({
+    [NOTIFICATION_RESULT_KEY]: fragments.flatMap((fragment) => fragment[NOTIFICATION_RESULT_KEY])
+  })
+};
+export { ARTIFACT_BRAND2, ArtifactTypes2, normalizeArtifactAccept2, artifact2, Artifact2, exports_z, createPromptInputProxy2, createPromptTemplateContext2, renderPromptTemplate2, isSecretLookingEnvName2, Env2, normalizeEnv2, Repo2, compileRepo2, Runtime2, compileEnvironment2, isMcpHandle2, defineMcp2, resolveMcpChecks2, compileMcps2, compileStepErrors2, compileStepRetry2, toStepHandle2, toStepSpec2, defineStep2, codeStep2, createStepDefinitionsClient2, Features2, Notify2 };