@treeseed/sdk 0.3.4 → 0.4.1

package/dist/platform/books-data.js

@@ -1 +1,82 @@
-export * from "./utils/books-data.js";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { getTenantContentRoot } from "./tenant-config.js";
+import { RUNTIME_PROJECT_ROOT, RUNTIME_TENANT } from "./tenant/runtime-config.js";
+function sortPaths(paths) {
+  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
+}
+function collectMarkdownFiles(rootPath) {
+  const stats = statSync(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  return sortPaths(
+    readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
+      const fullPath = path.join(rootPath, entry.name);
+      if (entry.isDirectory()) {
+        return collectMarkdownFiles(fullPath);
+      }
+      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+        return [fullPath];
+      }
+      return [];
+    })
+  );
+}
+function parseFrontmatter(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    throw new Error(`Book content entry is missing frontmatter: ${filePath}`);
+  }
+  return parseYaml(match[1]);
+}
+function inferDocsLibraryDownload(book) {
+  const title = book?.title ? `${book.title} Library` : "Knowledge Library";
+  return {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: title
+  };
+}
+function buildTenantBookRuntime(tenantConfig, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const booksContentRoot = path.resolve(projectRoot, getTenantContentRoot(tenantConfig, "books"));
+  const books = collectMarkdownFiles(booksContentRoot).map((filePath) => {
+    const frontmatter = parseFrontmatter(filePath);
+    return {
+      ...frontmatter,
+      id: path.basename(filePath, path.extname(filePath))
+    };
+  }).sort((left, right) => left.order - right.order);
+  const docsHomePath = options.docsHomePath ?? "/knowledge/";
+  const docsLibraryDownload = options.docsLibraryDownload ?? inferDocsLibraryDownload(tenantConfig);
+  return {
+    BOOKS: books,
+    BOOKS_LINK: {
+      label: "Books",
+      link: docsHomePath
+    },
+    TREESEED_LINKS: {
+      home: docsHomePath
+    },
+    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
+  };
+}
+const runtime = buildTenantBookRuntime(RUNTIME_TENANT, {
+  projectRoot: RUNTIME_PROJECT_ROOT,
+  docsLibraryDownload: {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: "TreeSeed Knowledge Library"
+  }
+});
+const { BOOKS, BOOKS_LINK, TREESEED_LINKS, TREESEED_LIBRARY_DOWNLOAD } = runtime;
+export {
+  BOOKS,
+  BOOKS_LINK,
+  TREESEED_LIBRARY_DOWNLOAD,
+  TREESEED_LINKS,
+  buildTenantBookRuntime
+};

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

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

package/dist/platform/deploy-config.js

@@ -1 +1,222 @@
-export * from "./deploy/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { normalizeAliasedRecord } from "../field-aliases.js";
+import { resolveTreeseedTenantRoot } from "./tenant-config.js";
+import {
+  TREESEED_DEFAULT_PLUGIN_REFERENCES,
+  TREESEED_DEFAULT_PROVIDER_SELECTIONS
+} from "./plugins/constants.js";
+const deployConfigFieldAliases = {
+  siteUrl: { key: "siteUrl", aliases: ["site_url"] },
+  contactEmail: { key: "contactEmail", aliases: ["contact_email"] }
+};
+const cloudflareFieldAliases = {
+  accountId: { key: "accountId", aliases: ["account_id"] },
+  workerName: { key: "workerName", aliases: ["worker_name"] }
+};
+const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
+function expectString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Invalid deploy config: expected ${label} to be a non-empty string.`);
+  }
+  return value.trim();
+}
+function optionalString(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  return value.trim();
+}
+function optionalCloudflareAccountId(value) {
+  const accountId = optionalString(value);
+  return accountId === CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER ? void 0 : accountId;
+}
+function optionalBoolean(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`Invalid deploy config: expected ${label} to be a boolean when provided.`);
+  }
+  return value;
+}
+function optionalRecord(value, label) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid deploy config: expected ${label} to be an object when provided.`);
+  }
+  return value;
+}
+function parsePluginReferences(value) {
+  if (value === void 0) {
+    return [...TREESEED_DEFAULT_PLUGIN_REFERENCES];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid deploy config: expected plugins to be an array.");
+  }
+  return value.map((entry, index) => {
+    const record = optionalRecord(entry, `plugins[${index}]`);
+    return {
+      package: expectString(record?.package, `plugins[${index}].package`),
+      enabled: record?.enabled === void 0 ? true : optionalBoolean(record.enabled, `plugins[${index}].enabled`),
+      config: record?.config === void 0 ? {} : optionalRecord(record.config, `plugins[${index}].config`)
+    };
+  });
+}
+function parseProviderSelections(value) {
+  const record = optionalRecord(value, "providers");
+  if (!record) {
+    return structuredClone(TREESEED_DEFAULT_PROVIDER_SELECTIONS);
+  }
+  const agentProviders = optionalRecord(record.agents, "providers.agents") ?? {};
+  const contentProviders = optionalRecord(record.content, "providers.content") ?? {};
+  return {
+    forms: expectString(record.forms ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.forms, "providers.forms"),
+    operations: expectString(record.operations ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.operations, "providers.operations"),
+    agents: {
+      execution: expectString(
+        agentProviders.execution ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.execution,
+        "providers.agents.execution"
+      ),
+      mutation: expectString(
+        agentProviders.mutation ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.mutation,
+        "providers.agents.mutation"
+      ),
+      repository: expectString(
+        agentProviders.repository ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.repository,
+        "providers.agents.repository"
+      ),
+      verification: expectString(
+        agentProviders.verification ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.verification,
+        "providers.agents.verification"
+      ),
+      notification: expectString(
+        agentProviders.notification ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.notification,
+        "providers.agents.notification"
+      ),
+      research: expectString(
+        agentProviders.research ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents.research,
+        "providers.agents.research"
+      )
+    },
+    deploy: expectString(record.deploy ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.deploy, "providers.deploy"),
+    content: {
+      docs: expectString(
+        contentProviders.docs ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.content.docs,
+        "providers.content.docs"
+      )
+    },
+    site: expectString(record.site ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.site, "providers.site")
+  };
+}
+function parseServiceEnvironmentConfig(value, label) {
+  const record = optionalRecord(value, label) ?? {};
+  return {
+    baseUrl: optionalString(record.baseUrl),
+    domain: optionalString(record.domain),
+    railwayEnvironment: optionalString(record.railwayEnvironment)
+  };
+}
+function parseManagedServiceConfig(value, label) {
+  const record = optionalRecord(value, label);
+  if (!record) {
+    return void 0;
+  }
+  const railway = optionalRecord(record.railway, `${label}.railway`) ?? {};
+  const environments = optionalRecord(record.environments, `${label}.environments`) ?? {};
+  return {
+    enabled: record.enabled === void 0 ? void 0 : optionalBoolean(record.enabled, `${label}.enabled`),
+    provider: optionalString(record.provider),
+    rootDir: optionalString(record.rootDir),
+    publicBaseUrl: optionalString(record.publicBaseUrl),
+    railway: {
+      projectId: optionalString(railway.projectId),
+      projectName: optionalString(railway.projectName),
+      serviceId: optionalString(railway.serviceId),
+      serviceName: optionalString(railway.serviceName),
+      rootDir: optionalString(railway.rootDir),
+      buildCommand: optionalString(railway.buildCommand),
+      startCommand: optionalString(railway.startCommand)
+    },
+    environments: {
+      local: parseServiceEnvironmentConfig(environments.local, `${label}.environments.local`),
+      staging: parseServiceEnvironmentConfig(environments.staging, `${label}.environments.staging`),
+      prod: parseServiceEnvironmentConfig(environments.prod, `${label}.environments.prod`)
+    }
+  };
+}
+function parseManagedServicesConfig(value) {
+  const record = optionalRecord(value, "services");
+  if (!record) {
+    return void 0;
+  }
+  return {
+    api: parseManagedServiceConfig(record.api, "services.api"),
+    agents: parseManagedServiceConfig(record.agents, "services.agents")
+  };
+}
+function parseDeployConfig(raw) {
+  const parsed = normalizeAliasedRecord(
+    deployConfigFieldAliases,
+    parseYaml(raw) ?? {}
+  );
+  const cloudflare = normalizeAliasedRecord(
+    cloudflareFieldAliases,
+    optionalRecord(parsed.cloudflare, "cloudflare") ?? {}
+  );
+  const smtp = optionalRecord(parsed.smtp, "smtp") ?? {};
+  const turnstile = optionalRecord(parsed.turnstile, "turnstile") ?? {};
+  optionalBoolean(turnstile.enabled, "turnstile.enabled");
+  return {
+    name: expectString(parsed.name, "name"),
+    slug: expectString(parsed.slug, "slug"),
+    siteUrl: expectString(parsed.siteUrl, "siteUrl"),
+    contactEmail: expectString(parsed.contactEmail, "contactEmail"),
+    cloudflare: {
+      accountId: optionalCloudflareAccountId(cloudflare.accountId) ?? optionalCloudflareAccountId(process.env.CLOUDFLARE_ACCOUNT_ID) ?? CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER,
+      workerName: optionalString(cloudflare.workerName)
+    },
+    plugins: parsePluginReferences(parsed.plugins),
+    providers: parseProviderSelections(parsed.providers),
+    services: parseManagedServicesConfig(parsed.services),
+    smtp: {
+      enabled: optionalBoolean(smtp.enabled, "smtp.enabled")
+    },
+    turnstile: {
+      enabled: true
+    }
+  };
+}
+function resolveTreeseedDeployConfigPath(configPath = "treeseed.site.yaml") {
+  const tenantRoot = resolveTreeseedTenantRoot();
+  const candidate = resolve(tenantRoot, configPath);
+  if (!existsSync(candidate)) {
+    throw new Error(`Unable to resolve Treeseed deploy config at "${candidate}".`);
+  }
+  return candidate;
+}
+function deriveCloudflareWorkerName(config) {
+  return config.cloudflare.workerName?.trim() || config.slug;
+}
+function loadTreeseedDeployConfig(configPath = "treeseed.site.yaml") {
+  const resolvedConfigPath = resolveTreeseedDeployConfigPath(configPath);
+  const tenantRoot = dirname(resolvedConfigPath);
+  const parsed = parseDeployConfig(readFileSync(resolvedConfigPath, "utf8"));
+  Object.defineProperty(parsed, "__tenantRoot", {
+    value: tenantRoot,
+    enumerable: false
+  });
+  Object.defineProperty(parsed, "__configPath", {
+    value: resolvedConfigPath,
+    enumerable: false
+  });
+  return parsed;
+}
+export {
+  deriveCloudflareWorkerName,
+  loadTreeseedDeployConfig,
+  resolveTreeseedDeployConfigPath
+};

package/dist/platform/deploy-runtime.js

@@ -1,4 +1,4 @@
-import { loadTreeseedDeployConfig } from "./deploy/config.js";
+import { loadTreeseedDeployConfig } from "./deploy-config.js";
 import { TREESEED_DEFAULT_PLUGIN_REFERENCES, TREESEED_DEFAULT_PROVIDER_SELECTIONS } from "./plugins/constants.js";
 let cachedDeployConfig = null;
 function defaultDeployConfig() {

package/dist/platform/environment.d.ts

@@ -1,5 +1,5 @@
 import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
-import { type LoadedTreeseedPluginEntry } from './plugins/runtime.ts';
+import { type LoadedTreeseedPluginEntry } from './plugins.ts';
 export declare const TREESEED_ENVIRONMENT_SCOPES: readonly ["local", "staging", "prod"];
 export declare const TREESEED_ENVIRONMENT_REQUIREMENTS: readonly ["required", "conditional", "optional"];
 export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-file", "wrangler-dev-vars", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "railway-secret", "config-file"];

package/dist/platform/environment.js

@@ -3,9 +3,9 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseYaml } from "yaml";
-import { loadTreeseedDeployConfig } from "./deploy/config.js";
-import { loadTreeseedPlugins } from "./plugins/runtime.js";
-import { loadTreeseedManifest } from "./tenant/config.js";
+import { loadTreeseedDeployConfig } from "./deploy-config.js";
+import { loadTreeseedPlugins } from "./plugins.js";
+import { loadTreeseedManifest } from "./tenant-config.js";
 const TREESEED_ENVIRONMENT_SCOPES = ["local", "staging", "prod"];
 const TREESEED_ENVIRONMENT_REQUIREMENTS = ["required", "conditional", "optional"];
 const TREESEED_ENVIRONMENT_TARGETS = [

package/dist/platform/plugin.d.ts

@@ -1,2 +1,51 @@
-export { defineTreeseedPlugin } from './plugins/plugin.ts';
-export type * from './plugins/plugin.ts';
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
+import type { TreeseedEnvironmentRegistryOverlay } from './environment.ts';
+import type { SdkGraphRankingProvider } from '../sdk-types.ts';
+export type TreeseedSiteLayerDefinition = {
+    root: string;
+    kinds?: Array<'pages' | 'styles' | 'components'>;
+};
+export type TreeseedSiteRouteContribution = {
+    pattern: string;
+    entrypoint?: string;
+    resourcePath?: string;
+};
+export type TreeseedSiteExtensionContribution = {
+    routes?: TreeseedSiteRouteContribution[];
+    starlightComponents?: Record<string, string>;
+    customCss?: string[];
+    remarkPlugins?: unknown[];
+    rehypePlugins?: unknown[];
+    envSchema?: Record<string, unknown>;
+    vitePlugins?: unknown[];
+    integrations?: unknown[];
+    routeMiddleware?: unknown[];
+};
+export type TreeseedPluginSiteContext = {
+    projectRoot: string;
+    tenantConfig: TreeseedTenantConfig;
+    siteConfig?: unknown;
+    deployConfig?: TreeseedDeployConfig;
+    pluginConfig: Record<string, unknown>;
+};
+export type TreeseedPluginEnvironmentContext = {
+    projectRoot: string;
+    tenantConfig?: TreeseedTenantConfig;
+    deployConfig?: TreeseedDeployConfig;
+    pluginConfig: Record<string, unknown>;
+};
+export type TreeseedGraphRankingProviderContribution = SdkGraphRankingProvider | ((context: TreeseedPluginEnvironmentContext) => SdkGraphRankingProvider | undefined);
+export interface TreeseedPlugin {
+    id?: string;
+    provides?: Record<string, any> & {
+        operations?: string[];
+    };
+    operationProviders?: Record<string, unknown>;
+    siteProviders?: Record<string, TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution)>;
+    siteHooks?: TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution);
+    siteLayers?: TreeseedSiteLayerDefinition[] | ((context: TreeseedPluginSiteContext) => TreeseedSiteLayerDefinition[] | undefined);
+    environmentRegistry?: TreeseedEnvironmentRegistryOverlay | ((context: TreeseedPluginEnvironmentContext) => TreeseedEnvironmentRegistryOverlay | undefined);
+    graphRankingProviders?: Record<string, TreeseedGraphRankingProviderContribution>;
+    [key: string]: unknown;
+}
+export declare function defineTreeseedPlugin<T extends TreeseedPlugin>(plugin: T): T;

package/dist/platform/plugin.js

@@ -1,4 +1,6 @@
-import { defineTreeseedPlugin } from "./plugins/plugin.js";
+function defineTreeseedPlugin(plugin) {
+  return plugin;
+}
 export {
   defineTreeseedPlugin
 };

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

@@ -1,4 +1,4 @@
-export declare const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/core/plugin-default";
+export declare const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/sdk/plugin-default";
 export declare const TREESEED_DEFAULT_PROVIDER_SELECTIONS: {
     forms: string;
     operations: string;

package/dist/platform/plugins/constants.js

@@ -1,4 +1,4 @@
-const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/core/plugin-default";
+const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/sdk/plugin-default";
 const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   forms: "store_only",
   operations: "default",

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

@@ -1,5 +1,5 @@
 import type { TreeseedDeployConfig } from '../contracts.ts';
-import type { TreeseedPluginEnvironmentContext } from './plugin.ts';
+import type { TreeseedPluginEnvironmentContext } from '../plugin.ts';
 import type { SdkGraphRankingProvider } from '../../sdk-types.ts';
 type LoadedPluginEntry = {
     package: string;

package/dist/platform/plugins/runtime.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadTreeseedDeployConfig } from "../deploy/config.js";
+import { loadTreeseedDeployConfig } from "../deploy-config.js";
 import { TREESEED_DEFAULT_PLUGIN_PACKAGE } from "./constants.js";
 const require2 = createRequire(import.meta.url);
 const runtimeDir = path.dirname(fileURLToPath(import.meta.url));
@@ -18,18 +18,18 @@ function isPathLikePluginReference(packageName) {
 }
 function resolveLocalDefaultPluginPath() {
   const candidates = [
-    path.resolve(runtimeDir, "../../../../core/dist/plugin-default.js"),
-    path.resolve(runtimeDir, "../../../../dist/plugin-default.js")
+    path.resolve(runtimeDir, "../../../dist/plugin-default.js"),
+    path.resolve(runtimeDir, "../../../../sdk/dist/plugin-default.js")
   ];
   let current = runtimeDir;
   while (true) {
+    candidates.push(path.resolve(current, "..", "sdk", "dist", "plugin-default.js"));
     const packageJsonPath = path.resolve(current, "package.json");
     if (existsSync(packageJsonPath)) {
       try {
         const packageJson = require2(packageJsonPath);
-        if (packageJson?.name === "@treeseed/core") {
+        if (packageJson?.name === "@treeseed/sdk") {
           candidates.push(path.resolve(current, "dist/plugin-default.js"));
-          break;
         }
       } catch {
       }

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, getTreeseedDeployConfig, getTreeseedDeployProvider, getTreeseedDocsProvider, getTreeseedFormsProvider, getTreeseedOperationsProvider, getTreeseedSiteProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled, resetTreeseedDeployConfigForTests, } from './deploy-runtime.ts';
-export { defineTreeseedPlugin } from './plugins/plugin.ts';
-export type * from './plugins/plugin.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';

package/dist/platform/plugins.js

@@ -15,7 +15,7 @@ import {
   isTreeseedTurnstileEnabled,
   resetTreeseedDeployConfigForTests
 } from "./deploy-runtime.js";
-import { defineTreeseedPlugin } from "./plugins/plugin.js";
+import { defineTreeseedPlugin } from "./plugin.js";
 import { loadTreeseedPluginRuntime, loadTreeseedPlugins, resolveTreeseedGraphRankingProvider } from "./plugins/runtime.js";
 export {
   TREESEED_DEFAULT_PLUGIN_PACKAGE,

package/dist/platform/tenant/runtime-config.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { loadTreeseedManifest } from "./config.js";
+import { loadTreeseedManifest } from "../tenant-config.js";
 import { parseSiteConfig } from "../utils/site-config-schema.js";
 const injectedTenantConfig = typeof __TREESEED_TENANT_CONFIG__ !== "undefined" ? __TREESEED_TENANT_CONFIG__ : null;
 const injectedProjectRoot = typeof __TREESEED_PROJECT_ROOT__ !== "undefined" ? __TREESEED_PROJECT_ROOT__ : null;

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

@@ -1 +1,7 @@
-export * from './tenant/config.ts';
+import type { TreeseedTenantConfig } from './contracts.ts';
+export declare function resolveTreeseedTenantRoot(): string;
+export declare function defineTreeseedTenant<T>(tenantConfig: T): T;
+export declare function loadTreeseedManifest(manifestPath?: string): TreeseedTenantConfig;
+export declare const loadTreeseedTenantManifest: typeof loadTreeseedManifest;
+export declare function getTenantContentRoot(tenantConfig: Pick<TreeseedTenantConfig, 'content'>, collectionName: string): string;
+export declare function tenantFeatureEnabled(tenantConfig: Pick<TreeseedTenantConfig, 'features'>, featureName: string): boolean;

package/dist/platform/tenant-config.js

@@ -1 +1,153 @@
-export * from "./tenant/config.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 { normalizeAliasedRecord } from "../field-aliases.js";
+function resolvePackageRoot() {
+  const moduleUrl = typeof import.meta?.url === "string" ? import.meta.url : null;
+  if (!moduleUrl) {
+    return process.cwd();
+  }
+  return resolve(dirname(fileURLToPath(moduleUrl)), "../..");
+}
+const packageRoot = resolvePackageRoot();
+const packageFixtureRoot = resolve(packageRoot, ".fixtures", "treeseed-fixtures", "sites", "working-site");
+const explicitTenantRoot = process.env.TREESEED_TENANT_ROOT ? resolve(process.env.TREESEED_TENANT_ROOT) : null;
+const manifestFieldAliases = {
+  siteConfigPath: { key: "siteConfigPath", aliases: ["site_config_path"] }
+};
+const manifestContentFieldAliases = {
+  pages: { key: "pages", aliases: ["page_root", "pages_root"] },
+  notes: { key: "notes", aliases: ["notes_root"] },
+  questions: { key: "questions", aliases: ["questions_root"] },
+  objectives: { key: "objectives", aliases: ["objectives_root"] },
+  people: { key: "people", aliases: ["people_root"] },
+  agents: { key: "agents", aliases: ["agents_root"] },
+  books: { key: "books", aliases: ["books_root"] },
+  docs: { key: "docs", aliases: ["knowledge", "knowledge_root", "docs_root"] }
+};
+const manifestOverrideFieldAliases = {
+  pagesRoot: { key: "pagesRoot", aliases: ["pages_root"] },
+  stylesRoot: { key: "stylesRoot", aliases: ["styles_root"] },
+  componentsRoot: { key: "componentsRoot", aliases: ["components_root"] }
+};
+function pathWithin(parent, candidate) {
+  const normalizedParent = resolve(parent);
+  const normalizedCandidate = resolve(candidate);
+  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
+}
+function collectTenantRootCandidates(start) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(
+      current,
+      resolve(current, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
+      resolve(current, "fixture")
+    );
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates;
+}
+function uniqueCandidates(entries) {
+  return [...new Set(entries.map((entry) => resolve(entry)))];
+}
+function tenantRootCandidates() {
+  const cwd = resolve(process.cwd());
+  const cwdCandidates = collectTenantRootCandidates(cwd);
+  const packageCandidates = collectTenantRootCandidates(packageRoot);
+  if (explicitTenantRoot) {
+    return uniqueCandidates([explicitTenantRoot, ...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+  }
+  if (pathWithin(packageRoot, cwd)) {
+    return uniqueCandidates([packageFixtureRoot, ...cwdCandidates, ...packageCandidates]);
+  }
+  return uniqueCandidates([...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+}
+function resolveTenantPath(manifestPath) {
+  if (existsSync(manifestPath)) {
+    return resolve(manifestPath);
+  }
+  const candidates = tenantRootCandidates().map((root) => resolve(root, manifestPath));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve Treeseed tenant manifest at "${manifestPath}" from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function resolveTreeseedTenantRoot() {
+  const candidates = tenantRootCandidates();
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, "src/manifest.yaml"))) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve a Treeseed tenant root from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function defineTreeseedTenant(tenantConfig) {
+  return tenantConfig;
+}
+function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
+  const resolvedManifestPath = resolveTenantPath(manifestPath);
+  const tenantRoot = resolve(dirname(resolvedManifestPath), "..");
+  const parsed = normalizeAliasedRecord(
+    manifestFieldAliases,
+    parseYaml(readFileSync(resolvedManifestPath, "utf8"))
+  );
+  const content = normalizeAliasedRecord(
+    manifestContentFieldAliases,
+    parsed.content ?? {}
+  );
+  const overrides = parsed.overrides ? normalizeAliasedRecord(
+    manifestOverrideFieldAliases,
+    parsed.overrides
+  ) : void 0;
+  const tenantConfig = defineTreeseedTenant({
+    ...parsed,
+    siteConfigPath: resolve(tenantRoot, parsed.siteConfigPath),
+    content: Object.fromEntries(
+      Object.entries(content ?? {}).map(([collectionName, rootPath]) => [
+        collectionName,
+        resolve(tenantRoot, String(rootPath))
+      ])
+    ),
+    overrides: overrides ? {
+      pagesRoot: overrides.pagesRoot ? resolve(tenantRoot, overrides.pagesRoot) : void 0,
+      stylesRoot: overrides.stylesRoot ? resolve(tenantRoot, overrides.stylesRoot) : void 0,
+      componentsRoot: overrides.componentsRoot ? resolve(tenantRoot, overrides.componentsRoot) : void 0
+    } : void 0
+  });
+  Object.defineProperty(tenantConfig, "__tenantRoot", {
+    value: tenantRoot,
+    enumerable: false
+  });
+  return tenantConfig;
+}
+const loadTreeseedTenantManifest = loadTreeseedManifest;
+function getTenantContentRoot(tenantConfig, collectionName) {
+  const root = tenantConfig.content[collectionName];
+  if (!root) {
+    throw new Error(`Unknown tenant content collection: ${collectionName}`);
+  }
+  return root;
+}
+function tenantFeatureEnabled(tenantConfig, featureName) {
+  return tenantConfig.features?.[featureName] !== false;
+}
+export {
+  defineTreeseedTenant,
+  getTenantContentRoot,
+  loadTreeseedManifest,
+  loadTreeseedTenantManifest,
+  resolveTreeseedTenantRoot,
+  tenantFeatureEnabled
+};