@boboddy/sdk 0.2.10-alpha → 0.2.13-alpha

package/dist/index.js

@@ -16057,7 +16057,8 @@ ${feature._promptAddition}` : feature._promptAddition;
       }))
     ],
     opencodeMcpJson: config2.mcpServers ?? null,
-    opencodePluginJson: config2.plugins ?? null
+    opencodePluginJson: config2.plugins ?? null,
+    healthChecksJson: config2.healthChecks ?? null
   };
   return spec;
 }
@@ -17186,7 +17187,6 @@ var parseServices = (raw) => {
     return [];
   return Object.entries(raw).map(([name, entry]) => {
     const expose = entry.expose ?? {};
-    const healthcheck = entry.healthcheck ?? {};
     const dependsOn = Array.isArray(entry.dependsOn) ? entry.dependsOn.filter((d) => typeof d === "string") : [];
     return {
       name,
@@ -17197,11 +17197,6 @@ var parseServices = (raw) => {
       expose: {
         targetPort: asNumber(expose.targetPort) ?? 0,
         protocol: asString(expose.protocol) ?? "http"
-      },
-      healthcheck: {
-        protocol: asString(healthcheck.protocol) ?? "http",
-        path: asString(healthcheck.path) ?? null,
-        expectedStatus: asNumber(healthcheck.expectedStatus) ?? null
       }
     };
   });

package/dist/push/collect-definitions.d.ts

@@ -0,0 +1,21 @@
+import type { PipelineDefinitionSpec } from "../definitions/pipelines";
+import { type DefaultPipelineAssignmentSpec } from "../definitions/pipelines/define-default-pipeline-assignment";
+import type { StepDefinitionSpec } from "../definitions/steps";
+export type CollectedDefinitions = {
+    readonly pipelines: readonly PipelineDefinitionSpec[];
+    /** Deduped by `key@vN`; named exports take precedence over embedded steps. */
+    readonly steps: readonly StepDefinitionSpec[];
+    /** Present only when `default-pipeline-assignment.ts` exists in the directory. */
+    readonly defaultPipelineAssignment: DefaultPipelineAssignmentSpec | null;
+};
+/**
+ * Imports every `.ts`/`.js` file in `dir` (except the push script itself and
+ * `default-pipeline-assignment.ts`) and collects the pipeline and step
+ * definitions they export. The assignment file, when present, is imported and
+ * validated too but returned separately — syncing it needs the server.
+ *
+ * Designed to run on the user's native runtime (bun, node-with-tsx, deno), NOT
+ * inside a `bun --compile`'d binary — that runtime can't resolve scoped package
+ * `exports` field remappings from external user files.
+ */
+export declare function collectDefinitionsFromDirectory(dir: string): Promise<CollectedDefinitions>;

package/dist/push/index.d.ts

@@ -1,2 +1,4 @@
+export { collectDefinitionsFromDirectory } from "./collect-definitions";
+export type { CollectedDefinitions } from "./collect-definitions";
 export { pushFromDirectory } from "./push-from-directory";
 export type { PushFromDirectoryOptions, PushFromDirectoryResult, } from "./push-from-directory";

package/dist/push/index.js

@@ -12075,7 +12075,8 @@ ${feature._promptAddition}` : feature._promptAddition;
       }))
     ],
     opencodeMcpJson: config2.mcpServers ?? null,
-    opencodePluginJson: config2.plugins ?? null
+    opencodePluginJson: config2.plugins ?? null,
+    healthChecksJson: config2.healthChecks ?? null
   };
   return spec;
 }
@@ -16784,10 +16785,428 @@ function isDefaultPipelineAssignmentSpec(value) {
     return false;
   return value["_tag"] === "default_pipeline_assignment";
 }
-// src/push/push-from-directory.ts
+// src/definitions/validation/json-schema-paths.ts
+var SEGMENT_PATTERN = /([^.[\]]+)|(\[(\d+)\])/g;
+var NUMERIC_SEGMENT = /^\d+$/;
+var SCALAR_TYPES = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null"
+]);
+var MAX_REF_HOPS = 16;
+var MAX_CANDIDATES = 64;
+function parseSourcePath(sourcePath) {
+  const trimmed = sourcePath.trim();
+  const normalized = trimmed === "$" ? "" : trimmed.startsWith("$.") ? trimmed.slice(2) : trimmed;
+  if (!normalized)
+    return [];
+  return [...normalized.matchAll(SEGMENT_PATTERN)].map((match) => match[1] ?? match[3]).filter((segment) => Boolean(segment));
+}
+function isSchemaNode(value) {
+  return typeof value === "boolean" || typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(node) {
+  return typeof node === "boolean" ? null : node;
+}
+function resolveRef2(root, ref) {
+  if (!ref.startsWith("#"))
+    return null;
+  const pointer = ref.slice(1);
+  if (pointer === "" || pointer === "/")
+    return root;
+  if (!pointer.startsWith("/"))
+    return null;
+  let current = root;
+  for (const rawToken of pointer.slice(1).split("/")) {
+    const token = rawToken.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (typeof current !== "object" || current === null)
+      return null;
+    current = current[token];
+  }
+  return isSchemaNode(current) ? current : null;
+}
+function flatten(node, root) {
+  const out = [];
+  const queue = [
+    { node, hops: 0 }
+  ];
+  while (queue.length > 0) {
+    const entry = queue.shift();
+    if (!entry)
+      break;
+    if (out.length >= MAX_CANDIDATES)
+      return null;
+    if (entry.hops > MAX_REF_HOPS)
+      return null;
+    const record2 = asRecord(entry.node);
+    if (!record2) {
+      out.push(entry.node);
+      continue;
+    }
+    const ref = record2["$ref"];
+    if (typeof ref === "string") {
+      const target = resolveRef2(root, ref);
+      if (!target)
+        return null;
+      queue.push({ node: target, hops: entry.hops + 1 });
+      continue;
+    }
+    const branches = ["anyOf", "oneOf", "allOf"].flatMap((keyword) => {
+      const value = record2[keyword];
+      return Array.isArray(value) ? value.filter(isSchemaNode) : [];
+    });
+    if (branches.length > 0) {
+      for (const branch of branches) {
+        queue.push({ node: branch, hops: entry.hops + 1 });
+      }
+      continue;
+    }
+    out.push(entry.node);
+  }
+  return out;
+}
+function typeNames(record2) {
+  const raw = record2["type"];
+  if (typeof raw === "string")
+    return new Set([raw]);
+  if (Array.isArray(raw)) {
+    return new Set(raw.filter((entry) => typeof entry === "string"));
+  }
+  return new Set;
+}
+var INDETERMINATE = { kind: "indeterminate" };
+function stepIntoObject(record2, segment) {
+  const properties = asRecord(isSchemaNode(record2["properties"]) ? record2["properties"] : {});
+  const declared = properties ?? {};
+  const child = declared[segment];
+  if (isSchemaNode(child))
+    return { kind: "child", node: child };
+  if (record2["patternProperties"] !== undefined)
+    return INDETERMINATE;
+  if (record2["additionalProperties"] !== false)
+    return INDETERMINATE;
+  return {
+    kind: "invalid",
+    reason: "unknown-property",
+    availablePaths: Object.keys(declared).sort()
+  };
+}
+function stepIntoArray(record2, segment) {
+  if (!NUMERIC_SEGMENT.test(segment)) {
+    return {
+      kind: "invalid",
+      reason: "not-an-array-index",
+      availablePaths: []
+    };
+  }
+  const prefixItems = record2["prefixItems"];
+  if (Array.isArray(prefixItems)) {
+    const positional = prefixItems[Number(segment)];
+    if (isSchemaNode(positional))
+      return { kind: "child", node: positional };
+  }
+  const items = record2["items"];
+  if (isSchemaNode(items))
+    return { kind: "child", node: items };
+  return INDETERMINATE;
+}
+function stepInto(node, segment) {
+  const record2 = asRecord(node);
+  if (!record2 || Object.keys(record2).length === 0)
+    return INDETERMINATE;
+  const types = typeNames(record2);
+  const objectLike = types.has("object") || record2["properties"] !== undefined || record2["patternProperties"] !== undefined || record2["additionalProperties"] !== undefined;
+  const arrayLike = types.has("array") || record2["items"] !== undefined || record2["prefixItems"] !== undefined;
+  const outcomes = [];
+  if (objectLike)
+    outcomes.push(stepIntoObject(record2, segment));
+  if (arrayLike)
+    outcomes.push(stepIntoArray(record2, segment));
+  if (outcomes.length === 0) {
+    if (types.size > 0 && [...types].every((name) => SCALAR_TYPES.has(name))) {
+      return {
+        kind: "invalid",
+        reason: "scalar-has-no-members",
+        availablePaths: []
+      };
+    }
+    return INDETERMINATE;
+  }
+  return combine(outcomes);
+}
+function combine(outcomes) {
+  const children = outcomes.filter((outcome) => outcome.kind === "child");
+  if (children.length > 0)
+    return children[0] ?? INDETERMINATE;
+  if (outcomes.some((outcome) => outcome.kind === "indeterminate")) {
+    return INDETERMINATE;
+  }
+  const invalid = outcomes.filter((outcome) => outcome.kind === "invalid");
+  const first = invalid[0];
+  if (!first)
+    return INDETERMINATE;
+  return {
+    kind: "invalid",
+    reason: first.reason,
+    availablePaths: [
+      ...new Set(invalid.flatMap((outcome) => outcome.availablePaths))
+    ].sort()
+  };
+}
+function enumeratePaths(node, root, maxDepth = 3, limit = 40) {
+  const out = [];
+  const visit = (current, prefix, depth) => {
+    if (out.length >= limit || depth > maxDepth)
+      return;
+    for (const branch of flatten(current, root) ?? []) {
+      const record2 = asRecord(branch);
+      const properties = record2 ? asRecord(isSchemaNode(record2["properties"]) ? record2["properties"] : {}) : null;
+      if (!properties)
+        continue;
+      for (const [key, child] of Object.entries(properties)) {
+        if (out.length >= limit)
+          return;
+        const path = prefix ? `${prefix}.${key}` : key;
+        out.push(path);
+        if (isSchemaNode(child))
+          visit(child, path, depth + 1);
+      }
+    }
+  };
+  visit(node, "", 1);
+  return [...new Set(out)].sort();
+}
+function resolveSourcePath(schema, sourcePath) {
+  const segments = parseSourcePath(sourcePath);
+  if (segments.length === 0)
+    return { kind: "resolved" };
+  let candidates = [schema];
+  let resolvedPrefix = "";
+  for (const segment of segments) {
+    const expanded = candidates.flatMap((node) => flatten(node, schema) ?? []);
+    if (expanded.length === 0)
+      return { kind: "indeterminate" };
+    const outcome = combine(expanded.map((node) => stepInto(node, segment)));
+    if (outcome.kind === "indeterminate")
+      return { kind: "indeterminate" };
+    if (outcome.kind === "invalid") {
+      const availablePaths = [
+        ...new Set(expanded.flatMap((node) => enumeratePaths(node, schema)))
+      ].sort();
+      return {
+        kind: "invalid",
+        resolvedPrefix,
+        segment,
+        reason: outcome.reason,
+        availablePaths
+      };
+    }
+    candidates = [outcome.node];
+    resolvedPrefix = resolvedPrefix ? `${resolvedPrefix}.${segment}` : segment;
+  }
+  return { kind: "resolved" };
+}
+// src/definitions/validation/validate-definition-specs.ts
+function listPaths(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)`;
+}
+function quotedOrRoot(prefix) {
+  return prefix ? `"${prefix}"` : "the result root";
+}
+function checkSignalSourcePaths(steps) {
+  const issues = [];
+  for (const step of steps) {
+    const schema = step.resultSchemaJson ?? null;
+    if (!schema)
+      continue;
+    for (const signal2 of step.signalExtractorDefinitions) {
+      const resolution = resolveSourcePath(schema, signal2.sourcePath);
+      if (resolution.kind !== "invalid")
+        continue;
+      const { resolvedPrefix, segment, reason, availablePaths } = resolution;
+      const cause = reason === "not-an-array-index" ? `${quotedOrRoot(resolvedPrefix)} is an array, so "${segment}" can never index it \u2014 array segments must be numeric (e.g. "${resolvedPrefix}[0]")` : reason === "scalar-has-no-members" ? `${quotedOrRoot(resolvedPrefix)} is a scalar, so it has no property "${segment}"` : `${quotedOrRoot(resolvedPrefix)} has no property "${segment}"`;
+      const suffix = availablePaths.length > 0 ? ` Valid sourcePaths ${resolvedPrefix ? `under "${resolvedPrefix}"` : "for this step"}: ${listPaths(availablePaths)}.` : "";
+      issues.push({
+        check: "signal-source-path",
+        message: `Step "${step.key}" declares signal "${signal2.key}" with sourcePath ` + `"${signal2.sourcePath}", which can never resolve against the step's ` + `result schema: ${cause}.${suffix}`
+      });
+    }
+  }
+  return issues;
+}
+function checkHealthChecks(steps) {
+  const issues = [];
+  for (const step of steps) {
+    const checks3 = step.healthChecksJson ?? [];
+    if (checks3.length === 0)
+      continue;
+    const mcpServerKeys = Object.keys(step.opencodeMcpJson ?? {});
+    const mcpServerKeySet = new Set(mcpServerKeys);
+    checks3.forEach((check2, index) => {
+      const label = check2.name ?? check2.tool;
+      const where = `Step "${step.key}" health check #${String(index + 1)} ("${label}")`;
+      if (!check2.mcp)
+        return;
+      if (!mcpServerKeySet.has(check2.mcp)) {
+        issues.push({
+          check: "health-check-mcp-server",
+          message: `${where} names MCP server "${check2.mcp}", but the step declares no ` + `such server in mcpServers. Declared servers: ${mcpServerKeys.length > 0 ? listPaths([...mcpServerKeys].sort()) : "(none)"}.`
+        });
+      }
+      const prefix = `${check2.mcp}_`;
+      if (check2.tool.startsWith(prefix)) {
+        issues.push({
+          check: "health-check-double-qualified",
+          message: `${where} sets mcp "${check2.mcp}" and tool "${check2.tool}", which already ` + `starts with "${prefix}". When "mcp" is set, "tool" should be the bare tool ` + `name \u2014 OpenCode resolves it to "${prefix}${check2.tool}". Did you mean ` + `tool: "${check2.tool.slice(prefix.length)}"?`
+        });
+      }
+    });
+  }
+  return issues;
+}
+function routeTargets(policy) {
+  const keys = [];
+  if (policy.defaultEventType === "route" && typeof policy.defaultEventParamsJson?.["pipelineKey"] === "string") {
+    keys.push(policy.defaultEventParamsJson["pipelineKey"]);
+  }
+  for (const rule of policy.rulesJson.rules) {
+    if (rule.event.type === "route" && typeof rule.event.params?.["pipelineKey"] === "string") {
+      keys.push(rule.event.params["pipelineKey"]);
+    }
+  }
+  return keys;
+}
+function checkRouteTargets(pipelines, knownPipelineKeys) {
+  const issues = [];
+  const known = new Set([
+    ...pipelines.map((pipeline2) => pipeline2.key),
+    ...knownPipelineKeys
+  ]);
+  for (const pipeline2 of pipelines) {
+    for (const step of pipeline2.steps) {
+      for (const target of routeTargets(step.advancementPolicyDefinition)) {
+        if (known.has(target))
+          continue;
+        issues.push({
+          check: "route-target",
+          message: `Pipeline "${pipeline2.key}" step "${step.stepKey}" routes to pipeline ` + `"${target}", but no pipeline with that key was found on the server or ` + `in the current push batch. Push the target pipeline first.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function executionRanks(steps) {
+  const positions = steps.map((step) => step.position);
+  const usable = positions.every((value) => Number.isInteger(value) && value > 0) && new Set(positions).size === positions.length;
+  const indexes = steps.map((_, index) => index);
+  const ordered = usable ? [...indexes].sort((left, right) => (positions[left] ?? 0) - (positions[right] ?? 0)) : indexes;
+  return new Map(ordered.map((index, rank) => [index, rank]));
+}
+function bindingSource(binding) {
+  if (binding.source === "step_signal") {
+    return { stepKey: binding.stepKey, signalKey: binding.signalKey };
+  }
+  if (binding.source === "step_output") {
+    return { stepKey: binding.stepKey, signalKey: null };
+  }
+  return null;
+}
+function declaredSignalKeys(stepKey, stepsByKey, pipelineSteps) {
+  const specs = stepsByKey.get(stepKey);
+  if (!specs || specs.length === 0)
+    return null;
+  const keys = new Set;
+  for (const spec of specs) {
+    for (const signal2 of spec.signalExtractorDefinitions)
+      keys.add(signal2.key);
+  }
+  for (const step of pipelineSteps) {
+    if (step.stepKey !== stepKey)
+      continue;
+    for (const computed of step.computedSignalDefinitions)
+      keys.add(computed.key);
+  }
+  return [...keys];
+}
+function checkSignalBindings(pipelines, stepsByKey) {
+  const issues = [];
+  for (const pipeline2 of pipelines) {
+    const ranks = executionRanks(pipeline2.steps);
+    const order = [...pipeline2.steps.keys()].sort((left, right) => (ranks.get(left) ?? 0) - (ranks.get(right) ?? 0)).map((index) => pipeline2.steps[index]?.stepKey ?? "");
+    const orderHint = `Steps in "${pipeline2.key}", in order: ${order.join(" \u2192 ")}.`;
+    pipeline2.steps.forEach((step, index) => {
+      const consumerRank = ranks.get(index) ?? index;
+      const where = `Pipeline "${pipeline2.key}" step "${step.stepKey}"`;
+      for (const [field, binding] of Object.entries(step.inputBindingsJson)) {
+        const source = bindingSource(binding);
+        if (!source)
+          continue;
+        const what = source.signalKey ? `binds input "${field}" to signal "${source.signalKey}" of step "${source.stepKey}"` : `binds input "${field}" to the output of step "${source.stepKey}"`;
+        const producerRanks = pipeline2.steps.map((candidate, candidateIndex) => candidate.stepKey === source.stepKey ? ranks.get(candidateIndex) ?? candidateIndex : null).filter((rank) => rank !== null);
+        if (producerRanks.length === 0) {
+          issues.push({
+            check: "signal-binding",
+            message: `${where} ${what}, but no step with that key is in the pipeline. ${orderHint}`
+          });
+          continue;
+        }
+        if (!producerRanks.some((rank) => rank < consumerRank)) {
+          issues.push({
+            check: "signal-binding",
+            message: `${where} ${what}, but that step does not run before it, so the ` + `value will never exist. ${orderHint}`
+          });
+          continue;
+        }
+        if (source.signalKey === null)
+          continue;
+        const available = declaredSignalKeys(source.stepKey, stepsByKey, pipeline2.steps);
+        if (available === null || available.includes(source.signalKey))
+          continue;
+        issues.push({
+          check: "signal-binding",
+          message: `${where} ${what}, but "${source.stepKey}" declares no such signal. ` + `Signals on "${source.stepKey}": ${available.length > 0 ? listPaths([...available].sort()) : "(none)"}.`
+        });
+      }
+    });
+  }
+  return issues;
+}
+function validateDefinitionSpecs(specs, options = {}) {
+  const stepsByKey = new Map;
+  for (const step of specs.steps) {
+    const existing = stepsByKey.get(step.key);
+    if (existing)
+      existing.push(step);
+    else
+      stepsByKey.set(step.key, [step]);
+  }
+  return [
+    ...checkSignalSourcePaths(specs.steps),
+    ...checkHealthChecks(specs.steps),
+    ...checkRouteTargets(specs.pipelines, options.knownPipelineKeys ?? []),
+    ...checkSignalBindings(specs.pipelines, stepsByKey)
+  ];
+}
+function assertValidDefinitionSpecs(specs, options = {}) {
+  const issues = validateDefinitionSpecs(specs, options);
+  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((issue2) => `  \u2022 ${issue2.message}`)].join(`
+`));
+}
+// src/push/collect-definitions.ts
 import { existsSync, readdirSync } from "fs";
 import { join, resolve } from "path";
 import { pathToFileURL } from "url";
+var PUSH_SCRIPT_NAMES = new Set(["push.ts", "push.mjs", "push.js"]);
 function isStepDefinitionSpec(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -16800,38 +17219,21 @@ function isPipelineDefinitionSpec(value) {
   const obj = value;
   return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && Array.isArray(obj["steps"]);
 }
-function extractRoutePipelineKeys(policy) {
-  const keys = [];
-  if (policy.defaultEventType === "route" && typeof policy.defaultEventParamsJson?.["pipelineKey"] === "string") {
-    keys.push(policy.defaultEventParamsJson["pipelineKey"]);
-  }
-  for (const rule of policy.rulesJson.rules) {
-    if (rule.event.type === "route" && typeof rule.event.params?.["pipelineKey"] === "string") {
-      keys.push(rule.event.params["pipelineKey"]);
-    }
-  }
-  return keys;
+async function importModule(path) {
+  return await import(pathToFileURL(path).href);
 }
-var PUSH_SCRIPT_NAMES = new Set(["push.ts", "push.mjs", "push.js"]);
-async function pushFromDirectory(dir, opts) {
-  const log = opts.log ?? ((msg) => {
-    console.warn(msg);
-  });
-  const headers = { Authorization: `Bearer ${opts.accessToken}` };
+async function collectDefinitionsFromDirectory(dir) {
   const absDir = resolve(dir);
-  const allFiles = readdirSync(absDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
-  const hasAssignmentFile = existsSync(join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME));
-  const sourceFiles = allFiles.filter((f) => !PUSH_SCRIPT_NAMES.has(f) && f !== DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
-  const pipelineSpecs = [];
+  const allFiles = readdirSync(absDir).filter((file2) => file2.endsWith(".ts") || file2.endsWith(".js"));
+  const sourceFiles = allFiles.filter((file2) => !PUSH_SCRIPT_NAMES.has(file2) && file2 !== DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
+  const pipelines = [];
   const stepMap = new Map;
   for (const file2 of sourceFiles) {
-    const absPath = join(absDir, file2);
-    const mod = await import(pathToFileURL(absPath).href);
+    const mod = await importModule(join(absDir, file2));
     for (const [exportName, value] of Object.entries(mod)) {
       if (exportName === "default") {
-        if (isPipelineDefinitionSpec(value)) {
-          pipelineSpecs.push(value);
-        }
+        if (isPipelineDefinitionSpec(value))
+          pipelines.push(value);
         continue;
       }
       if (isStepDefinitionSpec(value)) {
@@ -16839,38 +17241,48 @@ async function pushFromDirectory(dir, opts) {
       }
     }
   }
-  for (const spec of pipelineSpecs) {
+  for (const spec of pipelines) {
     for (const embedded of spec._stepDefinitions ?? []) {
       const key = `${embedded.key}@v${String(embedded.version)}`;
-      if (!stepMap.has(key)) {
+      if (!stepMap.has(key))
         stepMap.set(key, embedded);
-      }
     }
   }
-  log(`Found ${String(pipelineSpecs.length)} pipeline(s) and ${String(stepMap.size)} step(s).`);
+  return {
+    pipelines,
+    steps: [...stepMap.values()],
+    defaultPipelineAssignment: await collectDefaultPipelineAssignment(absDir)
+  };
+}
+async function collectDefaultPipelineAssignment(absDir) {
+  const path = join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
+  if (!existsSync(path))
+    return null;
+  const mod = await importModule(path);
+  const spec = mod["default"];
+  if (!isDefaultPipelineAssignmentSpec(spec)) {
+    throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} must have a default export produced by defaultPipelineAssignment(({ assign, skip, ... }) => ({ default: ..., rules: [...] })). Got: ${typeof spec}`);
+  }
+  return spec;
+}
+// src/push/push-from-directory.ts
+async function pushFromDirectory(dir, opts) {
+  const log = opts.log ?? ((msg) => {
+    console.warn(msg);
+  });
+  const headers = { Authorization: `Bearer ${opts.accessToken}` };
+  const collected = await collectDefinitionsFromDirectory(dir);
+  const { pipelines, steps } = collected;
+  log(`Found ${String(pipelines.length)} pipeline(s) and ${String(steps.length)} step(s).`);
   const stepsClient = createStepDefinitionsClient(opts.baseUrl);
-  for (const spec of stepMap.values()) {
+  const pipelinesClient = createPipelineDefinitionsClient(opts.baseUrl);
+  const serverPipelineKeys = pipelines.length > 0 ? (await pipelinesClient.listByProjectId(opts.projectId, { headers })).map((pipeline2) => pipeline2.key) : [];
+  assertValidDefinitionSpecs({ pipelines, steps }, { knownPipelineKeys: serverPipelineKeys });
+  for (const spec of steps) {
     await stepsClient.upsertFromSpec(opts.projectId, spec, { headers });
     log(`\u2713 step ${spec.key} v${String(spec.version)} \u2192 upserted`);
   }
-  const pipelinesClient = createPipelineDefinitionsClient(opts.baseUrl);
-  let pushedPipelinesCount = 0;
-  if (pipelineSpecs.length > 0) {
-    const existingPipelines = await pipelinesClient.listByProjectId(opts.projectId, { headers });
-    const knownPipelineKeys = new Set([
-      ...pipelineSpecs.map((s) => s.key),
-      ...existingPipelines.map((p) => p.key)
-    ]);
-    for (const spec of pipelineSpecs) {
-      for (const step of spec.steps) {
-        const routeKeys = extractRoutePipelineKeys(step.advancementPolicyDefinition);
-        for (const routeKey of routeKeys) {
-          if (!knownPipelineKeys.has(routeKey)) {
-            throw new Error(`Pipeline "${spec.key}" step "${step.stepKey}" routes to pipeline "${routeKey}", but no pipeline with that key was found on the server or in the current push batch. Push the target pipeline first.`);
-          }
-        }
-      }
-    }
+  if (pipelines.length > 0) {
     const serverSteps = await stepsClient.listByProjectId(opts.projectId, {
       headers
     });
@@ -16879,27 +17291,17 @@ async function pushFromDirectory(dir, opts) {
       key: s.key,
       version: s.version
     }));
-    for (const spec of pipelineSpecs) {
+    for (const spec of pipelines) {
       await pipelinesClient.upsertFromSpec(opts.projectId, spec, stepDefs, {
         headers
       });
       log(`\u2713 pipeline ${spec.key} v${String(spec.version)} \u2192 upserted`);
     }
-    pushedPipelinesCount = pipelineSpecs.length;
-  }
-  let syncedDefaultPipelineAssignment = false;
-  if (hasAssignmentFile) {
-    const assignmentFilePath = join(absDir, DEFAULT_PIPELINE_ASSIGNMENT_FILENAME);
-    const assignmentMod = await import(pathToFileURL(assignmentFilePath).href);
-    const assignmentSpec = assignmentMod["default"];
-    if (!isDefaultPipelineAssignmentSpec(assignmentSpec)) {
-      throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} must have a default export produced by defaultPipelineAssignment(({ assign, skip, ... }) => ({ default: ..., rules: [...] })). Got: ${typeof assignmentSpec}`);
-    }
-    syncedDefaultPipelineAssignment = await syncDefaultPipelineAssignment(assignmentSpec, opts, headers, pipelinesClient, log);
   }
+  const syncedDefaultPipelineAssignment = collected.defaultPipelineAssignment ? await syncDefaultPipelineAssignment(collected.defaultPipelineAssignment, opts, headers, pipelinesClient, log) : false;
   return {
-    pushedSteps: stepMap.size,
-    pushedPipelines: pushedPipelinesCount,
+    pushedSteps: steps.length,
+    pushedPipelines: pipelines.length,
     syncedDefaultPipelineAssignment
   };
 }
@@ -16921,7 +17323,7 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
   }
   for (const key of referencedKeys) {
     if (!pipelineKeyToId.has(key)) {
-      throw new Error(`default-pipeline-assignment.ts references pipeline "${key}", but no pipeline with that key was found on the server. Push the pipeline first with \`boboddy pipelines push\`.`);
+      throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} references pipeline "${key}", ` + `but no pipeline with that key was found on the server. ` + `Push the pipeline first with \`boboddy pipelines push\`.`);
     }
   }
   const linearPipelineDefinitionId = pipelineKeyToId.get(serialized.linearPipelineDefinitionKey);
@@ -16933,7 +17335,7 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
       const pKey = rule.event.params["pipelineKey"];
       const pId = pipelineKeyToId.get(pKey);
       if (!pId) {
-        throw new Error(`default-pipeline-assignment.ts assign() references pipeline "${pKey}" which was not found on the server.`);
+        throw new Error(`${DEFAULT_PIPELINE_ASSIGNMENT_FILENAME} assign() references pipeline "${pKey}" ` + `which was not found on the server.`);
       }
       return {
         ...rule,
@@ -16971,5 +17373,6 @@ async function syncDefaultPipelineAssignment(spec, opts, headers, pipelinesClien
   return true;
 }
 export {
-  pushFromDirectory
+  pushFromDirectory,
+  collectDefinitionsFromDirectory
 };