@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/chunk-ny07ncb9.js

@@ -0,0 +1,330 @@
+// @bun
+import {
+  artifactPlatforms2,
+  EMBEDDABLE_ARTIFACT_EXTENSIONS2,
+  findArtifactFields2
+} from "./chunk-56e4kp0a.js";
+import {
+  findArtifactMarkers2
+} from "./chunk-631ffb6r.js";
+import {
+  envVarsSchema2
+} from "./chunk-p6kc9wq8.js";
+import {
+  repoConfigInputSchema2,
+  repoRuntimeMismatch2
+} from "./chunk-b21233rt.js";
+import {
+  devcontainerConfigPathSchema2
+} from "./chunk-9s07v9r1.js";
+import {
+  MANAGED_RUNTIME_IDS2,
+  isManagedRuntimeId2
+} from "./chunk-s0gap8r8.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)) {
+      if (!field.inArray)
+        continue;
+      issues.push({
+        check: "artifact-field",
+        severity: "error",
+        message: `Step "${step.key}" declares artifact field "${field.path}" inside an ` + `array. Artifact fields in arrays aren't supported; declare a fixed ` + `number of named artifact fields instead.`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/definitions/validation/validation-issue.ts
+function listPaths2(paths, limit = 24) {
+  if (paths.length === 0)
+    return "";
+  if (paths.length <= limit)
+    return paths.join(", ");
+  return `${paths.slice(0, limit).join(", ")}, \u2026 (${String(paths.length - limit)} more)`;
+}
+
+// src/definitions/validation/validate-artifact-markers.ts
+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) ? [
+    {
+      kind: marker.kind,
+      stepKey: marker.ref.stepKey,
+      resultPath: marker.ref.signalKey
+    }
+  ] : []);
+}
+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]
+  ]));
+  for (const step of steps) {
+    for (const marker of stepMarkers(step)) {
+      const targets = stepsByKey.get(marker.stepKey);
+      if (!targets)
+        continue;
+      const where = `Step "${step.key}" uses ${markerLabel(marker)}`;
+      for (const target of targets) {
+        if (!target.resultSchemaJson)
+          continue;
+        const fields = findArtifactFields2(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)"}.`
+          });
+          continue;
+        }
+        if (marker.kind !== "embed")
+          continue;
+        const { accept } = field;
+        if (accept.length === 0)
+          continue;
+        if (accept.some((extension) => embeddable.has(extension)))
+          continue;
+        issues.push({
+          check: "artifact-marker",
+          severity: "warning",
+          message: `${where}, but the field accepts only ${accept.join(", ")}, which ` + `no platform can embed, so it will always be linked. Embeddable ` + `extensions: ${[...embeddable].join(", ")}.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkArtifactMarkers(steps, stepsByKey) {
+  return checkMarkerTargets(steps, stepsByKey);
+}
+
+// src/definitions/validation/validate-env.ts
+function checkEnv(steps) {
+  const issues = [];
+  for (const step of steps) {
+    if (!step.envJson)
+      continue;
+    issues.push(...checkEnvMcpOwners(step));
+    issues.push(...checkEnvApplies(step));
+    const result = envVarsSchema2.safeParse(step.envJson);
+    if (result.success)
+      continue;
+    for (const issue of result.error.issues) {
+      const [index, ...field] = issue.path;
+      const entry = typeof index === "number" ? step.envJson[index] : undefined;
+      const where = typeof index === "number" && entry ? `Step "${step.key}" env var #${String(index + 1)} ("${entry.name}")` : `Step "${step.key}" env`;
+      const fieldLabel = field.length > 0 ? ` ${field.map(String).join(".")}` : "";
+      issues.push({
+        check: "env-var",
+        severity: "error",
+        message: `${where}${fieldLabel}: ${issue.message}`
+      });
+    }
+  }
+  return issues;
+}
+function checkEnvMcpOwners(step) {
+  const serverKeys = Object.keys(step.opencodeMcpJson ?? {}).sort();
+  const serverKeySet = new Set(serverKeys);
+  const issues = [];
+  (step.envJson ?? []).forEach((entry, index) => {
+    if (entry.source !== "inherit" || entry.mcp === undefined)
+      return;
+    if (serverKeySet.has(entry.mcp))
+      return;
+    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)"}.`
+    });
+  });
+  return issues;
+}
+function checkEnvApplies(step) {
+  const issues = [];
+  (step.envJson ?? []).forEach((entry, index) => {
+    const applies = entry.applies ?? "agent";
+    if (applies === "agent")
+      return;
+    const where = `Step "${step.key}" env var #${String(index + 1)} ("${entry.name}") applies "${applies}"`;
+    if (step.executionMode === "no_workspace") {
+      issues.push({
+        check: "env-var-applies",
+        severity: "error",
+        message: `${where}: setup variables reach devcontainer up, but the step runs on the host (executionMode "no_workspace") with no container to set up. Use applies "agent" or Runtime.devcontainer().`
+      });
+    }
+    if (entry.source === "inherit" && entry.mcp !== undefined) {
+      issues.push({
+        check: "env-var-applies",
+        severity: "error",
+        message: `${where}: it belongs to MCP server "${entry.mcp}", and MCP servers run inside the agent. Use applies "agent".`
+      });
+    }
+  });
+  return issues;
+}
+
+// src/definitions/validation/validate-repo.ts
+function checkRepo(steps) {
+  const issues = [];
+  for (const step of steps) {
+    if (!step.repo)
+      continue;
+    const where = `Step "${step.key}" repo`;
+    const parsed = repoConfigInputSchema2.safeParse(step.repo);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        const field = issue.path.map(String).join(".");
+        issues.push({
+          check: "repo",
+          severity: "error",
+          message: `${where}${field ? ` ${field}` : ""}: ${issue.message}`
+        });
+      }
+      continue;
+    }
+    const executionMode = step.executionMode ?? "workspace";
+    const mismatch = repoRuntimeMismatch2(executionMode, parsed.data.mode);
+    if (mismatch === null)
+      continue;
+    issues.push({
+      check: "repo",
+      severity: "error",
+      message: `${where} "${parsed.data.mode}" cannot be used with executionMode "${executionMode}": ${mismatch}.`
+    });
+  }
+  return issues;
+}
+
+// src/definitions/validation/validate-runtime.ts
+function checkRuntime(steps) {
+  const issues = [];
+  for (const step of steps) {
+    if (step.kind === "code" && step.executionMode === "no_workspace") {
+      issues.push({
+        check: "runtime",
+        severity: "error",
+        message: `Step "${step.key}": code steps run repo code and need a workspace, so Runtime.host() (executionMode "no_workspace") is not supported for codeStep. Use Runtime.managed.<id>() or Runtime.devcontainer(), or drop the runtime.`
+      });
+    }
+    issues.push(...checkManagedRuntime(step));
+    if (step.devcontainerConfigPath == null)
+      continue;
+    const where = `Step "${step.key}" devcontainerConfigPath "${step.devcontainerConfigPath}"`;
+    if (step.executionMode === "no_workspace") {
+      issues.push({
+        check: "runtime",
+        severity: "error",
+        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);
+    if (result.success)
+      continue;
+    for (const issue of result.error.issues) {
+      issues.push({
+        check: "runtime",
+        severity: "error",
+        message: `${where}: ${issue.message}`
+      });
+    }
+  }
+  return issues;
+}
+function checkManagedRuntime(step) {
+  if (step.managedRuntime == null)
+    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 (step.kind !== "code") {
+    problems.push("managed runtimes are only supported for code steps. Use Runtime.devcontainer() or Runtime.host() for defineStep");
+  }
+  if (step.executionMode === "no_workspace") {
+    problems.push('a managed runtime needs a workspace, but the step runs on the host (executionMode "no_workspace")');
+  }
+  if (step.devcontainerConfigPath != null) {
+    problems.push("cannot be combined with devcontainerConfigPath. Use either Runtime.managed.<id>() or Runtime.devcontainer({ config })");
+  }
+  return problems.map((problem) => ({
+    check: "runtime",
+    severity: "error",
+    message: `${where}: ${problem}.`
+  }));
+}
+
+// src/definitions/validation/validate-definition-specs.ts
+function checkHealthChecks(steps) {
+  const issues = [];
+  for (const step of steps) {
+    const checks = step.healthChecksJson ?? [];
+    if (checks.length === 0)
+      continue;
+    const mcpServerKeys = Object.keys(step.opencodeMcpJson ?? {});
+    const mcpServerKeySet = new Set(mcpServerKeys);
+    checks.forEach((check, index) => {
+      if (check.kind === "cli")
+        return;
+      const label = check.name ?? check.tool;
+      const where = `Step "${step.key}" health check #${String(index + 1)} ("${label}")`;
+      if (!check.mcp)
+        return;
+      if (!mcpServerKeySet.has(check.mcp)) {
+        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)"}.`
+        });
+      }
+      const prefix = `${check.mcp}_`;
+      if (check.tool.startsWith(prefix)) {
+        issues.push({
+          check: "health-check-double-qualified",
+          severity: "error",
+          message: `${where} sets mcp "${check.mcp}" and tool "${check.tool}", which already ` + `starts with "${prefix}". When "mcp" is set, "tool" should be the bare tool ` + `name \u2014 OpenCode resolves it to "${prefix}${check.tool}". Did you mean ` + `tool: "${check.tool.slice(prefix.length)}"?`
+        });
+      }
+    });
+  }
+  return issues;
+}
+function validateDefinitionSpecs2(steps) {
+  const stepsByKey = new Map;
+  for (const step of steps) {
+    const existing = stepsByKey.get(step.key);
+    if (existing)
+      existing.push(step);
+    else
+      stepsByKey.set(step.key, [step]);
+  }
+  return [
+    ...checkArtifactFields(steps),
+    ...checkArtifactMarkers(steps, stepsByKey),
+    ...checkHealthChecks(steps),
+    ...checkEnv(steps),
+    ...checkRuntime(steps),
+    ...checkRepo(steps)
+  ];
+}
+function assertValidDefinitionSpecs2(steps) {
+  const issues = validateDefinitionSpecs2(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 };

package/dist/chunk-p6kc9wq8.js

@@ -0,0 +1,97 @@
+// @bun
+import {
+  string,
+  boolean,
+  array,
+  object,
+  discriminatedUnion,
+  _enum,
+  literal
+} from "./chunk-dnn39qt4.js";
+
+// src/env-vars.ts
+var ENV_VAR_NAME_PATTERN2 = /^[A-Z_][A-Z0-9_]*$/;
+var RESERVED_ENV_VAR_NAMES2 = [
+  "HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "OPENCODE_CONFIG_CONTENT",
+  "npm_config_cache"
+];
+var RESERVED_ENV_VAR_PREFIX2 = "SCARN_";
+var MAX_ENV_VARS2 = 64;
+var MAX_ENV_VAR_NAME_LENGTH2 = 128;
+var MAX_ENV_VAR_VALUE_LENGTH2 = 4096;
+var INPUT_TOKEN_PATTERN = /\{\{input\.[^}]+\}\}/;
+function containsInputToken2(value) {
+  return INPUT_TOKEN_PATTERN.test(value);
+}
+function isReservedEnvVarName2(name) {
+  return name.startsWith(RESERVED_ENV_VAR_PREFIX2) || RESERVED_ENV_VAR_NAMES2.includes(name);
+}
+var envVarNameSchema = string().max(MAX_ENV_VAR_NAME_LENGTH2).regex(ENV_VAR_NAME_PATTERN2, "must match /^[A-Z_][A-Z0-9_]*$/").refine((name) => !isReservedEnvVarName2(name), {
+  message: `is reserved (SCARN_*, ${RESERVED_ENV_VAR_NAMES2.join(", ")})`
+});
+var envVarValueSchema = string().max(MAX_ENV_VAR_VALUE_LENGTH2);
+var envVarAppliesValues2 = ["agent", "setup", "both"];
+var envVarAppliesSchema = _enum(envVarAppliesValues2).default("agent");
+function appliesToAgent2(applies) {
+  return applies !== "setup";
+}
+function appliesToSetup2(applies) {
+  return applies === "setup" || applies === "both";
+}
+function isUninheritableWorkerEnvVarName2(name) {
+  return name.toUpperCase().startsWith(RESERVED_ENV_VAR_PREFIX2);
+}
+var valueEnvVarSchema = object({
+  name: envVarNameSchema,
+  source: literal("value"),
+  value: envVarValueSchema,
+  secret: boolean(),
+  applies: envVarAppliesSchema
+}).strict().refine((entry) => !entry.secret || containsInputToken2(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 = object({
+  name: envVarNameSchema,
+  source: literal("inherit"),
+  from: string().max(MAX_ENV_VAR_NAME_LENGTH2).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "must be a valid environment variable name").refine((from) => !isUninheritableWorkerEnvVarName2(from), {
+    message: `cannot read worker variables starting with ${RESERVED_ENV_VAR_PREFIX2}`
+  }),
+  secret: boolean(),
+  optional: boolean(),
+  default: envVarValueSchema.optional(),
+  mcp: 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 envVarSpecSchema2 = discriminatedUnion("source", [
+  valueEnvVarSchema,
+  inheritEnvVarSchema
+]);
+var envVarsSchema2 = array(envVarSpecSchema2).max(MAX_ENV_VARS2).refine((entries) => new Set(entries.map((entry) => entry.name)).size === entries.length, { message: "environment variable names must be unique" });
+var storedEnvVarsSchema2 = array(discriminatedUnion("source", [
+  object({
+    name: string(),
+    source: literal("value"),
+    value: string(),
+    secret: boolean(),
+    applies: _enum(envVarAppliesValues2).default("agent")
+  }),
+  object({
+    name: string(),
+    source: literal("inherit"),
+    from: string(),
+    secret: boolean(),
+    optional: boolean(),
+    default: string().optional(),
+    mcp: string().optional(),
+    applies: _enum(envVarAppliesValues2).default("agent")
+  })
+]));
+
+export { ENV_VAR_NAME_PATTERN2, RESERVED_ENV_VAR_NAMES2, RESERVED_ENV_VAR_PREFIX2, MAX_ENV_VARS2, MAX_ENV_VAR_NAME_LENGTH2, MAX_ENV_VAR_VALUE_LENGTH2, containsInputToken2, isReservedEnvVarName2, envVarAppliesValues2, appliesToAgent2, appliesToSetup2, isUninheritableWorkerEnvVarName2, envVarSpecSchema2, envVarsSchema2, storedEnvVarsSchema2 };

package/dist/chunk-qpw5wt1p.js

@@ -0,0 +1,257 @@
+// @bun
+import {
+  createClient,
+  PipelineDefinitions2
+} from "./chunk-ynk2bjae.js";
+import {
+  string,
+  object
+} from "./chunk-dnn39qt4.js";
+
+// src/definitions/pipelines/pipeline-definitions-client.ts
+var pipelineDocumentIssueSchema = object({
+  code: string(),
+  path: string(),
+  message: string(),
+  hint: string().optional()
+});
+
+class PipelineDefinitionsApiError2 extends Error {
+  code;
+  issues;
+  constructor(error) {
+    super(error.detail ?? error.title ?? JSON.stringify(error));
+    this.name = "PipelineDefinitionsApiError";
+    this.code = error.code;
+    this.issues = documentIssuesOf(error.meta);
+  }
+}
+function documentIssuesOf(meta) {
+  const errors = meta?.["errors"];
+  if (!Array.isArray(errors))
+    return [];
+  return errors.flatMap((error) => {
+    const parsed = pipelineDocumentIssueSchema.safeParse(error);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function unwrap(result) {
+  if (result.error !== undefined) {
+    throw new PipelineDefinitionsApiError2(result.error);
+  }
+  return result.data;
+}
+function createPipelineDefinitionsClient2(baseUrl) {
+  const client = createClient({ baseUrl });
+  return buildPipelineDefinitionsClient(new PipelineDefinitions2({ client }));
+}
+var buildPipelineDefinitionsClient = (pipelineDefinitions) => ({
+  listByProjectId: async (projectId, options) => unwrap(await pipelineDefinitions.listPipelineDefinitions({
+    path: { projectId },
+    headers: options?.headers
+  })),
+  get: async (pipelineDefinitionId, options) => unwrap(await pipelineDefinitions.getPipelineDefinition({
+    path: { pipelineDefinitionId },
+    headers: options?.headers
+  })),
+  create: async (input, options) => unwrap(await pipelineDefinitions.createPipelineDefinition({
+    body: input,
+    headers: options?.headers
+  })),
+  publishVersion: async (pipelineDefinitionId, document, options) => unwrap(await pipelineDefinitions.publishPipelineDefinitionVersion({
+    path: { pipelineDefinitionId },
+    body: { document },
+    headers: options?.headers
+  })),
+  activateVersion: async (pipelineDefinitionId, version, options) => unwrap(await pipelineDefinitions.activatePipelineDefinitionVersion({
+    path: { pipelineDefinitionId, version },
+    headers: options?.headers
+  })),
+  listVersions: async (pipelineDefinitionId, options) => unwrap(await pipelineDefinitions.listPipelineDefinitionVersions({
+    path: { pipelineDefinitionId },
+    headers: options?.headers
+  })),
+  getVersion: async (pipelineDefinitionId, version, options) => unwrap(await pipelineDefinitions.getPipelineDefinitionVersion({
+    path: { pipelineDefinitionId, version },
+    headers: options?.headers
+  }))
+});
+// src/definitions/pipelines/work-item-fields.ts
+var WORK_ITEM_TOP_LEVEL_FIELDS2 = [
+  "id",
+  "projectId",
+  "platform",
+  "platformId",
+  "platformKey",
+  "url",
+  "title",
+  "description",
+  "sourceCreatedAt",
+  "sourceUpdatedAt",
+  "createdByUserId",
+  "parentWorkItemId",
+  "createdAt",
+  "updatedAt"
+];
+var WORK_ITEM_FIELDS_PATH_PREFIX2 = "fields.";
+function resolveWorkItemFieldPath2(record, path) {
+  if (typeof record !== "object" || record === null)
+    return;
+  const asRecord = record;
+  if (path.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX2)) {
+    const fieldName = path.slice(WORK_ITEM_FIELDS_PATH_PREFIX2.length);
+    const fields = asRecord["fields"];
+    if (typeof fields !== "object" || fields === null)
+      return;
+    return fields[fieldName];
+  }
+  return asRecord[path];
+}
+
+// src/definitions/pipelines/define-default-pipeline-assignment.ts
+var DEFAULT_PIPELINE_ASSIGNMENT_FILENAME2 = "default-pipeline-assignment.ts";
+function makeLeaf(fact, path, operator, value) {
+  const condition = {
+    _tag: "leaf",
+    fact,
+    ...path ? { path } : {},
+    operator,
+    value
+  };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return {
+        _tag: "assignment_rule",
+        conditions: [condition],
+        mode: "all",
+        outcome
+      };
+    }
+  };
+}
+function makeFieldRef(fact, path) {
+  const untyped = {
+    eq: (v) => makeLeaf(fact, path, "equal", v),
+    ne: (v) => makeLeaf(fact, path, "notEqual", v),
+    gt: (v) => makeLeaf(fact, path, "greaterThan", v),
+    gte: (v) => makeLeaf(fact, path, "greaterThanInclusive", v),
+    lt: (v) => makeLeaf(fact, path, "lessThan", v),
+    lte: (v) => makeLeaf(fact, path, "lessThanInclusive", v),
+    in: (vs) => makeLeaf(fact, path, "in", vs),
+    notIn: (vs) => makeLeaf(fact, path, "notIn", vs),
+    contains: (v) => makeLeaf(fact, path, "contains", v),
+    doesNotContain: (v) => makeLeaf(fact, path, "doesNotContain", v)
+  };
+  return untyped;
+}
+function buildWorkItemAccessor() {
+  const accessor = {
+    field: (name) => makeFieldRef("workItem", `$.${WORK_ITEM_FIELDS_PATH_PREFIX2}${name}`)
+  };
+  for (const key of WORK_ITEM_TOP_LEVEL_FIELDS2) {
+    accessor[key] = makeFieldRef("workItem", `$.${key}`);
+  }
+  return accessor;
+}
+function makeAssign(pipeline) {
+  const key = typeof pipeline === "string" ? pipeline : pipeline.key;
+  if (typeof key !== "string" || key.length === 0) {
+    throw new Error("assign() requires a pipeline key or the value definePipeline() returns.");
+  }
+  return { _tag: "assign", pipelineKey: key };
+}
+function extractCondition(ref) {
+  return ref._condition;
+}
+function makeGroup(mode, refs) {
+  const conditions = refs.map(extractCondition);
+  const condition = { _tag: "group", mode, conditions };
+  return {
+    _condition: condition,
+    then(outcome) {
+      return { _tag: "assignment_rule", conditions, mode, outcome };
+    }
+  };
+}
+function buildCtx() {
+  return {
+    workItem: buildWorkItemAccessor(),
+    context: {
+      isNew: makeFieldRef("context", "$.isNew")
+    },
+    assign: makeAssign,
+    skip: () => ({ _tag: "skip" }),
+    all: (...refs) => makeGroup("all", refs),
+    any: (...refs) => makeGroup("any", refs)
+  };
+}
+function defaultPipelineAssignment2(callback) {
+  const input = callback(buildCtx());
+  return {
+    _tag: "default_pipeline_assignment",
+    default: input.default,
+    rules: input.rules
+  };
+}
+function serializeConditionNode(condition) {
+  if (condition._tag === "leaf") {
+    return {
+      fact: condition.fact,
+      ...condition.path ? { path: condition.path } : {},
+      operator: condition.operator,
+      value: condition.value
+    };
+  }
+  if (condition.mode === "all") {
+    return { all: condition.conditions.map(serializeConditionNode) };
+  }
+  return { any: condition.conditions.map(serializeConditionNode) };
+}
+function serializeOutcome(outcome) {
+  if (outcome._tag === "skip")
+    return { type: "skip", params: null };
+  return { type: "assign", params: { pipelineKey: outcome.pipelineKey } };
+}
+function serializeAssignmentRule(rule) {
+  const { type, params } = serializeOutcome(rule.outcome);
+  return {
+    conditions: { [rule.mode]: rule.conditions.map(serializeConditionNode) },
+    event: { type, ...params ? { params } : {} }
+  };
+}
+function serializeDefaultPipelineAssignment2(spec) {
+  let primaryKey = null;
+  if (spec.default._tag === "assign") {
+    primaryKey = spec.default.pipelineKey;
+  } else {
+    for (const rule of spec.rules) {
+      if (rule.outcome._tag === "assign") {
+        primaryKey = rule.outcome.pipelineKey;
+        break;
+      }
+    }
+  }
+  if (primaryKey === null) {
+    throw new Error("defaultPipelineAssignment must contain at least one assign() outcome " + "(in `default` or in `rules`). A policy that only skips is not useful.");
+  }
+  const { type: defaultType, params: defaultParams } = serializeOutcome(spec.default);
+  const outcomeSet = new Set([defaultType]);
+  const serializedRules = spec.rules.map((rule) => {
+    outcomeSet.add(serializeOutcome(rule.outcome).type);
+    return serializeAssignmentRule(rule);
+  });
+  return {
+    pipelineDefinitionKey: primaryKey,
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultType,
+    defaultEventParamsJson: defaultParams,
+    allowedEventTypes: [...outcomeSet]
+  };
+}
+function isDefaultPipelineAssignmentSpec2(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  return value["_tag"] === "default_pipeline_assignment";
+}
+export { PipelineDefinitionsApiError2, createPipelineDefinitionsClient2, WORK_ITEM_TOP_LEVEL_FIELDS2, WORK_ITEM_FIELDS_PATH_PREFIX2, resolveWorkItemFieldPath2, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME2, defaultPipelineAssignment2, serializeDefaultPipelineAssignment2, isDefaultPipelineAssignmentSpec2 };