@treeseed/sdk 0.10.16 → 0.10.18

package/dist/operations/services/project-platform.d.ts

@@ -3,6 +3,7 @@ import type { TreeseedRunnableBootstrapSystem } from '../../reconcile/index.ts';
 import { type TreeseedBootstrapExecution, type TreeseedBootstrapWriter } from './bootstrap-runner.ts';
 export type ProjectPlatformScope = 'local' | 'staging' | 'prod';
 export type ProjectPlatformAction = 'deploy_web' | 'publish_content' | 'monitor';
+type ProjectPlatformContentPublishMode = 'production' | 'editorial_overlay';
 export interface ProjectPlatformActionOptions {
     tenantRoot: string;
     scope: ProjectPlatformScope;
@@ -292,7 +293,7 @@ export declare function resolveRailwayServiceDeployDependencies({ includeDataDep
 export declare function publishProjectContent(options: ProjectPlatformActionOptions): Promise<{
     ok: boolean;
     scope: ProjectPlatformScope;
-    mode: string;
+    mode: ProjectPlatformContentPublishMode;
     revision: string;
     previewId: string | null;
     previewUrl: string | null;
@@ -454,7 +455,7 @@ export declare function syncControlPlaneState(options: ProjectPlatformActionOpti
 export declare function runProjectPlatformAction(action: ProjectPlatformAction, options: ProjectPlatformActionOptions): Promise<{
     ok: boolean;
     scope: ProjectPlatformScope;
-    mode: string;
+    mode: ProjectPlatformContentPublishMode;
     revision: string;
     previewId: string | null;
     previewUrl: string | null;
@@ -809,3 +810,4 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
         } | null;
     } | undefined)[];
 }>;
+export {};

package/dist/operations/services/project-platform.js

@@ -27,6 +27,7 @@ import {
   purgePublishedContentCaches,
   resolveConfiguredCloudflareAccountId,
   resolveConfiguredSurfaceBaseUrl,
+  resolveTreeseedResourceIdentity,
   syncCloudflareSecrets,
   writeDeployState
 } from "./deploy.js";
@@ -220,7 +221,8 @@ function prepareTenantCloudflareDeploy({
     env: {
       ...process.env,
       ...env,
-      CLOUDFLARE_ACCOUNT_ID: resolveConfiguredCloudflareAccountId(deployConfig)
+      CLOUDFLARE_ACCOUNT_ID: resolveConfiguredCloudflareAccountId(deployConfig),
+      ...target.kind === "persistent" && target.scope !== "local" ? { TREESEED_CONTENT_SERVING_MODE: "published_runtime" } : {}
     },
     write
   };
@@ -464,8 +466,8 @@ function resolveReporter(tenantRoot, explicit) {
   const deployConfig = loadCliDeployConfig(tenantRoot);
   return createControlPlaneReporter({ deployConfig });
 }
-function uploadObject(tenantRoot, wranglerPath, wranglerEnv, bucketName, pointer, filePath) {
-  runWrangler(tenantRoot, [
+async function uploadObject(tenantRoot, wranglerPath, wranglerEnv, bucketName, pointer, filePath, options) {
+  await runPrefixedWranglerWithRetry(tenantRoot, [
     "r2",
     "object",
     "put",
@@ -478,7 +480,11 @@ function uploadObject(tenantRoot, wranglerPath, wranglerEnv, bucketName, pointer
     filePath,
     "--content-type",
     pointer.contentType ?? inferContentType(filePath)
-  ], wranglerEnv);
+  ], {
+    env: wranglerEnv,
+    write: options.write,
+    prefix: options.prefix
+  });
 }
 function deleteObject(tenantRoot, wranglerPath, wranglerEnv, bucketName, objectKey) {
   runWrangler(tenantRoot, [
@@ -794,11 +800,11 @@ function probeScaleConfiguration(siteConfig, state) {
     serviceName: worker.serviceName ?? null
   };
 }
-async function publishContent(options, reporter) {
+async function publishContent(options, reporter, publishOptions = {}) {
   const target = runTenantPublishContentPreflight(options);
   const siteConfig = loadCliDeployConfig(options.tenantRoot);
   const tenantConfig = loadTreeseedManifest(resolve(options.tenantRoot, "src", "manifest.yaml"));
-  const teamId = String(process.env.TREESEED_HOSTING_TEAM_ID ?? siteConfig.hosting?.teamId ?? siteConfig.slug).trim() || siteConfig.slug;
+  const teamId = resolveTreeseedResourceIdentity(siteConfig, target).teamId;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const commitSha = currentCommit(options.tenantRoot);
   const branchName = currentRef(options.tenantRoot);
@@ -827,7 +833,8 @@ async function publishContent(options, reporter) {
     sourceRef: branchName,
     previewId
   });
-  const built = options.scope === "staging" ? await pipeline.buildEditorialOverlay({ previousManifest, previewId }) : await pipeline.buildProductionRevision({ previousManifest });
+  const publishMode = publishOptions.mode ?? (options.scope === "staging" ? "editorial_overlay" : "production");
+  const built = publishMode === "editorial_overlay" ? await pipeline.buildEditorialOverlay({ previousManifest, previewId }) : await pipeline.buildProductionRevision({ previousManifest });
   const changedEntrySet = "manifest" in built ? changedEntries(previousManifest, built.manifest.entries) : [];
   const changedArtifactSet = "manifest" in built ? changedArtifacts(previousManifest, built.manifest.artifacts ?? []) : [];
   const tombstones = "manifest" in built ? built.manifest.tombstones ?? [] : [];
@@ -910,20 +917,29 @@ async function publishContent(options, reporter) {
   const tempRoot = mkdtempSync(join(tmpdir(), "treeseed-content-publish-"));
   try {
     if (!options.dryRun) {
+      const uploadOptions = {
+        write: options.write,
+        prefix: {
+          scope: options.scope,
+          system: "content",
+          task: "publish",
+          stage: "upload"
+        }
+      };
       for (const object of built.objects) {
         const filePath = writeTempFile(tempRoot, objectFileName(object.pointer), toBuffer(object.body));
-        uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, object.pointer, filePath);
+        await uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, object.pointer, filePath, uploadOptions);
       }
       for (const alias of stableObjectUploads) {
         const filePath = writeTempFile(tempRoot, objectFileName(alias.pointer), alias.body);
-        uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, alias.pointer, filePath);
+        await uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, alias.pointer, filePath, uploadOptions);
       }
       for (const objectKey of deletedObjectKeys) {
         deleteObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, objectKey);
       }
       if ("overlay" in built) {
         const overlayFile = writeTempFile(tempRoot, "overlay.json", Buffer.from(JSON.stringify(built.overlay, null, 2)));
-        uploadObject(
+        await uploadObject(
           options.tenantRoot,
           wranglerPath,
           wranglerEnv,
@@ -934,23 +950,24 @@ async function publishContent(options, reporter) {
             size: statSync(overlayFile).size,
             contentType: "application/json"
           },
-          overlayFile
+          overlayFile,
+          uploadOptions
         );
       } else {
         const manifestFile = writeTempFile(tempRoot, "manifest.json", Buffer.from(JSON.stringify(built.manifest, null, 2)));
         const snapshotKey = locator.manifestKey.replace(/\/common\.json$/u, `/manifests/${built.manifest.revision}.json`);
-        uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, {
+        await uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, {
           objectKey: snapshotKey,
           sha256: stableHash(readFileSync(manifestFile)),
           size: statSync(manifestFile).size,
           contentType: "application/json"
-        }, manifestFile);
-        uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, {
+        }, manifestFile, uploadOptions);
+        await uploadObject(options.tenantRoot, wranglerPath, wranglerEnv, bucketName, {
           objectKey: locator.manifestKey,
           sha256: stableHash(readFileSync(manifestFile)),
           size: statSync(manifestFile).size,
           contentType: "application/json"
-        }, manifestFile);
+        }, manifestFile, uploadOptions);
         if (contentPurgeUrls.size > 0) {
           try {
             purgePublishedContentCaches(options.tenantRoot, [...contentPurgeUrls].filter(Boolean), { target });
@@ -960,12 +977,14 @@ async function publishContent(options, reporter) {
       }
     }
     const state = loadDeployState(options.tenantRoot, siteConfig, { target });
-    state.content.lastPublishedManifestRevision = "overlay" in built ? built.overlay.previewId : built.manifest.revision;
-    state.content.lastPublishedManifestSha256 = stableHash(
-      JSON.stringify("overlay" in built ? built.overlay : built.manifest)
-    );
-    writeDeployState(options.tenantRoot, state, { target });
-    const previewToken = options.scope === "staging" && process.env.TREESEED_EDITORIAL_PREVIEW_SECRET ? signEditorialPreviewToken({
+    if (!options.dryRun) {
+      state.content.lastPublishedManifestRevision = "overlay" in built ? built.overlay.previewId : built.manifest.revision;
+      state.content.lastPublishedManifestSha256 = stableHash(
+        JSON.stringify("overlay" in built ? built.overlay : built.manifest)
+      );
+      writeDeployState(options.tenantRoot, state, { target });
+    }
+    const previewToken = publishMode === "editorial_overlay" && process.env.TREESEED_EDITORIAL_PREVIEW_SECRET ? signEditorialPreviewToken({
       teamId,
       previewId,
       expiresAt: "overlay" in built ? built.overlay.expiresAt ?? new Date(Date.now() + resolvePublishedContentPreviewTtlHours(siteConfig) * 60 * 60 * 1e3).toISOString() : new Date(Date.now() + resolvePublishedContentPreviewTtlHours(siteConfig) * 60 * 60 * 1e3).toISOString()
@@ -980,9 +999,9 @@ async function publishContent(options, reporter) {
       commitSha,
       triggeredByType: "project_runner",
       metadata: {
-        mode: options.scope === "staging" ? "editorial_overlay" : "production",
+        mode: publishMode,
         revision: "overlay" in built ? built.overlay.previewId : built.manifest.revision,
-        previewId: options.scope === "staging" ? previewId : null,
+        previewId: publishMode === "editorial_overlay" ? previewId : null,
         previewUrl,
         entries: ("overlay" in built ? built.overlay.entries : built.manifest.entries).length,
         artifacts: ("overlay" in built ? built.overlay.artifacts : built.manifest.artifacts)?.length ?? 0,
@@ -994,9 +1013,9 @@ async function publishContent(options, reporter) {
     return {
       ok: true,
       scope: options.scope,
-      mode: options.scope === "staging" ? "editorial_overlay" : "production",
+      mode: publishMode,
       revision: "overlay" in built ? built.overlay.previewId : built.manifest.revision,
-      previewId: options.scope === "staging" ? previewId : null,
+      previewId: publishMode === "editorial_overlay" ? previewId : null,
       previewUrl,
       target: deployTargetLabel(target)
     };
@@ -1214,13 +1233,23 @@ async function deployProjectPlatform(options) {
   }
   if (cloudflareContext && selectedSystems.has("web")) {
     const context = cloudflareContext;
+    const contentNodeId = "content:publish-runtime";
+    nodes.push({
+      id: contentNodeId,
+      dependencies: selectedSystems.has("data") ? ["data:d1-migrate"] : [],
+      run: () => publishContent({
+        ...options,
+        reporter,
+        bootstrapSystems: ["web"]
+      }, reporter, { mode: "production" })
+    });
     nodes.push({
       id: "web:build",
       run: () => runTenantWebBuild(context)
     });
     nodes.push({
       id: "web:publish",
-      dependencies: ["web:build", ...selectedSystems.has("data") ? ["data:d1-migrate"] : []],
+      dependencies: ["web:build", contentNodeId, ...selectedSystems.has("data") ? ["data:d1-migrate"] : []],
       run: () => runTenantWebPublish(context)
     });
   }
@@ -1452,7 +1481,7 @@ async function runProjectPlatformAction(action, options) {
   const previousWorkflowAction = process.env.TREESEED_WORKFLOW_ACTION;
   const previousWorkflowPlane = process.env.TREESEED_WORKFLOW_PLANE;
   process.env.TREESEED_WORKFLOW_ACTION = action;
-  process.env.TREESEED_WORKFLOW_PLANE = previousWorkflowPlane ?? "web";
+  process.env.TREESEED_WORKFLOW_PLANE = previousWorkflowPlane ?? "all";
   applyTreeseedEnvironmentToProcess({ tenantRoot: options.tenantRoot, scope: options.scope, override: true });
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
   try {

package/dist/operations/services/railway-api.d.ts

@@ -288,12 +288,7 @@ export declare function ensureRailwayServiceVolume({ projectId, environmentId, s
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<{
-    volume: {
-        instances: RailwayVolumeInstanceSummary[];
-        id: string;
-        name: string;
-        projectId: string | null;
-    } | null;
+    volume: RailwayVolumeSummary | null;
     instance: RailwayVolumeInstanceSummary | null;
     created: boolean;
     updated: boolean;
@@ -316,3 +311,23 @@ export declare function ensureRailwayCustomDomain({ projectId, environmentId, se
     domain: RailwayCustomDomainSummary;
     created: boolean;
 }>;
+export declare function deleteRailwayCustomDomain({ domainId, env, fetchImpl, }: {
+    domainId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;
+export declare function deleteRailwayVolume({ volumeId, env, fetchImpl, }: {
+    volumeId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;
+export declare function deleteRailwayEnvironment({ environmentId, env, fetchImpl, }: {
+    environmentId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;
+export declare function deleteRailwayProject({ projectId, env, fetchImpl, }: {
+    projectId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;

package/dist/operations/services/railway-api.js

@@ -840,7 +840,13 @@ async function ensureRailwayServiceInstanceConfiguration({
   env = process.env,
   fetchImpl = fetch
 }) {
-  const current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+  let current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+  if (!current.id) {
+    for (let attempt = 0; attempt < 8 && !current.id; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+    }
+  }
   if (!current.id) {
     return { instance: current, updated: false };
   }
@@ -905,12 +911,21 @@ mutation TreeseedRailwayServiceInstanceUpdateLegacy($serviceId: String!, $enviro
     }
     throw error;
   }
-  const instance = await getRailwayServiceInstance({
+  let instance = await getRailwayServiceInstance({
     serviceId,
     environmentId,
     env,
     fetchImpl
   });
+  for (let attempt = 0; attempt < 5 && serviceInstanceDrifted(instance, desired); attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    instance = await getRailwayServiceInstance({
+      serviceId,
+      environmentId,
+      env,
+      fetchImpl
+    });
+  }
   return {
     instance: {
       id: instance.id || current.id,
@@ -929,6 +944,9 @@ mutation TreeseedRailwayServiceInstanceUpdateLegacy($serviceId: String!, $enviro
     updated: true
   };
 }
+function serviceInstanceDrifted(current, desired) {
+  return desired.buildCommand !== null && desired.buildCommand !== current.buildCommand || desired.startCommand !== null && desired.startCommand !== current.startCommand || desired.cronSchedule !== null && desired.cronSchedule !== current.cronSchedule || desired.rootDirectory !== null && desired.rootDirectory !== current.rootDirectory || desired.healthcheckPath !== null && desired.healthcheckPath !== current.healthcheckPath || desired.healthcheckTimeoutSeconds !== null && desired.healthcheckTimeoutSeconds !== current.healthcheckTimeoutSeconds || desired.runtimeMode !== null && desired.runtimeMode !== current.runtimeMode;
+}
 async function listRailwayVariables({
   projectId,
   environmentId,
@@ -1193,44 +1211,97 @@ async function ensureRailwayServiceVolume({
     ...candidate,
     instances: candidate.instances.filter(isActiveRailwayVolumeInstance)
   })).filter((candidate) => candidate.instances.length > 0);
-  let volume = activeVolumes.find(
-    (candidate) => candidate.instances.some((instance2) => instance2.serviceId === serviceId && instance2.environmentId === environmentId)
-  ) ?? activeVolumes.find((candidate) => candidate.name === name) ?? null;
+  let volume = findRailwayVolumeForService(volumes, serviceId, environmentId) ?? activeVolumes.find(
+    (candidate) => candidate.name === name && candidate.instances.some((instance2) => instance2.environmentId === environmentId)
+  ) ?? null;
   let created = false;
   let updated = false;
-  if (!volume) {
-    volume = await createRailwayVolume({
-      projectId,
-      environmentId,
-      serviceId,
-      name,
-      mountPath,
-      env,
-      fetchImpl
-    });
+  const createReplacementVolume = async () => {
+    let replacement;
+    try {
+      replacement = await createRailwayVolume({
+        projectId,
+        environmentId,
+        serviceId,
+        name,
+        mountPath,
+        env,
+        fetchImpl
+      });
+    } catch (error) {
+      if (!looksLikeRailwayVolumeCreateRace(error)) {
+        throw error;
+      }
+      for (let attempt = 0; attempt < 8; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        const refreshed = await listRailwayVolumes({ projectId, env, fetchImpl });
+        const existing = findRailwayVolumeForService(refreshed, serviceId, environmentId);
+        if (existing) {
+          return existing;
+        }
+      }
+      throw error;
+    }
     created = true;
+    return replacement;
+  };
+  if (!volume) {
+    volume = await createReplacementVolume();
   }
   if (volume.name && volume.name !== name) {
-    volume = await updateRailwayVolumeName({ volumeId: volume.id, name, env, fetchImpl }) ?? { ...volume, name };
+    try {
+      volume = await updateRailwayVolumeName({ volumeId: volume.id, name, env, fetchImpl }) ?? { ...volume, name };
+    } catch (error) {
+      if (!looksLikeRailwayMissingResource(error)) {
+        throw error;
+      }
+      volume = await createReplacementVolume();
+    }
     updated = true;
   }
   let instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? null;
   if (!instance && volume.instances.some((entry) => entry.environmentId === environmentId)) {
-    await updateRailwayVolumeInstanceMountPath({ volumeId: volume.id, serviceId, mountPath, env, fetchImpl });
-    volume = await listRailwayVolumes({ projectId, env, fetchImpl }).then((refreshed) => refreshed.find((candidate) => candidate.id === volume?.id) ?? volume);
+    try {
+      await updateRailwayVolumeInstanceMountPath({ volumeId: volume.id, serviceId, mountPath, env, fetchImpl });
+      volume = await listRailwayVolumes({ projectId, env, fetchImpl }).then((refreshed) => refreshed.find((candidate) => candidate.id === volume?.id) ?? volume);
+    } catch (error) {
+      if (!looksLikeRailwayMissingResource(error)) {
+        throw error;
+      }
+      volume = await createReplacementVolume();
+    }
     instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? null;
     updated = true;
   }
   if (instance && instance.mountPath !== mountPath) {
-    await updateRailwayVolumeInstanceMountPath({ volumeId: volume.id, mountPath, env, fetchImpl });
-    volume = {
-      ...volume,
-      instances: volume.instances.map((entry) => entry.id === instance.id ? { ...entry, mountPath } : entry)
-    };
+    try {
+      await updateRailwayVolumeInstanceMountPath({ volumeId: volume.id, mountPath, env, fetchImpl });
+      volume = {
+        ...volume,
+        instances: volume.instances.map((entry) => entry.id === instance.id ? { ...entry, mountPath } : entry)
+      };
+    } catch (error) {
+      if (!looksLikeRailwayMissingResource(error)) {
+        throw error;
+      }
+      volume = await createReplacementVolume();
+      instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? null;
+    }
     updated = true;
   }
   return { volume, instance, created, updated };
 }
+function findRailwayVolumeForService(volumes, serviceId, environmentId) {
+  return volumes.find(
+    (candidate) => candidate.instances.some(
+      (instance) => instance.serviceId === serviceId && instance.environmentId === environmentId && isActiveRailwayVolumeInstance(instance)
+    )
+  ) ?? null;
+}
+function looksLikeRailwayVolumeCreateRace(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /would have \d+ volumes attached|can only have one volume|not authorized/iu.test(message);
+}
 async function listRailwayCustomDomains({
   projectId,
   environmentId,
@@ -1340,7 +1411,121 @@ mutation TreeseedRailwayCustomDomainCreate($input: CustomDomainCreateInput!) {
   }
   return { domain: created, created: true };
 }
+function looksLikeRailwayMissingResource(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /not found|does not exist|could not find|unknown|invalid .*id/iu.test(message);
+}
+async function railwayDeleteMutation({
+  query,
+  variables,
+  env,
+  fetchImpl,
+  missingResult
+}) {
+  try {
+    await railwayGraphqlRequest({
+      query,
+      variables,
+      env,
+      fetchImpl
+    });
+    return { status: "deleted" };
+  } catch (error) {
+    if (looksLikeRailwayMissingResource(error)) {
+      return missingResult;
+    }
+    throw error;
+  }
+}
+async function deleteRailwayCustomDomain({
+  domainId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!railwayConnectionLabel(domainId)) {
+    return { status: "missing", id: domainId };
+  }
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_CUSTOM_DOMAIN_DELETE_MUTATION") || `
+mutation TreeseedRailwayCustomDomainDelete($id: String!) {
+	customDomainDelete(id: $id)
+}
+`.trim();
+  return railwayDeleteMutation({
+    query: mutation,
+    variables: { id: domainId },
+    env,
+    fetchImpl,
+    missingResult: { status: "missing", id: domainId }
+  });
+}
+async function deleteRailwayVolume({
+  volumeId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!railwayConnectionLabel(volumeId)) {
+    return { status: "missing", id: volumeId };
+  }
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_DELETE_MUTATION") || `
+mutation TreeseedRailwayVolumeDelete($volumeId: String!) {
+	volumeDelete(volumeId: $volumeId)
+}
+`.trim();
+  return railwayDeleteMutation({
+    query: mutation,
+    variables: { volumeId },
+    env,
+    fetchImpl,
+    missingResult: { status: "missing", id: volumeId }
+  });
+}
+async function deleteRailwayEnvironment({
+  environmentId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!railwayConnectionLabel(environmentId)) {
+    return { status: "missing", id: environmentId };
+  }
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_ENVIRONMENT_DELETE_MUTATION") || `
+mutation TreeseedRailwayEnvironmentDelete($id: String!) {
+	environmentDelete(id: $id)
+}
+`.trim();
+  return railwayDeleteMutation({
+    query: mutation,
+    variables: { id: environmentId },
+    env,
+    fetchImpl,
+    missingResult: { status: "missing", id: environmentId }
+  });
+}
+async function deleteRailwayProject({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!railwayConnectionLabel(projectId)) {
+    return { status: "missing", id: projectId };
+  }
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_PROJECT_DELETE_MUTATION") || `
+mutation TreeseedRailwayProjectDelete($id: String!) {
+	projectDelete(id: $id)
+}
+`.trim();
+  return railwayDeleteMutation({
+    query: mutation,
+    variables: { id: projectId },
+    env,
+    fetchImpl,
+    missingResult: { status: "missing", id: projectId }
+  });
+}
 export {
+  deleteRailwayCustomDomain,
+  deleteRailwayEnvironment,
+  deleteRailwayProject,
+  deleteRailwayVolume,
   ensureRailwayCustomDomain,
   ensureRailwayEnvironment,
   ensureRailwayPostgresService,

package/dist/operations/services/railway-deploy.d.ts

@@ -14,10 +14,13 @@ export declare function buildRailwayDeployCommandEnv(env?: NodeJS.ProcessEnv): {
     [key: string]: string | undefined;
 };
 export declare function isRailwayTransientFailure(result: any): boolean;
-export declare function runRailway(args: any, { cwd, capture, allowFailure, input, env }?: {
+export declare function runRailway(args: any, { cwd, capture, allowFailure, input, env, retryTransient, retryAttempts, retryDelayMs }?: {
     capture?: boolean | undefined;
     allowFailure?: boolean | undefined;
-}): import("child_process").SpawnSyncReturns<string>;
+    retryTransient?: boolean | undefined;
+    retryAttempts?: number | undefined;
+    retryDelayMs?: number | undefined;
+}): import("child_process").SpawnSyncReturns<string> | null;
 export declare function waitForRailwayManagedDeploymentsSettled(tenantRoot: any, scope: any, { services, env, timeoutMs, pollMs, onProgress, }?: {
     services?: unknown[] | undefined;
     env?: NodeJS.ProcessEnv | undefined;
@@ -53,11 +56,11 @@ export declare function ensureRailwayEnvironmentExists(service: any, { env }?: {
 }): import("child_process").SpawnSyncReturns<string> | null;
 export declare function ensureRailwayServiceExists(service: any, { env }?: {
     env?: NodeJS.ProcessEnv | undefined;
-}): import("child_process").SpawnSyncReturns<string>;
+}): import("child_process").SpawnSyncReturns<string> | null;
 export declare function ensureRailwayDatabaseServiceExists(service: any, { database, env, }?: {
     database?: string | undefined;
     env?: NodeJS.ProcessEnv | undefined;
-}): import("child_process").SpawnSyncReturns<string>;
+}): import("child_process").SpawnSyncReturns<string> | null;
 export declare function ensureRailwayProjectContext(service: any, { env, allowFailure, capture }?: {
     env?: NodeJS.ProcessEnv | undefined;
     allowFailure?: boolean | undefined;
@@ -141,6 +144,23 @@ export declare function planRailwayServiceLink(service: any, { env }?: {
     args: string[];
     cwd: any;
 };
+export declare function ensureRailwayServiceVolumeWithCliFallback({ tenantRoot, projectId, environmentId, environmentName, serviceId, serviceName, name, mountPath, preferCli, env, }: {
+    tenantRoot: any;
+    projectId: any;
+    environmentId: any;
+    environmentName: any;
+    serviceId: any;
+    serviceName: any;
+    name: any;
+    mountPath: any;
+    preferCli?: boolean | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}): Promise<{
+    volume: any;
+    instance: any;
+    created: boolean;
+    updated: boolean;
+}>;
 export declare function deployRailwayService(tenantRoot: any, service: any, { dryRun, write, prefix, env, }?: {
     dryRun?: boolean;
     write?: TreeseedBootstrapWriter;

package/dist/operations/services/railway-deploy.js

@@ -332,7 +332,7 @@ function isRailwayTransientFailure(result) {
   if (!message.trim() && result?.status === 1) {
     return true;
   }
-  return /timed out|failed to fetch|temporarily unavailable|econnreset|etimedout|failed to stream build logs|failed to retrieve build log/iu.test(message);
+  return /timed out|failed to fetch|error decoding response body|expected value at line 1 column 1|temporarily unavailable|econnreset|etimedout|failed to stream build logs|failed to retrieve build log/iu.test(message);
 }
 function sleepSync(milliseconds) {
   if (!Number.isFinite(milliseconds) || milliseconds <= 0) {
@@ -412,7 +412,7 @@ mutation TreeseedScheduleUpdate($id: String!, $name: String!, $schedule: String!
 `.trim()
   };
 }
-function runRailway(args, { cwd, capture = false, allowFailure = false, input, env } = {}) {
+function runRailway(args, { cwd, capture = false, allowFailure = false, input, env, retryTransient = true, retryAttempts = 3, retryDelayMs = 2e3 } = {}) {
   const effectiveEnv = buildRailwayCommandEnv({ ...process.env, ...env ?? {} });
   const railway = resolveTreeseedToolCommand("railway", { env: effectiveEnv });
   if (!railway) {
@@ -425,8 +425,16 @@ function runRailway(args, { cwd, capture = false, allowFailure = false, input, e
     env: spawnEnv,
     input
   });
-  const result = runWithEnv(effectiveEnv);
-  if (result.status !== 0 && !allowFailure) {
+  let result = null;
+  const maxAttempts = retryTransient && !allowFailure ? Math.max(1, Number(retryAttempts) || 1) : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    result = runWithEnv(effectiveEnv);
+    if (result.status === 0 || allowFailure || !isRailwayTransientFailure(result) || attempt === maxAttempts) {
+      break;
+    }
+    sleepSync((Number(retryDelayMs) || 0) * attempt);
+  }
+  if (result?.status !== 0 && !allowFailure) {
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${args.join(" ")} failed`);
   }
   return result;
@@ -1917,6 +1925,7 @@ export {
   ensureRailwayProjectExists,
   ensureRailwayScheduledJobs,
   ensureRailwayServiceExists,
+  ensureRailwayServiceVolumeWithCliFallback,
   isRailwayTransientFailure,
   isUsableRailwayToken,
   planRailwayServiceDeploy,

package/dist/platform/environment.js

@@ -68,6 +68,9 @@ function platformSurfaceEnabled(context, surface) {
 }
 function activeWorkflowPlane() {
   const plane = process.env.TREESEED_WORKFLOW_PLANE;
+  if (plane === "all") {
+    return null;
+  }
   return plane === "web" || plane === "processing" ? plane : null;
 }
 function workflowPlaneAllows(plane) {