@treeseed/sdk 0.10.28 → 0.11.0

package/dist/operations/services/deployment-readiness.d.ts

@@ -0,0 +1,30 @@
+import { type TreeseedHostingEnvironment } from '../../hosting/index.ts';
+export type TreeseedDeploymentReadinessStatus = 'passed' | 'failed' | 'warning' | 'skipped';
+export interface TreeseedDeploymentReadinessCheck {
+    id: string;
+    status: TreeseedDeploymentReadinessStatus;
+    expected?: Record<string, unknown>;
+    observed?: Record<string, unknown>;
+    message: string;
+    remediation?: string;
+}
+export interface TreeseedDeploymentReadinessReport {
+    environment: TreeseedHostingEnvironment;
+    ok: boolean;
+    generatedAt: string;
+    checks: TreeseedDeploymentReadinessCheck[];
+    summary: {
+        passed: number;
+        failed: number;
+        warning: number;
+        skipped: number;
+    };
+}
+export interface TreeseedDeploymentReadinessOptions {
+    tenantRoot: string;
+    environment: TreeseedHostingEnvironment;
+    appId?: string;
+    now?: Date;
+}
+export declare function collectTreeseedDeploymentReadiness(options: TreeseedDeploymentReadinessOptions): TreeseedDeploymentReadinessReport;
+export declare function formatTreeseedReadinessReport(report: TreeseedDeploymentReadinessReport): string;

package/dist/operations/services/deployment-readiness.js

@@ -0,0 +1,175 @@
+import { relative, resolve } from "node:path";
+import { compileTreeseedHostingGraph, serializeHostingUnit } from "../../hosting/index.js";
+import { configuredRailwayServices } from "./railway-deploy.js";
+function relRoot(tenantRoot, path) {
+  const value = relative(tenantRoot, path).split("\\").join("/");
+  return value || ".";
+}
+function summary(checks) {
+  return {
+    passed: checks.filter((check2) => check2.status === "passed").length,
+    failed: checks.filter((check2) => check2.status === "failed").length,
+    warning: checks.filter((check2) => check2.status === "warning").length,
+    skipped: checks.filter((check2) => check2.status === "skipped").length
+  };
+}
+function check(id, actual, expected, message, remediation, key = id.split(":").at(-1) ?? "value") {
+  const passed = actual === expected;
+  return {
+    id,
+    status: passed ? "passed" : "failed",
+    expected: { [key]: expected },
+    observed: { [key]: actual ?? null },
+    message: passed ? message : `${message} Expected ${String(expected)}, observed ${String(actual ?? "(unset)")}.`,
+    remediation: passed ? void 0 : remediation
+  };
+}
+function checkIncludes(id, values, required, message, remediation) {
+  const observed = Array.isArray(values) ? values.map(String) : [];
+  const missing = required.filter((value) => !observed.includes(value));
+  return {
+    id,
+    status: missing.length === 0 ? "passed" : "failed",
+    expected: { includes: required },
+    observed: { values: observed },
+    message: missing.length === 0 ? message : `${message} Missing: ${missing.join(", ")}.`,
+    remediation: missing.length === 0 ? void 0 : remediation
+  };
+}
+function unitById(units, id) {
+  return units.find((unit) => unit.id === id) ?? null;
+}
+function railwayServiceByKey(services, key) {
+  return services.find((service) => service.key === key) ?? null;
+}
+function collectTreeseedDeploymentReadiness(options) {
+  const tenantRoot = resolve(options.tenantRoot);
+  const environment = options.environment;
+  const graph = compileTreeseedHostingGraph({ tenantRoot, environment, appId: options.appId });
+  const units = graph.units.map((unit) => serializeHostingUnit(unit));
+  const railwayServices = configuredRailwayServices(tenantRoot, environment).filter((service) => !options.appId || service.application?.id === options.appId);
+  const checks = [];
+  const web = unitById(units, "web");
+  const api = unitById(units, "api");
+  const runner = unitById(units, "operationsRunner");
+  const database = unitById(units, "treeseedDatabase");
+  const hasApiPlane = Boolean(api || runner || database);
+  const hasWorkspaceMarketControlPlane = graph.applications?.some((app) => app.config.hosting?.kind === "treeseed_control_plane") === true || graph.deployConfig.hosting?.kind === "treeseed_control_plane";
+  const railwayApi = railwayServiceByKey(railwayServices, "api");
+  const railwayRunner = railwayServiceByKey(railwayServices, "operationsRunner");
+  if (!web) {
+    if (!hasApiPlane) {
+      checks.push({
+        id: "hosting:web:present",
+        status: "failed",
+        message: "Web hosting unit is missing from the effective hosting graph.",
+        remediation: "Restore surfaces.web in treeseed.site.yaml."
+      });
+    }
+  } else {
+    checks.push(check("hosting:web:host", web.hostId, environment === "local" ? "local-process" : "cloudflare", "Web host matches the expected environment host.", "Set surfaces.web.provider to cloudflare for hosted environments.", "hostId"));
+    checks.push(check("hosting:web:rootDir", web.config?.rootDir, ".", "Web rootDir is the top-level UI application.", 'Set surfaces.web.rootDir to ".".', "rootDir"));
+    const apiConnection = graph.deployConfig.connections?.api;
+    const configuredBaseUrl = environment === "local" ? apiConnection?.localBaseUrl : apiConnection?.environments?.[environment]?.baseUrl ?? apiConnection?.environments?.[environment]?.domain;
+    checks.push({
+      id: "connection:api",
+      status: hasApiPlane || configuredBaseUrl ? "passed" : "failed",
+      expected: { apiConnection: true },
+      observed: {
+        localApiAppPresent: hasApiPlane,
+        baseUrl: configuredBaseUrl ?? null,
+        proxyPrefix: apiConnection?.proxyPrefix ?? null
+      },
+      message: hasApiPlane || configuredBaseUrl ? "Web app has an API app or configured API connection." : "Web app requires an API connection when no local API app manifest is present.",
+      remediation: hasApiPlane || configuredBaseUrl ? void 0 : "Add connections.api to treeseed.site.yaml or include packages/api/treeseed.site.yaml in the workspace."
+    });
+  }
+  if (!hasApiPlane && !hasWorkspaceMarketControlPlane) {
+    const counts2 = summary(checks);
+    return {
+      environment,
+      ok: counts2.failed === 0,
+      generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+      checks,
+      summary: counts2
+    };
+  }
+  const apiIsNestedApp = Boolean(api?.application?.relativeRoot && api.application.relativeRoot !== ".");
+  const runnerIsNestedApp = Boolean(runner?.application?.relativeRoot && runner.application.relativeRoot !== ".");
+  const expectedApiUnitRoot = apiIsNestedApp ? "." : "packages/api";
+  const expectedRunnerUnitRoot = runnerIsNestedApp ? "." : "packages/api";
+  const expectedApiRailwayRoot = api?.application?.relativeRoot && api.application.relativeRoot !== "." ? api.application.relativeRoot : expectedApiUnitRoot;
+  const expectedRunnerRailwayRoot = runner?.application?.relativeRoot && runner.application.relativeRoot !== "." ? runner.application.relativeRoot : expectedRunnerUnitRoot;
+  if (!api) {
+    checks.push({
+      id: "hosting:api:present",
+      status: "failed",
+      message: "API hosting unit is missing from the effective hosting graph.",
+      remediation: "Restore services.api in treeseed.site.yaml."
+    });
+  } else {
+    checks.push(check("hosting:api:host", api.hostId, environment === "local" ? "local-process" : "railway", "API host matches the expected environment host.", "Set services.api.provider to railway for hosted environments.", "hostId"));
+    checks.push(check("hosting:api:projectGroup", api.projectGroupId, "treeseed-control-plane", "API project group targets the Treeseed control plane.", "Bind services.api to the treeseed-control-plane project group.", "projectGroupId"));
+    checks.push(check("hosting:api:rootDir", api.config?.rootDir, expectedApiUnitRoot, "API effective rootDir points at the API package.", "Set services.api.rootDir and services.api.railway.rootDir relative to the owning API manifest.", "rootDir"));
+    checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
+    checks.push(check("hosting:api:startCommand", api.config?.startCommand, "npm run start:api", "API start command is package-local.", 'Set services.api.railway.startCommand to "npm run start:api".', "startCommand"));
+    checks.push(check("hosting:api:healthcheckPath", api.config?.healthcheckPath, "/healthz", "API healthcheck path is /healthz.", "Set services.api.railway.healthcheckPath to /healthz.", "healthcheckPath"));
+  }
+  if (railwayApi) {
+    checks.push(check("railway-config:api:serviceName", railwayApi.serviceName, "treeseed-api", "Railway API service uses the canonical name.", "Set services.api.railway.serviceName to treeseed-api.", "serviceName"));
+    checks.push(check("railway-config:api:rootDirectory", relRoot(tenantRoot, railwayApi.rootDir), expectedApiRailwayRoot, "Railway API effective rootDirectory points at the API app.", "Set services.api.railway.rootDir relative to the owning API manifest.", "rootDirectory"));
+  }
+  if (!runner) {
+    checks.push({
+      id: "hosting:operationsRunner:present",
+      status: "failed",
+      message: "Treeseed operations runner hosting unit is missing from the effective hosting graph.",
+      remediation: "Restore services.operationsRunner in treeseed.site.yaml."
+    });
+  } else {
+    checks.push(check("hosting:operationsRunner:host", runner.hostId, environment === "local" ? "local-docker" : "railway", "Runner host matches the expected environment host.", "Set services.operationsRunner.provider to railway for hosted environments.", "hostId"));
+    checks.push(check("hosting:operationsRunner:projectGroup", runner.projectGroupId, "treeseed-control-plane", "Runner project group targets the Treeseed control plane.", "Bind services.operationsRunner to the treeseed-control-plane project group.", "projectGroupId"));
+    checks.push(check("hosting:operationsRunner:rootDir", runner.config?.rootDir, expectedRunnerUnitRoot, "Runner effective rootDir points at the API package.", "Set services.operationsRunner.rootDir and services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDir"));
+    checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
+    checks.push(check("hosting:operationsRunner:startCommand", runner.config?.startCommand, "npm run start:runner", "Runner start command is package-local.", 'Set services.operationsRunner.railway.startCommand to "npm run start:runner".', "startCommand"));
+    checks.push(check("hosting:operationsRunner:healthcheckPath", runner.config?.healthcheckPath, "/healthz", "Runner healthcheck path is /healthz.", "Set services.operationsRunner.railway.healthcheckPath to /healthz.", "healthcheckPath"));
+    checks.push(check("hosting:operationsRunner:runtimeMode", runner.config?.runtimeMode, "service", "Runner runtime mode is a long-running service.", "Set services.operationsRunner.railway.runtimeMode to service.", "runtimeMode"));
+    checks.push(check("hosting:operationsRunner:volumeMountPath", runner.config?.volumeMountPath, "/data", "Runner volume mount path is stable.", "Set services.operationsRunner.railway.volumeMountPath to /data.", "volumeMountPath"));
+  }
+  if (railwayRunner) {
+    checks.push(check("railway-config:operationsRunner:serviceName", railwayRunner.serviceName, "treeseed-api-operations-runner-01", "Railway runner service instance uses the canonical name.", "Set the runner service instance name to treeseed-api-operations-runner-01.", "serviceName"));
+    checks.push(check("railway-config:operationsRunner:rootDirectory", relRoot(tenantRoot, railwayRunner.rootDir), expectedRunnerRailwayRoot, "Railway runner effective rootDirectory points at the API app.", "Set services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDirectory"));
+  }
+  if (!database) {
+    checks.push({
+      id: "hosting:treeseedDatabase:present",
+      status: "failed",
+      message: "Treeseed database hosting unit is missing from the effective hosting graph.",
+      remediation: "Restore services.treeseedDatabase in treeseed.site.yaml."
+    });
+  } else {
+    checks.push(checkIncludes("hosting:treeseedDatabase:serviceTargets", database.config?.serviceTargets, ["api", "operationsRunner"], "Treeseed database targets API and runner services.", "Set services.treeseedDatabase.railway.serviceTargets to include api and operationsRunner."));
+  }
+  const counts = summary(checks);
+  return {
+    environment,
+    ok: counts.failed === 0,
+    generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    summary: counts
+  };
+}
+function formatTreeseedReadinessReport(report) {
+  const lines = [
+    `Deployment readiness for ${report.environment}: ${report.ok ? "passed" : "failed"}`,
+    `passed=${report.summary.passed} failed=${report.summary.failed} warning=${report.summary.warning} skipped=${report.summary.skipped}`
+  ];
+  for (const check2 of report.checks.filter((entry) => entry.status !== "passed")) {
+    lines.push(`${check2.status.toUpperCase()} ${check2.id}: ${check2.message}${check2.remediation ? ` Remediation: ${check2.remediation}` : ""}`);
+  }
+  return lines.join("\n");
+}
+export {
+  collectTreeseedDeploymentReadiness,
+  formatTreeseedReadinessReport
+};

package/dist/operations/services/git-workflow.d.ts

@@ -179,9 +179,10 @@ export declare function mergeStagingIntoMain(cwd?: any): {
     commitSha: string;
     pushed: boolean;
 };
-export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget, quietMerge }?: {
+export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget, quietMerge, allowUnrelatedHistories }?: {
     pushTarget?: boolean | undefined;
     quietMerge?: boolean | undefined;
+    allowUnrelatedHistories?: boolean | undefined;
 }): {
     repoDir: string;
     targetBranch: any;

package/dist/operations/services/git-workflow.js

@@ -456,16 +456,22 @@ function mergeStagingIntoMain(cwd = workspaceRoot()) {
     sourceBranch: STAGING_BRANCH,
     targetBranch: PRODUCTION_BRANCH,
     message: `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`,
-    pushTarget: true
+    pushTarget: true,
+    allowUnrelatedHistories: false
   });
 }
-function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true, quietMerge = false } = {}) {
+function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true, quietMerge = false, allowUnrelatedHistories = false } = {}) {
   const repoDir = prepareReleaseBranches(cwd);
   checkoutBranch(repoDir, targetBranch);
   if (remoteBranchExists(repoDir, targetBranch)) {
     runGit(["merge", "--ff-only", `origin/${targetBranch}`], { cwd: repoDir });
   }
-  runGit(["merge", "--no-ff", sourceBranch, "-m", message], { cwd: repoDir, capture: quietMerge });
+  const mergeArgs = ["merge", "--no-ff"];
+  if (allowUnrelatedHistories) {
+    mergeArgs.push("--allow-unrelated-histories");
+  }
+  mergeArgs.push(sourceBranch, "-m", message);
+  runGit(mergeArgs, { cwd: repoDir, capture: quietMerge });
   pushBranch(repoDir, STAGING_BRANCH);
   if (pushTarget) {
     pushBranch(repoDir, targetBranch);

package/dist/operations/services/github-actions-verification.d.ts

@@ -135,6 +135,7 @@ export declare function waitForGitHubActionsGate(gate: GitHubActionsWorkflowGate
     timeoutSeconds?: number;
     pollSeconds?: number;
     operation?: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
 }): Promise<Record<string, unknown>>;
 export {};

package/dist/operations/services/github-actions-verification.js

@@ -544,6 +544,7 @@ async function waitForGitHubActionsGate(gate, options = {}) {
     dispatchIfMissing: gate.dispatchIfMissing ?? gate.workflow === "verify.yml",
     dispatchAfterSeconds: gate.dispatchAfterSeconds ?? 75,
     dispatchInputs: gate.dispatchInputs,
+    env: options.env,
     onProgress: reportProgress
   });
 }

package/dist/operations/services/github-api.js

@@ -794,7 +794,7 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
         continue;
       }
       for (; ; ) {
-        if (Date.now() - startedAt >= timeoutSeconds * 1e3) {
+        if (Date.now() - startedAt >= timeoutSeconds * 1e3 && lastProgress?.runId === match.id) {
           break;
         }
         const current = await client.rest.actions.getWorkflowRun({

package/dist/operations/services/github-automation.d.ts

@@ -209,7 +209,7 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
         skipped?: undefined;
     };
 }>;
-export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, dispatchIfMissing, dispatchAfterSeconds, dispatchInputs, onProgress, }?: {
+export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, dispatchIfMissing, dispatchAfterSeconds, dispatchInputs, onProgress, env, }?: {
     workflow?: string | undefined;
     timeoutSeconds?: number | undefined;
     pollSeconds?: number | undefined;

package/dist/operations/services/github-automation.js

@@ -358,7 +358,7 @@ function ensureStandardizedGitHubWorkflows(tenantRoot) {
   const deployConfig = loadCliDeployConfig(tenantRoot);
   const deploy = ensureDeployWorkflow(tenantRoot);
   const workflows = [deploy, ...deploy.additionalWorkflows ?? []];
-  if ((deployConfig.hosting?.kind ?? "self_hosted_project") === "market_control_plane") {
+  if ((deployConfig.hosting?.kind ?? "self_hosted_project") === "treeseed_control_plane") {
     workflows.push(ensureHostedProjectWorkflow(tenantRoot));
   }
   return workflows;
@@ -477,11 +477,12 @@ async function waitForGitHubWorkflowCompletion(tenantRoot, {
   dispatchIfMissing = false,
   dispatchAfterSeconds,
   dispatchInputs,
-  onProgress
+  onProgress,
+  env
 } = {}) {
   const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
   return await waitForGitHubWorkflowRunCompletion(repo, {
-    client: createGitHubApiClient(),
+    client: createGitHubApiClient({ env }),
     workflow,
     headSha,
     branch,

package/dist/operations/services/github-credentials.d.ts

@@ -0,0 +1,13 @@
+export type TreeseedGitHubCredentialResolution = {
+    repository: string;
+    envName: string;
+    configured: boolean;
+    fallbackUsed: boolean;
+    source: 'repository' | 'fallback' | 'missing';
+    token: string | null;
+};
+export declare function githubRepositoryCredentialEnvName(repository: string): string;
+export declare function resolveGitHubCredentialForRepository(repository: string, { values, env, }?: {
+    values?: Record<string, string | undefined>;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}): TreeseedGitHubCredentialResolution;

package/dist/operations/services/github-credentials.js

@@ -0,0 +1,58 @@
+function cleanRepositorySlug(repository) {
+  const raw = String(repository ?? "").trim().replace(/^https?:\/\/github\.com\//iu, "").replace(/^git@github\.com:/iu, "").replace(/^ssh:\/\/git@github\.com\//iu, "").replace(/\.git$/iu, "").replace(/^\/+|\/+$/gu, "");
+  const [owner, repo, ...extra] = raw.split("/").filter(Boolean);
+  if (!owner || !repo || extra.length > 0) {
+    throw new Error(`Invalid GitHub repository "${repository}". Expected owner/name.`);
+  }
+  return `${owner}/${repo}`;
+}
+function githubRepositoryCredentialEnvName(repository) {
+  const slug = cleanRepositorySlug(repository);
+  const suffix = slug.toUpperCase().replace(/[^A-Z0-9]+/gu, "_").replace(/^_+|_+$/gu, "").replace(/_+/gu, "_");
+  return `TREESEED_GITHUB_TOKEN_${suffix}`;
+}
+function configuredValue(values, key) {
+  const value = values?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function resolveGitHubCredentialForRepository(repository, {
+  values,
+  env = process.env
+} = {}) {
+  const normalizedRepository = cleanRepositorySlug(repository);
+  const envName = githubRepositoryCredentialEnvName(normalizedRepository);
+  const repositoryToken = configuredValue(values, envName) || configuredValue(env, envName);
+  if (repositoryToken) {
+    return {
+      repository: normalizedRepository,
+      envName,
+      configured: true,
+      fallbackUsed: false,
+      source: "repository",
+      token: repositoryToken
+    };
+  }
+  const fallbackToken = configuredValue(values, "GH_TOKEN") || configuredValue(values, "GITHUB_TOKEN") || configuredValue(env, "GH_TOKEN") || configuredValue(env, "GITHUB_TOKEN");
+  if (fallbackToken) {
+    return {
+      repository: normalizedRepository,
+      envName,
+      configured: true,
+      fallbackUsed: true,
+      source: "fallback",
+      token: fallbackToken
+    };
+  }
+  return {
+    repository: normalizedRepository,
+    envName,
+    configured: false,
+    fallbackUsed: false,
+    source: "missing",
+    token: null
+  };
+}
+export {
+  githubRepositoryCredentialEnvName,
+  resolveGitHubCredentialForRepository
+};

package/dist/operations/services/hosted-service-checks.d.ts

@@ -0,0 +1,63 @@
+export type TreeseedHostedServiceCheckStatus = 'passed' | 'failed' | 'skipped' | 'warning';
+export type TreeseedHostedServiceTarget = 'local' | 'staging' | 'prod';
+export type TreeseedHostedServiceProvider = 'cloudflare' | 'railway' | 'http' | 'dns' | 'github';
+export type TreeseedHostedServiceType = 'web' | 'api' | 'operationsRunner' | 'treeseedDatabase' | 'customDomain' | 'dnsRecord' | 'githubWorkflow' | 'unknown';
+export interface TreeseedHostedServiceCheck {
+    id: string;
+    provider: TreeseedHostedServiceProvider;
+    serviceKey?: string;
+    serviceType: TreeseedHostedServiceType;
+    target: TreeseedHostedServiceTarget;
+    description: string;
+    expected?: Record<string, unknown>;
+    observed?: Record<string, unknown>;
+    status: TreeseedHostedServiceCheckStatus;
+    issues: string[];
+    remediation?: string;
+}
+export interface TreeseedHostedServiceCheckReport {
+    target: TreeseedHostedServiceTarget;
+    tenantRoot: string;
+    generatedAt: string;
+    summary: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        warning: number;
+    };
+    checks: TreeseedHostedServiceCheck[];
+}
+export interface TreeseedObservedRailwayServiceState {
+    projectName?: string | null;
+    environmentName?: string | null;
+    serviceName?: string | null;
+    rootDirectory?: string | null;
+    buildCommand?: string | null;
+    startCommand?: string | null;
+    healthcheckPath?: string | null;
+    healthcheckTimeoutSeconds?: number | null;
+    runtimeMode?: string | null;
+    volumeMountPath?: string | null;
+    variables?: Record<string, unknown> | string[];
+    secrets?: Record<string, unknown> | string[];
+    health?: 'ready' | 'failed' | 'unknown' | string | null;
+}
+export interface TreeseedHostedServiceCheckOptions {
+    tenantRoot: string;
+    target?: TreeseedHostedServiceTarget;
+    appId?: string;
+    now?: Date;
+    valuesOverlay?: Record<string, string | undefined>;
+    observedRailwayServices?: Record<string, TreeseedObservedRailwayServiceState | undefined>;
+    httpChecks?: Record<string, {
+        status?: number;
+        ok?: boolean;
+        skipped?: boolean;
+        error?: string;
+        fallbackUrl?: string;
+        fallbackStatus?: number;
+        fallbackOk?: boolean;
+        fallbackError?: string;
+    } | undefined>;
+}
+export declare function collectTreeseedHostedServiceChecks(options: TreeseedHostedServiceCheckOptions): TreeseedHostedServiceCheckReport;