@treeseed/sdk 0.11.0 → 0.12.5

package/dist/platform/environment.js

@@ -1,5 +1,5 @@
 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";
@@ -35,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")
   ];
@@ -48,12 +50,8 @@ function resolveSiblingPackageEnvironmentPath(packageDir) {
     resolve(moduleDir, `../../${packageDir}/dist/env.yaml`)
   ]);
 }
-const SDK_ENVIRONMENT_PATH = resolveSdkEnvironmentPath();
-const CORE_ENVIRONMENT_PATH = resolveSiblingPackageEnvironmentPath("core");
-const API_ENVIRONMENT_PATH = resolveSiblingPackageEnvironmentPath("api");
-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();
@@ -117,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;
@@ -179,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, "");
 }
@@ -208,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") {
@@ -284,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,
+    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,
-    stdio: "pipe",
-    encoding: "utf8"
+    mode: "read",
+    allowFailure: true
   });
   if (result.status !== 0) {
     return null;
@@ -305,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),
@@ -355,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",
@@ -503,25 +530,29 @@ 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 apiOverlay = readYamlOverlayIfPresent(API_ENVIRONMENT_PATH);
+    const apiEnvironmentPath = resolveSiblingPackageEnvironmentPath("api");
+    const apiOverlay = readYamlOverlayIfPresent(apiEnvironmentPath);
     if (apiOverlay) {
-      sources.push({ label: API_ENVIRONMENT_PATH, overlay: apiOverlay });
+      sources.push({ label: apiEnvironmentPath, overlay: apiOverlay });
     }
-    const agentOverlay = readYamlOverlayIfPresent(AGENT_ENVIRONMENT_PATH);
+    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 = [];
@@ -530,10 +561,11 @@ function collectOverlaySources(context) {
   } catch {
     discoveredApiApps = [];
   }
-  if (discoveredApiApps.length > 0 && !sources.some((source) => source.label === API_ENVIRONMENT_PATH)) {
-    const apiOverlay = readYamlOverlayIfPresent(API_ENVIRONMENT_PATH);
+  const discoveredApiEnvironmentPath = resolveSiblingPackageEnvironmentPath("api");
+  if (discoveredApiApps.length > 0 && !sources.some((source) => source.label === discoveredApiEnvironmentPath)) {
+    const apiOverlay = readYamlOverlayIfPresent(discoveredApiEnvironmentPath);
     if (apiOverlay) {
-      sources.push({ label: API_ENVIRONMENT_PATH, overlay: apiOverlay });
+      sources.push({ label: discoveredApiEnvironmentPath, overlay: apiOverlay });
     }
   }
   for (const application of discoveredApiApps) {

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,8 +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 { TreeseedApplicationHostingProfile, TreeseedHostAdapter, TreeseedServiceTypeAdapter } from '../hosting/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'>;
 };

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';

package/dist/platform/published-content-pipeline.d.ts

@@ -1,6 +1,6 @@
-import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
-import { type PublishContentObjectInput, type PublishedArtifactVersion, type PublishedCollectionIndex, type PublishedContentEntry, type PublishedContentManifest, type PublishedOverlayManifest, type PublishedRuntimePointers, type PublishedContentVisibility } from './published-content.ts';
-import type { CatalogIndexEntry } from './published-content.ts';
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.js';
+import { type PublishContentObjectInput, type PublishedArtifactVersion, type PublishedCollectionIndex, type PublishedContentEntry, type PublishedContentManifest, type PublishedOverlayManifest, type PublishedRuntimePointers, type PublishedContentVisibility } from './published-content.js';
+import type { CatalogIndexEntry } from './published-content.js';
 export interface ContentSourceEntry {
     model: string;
     id: string;

package/dist/platform/published-content-pipeline.js

@@ -7,11 +7,15 @@ import { toString } from "mdast-util-to-string";
 import { parseFrontmatterDocument } from "../frontmatter.js";
 import { buildTenantBookRuntime } from "./books-data.js";
 import { exportBookLibrary, exportBookPackage } from "./book-export.js";
+import { COMMERCE_OFFER_MODES } from "../sdk-types.js";
 import {
   PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
   resolvePublishedContentPreviewTtlHours,
   resolveTeamScopedContentLocator
 } from "./published-content.js";
+function resolveCommerceOfferMode(value) {
+  return typeof value === "string" && COMMERCE_OFFER_MODES.includes(value) ? value : "free";
+}
 function stableHash(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -370,7 +374,7 @@ class DefaultArtifactBuilder {
         summary: entry.summary,
         visibility: entry.visibility,
         listingEnabled: entry.metadata?.listingEnabled !== false,
-        offerMode: typeof entry.metadata?.offer?.priceModel === "string" ? entry.metadata.offer.priceModel : "free",
+        offerMode: resolveCommerceOfferMode(entry.metadata?.offer?.priceModel),
         manifestKey: resolveTeamScopedContentLocator(context.siteConfig, context.teamId).manifestKey,
         artifactKey: void 0,
         updatedAt: context.generatedAt,

package/dist/platform/published-content.d.ts

@@ -1,5 +1,6 @@
-import type { TreeseedDeployConfig } from './contracts.ts';
-import type { CloudflareRuntime, R2BucketLike } from '../types/cloudflare.ts';
+import type { TreeseedDeployConfig } from './contracts.js';
+import type { CommerceOfferMode } from '../sdk-types.js';
+import type { CloudflareRuntime, R2BucketLike } from '../types/cloudflare.js';
 export declare const PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION = 2;
 export declare const EDITORIAL_PREVIEW_COOKIE = "treeseed-content-preview";
 export type PublishedContentVisibility = 'public' | 'authenticated' | 'team' | 'private';
@@ -67,7 +68,7 @@ export interface CatalogIndexEntry {
     summary?: string;
     visibility?: PublishedContentVisibility;
     listingEnabled?: boolean;
-    offerMode?: 'free' | 'paid' | 'contact' | 'one_time_current_version' | 'subscription_updates' | 'private';
+    offerMode?: CommerceOfferMode;
     manifestKey?: string;
     artifactKey?: string;
     updatedAt: string;

package/dist/platform/site-config-schema.d.ts

@@ -0,0 +1 @@
+export { parseSiteConfig } from './utils/site-config-schema.js';

package/dist/platform/site-config-schema.js

@@ -1 +1,4 @@
-export { parseSiteConfig } from './utils/site-config-schema.js';
+import { parseSiteConfig } from "./utils/site-config-schema.js";
+export {
+  parseSiteConfig
+};