@treeseed/sdk 0.10.28 → 0.12.4

package/dist/reconcile/providers/railway-iac.d.ts

@@ -0,0 +1,66 @@
+import { type RailwayChangeSet, type RailwayIacApplyResponse, type RailwayIacPlanResponse } from 'railway/iac';
+export type TreeseedRailwayIacService = {
+    key: string;
+    serviceName: string;
+    sourceMode?: string | null;
+    sourceRepo?: string | null;
+    sourceBranch?: string | null;
+    sourceCommit?: string | null;
+    sourceRootDirectory?: string | null;
+    imageRef?: string | null;
+    dockerfilePath?: string | null;
+    buildCommand?: string | null;
+    startCommand?: string | null;
+    healthcheckPath?: string | null;
+    healthcheckTimeoutSeconds?: number | null;
+    runtimeMode?: string | null;
+    volumeMountPath?: string | null;
+    variables?: Record<string, string>;
+    secrets?: Record<string, string>;
+    detachVolumeIds?: string[];
+};
+export type TreeseedRailwayIacDatabase = {
+    serviceName: string;
+    environmentVariable: string;
+    mountPath?: string | null;
+    detachVolumeIds?: string[];
+    useNativePostgres?: boolean;
+};
+export type TreeseedRailwayIacProjectInput = {
+    tenantRoot: string;
+    projectName: string;
+    projectId: string;
+    environmentName: string;
+    environmentId: string;
+    railwayApiToken: string;
+    railwayApiUrl?: string | null;
+    services: TreeseedRailwayIacService[];
+    database: TreeseedRailwayIacDatabase | null;
+    region?: string | null;
+};
+export type TreeseedRailwayIacRenderResult = {
+    filePath: string;
+    tempDir: string;
+    projectName: string;
+    environmentName: string;
+    serviceNames: string[];
+    volumeNames: string[];
+    databaseName: string | null;
+    source: string;
+};
+export type RailwayIacValidationResult = {
+    ok: boolean;
+    destructiveChanges: string[];
+    blockedReasons: string[];
+    allowedDrift: string[];
+};
+export declare function renderRailwayIacProject(input: TreeseedRailwayIacProjectInput): TreeseedRailwayIacRenderResult;
+export declare function validateRailwayIacChangeSet(changeSet: RailwayChangeSet | undefined, desiredNames: {
+    services: string[];
+    volumes: string[];
+    database: string | null;
+    scope: string;
+}): RailwayIacValidationResult;
+export declare function planRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacPlanResponse>;
+export declare function applyRailwayIacProject(input: TreeseedRailwayIacProjectInput, rendered?: TreeseedRailwayIacRenderResult): Promise<RailwayIacApplyResponse>;
+export declare function cleanupRailwayIacRender(rendered: Pick<TreeseedRailwayIacRenderResult, 'tempDir'>): void;

package/dist/reconcile/providers/railway-iac.js

@@ -0,0 +1,275 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { runRailwayIac } from "railway/iac";
+function js(value) {
+  return JSON.stringify(value);
+}
+function id(prefix, index) {
+  return `${prefix}${index}`;
+}
+function codeObject(entries) {
+  const rendered = entries.filter(([, value]) => typeof value === "string" && value.length > 0).map(([key, value]) => `${js(key)}: ${value}`);
+  return rendered.length > 0 ? `{
+${rendered.map((line) => `      ${line}`).join(",\n")}
+    }` : "{}";
+}
+function literalVariable(value) {
+  return js(value);
+}
+function validateGeneratedVariables(service) {
+  const keys = [...Object.keys(service.variables ?? {}), ...Object.keys(service.secrets ?? {})];
+  const isTreeDxService = service.serviceName.includes("treedx") || service.key.includes("treedx");
+  return keys.filter((key) => {
+    if (key === "PORT") return false;
+    if (key.startsWith("TREESEED_")) return false;
+    if (isTreeDxService && key.startsWith("TREEDX_")) return false;
+    return true;
+  });
+}
+function serviceSource(service) {
+  if (service.imageRef) {
+    return `image(${js(service.imageRef)})`;
+  }
+  if (service.sourceMode === "git" && service.sourceRepo) {
+    const sourceConfig = {
+      ...service.sourceBranch ? { branch: service.sourceBranch } : {},
+      ...service.sourceRootDirectory ? { rootDirectory: service.sourceRootDirectory } : {},
+      ...service.sourceCommit ? { commitSha: service.sourceCommit } : {}
+    };
+    return `github(${js(service.sourceRepo)}, ${js(sourceConfig)})`;
+  }
+  return "empty()";
+}
+function buildConfig(service) {
+  if (service.imageRef) return null;
+  if (service.dockerfilePath) {
+    return {
+      builder: "DOCKERFILE",
+      dockerfilePath: service.dockerfilePath
+    };
+  }
+  if (service.buildCommand) {
+    return {
+      builder: "NIXPACKS",
+      buildCommand: service.buildCommand
+    };
+  }
+  return null;
+}
+function deployConfig(service, region) {
+  const runtimeMode = String(service.runtimeMode ?? "").trim();
+  const deploy = {
+    ...service.startCommand ? { startCommand: service.startCommand } : {},
+    ...service.healthcheckPath ? { healthcheckPath: service.healthcheckPath } : {},
+    ...service.healthcheckTimeoutSeconds ? { healthcheckTimeout: service.healthcheckTimeoutSeconds } : {},
+    ...runtimeMode === "serverless" ? { sleepApplication: true } : {},
+    ...runtimeMode === "service" || runtimeMode === "replicated" ? { sleepApplication: false } : {},
+    ...service.volumeMountPath ? { requiredMountPath: service.volumeMountPath } : {},
+    region
+  };
+  return Object.keys(deploy).length > 0 ? deploy : null;
+}
+function renderServiceEnv(service, databaseVariableName, databaseEnvName) {
+  const variables = {
+    ...service.variables ?? {},
+    ...service.secrets ?? {}
+  };
+  const entries = Object.entries(variables).filter(([key]) => key.startsWith("TREESEED_") || key.startsWith("TREEDX_") || key === "PORT").map(([key, value]) => {
+    const dbRef = databaseVariableName && databaseEnvName && key === databaseEnvName;
+    return [key, dbRef ? `${databaseVariableName}.env.DATABASE_URL` : literalVariable(value)];
+  });
+  return codeObject(entries);
+}
+function renderPostgresEnv() {
+  return codeObject([
+    ["PGDATA", js("/var/lib/postgresql/data/pgdata")],
+    ["PGHOST", js("${{RAILWAY_PRIVATE_DOMAIN}}")],
+    ["PGPORT", js("5432")],
+    ["PGUSER", js("${{POSTGRES_USER}}")],
+    ["PGDATABASE", js("${{POSTGRES_DB}}")],
+    ["PGPASSWORD", js("${{POSTGRES_PASSWORD}}")],
+    ["POSTGRES_DB", js("railway")],
+    ["DATABASE_URL", js("postgresql://${{PGUSER}}:${{POSTGRES_PASSWORD}}@${{RAILWAY_PRIVATE_DOMAIN}}:5432/${{PGDATABASE}}")],
+    ["POSTGRES_USER", js("postgres")],
+    ["SSL_CERT_DAYS", js("820")],
+    ["POSTGRES_PASSWORD", '{ generator: "secret(32, \\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\\")" }'],
+    ["DATABASE_PUBLIC_URL", js("postgresql://${{PGUSER}}:${{POSTGRES_PASSWORD}}@${{RAILWAY_TCP_PROXY_DOMAIN}}:${{RAILWAY_TCP_PROXY_PORT}}/${{PGDATABASE}}")],
+    ["RAILWAY_DEPLOYMENT_DRAINING_SECONDS", js("60")]
+  ]);
+}
+function renderRailwayIacProject(input) {
+  const region = input.region?.trim() || "us-east4-eqdc4a";
+  const tempParent = resolve(input.tenantRoot, ".treeseed", "tmp");
+  mkdirSync(tempParent, { recursive: true });
+  const tempDir = mkdtempSync(resolve(tempParent, "railway-iac-"));
+  const filePath = resolve(tempDir, "railway.mjs");
+  const resources = [];
+  const declarations = [];
+  const volumeNames = [];
+  const databaseVariableName = input.database ? "db" : null;
+  const databaseEnvName = input.database?.environmentVariable ?? null;
+  if (input.database) {
+    const postgresVolumeName = `${input.database.serviceName}-volume`;
+    const postgresMountPath = input.database.mountPath?.trim() || "/var/lib/postgresql/data";
+    volumeNames.push(postgresVolumeName);
+    if (input.database.useNativePostgres) {
+      declarations.push(`  const dbVolume = volume(${js(postgresVolumeName)}, ${js({
+        region,
+        sizeMB: 5e4,
+        allowOnlineResize: true,
+        alerts: { usage: { 80: {}, 95: {}, 100: {} } }
+      })});`);
+      declarations.push(`  const db = postgres(${js(input.database.serviceName)}, ${js({ region })});`);
+      resources.push("dbVolume", "db");
+    } else {
+      const postgresMounts = [
+        ...(input.database.detachVolumeIds ?? []).map((volumeId) => `${js(volumeId)}: null`),
+        `${js(postgresMountPath)}: dbVolume`
+      ];
+      declarations.push(`  const dbVolume = volume(${js(postgresVolumeName)}, ${js({
+        region,
+        sizeMB: 5e4,
+        allowOnlineResize: true,
+        alerts: { usage: { 80: {}, 95: {}, 100: {} } }
+      })});`);
+      declarations.push(`  const db = service(${js(input.database.serviceName)}, {
+    source: image("ghcr.io/railwayapp-templates/postgres-ssl:18"),
+    env: ${renderPostgresEnv()},
+    deploy: {
+      requiredMountPath: ${js(postgresMountPath)},
+      region: ${js(region)}
+    },
+    volumeMounts: { ${postgresMounts.join(", ")} }
+  });`);
+      resources.push("dbVolume", "db");
+    }
+  }
+  input.services.forEach((service, index) => {
+    const serviceVar = id("svc", index);
+    const invalidVariables = validateGeneratedVariables(service);
+    if (invalidVariables.length > 0) {
+      throw new Error(`Railway IaC service ${service.serviceName} has invalid generated variables: ${invalidVariables.join(", ")}.`);
+    }
+    const entries = [
+      `source: ${serviceSource(service)}`,
+      `env: ${renderServiceEnv(service, databaseVariableName, databaseEnvName)}`
+    ];
+    const build = buildConfig(service);
+    const deploy = deployConfig(service, region);
+    if (build) entries.push(`build: ${js(build)}`);
+    if (deploy) entries.push(`deploy: ${js(deploy)}`);
+    if (service.volumeMountPath) {
+      const volumeName = `${service.serviceName}-volume`;
+      const volumeVar = id("vol", index);
+      const volumeMounts = [
+        ...(service.detachVolumeIds ?? []).map((volumeId) => `${js(volumeId)}: null`),
+        `${js(service.volumeMountPath)}: ${volumeVar}`
+      ];
+      volumeNames.push(volumeName);
+      declarations.push(`  const ${volumeVar} = volume(${js(volumeName)}, ${js({
+        region,
+        sizeMB: 5e4,
+        allowOnlineResize: true,
+        alerts: { usage: { 80: {}, 95: {}, 100: {} } }
+      })});`);
+      entries.push(`volumeMounts: { ${volumeMounts.join(", ")} }`);
+      resources.push(volumeVar);
+    }
+    declarations.push(`  const ${serviceVar} = service(${js(service.serviceName)}, {
+    ${entries.join(",\n    ")}
+  });`);
+    resources.push(serviceVar);
+  });
+  const source = `
+import { defineRailway, empty, github, image, postgres, project, service, volume, preserve } from "railway/iac";
+
+export default defineRailway(() => {
+${declarations.join("\n")}
+  return project(${js(input.projectName)}, { resources: [${resources.join(", ")}] });
+});
+`.trimStart();
+  writeFileSync(filePath, source);
+  return {
+    filePath,
+    tempDir,
+    projectName: input.projectName,
+    environmentName: input.environmentName,
+    serviceNames: input.services.map((service) => service.serviceName),
+    volumeNames,
+    databaseName: input.database?.serviceName ?? null,
+    source
+  };
+}
+function changeName(change) {
+  return String(change?.resource?.name ?? change?.previous?.name ?? change?.address ?? change?.path ?? "");
+}
+function validateRailwayIacChangeSet(changeSet, desiredNames) {
+  const blockedReasons = [];
+  const destructiveChanges = [];
+  const desired = /* @__PURE__ */ new Set([...desiredNames.services, ...desiredNames.volumes, ...desiredNames.database ? [desiredNames.database] : []]);
+  const created = new Set((changeSet?.changes ?? []).filter((change) => change.kind === "resource.create").map((change) => changeName(change)));
+  for (const change of changeSet?.changes ?? []) {
+    const name = changeName(change);
+    if (change.kind === "resource.delete") {
+      destructiveChanges.push(change.summary);
+      blockedReasons.push(`Railway IaC plan would delete resource ${name || change.summary}; hosting reconciliation only updates or creates resources. Use the explicit destroy workflow for deletions.`);
+      if (desired.has(name) && !created.has(name)) {
+        blockedReasons.push(`Railway IaC plan would delete desired resource ${name}.`);
+      }
+    }
+    if (desiredNames.scope === "staging" && change.kind === "resource.update" && /image/iu.test(String(change.summary))) {
+      blockedReasons.push(`Railway IaC plan would switch staging resource ${name} to an image source.`);
+    }
+    if (desiredNames.scope === "prod" && change.kind === "resource.update" && /github|repo|branch/iu.test(String(change.summary))) {
+      blockedReasons.push(`Railway IaC plan would switch production resource ${name} to a Git source.`);
+    }
+  }
+  return {
+    ok: blockedReasons.length === 0,
+    destructiveChanges,
+    blockedReasons,
+    allowedDrift: []
+  };
+}
+async function planRailwayIacProject(input, rendered = renderRailwayIacProject(input)) {
+  return runRailwayIac({
+    command: "plan",
+    cwd: rendered.tempDir,
+    file: rendered.filePath,
+    backboard: {
+      endpoint: input.railwayApiUrl?.trim() || void 0,
+      token: input.railwayApiToken,
+      authType: "bearer",
+      projectId: input.projectId,
+      environmentId: input.environmentId,
+      decryptVariables: false,
+      merge: true
+    }
+  });
+}
+async function applyRailwayIacProject(input, rendered = renderRailwayIacProject(input)) {
+  return runRailwayIac({
+    command: "apply",
+    cwd: rendered.tempDir,
+    file: rendered.filePath,
+    backboard: {
+      endpoint: input.railwayApiUrl?.trim() || void 0,
+      token: input.railwayApiToken,
+      authType: "bearer",
+      projectId: input.projectId,
+      environmentId: input.environmentId,
+      decryptVariables: false,
+      merge: true
+    }
+  });
+}
+function cleanupRailwayIacRender(rendered) {
+  rmSync(rendered.tempDir, { recursive: true, force: true });
+}
+export {
+  applyRailwayIacProject,
+  cleanupRailwayIacRender,
+  planRailwayIacProject,
+  renderRailwayIacProject,
+  validateRailwayIacChangeSet
+};

package/dist/reconcile/providers/release-private.d.ts

@@ -0,0 +1,92 @@
+import type { TreeseedReconcileRunContext, TreeseedReconcileSelector, TreeseedReconcileTarget } from '../contracts.js';
+export declare function runReleaseVerifyCommand(input: {
+    tenantRoot: string;
+    packageId: string;
+    env?: NodeJS.ProcessEnv;
+    onProgress?: (message: string) => void;
+}): Promise<{
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    status?: undefined;
+    signal?: undefined;
+    command?: undefined;
+    stdout?: undefined;
+    stderr?: undefined;
+} | {
+    ok: boolean;
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    command: import("../../index.js").TreeseedPackageCommand;
+    stdout: string;
+    stderr: string;
+    skipped?: undefined;
+    reason?: undefined;
+}>;
+export declare function runTemplateReleaseVerifyCommand(input: {
+    tenantRoot: string;
+    templateId: string;
+    env?: NodeJS.ProcessEnv;
+}): {
+    ok: boolean;
+    status: number | null;
+    command: string;
+    stdout: string;
+    stderr: string;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+};
+export declare function ensureTemplateReleaseTag(input: {
+    tenantRoot: string;
+    templateId: string;
+    tagName: string;
+}): {
+    templateId: string;
+    tagName: string;
+    head: string;
+    local: string;
+    remote: string;
+};
+export declare function writeReleaseRecord(input: {
+    tenantRoot: string;
+    recordPath: string;
+    record: Record<string, unknown>;
+}): {
+    path: string;
+    record: Record<string, unknown>;
+};
+export declare function runHostedReconcileGate(input: {
+    parentContext: TreeseedReconcileRunContext;
+    selector: TreeseedReconcileSelector;
+    target: TreeseedReconcileTarget;
+    dryRun: boolean;
+}): Promise<{
+    target: TreeseedReconcileTarget;
+    units: import("../contracts.js").TreeseedDesiredUnit[];
+    plans: import("../contracts.js").TreeseedReconcilePlan[];
+    results: import("../contracts.js").TreeseedReconcileResult[];
+    state: import("../contracts.js").TreeseedReconcileStateRecord;
+    timings: import("../../timing.js").TreeseedTimingEntry[];
+}>;
+export declare function runHostedVerifyGate(input: {
+    parentContext: TreeseedReconcileRunContext;
+    selector: TreeseedReconcileSelector;
+    target: TreeseedReconcileTarget;
+}): Promise<{
+    target: TreeseedReconcileTarget;
+    ready: boolean;
+    blockers: string[];
+    warnings: string[];
+    units: {
+        unitId: string;
+        unitType: import("../contracts.js").TreeseedReconcileUnitType;
+        provider: string;
+        status: import("../contracts.js").TreeseedReconcileStatusKind;
+        exists: boolean;
+        locators: Record<string, string | null>;
+        warnings: string[];
+        verification: import("../contracts.js").TreeseedUnitVerificationResult | null;
+    }[];
+}>;

package/dist/reconcile/providers/release-private.js

@@ -0,0 +1,152 @@
+import { spawn, spawnSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { findTreeseedPackageAdapter } from "../../operations/services/package-adapters.js";
+import { checkedOutTemplateRepositories } from "../../operations/services/managed-repositories.js";
+import { runTreeseedGitText } from "../../operations/services/git-runner.js";
+async function runReleaseVerifyCommand(input) {
+  const adapter = findTreeseedPackageAdapter(input.tenantRoot, input.packageId);
+  if (!adapter) {
+    throw new Error(`Package ${input.packageId} was not discovered.`);
+  }
+  const command = adapter.verifyCommands.release ?? adapter.verifyCommands.local;
+  if (!command) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: `${input.packageId} has no release verify command.`
+    };
+  }
+  const renderedCommand = [command.command, ...command.args].join(" ");
+  input.onProgress?.(`Running ${input.packageId} release verification: ${renderedCommand}`);
+  const started = Date.now();
+  let stdout = "";
+  let stderr = "";
+  const result = await new Promise((resolve2, reject) => {
+    const child = spawn(command.command, command.args, {
+      cwd: command.cwd,
+      env: { ...process.env, ...input.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const heartbeat = setInterval(() => {
+      input.onProgress?.(`Still running ${input.packageId} release verification after ${Math.round((Date.now() - started) / 1e3)}s.`);
+    }, 3e4);
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearInterval(heartbeat);
+      reject(error);
+    });
+    child.on("close", (status, signal) => {
+      clearInterval(heartbeat);
+      resolve2({ status, signal });
+    });
+  });
+  const elapsedSeconds = Math.round((Date.now() - started) / 1e3);
+  input.onProgress?.(`${input.packageId} release verification ${result.status === 0 ? "passed" : "failed"} in ${elapsedSeconds}s.`);
+  return {
+    ok: (result.status ?? 1) === 0,
+    status: result.status,
+    signal: result.signal,
+    command,
+    stdout,
+    stderr
+  };
+}
+function runTemplateCommand(command, cwd, env) {
+  const result = spawnSync("bash", ["-lc", command], {
+    cwd,
+    env: { ...process.env, ...env ?? {} },
+    encoding: "utf8"
+  });
+  return {
+    ok: (result.status ?? 1) === 0,
+    status: result.status,
+    command,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function runTemplateReleaseVerifyCommand(input) {
+  const repo = checkedOutTemplateRepositories(input.tenantRoot).find((candidate) => candidate.templateManifest?.id === input.templateId);
+  if (!repo?.templateManifest) {
+    throw new Error(`Template ${input.templateId} was not discovered.`);
+  }
+  const command = repo.templateManifest.verify.release ?? repo.templateManifest.verify.local;
+  if (!command) {
+    return {
+      ok: true,
+      skipped: true,
+      reason: `${input.templateId} has no release verify command.`
+    };
+  }
+  return runTemplateCommand(command, repo.dir, input.env);
+}
+function gitText(repoDir, args) {
+  return runTreeseedGitText(args, { cwd: repoDir, mode: "mutate" }).trim();
+}
+function gitTextAllowFailure(repoDir, args) {
+  try {
+    return gitText(repoDir, args);
+  } catch {
+    return null;
+  }
+}
+function ensureTemplateReleaseTag(input) {
+  const repo = checkedOutTemplateRepositories(input.tenantRoot).find((candidate) => candidate.templateManifest?.id === input.templateId);
+  if (!repo?.templateManifest) {
+    throw new Error(`Template ${input.templateId} was not discovered.`);
+  }
+  const head = gitText(repo.dir, ["rev-parse", "HEAD"]);
+  const local = gitTextAllowFailure(repo.dir, ["rev-list", "-n", "1", input.tagName]);
+  if (local && local !== head) {
+    throw new Error(`Template tag ${input.tagName} already exists at ${local}, expected ${head}.`);
+  }
+  if (!local) {
+    gitText(repo.dir, ["tag", "-a", input.tagName, head, "-m", `release: ${input.tagName}`]);
+  }
+  const remote = gitTextAllowFailure(repo.dir, ["ls-remote", "origin", `refs/tags/${input.tagName}`])?.split(/\s+/u)[0] ?? null;
+  if (remote && remote !== head) {
+    throw new Error(`Remote template tag ${input.tagName} already exists at ${remote}, expected ${head}.`);
+  }
+  if (!remote && repo.hasOriginRemote) {
+    gitText(repo.dir, ["push", "origin", input.tagName]);
+  }
+  return {
+    templateId: input.templateId,
+    tagName: input.tagName,
+    head,
+    local: local ? "existing" : "created",
+    remote: remote ? "existing" : repo.hasOriginRemote ? "pushed" : "skipped-no-origin"
+  };
+}
+function writeReleaseRecord(input) {
+  const absolutePath = resolve(input.tenantRoot, input.recordPath);
+  mkdirSync(dirname(absolutePath), { recursive: true });
+  writeFileSync(absolutePath, `${JSON.stringify(input.record, null, 2)}
+`, "utf8");
+  return {
+    path: absolutePath,
+    record: input.record
+  };
+}
+async function runHostedReconcileGate(input) {
+  const { reconcileTreeseedNestedTarget } = await import("../engine.js");
+  return reconcileTreeseedNestedTarget(input);
+}
+async function runHostedVerifyGate(input) {
+  const { verifyTreeseedNestedTarget } = await import("../engine.js");
+  return verifyTreeseedNestedTarget(input);
+}
+export {
+  ensureTemplateReleaseTag,
+  runHostedReconcileGate,
+  runHostedVerifyGate,
+  runReleaseVerifyCommand,
+  runTemplateReleaseVerifyCommand,
+  writeReleaseRecord
+};

package/dist/reconcile/registry.d.ts

@@ -1,5 +1,5 @@
-import type { TreeseedDeployConfig } from '../platform/contracts.ts';
-import type { TreeseedReconcileAdapter, TreeseedReconcileProviderId, TreeseedReconcileUnitType } from './contracts.ts';
+import type { TreeseedDeployConfig } from '../platform/contracts.js';
+import type { TreeseedReconcileAdapter, TreeseedReconcileProviderId, TreeseedReconcileUnitType } from './contracts.js';
 export type TreeseedReconcileRegistry = {
     adapters: TreeseedReconcileAdapter[];
     get(unitType: TreeseedReconcileUnitType, providerId: TreeseedReconcileProviderId): TreeseedReconcileAdapter;

package/dist/reconcile/registry.js

@@ -1,5 +1,14 @@
 import { loadTreeseedPlugins } from "../platform/plugins/runtime.js";
-import { createCloudflareReconcileAdapters, createRailwayReconcileAdapters } from "./builtin-adapters.js";
+import {
+  createCapacityProviderReconcileAdapters,
+  createCloudflareReconcileAdapters,
+  createDockerReconcileAdapters,
+  createGitHubReconcileAdapters,
+  createLocalProcessReconcileAdapters,
+  createPackageReconcileAdapters,
+  createRailwayReconcileAdapters,
+  createReleaseGateReconcileAdapters
+} from "./builtin-adapters.js";
 function normalizeAdapterContribution(contribution, context) {
   if (typeof contribution === "function") {
     return contribution(context);
@@ -33,6 +42,12 @@ function loadPluginReconcileAdapters(config) {
 }
 function createTreeseedReconcileRegistry(config) {
   const adapters = [
+    ...createReleaseGateReconcileAdapters(),
+    ...createPackageReconcileAdapters(),
+    ...createGitHubReconcileAdapters(),
+    ...createDockerReconcileAdapters(),
+    ...createLocalProcessReconcileAdapters(),
+    ...createCapacityProviderReconcileAdapters(),
     ...createCloudflareReconcileAdapters(),
     ...createRailwayReconcileAdapters(),
     ...loadPluginReconcileAdapters(config)

package/dist/reconcile/state.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDesiredUnit, TreeseedReconcileStateRecord, TreeseedReconcileTarget, TreeseedUnitPersistedState } from './contracts.ts';
+import type { TreeseedDesiredUnit, TreeseedReconcileStateRecord, TreeseedReconcileTarget, TreeseedUnitPersistedState } from './contracts.js';
 export declare function migrateLegacyDeployStateUnits(legacyState: Record<string, any>, target: TreeseedReconcileTarget): Record<string, TreeseedUnitPersistedState>;
 export declare function loadTreeseedReconcileState(tenantRoot: string, target: TreeseedReconcileTarget): TreeseedReconcileStateRecord;
 export declare function writeTreeseedReconcileState(tenantRoot: string, reconcileState: TreeseedReconcileStateRecord): void;