@treeseed/sdk 0.10.28 → 0.12.4

package/dist/platform/environment.d.ts

@@ -1,5 +1,5 @@
-import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
-import { type LoadedTreeseedPluginEntry } from './plugins.ts';
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.js';
+import { type LoadedTreeseedPluginEntry } from './plugins.js';
 export declare const TREESEED_ENVIRONMENT_SCOPES: readonly ["local", "staging", "prod"];
 export declare const TREESEED_ENVIRONMENT_REQUIREMENTS: readonly ["required", "conditional", "optional", "generated"];
 export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-runtime", "local-cloudflare", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "railway-secret", "railway-var", "config-file"];
@@ -75,6 +75,7 @@ export type TreeseedEnvironmentEntry = {
     howToGet: string;
     sensitivity: TreeseedEnvironmentSensitivity;
     targets: TreeseedEnvironmentTarget[];
+    appTargets?: string[];
     serviceTargets?: string[];
     scopes: TreeseedEnvironmentScope[];
     requirement: TreeseedEnvironmentRequirement;

package/dist/platform/environment.js

@@ -1,9 +1,12 @@
 import { randomBytes } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import { runTreeseedGit } from "../operations/services/git-runner.js";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseYaml } from "yaml";
+import { discoverTreeseedApplications } from "../hosting/apps.js";
+import { githubRepositoryCredentialEnvName } from "../operations/services/github-credentials.js";
+import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
 import { loadTreeseedDeployConfig } from "./deploy-config.js";
 import { loadTreeseedPlugins } from "./plugins.js";
 import { loadTreeseedManifest } from "./tenant-config.js";
@@ -32,6 +35,8 @@ function firstExistingPath(candidates) {
 function resolveSdkEnvironmentPath() {
   const candidates = [
     resolve(moduleDir, "env.yaml"),
+    resolve(moduleDir, "../../src/platform/env.yaml"),
+    resolve(moduleDir, "../../dist/platform/env.yaml"),
     resolve(moduleDir, "../src/platform/env.yaml"),
     resolve(moduleDir, "../dist/platform/env.yaml")
   ];
@@ -45,11 +50,8 @@ function resolveSiblingPackageEnvironmentPath(packageDir) {
     resolve(moduleDir, `../../${packageDir}/dist/env.yaml`)
   ]);
 }
-const SDK_ENVIRONMENT_PATH = resolveSdkEnvironmentPath();
-const CORE_ENVIRONMENT_PATH = resolveSiblingPackageEnvironmentPath("core");
-const AGENT_ENVIRONMENT_PATH = resolveSiblingPackageEnvironmentPath("agent");
 const TENANT_ENVIRONMENT_OVERLAY_PATH = "src/env.yaml";
-const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.ai";
+const DEFAULT_TREESEED_MARKET_BASE_URL = "https://api.treeseed.dev";
 function loadOptionalTenantConfig() {
   try {
     return loadTreeseedManifest();
@@ -113,6 +115,9 @@ function codexExecutionSelected(context) {
   const execution = context.deployConfig.providers?.agents?.execution ?? "codex";
   return execution === "codex" || execution === "codex_subscription";
 }
+function copilotExecutionSelected(context) {
+  return context.deployConfig.providers?.agents?.execution === "github_copilot";
+}
 function railwayManagedEnabled(context) {
   if (!workflowPlaneAllows("processing")) {
     return false;
@@ -146,7 +151,7 @@ function resolveHostingRegistration(context) {
   return context.deployConfig.hosting?.registration ?? "none";
 }
 function marketControlPlaneEnabled(context) {
-  return resolveHostingKind(context) === "market_control_plane";
+  return resolveHostingKind(context) === "treeseed_control_plane";
 }
 function hostedProjectEnabled(context) {
   return resolveHostingKind(context) === "hosted_project";
@@ -175,6 +180,13 @@ function contactEmailDefault(context) {
 function workdayWindowsDefault() {
   return JSON.stringify([{ days: [1, 2, 3, 4, 5], startTime: "09:00", endTime: "17:00" }]);
 }
+function localApiDatabaseUrlDefault(_context, _scope, values = {}) {
+  const port = values.TREESEED_MARKET_LOCAL_POSTGRES_PORT?.trim() || values.TREESEED_API_LOCAL_POSTGRES_PORT?.trim() || process.env.TREESEED_MARKET_LOCAL_POSTGRES_PORT?.trim() || "54329";
+  const database = values.TREESEED_MARKET_LOCAL_POSTGRES_DATABASE?.trim() || values.TREESEED_API_LOCAL_POSTGRES_DATABASE?.trim() || "treeseed_api";
+  const user = values.TREESEED_MARKET_LOCAL_POSTGRES_USER?.trim() || values.TREESEED_API_LOCAL_POSTGRES_USER?.trim() || "treeseed";
+  const password = values.TREESEED_MARKET_LOCAL_POSTGRES_PASSWORD?.trim() || values.TREESEED_API_LOCAL_POSTGRES_PASSWORD?.trim() || "treeseed-local-dev";
+  return `postgres://${encodeURIComponent(user)}:${encodeURIComponent(password)}@127.0.0.1:${port}/${encodeURIComponent(database)}`;
+}
 function normalizeUrl(value) {
   return value.trim().replace(/\/$/u, "");
 }
@@ -204,6 +216,15 @@ function deriveApiDomainFromProjectDomain(domain) {
   }
   return `api.${segments.slice(1).join(".")}`;
 }
+function projectDomainsDefault(context, scope) {
+  if (scope === "staging") {
+    return context.deployConfig.surfaces?.web?.environments?.staging?.domain ?? primaryHostFromUrl(context.deployConfig.surfaces?.web?.environments?.staging?.baseUrl) ?? primaryHostFromUrl(context.deployConfig.siteUrl);
+  }
+  if (scope === "prod") {
+    return context.deployConfig.surfaces?.web?.environments?.prod?.domain ?? primaryHostFromUrl(context.deployConfig.surfaces?.web?.environments?.prod?.baseUrl) ?? primaryHostFromUrl(context.deployConfig.surfaces?.web?.publicBaseUrl) ?? primaryHostFromUrl(context.deployConfig.siteUrl);
+  }
+  return primaryHostFromUrl(context.deployConfig.siteUrl);
+}
 function resolveConfiguredApiBaseUrl(context, scope, values = {}) {
   const localBaseUrl = context.deployConfig.services?.api?.environments?.local?.baseUrl ?? context.deployConfig.surfaces?.api?.localBaseUrl ?? "http://127.0.0.1:3000";
   if (scope === "local") {
@@ -235,7 +256,7 @@ function resolvePagesProjectName(context) {
   return context.deployConfig.slug;
 }
 function resolvePagesPreviewProjectName(context, _scope, values = {}) {
-  return values.TREESEED_CLOUDFLARE_PAGES_PROJECT_NAME?.trim() || `${context.deployConfig.slug}-staging`;
+  return values.TREESEED_CLOUDFLARE_PAGES_PROJECT_NAME?.trim() || context.deployConfig.cloudflare.pages?.projectName?.trim() || context.deployConfig.slug;
 }
 function resolveContentBucketName(context) {
   return `${context.deployConfig.slug}-content`;
@@ -244,13 +265,13 @@ function resolveContentBucketBinding(context) {
   return context.deployConfig.cloudflare.r2?.binding?.trim() || "TREESEED_CONTENT_BUCKET";
 }
 function resolveMarketBaseUrl(context, _scope, values = {}) {
-  return values.TREESEED_MARKET_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || context.deployConfig.runtime?.marketBaseUrl?.trim() || context.deployConfig.hosting?.marketBaseUrl?.trim() || DEFAULT_TREESEED_MARKET_BASE_URL;
+  return values.TREESEED_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_API_BASE_URL?.trim() || process.env.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || context.deployConfig.runtime?.marketBaseUrl?.trim() || context.deployConfig.hosting?.marketBaseUrl?.trim() || DEFAULT_TREESEED_MARKET_BASE_URL;
 }
 function resolveCentralMarketBaseUrl(context, scope, values = {}) {
   return values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || resolveMarketBaseUrl(context, scope, values) || DEFAULT_TREESEED_MARKET_BASE_URL;
 }
 function resolveCatalogMarketBaseUrls(context, scope, values = {}) {
-  return values.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || values.TREESEED_MARKET_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || resolveCentralMarketBaseUrl(context, scope, values);
+  return values.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || values.TREESEED_API_BASE_URL?.trim() || values.TREESEED_CENTRAL_MARKET_API_BASE_URL?.trim() || process.env.TREESEED_CATALOG_MARKET_API_BASE_URLS?.trim() || resolveCentralMarketBaseUrl(context, scope, values);
 }
 function resolveHostedTeamId(context) {
   return context.deployConfig.slug;
@@ -262,7 +283,7 @@ function resolveRailwayWorkspaceDefault() {
   return "knowledge-coop";
 }
 function resolvePlatformRunnerIdDefault(_context, scope) {
-  return scope === "prod" ? "market-ops-prod-1" : scope === "staging" ? "market-ops-staging-1" : "market-ops-local-1";
+  return scope === "prod" ? "treeseed-ops-prod-1" : scope === "staging" ? "treeseed-ops-staging-1" : "treeseed-ops-local-1";
 }
 function resolvePlatformRunnerEnvironmentDefault(_context, scope) {
   return scope === "prod" ? "production" : scope;
@@ -280,10 +301,18 @@ function parseGitHubRepositorySlugFromRemote(remoteUrl) {
   return null;
 }
 function resolveGitHubOriginRepository(context) {
-  const result = spawnSync("git", ["remote", "get-url", "origin"], {
+  const rootResult = runTreeseedGit(["rev-parse", "--show-toplevel"], {
     cwd: context.tenantRoot,
-    stdio: "pipe",
-    encoding: "utf8"
+    mode: "read",
+    allowFailure: true
+  });
+  if (rootResult.status !== 0 || resolve(rootResult.stdout.trim()) !== resolve(context.tenantRoot)) {
+    return null;
+  }
+  const result = runTreeseedGit(["remote", "get-url", "origin"], {
+    cwd: context.tenantRoot,
+    mode: "read",
+    allowFailure: true
   });
   if (result.status !== 0) {
     return null;
@@ -301,8 +330,9 @@ const VALUE_RESOLVERS = {
   localFormsBypassDefault: () => "true",
   localSmtpHostDefault: () => localSmtpHostDefault(),
   localSmtpPortDefault: () => localSmtpPortDefault(),
+  localApiDatabaseUrlDefault: (context, scope, values) => localApiDatabaseUrlDefault(context, scope, values),
   contactEmailDefault: (context) => contactEmailDefault(context),
-  projectDomainsDefault: (context) => primaryHostFromUrl(context.deployConfig.siteUrl),
+  projectDomainsDefault: (context, scope) => projectDomainsDefault(context, scope),
   apiBaseUrlDefault: (context, scope, values) => resolveConfiguredApiBaseUrl(context, scope, values),
   webServiceIdDefault: (_context, _scope, values) => resolveWebServiceId(values),
   apiWebServiceIdDefault: (_context, _scope, values) => resolveApiWebServiceId(values),
@@ -324,6 +354,7 @@ const VALUE_RESOLVERS = {
   platformRunnerIdDefault: (context, scope) => resolvePlatformRunnerIdDefault(context, scope),
   platformRunnerEnvironmentDefault: (context, scope) => resolvePlatformRunnerEnvironmentDefault(context, scope),
   platformRunnerDataDirDefault: () => "/data",
+  treedxDockerImageDefault: () => "treeseed/treedx:latest",
   githubOwnerDefault: (context) => resolveGitHubOwnerDefault(context),
   githubRepositoryNameDefault: (context) => resolveGitHubRepositoryNameDefault(context),
   githubRepositoryVisibilityDefault: () => "private",
@@ -350,6 +381,7 @@ const PREDICATES = {
   processingPlaneEnabled: (context) => processingPlaneEnabled(context),
   formsEnabled: (context) => formsEnabled(context),
   codexExecutionSelected: (context) => codexExecutionSelected(context),
+  copilotExecutionSelected: (context) => copilotExecutionSelected(context),
   railwayManagedEnabled: (context) => railwayManagedEnabled(context),
   hubTreeseedHosted: (context) => resolveHubMode(context) === "treeseed_hosted",
   hubCustomerHosted: (context) => resolveHubMode(context) === "customer_hosted",
@@ -413,6 +445,44 @@ function readPluginEnvironmentOverlay(baseDir) {
   }
   return null;
 }
+function packageRepositoryCredentialOverlay(tenantRoot) {
+  const entries = {};
+  let packages = [];
+  try {
+    packages = discoverTreeseedPackageAdapters(tenantRoot);
+  } catch {
+    packages = [];
+  }
+  for (const pkg of packages) {
+    const repository = typeof pkg.metadata.repository === "string" && pkg.metadata.repository.trim() ? pkg.metadata.repository.trim() : null;
+    if (!repository) continue;
+    let id = "";
+    try {
+      id = githubRepositoryCredentialEnvName(repository);
+    } catch {
+      continue;
+    }
+    entries[id] = {
+      label: `${pkg.name} GitHub token`,
+      group: "github",
+      cluster: `github:${repository}`,
+      description: `GitHub token used by Treeseed package workflows for ${pkg.name} in ${repository}.`,
+      howToGet: `Create a GitHub token with Actions workflow and environment secret permissions for ${repository}, then store it as ${id}.`,
+      sensitivity: "secret",
+      targets: ["local-runtime"],
+      scopes: ["staging", "prod"],
+      storage: "shared",
+      requirement: "optional",
+      purposes: ["deploy", "config"],
+      validation: {
+        kind: "nonempty",
+        minLength: 8
+      },
+      sourcePriority: ["machine-config", "process-env"]
+    };
+  }
+  return { entries };
+}
 function loadTreeseedEnvironmentOverlay(tenantRoot) {
   const overlayPath = resolve(tenantRoot, TENANT_ENVIRONMENT_OVERLAY_PATH);
   return {
@@ -460,23 +530,54 @@ function mergeEntryYaml(baseEntry, id, override) {
 }
 function collectOverlaySources(context) {
   const sources = [];
-  const sdkOverlay = readYamlOverlayIfPresent(SDK_ENVIRONMENT_PATH);
+  const sdkEnvironmentPath = resolveSdkEnvironmentPath();
+  const sdkOverlay = readYamlOverlayIfPresent(sdkEnvironmentPath);
   if (!sdkOverlay) {
-    throw new Error(`Treeseed SDK environment registry file was not found at ${SDK_ENVIRONMENT_PATH}.`);
+    throw new Error(`Treeseed SDK environment registry file was not found at ${sdkEnvironmentPath}.`);
   }
-  sources.push({ label: SDK_ENVIRONMENT_PATH, overlay: sdkOverlay });
+  sources.push({ label: sdkEnvironmentPath, overlay: sdkOverlay });
   if (webSurfaceEnabled(context)) {
-    const coreOverlay = readYamlOverlayIfPresent(CORE_ENVIRONMENT_PATH);
+    const coreEnvironmentPath = resolveSiblingPackageEnvironmentPath("core");
+    const coreOverlay = readYamlOverlayIfPresent(coreEnvironmentPath);
     if (coreOverlay) {
-      sources.push({ label: CORE_ENVIRONMENT_PATH, overlay: coreOverlay });
+      sources.push({ label: coreEnvironmentPath, overlay: coreOverlay });
     }
   }
   if (apiSurfaceEnabled(context) || processingPlaneEnabled(context)) {
-    const agentOverlay = readYamlOverlayIfPresent(AGENT_ENVIRONMENT_PATH);
+    const apiEnvironmentPath = resolveSiblingPackageEnvironmentPath("api");
+    const apiOverlay = readYamlOverlayIfPresent(apiEnvironmentPath);
+    if (apiOverlay) {
+      sources.push({ label: apiEnvironmentPath, overlay: apiOverlay });
+    }
+    const agentEnvironmentPath = resolveSiblingPackageEnvironmentPath("agent");
+    const agentOverlay = readYamlOverlayIfPresent(agentEnvironmentPath);
     if (agentOverlay) {
-      sources.push({ label: AGENT_ENVIRONMENT_PATH, overlay: agentOverlay });
+      sources.push({ label: agentEnvironmentPath, overlay: agentOverlay });
     }
   }
+  let discoveredApiApps = [];
+  try {
+    discoveredApiApps = discoverTreeseedApplications(context.tenantRoot).filter((application) => application.root !== context.tenantRoot && application.roles.some((role) => role === "api" || role === "operations-runner" || role === "treeseed-control-plane"));
+  } catch {
+    discoveredApiApps = [];
+  }
+  const discoveredApiEnvironmentPath = resolveSiblingPackageEnvironmentPath("api");
+  if (discoveredApiApps.length > 0 && !sources.some((source) => source.label === discoveredApiEnvironmentPath)) {
+    const apiOverlay = readYamlOverlayIfPresent(discoveredApiEnvironmentPath);
+    if (apiOverlay) {
+      sources.push({ label: discoveredApiEnvironmentPath, overlay: apiOverlay });
+    }
+  }
+  for (const application of discoveredApiApps) {
+    const overlay = readYamlOverlayIfPresent(resolve(application.root, "src/env.yaml"));
+    if (overlay) {
+      sources.push({ label: resolve(application.root, "src/env.yaml"), overlay });
+    }
+  }
+  const packageCredentialOverlay = packageRepositoryCredentialOverlay(context.tenantRoot);
+  if (Object.keys(packageCredentialOverlay.entries ?? {}).length > 0) {
+    sources.push({ label: "discovered package repository credentials", overlay: packageCredentialOverlay });
+  }
   for (const pluginEntry of context.plugins) {
     const fileOverlay = readPluginEnvironmentOverlay(pluginEntry.baseDir);
     if (fileOverlay) {

package/dist/platform/local-content-materialization.d.ts

@@ -0,0 +1,9 @@
+import type { TreeseedDesiredEnvironment, TreeseedDesiredResource } from './desired-state.js';
+export declare const TREESEED_LOCAL_CONTENT_MODES: readonly ["auto", "none", "preview", "edit"];
+export type TreeseedLocalContentMode = typeof TREESEED_LOCAL_CONTENT_MODES[number];
+export type TreeseedLocalContentMaterializationStatus = 'not_requested' | 'existing_path_ready' | 'existing_path_missing' | 'managed_clone_ready' | 'managed_clone_missing' | 'submodule_ready' | 'submodule_missing' | 'site_not_prepared' | 'blocked';
+export declare function buildProjectLocalContentResources({ tenantRoot, environment, localContent, }: {
+    tenantRoot: string;
+    environment: TreeseedDesiredEnvironment;
+    localContent?: TreeseedLocalContentMode;
+}): TreeseedDesiredResource[];

package/dist/platform/local-content-materialization.js

@@ -0,0 +1,212 @@
+import { existsSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { loadAndPlanSeed } from "../seeds/index.js";
+const TREESEED_LOCAL_CONTENT_MODES = ["auto", "none", "preview", "edit"];
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function safeSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "") || "project";
+}
+function normalizeRelativePath(value, fallback = ".") {
+  const raw = stringValue(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 pathFrom(root, ...parts) {
+  const clean = parts.filter((part) => Boolean(part && part !== "."));
+  return resolve(root, ...clean);
+}
+function isPreparedSitePath(path) {
+  if (!existsSync(path)) return false;
+  const stat = statSync(path);
+  if (!stat.isDirectory()) return false;
+  return [
+    "treeseed.site.yaml",
+    "astro.config.ts",
+    "astro.config.ts",
+    "package.json",
+    "src"
+  ].some((entry) => existsSync(resolve(path, entry)));
+}
+function contentSourceMode(source) {
+  if (source === "local_directory") return "local_directory";
+  if (source === "treedx_snapshot") return "treedx";
+  return "r2";
+}
+function projectRepository(value) {
+  if (!isRecord(value)) return null;
+  const provider = stringValue(value.provider);
+  const owner = stringValue(value.owner);
+  const name = stringValue(value.name);
+  const gitUrl = stringValue(value.gitUrl);
+  const role = stringValue(value.role, "software");
+  if (!provider || !owner || !name || !gitUrl) return null;
+  return {
+    role,
+    provider,
+    owner,
+    name,
+    gitUrl,
+    defaultBranch: stringValue(value.defaultBranch, "main"),
+    checkoutPath: stringValue(value.checkoutPath) || void 0,
+    submodulePath: stringValue(value.submodulePath) || void 0,
+    webUrl: stringValue(value.webUrl) || void 0
+  };
+}
+function projectArchitecture(value) {
+  if (!isRecord(value)) return null;
+  const topology = stringValue(value.topology);
+  const contentRuntimeSource = stringValue(value.contentRuntimeSource);
+  const localContentMaterialization = stringValue(value.localContentMaterialization);
+  if (!topology || !contentRuntimeSource || !localContentMaterialization) return null;
+  return {
+    topology,
+    rootPath: normalizeRelativePath(value.rootPath),
+    sitePath: normalizeRelativePath(value.sitePath),
+    contentPath: stringValue(value.contentPath) ? normalizeRelativePath(value.contentPath) : void 0,
+    contentRuntimeSource,
+    localContentMaterialization,
+    contentPublishTarget: isRecord(value.contentPublishTarget) ? value.contentPublishTarget : void 0,
+    requiresLocalContentForCi: value.requiresLocalContentForCi === true,
+    requiresLocalContentForDeploy: value.requiresLocalContentForDeploy === true
+  };
+}
+function hubRepository(value) {
+  if (!isRecord(value)) return null;
+  const payload = value;
+  const projectKey = stringValue(payload.projectKey);
+  const role = stringValue(payload.role);
+  const provider = stringValue(payload.provider);
+  const owner = stringValue(payload.owner);
+  const name = stringValue(payload.name);
+  const gitUrl = stringValue(payload.gitUrl);
+  if (!projectKey || role !== "content" || !provider || !owner || !name || !gitUrl) return null;
+  return {
+    projectKey,
+    role,
+    provider,
+    owner,
+    name,
+    gitUrl,
+    defaultBranch: stringValue(payload.defaultBranch) || stringValue(payload.currentBranch) || "main",
+    submodulePath: stringValue(payload.submodulePath) || void 0
+  };
+}
+function requestedMaterialization(architecture, mode) {
+  if (mode === "none") return "none";
+  if (mode === "preview" || mode === "edit") {
+    if (architecture.localContentMaterialization === "none" && architecture.contentRuntimeSource !== "local_directory") {
+      return "managed_clone";
+    }
+    return architecture.localContentMaterialization === "none" ? "managed_clone" : architecture.localContentMaterialization;
+  }
+  return architecture.localContentMaterialization;
+}
+function buildProjectLocalContentResources({
+  tenantRoot,
+  environment,
+  localContent = "auto"
+}) {
+  if (environment !== "local") return [];
+  const seed = loadAndPlanSeed({
+    projectRoot: tenantRoot,
+    seedName: "treeseed",
+    environments: "local",
+    mode: "plan"
+  });
+  if (!seed.ok || !seed.plan) return [];
+  const contentRepositories = /* @__PURE__ */ new Map();
+  for (const action of seed.plan.actions) {
+    if (action.kind !== "hubRepository") continue;
+    const repo = hubRepository(action.payload);
+    if (repo) contentRepositories.set(repo.projectKey, repo);
+  }
+  return seed.plan.actions.flatMap((action) => {
+    if (action.kind !== "project") return [];
+    const payload = action.payload;
+    const architecture = projectArchitecture(payload.architecture);
+    const repository = projectRepository(payload.repository);
+    const slug = stringValue(payload.slug, safeSegment(action.key));
+    const teamSlug = stringValue(payload.teamKey, "team:treeseed").replace(/^team:/u, "") || "treeseed";
+    if (!architecture || !repository) return [];
+    const contentRepository = contentRepositories.get(action.key) ?? repository;
+    const materialization = requestedMaterialization(architecture, localContent);
+    const rootPath = normalizeRelativePath(architecture.rootPath);
+    const sitePath = normalizeRelativePath(architecture.sitePath);
+    const contentPath = architecture.contentPath ? normalizeRelativePath(architecture.contentPath) : null;
+    const repositoryCheckoutPath = normalizeRelativePath(repository.checkoutPath, ".");
+    const sourceRepoSlug = `${contentRepository.owner}/${contentRepository.name}`;
+    const managedTarget = pathFrom(tenantRoot, ".treeseed", "local-content", safeSegment(teamSlug), safeSegment(slug), "content");
+    const existingRoot = pathFrom(tenantRoot, repositoryCheckoutPath, rootPath);
+    const effectiveLocalPath = materialization === "managed_clone" ? managedTarget : materialization === "submodule" ? pathFrom(tenantRoot, repositoryCheckoutPath, normalizeRelativePath(contentRepository.submodulePath ?? repository.submodulePath ?? contentPath ?? sitePath)) : materialization === "existing_path" ? pathFrom(existingRoot, contentPath ?? sitePath) : null;
+    const siteLocalPath = materialization === "managed_clone" ? pathFrom(managedTarget, sitePath) : pathFrom(existingRoot, sitePath);
+    const siteReady = isPreparedSitePath(siteLocalPath);
+    const exists = effectiveLocalPath ? existsSync(effectiveLocalPath) : false;
+    const materializationStatus = materialization === "none" ? "not_requested" : materialization === "existing_path" ? exists ? siteReady ? "existing_path_ready" : "site_not_prepared" : "existing_path_missing" : materialization === "managed_clone" ? exists ? siteReady ? "managed_clone_ready" : "site_not_prepared" : "managed_clone_missing" : exists ? siteReady ? "submodule_ready" : "site_not_prepared" : "submodule_missing";
+    const executeRequested = (localContent === "preview" || localContent === "edit") && (materialization === "managed_clone" || materialization === "submodule");
+    return [{
+      id: `local-content-materialization:${safeSegment(teamSlug)}:${safeSegment(slug)}:content`,
+      kind: "local-content-materialization",
+      provider: "local",
+      environment,
+      packageId: "@treeseed/market",
+      serviceId: `content:${slug}`,
+      logicalName: `${stringValue(payload.name, slug)} local content materialization`,
+      dependencies: architecture.contentRuntimeSource === "treedx_snapshot" && !executeRequested ? ["local-treedx:team-primary"] : [],
+      spec: {
+        teamKey: stringValue(payload.teamKey, "team:treeseed"),
+        teamSlug,
+        projectKey: action.key,
+        projectSlug: slug,
+        projectName: stringValue(payload.name, slug),
+        topology: architecture.topology,
+        rootPath,
+        sitePath,
+        contentPath,
+        contentRuntimeSource: architecture.contentRuntimeSource,
+        contentSourceMode: contentSourceMode(architecture.contentRuntimeSource),
+        localContentMaterialization: materialization,
+        configuredLocalContentMaterialization: architecture.localContentMaterialization,
+        requestedLocalContentMode: localContent,
+        executeRequested,
+        repository: {
+          provider: repository.provider,
+          owner: repository.owner,
+          name: repository.name,
+          gitUrl: repository.gitUrl,
+          defaultBranch: repository.defaultBranch ?? "main",
+          checkoutPath: repository.checkoutPath ?? null,
+          submodulePath: repository.submodulePath ?? null
+        },
+        contentRepository: {
+          provider: contentRepository.provider,
+          owner: contentRepository.owner,
+          name: contentRepository.name,
+          gitUrl: contentRepository.gitUrl,
+          defaultBranch: contentRepository.defaultBranch ?? repository.defaultBranch ?? "main",
+          submodulePath: contentRepository.submodulePath ?? null
+        },
+        sourceRepoSlug,
+        effectiveLocalPath,
+        siteLocalPath,
+        docsSiteReadiness: siteReady ? "ready" : "site_not_prepared",
+        materializationStatus,
+        targetRelativePath: effectiveLocalPath ? effectiveLocalPath.replace(`${tenantRoot}/`, "") : null,
+        managedCloneRoot: resolve(tenantRoot, ".treeseed", "local-content"),
+        defaultDirectoryName: basename(effectiveLocalPath ?? slug)
+      },
+      source: { type: "package-adapter", id: `project-architecture:${action.key}` }
+    }];
+  });
+}
+export {
+  TREESEED_LOCAL_CONTENT_MODES,
+  buildProjectLocalContentResources
+};

package/dist/platform/plugin.d.ts

@@ -1,7 +1,8 @@
-import type { TreeseedDeployConfig, TreeseedPlatformLayerDefinition, TreeseedPlatformResourceKind, TreeseedPlatformSurfaceName, TreeseedTenantConfig } from './contracts.ts';
-import type { TreeseedEnvironmentRegistryOverlay } from './environment.ts';
-import type { SdkGraphRankingProvider } from '../sdk-types.ts';
-import type { TreeseedReconcileAdapter } from '../reconcile/contracts.ts';
+import type { TreeseedDeployConfig, TreeseedPlatformLayerDefinition, TreeseedPlatformResourceKind, TreeseedPlatformSurfaceName, TreeseedTenantConfig } from './contracts.js';
+import type { TreeseedEnvironmentRegistryOverlay } from './environment.js';
+import type { SdkGraphRankingProvider } from '../sdk-types.js';
+import type { TreeseedReconcileAdapter } from '../reconcile/contracts.js';
+import type { TreeseedApplicationHostingProfile, TreeseedHostAdapter, TreeseedServiceTypeAdapter } from '../hosting/contracts.js';
 export type TreeseedSiteLayerDefinition = TreeseedPlatformLayerDefinition & {
     kinds?: Array<'pages' | 'styles' | 'components'>;
 };
@@ -65,6 +66,13 @@ export type TreeseedContentProviderContext = TreeseedPluginEnvironmentContext &
     tenantConfig: TreeseedTenantConfig;
 };
 export type TreeseedGraphRankingProviderContribution = SdkGraphRankingProvider | ((context: TreeseedPluginEnvironmentContext) => SdkGraphRankingProvider | undefined);
+export type TreeseedHostingContribution = {
+    hostAdapters?: Record<string, TreeseedHostAdapter>;
+    serviceTypeAdapters?: Record<string, TreeseedServiceTypeAdapter>;
+    profiles?: TreeseedApplicationHostingProfile[];
+    uiPlacements?: Record<string, unknown>;
+    environmentDefaults?: Record<string, unknown>;
+};
 export interface TreeseedPlugin {
     id?: string;
     provides?: Record<string, any> & {
@@ -88,6 +96,7 @@ export interface TreeseedPlugin {
     platformLayers?: TreeseedPlatformLayerContribution[] | ((context: TreeseedPluginPlatformContext) => TreeseedPlatformLayerContribution[] | undefined);
     environmentRegistry?: TreeseedEnvironmentRegistryOverlay | ((context: TreeseedPluginEnvironmentContext) => TreeseedEnvironmentRegistryOverlay | undefined);
     reconcileAdapters?: Record<string, TreeseedReconcileAdapter | ((context: TreeseedPluginEnvironmentContext) => TreeseedReconcileAdapter | undefined)> | ((context: TreeseedPluginEnvironmentContext) => Record<string, TreeseedReconcileAdapter | ((context: TreeseedPluginEnvironmentContext) => TreeseedReconcileAdapter | undefined)> | undefined);
+    hosting?: TreeseedHostingContribution | ((context: TreeseedPluginEnvironmentContext) => TreeseedHostingContribution | undefined);
     graphRankingProviders?: Record<string, TreeseedGraphRankingProviderContribution>;
     [key: string]: unknown;
 }

package/dist/platform/plugins/runtime.d.ts

@@ -1,6 +1,6 @@
-import type { TreeseedDeployConfig } from '../contracts.ts';
-import type { TreeseedPluginEnvironmentContext } from '../plugin.ts';
-import type { SdkGraphRankingProvider } from '../../sdk-types.ts';
+import type { TreeseedDeployConfig } from '../contracts.js';
+import type { TreeseedPluginEnvironmentContext } from '../plugin.js';
+import type { SdkGraphRankingProvider } from '../../sdk-types.js';
 type LoadedPluginEntry = {
     package: string;
     config: Record<string, unknown>;

package/dist/platform/plugins/runtime.js

@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -52,6 +53,59 @@ function resolveInstalledPluginPath(packageName, tenantRoot) {
     paths: [tenantRoot, process.cwd()]
   });
 }
+function parseTreeseedPackageReference(packageName) {
+  const match = packageName.match(/^@treeseed\/([^/]+)(?:\/(.+))?$/u);
+  if (!match) return null;
+  return {
+    packageId: match[1],
+    subpath: match[2] ?? "index"
+  };
+}
+function buildWorkspacePluginArtifacts(packageDir, packageName) {
+  const packageJsonPath = path.resolve(packageDir, "package.json");
+  let packageJson;
+  try {
+    packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return false;
+  }
+  const scripts = packageJson.scripts && typeof packageJson.scripts === "object" && !Array.isArray(packageJson.scripts) ? packageJson.scripts : {};
+  const buildScript = typeof scripts["build:dist"] === "string" && scripts["build:dist"].trim() ? "build:dist" : typeof scripts.build === "string" && scripts.build.trim() ? "build" : null;
+  if (!buildScript) return false;
+  const result = spawnSync("npm", ["--prefix", packageDir, "run", buildScript], {
+    cwd: path.resolve(packageDir, "..", ".."),
+    stdio: "inherit",
+    env: process.env
+  });
+  if (result.status !== 0) {
+    throw new Error(`Failed to build ${packageName} workspace plugin artifacts with npm run ${buildScript}.`);
+  }
+  return true;
+}
+function resolveLocalWorkspacePluginPath(packageName, tenantRoot) {
+  const parsed = parseTreeseedPackageReference(packageName);
+  if (!parsed) return null;
+  const packageDir = path.resolve(tenantRoot, "packages", parsed.packageId);
+  const packageJsonPath = path.resolve(packageDir, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (packageJson?.name !== `@treeseed/${parsed.packageId}`) return null;
+  } catch {
+    return null;
+  }
+  const normalizedSubpath = parsed.subpath.replace(/^\.\//u, "").replace(/\.js$/u, "");
+  const candidates = [
+    path.resolve(packageDir, "dist", `${normalizedSubpath}.js`),
+    path.resolve(packageDir, `${normalizedSubpath}.js`)
+  ];
+  const existing = candidates.find((candidate) => existsSync(candidate));
+  if (existing) return existing;
+  if (buildWorkspacePluginArtifacts(packageDir, packageName)) {
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+  }
+  return null;
+}
 function loadPluginModule(packageName, tenantRoot) {
   if (packageName === TREESEED_DEFAULT_PLUGIN_PACKAGE) {
     const localDefaultPluginPath = resolveLocalDefaultPluginPath();
@@ -68,6 +122,13 @@ function loadPluginModule(packageName, tenantRoot) {
       baseDir: path.dirname(resolvedPath2)
     };
   }
+  const localWorkspacePluginPath = resolveLocalWorkspacePluginPath(packageName, tenantRoot);
+  if (localWorkspacePluginPath) {
+    return {
+      moduleExports: require2(localWorkspacePluginPath),
+      baseDir: path.dirname(localWorkspacePluginPath)
+    };
+  }
   const resolvedPath = resolveInstalledPluginPath(packageName, tenantRoot);
   return {
     moduleExports: require2(resolvedPath),

package/dist/platform/plugins.d.ts

@@ -1,6 +1,6 @@
-export { TREESEED_DEFAULT_PLUGIN_PACKAGE, TREESEED_DEFAULT_PLUGIN_REFERENCES, TREESEED_DEFAULT_PROVIDER_SELECTIONS, } from './plugins/constants.ts';
-export { getTreeseedAgentProviderSelections, getTreeseedContentPublishProvider, getTreeseedContentRuntimeProvider, getTreeseedDeployConfig, getTreeseedDeployProvider, getTreeseedDocsProvider, getTreeseedFormsProvider, getTreeseedOperationsProvider, getTreeseedSiteProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled, resetTreeseedDeployConfigForTests, } from './deploy-runtime.ts';
-export { defineTreeseedPlugin } from './plugin.ts';
-export type * from './plugin.ts';
-export { loadTreeseedPluginRuntime, loadTreeseedPlugins, resolveTreeseedGraphRankingProvider } from './plugins/runtime.ts';
-export type { LoadedTreeseedPluginEntry } from './plugins/runtime.ts';
+export { TREESEED_DEFAULT_PLUGIN_PACKAGE, TREESEED_DEFAULT_PLUGIN_REFERENCES, TREESEED_DEFAULT_PROVIDER_SELECTIONS, } from './plugins/constants.js';
+export { getTreeseedAgentProviderSelections, getTreeseedContentPublishProvider, getTreeseedContentRuntimeProvider, getTreeseedDeployConfig, getTreeseedDeployProvider, getTreeseedDocsProvider, getTreeseedFormsProvider, getTreeseedOperationsProvider, getTreeseedSiteProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled, resetTreeseedDeployConfigForTests, } from './deploy-runtime.js';
+export { defineTreeseedPlugin } from './plugin.js';
+export type * from './plugin.js';
+export { loadTreeseedPluginRuntime, loadTreeseedPlugins, resolveTreeseedGraphRankingProvider } from './plugins/runtime.js';
+export type { LoadedTreeseedPluginEntry } from './plugins/runtime.js';