@treeseed/sdk 0.12.62 → 0.13.0-rc.10

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

@@ -1,89 +0,0 @@
-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;
-    dependencies?: undefined;
-} | {
-    ok: boolean;
-    skipped: boolean;
-    reason: string;
-    dependencies: {
-        status: "staging-proof-reused";
-        candidatePath: string;
-        packageCommit: string;
-        rootCommit: string;
-    };
-}>;
-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;
-    planOnly: 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

@@ -1,140 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, 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";
-function requireMatchingStageCandidate(tenantRoot, packageId, packageDir) {
-  const candidatePath = resolve(tenantRoot, ".treeseed/workflow/stage-candidates/latest.json");
-  if (!existsSync(candidatePath)) {
-    throw new Error(`Release verification requires a successful staged candidate; ${candidatePath} is missing.`);
-  }
-  const candidate = JSON.parse(readFileSync(candidatePath, "utf8"));
-  const packageProof = candidate.packages?.find((entry) => entry.name === packageId);
-  const packageHead = runTreeseedGitText(["rev-parse", "HEAD"], { cwd: packageDir, mode: "read" }).trim();
-  const rootHead = runTreeseedGitText(["rev-parse", "HEAD"], { cwd: tenantRoot, mode: "read" }).trim();
-  if (candidate.targetBranch !== "staging" || candidate.root?.verified !== true || candidate.root.commit !== rootHead || packageProof?.verified !== true || packageProof.commit !== packageHead) {
-    throw new Error(`Release verification requires ${packageId} and the Market root to match the latest verified staging candidate.`);
-  }
-  return {
-    status: "staging-proof-reused",
-    candidatePath,
-    packageCommit: packageHead,
-    rootCommit: rootHead
-  };
-}
-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 stagingProof = requireMatchingStageCandidate(input.tenantRoot, input.packageId, adapter.dir);
-  input.onProgress?.(`Reusing exact-SHA staging verification for ${input.packageId} at ${stagingProof.packageCommit.slice(0, 12)}.`);
-  return {
-    ok: true,
-    skipped: true,
-    reason: `${input.packageId} matches the latest verified staging candidate; tag workflows perform independent release verification before publication or deployment.`,
-    dependencies: stagingProof
-  };
-}
-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,7 +0,0 @@
-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;
-};
-export declare function createTreeseedReconcileRegistry(config: TreeseedDeployConfig): TreeseedReconcileRegistry;

package/dist/reconcile/registry.js

@@ -1,79 +0,0 @@
-import { loadTreeseedPlugins } from "../platform/plugins/runtime.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);
-  }
-  return contribution;
-}
-function loadPluginReconcileAdapters(config) {
-  const tenantRoot = config.__tenantRoot ?? process.cwd();
-  const plugins = loadTreeseedPlugins(config);
-  const adapters = [];
-  for (const entry of plugins) {
-    const plugin = entry.plugin;
-    const contributions = plugin.reconcileAdapters;
-    if (!contributions || typeof contributions !== "object") {
-      continue;
-    }
-    for (const contribution of Object.values(contributions)) {
-      const resolved = normalizeAdapterContribution(contribution, {
-        projectRoot: tenantRoot,
-        deployConfig: config,
-        tenantConfig: void 0,
-        pluginConfig: entry.config ?? {}
-      });
-      if (!resolved) {
-        continue;
-      }
-      adapters.push(resolved);
-    }
-  }
-  return adapters;
-}
-function createTreeseedReconcileRegistry(config) {
-  const adapters = [
-    ...createReleaseGateReconcileAdapters(),
-    ...createPackageReconcileAdapters(),
-    ...createGitHubReconcileAdapters(),
-    ...createDockerReconcileAdapters(),
-    ...createLocalProcessReconcileAdapters(),
-    ...createCapacityProviderReconcileAdapters(),
-    ...createCloudflareReconcileAdapters(),
-    ...createRailwayReconcileAdapters(),
-    ...loadPluginReconcileAdapters(config)
-  ];
-  const seenBindings = /* @__PURE__ */ new Map();
-  for (const adapter of adapters) {
-    for (const unitType of adapter.unitTypes) {
-      const bindingKey = `${adapter.providerId}:${unitType}`;
-      const existing = seenBindings.get(bindingKey);
-      if (existing) {
-        throw new Error(`Duplicate Treeseed reconcile adapter binding for ${bindingKey} (${existing}, ${adapter.providerId}).`);
-      }
-      seenBindings.set(bindingKey, adapter.providerId);
-    }
-  }
-  return {
-    adapters,
-    get(unitType, providerId) {
-      const adapter = adapters.find((candidate) => candidate.supports(unitType, providerId));
-      if (!adapter) {
-        throw new Error(`Treeseed reconcile adapter missing for ${providerId}:${unitType}.`);
-      }
-      return adapter;
-    }
-  };
-}
-export {
-  createTreeseedReconcileRegistry
-};

package/dist/reconcile/state.d.ts

@@ -1,7 +0,0 @@
-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, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): TreeseedReconcileStateRecord;
-export declare function writeTreeseedReconcileState(tenantRoot: string, reconcileState: TreeseedReconcileStateRecord, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): void;
-export declare function ensureTreeseedPersistedUnitState(reconcileState: TreeseedReconcileStateRecord, unit: TreeseedDesiredUnit): TreeseedUnitPersistedState;
-export declare function updateTreeseedPersistedUnitState(reconcileState: TreeseedReconcileStateRecord, state: TreeseedUnitPersistedState): void;
-export declare function desiredUnitSpecHash(unit: TreeseedDesiredUnit): string;

package/dist/reconcile/state.js

@@ -1,270 +0,0 @@
-import { createHash } from "node:crypto";
-import { loadTreeseedPlatformConfig } from "../platform/config.js";
-import { loadDeployState, resolveTreeseedResourceIdentity, writeDeployState } from "../operations/services/deploy.js";
-import { targetKey } from "./units.js";
-function stableHash(value) {
-  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
-}
-function railwayUnitTypeForServiceKey(serviceKey) {
-  if (serviceKey === "operationsRunner") {
-    return "railway-service:operations-runner";
-  }
-  if (serviceKey === "workdayManager") {
-    return "railway-service:workday-manager";
-  }
-  if (serviceKey === "workerRunner") {
-    return "railway-service:worker-runner";
-  }
-  return `railway-service:${serviceKey}`;
-}
-function emptyPersistedUnitState(unit) {
-  return {
-    unitId: unit.unitId,
-    unitType: unit.unitType,
-    provider: unit.provider,
-    identity: unit.identity,
-    target: unit.target,
-    logicalName: unit.logicalName,
-    desiredSpecHash: stableHash(unit.spec),
-    lastObservedAt: null,
-    lastReconciledAt: null,
-    lastVerifiedAt: null,
-    lastStatus: "pending",
-    lastObservedState: {},
-    lastReconciledState: {},
-    lastDiff: null,
-    lastVerification: null,
-    lastAction: null,
-    resourceLocators: {},
-    warnings: [],
-    error: null
-  };
-}
-function migrateLegacyDeployStateUnits(legacyState, target) {
-  const identity = legacyState.identity ?? resolveTreeseedResourceIdentity({
-    slug: legacyState.hosting?.projectId ?? legacyState.runtime?.projectId ?? "project",
-    hosting: legacyState.hosting ?? {},
-    runtime: legacyState.runtime ?? {},
-    cloudflare: {}
-  }, target);
-  const units = {};
-  const db = legacyState.d1Databases?.SITE_DATA_DB;
-  if (db?.databaseName) {
-    units[`database:${db.databaseName}`] = {
-      unitId: `database:${db.databaseName}`,
-      unitType: "database",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: db.databaseName,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: db.databaseId ? "ready" : "pending",
-      lastObservedState: {
-        databaseName: db.databaseName,
-        databaseId: db.databaseId ?? null,
-        previewDatabaseId: db.previewDatabaseId ?? null
-      },
-      lastReconciledState: {
-        databaseName: db.databaseName,
-        databaseId: db.databaseId ?? null,
-        previewDatabaseId: db.previewDatabaseId ?? null
-      },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        databaseId: db.databaseId ?? null,
-        previewDatabaseId: db.previewDatabaseId ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  for (const [binding, namespace] of Object.entries(legacyState.kvNamespaces ?? {})) {
-    if (binding !== "FORM_GUARD_KV") continue;
-    const record = namespace;
-    if (!record?.name) continue;
-    const unitType = "kv-form-guard";
-    units[`${unitType}:${record.name}`] = {
-      unitId: `${unitType}:${record.name}`,
-      unitType,
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: record.name,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: record.id ? "ready" : "pending",
-      lastObservedState: { ...record },
-      lastReconciledState: { ...record },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        id: record.id ?? null,
-        previewId: record.previewId ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  if (legacyState.content?.bucketName) {
-    units[`content-store:${legacyState.content.bucketName}`] = {
-      unitId: `content-store:${legacyState.content.bucketName}`,
-      unitType: "content-store",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: legacyState.content.bucketName,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: "ready",
-      lastObservedState: { ...legacyState.content },
-      lastReconciledState: { ...legacyState.content },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        bucketName: legacyState.content.bucketName,
-        r2Binding: legacyState.content.r2Binding ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  if (legacyState.pages?.projectName) {
-    units[`pages-project:${legacyState.pages.projectName}`] = {
-      unitId: `pages-project:${legacyState.pages.projectName}`,
-      unitType: "pages-project",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: legacyState.pages.projectName,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: "ready",
-      lastObservedState: { ...legacyState.pages },
-      lastReconciledState: { ...legacyState.pages },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        projectName: legacyState.pages.projectName,
-        url: legacyState.pages.url ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  if (legacyState.workerName) {
-    units[`edge-worker:${legacyState.workerName}`] = {
-      unitId: `edge-worker:${legacyState.workerName}`,
-      unitType: "edge-worker",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: legacyState.workerName,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: legacyState.workerName ? "ready" : "pending",
-      lastObservedState: { workerName: legacyState.workerName, lastDeployedUrl: legacyState.lastDeployedUrl ?? null },
-      lastReconciledState: { workerName: legacyState.workerName, lastDeployedUrl: legacyState.lastDeployedUrl ?? null },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        workerName: legacyState.workerName,
-        url: legacyState.lastDeployedUrl ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  for (const [serviceKey, service] of Object.entries(legacyState.services ?? {})) {
-    const record = service;
-    if (!record?.enabled || record.provider !== "railway") {
-      continue;
-    }
-    const unitType = railwayUnitTypeForServiceKey(serviceKey);
-    const logicalName = record.serviceName ?? record.serviceId ?? serviceKey;
-    units[`${unitType}:${logicalName}`] = {
-      unitId: `${unitType}:${logicalName}`,
-      unitType,
-      provider: "railway",
-      identity,
-      target,
-      logicalName,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: record.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: record.initialized ? "ready" : "pending",
-      lastObservedState: { ...record },
-      lastReconciledState: { ...record },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        projectId: record.projectId ?? null,
-        serviceId: record.serviceId ?? null,
-        serviceName: record.serviceName ?? null,
-        publicBaseUrl: record.publicBaseUrl ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
-  return units;
-}
-function loadTreeseedReconcileState(tenantRoot, target, env = process.env) {
-  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: target.kind === "persistent" ? target.scope : "staging", env }).deployConfig;
-  const legacyState = loadDeployState(tenantRoot, deployConfig, { target });
-  const persistedUnits = legacyState.units && typeof legacyState.units === "object" ? legacyState.units : migrateLegacyDeployStateUnits(legacyState, target);
-  return {
-    version: 1,
-    target,
-    dependencyGraphVersion: legacyState.reconciliation?.dependencyGraphVersion ?? 1,
-    units: { ...persistedUnits }
-  };
-}
-function writeTreeseedReconcileState(tenantRoot, reconcileState, env = process.env) {
-  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: reconcileState.target.kind === "persistent" ? reconcileState.target.scope : "staging", env }).deployConfig;
-  const legacyState = loadDeployState(tenantRoot, deployConfig, { target: reconcileState.target });
-  writeDeployState(tenantRoot, {
-    ...legacyState,
-    reconciliation: {
-      version: reconcileState.version,
-      dependencyGraphVersion: reconcileState.dependencyGraphVersion,
-      targetKey: targetKey(reconcileState.target)
-    },
-    units: reconcileState.units
-  }, { target: reconcileState.target });
-}
-function ensureTreeseedPersistedUnitState(reconcileState, unit) {
-  return reconcileState.units[unit.unitId] ?? emptyPersistedUnitState(unit);
-}
-function updateTreeseedPersistedUnitState(reconcileState, state) {
-  reconcileState.units[state.unitId] = state;
-}
-function desiredUnitSpecHash(unit) {
-  return stableHash(unit.spec);
-}
-export {
-  desiredUnitSpecHash,
-  ensureTreeseedPersistedUnitState,
-  loadTreeseedReconcileState,
-  migrateLegacyDeployStateUnits,
-  updateTreeseedPersistedUnitState,
-  writeTreeseedReconcileState
-};

package/dist/reconcile/units.d.ts

@@ -1,6 +0,0 @@
-import type { TreeseedDesiredUnit, TreeseedReconcileTarget, TreeseedReconcileUnitType } from './contracts.js';
-export declare const TRESEED_RECONCILE_UNIT_TYPES: TreeseedReconcileUnitType[];
-export declare function targetKey(target: TreeseedReconcileTarget): string;
-export declare function createTreeseedReconcileUnitId(unitType: TreeseedReconcileUnitType, logicalName: string): string;
-export declare function topologicallySortDesiredUnits(units: TreeseedDesiredUnit[]): TreeseedDesiredUnit[];
-export declare function reverseTopologicallySortedUnits(units: TreeseedDesiredUnit[]): TreeseedDesiredUnit[];

package/dist/reconcile/units.js

@@ -1,72 +0,0 @@
-const TRESEED_RECONCILE_UNIT_TYPES = [
-  "web-ui",
-  "api-runtime",
-  "operations-runner-runtime",
-  "workday-manager-runtime",
-  "worker-runner-runtime",
-  "edge-worker",
-  "content-store",
-  "queue",
-  "database",
-  "kv-form-guard",
-  "turnstile-widget",
-  "pages-project",
-  "custom-domain:web",
-  "custom-domain:api",
-  "dns-record",
-  "railway-service:api",
-  "railway-service:operations-runner",
-  "railway-service:workday-manager",
-  "railway-service:worker-runner",
-  "branch-preview",
-  "branch-preview-cleanup",
-  "workflow-gate",
-  "save-gate:local-verify",
-  "save-gate:promotion-readiness",
-  "save-gate:hosted-verify"
-];
-function targetKey(target) {
-  return target.kind === "persistent" ? target.scope : `branch:${target.branchName}`;
-}
-function createTreeseedReconcileUnitId(unitType, logicalName) {
-  return `${unitType}:${logicalName}`;
-}
-function topologicallySortDesiredUnits(units) {
-  const byId = new Map(units.map((unit) => [unit.unitId, unit]));
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const output = [];
-  const visit = (unit) => {
-    if (visited.has(unit.unitId)) {
-      return;
-    }
-    if (visiting.has(unit.unitId)) {
-      throw new Error(`Treeseed reconcile dependency cycle detected at ${unit.unitId}.`);
-    }
-    visiting.add(unit.unitId);
-    for (const dependencyId of unit.dependencies) {
-      const dependency = byId.get(dependencyId);
-      if (!dependency) {
-        throw new Error(`Treeseed reconcile dependency ${dependencyId} referenced by ${unit.unitId} is missing.`);
-      }
-      visit(dependency);
-    }
-    visiting.delete(unit.unitId);
-    visited.add(unit.unitId);
-    output.push(unit);
-  };
-  for (const unit of units) {
-    visit(unit);
-  }
-  return output;
-}
-function reverseTopologicallySortedUnits(units) {
-  return [...topologicallySortDesiredUnits(units)].reverse();
-}
-export {
-  TRESEED_RECONCILE_UNIT_TYPES,
-  createTreeseedReconcileUnitId,
-  reverseTopologicallySortedUnits,
-  targetKey,
-  topologicallySortDesiredUnits
-};