@scarn/sdk 0.0.0 → 0.8.0

package/dist/{chunk-9s07v9r1.js → chunk-4ggr8af6.js}

@@ -1,30 +1,30 @@
 // @bun
 import {
-  string
-} from "./chunk-dnn39qt4.js";
+  exports_external
+} from "./chunk-skzxcba3.js";
 
 // src/devcontainer-config-path.ts
-var MAX_DEVCONTAINER_CONFIG_PATH_LENGTH2 = 255;
-var DEVCONTAINER_CONFIG_BASENAMES2 = [
+var MAX_DEVCONTAINER_CONFIG_PATH_LENGTH = 255;
+var DEVCONTAINER_CONFIG_BASENAMES = [
   "devcontainer.json",
   ".devcontainer.json"
 ];
 var LEADING_CURRENT_DIR = /^(?:\.\/)+/;
 var DRIVE_LETTER = /^[A-Za-z]:/;
-function normalizeDevcontainerConfigPath2(path) {
+function normalizeDevcontainerConfigPath(path) {
   return path.replace(LEADING_CURRENT_DIR, "");
 }
 function basenameOf(path) {
   return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
 }
-var devcontainerConfigPathSchema2 = string().max(MAX_DEVCONTAINER_CONFIG_PATH_LENGTH2).overwrite(normalizeDevcontainerConfigPath2).refine((path) => !path.includes("\\"), {
+var devcontainerConfigPathSchema = exports_external.string().max(MAX_DEVCONTAINER_CONFIG_PATH_LENGTH).overwrite(normalizeDevcontainerConfigPath).refine((path) => !path.includes("\\"), {
   message: "must use forward slashes, not backslashes"
 }).refine((path) => !path.startsWith("/") && !DRIVE_LETTER.test(path), {
   message: "must be relative to the repository root, not absolute"
 }).refine((path) => !path.split("/").includes(".."), {
   message: 'must not contain a ".." segment'
-}).refine((path) => DEVCONTAINER_CONFIG_BASENAMES2.includes(basenameOf(path)), {
+}).refine((path) => DEVCONTAINER_CONFIG_BASENAMES.includes(basenameOf(path)), {
   message: 'must end in "devcontainer.json" or ".devcontainer.json"'
 });
 
-export { MAX_DEVCONTAINER_CONFIG_PATH_LENGTH2, DEVCONTAINER_CONFIG_BASENAMES2, normalizeDevcontainerConfigPath2, devcontainerConfigPathSchema2 };
+export { MAX_DEVCONTAINER_CONFIG_PATH_LENGTH, DEVCONTAINER_CONFIG_BASENAMES, normalizeDevcontainerConfigPath, devcontainerConfigPathSchema };

package/dist/chunk-5zsavw98.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/env-vars.ts
+var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var RESERVED_ENV_VAR_NAMES = [
+  "HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "OPENCODE_CONFIG_CONTENT",
+  "npm_config_cache"
+];
+var RESERVED_ENV_VAR_PREFIX = "SCARN_";
+var MAX_ENV_VARS = 64;
+var MAX_ENV_VAR_NAME_LENGTH = 128;
+var MAX_ENV_VAR_VALUE_LENGTH = 4096;
+var INPUT_TOKEN_PATTERN = /\{\{input\.[^}]+\}\}/;
+function containsInputToken(value) {
+  return INPUT_TOKEN_PATTERN.test(value);
+}
+function isReservedEnvVarName(name) {
+  return name.startsWith(RESERVED_ENV_VAR_PREFIX) || RESERVED_ENV_VAR_NAMES.includes(name);
+}
+var envVarNameSchema = exports_external.string().max(MAX_ENV_VAR_NAME_LENGTH).regex(ENV_VAR_NAME_PATTERN, "must match /^[A-Z_][A-Z0-9_]*$/").refine((name) => !isReservedEnvVarName(name), {
+  message: `is reserved (SCARN_*, ${RESERVED_ENV_VAR_NAMES.join(", ")})`
+});
+var envVarValueSchema = exports_external.string().max(MAX_ENV_VAR_VALUE_LENGTH);
+var envVarAppliesValues = ["agent", "setup", "both"];
+var envVarAppliesSchema = exports_external.enum(envVarAppliesValues).default("agent");
+function appliesToAgent(applies) {
+  return applies !== "setup";
+}
+function appliesToSetup(applies) {
+  return applies === "setup" || applies === "both";
+}
+function isUninheritableWorkerEnvVarName(name) {
+  return name.toUpperCase().startsWith(RESERVED_ENV_VAR_PREFIX);
+}
+var valueEnvVarSchema = exports_external.object({
+  name: envVarNameSchema,
+  source: exports_external.literal("value"),
+  value: envVarValueSchema,
+  secret: exports_external.boolean(),
+  applies: envVarAppliesSchema
+}).strict().refine((entry) => !entry.secret || containsInputToken(entry.value), {
+  path: ["value"],
+  message: "a secret value must contain an {{input.\u2026}} token; a static secret would be stored in plaintext. Use Env.inherit({ secret: true }) instead"
+});
+var inheritEnvVarSchema = exports_external.object({
+  name: envVarNameSchema,
+  source: exports_external.literal("inherit"),
+  from: exports_external.string().max(MAX_ENV_VAR_NAME_LENGTH).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "must be a valid environment variable name").refine((from) => !isUninheritableWorkerEnvVarName(from), {
+    message: `cannot read worker variables starting with ${RESERVED_ENV_VAR_PREFIX}`
+  }),
+  secret: exports_external.boolean(),
+  optional: exports_external.boolean(),
+  default: envVarValueSchema.optional(),
+  mcp: exports_external.string().min(1).optional(),
+  applies: envVarAppliesSchema
+}).strict().refine((entry) => !(entry.secret && entry.default !== undefined), {
+  path: ["default"],
+  message: "a secret cannot carry a default; it would be stored in plaintext"
+});
+var envVarSpecSchema = exports_external.discriminatedUnion("source", [
+  valueEnvVarSchema,
+  inheritEnvVarSchema
+]);
+var envVarsSchema = exports_external.array(envVarSpecSchema).max(MAX_ENV_VARS).refine((entries) => new Set(entries.map((entry) => entry.name)).size === entries.length, { message: "environment variable names must be unique" });
+var storedEnvVarsSchema = exports_external.array(exports_external.discriminatedUnion("source", [
+  exports_external.object({
+    name: exports_external.string(),
+    source: exports_external.literal("value"),
+    value: exports_external.string(),
+    secret: exports_external.boolean(),
+    applies: exports_external.enum(envVarAppliesValues).default("agent")
+  }),
+  exports_external.object({
+    name: exports_external.string(),
+    source: exports_external.literal("inherit"),
+    from: exports_external.string(),
+    secret: exports_external.boolean(),
+    optional: exports_external.boolean(),
+    default: exports_external.string().optional(),
+    mcp: exports_external.string().optional(),
+    applies: exports_external.enum(envVarAppliesValues).default("agent")
+  })
+]));
+
+export { ENV_VAR_NAME_PATTERN, RESERVED_ENV_VAR_NAMES, RESERVED_ENV_VAR_PREFIX, MAX_ENV_VARS, MAX_ENV_VAR_NAME_LENGTH, MAX_ENV_VAR_VALUE_LENGTH, containsInputToken, isReservedEnvVarName, envVarAppliesValues, appliesToAgent, appliesToSetup, isUninheritableWorkerEnvVarName, envVarSpecSchema, envVarsSchema, storedEnvVarsSchema };

package/dist/chunk-63f90zky.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/health-checks.ts
+var healthCheckSeverityValues = ["required", "warn"];
+var healthCheckBaseSchema = exports_external.object({
+  name: exports_external.string().trim().min(1).optional(),
+  severity: exports_external.enum(healthCheckSeverityValues).default("required"),
+  timeoutSeconds: exports_external.number().gt(0).max(3600).default(15),
+  serialGroup: exports_external.string().trim().min(1).optional()
+});
+var toolHealthCheckSchema = healthCheckBaseSchema.extend({
+  kind: exports_external.literal("tool").default("tool"),
+  tool: exports_external.string().trim().min(1),
+  mcp: exports_external.string().trim().min(1).optional(),
+  args: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+}).strict();
+var cliHealthCheckSchema = healthCheckBaseSchema.extend({
+  kind: exports_external.literal("cli"),
+  command: exports_external.array(exports_external.string().min(1)).min(1),
+  expectExitCode: exports_external.int().default(0)
+}).strict();
+function injectDefaultKind(value) {
+  if (typeof value === "object" && value !== null && !("kind" in value)) {
+    return { ...value, kind: "tool" };
+  }
+  return value;
+}
+var healthCheckSchema = exports_external.preprocess(injectDefaultKind, exports_external.discriminatedUnion("kind", [toolHealthCheckSchema, cliHealthCheckSchema]));
+var healthChecksSchema = exports_external.array(healthCheckSchema);
+var stepToolHealthCheckSchema = toolHealthCheckSchema.omit({ mcp: true }).strict();
+var stepHealthChecksInputSchema = exports_external.array(exports_external.preprocess(injectDefaultKind, exports_external.discriminatedUnion("kind", [
+  stepToolHealthCheckSchema,
+  cliHealthCheckSchema
+])));
+
+export { healthCheckSeverityValues, toolHealthCheckSchema, cliHealthCheckSchema, healthCheckSchema, healthChecksSchema, stepToolHealthCheckSchema, stepHealthChecksInputSchema };

package/dist/{chunk-tfm5hjzm.js → chunk-700xe701.js}

@@ -1,18 +1,18 @@
 // @bun
 import {
-  createClient,
-  TaskRuns2,
-  ScarnClient2
-} from "./chunk-ynk2bjae.js";
+  ScarnClient,
+  TaskRuns,
+  createClient
+} from "./chunk-vfeytkqx.js";
 // src/task-plane-client.ts
 function unwrap(result) {
   if (result.error)
     throw new Error(JSON.stringify(result.error));
   return result.data;
 }
-function createTaskPlaneClient2(baseUrl, options) {
+function createTaskPlaneClient(baseUrl, options) {
   const client = createClient({ baseUrl, headers: options?.headers });
-  return buildTaskPlaneClient(new TaskRuns2({ client }));
+  return buildTaskPlaneClient(new TaskRuns({ client }));
 }
 var buildTaskPlaneClient = (taskRuns) => {
   return {
@@ -92,9 +92,9 @@ var buildTaskPlaneClient = (taskRuns) => {
 };
 
 // src/client.ts
-function createScarnClient2(baseUrl) {
+function createScarnClient(baseUrl) {
   const client = createClient({ baseUrl });
-  return new ScarnClient2({ client });
+  return new ScarnClient({ client });
 }
 
-export { createTaskPlaneClient2, createScarnClient2 };
+export { createTaskPlaneClient, createScarnClient };

package/dist/{chunk-njd6npf0.js → chunk-ar6hcj1r.js}

@@ -1,6 +1,6 @@
 // @bun
 // src/push/code-step-lookup.ts
-function isStepDefinitionSpec2(value) {
+function isStepDefinitionSpec(value) {
   if (typeof value !== "object" && typeof value !== "function")
     return false;
   if (value === null)
@@ -8,18 +8,18 @@ function isStepDefinitionSpec2(value) {
   const obj = value;
   return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && (obj["kind"] === "user_defined" || obj["kind"] === "code");
 }
-function stepsInModule2(mod) {
+function stepsInModule(mod) {
   const found = new Set;
   for (const [exportName, value] of Object.entries(mod)) {
-    if (exportName !== "default" && isStepDefinitionSpec2(value)) {
+    if (exportName !== "default" && isStepDefinitionSpec(value)) {
       found.add(value);
     }
   }
   return [...found];
 }
-function findCodeStepInModule2(mod, key) {
+function findCodeStepInModule(mod, key) {
   const fns = new Set;
-  for (const spec of stepsInModule2(mod)) {
+  for (const spec of stepsInModule(mod)) {
     if (spec.kind !== "code" || spec.key !== key)
       continue;
     const fn = spec.entrypoint?.fn;
@@ -32,4 +32,4 @@ function findCodeStepInModule2(mod, key) {
   return fns.values().next().value;
 }
 
-export { isStepDefinitionSpec2, stepsInModule2, findCodeStepInModule2 };
+export { isStepDefinitionSpec, stepsInModule, findCodeStepInModule };

package/dist/chunk-cdanncng.js

@@ -0,0 +1,74 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/repo-config.ts
+var MAX_REPO_COMMIT_MESSAGE_LENGTH = 500;
+var REPO_COMMIT_MESSAGE_TOKEN_ROOTS = [
+  "input",
+  "result"
+];
+var TOKEN_PATTERN = /\{\{([^}]+)\}\}/g;
+function findDisallowedCommitMessageTokenRoots(message) {
+  const disallowed = [];
+  for (const match of message.matchAll(TOKEN_PATTERN)) {
+    const root = (match[1] ?? "").split(".")[0] ?? "";
+    if (!REPO_COMMIT_MESSAGE_TOKEN_ROOTS.includes(root))
+      disallowed.push(root);
+  }
+  return disallowed;
+}
+var repoCommitMessageSchema = exports_external.string().max(MAX_REPO_COMMIT_MESSAGE_LENGTH).refine((message) => !/[\r\n]/.test(message), {
+  message: "must be a single line"
+}).refine((message) => findDisallowedCommitMessageTokenRoots(message).length === 0, {
+  message: `may only use {{${REPO_COMMIT_MESSAGE_TOKEN_ROOTS.join(".\u2026}}, {{")}.\u2026}} tokens`
+});
+var onPushFailureSchema = exports_external.enum(["fail", "warn"]);
+var repoConfigInputSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("none") }).strict(),
+  exports_external.object({ mode: exports_external.literal("readOnly") }).strict(),
+  exports_external.object({
+    mode: exports_external.literal("readWrite"),
+    message: repoCommitMessageSchema.nullish(),
+    onPushFailure: onPushFailureSchema.optional()
+  }).strict()
+]);
+var repoConfigSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("none") }).strict(),
+  exports_external.object({ mode: exports_external.literal("readOnly") }).strict(),
+  exports_external.object({
+    mode: exports_external.literal("readWrite"),
+    message: repoCommitMessageSchema.nullable(),
+    onPushFailure: onPushFailureSchema
+  }).strict()
+]);
+var REPO_RUNTIME_SUPPORT = {
+  workspace: {
+    modes: ["readOnly", "readWrite"],
+    default: "readWrite",
+    unsupportedBecause: "a devcontainer step reads its config from the clone"
+  },
+  no_workspace: {
+    modes: ["none"],
+    default: "none",
+    unsupportedBecause: "a host step has no clone"
+  }
+};
+function repoRuntimeMismatch(executionMode, mode) {
+  const support = REPO_RUNTIME_SUPPORT[executionMode];
+  return support.modes.includes(mode) ? null : support.unsupportedBecause;
+}
+function resolveRepoConfig(executionMode, input) {
+  const mode = input?.mode ?? REPO_RUNTIME_SUPPORT[executionMode].default;
+  if (mode !== "readWrite")
+    return { mode };
+  const readWrite = input?.mode === "readWrite" ? input : undefined;
+  return {
+    mode,
+    message: readWrite?.message ?? null,
+    onPushFailure: readWrite?.onPushFailure ?? "fail"
+  };
+}
+
+export { MAX_REPO_COMMIT_MESSAGE_LENGTH, REPO_COMMIT_MESSAGE_TOKEN_ROOTS, findDisallowedCommitMessageTokenRoots, repoCommitMessageSchema, repoConfigInputSchema, repoConfigSchema, REPO_RUNTIME_SUPPORT, repoRuntimeMismatch, resolveRepoConfig };

package/dist/chunk-dp86pa6m.js

@@ -0,0 +1,68 @@
+// @bun
+// src/contracts/pipeline-document/built-ins.ts
+var BUILT_IN_ERRORS = [
+  "Scarn.All",
+  "Scarn.StepFailed",
+  "Scarn.HealthCheckFailed",
+  "Scarn.Timeout",
+  "Scarn.HeartbeatTimeout",
+  "Scarn.MaxRunsExceeded",
+  "Scarn.MaxTurnsExceeded",
+  "Scarn.ConditionError",
+  "Scarn.ArgsError"
+];
+var WAIT_ERRORS = [
+  "Scarn.All",
+  "Scarn.MaxRunsExceeded",
+  "Scarn.ArgsError"
+];
+function decisionResultSchema(actions) {
+  const keys = [...new Set(actions.map((action) => action.key))];
+  return {
+    title: "DecisionResult",
+    type: "object",
+    properties: {
+      action: keys.length === 0 ? { type: "string" } : { type: "string", enum: keys },
+      body: { type: ["string", "null"] }
+    },
+    required: ["action", "body"],
+    additionalProperties: false
+  };
+}
+var REPLY_RESULT_SCHEMA = {
+  title: "ReplyResult",
+  type: "object",
+  properties: {
+    replied: { type: "boolean" },
+    body: { type: ["string", "null"] },
+    commentId: { type: ["string", "null"] }
+  },
+  required: ["replied", "body", "commentId"],
+  additionalProperties: false
+};
+var CONVERSATION_RESULT_SCHEMA = {
+  title: "ConversationResult",
+  type: "object",
+  properties: {
+    conversationId: { type: "string" },
+    summary: { type: "string" }
+  },
+  required: ["conversationId", "summary"],
+  additionalProperties: false
+};
+var REPLY_INPUT_SCHEMA = {
+  type: "array",
+  items: { type: "string" }
+};
+var ERROR_SCHEMA = {
+  title: "Error",
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    message: { type: "string" },
+    cause: {}
+  },
+  required: ["name", "message"]
+};
+
+export { BUILT_IN_ERRORS, WAIT_ERRORS, decisionResultSchema, REPLY_RESULT_SCHEMA, CONVERSATION_RESULT_SCHEMA, REPLY_INPUT_SCHEMA, ERROR_SCHEMA };

package/dist/chunk-e1h021kq.js

@@ -0,0 +1,86 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/opencode-mcp.ts
+var nonEmptyStringSchema = exports_external.string().trim().min(1);
+var mcpStringMapSchema = exports_external.record(exports_external.string(), exports_external.string());
+var positiveIntSchema = exports_external.int().gt(0).max(Number.MAX_SAFE_INTEGER);
+var openCodeMcpTimeoutSchema = exports_external.object({
+  startup: positiveIntSchema.optional(),
+  catalog: positiveIntSchema.optional(),
+  execution: positiveIntSchema.optional()
+}).strict();
+var openCodeMcpProtocolSchema = exports_external.enum([
+  "legacy",
+  "auto",
+  "2026-07-28"
+]);
+var sharedServerFields = {
+  disabled: exports_external.boolean().optional(),
+  codemode: exports_external.boolean().optional(),
+  timeout: openCodeMcpTimeoutSchema.optional(),
+  protocol: openCodeMcpProtocolSchema.optional()
+};
+var openCodeMcpLocalConfigSchema = exports_external.object({
+  type: exports_external.literal("local"),
+  command: exports_external.array(nonEmptyStringSchema).min(1),
+  cwd: exports_external.string().optional(),
+  environment: mcpStringMapSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpOAuthConfigSchema = exports_external.object({
+  client_id: exports_external.string().optional(),
+  client_secret: exports_external.string().optional(),
+  scope: exports_external.string().optional(),
+  callback_port: positiveIntSchema.optional(),
+  redirect_uri: exports_external.string().optional(),
+  auth_server_metadata_url: exports_external.string().optional()
+}).strict();
+var openCodeMcpRemoteConfigSchema = exports_external.object({
+  type: exports_external.literal("remote"),
+  url: exports_external.string(),
+  headers: mcpStringMapSchema.optional(),
+  oauth: exports_external.union([openCodeMcpOAuthConfigSchema, exports_external.literal(false)]).optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpRefConfigSchema = exports_external.object({
+  type: exports_external.literal("ref"),
+  name: nonEmptyStringSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeResolvedMcpServerConfigSchema = exports_external.discriminatedUnion("type", [openCodeMcpLocalConfigSchema, openCodeMcpRemoteConfigSchema]);
+var openCodeResolvedMcpServersSchema = exports_external.record(exports_external.string(), openCodeResolvedMcpServerConfigSchema);
+var openCodeMcpServerConfigSchema = exports_external.discriminatedUnion("type", [
+  openCodeMcpLocalConfigSchema,
+  openCodeMcpRemoteConfigSchema,
+  openCodeMcpRefConfigSchema
+]);
+var openCodeMcpServersSchema = exports_external.record(exports_external.string(), openCodeMcpServerConfigSchema);
+var ENV_PLACEHOLDER_PATTERN = /\{env:[A-Za-z_][A-Za-z0-9_]*\}/gu;
+var ENV_PLACEHOLDER_NAME_PATTERN = /\{env:([^}]+)\}/gu;
+var AUTH_SCHEME_PATTERN = /^(?:bearer|basic|token)\s+/iu;
+function isEnvPlaceholderValue(value) {
+  if (value.match(ENV_PLACEHOLDER_PATTERN) === null)
+    return false;
+  return value.trim().replace(AUTH_SCHEME_PATTERN, "").replace(ENV_PLACEHOLDER_PATTERN, "").trim() === "";
+}
+function collectEnvPlaceholderNames(value) {
+  const names = new Set;
+  const visit = (item) => {
+    if (typeof item === "string") {
+      for (const match of item.matchAll(ENV_PLACEHOLDER_NAME_PATTERN)) {
+        if (match[1] !== undefined)
+          names.add(match[1]);
+      }
+    } else if (typeof item === "object" && item !== null) {
+      for (const child of Object.values(item))
+        visit(child);
+    }
+  };
+  visit(value);
+  return [...names].sort();
+}
+
+export { openCodeMcpTimeoutSchema, openCodeMcpProtocolSchema, openCodeMcpLocalConfigSchema, openCodeMcpOAuthConfigSchema, openCodeMcpRemoteConfigSchema, openCodeMcpRefConfigSchema, openCodeResolvedMcpServerConfigSchema, openCodeResolvedMcpServersSchema, openCodeMcpServerConfigSchema, openCodeMcpServersSchema, isEnvPlaceholderValue, collectEnvPlaceholderNames };

package/dist/{chunk-ny07ncb9.js → chunk-gds7w7zh.js}

@@ -1,32 +1,32 @@
 // @bun
 import {
-  artifactPlatforms2,
-  EMBEDDABLE_ARTIFACT_EXTENSIONS2,
-  findArtifactFields2
-} from "./chunk-56e4kp0a.js";
+  envVarsSchema
+} from "./chunk-5zsavw98.js";
 import {
-  findArtifactMarkers2
-} from "./chunk-631ffb6r.js";
+  devcontainerConfigPathSchema
+} from "./chunk-4ggr8af6.js";
 import {
-  envVarsSchema2
-} from "./chunk-p6kc9wq8.js";
+  MANAGED_RUNTIME_IDS,
+  isManagedRuntimeId
+} from "./chunk-k4y5qt4y.js";
 import {
-  repoConfigInputSchema2,
-  repoRuntimeMismatch2
-} from "./chunk-b21233rt.js";
+  repoConfigInputSchema,
+  repoRuntimeMismatch
+} from "./chunk-cdanncng.js";
 import {
-  devcontainerConfigPathSchema2
-} from "./chunk-9s07v9r1.js";
+  findArtifactMarkers
+} from "./chunk-ngy1fdcx.js";
 import {
-  MANAGED_RUNTIME_IDS2,
-  isManagedRuntimeId2
-} from "./chunk-s0gap8r8.js";
+  EMBEDDABLE_ARTIFACT_EXTENSIONS,
+  artifactPlatforms,
+  findArtifactFields
+} from "./chunk-y2pv8d6a.js";
 
 // src/definitions/validation/validate-artifacts.ts
 function checkArtifactFields(steps) {
   const issues = [];
   for (const step of steps) {
-    for (const field of findArtifactFields2(step.resultSchemaJson ?? null)) {
+    for (const field of findArtifactFields(step.resultSchemaJson ?? null)) {
       if (!field.inArray)
         continue;
       issues.push({
@@ -40,7 +40,7 @@ function checkArtifactFields(steps) {
 }
 
 // src/definitions/validation/validation-issue.ts
-function listPaths2(paths, limit = 24) {
+function listPaths(paths, limit = 24) {
   if (paths.length === 0)
     return "";
   if (paths.length <= limit)
@@ -53,7 +53,7 @@ var isPlaceholder = (key) => /^<[^<>]*>$/.test(key);
 function stepMarkers(step) {
   if (!step.prompt)
     return [];
-  return findArtifactMarkers2(step.prompt).flatMap((marker) => marker.ref.type === "signal" && !isPlaceholder(marker.ref.stepKey) && !isPlaceholder(marker.ref.signalKey) ? [
+  return findArtifactMarkers(step.prompt).flatMap((marker) => marker.ref.type === "signal" && !isPlaceholder(marker.ref.stepKey) && !isPlaceholder(marker.ref.signalKey) ? [
     {
       kind: marker.kind,
       stepKey: marker.ref.stepKey,
@@ -64,8 +64,8 @@ function stepMarkers(step) {
 var markerLabel = (marker) => `${marker.kind === "embed" ? "Artifact.embed" : "Artifact.link"}(` + `"signal/${marker.stepKey}/${marker.resultPath}")`;
 function checkMarkerTargets(steps, stepsByKey) {
   const issues = [];
-  const embeddable = new Set(artifactPlatforms2.flatMap((platform) => [
-    ...EMBEDDABLE_ARTIFACT_EXTENSIONS2[platform]
+  const embeddable = new Set(artifactPlatforms.flatMap((platform) => [
+    ...EMBEDDABLE_ARTIFACT_EXTENSIONS[platform]
   ]));
   for (const step of steps) {
     for (const marker of stepMarkers(step)) {
@@ -76,14 +76,14 @@ function checkMarkerTargets(steps, stepsByKey) {
       for (const target of targets) {
         if (!target.resultSchemaJson)
           continue;
-        const fields = findArtifactFields2(target.resultSchemaJson);
+        const fields = findArtifactFields(target.resultSchemaJson);
         const field = fields.find((candidate) => candidate.path === marker.resultPath);
         if (!field) {
           const declared = fields.map((candidate) => candidate.path);
           issues.push({
             check: "artifact-marker",
             severity: "error",
-            message: `${where}, but step "${target.key}" has no artifact field at ` + `"${marker.resultPath}". Artifact fields on "${target.key}": ` + `${declared.length > 0 ? listPaths2(declared) : "(none)"}.`
+            message: `${where}, but step "${target.key}" has no artifact field at ` + `"${marker.resultPath}". Artifact fields on "${target.key}": ` + `${declared.length > 0 ? listPaths(declared) : "(none)"}.`
           });
           continue;
         }
@@ -116,7 +116,7 @@ function checkEnv(steps) {
       continue;
     issues.push(...checkEnvMcpOwners(step));
     issues.push(...checkEnvApplies(step));
-    const result = envVarsSchema2.safeParse(step.envJson);
+    const result = envVarsSchema.safeParse(step.envJson);
     if (result.success)
       continue;
     for (const issue of result.error.issues) {
@@ -145,7 +145,7 @@ function checkEnvMcpOwners(step) {
     issues.push({
       check: "env-var-mcp",
       severity: "error",
-      message: `Step "${step.key}" env var #${String(index + 1)} ("${entry.name}") ` + `belongs to MCP server "${entry.mcp}", but the step declares no MCP ` + `server with that key. Declared servers: ` + `${serverKeys.length > 0 ? listPaths2(serverKeys) : "(none)"}.`
+      message: `Step "${step.key}" env var #${String(index + 1)} ("${entry.name}") ` + `belongs to MCP server "${entry.mcp}", but the step declares no MCP ` + `server with that key. Declared servers: ` + `${serverKeys.length > 0 ? listPaths(serverKeys) : "(none)"}.`
     });
   });
   return issues;
@@ -182,7 +182,7 @@ function checkRepo(steps) {
     if (!step.repo)
       continue;
     const where = `Step "${step.key}" repo`;
-    const parsed = repoConfigInputSchema2.safeParse(step.repo);
+    const parsed = repoConfigInputSchema.safeParse(step.repo);
     if (!parsed.success) {
       for (const issue of parsed.error.issues) {
         const field = issue.path.map(String).join(".");
@@ -195,7 +195,7 @@ function checkRepo(steps) {
       continue;
     }
     const executionMode = step.executionMode ?? "workspace";
-    const mismatch = repoRuntimeMismatch2(executionMode, parsed.data.mode);
+    const mismatch = repoRuntimeMismatch(executionMode, parsed.data.mode);
     if (mismatch === null)
       continue;
     issues.push({
@@ -229,7 +229,7 @@ function checkRuntime(steps) {
         message: `${where}: a devcontainer config needs a workspace, but the step runs on the host (executionMode "no_workspace"). Use Runtime.devcontainer({ config }) or drop the config.`
       });
     }
-    const result = devcontainerConfigPathSchema2.safeParse(step.devcontainerConfigPath);
+    const result = devcontainerConfigPathSchema.safeParse(step.devcontainerConfigPath);
     if (result.success)
       continue;
     for (const issue of result.error.issues) {
@@ -247,8 +247,8 @@ function checkManagedRuntime(step) {
     return [];
   const where = `Step "${step.key}" managedRuntime "${step.managedRuntime}"`;
   const problems = [];
-  if (!isManagedRuntimeId2(step.managedRuntime)) {
-    problems.push(`unknown managed runtime; expected one of ${MANAGED_RUNTIME_IDS2.join(", ")}`);
+  if (!isManagedRuntimeId(step.managedRuntime)) {
+    problems.push(`unknown managed runtime; expected one of ${MANAGED_RUNTIME_IDS.join(", ")}`);
   }
   if (step.kind !== "code") {
     problems.push("managed runtimes are only supported for code steps. Use Runtime.devcontainer() or Runtime.host() for defineStep");
@@ -286,7 +286,7 @@ function checkHealthChecks(steps) {
         issues.push({
           check: "health-check-mcp-server",
           severity: "error",
-          message: `${where} names MCP server "${check.mcp}", but the step declares no ` + `such server in mcps. Declared servers: ${mcpServerKeys.length > 0 ? listPaths2([...mcpServerKeys].sort()) : "(none)"}.`
+          message: `${where} names MCP server "${check.mcp}", but the step declares no ` + `such server in mcps. Declared servers: ${mcpServerKeys.length > 0 ? listPaths([...mcpServerKeys].sort()) : "(none)"}.`
         });
       }
       const prefix = `${check.mcp}_`;
@@ -301,7 +301,7 @@ function checkHealthChecks(steps) {
   }
   return issues;
 }
-function validateDefinitionSpecs2(steps) {
+function validateDefinitionSpecs(steps) {
   const stepsByKey = new Map;
   for (const step of steps) {
     const existing = stepsByKey.get(step.key);
@@ -319,12 +319,12 @@ function validateDefinitionSpecs2(steps) {
     ...checkRepo(steps)
   ];
 }
-function assertValidDefinitionSpecs2(steps) {
-  const issues = validateDefinitionSpecs2(steps).filter((issue) => issue.severity === "error");
+function assertValidDefinitionSpecs(steps) {
+  const issues = validateDefinitionSpecs(steps).filter((issue) => issue.severity === "error");
   if (issues.length === 0)
     return;
   const header = issues.length === 1 ? "Definition validation failed:" : `Definition validation failed with ${String(issues.length)} problems:`;
   throw new Error([header, ...issues.map((issue) => `  \u2022 ${issue.message}`)].join(`
 `));
 }
-export { listPaths2, validateDefinitionSpecs2, assertValidDefinitionSpecs2 };
+export { listPaths, validateDefinitionSpecs, assertValidDefinitionSpecs };