@scarn/sdk 0.0.0 → 0.8.0

package/dist/{chunk-91p9vzcs.js → chunk-3ctaaseb.js}

@@ -1,290 +1,292 @@
 // @bun
 import {
-  ARTIFACT_SCHEMA_KEYWORD2
-} from "./chunk-56e4kp0a.js";
+  makeHandle,
+  stepCall,
+  stepNode
+} from "./chunk-mz53r914.js";
 import {
-  buildArtifactMarker2
-} from "./chunk-631ffb6r.js";
+  ENV_VAR_NAME_PATTERN,
+  containsInputToken,
+  isReservedEnvVarName
+} from "./chunk-5zsavw98.js";
 import {
-  toolHealthCheckSchema2,
-  stepHealthChecksInputSchema2
-} from "./chunk-zpqyjgb4.js";
+  devcontainerConfigPathSchema
+} from "./chunk-4ggr8af6.js";
 import {
-  devcontainerConfigPathSchema2
-} from "./chunk-9s07v9r1.js";
+  DEFAULT_CODE_STEP_RUNTIME_ID,
+  MANAGED_RUNTIME_IDS
+} from "./chunk-k4y5qt4y.js";
 import {
-  MANAGED_RUNTIME_IDS2,
-  DEFAULT_CODE_STEP_RUNTIME_ID2
-} from "./chunk-s0gap8r8.js";
+  repoConfigInputSchema,
+  repoRuntimeMismatch
+} from "./chunk-cdanncng.js";
 import {
-  ENV_VAR_NAME_PATTERN2,
-  containsInputToken2,
-  isReservedEnvVarName2
-} from "./chunk-p6kc9wq8.js";
+  collectEnvPlaceholderNames,
+  isEnvPlaceholderValue,
+  openCodeMcpLocalConfigSchema,
+  openCodeMcpRefConfigSchema,
+  openCodeMcpRemoteConfigSchema
+} from "./chunk-e1h021kq.js";
 import {
-  repoConfigInputSchema2,
-  repoRuntimeMismatch2
-} from "./chunk-b21233rt.js";
+  stepHealthChecksInputSchema,
+  toolHealthCheckSchema
+} from "./chunk-63f90zky.js";
 import {
-  openCodeMcpLocalConfigSchema2,
-  openCodeMcpRemoteConfigSchema2,
-  openCodeMcpRefConfigSchema2,
-  isEnvPlaceholderValue2,
-  collectEnvPlaceholderNames2
-} from "./chunk-g0rdnn0r.js";
+  buildArtifactMarker
+} from "./chunk-ngy1fdcx.js";
 import {
-  makeHandle,
-  stepNode,
-  stepCall
-} from "./chunk-eg1hcvhb.js";
+  ARTIFACT_SCHEMA_KEYWORD
+} from "./chunk-y2pv8d6a.js";
 import {
-  createClient,
-  StepDefinitions2
-} from "./chunk-ynk2bjae.js";
+  BUILT_IN_ERRORS
+} from "./chunk-dp86pa6m.js";
 import {
-  ZodIssueCode,
-  setErrorMap,
-  getErrorMap,
-  ZodFirstPartyTypeKind,
-  fromJSONSchema,
-  exports_coerce,
-  exports_external,
-  BUILT_IN_ERRORS2
-} from "./chunk-5mmj03ah.js";
+  StepDefinitions,
+  createClient
+} from "./chunk-vfeytkqx.js";
 import {
-  __export,
-  NEVER,
   $brand,
-  config,
-  clone,
-  exports_util,
-  flattenError,
-  formatError,
-  treeifyError,
-  prettifyError,
-  exports_regexes,
-  exports_locales,
-  $output,
   $input,
-  registry,
-  globalRegistry,
+  $output,
+  NEVER,
   TimePrecision,
-  _lt,
-  _lte,
+  ZodAny,
+  ZodArray,
+  ZodBase64,
+  ZodBase64URL,
+  ZodBigInt,
+  ZodBigIntFormat,
+  ZodBoolean,
+  ZodCIDRv4,
+  ZodCIDRv6,
+  ZodCUID,
+  ZodCUID2,
+  ZodCatch,
+  ZodCodec,
+  ZodCustom,
+  ZodCustomStringFormat,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodE164,
+  ZodEmail,
+  ZodEmoji,
+  ZodEnum,
+  ZodError,
+  ZodExactOptional,
+  ZodFile,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodGUID,
+  ZodIPv4,
+  ZodIPv6,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodJWT,
+  ZodKSUID,
+  ZodLazy,
+  ZodLiteral,
+  ZodMAC,
+  ZodMap,
+  ZodNaN,
+  ZodNanoID,
+  ZodNever,
+  ZodNonOptional,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodNumberFormat,
+  ZodObject,
+  ZodOptional,
+  ZodPipe,
+  ZodPrefault,
+  ZodPreprocess,
+  ZodPromise,
+  ZodReadonly,
+  ZodRealError,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodStringFormat,
+  ZodSuccess,
+  ZodSymbol,
+  ZodTemplateLiteral,
+  ZodTransform,
+  ZodTuple,
+  ZodType,
+  ZodULID,
+  ZodURL,
+  ZodUUID,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  ZodXID,
+  ZodXor,
+  _ZodString,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
   _gt,
   _gte,
-  _positive,
-  _negative,
-  _nonpositive,
-  _nonnegative,
-  _multipleOf,
-  _maxSize,
-  _minSize,
-  _size,
-  _maxLength,
-  _minLength,
+  _includes,
+  _instanceof,
   _length,
-  _regex,
   _lowercase,
-  _uppercase,
-  _includes,
-  _startsWith,
-  _endsWith,
-  _property,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
   _mime,
-  _overwrite,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
   _normalize,
-  _trim,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _slugify,
+  _startsWith,
   _toLowerCase,
   _toUpperCase,
-  _slugify,
-  toJSONSchema,
-  exports_core,
-  ZodISODateTime,
-  ZodISODate,
-  ZodISOTime,
-  ZodISODuration,
-  exports_iso,
-  ZodError,
-  ZodRealError,
-  parse,
-  parseAsync,
-  safeParse,
-  safeParseAsync,
-  encode,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  codec,
+  config,
+  cuid,
+  cuid2,
+  custom,
+  date,
   decode,
-  encodeAsync,
   decodeAsync,
-  safeEncode,
-  safeDecode,
-  safeEncodeAsync,
-  safeDecodeAsync,
-  ZodType,
-  _ZodString,
-  ZodString,
-  string,
-  ZodStringFormat,
-  ZodEmail,
+  describe,
+  discriminatedUnion,
+  e164,
   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,
+  encode,
+  encodeAsync,
+  exactOptional,
+  exports_coerce,
+  exports_core,
+  exports_external,
+  exports_iso,
+  exports_locales,
+  exports_regexes,
+  exports_util,
+  file,
+  flattenError,
   float32,
   float64,
+  formatError,
+  fromJSONSchema,
+  getErrorMap,
+  globalRegistry,
+  guid,
+  hash,
+  hex,
+  hostname,
+  httpUrl,
+  int,
   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,
+  intersection,
+  invertCodec,
+  ipv4,
+  ipv6,
+  json,
+  jwt,
   keyof,
-  ZodObject,
-  object,
-  strictObject,
+  ksuid,
+  lazy,
+  literal,
   looseObject,
-  ZodUnion,
-  union,
-  ZodXor,
-  xor,
-  ZodDiscriminatedUnion,
-  discriminatedUnion,
-  ZodIntersection,
-  intersection,
-  ZodTuple,
-  tuple,
-  ZodRecord,
-  record,
-  partialRecord,
   looseRecord,
-  ZodMap,
+  mac,
   map,
-  ZodSet,
-  set,
-  ZodEnum,
-  _enum,
+  meta,
+  nan,
+  nanoid,
   nativeEnum,
-  ZodLiteral,
-  literal,
-  ZodFile,
-  file,
-  ZodTransform,
-  transform,
-  ZodOptional,
-  optional,
-  ZodExactOptional,
-  exactOptional,
-  ZodNullable,
+  never,
+  nonoptional,
   nullable,
   nullish,
-  ZodDefault,
-  _default,
-  ZodPrefault,
-  prefault,
-  ZodNonOptional,
-  nonoptional,
-  ZodSuccess,
-  success,
-  ZodCatch,
-  _catch,
-  ZodNaN,
-  nan,
-  ZodPipe,
+  number,
+  object,
+  optional,
+  parse,
+  parseAsync,
+  partialRecord,
   pipe,
-  ZodCodec,
-  codec,
-  invertCodec,
-  ZodPreprocess,
-  ZodReadonly,
-  readonly,
-  ZodTemplateLiteral,
-  templateLiteral,
-  ZodLazy,
-  lazy,
-  ZodPromise,
+  prefault,
+  preprocess,
+  prettifyError,
   promise,
-  ZodFunction,
-  _function,
-  ZodCustom,
-  check,
-  custom,
+  readonly,
+  record,
   refine,
-  superRefine,
-  describe,
-  meta,
-  _instanceof,
+  registry,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeParse,
+  safeParseAsync,
+  set,
+  setErrorMap,
+  strictObject,
+  string,
+  stringFormat,
   stringbool,
-  json,
-  preprocess
-} from "./chunk-dnn39qt4.js";
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  xid,
+  xor
+} from "./chunk-skzxcba3.js";
+import {
+  __export
+} from "./chunk-y64skrwp.js";
 
 // src/z.ts
 var exports_z = {};
@@ -374,9 +376,9 @@ __export(exports_z, {
   _ZodString: () => _ZodString,
   _default: () => _default,
   _function: () => _function,
-  any: () => any3,
+  any: () => any,
   array: () => array,
-  artifact: () => artifact2,
+  artifact: () => artifact,
   base64: () => base64,
   base64url: () => base64url,
   bigint: () => bigint,
@@ -530,9 +532,10 @@ __export(exports_z, {
   xor: () => xor,
   z: () => exports_external
 });
+
 // src/definitions/artifacts/artifact.ts
-var ARTIFACT_BRAND2 = "ScarnArtifact";
-var ArtifactTypes2 = {
+var ARTIFACT_BRAND = "ScarnArtifact";
+var ArtifactTypes = {
   video: [".mp4", ".webm", ".mov"],
   image: [".png", ".jpg", ".jpeg", ".gif", ".svg"]
 };
@@ -541,7 +544,7 @@ function describeEntry(entry) {
   const cleaned = entry.trim().toLowerCase().replace(/^\*?\.?/, "");
   return cleaned && EXTENSION_PATTERN.test(`.${cleaned}`) ? ` Did you mean \`.${cleaned}\`?` : "";
 }
-function normalizeArtifactAccept2(accept) {
+function normalizeArtifactAccept(accept) {
   if (accept === undefined)
     return [];
   const problems = [];
@@ -571,30 +574,30 @@ function normalizeArtifactAccept2(accept) {
   }
   return out;
 }
-function artifact2(options = {}) {
+function artifact(options = {}) {
   const keyword = {
-    accept: normalizeArtifactAccept2(options.accept)
+    accept: normalizeArtifactAccept(options.accept)
   };
-  return string().brand().meta({ [ARTIFACT_SCHEMA_KEYWORD2]: keyword });
+  return exports_external.string().brand().meta({ [ARTIFACT_SCHEMA_KEYWORD]: keyword });
 }
 var toMarkerRef = (target) => typeof target === "string" ? { type: "path", pattern: target } : {
   type: "signal",
   stepKey: target.step.key,
   signalKey: target.path
 };
-var Artifact2 = {
+var Artifact = {
   path(relativePath) {
     return relativePath;
   },
   embed(target, options) {
-    return buildArtifactMarker2("embed", toMarkerRef(target), options.caption);
+    return buildArtifactMarker("embed", toMarkerRef(target), options.caption);
   },
   link(target, options) {
-    return buildArtifactMarker2("link", toMarkerRef(target), options.label);
+    return buildArtifactMarker("link", toMarkerRef(target), options.label);
   }
 };
 // src/definitions/steps/prompt-template.ts
-function createPromptInputProxy2(path = []) {
+function createPromptInputProxy(path = []) {
   const token = () => path.length ? `{{${path.join(".")}}}` : "";
   return new Proxy(Object.freeze({}), {
     get(_, key) {
@@ -606,23 +609,23 @@ function createPromptInputProxy2(path = []) {
       }
       if (typeof key !== "string")
         return;
-      return createPromptInputProxy2([...path, key]);
+      return createPromptInputProxy([...path, key]);
     }
   });
 }
-function createPromptTemplateContext2() {
+function createPromptTemplateContext() {
   return {
-    input: createPromptInputProxy2(["input"]),
-    env: createPromptInputProxy2(["env"]),
+    input: createPromptInputProxy(["input"]),
+    env: createPromptInputProxy(["env"]),
     scarn: {
-      artifactsDir: createPromptInputProxy2([
+      artifactsDir: createPromptInputProxy([
         "scarn",
         "artifactsDir"
       ])
     }
   };
 }
-function renderPromptTemplate2(template, contextJson) {
+function renderPromptTemplate(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) : "";
@@ -631,7 +634,7 @@ function renderPromptTemplate2(template, contextJson) {
 
 // src/definitions/steps/env.ts
 var SECRET_LOOKING_NAME = /SECRET|TOKEN|PASSWORD|PASSWD|API_?KEY|PRIVATE/i;
-function isSecretLookingEnvName2(name) {
+function isSecretLookingEnvName(name) {
   return SECRET_LOOKING_NAME.test(name);
 }
 var helperEntries = new WeakSet;
@@ -639,7 +642,7 @@ function brand(entry) {
   helperEntries.add(entry);
   return entry;
 }
-var Env2 = {
+var Env = {
   value(opts) {
     return brand({
       kind: "value",
@@ -664,12 +667,12 @@ function isHelperEntry(entry) {
   return typeof entry === "object" && helperEntries.has(entry);
 }
 function assertNotStaticSecret(name, value, flags) {
-  if (containsInputToken2(value))
+  if (containsInputToken(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) {
+  if (isSecretLookingEnvName(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.`);
   }
 }
@@ -705,16 +708,16 @@ function toEnvVarSpec(name, entry) {
     ...appliesField(entry.applies)
   };
 }
-function normalizeEnv2(fn) {
+function normalizeEnv(fn) {
   if (!fn)
     return null;
-  const record = fn({ input: createPromptInputProxy2(["input"]) });
-  const specs = Object.entries(record).map(([name, entry]) => toEnvVarSpec(name, entry));
+  const record2 = fn({ input: createPromptInputProxy(["input"]) });
+  const specs = Object.entries(record2).map(([name, entry]) => toEnvVarSpec(name, entry));
   return specs.length > 0 ? specs : null;
 }
 
 // src/definitions/steps/repo.ts
-var Repo2 = {
+var Repo = {
   none() {
     return { mode: "none" };
   },
@@ -728,25 +731,25 @@ var Repo2 = {
 function executionModeOf(runtime) {
   return runtime?.kind === "host" ? "no_workspace" : "workspace";
 }
-function compileRepo2(repo, runtime, ctx = {}) {
+function compileRepo(repo, runtime, ctx = {}) {
   if (repo === undefined)
     return;
   const spec = typeof repo === "function" ? repo({
-    input: createPromptInputProxy2(["input"]),
-    result: createPromptInputProxy2(["result"])
+    input: createPromptInputProxy(["input"]),
+    result: createPromptInputProxy(["result"])
   }) : repo;
   const where = ctx.stepKey ? `Step "${ctx.stepKey}" repo` : "repo";
   const executionMode = executionModeOf(runtime);
-  const mismatch = repoRuntimeMismatch2(executionMode, spec.mode);
+  const mismatch = repoRuntimeMismatch(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);
+  const config2 = spec.mode === "readWrite" ? toReadWriteConfig(spec) : { mode: spec.mode };
+  const parsed = repoConfigInputSchema.safeParse(config2);
   if (!parsed.success) {
     throw new Error(`${where}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "mode"} ${issue.message}`).join("; ")}`);
   }
-  return config;
+  return config2;
 }
 function toReadWriteConfig(spec) {
   return {
@@ -759,13 +762,13 @@ function toReadWriteConfig(spec) {
 }
 
 // src/definitions/steps/runtime.ts
-var managedRuntimeFactories = Object.fromEntries(MANAGED_RUNTIME_IDS2.map((id) => [id, () => ({ kind: "managed", id })]));
-var Runtime2 = {
+var managedRuntimeFactories = Object.fromEntries(MANAGED_RUNTIME_IDS.map((id) => [id, () => ({ kind: "managed", id })]));
+var Runtime = {
   managed: managedRuntimeFactories,
   devcontainer(opts) {
     if (opts?.config === undefined)
       return { kind: "devcontainer" };
-    const parsed = devcontainerConfigPathSchema2.safeParse(opts.config);
+    const parsed = devcontainerConfigPathSchema.safeParse(opts.config);
     if (!parsed.success) {
       throw new Error(`Runtime.devcontainer config "${opts.config}": ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
     }
@@ -783,27 +786,27 @@ function assertNoSetupVarsOnHost(envJson, runtime, stepKey) {
     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 = {}) {
+function compileEnvironment(environment, ctx = {}) {
   const runtime = environment?.runtime ?? ctx.defaultRuntime;
-  const envJson = normalizeEnv2(environment?.vars);
+  const envJson = normalizeEnv(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)
+    repo: compileRepo(environment?.repo, runtime, ctx)
   };
 }
 
 // src/definitions/steps/mcp-server-config.ts
 var ownedFields = { type: true, disabled: true };
-var refFieldsSchema = openCodeMcpRefConfigSchema2.omit({
+var refFieldsSchema = openCodeMcpRefConfigSchema.omit({
   ...ownedFields,
   name: true
 });
-var localFieldsSchema = openCodeMcpLocalConfigSchema2.omit(ownedFields);
-var remoteFieldsSchema = openCodeMcpRemoteConfigSchema2.omit(ownedFields);
+var localFieldsSchema = openCodeMcpLocalConfigSchema.omit(ownedFields);
+var remoteFieldsSchema = openCodeMcpRemoteConfigSchema.omit(ownedFields);
 var commonConfigKeys = new Set([
   "type",
   "name",
@@ -814,8 +817,8 @@ var commonConfigKeys = new Set([
 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)));
+function parseFields(name, schema, config2) {
+  const fields = Object.fromEntries(Object.entries(config2).filter(([key]) => !commonConfigKeys.has(key)));
   const parsed = schema.safeParse(fields);
   if (!parsed.success) {
     throw new Error(`defineMcp "${name}": ${formatIssues(parsed.error)}`);
@@ -824,46 +827,46 @@ function parseFields(name, schema, config) {
 }
 function assertPlaceholders(name, field, values) {
   for (const [key, value] of Object.entries(values ?? {})) {
-    if (isEnvPlaceholderValue2(value))
+    if (isEnvPlaceholderValue(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);
+  return definition.type === "ref" ? [] : collectEnvPlaceholderNames(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 (!ENV_VAR_NAME_PATTERN.test(variable)) {
+      throw new Error(`defineMcp "${definition.name}": {env:${variable}} must name a variable matching ${String(ENV_VAR_NAME_PATTERN)}.`);
     }
-    if (isReservedEnvVarName2(variable)) {
+    if (isReservedEnvVarName(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) {
+function parseMcpServer(config2) {
+  if (typeof config2.name !== "string" || config2.name.trim().length === 0) {
     throw new Error("defineMcp: name must be a non-empty string.");
   }
-  const { name } = config;
+  const { name } = config2;
   let definition;
-  switch (config.type) {
+  switch (config2.type) {
     case "ref":
       definition = {
         type: "ref",
         name,
-        server: parseFields(name, refFieldsSchema, config)
+        server: parseFields(name, refFieldsSchema, config2)
       };
       break;
     case "local": {
-      const server = parseFields(name, localFieldsSchema, config);
+      const server = parseFields(name, localFieldsSchema, config2);
       assertPlaceholders(name, "environment", server.environment);
       definition = { type: "local", name, server };
       break;
     }
     case "remote": {
-      const server = parseFields(name, remoteFieldsSchema, config);
+      const server = parseFields(name, remoteFieldsSchema, config2);
       assertPlaceholders(name, "headers", server.headers);
       definition = { type: "remote", name, server };
       break;
@@ -876,8 +879,8 @@ function parseMcpServer(config) {
 }
 
 // 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({
+var mcpCheckInputSchema = toolHealthCheckSchema.omit({ kind: true, mcp: true, name: true }).extend({ enabled: exports_external.boolean().optional() }).strict();
+var mcpCheckPatchSchema = toolHealthCheckSchema.pick({
   tool: true,
   args: true,
   timeoutSeconds: true,
@@ -885,7 +888,7 @@ var mcpCheckPatchSchema = toolHealthCheckSchema2.pick({
   serialGroup: true
 }).partial().strict();
 var handles = new WeakSet;
-function isMcpHandle2(value) {
+function isMcpHandle(value) {
   return typeof value === "object" && value !== null && handles.has(value);
 }
 function deepFreeze(value) {
@@ -907,9 +910,9 @@ function assertCheckName(label, name) {
     throw new Error(`defineMcp "${label}": health check name "${name}" must be non-empty and contain no ".".`);
   }
 }
-function assertCheckInput(label, name, check) {
+function assertCheckInput(label, name, check2) {
   assertCheckName(label, name);
-  const parsed = mcpCheckInputSchema.safeParse(check);
+  const parsed = mcpCheckInputSchema.safeParse(check2);
   if (!parsed.success) {
     throw new Error(`defineMcp "${label}" health check "${name}": ${formatIssues2(parsed.error)}`);
   }
@@ -917,10 +920,10 @@ function assertCheckInput(label, name, check) {
 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 (!ENV_VAR_NAME_PATTERN.test(name)) {
+      throw new Error(`defineMcp "${label}": env var "${name}" must match ${String(ENV_VAR_NAME_PATTERN)}.`);
     }
-    if (isReservedEnvVarName2(name)) {
+    if (isReservedEnvVarName(name)) {
       throw new Error(`defineMcp "${label}": env var "${name}" is reserved for Scarn.`);
     }
     if (seen.has(name)) {
@@ -972,26 +975,26 @@ function createHandle(state) {
       assertKnownCheck(state, "enableCheck", name);
       return withOp(state, { op: "enable", name });
     },
-    addCheck: (name, check) => {
-      assertCheckInput(state.name, name, check);
+    addCheck: (name, check2) => {
+      assertCheckInput(state.name, name, check2);
       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) });
+      return withOp(state, { op: "add", name, check: structuredClone(check2) });
     },
     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 ?? [];
+function defineMcp(config2) {
+  const definition = parseMcpServer(config2);
+  const env = config2.env ?? [];
+  const optionalEnv = config2.optionalEnv ?? [];
   assertEnvNames(definition.name, env, optionalEnv);
-  const checks = config.healthChecks ?? {};
-  for (const [name, check] of Object.entries(checks)) {
-    assertCheckInput(definition.name, name, check);
+  const checks = config2.healthChecks ?? {};
+  for (const [name, check2] of Object.entries(checks)) {
+    assertCheckInput(definition.name, name, check2);
   }
   return createHandle({
     ...frozenCopy(definition),
@@ -1001,10 +1004,10 @@ function defineMcp2(config) {
     overrides: Object.freeze([])
   });
 }
-function resolveMcpChecks2(handle) {
+function resolveMcpChecks(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 [name, check2] of Object.entries(handle.checks)) {
+    resolved.set(name, { check: { ...check2 }, enabled: check2.enabled ?? true });
   }
   for (const op of handle.overrides) {
     if (op.op === "add") {
@@ -1025,9 +1028,9 @@ function resolveMcpChecks2(handle) {
         entry.enabled = op.op === "enable";
     }
   }
-  return [...resolved].map(([name, { check, enabled }]) => ({
+  return [...resolved].map(([name, { check: check2, enabled }]) => ({
     name,
-    check,
+    check: check2,
     enabled
   }));
 }
@@ -1048,24 +1051,24 @@ function compileServer(key, handle) {
   }
 }
 function compileChecks(key, handle) {
-  return resolveMcpChecks2(handle).filter((resolved) => resolved.enabled).map(({ name, check }) => ({
+  return resolveMcpChecks(handle).filter((resolved) => resolved.enabled).map(({ name, check: check2 }) => ({
     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"
+    tool: check2.tool,
+    ...check2.args !== undefined ? { args: check2.args } : {},
+    ...check2.timeoutSeconds !== undefined ? { timeoutSeconds: check2.timeoutSeconds } : {},
+    serialGroup: check2.serialGroup ?? key,
+    severity: check2.severity ?? "required"
   }));
 }
 function compileEnv(key, handle) {
-  const entry = (name, optional) => ({
+  const entry = (name, optional2) => ({
     source: "inherit",
     name,
     from: name,
     secret: true,
-    optional,
+    optional: optional2,
     mcp: key,
     applies: "agent"
   });
@@ -1096,14 +1099,14 @@ function dedupeEnv(entries) {
   }
   return [...byName.values()];
 }
-function compileMcps2(mcps, stepKey) {
+function compileMcps(mcps, stepKey) {
   const compiled = {
     opencodeMcpJson: {},
     healthChecks: [],
     envEntries: []
   };
   for (const [key, handle] of Object.entries(mcps)) {
-    if (!isMcpHandle2(handle)) {
+    if (!isMcpHandle(handle)) {
       throw new Error(`Step "${stepKey}" mcps.${key}: expected a handle from defineMcp().`);
     }
     compiled.opencodeMcpJson[key] = compileServer(key, handle);
@@ -1124,7 +1127,7 @@ function mergeStepMcps(stepKey, input) {
       envJson: input.envJson
     };
   }
-  const compiled = compileMcps2(input.mcps, stepKey);
+  const compiled = compileMcps(input.mcps, stepKey);
   const stepVars = input.envJson ?? [];
   const stepVarNames = new Set(stepVars.map((entry) => entry.name));
   return {
@@ -1141,7 +1144,7 @@ function mergeStepMcps(stepKey, input) {
 }
 
 // src/definitions/steps/step-handle.ts
-function compileStepErrors2(stepKey, errors) {
+function compileStepErrors(stepKey, errors) {
   const names = [...errors ?? []];
   const seen = new Set;
   for (const name of names) {
@@ -1155,15 +1158,15 @@ function compileStepErrors2(stepKey, errors) {
   }
   return names;
 }
-function compileStepRetry2(stepKey, retry, errors) {
-  const known = new Set([...BUILT_IN_ERRORS2, ...errors]);
+function compileStepRetry(stepKey, retry, errors) {
+  const known = new Set([...BUILT_IN_ERRORS, ...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.`);
+    const unknown2 = entry.on.find((name) => !known.has(name));
+    if (unknown2 !== undefined) {
+      throw new Error(`Step "${stepKey}": retry names "${unknown2}", 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.`);
@@ -1171,7 +1174,7 @@ function compileStepRetry2(stepKey, retry, errors) {
     return { on: [...entry.on], maxAttempts: entry.maxAttempts };
   });
 }
-function toStepHandle2(spec) {
+function toStepHandle(spec) {
   const node = stepNode(spec);
   const call = stepCall(node);
   const { name, ...rest } = spec;
@@ -1182,30 +1185,30 @@ function toStepHandle2(spec) {
   Object.assign(call, rest);
   return makeHandle(call, node);
 }
-function toStepSpec2(step) {
+function toStepSpec(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.`);
+function assertStepMcpInput(config2) {
+  if ("mcpServers" in config2) {
+    throw new Error(`Step "${config2.key}": mcpServers is not supported. Declare each MCP server with defineMcp({ type: "ref" | "local" | "remote", ... }) and list it under mcps.`);
   }
-  if (config.healthChecks == null)
+  if (config2.healthChecks == null)
     return;
-  const parsed = stepHealthChecksInputSchema2.safeParse(config.healthChecks);
+  const parsed = stepHealthChecksInputSchema.safeParse(config2.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 }).`);
+  throw new Error(`Step "${config2.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;
+function defineStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.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;
+  const basePrompt = typeof config2.agentPrompt === "function" ? config2.agentPrompt(createPromptTemplateContext()) : config2.agentPrompt;
   let effectivePrompt = basePrompt;
   for (const feature of features) {
     if (feature._promptAddition) {
@@ -1220,40 +1223,40 @@ ${feature._promptAddition}` : feature._promptAddition;
     managedRuntime,
     envJson,
     repo
-  } = compileEnvironment2(config.environment, { stepKey: config.key });
-  assertStepMcpInput(config);
-  const mcpFields = mergeStepMcps(config.key, {
-    mcps: config.mcps,
-    healthChecks: config.healthChecks,
+  } = compileEnvironment(config2.environment, { stepKey: config2.key });
+  assertStepMcpInput(config2);
+  const mcpFields = mergeStepMcps(config2.key, {
+    mcps: config2.mcps,
+    healthChecks: config2.healthChecks,
     envJson
   });
   const resultSchemaJson = effectiveResult ? toJSONSchema(effectiveResult) : null;
   const spec = {
-    key: config.key,
-    name: config.name,
-    description: config.description ?? null,
-    version: config.version ?? 1,
+    key: config2.key,
+    name: config2.name,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
     kind: "user_defined",
-    status: config.status ?? "active",
+    status: config2.status ?? "active",
     executionMode,
     devcontainerConfigPath,
     ...managedRuntime !== null ? { managedRuntime } : {},
     prompt: effectivePrompt,
-    inputSchemaJson: config.additionalInput ? toJSONSchema(config.additionalInput) : null,
+    inputSchemaJson: config2.additionalInput ? toJSONSchema(config2.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 ?? [])
+    errors: compileStepErrors(config2.key, config2.errors),
+    retryJson: compileStepRetry(config2.key, config2.retry, config2.errors ?? [])
   };
-  return toStepHandle2(spec);
+  return toStepHandle(spec);
 }
 // src/definitions/steps/define-code-step.ts
-function codeStep2(config) {
-  const features = config.features ?? [];
-  let effectiveResult = config.resultSchema;
+function codeStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.resultSchema;
   for (const feature of features) {
     effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
   }
@@ -1263,38 +1266,38 @@ function codeStep2(config) {
     managedRuntime,
     envJson,
     repo
-  } = compileEnvironment2(config.environment, {
-    stepKey: config.key,
-    defaultRuntime: Runtime2.managed[DEFAULT_CODE_STEP_RUNTIME_ID2]()
+  } = compileEnvironment(config2.environment, {
+    stepKey: config2.key,
+    defaultRuntime: Runtime.managed[DEFAULT_CODE_STEP_RUNTIME_ID]()
   });
   const spec = {
-    key: config.key,
-    name: config.name,
-    description: config.description ?? null,
-    version: config.version ?? 1,
+    key: config2.key,
+    name: config2.name,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
     kind: "code",
-    status: config.status ?? "active",
+    status: config2.status ?? "active",
     executionMode,
     devcontainerConfigPath,
     managedRuntime,
     prompt: null,
-    inputSchemaJson: config.inputSchema ? toJSONSchema(config.inputSchema) : null,
+    inputSchemaJson: config2.inputSchema ? toJSONSchema(config2.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 }
+    errors: compileStepErrors(config2.key, config2.errors),
+    retryJson: compileStepRetry(config2.key, config2.retry, config2.errors ?? []),
+    entrypoint: { fn: config2.fn }
   };
-  return toStepHandle2(spec);
+  return toStepHandle(spec);
 }
 // src/definitions/steps/step-definitions-client.ts
 var ANY_OBJECT_SCHEMA = { type: "object" };
-function createStepDefinitionsClient2(baseUrl) {
+function createStepDefinitionsClient(baseUrl) {
   const client = createClient({ baseUrl });
-  return buildStepDefinitionsClient(new StepDefinitions2({ client }));
+  return buildStepDefinitionsClient(new StepDefinitions({ client }));
 }
 var buildStepDefinitionsClient = (stepDefinitions) => {
   return {
@@ -1317,7 +1320,7 @@ var buildStepDefinitionsClient = (stepDefinitions) => {
       return result.data;
     },
     upsertFromSpec: async (projectId, step, options) => {
-      const spec = toStepSpec2(step);
+      const spec = toStepSpec(step);
       const body = {
         key: spec.key,
         name: spec.name,
@@ -1354,15 +1357,15 @@ var buildStepDefinitionsClient = (stepDefinitions) => {
   };
 };
 // src/definitions/steps/step-features.ts
-var notificationKindSchema = _enum([
+var notificationKindSchema = exports_external.enum([
   "feedback_request",
   "status_update",
   "blocked",
   "result_ready",
   "warning"
 ]);
-var notificationPrioritySchema = _enum(["low", "normal", "high", "urgent"]);
-var notificationChannelSchema = _enum([
+var notificationPrioritySchema = exports_external.enum(["low", "normal", "high", "urgent"]);
+var notificationChannelSchema = exports_external.enum([
   "in_app",
   "work_item_platform_comment",
   "email",
@@ -1370,17 +1373,17 @@ var notificationChannelSchema = _enum([
 ]);
 var NOTIFICATION_RESULT_KEY = "$scarn_notifications_v1";
 var DEFAULT_NOTIFICATION_KIND = "status_update";
-var notificationItemSchema = object({
+var notificationItemSchema = exports_external.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."),
+  title: exports_external.string().optional().describe("Short, human-readable notification title."),
+  body: exports_external.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 }.')
+  suggestedChannels: exports_external.array(notificationChannelSchema).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
+  payload: exports_external.record(exports_external.string(), exports_external.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()
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema).optional()
   }),
   _promptAddition: [
     "## User Notifications",
@@ -1408,8 +1411,8 @@ var notificationsFeature = {
 `)
 };
 var feedbackRequestsFeature = {
-  _resultExtension: object({
-    [NOTIFICATION_RESULT_KEY]: array(notificationItemSchema.extend({ kind: literal("feedback_request") })).optional()
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema.extend({ kind: exports_external.literal("feedback_request") })).optional()
   }),
   _promptAddition: [
     "## Feedback Requests",
@@ -1423,15 +1426,15 @@ var feedbackRequestsFeature = {
   ].join(`
 `)
 };
-var Features2 = {
+var Features = {
   notifications: () => notificationsFeature,
   feedbackRequests: () => feedbackRequestsFeature
 };
-var Notify2 = {
+var Notify = {
   create: (item) => ({
     [NOTIFICATION_RESULT_KEY]: [item]
   }),
-  inApp: (title, body, priority, options) => Notify2.create({
+  inApp: (title, body, priority, options) => Notify.create({
     kind: options?.kind ?? DEFAULT_NOTIFICATION_KIND,
     title,
     body,
@@ -1439,7 +1442,7 @@ var Notify2 = {
     suggestedChannels: ["in_app"],
     ...options?.payload ? { payload: options.payload } : {}
   }),
-  feedbackRequest: (question, category, urgency) => Notify2.create({
+  feedbackRequest: (question, category, urgency) => Notify.create({
     kind: "feedback_request",
     title: question,
     body: question,
@@ -1450,4 +1453,4 @@ var Notify2 = {
     [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 };
+export { ARTIFACT_BRAND, ArtifactTypes, normalizeArtifactAccept, artifact, Artifact, exports_z, createPromptInputProxy, createPromptTemplateContext, renderPromptTemplate, isSecretLookingEnvName, Env, normalizeEnv, Repo, compileRepo, Runtime, compileEnvironment, isMcpHandle, defineMcp, resolveMcpChecks, compileMcps, compileStepErrors, compileStepRetry, toStepHandle, toStepSpec, defineStep, codeStep, createStepDefinitionsClient, Features, Notify };