@treeseed/sdk 0.10.28 → 0.12.4

package/dist/reconcile/engine.js

@@ -26,17 +26,84 @@ function formatVerificationFailure(verification) {
   ].filter(Boolean);
   return details.length > 0 ? `Verification failed (${details.join(" | ")})` : "Verification failed.";
 }
-function createRunContext(tenantRoot, target, launchEnv, write) {
+function createRunContext(tenantRoot, target, launchEnv, write, dryRun = false, session) {
   const { deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
   return {
     tenantRoot,
     target,
     deployConfig,
     launchEnv,
+    dryRun,
     write,
-    session: /* @__PURE__ */ new Map()
+    session: session ?? /* @__PURE__ */ new Map()
   };
 }
+function normalizeSelectorValues(values) {
+  return new Set((values ?? []).map((value) => value.trim()).filter(Boolean));
+}
+function unitSelectorValues(unit) {
+  const metadata = unit.metadata ?? {};
+  const spec = unit.spec ?? {};
+  const serviceKey = typeof metadata.serviceKey === "string" ? metadata.serviceKey : null;
+  const placement = typeof metadata.placement === "string" ? metadata.placement : null;
+  const appId = typeof metadata.applicationId === "string" ? metadata.applicationId : typeof metadata.appId === "string" ? metadata.appId : typeof spec.applicationId === "string" ? spec.applicationId : null;
+  const packageId = typeof metadata.packageId === "string" ? metadata.packageId : appId;
+  const serviceName = typeof spec.serviceName === "string" ? spec.serviceName : null;
+  const serviceId = typeof metadata.serviceId === "string" ? metadata.serviceId : typeof spec.serviceId === "string" ? spec.serviceId : null;
+  return {
+    provider: unit.provider,
+    unitType: unit.unitType,
+    unitId: unit.unitId,
+    serviceIds: [
+      unit.logicalName,
+      serviceId,
+      serviceKey,
+      serviceName,
+      unit.unitType.startsWith("railway-service:") ? unit.unitType.slice("railway-service:".length) : null,
+      unit.unitType.endsWith("-runtime") ? unit.logicalName : null
+    ].filter((value) => Boolean(value)),
+    serviceTypes: [unit.unitType],
+    placements: [placement].filter((value) => Boolean(value)),
+    appIds: [appId].filter((value) => Boolean(value)),
+    packageIds: [packageId].filter((value) => Boolean(value))
+  };
+}
+function unitMatchesSelector(unit, selector) {
+  if (!selector) return true;
+  const values = unitSelectorValues(unit);
+  const provider = normalizeSelectorValues(selector.provider ?? selector.host);
+  const unitIds = normalizeSelectorValues(selector.unitId);
+  const unitTypes = normalizeSelectorValues([
+    ...selector.unitType ?? [],
+    ...selector.resourceKind ?? []
+  ]);
+  const serviceIds = normalizeSelectorValues(selector.serviceId);
+  const serviceTypes = normalizeSelectorValues(selector.serviceType);
+  const placements = normalizeSelectorValues(selector.placement);
+  const appIds = normalizeSelectorValues(selector.appId);
+  const packageIds = normalizeSelectorValues(selector.packageId);
+  const has = (needle, haystack) => needle.size === 0 || haystack.some((entry) => needle.has(entry));
+  return has(provider, [values.provider]) && has(unitIds, [values.unitId]) && has(unitTypes, [values.unitType]) && has(serviceIds, values.serviceIds) && has(serviceTypes, values.serviceTypes) && has(placements, values.placements) && has(appIds, values.appIds) && has(packageIds, values.packageIds);
+}
+function includeDependencies(units, selected) {
+  const byId = new Map(units.map((unit) => [unit.unitId, unit]));
+  const included = new Map(selected.map((unit) => [unit.unitId, unit]));
+  const visit = (unit) => {
+    for (const dependencyId of unit.dependencies) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency || included.has(dependency.unitId)) continue;
+      included.set(dependency.unitId, dependency);
+      visit(dependency);
+    }
+  };
+  for (const unit of selected) visit(unit);
+  return units.filter((unit) => included.has(unit.unitId));
+}
+function filterUnitsBySelector(units, selector) {
+  if (!selector) return units;
+  const selected = units.filter((unit) => unitMatchesSelector(unit, selector));
+  return includeDependencies(units, selected);
+}
 function dependencyLevels(units) {
   const remaining = new Map(units.map((unit) => [unit.unitId, unit]));
   const completed = /* @__PURE__ */ new Set();
@@ -123,33 +190,36 @@ async function verifyPlanUnits({
   }
   return verificationResults;
 }
-async function observeTreeseedUnits({
+async function refreshTreeseedUnits({
   tenantRoot,
   target,
   env = process.env,
   systems,
+  selector,
+  units: explicitUnits,
   write
 }) {
   const derived = deriveTreeseedDesiredUnits({ tenantRoot, target });
-  const units = filterTreeseedDesiredUnitsByBootstrapSystems(derived.units, systems);
+  const baseUnits = explicitUnits ?? filterTreeseedDesiredUnitsByBootstrapSystems(derived.units, systems);
+  const units = filterUnitsBySelector(baseUnits, selector);
   const deployConfig = derived.deployConfig;
   const registry = createTreeseedReconcileRegistry(deployConfig);
   const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
   const context = createRunContext(tenantRoot, target, env, write);
   const observations = /* @__PURE__ */ new Map();
   await runByDependencyLevel(topologicallySortDesiredUnits(units), async (unit) => {
-    write?.(`Observing ${unit.provider}:${unit.unitType}...`);
+    write?.(`Refreshing ${unit.provider}:${unit.unitType}...`);
     const adapter = registry.get(unit.unitType, unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(reconcileState, unit);
     let observed;
     try {
-      observed = await Promise.resolve(adapter.observe({
+      observed = await Promise.resolve(adapter.refresh({
         context,
         unit,
         persistedState: persisted
       }));
     } catch (error) {
-      wrapAdapterFailure("observe", unit.provider, unit.unitType, unit.unitId, error);
+      wrapAdapterFailure("refresh", unit.provider, unit.unitType, unit.unitId, error);
     }
     observations.set(unit.unitId, observed);
   });
@@ -165,9 +235,11 @@ async function planTreeseedReconciliation({
   target,
   env = process.env,
   systems,
+  selector,
+  units,
   write
 }) {
-  const observed = await observeTreeseedUnits({ tenantRoot, target, env, systems, write });
+  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems, selector, units, write });
   const registry = createTreeseedReconcileRegistry(observed.deployConfig);
   const context = createRunContext(tenantRoot, target, env, write);
   const plans = [];
@@ -177,14 +249,14 @@ async function planTreeseedReconciliation({
     const observation = observed.observations.get(unit.unitId);
     let diff;
     try {
-      diff = await Promise.resolve(adapter.plan({
+      diff = await Promise.resolve(adapter.diff({
         context,
         unit,
         persistedState: persisted,
         observed: observation
       }));
     } catch (error) {
-      wrapAdapterFailure("plan", unit.provider, unit.unitType, unit.unitId, error);
+      wrapAdapterFailure("diff", unit.provider, unit.unitType, unit.unitId, error);
     }
     plans.push({
       unit,
@@ -203,11 +275,15 @@ async function reconcileTreeseedTarget({
   target,
   env = process.env,
   systems,
-  write
+  selector,
+  units,
+  write,
+  dryRun = false,
+  session
 }) {
-  const planned = await planTreeseedReconciliation({ tenantRoot, target, env, systems, write });
+  const planned = await planTreeseedReconciliation({ tenantRoot, target, env, systems, selector, units, write });
   const registry = createTreeseedReconcileRegistry(planned.deployConfig);
-  const context = createRunContext(tenantRoot, target, env, write);
+  const context = createRunContext(tenantRoot, target, env, write, dryRun, session);
   const results = [];
   const verificationMap = /* @__PURE__ */ new Map();
   const timingEntries = [];
@@ -225,7 +301,7 @@ async function reconcileTreeseedTarget({
   await runByDependencyLevel(topologicallySortDesiredUnits(planned.units), async (unit) => {
     const plan = planByUnitId.get(unit.unitId);
     const unitTiming = {
-      name: `reconcile:${plan.unit.provider}:${plan.unit.unitType}:${plan.unit.logicalName}`,
+      name: `apply:${plan.unit.provider}:${plan.unit.unitType}:${plan.unit.logicalName}`,
       durationMs: 0,
       status: "running",
       children: [],
@@ -233,7 +309,7 @@ async function reconcileTreeseedTarget({
     };
     const unitStartMs = performance.now();
     timingEntries.push(unitTiming);
-    write?.(`Reconciling ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
+    write?.(`Applying ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const adapter = registry.get(plan.unit.unitType, plan.unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(planned.state, plan.unit);
     try {
@@ -261,27 +337,69 @@ async function reconcileTreeseedTarget({
     let result;
     try {
       const stageStartMs = performance.now();
-      result = await Promise.resolve(adapter.reconcile({
-        context,
-        unit: plan.unit,
-        persistedState: persisted,
-        observed: plan.observed,
-        diff: plan.diff
-      }));
+      if (dryRun) {
+        result = {
+          unit: plan.unit,
+          observed: plan.observed,
+          diff: plan.diff,
+          action: plan.diff.action,
+          warnings: [...plan.observed.warnings, "dry run: apply skipped"],
+          resourceLocators: plan.observed.locators,
+          state: plan.observed.live,
+          verification: null
+        };
+      } else {
+        result = await Promise.resolve(adapter.apply({
+          context,
+          unit: plan.unit,
+          persistedState: persisted,
+          observed: plan.observed,
+          diff: plan.diff
+        }));
+      }
       unitTiming.children?.push({
-        name: `${unitTiming.name}:reconcile`,
+        name: `${unitTiming.name}:apply`,
         durationMs: elapsedMs(stageStartMs),
-        status: "success"
+        status: dryRun ? "skipped" : "success"
       });
     } catch (error) {
       unitTiming.children?.push({
-        name: `${unitTiming.name}:reconcile`,
+        name: `${unitTiming.name}:apply`,
         durationMs: elapsedMs(unitStartMs),
         status: "failed"
       });
       unitTiming.durationMs = elapsedMs(unitStartMs);
       unitTiming.status = "failed";
-      wrapAdapterFailure("reconcile", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
+      wrapAdapterFailure("apply", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
+    }
+    let refreshedObserved = result.observed;
+    if (!dryRun) {
+      try {
+        const stageStartMs = performance.now();
+        refreshedObserved = await Promise.resolve(adapter.refresh({
+          context,
+          unit: plan.unit,
+          persistedState: persisted
+        }));
+        result = {
+          ...result,
+          observed: refreshedObserved
+        };
+        unitTiming.children?.push({
+          name: `${unitTiming.name}:refresh-after-apply`,
+          durationMs: elapsedMs(stageStartMs),
+          status: "success"
+        });
+      } catch (error) {
+        unitTiming.children?.push({
+          name: `${unitTiming.name}:refresh-after-apply`,
+          durationMs: elapsedMs(unitStartMs),
+          status: "failed"
+        });
+        unitTiming.durationMs = elapsedMs(unitStartMs);
+        unitTiming.status = "failed";
+        wrapAdapterFailure("refresh", plan.unit.provider, plan.unit.unitType, plan.unit.unitId, error);
+      }
     }
     write?.(`Verifying ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName})...`);
     const postconditions = await Promise.resolve(adapter.requiredPostconditions?.({
@@ -296,7 +414,7 @@ async function reconcileTreeseedTarget({
         context,
         unit: plan.unit,
         persistedState: persisted,
-        observed: result.observed,
+        observed: refreshedObserved,
         diff: plan.diff,
         result,
         postconditions
@@ -329,13 +447,19 @@ async function reconcileTreeseedTarget({
     unitTiming.status = verification.verified ? "success" : "failed";
     write?.(`Finished ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.logicalName}) in ${formatDurationMs(unitTiming.durationMs)}.`);
     if (!verification.verified) {
-      await persistVerifiedResult(persisted, verifiedResult);
+      if (!dryRun) {
+        await persistVerifiedResult(persisted, verifiedResult);
+      }
       throw new Error(`Treeseed reconcile verification failed for ${plan.unit.provider}:${plan.unit.unitType} (${plan.unit.unitId}): ${formatVerificationFailure(verification)}`);
     }
-    await persistVerifiedResult(persisted, verifiedResult);
+    if (!dryRun) {
+      await persistVerifiedResult(persisted, verifiedResult);
+    }
     results.push(verifiedResult);
   });
-  writeTreeseedReconcileState(tenantRoot, planned.state);
+  if (!dryRun) {
+    writeTreeseedReconcileState(tenantRoot, planned.state);
+  }
   return {
     target,
     units: planned.units,
@@ -349,9 +473,12 @@ async function destroyTreeseedTargetUnits({
   tenantRoot,
   target,
   env = process.env,
+  selector,
+  units: explicitUnits,
   write
 }) {
-  const { units, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
+  const { units: allUnits, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
+  const units = filterUnitsBySelector(explicitUnits ?? allUnits, selector);
   const registry = createTreeseedReconcileRegistry(deployConfig);
   const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
   const context = createRunContext(tenantRoot, target, env, write);
@@ -365,13 +492,13 @@ async function destroyTreeseedTargetUnits({
     const persisted = ensureTreeseedPersistedUnitState(reconcileState, unit);
     let observed;
     try {
-      observed = await Promise.resolve(adapter.observe({
+      observed = await Promise.resolve(adapter.refresh({
         context,
         unit,
         persistedState: persisted
       }));
     } catch (error) {
-      wrapAdapterFailure("observe", unit.provider, unit.unitType, unit.unitId, error);
+      wrapAdapterFailure("refresh", unit.provider, unit.unitType, unit.unitId, error);
     }
     let result;
     try {
@@ -392,16 +519,19 @@ async function collectTreeseedReconcileStatus({
   tenantRoot,
   target,
   env = process.env,
-  systems
+  systems,
+  selector,
+  units,
+  session
 }) {
-  const observed = await observeTreeseedUnits({ tenantRoot, target, env, systems });
+  const observed = await refreshTreeseedUnits({ tenantRoot, target, env, systems, selector, units });
   const registry = createTreeseedReconcileRegistry(observed.deployConfig);
-  const context = createRunContext(tenantRoot, target, env);
+  const context = createRunContext(tenantRoot, target, env, void 0, false, session);
   const plans = await Promise.all(observed.units.map(async (unit) => {
     const adapter = registry.get(unit.unitType, unit.provider);
     const persisted = ensureTreeseedPersistedUnitState(observed.state, unit);
     const observation = observed.observations.get(unit.unitId);
-    const diff = await Promise.resolve(adapter.plan({
+    const diff = await Promise.resolve(adapter.diff({
       context,
       unit,
       persistedState: persisted,
@@ -420,7 +550,7 @@ async function collectTreeseedReconcileStatus({
     context,
     state: observed.state
   });
-  const units = observed.units.map((unit) => {
+  const unitStatuses = observed.units.map((unit) => {
     const observation = observed.observations.get(unit.unitId);
     const verification = verificationResults.get(unit.unitId)?.verification ?? null;
     return {
@@ -434,21 +564,76 @@ async function collectTreeseedReconcileStatus({
       verification
     };
   });
-  const ready = units.every((unit) => unit.verification?.verified === true);
-  const blockers = units.filter((unit) => unit.verification?.verified !== true).map((unit) => `Reconcile unit ${unit.provider}:${unit.unitType} is unverified: ${formatVerificationFailure(unit.verification)}.`);
-  const warnings = units.flatMap((unit) => unit.warnings);
+  const ready = unitStatuses.every((unit) => unit.verification?.verified === true);
+  const blockers = unitStatuses.filter((unit) => unit.verification?.verified !== true).map((unit) => `Reconcile unit ${unit.provider}:${unit.unitType} is unverified: ${formatVerificationFailure(unit.verification)}.`);
+  const warnings = unitStatuses.flatMap((unit) => unit.warnings);
   return {
     target,
     ready,
     blockers,
     warnings,
-    units
+    units: unitStatuses
   };
 }
+async function reconcileTreeseedNestedTarget({
+  parentContext,
+  selector,
+  target,
+  dryRun
+}) {
+  const previousVerificationResults = parentContext.session.get("treeseed:verification-results");
+  const previousTimings = parentContext.session.get("treeseed:timings");
+  try {
+    return await reconcileTreeseedTarget({
+      tenantRoot: parentContext.tenantRoot,
+      target,
+      env: parentContext.launchEnv,
+      selector,
+      write: parentContext.write,
+      dryRun,
+      session: parentContext.session
+    });
+  } finally {
+    if (previousVerificationResults === void 0) {
+      parentContext.session.delete("treeseed:verification-results");
+    } else {
+      parentContext.session.set("treeseed:verification-results", previousVerificationResults);
+    }
+    if (previousTimings === void 0) {
+      parentContext.session.delete("treeseed:timings");
+    } else {
+      parentContext.session.set("treeseed:timings", previousTimings);
+    }
+  }
+}
+async function verifyTreeseedNestedTarget({
+  parentContext,
+  selector,
+  target
+}) {
+  const previousVerificationResults = parentContext.session.get("treeseed:verification-results");
+  try {
+    return await collectTreeseedReconcileStatus({
+      tenantRoot: parentContext.tenantRoot,
+      target,
+      env: parentContext.launchEnv,
+      selector,
+      session: parentContext.session
+    });
+  } finally {
+    if (previousVerificationResults === void 0) {
+      parentContext.session.delete("treeseed:verification-results");
+    } else {
+      parentContext.session.set("treeseed:verification-results", previousVerificationResults);
+    }
+  }
+}
 export {
   collectTreeseedReconcileStatus,
   destroyTreeseedTargetUnits,
-  observeTreeseedUnits,
   planTreeseedReconciliation,
-  reconcileTreeseedTarget
+  reconcileTreeseedNestedTarget,
+  reconcileTreeseedTarget,
+  refreshTreeseedUnits,
+  verifyTreeseedNestedTarget
 };

package/dist/reconcile/index.d.ts

@@ -1,8 +1,10 @@
-export * from './contracts.ts';
-export * from './bootstrap-systems.ts';
-export * from './desired-state.ts';
-export * from './engine.ts';
-export * from './errors.ts';
-export * from './registry.ts';
-export * from './state.ts';
-export * from './units.ts';
+export * from './contracts.js';
+export * from './platform.js';
+export * from './bootstrap-systems.js';
+export * from './desired-state.js';
+export * from './engine.js';
+export * from './errors.js';
+export * from './live-acceptance.js';
+export * from './registry.js';
+export * from './state.js';
+export * from './units.js';

package/dist/reconcile/index.js

@@ -1,8 +1,10 @@
 export * from "./contracts.js";
+export * from "./platform.js";
 export * from "./bootstrap-systems.js";
 export * from "./desired-state.js";
 export * from "./engine.js";
 export * from "./errors.js";
+export * from "./live-acceptance.js";
 export * from "./registry.js";
 export * from "./state.js";
 export * from "./units.js";

package/dist/reconcile/live-acceptance.d.ts

@@ -0,0 +1,100 @@
+import { type TreeseedCanonicalAction, type TreeseedCanonicalDrift, type TreeseedCanonicalGraphNode, type TreeseedCanonicalReconcileReport } from './platform.js';
+import type { TreeseedDesiredResource } from '../platform/desired-state.js';
+import type { TreeseedReconcileSelector } from './contracts.js';
+export type TreeseedLiveReconcileProvider = 'railway' | 'cloudflare' | 'github' | 'local';
+export type TreeseedLiveReconcileMode = 'smoke' | 'acceptance' | 'cleanup';
+export type TreeseedLiveReconcileEnvironment = 'local' | 'staging' | 'prod';
+export interface TreeseedLiveReconcileScenarioResult {
+    id: string;
+    provider: TreeseedLiveReconcileProvider;
+    capability: string;
+    mode: TreeseedLiveReconcileMode;
+    ok: boolean;
+    phase: 'smoke' | 'validate' | 'create' | 'update' | 'replace' | 'verify' | 'destroy' | 'cleanup' | 'blocked';
+    action: TreeseedCanonicalAction['kind'];
+    reason: string;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    locators: Record<string, string | null>;
+    createdResources: TreeseedCanonicalGraphNode[];
+    updatedResources: TreeseedCanonicalGraphNode[];
+    replacedResources: TreeseedCanonicalGraphNode[];
+    destroyedResources: TreeseedCanonicalGraphNode[];
+    retainedResources: TreeseedCanonicalGraphNode[];
+    issues: string[];
+}
+export interface TreeseedLiveReconcileProviderReport {
+    provider: TreeseedLiveReconcileProvider;
+    mode: TreeseedLiveReconcileMode;
+    runId: string;
+    resourcePrefix: string;
+    scenarioResults: TreeseedLiveReconcileScenarioResult[];
+    coverage: {
+        total: number;
+        passed: number;
+        failed: number;
+        capabilities: string[];
+    };
+    createdResources: TreeseedCanonicalGraphNode[];
+    updatedResources: TreeseedCanonicalGraphNode[];
+    replacedResources: TreeseedCanonicalGraphNode[];
+    destroyedResources: TreeseedCanonicalGraphNode[];
+    retainedResources: TreeseedCanonicalGraphNode[];
+    cleanupDrift: TreeseedCanonicalDrift[];
+    report: TreeseedCanonicalReconcileReport;
+    ok: boolean;
+}
+export interface TreeseedLiveReconcileRunResult {
+    command: 'reconcile test-live';
+    mode: TreeseedLiveReconcileMode;
+    environment: TreeseedLiveReconcileEnvironment;
+    runId: string;
+    resourcePrefix: string;
+    providers: TreeseedLiveReconcileProviderReport[];
+    ok: boolean;
+}
+export interface TreeseedLiveAcceptanceScenario {
+    id: string;
+    provider: TreeseedLiveReconcileProvider;
+    capability: string;
+    desiredResources: TreeseedDesiredResource[];
+    selector: TreeseedReconcileSelector;
+    expectedActions: TreeseedCanonicalAction['kind'][];
+    cleanupSelector: TreeseedReconcileSelector;
+    required: boolean;
+    probeOnly?: boolean;
+    cleanupRequired: boolean;
+}
+export interface TreeseedLiveReconcileProgressEvent {
+    provider: TreeseedLiveReconcileProvider;
+    mode: TreeseedLiveReconcileMode;
+    environment: TreeseedLiveReconcileEnvironment;
+    runId: string;
+    resourcePrefix: string;
+    capability?: string;
+    phase: 'start' | 'cleanup' | 'create' | 'verify' | 'destroy' | 'complete' | 'blocked';
+    message: string;
+    elapsedMs?: number;
+}
+export interface RunTreeseedLiveReconcileTestsOptions {
+    cwd: string;
+    environment: TreeseedLiveReconcileEnvironment;
+    providers: TreeseedLiveReconcileProvider[];
+    mode?: TreeseedLiveReconcileMode;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    runId?: string;
+    now?: Date;
+    fetchImpl?: typeof fetch;
+    onProgress?: (event: TreeseedLiveReconcileProgressEvent) => void;
+}
+export declare function compileTreeseedLiveAcceptanceScenarios(input: {
+    tenantRoot: string;
+    environment: TreeseedLiveReconcileEnvironment;
+    provider: TreeseedLiveReconcileProvider | 'all';
+    mode: TreeseedLiveReconcileMode;
+    runId: string;
+}): TreeseedLiveAcceptanceScenario[];
+export declare function treeseedLiveReconcileProviderCapabilities(provider: TreeseedLiveReconcileProvider): string[];
+export declare function treeseedLiveReconcileResourcePrefix(environment: TreeseedLiveReconcileEnvironment, provider: TreeseedLiveReconcileProvider, runId: string): string;
+export declare function runTreeseedLiveReconcileTests(options: RunTreeseedLiveReconcileTestsOptions): Promise<TreeseedLiveReconcileRunResult>;