@treeseed/sdk 0.11.0 → 0.12.4

package/dist/operations.js

@@ -16,10 +16,43 @@ import {
 import { TreeseedOperationsSdk } from "./operations/runtime.js";
 import {
   cancelGitHubWorkflowRun,
-  dispatchGitHubWorkflowRun,
   formatGitHubWorkflowFailure,
   waitForGitHubWorkflowRunCompletion
 } from "./operations/services/github-api.js";
+import {
+  computeProofInputHash,
+  createProofRecord,
+  proofIdFor
+} from "./operations/services/release-proof.js";
+import {
+  cleanProofLedger,
+  findReusableProof,
+  invalidateProofs,
+  readProofLedger,
+  writeProofRecord
+} from "./operations/services/release-proof-ledger.js";
+import {
+  buildTreeseedProofPlan,
+  summarizeTreeseedProofLedger
+} from "./operations/services/release-proof-planner.js";
+import {
+  runTreeseedProof
+} from "./operations/services/release-proof-runner.js";
+import {
+  createTreeseedWorkflowTimer,
+  formatTreeseedDuration,
+  slowestTreeseedWorkflowPhases
+} from "./operations/services/workflow-timing.js";
+import {
+  classifyTreeseedGitMode,
+  inspectTreeseedGitLocks,
+  inspectTreeseedWorkspaceGitLocks,
+  recoverTreeseedGitLocks,
+  runTreeseedGit,
+  runTreeseedGitBatch,
+  runTreeseedGitOk,
+  runTreeseedGitText
+} from "./operations/services/git-runner.js";
 import { TreeseedOperationError } from "./operations-types.js";
 import {
   AGENT_OPERATION_MODES,
@@ -38,23 +71,44 @@ export {
   TreeseedOperationError,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
+  buildTreeseedProofPlan,
   cancelGitHubWorkflowRun,
+  classifyTreeseedGitMode,
+  cleanProofLedger,
   collectTreeseedConfigSeedValues,
+  computeProofInputHash,
   createAgentOperationEvent,
   createKnowledgeHubRepositories,
+  createProofRecord,
+  createTreeseedWorkflowTimer,
   decideAgentOperationPermission,
   defaultHubContentResolutionPolicy,
   deniedAgentOperationResult,
-  dispatchGitHubWorkflowRun,
   executeKnowledgeHubLaunch,
+  findReusableProof,
   findTreeseedOperation,
   formatGitHubWorkflowFailure,
+  formatTreeseedDuration,
+  inspectTreeseedGitLocks,
+  inspectTreeseedWorkspaceGitLocks,
+  invalidateProofs,
   isAgentOperationName,
   listTreeseedOperationNames,
   normalizeKnowledgeHubLaunchIntent,
   planKnowledgeHubLaunch,
   planKnowledgeHubRepositories,
+  proofIdFor,
+  readProofLedger,
+  recoverTreeseedGitLocks,
   resolveAgentOperationGrant,
+  runTreeseedGit,
+  runTreeseedGitBatch,
+  runTreeseedGitOk,
+  runTreeseedGitText,
+  runTreeseedProof,
+  slowestTreeseedWorkflowPhases,
+  summarizeTreeseedProofLedger,
   validateRepositoryHost,
-  waitForGitHubWorkflowRunCompletion
+  waitForGitHubWorkflowRunCompletion,
+  writeProofRecord
 };

package/dist/platform/book-export.js

@@ -217,6 +217,8 @@ async function renderRepomixMarkdown(stageRoot, outputPath) {
     output: outputPath,
     style: "markdown",
     ignore: "",
+    gitignore: false,
+    dotIgnore: false,
     quiet: true,
     skipLocalConfig: true,
     copy: false,

package/dist/platform/books-data.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedBookDefinition, TreeseedTenantConfig } from './contracts.ts';
+import type { TreeseedBookDefinition, TreeseedTenantConfig } from './contracts.js';
 export interface DocsLibraryDownload {
     downloadFileName: string;
     downloadHref: string;

package/dist/platform/config.d.ts

@@ -0,0 +1,27 @@
+import { discoverTreeseedApplications } from '../hosting/apps.js';
+import { discoverTreeseedPackageAdapters } from '../operations/services/package-adapters.js';
+import { collectTreeseedEnvironmentContext } from '../operations/services/config-runtime.js';
+import type { TreeseedDeployConfig } from './contracts.js';
+export type TreeseedPlatformConfigInput = {
+    tenantRoot: string;
+    environment: 'local' | 'staging' | 'prod';
+    env?: Record<string, string | undefined>;
+    capacityConfigPath?: string | null;
+};
+declare function loadCapacityLaunchFromPackageManifest(tenantRoot: string): {
+    path: string;
+    manifest: import("../capacity-provider.js").CapacityProviderLaunchManifest;
+    plan: import("../capacity-provider.js").CapacityProviderLaunchPlan;
+} | null;
+declare function loadTreeseedDevManifest(tenantRoot: string): Record<string, unknown>;
+export declare function loadTreeseedPlatformConfig(input: TreeseedPlatformConfigInput): {
+    tenantRoot: string;
+    environment: 'local' | 'staging' | 'prod';
+    deployConfig: TreeseedDeployConfig;
+    packages: ReturnType<typeof discoverTreeseedPackageAdapters>;
+    applications: ReturnType<typeof discoverTreeseedApplications>;
+    capacityLaunch: ReturnType<typeof loadCapacityLaunchFromPackageManifest>;
+    dev: ReturnType<typeof loadTreeseedDevManifest>;
+    envRegistry: ReturnType<typeof collectTreeseedEnvironmentContext> | null;
+};
+export {};

package/dist/platform/config.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { parseCapacityProviderLaunchManifest, resolveCapacityProviderLaunchPlan } from "../capacity-provider.js";
+import { discoverTreeseedApplications } from "../hosting/apps.js";
+import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
+import { collectTreeseedEnvironmentContext } from "../operations/services/config-runtime.js";
+import { loadTreeseedDeployConfigFromPath, resolveTreeseedDeployConfigPathFromRoot } from "./deploy-config.js";
+function loadOptionalYaml(filePath) {
+  if (!existsSync(filePath)) return null;
+  return parseYaml(readFileSync(filePath, "utf8"));
+}
+function loadCapacityLaunchFromPackageManifest(tenantRoot) {
+  const agentManifestPath = resolve(tenantRoot, "packages", "agent", "treeseed.package.yaml");
+  const manifest = loadOptionalYaml(agentManifestPath);
+  const capacityProvider = manifest?.capacityProvider;
+  if (!capacityProvider || typeof capacityProvider !== "object" || Array.isArray(capacityProvider)) return null;
+  const local = capacityProvider.local ?? {};
+  const roles = capacityProvider.roles ?? {};
+  const launchManifest = {
+    schemaVersion: 1,
+    provider: {
+      dataDir: local.dataDir ?? ".treeseed/local-capacity-provider/data",
+      environment: "local"
+    },
+    runtime: {
+      images: {
+        roles: {
+          manager: { image: roles.manager?.image ?? "treeseed/agent-manager", tag: roles.manager?.tag ?? "latest" },
+          runner: { image: roles.runner?.image ?? "treeseed/agent-runner", tag: roles.runner?.tag ?? "latest" }
+        }
+      }
+    }
+  };
+  const parsed = parseCapacityProviderLaunchManifest(launchManifest);
+  return {
+    path: agentManifestPath,
+    manifest: parsed,
+    plan: resolveCapacityProviderLaunchPlan(parsed)
+  };
+}
+function loadCapacityLaunchFromPath(configPath) {
+  if (!configPath) return null;
+  const absolutePath = resolve(configPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Capacity launch config was not found: ${absolutePath}`);
+  }
+  const parsed = parseCapacityProviderLaunchManifest(readFileSync(absolutePath, "utf8"));
+  return {
+    path: absolutePath,
+    manifest: parsed,
+    plan: resolveCapacityProviderLaunchPlan(parsed)
+  };
+}
+function loadTreeseedDevManifest(tenantRoot) {
+  return loadOptionalYaml(resolve(tenantRoot, "treeseed.dev.yaml")) ?? {
+    schemaVersion: 1,
+    dev: {
+      processes: {
+        "market-web": { package: "@treeseed/market", cwd: ".", surface: "web" },
+        api: { package: "@treeseed/api", cwd: "packages/api", surface: "api" },
+        "operations-runner": { package: "@treeseed/api", cwd: "packages/api", surface: "operations-runner" }
+      }
+    }
+  };
+}
+function discoverPlatformPackages(tenantRoot) {
+  if (!existsSync(resolve(tenantRoot, "package.json"))) {
+    return [];
+  }
+  return discoverTreeseedPackageAdapters(tenantRoot);
+}
+function loadTreeseedPlatformConfig(input) {
+  const tenantRoot = resolve(input.tenantRoot);
+  const deployConfigPath = resolveTreeseedDeployConfigPathFromRoot(tenantRoot);
+  const deployConfig = loadTreeseedDeployConfigFromPath(deployConfigPath);
+  const packages = discoverPlatformPackages(tenantRoot);
+  const applications = discoverTreeseedApplications(tenantRoot);
+  const capacityLaunch = loadCapacityLaunchFromPath(input.capacityConfigPath ?? input.env?.TREESEED_CAPACITY_CONFIG_PATH) ?? loadCapacityLaunchFromPackageManifest(tenantRoot);
+  const dev = loadTreeseedDevManifest(tenantRoot);
+  let envRegistry = null;
+  try {
+    envRegistry = collectTreeseedEnvironmentContext(tenantRoot, input.environment, { env: input.env });
+  } catch {
+    envRegistry = null;
+  }
+  return {
+    tenantRoot,
+    environment: input.environment,
+    deployConfig,
+    packages,
+    applications,
+    capacityLaunch,
+    dev,
+    envRegistry
+  };
+}
+export {
+  loadTreeseedPlatformConfig
+};

package/dist/platform/content-runtime-source.d.ts

@@ -0,0 +1,54 @@
+import type { SeedContentRuntimeSource, SeedProjectArchitecture } from '../seeds/types.js';
+export type TreeseedEffectiveContentSource = SeedContentRuntimeSource | 'missing';
+export type TreeseedContentRuntimeMode = 'local' | 'treedx' | 'r2' | 'missing';
+export type TreeseedContentRuntimeDiagnosticStatus = 'ready' | 'missing' | 'site_not_prepared' | 'unsupported_structure';
+export type TreeseedContentRuntimeDiagnostic = {
+    code: string;
+    status: TreeseedContentRuntimeDiagnosticStatus;
+    source: TreeseedContentRuntimeMode;
+    summary: string;
+    relativePath?: string;
+};
+export type TreeseedLocalContentRuntimeSummary = {
+    requestedLocalContentMode?: 'auto' | 'none' | 'preview' | 'edit' | string;
+    materializationStatus?: string | null;
+    effectiveLocalPath?: string | null;
+    localPathExists?: boolean;
+};
+export type TreeseedR2ContentRuntimeMetadata = {
+    manifestKey?: string | null;
+    overlayKey?: string | null;
+    revision?: string | null;
+};
+export type TreeseedTreeDxContentRuntimeMetadata = {
+    libraryId?: string | null;
+    repositoryId?: string | null;
+    snapshotId?: string | null;
+};
+export type TreeseedContentRuntimeResolution = {
+    contentRuntimeSource: SeedContentRuntimeSource;
+    effectiveContentSource: TreeseedEffectiveContentSource;
+    mode: TreeseedContentRuntimeMode;
+    ready: boolean;
+    manifestKey: string | null;
+    overlayKey: string | null;
+    revision: string | null;
+    snapshotId: string | null;
+    diagnostics: TreeseedContentRuntimeDiagnostic[];
+    localPath?: string | null;
+};
+export declare function resolveTreeseedContentRuntimeSource(input: {
+    architecture: Pick<SeedProjectArchitecture, 'contentRuntimeSource' | 'contentPublishTarget'>;
+    local?: TreeseedLocalContentRuntimeSummary | null;
+    r2?: TreeseedR2ContentRuntimeMetadata | null;
+    treeDx?: TreeseedTreeDxContentRuntimeMetadata | null;
+    includeLocalPath?: boolean;
+}): TreeseedContentRuntimeResolution;
+export declare function inspectTreeseedContentStructure(input: {
+    projectRoot: string;
+    architecture: Pick<SeedProjectArchitecture, 'rootPath' | 'sitePath' | 'contentPath'>;
+}): TreeseedContentRuntimeDiagnostic;
+export declare function contentRuntimeMetadataFromTarget(target: unknown): {
+    r2: TreeseedR2ContentRuntimeMetadata;
+    treeDx: TreeseedTreeDxContentRuntimeMetadata;
+};

package/dist/platform/content-runtime-source.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function cleanRelativePath(value, fallback = ".") {
+  const raw = text(value, fallback).replace(/\\/gu, "/").replace(/^\/+/u, "");
+  const parts = raw.split("/").filter((part) => part && part !== ".");
+  if (parts.some((part) => part === "..")) return fallback;
+  return parts.length > 0 ? parts.join("/") : ".";
+}
+function contentRuntimeMode(source) {
+  if (source === "local_directory") return "local";
+  if (source === "treedx_snapshot") return "treedx";
+  if (source === "r2_published_manifest" || source === "r2_preview_overlay") return "r2";
+  return "missing";
+}
+function localStatusReady(status) {
+  return status === "existing_path_ready" || status === "managed_clone_ready" || status === "submodule_ready";
+}
+function localContentRequested(architecture, local) {
+  const mode = local?.requestedLocalContentMode;
+  return architecture.contentRuntimeSource === "local_directory" || mode === "preview" || mode === "edit";
+}
+function defaultManifestKey(architecture) {
+  const target = architecture.contentPublishTarget;
+  return target?.kind === "cloudflare_r2" && typeof target.manifestPath === "string" && target.manifestPath.trim() ? target.manifestPath.trim() : null;
+}
+function resolveTreeseedContentRuntimeSource(input) {
+  const diagnostics = [];
+  const localReady = input.local?.localPathExists === true || localStatusReady(input.local?.materializationStatus);
+  const localSelected = localReady && localContentRequested(input.architecture, input.local);
+  const source = localSelected ? "local_directory" : input.architecture.contentRuntimeSource ?? "r2_published_manifest";
+  const mode = contentRuntimeMode(source);
+  const manifestKey = input.r2?.manifestKey ?? defaultManifestKey(input.architecture);
+  const overlayKey = source === "r2_preview_overlay" ? input.r2?.overlayKey ?? null : null;
+  const snapshotId = source === "treedx_snapshot" ? input.treeDx?.snapshotId ?? null : null;
+  const revision = source === "r2_published_manifest" || source === "r2_preview_overlay" ? input.r2?.revision ?? null : null;
+  if (source === "local_directory") {
+    diagnostics.push({
+      code: localReady ? "local_content_ready" : "local_content_missing",
+      status: localReady ? "ready" : "missing",
+      source: "local",
+      summary: localReady ? "Local content path is available for runtime preview." : "Local content path is not available."
+    });
+  } else if (source === "treedx_snapshot") {
+    const ready = Boolean(snapshotId || input.treeDx?.libraryId || input.treeDx?.repositoryId);
+    diagnostics.push({
+      code: ready ? "treedx_snapshot_ready" : "treedx_snapshot_missing",
+      status: ready ? "ready" : "missing",
+      source: "treedx",
+      summary: ready ? "TreeDX content snapshot metadata is available." : "TreeDX content snapshot metadata is missing."
+    });
+  } else if (source === "r2_published_manifest" || source === "r2_preview_overlay") {
+    const ready = Boolean(manifestKey);
+    diagnostics.push({
+      code: ready ? "r2_manifest_ready" : "r2_manifest_missing",
+      status: ready ? "ready" : "missing",
+      source: "r2",
+      summary: ready ? "R2 published content manifest metadata is available." : "R2 published content manifest metadata is missing."
+    });
+    if (source === "r2_preview_overlay" && !overlayKey) {
+      diagnostics.push({
+        code: "r2_preview_overlay_missing",
+        status: "missing",
+        source: "r2",
+        summary: "R2 preview overlay metadata is missing."
+      });
+    }
+  }
+  return {
+    contentRuntimeSource: input.architecture.contentRuntimeSource,
+    effectiveContentSource: source,
+    mode,
+    ready: diagnostics.every((entry) => entry.status === "ready"),
+    manifestKey,
+    overlayKey,
+    revision,
+    snapshotId,
+    diagnostics,
+    ...input.includeLocalPath ? { localPath: input.local?.effectiveLocalPath ?? null } : {}
+  };
+}
+function hasMarkdownFile(root) {
+  if (!existsSync(root)) return false;
+  const stats = statSync(root);
+  if (stats.isFile()) return root.endsWith(".md") || root.endsWith(".mdx");
+  if (!stats.isDirectory()) return false;
+  return readdirSync(root, { withFileTypes: true }).some((entry) => {
+    const fullPath = resolve(root, entry.name);
+    if (entry.isDirectory()) return hasMarkdownFile(fullPath);
+    return entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"));
+  });
+}
+function inspectTreeseedContentStructure(input) {
+  const rootPath = cleanRelativePath(input.architecture.rootPath);
+  const sitePath = cleanRelativePath(input.architecture.sitePath);
+  const contentPath = input.architecture.contentPath ? cleanRelativePath(input.architecture.contentPath) : null;
+  const siteRoot = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, sitePath === "." ? "" : sitePath);
+  if (!existsSync(siteRoot)) {
+    return {
+      code: "site_not_prepared",
+      status: "site_not_prepared",
+      source: "local",
+      summary: "Site path is not prepared yet.",
+      relativePath: sitePath
+    };
+  }
+  const candidatePaths = [
+    contentPath,
+    sitePath === "." ? "src/content" : `${sitePath}/src/content`,
+    sitePath,
+    "content"
+  ].filter((entry) => Boolean(entry));
+  for (const candidate of [...new Set(candidatePaths)]) {
+    const absolute = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, candidate === "." ? "" : candidate);
+    if (!existsSync(absolute)) continue;
+    if (hasMarkdownFile(absolute)) {
+      return {
+        code: "content_structure_ready",
+        status: "ready",
+        source: "local",
+        summary: "Content structure contains Markdown or MDX files.",
+        relativePath: candidate
+      };
+    }
+    return {
+      code: "unsupported_content_structure",
+      status: "unsupported_structure",
+      source: "local",
+      summary: "Content path exists but does not contain Markdown or MDX files.",
+      relativePath: candidate
+    };
+  }
+  return {
+    code: "content_structure_missing",
+    status: "missing",
+    source: "local",
+    summary: "No supported local content path was found.",
+    relativePath: contentPath ?? "src/content"
+  };
+}
+function contentRuntimeMetadataFromTarget(target) {
+  const record = isRecord(target) ? target : {};
+  const contentRuntime = isRecord(record.contentRuntime) ? record.contentRuntime : {};
+  const contentPublish = isRecord(record.contentPublish) ? record.contentPublish : {};
+  const r2 = isRecord(contentRuntime.r2) ? contentRuntime.r2 : isRecord(contentPublish.r2) ? contentPublish.r2 : {};
+  const treeDx = isRecord(contentRuntime.treeDx) ? contentRuntime.treeDx : contentPublish.provider === "treedx" ? contentPublish : {};
+  return {
+    r2: {
+      manifestKey: text(contentRuntime.manifestKey) || text(r2.manifestKey) || text(r2.manifestPath) || null,
+      overlayKey: text(contentRuntime.overlayKey) || text(r2.overlayKey) || null,
+      revision: text(contentRuntime.revision) || text(r2.revision) || null
+    },
+    treeDx: {
+      libraryId: text(treeDx.libraryId) || null,
+      repositoryId: text(treeDx.repositoryId) || null,
+      snapshotId: text(treeDx.snapshotId) || text(contentPublish.snapshotId) || null
+    }
+  };
+}
+export {
+  contentRuntimeMetadataFromTarget,
+  inspectTreeseedContentStructure,
+  resolveTreeseedContentRuntimeSource
+};

package/dist/platform/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { CapacityProviderRegistrationRequest } from '../capacity-provider.ts';
+import type { CapacityProviderRegistrationRequest } from '../capacity-provider.js';
 export type TreeseedFeatureName = 'docs' | 'books' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'agents' | 'forms';
 export type TreeseedContentCollection = 'pages' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'people' | 'agents' | 'books' | 'docs' | 'templates' | 'knowledge_packs' | 'workdays';
 export interface TreeseedFeatureModules {
@@ -226,6 +226,11 @@ export interface TreeseedManagedServiceRailwayConfig {
     serviceId?: string;
     serviceName?: string;
     rootDir?: string;
+    imageRef?: string;
+    sourceMode?: 'git' | 'image';
+    sourceRepo?: string;
+    sourceBranch?: string;
+    sourceRootDirectory?: string;
     buildCommand?: string;
     startCommand?: string;
     healthcheckPath?: string;

package/dist/platform/deploy-config.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDeployConfig, TreeseedWebCachePolicyConfig } from './contracts.ts';
+import type { TreeseedDeployConfig, TreeseedWebCachePolicyConfig } from './contracts.js';
 export declare function resolveTreeseedDeployConfigPath(configPath?: string): string;
 export declare function resolveTreeseedDeployConfigPathFromRoot(tenantRoot: string, configPath?: string): string;
 export declare function deriveCloudflareWorkerName(config: TreeseedDeployConfig): string;

package/dist/platform/deploy-config.js

@@ -365,6 +365,12 @@ function parseManagedServiceConfig(value, label) {
       serviceId: optionalString(railway.serviceId),
       serviceName: optionalString(railway.serviceName),
       rootDir: optionalString(railway.rootDir),
+      imageRef: optionalString(railway.imageRef),
+      sourceMode: optionalEnum(railway.sourceMode, `${label}.railway.sourceMode`, ["git", "image"]),
+      sourceRepo: optionalString(railway.sourceRepo),
+      sourceBranch: optionalString(railway.sourceBranch),
+      sourceRootDirectory: optionalString(railway.sourceRootDirectory),
+      dockerfilePath: optionalString(railway.dockerfilePath),
       buildCommand: optionalString(railway.buildCommand),
       startCommand: optionalString(railway.startCommand),
       healthcheckPath: optionalString(railway.healthcheckPath),
@@ -615,7 +621,7 @@ function parseDeployConfig(raw) {
     hub,
     runtime,
     cloudflare: {
-      accountId: optionalCloudflareAccountId(process.env.CLOUDFLARE_ACCOUNT_ID) ?? CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER,
+      accountId: optionalCloudflareAccountId(process.env.TREESEED_CLOUDFLARE_ACCOUNT_ID) ?? CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER,
       zoneId: optionalString(cloudflare.zoneId),
       workerName: optionalString(cloudflare.workerName),
       queueName: optionalString(cloudflare.queueName),

package/dist/platform/deploy-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDeployConfig } from './contracts.ts';
+import type { TreeseedDeployConfig } from './contracts.js';
 export declare function getTreeseedDeployConfig(): TreeseedDeployConfig;
 export declare function resetTreeseedDeployConfigForTests(): void;
 export declare function getTreeseedFormsProvider(): string;

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

@@ -0,0 +1,63 @@
+import type { TreeseedDesiredUnit, TreeseedReconcileSelector, TreeseedReconcileTarget } from '../reconcile/contracts.js';
+import { type TreeseedLocalContentMode } from './local-content-materialization.js';
+export type TreeseedDesiredEnvironment = 'local' | 'staging' | 'prod';
+export type TreeseedPackageUnit = {
+    id: string;
+    name: string;
+    kind: string;
+    path: string;
+    version: string | null;
+    publishTarget: string | null;
+    manifestPath: string | null;
+    repository: string | null;
+    releaseCapability: 'npm' | 'image' | 'deploy-only' | 'none';
+};
+export type TreeseedTemplateUnit = {
+    id: string;
+    name: string;
+    category: string;
+    path: string;
+    version: string | null;
+    repository: string | null;
+    manifestPath: string | null;
+    releaseTag: string | null;
+    recordPath: string;
+};
+export type TreeseedDesiredResourceKind = 'package-manifest' | 'template-manifest' | 'package-workflow' | 'package-image' | 'github-environment' | 'github-secret-binding' | 'docker-image-build' | 'cloudflare-resource' | 'railway-project' | 'railway-environment' | 'railway-service' | 'railway-volume' | 'railway-domain' | 'local-process' | 'local-docker-compose' | 'local-treedx' | 'local-content-materialization' | 'capacity-provider' | 'branch-preview' | 'branch-preview-cleanup' | 'workflow-gate' | 'save-gate' | 'release-gate';
+export type TreeseedDesiredResource = {
+    id: string;
+    kind: TreeseedDesiredResourceKind;
+    provider: string;
+    environment: TreeseedDesiredEnvironment;
+    packageId: string | null;
+    serviceId: string | null;
+    logicalName: string;
+    dependencies: string[];
+    spec: Record<string, unknown>;
+    source: {
+        type: 'reconcile-unit' | 'package-adapter';
+        id: string;
+    };
+};
+export type TreeseedDesiredResourceEdge = {
+    from: string;
+    to: string;
+    reason: 'depends-on' | 'releases' | 'hosts';
+};
+export type TreeseedDesiredResourceGraph = {
+    workspaceId: string;
+    environment: TreeseedDesiredEnvironment;
+    packages: TreeseedPackageUnit[];
+    templates: TreeseedTemplateUnit[];
+    resources: TreeseedDesiredResource[];
+    edges: TreeseedDesiredResourceEdge[];
+    fingerprints: Record<string, string>;
+};
+export declare function compileTreeseedDesiredResourceGraph({ tenantRoot, target, localContent, }: {
+    tenantRoot?: string;
+    target: TreeseedReconcileTarget;
+    localContent?: TreeseedLocalContentMode;
+}): TreeseedDesiredResourceGraph;
+export declare function selectTreeseedDesiredResources(graph: TreeseedDesiredResourceGraph, selector?: TreeseedReconcileSelector): TreeseedDesiredResourceGraph;
+export declare function convertDesiredResourceToReconcileUnit(graph: TreeseedDesiredResourceGraph, resource: TreeseedDesiredResource): TreeseedDesiredUnit | null;
+export declare function compileTreeseedDesiredUnitsFromGraph(graph: TreeseedDesiredResourceGraph, selector?: TreeseedReconcileSelector): TreeseedDesiredUnit[];