@treeseed/sdk 0.10.5 → 0.10.7

package/dist/reconcile/bootstrap-systems.js

@@ -5,7 +5,7 @@ const SYSTEM_DEPENDENCIES = {
   data: [],
   web: ["data"],
   api: ["data"],
-  agents: ["data"]
+  agents: []
 };
 function uniqueSystems(values) {
   return [...new Set(values)];
@@ -55,8 +55,8 @@ function agentsSystemDisabled(config) {
   if (config.runtime?.mode === "none") {
     return "runtime.mode is none.";
   }
-  const enabled = ["workdayManager", "workerRunner"].some((serviceKey) => serviceEnabled(config, serviceKey));
-  return enabled ? null : "No agent Railway services are enabled.";
+  const enabled = ["marketOperationsRunner", "workdayManager", "workerRunner"].some((serviceKey) => serviceEnabled(config, serviceKey));
+  return enabled ? null : "No agent or market operations runner Railway services are enabled.";
 }
 function hasValue(env, key) {
   return typeof env[key] === "string" && String(env[key]).trim().length > 0;

package/dist/reconcile/builtin-adapters.js

@@ -30,6 +30,7 @@ import {
 } from "../operations/services/deploy.js";
 import {
   configuredRailwayServices,
+  deriveRailwayMarketOperationsRunnerVolumeName,
   ensureRailwayProjectContext,
   runRailway,
   validateRailwayDeployPrerequisites
@@ -37,15 +38,19 @@ import {
 import { shouldExposeManagedHostRuntimeSecret } from "../operations/services/managed-host-security.js";
 import {
   ensureRailwayEnvironment,
+  ensureRailwayCustomDomain as ensureRailwayCustomDomainViaApi,
   ensureRailwayProject,
   ensureRailwayService,
   ensureRailwayServiceInstanceConfiguration,
+  ensureRailwayServiceVolume,
   getRailwayServiceInstance,
   getRailwayProject,
   listRailwayCustomDomains,
   listRailwayProjects,
+  listRailwayVolumes,
   listRailwayVariables,
   resolveRailwayWorkspaceContext,
+  updateRailwayServiceName,
   upsertRailwayVariables
 } from "../operations/services/railway-api.js";
 import { loadTreeseedReconcileState } from "./state.js";
@@ -93,6 +98,28 @@ function noopDiff() {
     after: {}
   };
 }
+function parseRailwayJsonPayload(output) {
+  const text = typeof output === "string" ? output.trim() : "";
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+  const lines = text.split(/\r?\n/u);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const candidate = lines.slice(index).join("\n").trim();
+    if (!candidate.startsWith("{") && !candidate.startsWith("[")) {
+      continue;
+    }
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
 function buildCompositeAdapter(unitType) {
   return {
     providerId: "treeseed",
@@ -169,10 +196,17 @@ function resolveReconcileEnvironmentValues(input, scope) {
   if (scope === "local") {
     return resolveTreeseedMachineEnvironmentValues(input.context.tenantRoot, scope);
   }
-  const values = {
+  const hostedRuntimeValues = {
     ...normalizeEnvironmentValues(process.env),
     ...normalizeEnvironmentValues(input.context.launchEnv)
   };
+  if (hostedRuntimeValues.CLOUDFLARE_API_TOKEN || hostedRuntimeValues.RAILWAY_API_TOKEN || hostedRuntimeValues.GH_TOKEN) {
+    return hostedRuntimeValues;
+  }
+  const values = {
+    ...resolveTreeseedMachineEnvironmentValues(input.context.tenantRoot, scope),
+    ...hostedRuntimeValues
+  };
   return values;
 }
 function buildCloudflareEnv(input) {
@@ -494,15 +528,15 @@ function normalizeRailwayDomainPayload(value) {
 }
 async function ensureRailwayCustomDomain(input, service, domain, env, identifiers) {
   if (identifiers?.projectId && identifiers?.environmentId && identifiers?.serviceId) {
-    const existing = await listRailwayCustomDomains({
+    const ensured = await ensureRailwayCustomDomainViaApi({
       projectId: identifiers.projectId,
       environmentId: identifiers.environmentId,
       serviceId: identifiers.serviceId,
+      domain,
       env
     });
-    const matched = existing.find((entry) => entry.domain === domain) ?? null;
-    if (matched) {
-      return matched;
+    if (ensured.domain) {
+      return ensured.domain;
     }
   }
   ensureRailwayProjectContext(service, { env, capture: true });
@@ -1399,6 +1433,9 @@ async function resolveRailwayTopologyForScope(input, scope, {
       if (!project) {
         continue;
       }
+      if (typeof project.deletedAt === "string" && project.deletedAt.trim()) {
+        continue;
+      }
       projectsByKey.set(project.id, project);
       projectsByKey.set(project.name, project);
     }
@@ -1512,31 +1549,58 @@ async function syncRailwayEnvironmentForScope(input, { dryRun = false } = {}) {
     includeInstances: !dryRun,
     includeVariables: false
   });
-  const workerEntry = topology.services.get("workerRunner") ?? topology.services.get("worker") ?? null;
-  const railwayRuntimeVariables = Object.fromEntries(
-    [
-      ["TREESEED_RAILWAY_PROJECT_ID", workerEntry?.project?.id],
-      ["TREESEED_RAILWAY_ENVIRONMENT_ID", workerEntry?.environment?.id],
-      ["TREESEED_RAILWAY_WORKER_SERVICE_ID", workerEntry?.service?.id]
-    ].filter((entry) => typeof entry[1] === "string" && entry[1].length > 0)
-  );
   if (!dryRun) {
-    const combinedVariables = {
-      ...sync.variables,
-      ...railwayRuntimeVariables,
-      ...sync.secrets
-    };
+    await ensureRailwayMarketDatabaseForScope(input, topology);
     for (const entry of topology.services.values()) {
       if (!entry.project || !entry.environment || !entry.service) {
         continue;
       }
+      const serviceSync = sync.forService(entry.configuredService.key);
       await upsertRailwayVariables({
         projectId: entry.project.id,
         environmentId: entry.environment.id,
         serviceId: entry.service.id,
-        variables: combinedVariables,
+        variables: {
+          ...serviceSync.variables,
+          ...serviceSync.secrets
+        },
         env: topology.env
       });
+      if (entry.configuredService.volumeMountPath) {
+        const volumeName = entry.configuredService.key === "marketOperationsRunner" ? deriveRailwayMarketOperationsRunnerVolumeName(entry.service.name, entry.environment.name) : `${entry.service.name}-volume`;
+        const volume = await ensureRailwayServiceVolume({
+          projectId: entry.project.id,
+          environmentId: entry.environment.id,
+          serviceId: entry.service.id,
+          name: volumeName,
+          mountPath: entry.configuredService.volumeMountPath,
+          env: topology.env
+        });
+        if (!volume.instance?.serviceId) {
+          ensureRailwayProjectContext(entry.configuredService, { env: topology.env, capture: true });
+          const attachResult = runRailway([
+            "volume",
+            "--service",
+            entry.service.id,
+            "attach",
+            "--volume",
+            volume.volume.id,
+            "--yes",
+            "--json"
+          ], {
+            cwd: entry.configuredService.rootDir,
+            capture: true,
+            allowFailure: true,
+            env: topology.env
+          });
+          if ((attachResult.status ?? 1) !== 0) {
+            const attachMessage = attachResult.stderr?.trim() || attachResult.stdout?.trim() || "";
+            if (!/already mounted/iu.test(attachMessage)) {
+              throw new Error(attachMessage || `Railway volume attach failed for ${entry.service.name}.`);
+            }
+          }
+        }
+      }
     }
   }
   return {
@@ -1548,6 +1612,62 @@ async function syncRailwayEnvironmentForScope(input, { dryRun = false } = {}) {
     workspace: topology.workspace.name
   };
 }
+async function ensureRailwayMarketDatabaseForScope(input, topology) {
+  const marketDatabaseService = input.context.deployConfig.services?.marketDatabase;
+  if (!marketDatabaseService || marketDatabaseService.enabled === false || marketDatabaseService.provider !== "railway" || marketDatabaseService.railway?.resourceType !== "postgres") {
+    return;
+  }
+  const firstService = [...topology.services.values()].find((entry) => entry.project && entry.environment);
+  if (!firstService?.project || !firstService.environment) {
+    return;
+  }
+  const baseName = typeof marketDatabaseService.railway?.serviceName === "string" && marketDatabaseService.railway.serviceName.trim() ? marketDatabaseService.railway.serviceName.trim() : `${input.context.deployConfig.slug ?? "treeseed-market"}-postgres`;
+  const serviceName = `${baseName.replace(/-(staging|prod|production)$/u, "")}-${topology.scope === "prod" ? "prod" : topology.scope}`;
+  let postgresService = firstService.project.services.find((entry) => entry.name === serviceName || entry.id === serviceName) ?? null;
+  if (!postgresService) {
+    ensureRailwayProjectContext(firstService.configuredService, { env: topology.env, capture: true });
+    const addResult = runRailway(["add", "--database", "postgres", "--json"], {
+      cwd: firstService.configuredService.rootDir,
+      capture: true,
+      allowFailure: true,
+      env: topology.env
+    });
+    if ((addResult.status ?? 1) !== 0) {
+      throw new Error(addResult.stderr?.trim() || addResult.stdout?.trim() || `Railway database provisioning failed for ${serviceName}.`);
+    }
+    const payload = parseRailwayJsonPayload(addResult.stdout);
+    const createdServiceId = typeof payload?.serviceId === "string" && payload.serviceId.trim() ? payload.serviceId.trim() : "";
+    if (!createdServiceId) {
+      throw new Error(`Railway database provisioning did not return a service id for ${serviceName}.`);
+    }
+    postgresService = await updateRailwayServiceName({
+      serviceId: createdServiceId,
+      name: serviceName,
+      env: topology.env
+    });
+  }
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const existingVolumes = await listRailwayVolumes({
+      projectId: firstService.project.id,
+      env: topology.env
+    });
+    const attached = existingVolumes.some((volume) => volume.instances.some(
+      (instance) => instance.serviceId === postgresService.id && instance.environmentId === firstService.environment?.id && instance.mountPath === "/var/lib/postgresql/data"
+    ));
+    if (attached) {
+      break;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 1500));
+  }
+  await ensureRailwayServiceVolume({
+    projectId: firstService.project.id,
+    environmentId: firstService.environment.id,
+    serviceId: postgresService.id,
+    name: `postgres-${topology.scope === "prod" ? "prod" : topology.scope}-data`,
+    mountPath: "/var/lib/postgresql/data",
+    env: topology.env
+  });
+}
 async function observeRailwayUnit(input, { refresh = false } = {}) {
   let attempt = 0;
   for (; ; ) {
@@ -1600,17 +1720,27 @@ function collectRailwayEnvironmentSync(input) {
   const values = resolveReconcileEnvironmentValues(input, scope);
   const registry = collectTreeseedEnvironmentContext(input.context.tenantRoot);
   const state = loadDeployState(input.context.tenantRoot, input.context.deployConfig, { target: toDeployTarget(input.context.target) });
-  const secrets = Object.fromEntries(
-    registry.entries.filter((entry) => entry.scopes.includes(scope) && entry.targets.includes("railway-secret") && shouldExposeManagedHostRuntimeSecret(input.context.deployConfig, entry.id)).map((entry) => [entry.id, values[entry.id]]).filter(([, value]) => typeof value === "string" && value.length > 0)
-  );
-  const variables = Object.fromEntries(
-    registry.entries.filter((entry) => entry.scopes.includes(scope) && entry.targets.includes("railway-var")).map((entry) => [entry.id, values[entry.id]]).filter(([, value]) => typeof value === "string" && value.length > 0)
-  );
+  const serviceTargetsEntry = (entry, serviceKey) => {
+    const targets = Array.isArray(entry.serviceTargets) ? entry.serviceTargets.map((value) => String(value).trim()).filter(Boolean) : [];
+    return targets.length === 0 || targets.includes(serviceKey);
+  };
+  const entriesForService = (target, serviceKey) => registry.entries.filter((entry) => entry.scopes.includes(scope) && entry.targets.includes(target) && serviceTargetsEntry(entry, serviceKey) && (target !== "railway-secret" || shouldExposeManagedHostRuntimeSecret(input.context.deployConfig, entry.id))).map((entry) => [entry.id, values[entry.id]]).filter(([, value]) => typeof value === "string" && value.length > 0);
+  const aggregateEntries = (target) => registry.entries.filter((entry) => entry.scopes.includes(scope) && entry.targets.includes(target) && (target !== "railway-secret" || shouldExposeManagedHostRuntimeSecret(input.context.deployConfig, entry.id))).map((entry) => [entry.id, values[entry.id]]).filter(([, value]) => typeof value === "string" && value.length > 0);
+  const secrets = Object.fromEntries(aggregateEntries("railway-secret"));
+  const variables = Object.fromEntries(aggregateEntries("railway-var"));
+  const apiOnlySecrets = {};
+  const apiOnlyVariables = {};
+  const marketDatabaseService = input.context.deployConfig.services?.marketDatabase;
+  const marketDatabaseBaseName = typeof marketDatabaseService?.railway?.serviceName === "string" && marketDatabaseService.railway.serviceName.trim() ? marketDatabaseService.railway.serviceName.trim() : `${input.context.deployConfig.slug ?? "treeseed-market"}-postgres`;
+  const marketDatabaseServiceName = `${marketDatabaseBaseName.replace(/-(staging|prod|production)$/u, "")}-${scope === "prod" ? "prod" : scope}`;
+  const marketDatabaseUrl = typeof values.TREESEED_MARKET_DATABASE_URL === "string" && values.TREESEED_MARKET_DATABASE_URL.length > 0 ? values.TREESEED_MARKET_DATABASE_URL : marketDatabaseService?.enabled !== false && marketDatabaseService?.provider === "railway" ? `\${{${marketDatabaseServiceName}.DATABASE_URL}}` : "";
   if (typeof values.CLOUDFLARE_API_TOKEN === "string" && values.CLOUDFLARE_API_TOKEN.length > 0 && shouldExposeManagedHostRuntimeSecret(input.context.deployConfig, "CLOUDFLARE_API_TOKEN")) {
     secrets.CLOUDFLARE_API_TOKEN = values.CLOUDFLARE_API_TOKEN;
+    apiOnlySecrets.CLOUDFLARE_API_TOKEN = values.CLOUDFLARE_API_TOKEN;
   }
   if (typeof values.CLOUDFLARE_ACCOUNT_ID === "string" && values.CLOUDFLARE_ACCOUNT_ID.length > 0) {
     variables.CLOUDFLARE_ACCOUNT_ID = values.CLOUDFLARE_ACCOUNT_ID;
+    apiOnlyVariables.CLOUDFLARE_ACCOUNT_ID = values.CLOUDFLARE_ACCOUNT_ID;
   }
   const siteDataDb = state.d1Databases?.SITE_DATA_DB;
   let apiD1DatabaseId = siteDataDb?.databaseId;
@@ -1620,8 +1750,29 @@ function collectRailwayEnvironmentSync(input) {
   }
   if (hasLiveResourceId(apiD1DatabaseId)) {
     variables.TREESEED_API_D1_DATABASE_ID = apiD1DatabaseId;
+    apiOnlyVariables.TREESEED_API_D1_DATABASE_ID = apiD1DatabaseId;
   }
-  return { scope, secrets, variables };
+  if (marketDatabaseUrl) {
+    secrets.TREESEED_MARKET_DATABASE_URL = marketDatabaseUrl;
+  }
+  return {
+    scope,
+    secrets,
+    variables,
+    forService(serviceKey) {
+      return {
+        secrets: {
+          ...Object.fromEntries(entriesForService("railway-secret", serviceKey)),
+          ...marketDatabaseUrl && ["api", "marketOperationsRunner"].includes(serviceKey) ? { TREESEED_MARKET_DATABASE_URL: marketDatabaseUrl } : {},
+          ...serviceKey === "api" ? apiOnlySecrets : {}
+        },
+        variables: {
+          ...Object.fromEntries(entriesForService("railway-var", serviceKey)),
+          ...serviceKey === "api" ? apiOnlyVariables : {}
+        }
+      };
+    }
+  };
 }
 function buildAttachmentDiff(input, observed) {
   if (!observed.exists) {
@@ -1943,7 +2094,7 @@ async function verifyRailwayUnit(input) {
           })
         ]);
       }
-      const sync = collectRailwayEnvironmentSync(input);
+      const sync = collectRailwayEnvironmentSync(input).forService(serviceKey);
       const checks = [
         verificationCheck("railway.workspace", "Railway workspace is resolved", "api", {
           exists: Boolean(topology.workspace.id),
@@ -1977,12 +2128,13 @@ async function verifyRailwayUnit(input) {
         })
       ];
       if (service.startCommand) {
+        const startCommandMatches = railwayStartCommandMatches(serviceKey, entry.instance?.startCommand, service.startCommand);
         checks.push(verificationCheck("railway.instance.start-command", "Railway start command matches desired config", "api", {
           exists: Boolean(entry.instance?.id),
-          configured: entry.instance?.startCommand === service.startCommand,
+          configured: startCommandMatches,
           expected: service.startCommand,
           observed: entry.instance?.startCommand ?? null,
-          issues: entry.instance?.startCommand === service.startCommand ? [] : ["Railway start command does not match the desired value."]
+          issues: startCommandMatches ? [] : ["Railway start command does not match the desired value."]
         }));
       }
       const desiredRootDirectory = relativeRailwayRootDir(input.context.tenantRoot, service.rootDir);
@@ -2050,6 +2202,24 @@ async function verifyRailwayUnit(input) {
           }));
         }
       }
+      if (service.volumeMountPath) {
+        const volumes = entry.project?.id ? await listRailwayVolumes({ projectId: entry.project.id, env: topology.env }) : [];
+        const expectedServiceId = entry.service?.id ?? null;
+        const expectedEnvironmentId = entry.environment?.id ?? null;
+        const mountedVolume = volumes.find((volume) => volume.instances.some(
+          (instance) => instance.serviceId === expectedServiceId && instance.environmentId === expectedEnvironmentId && instance.mountPath === service.volumeMountPath
+        )) ?? null;
+        checks.push(verificationCheck("railway.volume:data", "Railway service has persistent data volume mounted", "api", {
+          exists: Boolean(mountedVolume),
+          configured: Boolean(mountedVolume),
+          expected: service.volumeMountPath,
+          observed: mountedVolume ? {
+            name: mountedVolume.name,
+            mountPath: service.volumeMountPath
+          } : null,
+          issues: mountedVolume ? [] : [`Railway service ${service.serviceName ?? service.key} is missing a persistent volume mounted at ${service.volumeMountPath}.`]
+        }));
+      }
       for (const [key, value] of Object.entries(sync.variables)) {
         checks.push(verificationCheck(`railway.var:${key}`, `Railway variable ${key} exists with the expected value`, "api", {
           exists: Object.hasOwn(entry.currentVariables, key),
@@ -2077,6 +2247,30 @@ async function verifyRailwayUnit(input) {
     }
   }
 }
+function railwayStartCommandMatches(serviceKey, observed, expected) {
+  if (observed === expected) {
+    return true;
+  }
+  if (serviceKey !== "marketOperationsRunner") {
+    return false;
+  }
+  const normalizedObserved = String(observed ?? "").trim().replace(/\s+/gu, " ");
+  const normalizedExpected = String(expected ?? "").trim().replace(/\s+/gu, " ");
+  if (normalizedObserved === normalizedExpected) {
+    return true;
+  }
+  const allowedInlineEnv = [
+    "TREESEED_MARKET_ID",
+    "TREESEED_PLATFORM_RUNNER_ID",
+    "TREESEED_PLATFORM_RUNNER_DATA_DIR",
+    "TREESEED_PLATFORM_RUNNER_ENVIRONMENT"
+  ];
+  let remainder = normalizedObserved;
+  for (const key of allowedInlineEnv) {
+    remainder = remainder.replace(new RegExp(`^${key}=[^\\s]+\\s+`, "u"), "");
+  }
+  return remainder === normalizedExpected;
+}
 function buildRailwayDiff(input, observed) {
   if (!observed.exists) {
     return {
@@ -2230,10 +2424,12 @@ function createCloudflareReconcileAdapters() {
 function createRailwayReconcileAdapters() {
   return [
     buildRailwayAdapter("railway-service:api"),
+    buildRailwayAdapter("railway-service:market-operations-runner"),
     buildRailwayAdapter("railway-service:workday-manager"),
     buildRailwayAdapter("railway-service:worker-runner"),
     buildCustomDomainAdapter("custom-domain:api", "railway"),
     buildCompositeAdapter("api-runtime"),
+    buildCompositeAdapter("market-operations-runner-runtime"),
     buildCompositeAdapter("workday-manager-runtime"),
     buildCompositeAdapter("worker-runner-runtime")
   ];

package/dist/reconcile/contracts.d.ts

@@ -3,7 +3,7 @@ export type TreeseedReconcileProviderId = string;
 export type TreeseedReconcileActionKind = 'noop' | 'create' | 'update' | 'reuse' | 'drift_correct' | 'destroy';
 export type TreeseedReconcileStatusKind = 'pending' | 'ready' | 'drifted' | 'error';
 export type TreeseedReconcileVerificationSource = 'cli' | 'api' | 'sdk' | 'derived';
-export type TreeseedReconcileUnitType = 'web-ui' | 'api-runtime' | 'workday-manager-runtime' | 'worker-runner-runtime' | 'edge-worker' | 'content-store' | 'queue' | 'database' | 'kv-form-guard' | 'pages-project' | 'custom-domain:web' | 'custom-domain:api' | 'dns-record' | 'railway-service:api' | 'railway-service:workday-manager' | 'railway-service:worker-runner';
+export type TreeseedReconcileUnitType = 'web-ui' | 'api-runtime' | 'market-operations-runner-runtime' | 'workday-manager-runtime' | 'worker-runner-runtime' | 'edge-worker' | 'content-store' | 'queue' | 'database' | 'kv-form-guard' | 'pages-project' | 'custom-domain:web' | 'custom-domain:api' | 'dns-record' | 'railway-service:api' | 'railway-service:market-operations-runner' | 'railway-service:workday-manager' | 'railway-service:worker-runner';
 export type TreeseedReconcileTarget = {
     kind: 'persistent';
     scope: 'local' | 'staging' | 'prod';

package/dist/reconcile/desired-state.d.ts

@@ -149,9 +149,23 @@ export declare function deriveTreeseedDesiredUnits({ tenantRoot, target, }: {
                     projectName: string | undefined;
                     serviceId: string | undefined;
                     serviceName: string | undefined;
+                    resourceType: string | undefined;
+                    environmentVariable: string | undefined;
+                    serviceTargets: any;
                     rootDir: string | undefined;
                     buildCommand: string | undefined;
                     startCommand: string | undefined;
+                    healthcheckPath: string | undefined;
+                    healthcheckTimeoutSeconds: number | undefined;
+                    healthcheckIntervalSeconds: number | undefined;
+                    restartPolicy: string | undefined;
+                    runtimeMode: string | undefined;
+                    volumeMountPath: string | undefined;
+                    runnerPool: {
+                        bootstrapCount: number | undefined;
+                        maxRunners: number | undefined;
+                        volumeMountPath: string | undefined;
+                    } | undefined;
                     schedule: any;
                 };
                 environments: {

package/dist/reconcile/desired-state.js

@@ -11,6 +11,8 @@ function railwayConcreteUnitTypeForServiceKey(serviceKey) {
   switch (serviceKey) {
     case "api":
       return "railway-service:api";
+    case "marketOperationsRunner":
+      return "railway-service:market-operations-runner";
     case "workdayManager":
       return "railway-service:workday-manager";
     case "workerRunner":
@@ -266,6 +268,8 @@ function deriveTreeseedDesiredUnits({
       switch (serviceKey) {
         case "api":
           return "api-runtime";
+        case "marketOperationsRunner":
+          return "market-operations-runner-runtime";
         case "workdayManager":
           return "workday-manager-runtime";
         case "workerRunner":

package/dist/reconcile/engine.d.ts

@@ -156,9 +156,23 @@ export declare function observeTreeseedUnits({ tenantRoot, target, env, systems,
                     projectName: string | undefined;
                     serviceId: string | undefined;
                     serviceName: string | undefined;
+                    resourceType: string | undefined;
+                    environmentVariable: string | undefined;
+                    serviceTargets: any;
                     rootDir: string | undefined;
                     buildCommand: string | undefined;
                     startCommand: string | undefined;
+                    healthcheckPath: string | undefined;
+                    healthcheckTimeoutSeconds: number | undefined;
+                    healthcheckIntervalSeconds: number | undefined;
+                    restartPolicy: string | undefined;
+                    runtimeMode: string | undefined;
+                    volumeMountPath: string | undefined;
+                    runnerPool: {
+                        bootstrapCount: number | undefined;
+                        maxRunners: number | undefined;
+                        volumeMountPath: string | undefined;
+                    } | undefined;
                     schedule: any;
                 };
                 environments: {
@@ -345,9 +359,23 @@ export declare function planTreeseedReconciliation({ tenantRoot, target, env, sy
                     projectName: string | undefined;
                     serviceId: string | undefined;
                     serviceName: string | undefined;
+                    resourceType: string | undefined;
+                    environmentVariable: string | undefined;
+                    serviceTargets: any;
                     rootDir: string | undefined;
                     buildCommand: string | undefined;
                     startCommand: string | undefined;
+                    healthcheckPath: string | undefined;
+                    healthcheckTimeoutSeconds: number | undefined;
+                    healthcheckIntervalSeconds: number | undefined;
+                    restartPolicy: string | undefined;
+                    runtimeMode: string | undefined;
+                    volumeMountPath: string | undefined;
+                    runnerPool: {
+                        bootstrapCount: number | undefined;
+                        maxRunners: number | undefined;
+                        volumeMountPath: string | undefined;
+                    } | undefined;
                     schedule: any;
                 };
                 environments: {

package/dist/reconcile/state.js

@@ -6,6 +6,9 @@ function stableHash(value) {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function railwayUnitTypeForServiceKey(serviceKey) {
+  if (serviceKey === "marketOperationsRunner") {
+    return "railway-service:market-operations-runner";
+  }
   if (serviceKey === "workdayManager") {
     return "railway-service:workday-manager";
   }

package/dist/reconcile/units.js

@@ -1,6 +1,7 @@
 const TRESEED_RECONCILE_UNIT_TYPES = [
   "web-ui",
   "api-runtime",
+  "market-operations-runner-runtime",
   "workday-manager-runtime",
   "worker-runner-runtime",
   "edge-worker",
@@ -13,6 +14,7 @@ const TRESEED_RECONCILE_UNIT_TYPES = [
   "custom-domain:api",
   "dns-record",
   "railway-service:api",
+  "railway-service:market-operations-runner",
   "railway-service:workday-manager",
   "railway-service:worker-runner"
 ];

package/dist/workflow/operations.d.ts

@@ -871,16 +871,24 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
     mode: TreeseedWorkflowMode;
     mergeStrategy: string;
     level: string;
+    releaseLine: {
+        group: string[];
+        repair: boolean;
+        targetLine: string;
+        highestCurrentLine: string;
+        alignedBefore: boolean;
+    };
     rootVersion: string;
     releaseTag: string;
     stagingBranch: string;
     productionBranch: string;
     packageSelection: {
-        changed: string[];
-        dependents: string[];
-        selected: string[];
+        changed: any[];
+        dependents: any[];
+        selected: any[];
     };
     plannedVersions: any;
+    stableDependencyVersions: Record<string, string>;
     plannedDevReferenceRewrites: {
         repoName: string;
         filePath: string;
@@ -890,12 +898,12 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         reason: string;
     }[];
     plannedPublishWaits: {
-        name: string;
+        name: any;
         workflow: string;
         branch: string;
         status: string;
     }[];
-    touchedPackages: string[];
+    touchedPackages: any[];
     repos: WorkflowRepoReport[];
     rootRepo: WorkflowRepoReport;
     finalBranch: string;