@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/reconcile/contracts.d.ts

@@ -1,172 +0,0 @@
-import type { TreeseedDeployConfig } from '../platform/contracts.js';
-export type TreeseedReconcileProviderId = string;
-export type TreeseedReconcileActionKind = 'noop' | 'create' | 'update' | 'replace' | 'delete' | 'adopt' | 'rename' | 'reattach' | 'retain' | 'taint' | 'blocked';
-export type TreeseedReconcileStatusKind = 'pending' | 'ready' | 'drifted' | 'error';
-export type TreeseedReconcileVerificationSource = 'cli' | 'api' | 'sdk' | 'derived';
-export type TreeseedReconcileUnitType = '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' | 'package-manifest' | 'template-manifest' | 'package-workflow' | 'package-image' | 'github-environment' | 'github-secret-binding' | 'github-variable-binding' | 'github-workflow-dispatch' | 'docker-image-build' | 'local-docker-compose' | 'local-treedx' | 'local-content-materialization' | 'local-process' | 'capacity-provider' | 'branch-preview' | 'branch-preview-cleanup' | 'workflow-gate' | 'save-gate:local-verify' | 'save-gate:promotion-readiness' | 'save-gate:hosted-verify' | 'release-gate:verify' | 'release-gate:template-verify' | 'release-gate:template-release-record' | 'release-gate:npm-publish' | 'release-gate:image-publish' | 'release-gate:hosted-reconcile' | 'release-gate:live-verify' | 'release-gate:candidate-record' | 'release-gate:production-record';
-export type TreeseedReconcileTarget = {
-    kind: 'persistent';
-    scope: 'local' | 'staging' | 'prod';
-} | {
-    kind: 'branch';
-    branchName: string;
-};
-export type TreeseedReconcileUnitId = string;
-export interface TreeseedReconcileIdentity {
-    teamId: string;
-    projectId: string;
-    slug: string;
-    environment: string;
-    deploymentKey: string;
-    environmentKey: string;
-}
-export interface TreeseedDesiredUnit {
-    unitId: TreeseedReconcileUnitId;
-    unitType: TreeseedReconcileUnitType;
-    provider: TreeseedReconcileProviderId;
-    identity: TreeseedReconcileIdentity;
-    target: TreeseedReconcileTarget;
-    logicalName: string;
-    dependencies: TreeseedReconcileUnitId[];
-    spec: Record<string, unknown>;
-    secrets: Record<string, string | null | undefined>;
-    metadata: Record<string, unknown>;
-}
-export interface TreeseedReconcileSelector {
-    environment?: 'local' | 'staging' | 'prod';
-    host?: string[];
-    packageId?: string[];
-    appId?: string[];
-    serviceId?: string[];
-    serviceType?: string[];
-    placement?: string[];
-    resourceKind?: string[];
-    unitId?: string[];
-    unitType?: TreeseedReconcileUnitType[];
-    provider?: string[];
-}
-export interface TreeseedObservedUnitState {
-    exists: boolean;
-    status: TreeseedReconcileStatusKind;
-    live: Record<string, unknown>;
-    locators: Record<string, string | null>;
-    warnings: string[];
-}
-export interface TreeseedUnitDiff {
-    action: TreeseedReconcileActionKind;
-    reasons: string[];
-    before: Record<string, unknown>;
-    after: Record<string, unknown>;
-}
-export interface TreeseedUnitPersistedState {
-    unitId: TreeseedReconcileUnitId;
-    unitType: TreeseedReconcileUnitType;
-    provider: TreeseedReconcileProviderId;
-    identity: TreeseedReconcileIdentity;
-    target: TreeseedReconcileTarget;
-    logicalName: string;
-    desiredSpecHash: string;
-    lastObservedAt: string | null;
-    lastReconciledAt: string | null;
-    lastVerifiedAt: string | null;
-    lastStatus: TreeseedReconcileStatusKind;
-    lastObservedState: Record<string, unknown>;
-    lastReconciledState: Record<string, unknown>;
-    lastDiff: TreeseedUnitDiff | null;
-    lastVerification: TreeseedUnitVerificationResult | null;
-    lastAction: TreeseedReconcileActionKind | null;
-    resourceLocators: Record<string, string | null>;
-    warnings: string[];
-    error: string | null;
-}
-export interface TreeseedUnitPostcondition {
-    key: string;
-    description: string;
-}
-export interface TreeseedUnitVerificationCheck {
-    key: string;
-    description: string;
-    source: TreeseedReconcileVerificationSource;
-    exists: boolean;
-    configured: boolean;
-    ready: boolean;
-    verified: boolean;
-    expected?: unknown;
-    observed?: unknown;
-    issues: string[];
-}
-export interface TreeseedUnitVerificationResult {
-    unitId: TreeseedReconcileUnitId;
-    supported: boolean;
-    exists: boolean;
-    configured: boolean;
-    ready: boolean;
-    verified: boolean;
-    checks: TreeseedUnitVerificationCheck[];
-    missing: string[];
-    drifted: string[];
-    warnings: string[];
-}
-export interface TreeseedReconcilePlan {
-    unit: TreeseedDesiredUnit;
-    observed: TreeseedObservedUnitState;
-    diff: TreeseedUnitDiff;
-    persisted: TreeseedUnitPersistedState | null;
-}
-export interface TreeseedReconcileResult {
-    unit: TreeseedDesiredUnit;
-    observed: TreeseedObservedUnitState;
-    diff: TreeseedUnitDiff;
-    action: TreeseedReconcileActionKind;
-    warnings: string[];
-    resourceLocators: Record<string, string | null>;
-    state: Record<string, unknown>;
-    verification: TreeseedUnitVerificationResult | null;
-}
-export interface TreeseedReconcileRunContext {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    deployConfig: TreeseedDeployConfig;
-    launchEnv: NodeJS.ProcessEnv;
-    planOnly?: boolean;
-    write?: (line: string) => void;
-    session: Map<string, unknown>;
-}
-export interface TreeseedReconcileAdapterInput {
-    context: TreeseedReconcileRunContext;
-    unit: TreeseedDesiredUnit;
-    persistedState: TreeseedUnitPersistedState | null;
-}
-export interface TreeseedReconcileAdapter {
-    providerId: TreeseedReconcileProviderId;
-    unitTypes: TreeseedReconcileUnitType[];
-    supports(unitType: TreeseedReconcileUnitType, providerId: TreeseedReconcileProviderId): boolean;
-    validate?(input: TreeseedReconcileAdapterInput): Promise<void> | void;
-    requiredPostconditions?(input: TreeseedReconcileAdapterInput): Promise<TreeseedUnitPostcondition[]> | TreeseedUnitPostcondition[];
-    refresh(input: TreeseedReconcileAdapterInput): Promise<TreeseedObservedUnitState> | TreeseedObservedUnitState;
-    diff(input: TreeseedReconcileAdapterInput & {
-        observed: TreeseedObservedUnitState;
-    }): Promise<TreeseedUnitDiff> | TreeseedUnitDiff;
-    apply(input: TreeseedReconcileAdapterInput & {
-        observed: TreeseedObservedUnitState;
-        diff: TreeseedUnitDiff;
-    }): Promise<TreeseedReconcileResult> | TreeseedReconcileResult;
-    verify(input: TreeseedReconcileAdapterInput & {
-        observed: TreeseedObservedUnitState;
-        diff: TreeseedUnitDiff;
-        result: TreeseedReconcileResult | null;
-        postconditions: TreeseedUnitPostcondition[];
-    }): Promise<TreeseedUnitVerificationResult> | TreeseedUnitVerificationResult;
-    destroy?(input: TreeseedReconcileAdapterInput & {
-        observed: TreeseedObservedUnitState;
-    }): Promise<TreeseedReconcileResult> | TreeseedReconcileResult;
-    importOrAdopt?(input: TreeseedReconcileAdapterInput & {
-        observed: TreeseedObservedUnitState;
-    }): Promise<TreeseedReconcileResult> | TreeseedReconcileResult;
-}
-export interface TreeseedReconcileStateRecord {
-    version: 1;
-    target: TreeseedReconcileTarget;
-    dependencyGraphVersion: number;
-    units: Record<TreeseedReconcileUnitId, TreeseedUnitPersistedState>;
-}

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

@@ -1,10 +0,0 @@
-import type { TreeseedDesiredUnit, TreeseedReconcileTarget } from './contracts.js';
-export declare function deriveTreeseedDesiredUnits({ tenantRoot, target, env, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-}): {
-    deployConfig: import("../platform/contracts.js").TreeseedDeployConfig;
-    legacyState: any;
-    units: TreeseedDesiredUnit[];
-};

package/dist/reconcile/desired-state.js

@@ -1,322 +0,0 @@
-import { loadTreeseedPlatformConfig } from "../platform/config.js";
-import {
-  loadDeployState,
-  resolveConfiguredSurfaceDomain,
-  resolveTreeseedResourceIdentity
-} from "../operations/services/deploy.js";
-import { configuredRailwayServices } from "../operations/services/railway-deploy.js";
-import { normalizeRailwayEnvironmentName } from "../operations/services/railway-api.js";
-import { createTreeseedReconcileUnitId } from "./units.js";
-function railwayConcreteUnitTypeForServiceKey(serviceKey) {
-  switch (serviceKey) {
-    case "api":
-      return "railway-service:api";
-    case "operationsRunner":
-      return "railway-service:operations-runner";
-    case "workdayManager":
-      return "railway-service:workday-manager";
-    case "workerRunner":
-      return "railway-service:worker-runner";
-    default:
-      return "railway-service:api";
-  }
-}
-function isPublicTreeDxNodeServiceKey(serviceKey) {
-  return serviceKey.startsWith("public-treedx-node-");
-}
-function deriveTreeseedDesiredUnits({
-  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 identity = legacyState.identity ?? resolveTreeseedResourceIdentity(deployConfig, target);
-  const units = [];
-  const add = (unit) => {
-    units.push(unit);
-    return unit.unitId;
-  };
-  const databaseId = add({
-    unitId: createTreeseedReconcileUnitId("database", legacyState.d1Databases.SITE_DATA_DB.databaseName),
-    unitType: "database",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.d1Databases.SITE_DATA_DB.databaseName,
-    dependencies: [],
-    spec: {
-      databaseName: legacyState.d1Databases.SITE_DATA_DB.databaseName,
-      binding: "SITE_DATA_DB"
-    },
-    secrets: {},
-    metadata: { bootstrapSystem: "data" }
-  });
-  const formGuardKvId = add({
-    unitId: createTreeseedReconcileUnitId("kv-form-guard", legacyState.kvNamespaces.FORM_GUARD_KV.name),
-    unitType: "kv-form-guard",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.kvNamespaces.FORM_GUARD_KV.name,
-    dependencies: [],
-    spec: { binding: "FORM_GUARD_KV", name: legacyState.kvNamespaces.FORM_GUARD_KV.name },
-    secrets: {},
-    metadata: { bootstrapSystem: "web" }
-  });
-  const turnstileWidgetId = legacyState.turnstileWidgets?.formGuard?.name && deployConfig.turnstile?.enabled === true ? add({
-    unitId: createTreeseedReconcileUnitId("turnstile-widget", legacyState.turnstileWidgets.formGuard.name),
-    unitType: "turnstile-widget",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.turnstileWidgets.formGuard.name,
-    dependencies: [],
-    spec: {
-      name: legacyState.turnstileWidgets.formGuard.name,
-      domains: legacyState.turnstileWidgets.formGuard.domains ?? [],
-      mode: "managed"
-    },
-    secrets: {},
-    metadata: { bootstrapSystem: "web" }
-  }) : null;
-  const contentStoreId = add({
-    unitId: createTreeseedReconcileUnitId("content-store", legacyState.content.bucketName ?? deployConfig.slug),
-    unitType: "content-store",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.content.bucketName ?? deployConfig.slug,
-    dependencies: [],
-    spec: {
-      bucketName: legacyState.content.bucketName,
-      binding: legacyState.content.r2Binding,
-      publicBaseUrl: legacyState.content.publicBaseUrl,
-      manifestKeyTemplate: legacyState.content.manifestKeyTemplate,
-      previewRootTemplate: legacyState.content.previewRootTemplate
-    },
-    secrets: {},
-    metadata: { shared: true, bootstrapSystem: "data" }
-  });
-  const pagesProjectId = add({
-    unitId: createTreeseedReconcileUnitId("pages-project", legacyState.pages.projectName),
-    unitType: "pages-project",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.pages.projectName,
-    dependencies: [],
-    spec: {
-      projectName: legacyState.pages.projectName,
-      productionBranch: legacyState.pages.productionBranch,
-      stagingBranch: legacyState.pages.stagingBranch,
-      buildOutputDir: legacyState.pages.buildOutputDir
-    },
-    secrets: {},
-    metadata: { bootstrapSystem: "web" }
-  });
-  const edgeWorkerId = add({
-    unitId: createTreeseedReconcileUnitId("edge-worker", legacyState.workerName),
-    unitType: "edge-worker",
-    provider: "cloudflare",
-    identity,
-    target,
-    logicalName: legacyState.workerName,
-    dependencies: [databaseId, formGuardKvId, ...turnstileWidgetId ? [turnstileWidgetId] : [], contentStoreId, pagesProjectId],
-    spec: {
-      workerName: legacyState.workerName
-    },
-    secrets: {},
-    metadata: { bootstrapSystem: "web" }
-  });
-  if (deployConfig.surfaces?.web?.enabled !== false) {
-    const scope2 = target.kind === "persistent" ? target.scope : "staging";
-    const webDomain = target.kind === "persistent" ? resolveConfiguredSurfaceDomain(deployConfig, target, "web") : null;
-    const webDomainUnitId = webDomain ? add({
-      unitId: createTreeseedReconcileUnitId("custom-domain:web", webDomain),
-      unitType: "custom-domain:web",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: webDomain,
-      dependencies: [pagesProjectId],
-      spec: {
-        domain: webDomain,
-        projectName: legacyState.pages.projectName
-      },
-      secrets: {},
-      metadata: { surface: "web", bootstrapSystem: "web" }
-    }) : null;
-    const webDnsUnitId = webDomain ? add({
-      unitId: createTreeseedReconcileUnitId("dns-record", `web:${webDomain}`),
-      unitType: "dns-record",
-      provider: deployConfig.providers?.dns ?? "cloudflare-dns",
-      identity,
-      target,
-      logicalName: `web:${webDomain}`,
-      dependencies: webDomainUnitId ? [webDomainUnitId] : [],
-      spec: {
-        domain: webDomain,
-        zoneHost: webDomain,
-        recordName: webDomain,
-        recordType: "CNAME",
-        recordContent: scope2 === "prod" ? `${legacyState.pages.projectName}.pages.dev` : `${legacyState.pages.stagingBranch ?? "staging"}.${legacyState.pages.projectName}.pages.dev`,
-        proxied: true,
-        targetKind: "pages-project"
-      },
-      secrets: {},
-      metadata: { surface: "web", bootstrapSystem: "web" }
-    }) : null;
-    add({
-      unitId: createTreeseedReconcileUnitId("web-ui", "web-ui"),
-      unitType: "web-ui",
-      provider: "treeseed",
-      identity,
-      target,
-      logicalName: "web-ui",
-      dependencies: [
-        edgeWorkerId,
-        pagesProjectId,
-        contentStoreId,
-        ...webDomainUnitId ? [webDomainUnitId] : [],
-        ...webDnsUnitId ? [webDnsUnitId] : []
-      ],
-      spec: {
-        publicBaseUrl: deployConfig.surfaces?.web?.publicBaseUrl ?? deployConfig.siteUrl,
-        localBaseUrl: deployConfig.surfaces?.web?.localBaseUrl ?? null
-      },
-      secrets: {},
-      metadata: { bootstrapSystem: "web" }
-    });
-  }
-  const scope = target.kind === "persistent" ? target.scope : "staging";
-  for (const configuredService of configuredRailwayServices(tenantRoot, scope, env)) {
-    const serviceKey = configuredService.key;
-    const service = configuredService.serviceConfig ?? deployConfig.services?.[serviceKey];
-    const serviceState = legacyState.services?.[serviceKey];
-    if (isPublicTreeDxNodeServiceKey(serviceKey)) {
-    } else if (!service || service.enabled === false || service.provider !== "railway") {
-      continue;
-    }
-    const concreteType = railwayConcreteUnitTypeForServiceKey(serviceKey);
-    const serviceBootstrapSystem = serviceKey === "api" || serviceKey === "operationsRunner" || isPublicTreeDxNodeServiceKey(serviceKey) ? "api" : "agents";
-    const desiredServiceName = configuredService.serviceName ?? serviceState?.serviceName ?? serviceKey;
-    const desiredProjectName = configuredService.projectName ?? serviceState?.projectName;
-    const persistedServiceMatchesDesired = (!serviceState?.serviceName || serviceState.serviceName === desiredServiceName) && (!serviceState?.projectName || serviceState.projectName === desiredProjectName);
-    const concreteId = add({
-      unitId: createTreeseedReconcileUnitId(concreteType, desiredServiceName),
-      unitType: concreteType,
-      provider: "railway",
-      identity,
-      target,
-      logicalName: desiredServiceName,
-      dependencies: [],
-      spec: {
-        projectId: persistedServiceMatchesDesired ? serviceState?.projectId ?? configuredService.projectId : configuredService.projectId,
-        projectName: desiredProjectName,
-        serviceId: persistedServiceMatchesDesired ? serviceState?.serviceId ?? configuredService.serviceId : configuredService.serviceId,
-        serviceName: desiredServiceName,
-        rootDir: configuredService.rootDir ?? serviceState?.rootDir,
-        imageRef: configuredService.imageRef,
-        imageRefEnv: configuredService.serviceConfig?.railway?.imageRefEnv,
-        sourceMode: configuredService.sourceMode,
-        sourceRepo: configuredService.sourceRepo,
-        sourceBranch: configuredService.sourceBranch,
-        sourceCommit: configuredService.sourceCommit,
-        sourceRootDirectory: configuredService.sourceRootDirectory,
-        environment: normalizeRailwayEnvironmentName(configuredService.railwayEnvironment ?? serviceState?.environment),
-        buildCommand: configuredService.buildCommand,
-        startCommand: configuredService.startCommand,
-        healthcheckPath: configuredService.healthcheckPath,
-        healthcheckTimeoutSeconds: configuredService.healthcheckTimeoutSeconds,
-        healthcheckIntervalSeconds: configuredService.healthcheckIntervalSeconds,
-        restartPolicy: configuredService.restartPolicy,
-        runtimeMode: configuredService.runtimeMode,
-        schedule: serviceState?.schedule ?? configuredService.schedule,
-        publicBaseUrl: serviceState?.publicBaseUrl ?? configuredService.publicBaseUrl
-      },
-      secrets: {},
-      metadata: {
-        serviceKey,
-        serviceInstanceKey: configuredService.instanceKey ?? desiredServiceName,
-        scheduleManaged: Array.isArray(configuredService.schedule) && configuredService.schedule.length > 0,
-        scheduleBootstrap: false,
-        scheduleDeployScopes: ["staging", "prod"],
-        bootstrapSystem: serviceBootstrapSystem
-      }
-    });
-    const apiDomain = serviceKey === "api" && target.kind === "persistent" ? resolveConfiguredSurfaceDomain(deployConfig, target, "api") : null;
-    const apiCustomDomainId = apiDomain ? add({
-      unitId: createTreeseedReconcileUnitId("custom-domain:api", apiDomain),
-      unitType: "custom-domain:api",
-      provider: "railway",
-      identity,
-      target,
-      logicalName: apiDomain,
-      dependencies: [concreteId],
-      spec: {
-        domain: apiDomain,
-        serviceName: desiredServiceName,
-        projectName: desiredProjectName,
-        environment: normalizeRailwayEnvironmentName(configuredService.railwayEnvironment ?? serviceState?.environment)
-      },
-      secrets: {},
-      metadata: { surface: "api", serviceKey, bootstrapSystem: "api" }
-    }) : null;
-    const apiDnsUnitId = apiDomain ? add({
-      unitId: createTreeseedReconcileUnitId("dns-record", `api:${apiDomain}`),
-      unitType: "dns-record",
-      provider: deployConfig.providers?.dns ?? "cloudflare-dns",
-      identity,
-      target,
-      logicalName: `api:${apiDomain}`,
-      dependencies: apiCustomDomainId ? [apiCustomDomainId] : [concreteId],
-      spec: {
-        domain: apiDomain,
-        zoneHost: apiDomain,
-        targetKind: "railway-service",
-        serviceKey
-      },
-      secrets: {},
-      metadata: { surface: "api", serviceKey, bootstrapSystem: "api" }
-    }) : null;
-    const runtimeUnitType = (() => {
-      switch (serviceKey) {
-        case "api":
-          return "api-runtime";
-        case "operationsRunner":
-          return "operations-runner-runtime";
-        case "workdayManager":
-          return "workday-manager-runtime";
-        case "workerRunner":
-          return "worker-runner-runtime";
-        default:
-          return isPublicTreeDxNodeServiceKey(serviceKey) ? "api-runtime" : "api-runtime";
-      }
-    })();
-    const runtimeInstanceKey = serviceKey === "operationsRunner" ? configuredService.instanceKey ?? desiredServiceName : serviceKey;
-    add({
-      unitId: createTreeseedReconcileUnitId(runtimeUnitType, runtimeInstanceKey),
-      unitType: runtimeUnitType,
-      provider: "treeseed",
-      identity,
-      target,
-      logicalName: runtimeInstanceKey,
-      dependencies: [
-        concreteId,
-        ...apiCustomDomainId ? [apiCustomDomainId] : [],
-        ...apiDnsUnitId ? [apiDnsUnitId] : []
-      ],
-      spec: {
-        serviceKey,
-        publicBaseUrl: serviceState?.publicBaseUrl ?? null
-      },
-      secrets: {},
-      metadata: { serviceKey, bootstrapSystem: serviceBootstrapSystem }
-    });
-  }
-  return { deployConfig, legacyState, units };
-}
-export {
-  deriveTreeseedDesiredUnits
-};

package/dist/reconcile/engine.d.ts

@@ -1,118 +0,0 @@
-import type { TreeseedDesiredUnit, TreeseedObservedUnitState, TreeseedReconcilePlan, TreeseedReconcileResult, TreeseedReconcileRunContext, TreeseedReconcileSelector, TreeseedReconcileStateRecord, TreeseedReconcileTarget, TreeseedUnitVerificationResult } from './contracts.js';
-import { type TreeseedRunnableBootstrapSystem } from './bootstrap-systems.js';
-import { type TreeseedTimingEntry } from '../timing.js';
-export declare function refreshTreeseedUnits({ tenantRoot, target, env, systems, selector, units: explicitUnits, write, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-    systems?: TreeseedRunnableBootstrapSystem[];
-    selector?: TreeseedReconcileSelector;
-    units?: TreeseedDesiredUnit[];
-    write?: (line: string) => void;
-}): Promise<{
-    units: TreeseedDesiredUnit[];
-    observations: Map<string, TreeseedObservedUnitState>;
-    state: TreeseedReconcileStateRecord;
-    deployConfig: import("../platform/contracts.js").TreeseedDeployConfig;
-}>;
-export declare function planTreeseedReconciliation({ tenantRoot, target, env, systems, selector, units, write, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-    systems?: TreeseedRunnableBootstrapSystem[];
-    selector?: TreeseedReconcileSelector;
-    units?: TreeseedDesiredUnit[];
-    write?: (line: string) => void;
-}): Promise<{
-    plans: TreeseedReconcilePlan[];
-    units: TreeseedDesiredUnit[];
-    observations: Map<string, TreeseedObservedUnitState>;
-    state: TreeseedReconcileStateRecord;
-    deployConfig: import("../platform/contracts.js").TreeseedDeployConfig;
-}>;
-export declare function reconcileTreeseedTarget({ tenantRoot, target, env, systems, selector, units, write, planOnly, session, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-    systems?: TreeseedRunnableBootstrapSystem[];
-    selector?: TreeseedReconcileSelector;
-    units?: TreeseedDesiredUnit[];
-    write?: (line: string) => void;
-    planOnly?: boolean;
-    session?: Map<string, unknown>;
-}): Promise<{
-    target: TreeseedReconcileTarget;
-    units: TreeseedDesiredUnit[];
-    plans: TreeseedReconcilePlan[];
-    results: TreeseedReconcileResult[];
-    state: TreeseedReconcileStateRecord;
-    timings: TreeseedTimingEntry[];
-}>;
-export declare function destroyTreeseedTargetUnits({ tenantRoot, target, env, selector, units: explicitUnits, write, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-    selector?: TreeseedReconcileSelector;
-    units?: TreeseedDesiredUnit[];
-    write?: (line: string) => void;
-}): Promise<{
-    target: TreeseedReconcileTarget;
-    results: TreeseedReconcileResult[];
-}>;
-export declare function collectTreeseedReconcileStatus({ tenantRoot, target, env, systems, selector, units, session, }: {
-    tenantRoot: string;
-    target: TreeseedReconcileTarget;
-    env?: NodeJS.ProcessEnv;
-    systems?: TreeseedRunnableBootstrapSystem[];
-    selector?: TreeseedReconcileSelector;
-    units?: TreeseedDesiredUnit[];
-    session?: Map<string, unknown>;
-}): 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: TreeseedUnitVerificationResult | null;
-    }[];
-}>;
-export declare function reconcileTreeseedNestedTarget({ parentContext, selector, target, planOnly, }: {
-    parentContext: TreeseedReconcileRunContext;
-    selector: TreeseedReconcileSelector;
-    target: TreeseedReconcileTarget;
-    planOnly: boolean;
-}): Promise<{
-    target: TreeseedReconcileTarget;
-    units: TreeseedDesiredUnit[];
-    plans: TreeseedReconcilePlan[];
-    results: TreeseedReconcileResult[];
-    state: TreeseedReconcileStateRecord;
-    timings: TreeseedTimingEntry[];
-}>;
-export declare function verifyTreeseedNestedTarget({ parentContext, selector, target, }: {
-    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: TreeseedUnitVerificationResult | null;
-    }[];
-}>;