@treeseed/sdk 0.10.15 → 0.10.17

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

@@ -316,3 +316,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

@@ -1195,11 +1195,13 @@ async function ensureRailwayServiceVolume({
   })).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;
+  ) ?? 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({
+  const createReplacementVolume = async () => {
+    const replacement = await createRailwayVolume({
       projectId,
       environmentId,
       serviceId,
@@ -1209,24 +1211,50 @@ async function ensureRailwayServiceVolume({
       fetchImpl
     });
     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 };
@@ -1340,7 +1368,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;

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;

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) {

package/dist/reconcile/builtin-adapters.js

@@ -587,7 +587,7 @@ function collectCloudflareEnvironmentSync(input) {
   const registry = collectTreeseedEnvironmentContext(input.context.tenantRoot);
   const state = loadDeployState(input.context.tenantRoot, input.context.deployConfig, { target });
   const generatedSecrets = buildSecretMap(input.context.deployConfig, state);
-  const publicVars = buildPublicVars(input.context.deployConfig);
+  const publicVars = buildPublicVars(input.context.deployConfig, { target });
   const secrets = {};
   const vars = { ...publicVars };
   const secretNames = /* @__PURE__ */ new Set();
@@ -1578,26 +1578,40 @@ async function syncRailwayEnvironmentForScope(input, { dryRun = false } = {}) {
         });
         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}.`);
+          let attachMessage = "";
+          let attached = false;
+          for (let attempt = 0; attempt < 5; attempt += 1) {
+            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) {
+              attached = true;
+              break;
+            }
+            attachMessage = attachResult.stderr?.trim() || attachResult.stdout?.trim() || "";
+            if (/already mounted/iu.test(attachMessage)) {
+              attached = true;
+              break;
             }
+            if (!/volume .*not found|not found|does not exist/iu.test(attachMessage)) {
+              break;
+            }
+            sleepMs(2e3 * (attempt + 1));
+          }
+          if (!attached) {
+            throw new Error(attachMessage || `Railway volume attach failed for ${entry.service.name}.`);
           }
         }
       }

package/dist/scripts/tenant-destroy.js

@@ -2,7 +2,7 @@
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
-import { cleanupDestroyedState, createPersistentDeployTarget, destroyCloudflareResources, loadDeployState, printDestroySummary, validateDestroyPrerequisites, } from '../operations/services/deploy.js';
+import { cleanupDestroyedState, createPersistentDeployTarget, destroyTreeseedEnvironmentResources, loadDeployState, printDestroySummary, validateDestroyPrerequisites, } from '../operations/services/deploy.js';
 import { deriveCloudflareWorkerName } from '../platform/deploy-config.js';
 const tenantRoot = process.cwd();
 function parseArgs(argv) {
@@ -11,6 +11,7 @@ function parseArgs(argv) {
         force: false,
         skipConfirmation: false,
         confirm: null,
+        deleteData: false,
         removeBuildArtifacts: false,
         environment: null,
     };
@@ -27,6 +28,10 @@ function parseArgs(argv) {
             parsed.force = true;
             continue;
         }
+        if (current === '--delete-data') {
+            parsed.deleteData = true;
+            continue;
+        }
         if (current === '--skip-confirmation') {
             parsed.skipConfirmation = true;
             continue;
@@ -92,9 +97,10 @@ if (!options.skipConfirmation) {
         process.exit(1);
     }
 }
-const result = destroyCloudflareResources(tenantRoot, {
+const result = await destroyTreeseedEnvironmentResources(tenantRoot, {
     dryRun: options.dryRun,
     force: options.force,
+    deleteData: options.deleteData,
     target,
 });
 printDestroySummary(result);