@treeseed/core 0.1.2

package/dist/components/site/TrustCallout.astro

@@ -0,0 +1,9 @@
+---
+const { title, body } = Astro.props;
+---
+
+<aside class="border-l-4 border-[color:var(--site-warm)] bg-[color:rgba(215,176,123,0.12)] px-5 py-5 text-[color:var(--site-text)]">
+	<p class="text-sm font-semibold uppercase tracking-[0.14em] text-[color:var(--site-warm-strong)]">Trust note</p>
+	<h3 class="mt-2 text-2xl font-bold">{title}</h3>
+	<p class="mt-3 text-base leading-8 text-[color:var(--site-text-muted)]">{body}</p>
+</aside>

package/dist/components/starlight.js

@@ -0,0 +1,6 @@
+import { Card, CardGrid, LinkCard } from "../vendor/starlight/components.js";
+export {
+  Card,
+  CardGrid,
+  LinkCard
+};

package/dist/config.js

@@ -0,0 +1,8 @@
+import starlight from './vendor/starlight/index.js';
+import { createTreeseedSite } from './site.js';
+import { loadTreeseedManifest } from './tenant/config.js';
+
+export function createTreeseedTenantSite(manifestPath) {
+	const tenant = loadTreeseedManifest(manifestPath);
+	return createTreeseedSite(tenant, { starlight });
+}

package/dist/content-config.js

@@ -0,0 +1,9 @@
+import { docsLoader } from './vendor/starlight/loaders.js';
+import { docsSchema } from './vendor/starlight/schema.js';
+import { createTreeseedCollections } from './content.js';
+import { loadTreeseedManifest } from './tenant/config.js';
+
+export function createTreeseedTenantCollections(manifestPath) {
+	const tenant = loadTreeseedManifest(manifestPath);
+	return createTreeseedCollections(tenant, { docsLoader, docsSchema });
+}

package/dist/content.js

@@ -0,0 +1,230 @@
+import { defineCollection, reference } from "astro:content";
+import { z } from "astro/zod";
+import { glob } from "astro/loaders";
+import { AGENT_CLI_ALLOW_TOOLS } from "./types/agents.js";
+import { loadTreeseedPluginRuntime } from "./plugins/runtime.js";
+import { loadTreeseedDeployConfig } from "./deploy/config.js";
+import {
+  AGENT_MODEL_DEFAULTS,
+  BOOK_MODEL_DEFAULTS,
+  TREESEED_MODEL_DEFAULTS,
+  NOTE_MODEL_DEFAULTS,
+  OBJECTIVE_MODEL_DEFAULTS,
+  PAGE_MODEL_DEFAULTS,
+  PEOPLE_MODEL_DEFAULTS,
+  QUESTION_MODEL_DEFAULTS
+} from "./utils/site-config.js";
+const statusValues = ["live", "in progress", "exploratory", "planned", "speculative"];
+const pageLayoutValues = ["article", "bridge"];
+const questionTypeValues = ["research", "implementation", "strategy", "evaluation"];
+const timeHorizonValues = ["near-term", "mid-term", "long-term"];
+const runtimeStatusValues = ["active", "experimental", "dormant"];
+const agentTriggerTypeValues = ["schedule", "message", "follow", "startup"];
+const agentPermissionOperationValues = ["get", "search", "follow", "pick", "create", "update"];
+function withOptionalDefault(schema, defaultValue) {
+  return defaultValue === void 0 ? schema : schema.default(defaultValue);
+}
+function createKnowledgeDocId({ entry, data }) {
+  const rawSlug = typeof data.slug === "string" ? data.slug : entry;
+  const normalized = rawSlug.replace(/\\/g, "/").replace(/\.(md|mdx)$/i, "").replace(/\/index$/i, "").replace(/^\/+|\/+$/g, "");
+  if (normalized === "knowledge" || normalized.startsWith("knowledge/")) {
+    return normalized;
+  }
+  return normalized ? `knowledge/${normalized}` : "knowledge";
+}
+function resolveDocsCollectionProvider(tenantConfig, dependencies) {
+  const pluginRuntime = loadTreeseedPluginRuntime(loadTreeseedDeployConfig());
+  const selectedId = pluginRuntime.config.providers.content.docs;
+  if (selectedId === "default") {
+    return {
+      loader: dependencies.docsLoader({ generateId: createKnowledgeDocId }),
+      schema: dependencies.docsSchema({
+        extend: z.object({
+          tags: z.array(z.string()).default(TREESEED_MODEL_DEFAULTS.tags ?? [])
+        })
+      })
+    };
+  }
+  for (const { plugin, config, package: packageName } of pluginRuntime.plugins) {
+    const docsProviders = plugin.contentProviders?.docs ?? {};
+    if (!(selectedId in docsProviders)) {
+      continue;
+    }
+    const resolved = docsProviders[selectedId]({
+      tenantConfig,
+      dependencies,
+      pluginConfig: config ?? {}
+    });
+    if (!resolved?.loader || !resolved?.schema) {
+      throw new Error(`Treeseed docs provider "${selectedId}" from "${packageName}" must return loader and schema.`);
+    }
+    return resolved;
+  }
+  throw new Error(`Treeseed docs provider "${selectedId}" is not registered.`);
+}
+function createTreeseedCollections(tenantConfig, { docsLoader, docsSchema }) {
+  const contributorReference = z.union([reference("people"), reference("agents")]);
+  const sidebarItemSchema = z.lazy(
+    () => z.object({
+      label: z.string(),
+      link: z.string().optional(),
+      autogenerate: z.object({ directory: z.string() }).optional(),
+      items: z.array(sidebarItemSchema).optional()
+    })
+  );
+  const pageSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    slug: z.string(),
+    pageLayout: withOptionalDefault(z.enum(pageLayoutValues), PAGE_MODEL_DEFAULTS.pageLayout),
+    status: withOptionalDefault(z.enum(statusValues), PAGE_MODEL_DEFAULTS.status),
+    stage: withOptionalDefault(z.string(), PAGE_MODEL_DEFAULTS.stage),
+    audience: z.array(z.string()).default(PAGE_MODEL_DEFAULTS.audience ?? []),
+    summary: z.string(),
+    updated: z.coerce.date(),
+    seoTitle: z.string().optional(),
+    seoDescription: z.string().optional()
+  });
+  const noteSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    date: z.coerce.date(),
+    status: withOptionalDefault(z.enum(statusValues), NOTE_MODEL_DEFAULTS.status),
+    tags: z.array(z.string()).default(NOTE_MODEL_DEFAULTS.tags ?? []),
+    author: withOptionalDefault(z.string(), NOTE_MODEL_DEFAULTS.author),
+    summary: z.string(),
+    draft: z.boolean().default(NOTE_MODEL_DEFAULTS.draft ?? false),
+    canonicalRoute: z.string().optional()
+  });
+  const questionSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    date: z.coerce.date(),
+    status: withOptionalDefault(z.enum(statusValues), QUESTION_MODEL_DEFAULTS.status),
+    tags: z.array(z.string()).default(QUESTION_MODEL_DEFAULTS.tags ?? []),
+    summary: z.string(),
+    draft: z.boolean().default(QUESTION_MODEL_DEFAULTS.draft ?? false),
+    questionType: z.enum(questionTypeValues),
+    motivation: z.string(),
+    primaryContributor: contributorReference,
+    relatedObjectives: z.array(reference("objectives")).default([]),
+    relatedBooks: z.array(reference("books")).default([])
+  });
+  const objectiveSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    date: z.coerce.date(),
+    status: withOptionalDefault(z.enum(statusValues), OBJECTIVE_MODEL_DEFAULTS.status),
+    tags: z.array(z.string()).default(OBJECTIVE_MODEL_DEFAULTS.tags ?? []),
+    summary: z.string(),
+    draft: z.boolean().default(OBJECTIVE_MODEL_DEFAULTS.draft ?? false),
+    timeHorizon: z.enum(timeHorizonValues),
+    motivation: z.string(),
+    primaryContributor: contributorReference,
+    relatedQuestions: z.array(reference("questions")).default([]),
+    relatedBooks: z.array(reference("books")).default([])
+  });
+  const profileLinkSchema = z.object({ label: z.string(), href: z.string() });
+  const agentCliSchema = z.object({
+    model: z.string().optional(),
+    allowTools: z.array(z.enum(AGENT_CLI_ALLOW_TOOLS)).default([]),
+    additionalArgs: z.array(z.string()).default([])
+  });
+  const agentTriggerSchema = z.object({
+    type: z.enum(agentTriggerTypeValues),
+    cron: z.string().optional(),
+    messageTypes: z.array(z.string()).default([]),
+    models: z.array(z.string()).default([]),
+    sinceField: z.string().optional(),
+    runOnStart: z.boolean().default(false)
+  });
+  const agentPermissionSchema = z.object({
+    model: z.string(),
+    operations: z.array(z.enum(agentPermissionOperationValues)).min(1)
+  });
+  const agentExecutionSchema = z.object({
+    maxConcurrency: z.number().int().positive().default(1),
+    timeoutSeconds: z.number().int().positive().default(900),
+    cooldownSeconds: z.number().int().nonnegative().default(30),
+    leaseSeconds: z.number().int().positive().default(300),
+    retryLimit: z.number().int().nonnegative().default(3),
+    branchPrefix: z.string().default("agent")
+  });
+  const agentTriggerPolicySchema = z.object({
+    maxRunsPerCycle: z.number().int().positive().optional(),
+    messageBatchSize: z.number().int().positive().optional()
+  });
+  const agentOutputSchema = z.object({
+    messageTypes: z.array(z.string()).default([]),
+    modelMutations: z.array(z.string()).default([])
+  });
+  const peopleSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    summary: z.string(),
+    role: z.string(),
+    affiliation: z.string(),
+    status: withOptionalDefault(z.enum(statusValues), PEOPLE_MODEL_DEFAULTS.status),
+    tags: z.array(z.string()).default(PEOPLE_MODEL_DEFAULTS.tags ?? []),
+    links: z.array(profileLinkSchema).default([]),
+    relatedQuestions: z.array(reference("questions")).default([]),
+    relatedObjectives: z.array(reference("objectives")).default([])
+  });
+  const agentSchema = z.object({
+    name: z.string(),
+    slug: z.string(),
+    handler: z.string(),
+    enabled: z.boolean().default(true),
+    description: z.string(),
+    summary: z.string(),
+    operator: z.string(),
+    runtimeStatus: withOptionalDefault(z.enum(runtimeStatusValues), AGENT_MODEL_DEFAULTS.runtimeStatus),
+    capabilities: z.array(z.string()).default([]),
+    tags: z.array(z.string()).default(AGENT_MODEL_DEFAULTS.tags ?? []),
+    links: z.array(profileLinkSchema).default([]),
+    relatedQuestions: z.array(reference("questions")).default([]),
+    relatedObjectives: z.array(reference("objectives")).default([]),
+    systemPrompt: z.string(),
+    persona: z.string(),
+    cli: agentCliSchema.default({ allowTools: [], additionalArgs: [] }),
+    triggers: z.array(agentTriggerSchema).min(1),
+    triggerPolicy: agentTriggerPolicySchema.optional(),
+    permissions: z.array(agentPermissionSchema).min(1),
+    execution: agentExecutionSchema.default({}),
+    outputs: agentOutputSchema.default({})
+  });
+  const bookSchema = z.object({
+    order: z.number().int().nonnegative(),
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    summary: z.string(),
+    sectionLabel: z.string(),
+    basePath: z.string(),
+    landingPath: z.string(),
+    outlinePath: z.string().optional(),
+    downloadFileName: z.string(),
+    downloadHref: z.string(),
+    downloadTitle: z.string(),
+    exportRoots: z.array(z.string()).min(1).optional(),
+    sidebarItems: z.array(sidebarItemSchema).min(1),
+    tags: z.array(z.string()).default(BOOK_MODEL_DEFAULTS.tags ?? [])
+  });
+  const docsCollectionProvider = resolveDocsCollectionProvider(tenantConfig, { docsLoader, docsSchema });
+  return {
+    pages: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.pages }), schema: pageSchema }),
+    notes: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.notes }), schema: noteSchema }),
+    questions: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.questions }), schema: questionSchema }),
+    objectives: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.objectives }), schema: objectiveSchema }),
+    people: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.people }), schema: peopleSchema }),
+    agents: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.agents }), schema: agentSchema }),
+    books: defineCollection({ loader: glob({ pattern: "**/*.{md,mdx}", base: tenantConfig.content.books }), schema: bookSchema }),
+    docs: defineCollection({
+      loader: docsCollectionProvider.loader,
+      schema: docsCollectionProvider.schema
+    })
+  };
+}
+export {
+  createTreeseedCollections
+};

package/dist/contracts.d.ts

@@ -0,0 +1,130 @@
+export type TreeseedFeatureName = 'docs' | 'books' | 'notes' | 'questions' | 'objectives' | 'agents' | 'forms';
+export type TreeseedContentCollection = 'pages' | 'notes' | 'questions' | 'objectives' | 'people' | 'agents' | 'books' | 'docs';
+export interface TreeseedFeatureModules {
+    docs?: boolean;
+    books?: boolean;
+    notes?: boolean;
+    questions?: boolean;
+    objectives?: boolean;
+    agents?: boolean;
+    forms?: boolean;
+    [key: string]: boolean | undefined;
+}
+export interface TreeseedContentMap {
+    pages: string;
+    notes: string;
+    questions: string;
+    objectives: string;
+    people: string;
+    agents: string;
+    books: string;
+    docs: string;
+}
+export interface TreeseedBookDefinition {
+    order: number;
+    slug: string;
+    title: string;
+    description: string;
+    summary: string;
+    sectionLabel: string;
+    basePath: string;
+    landingPath: string;
+    outlinePath?: string;
+    downloadFileName: string;
+    downloadHref: string;
+    downloadTitle: string;
+    exportRoots?: string[];
+    sidebarItems: Array<{
+        label: string;
+        link?: string;
+        autogenerate?: {
+            directory: string;
+        };
+        items?: TreeseedBookDefinition['sidebarItems'];
+    }>;
+    tags?: string[];
+    id?: string;
+}
+export interface TreeseedThemeConfig {
+    surfaces?: {
+        background?: string;
+        backgroundElevated?: string;
+        backgroundSoft?: string;
+        panel?: string;
+        panelStrong?: string;
+    };
+    text?: {
+        body?: string;
+        muted?: string;
+        soft?: string;
+    };
+    border?: {
+        base?: string;
+        strong?: string;
+        grid?: string;
+    };
+    accent?: {
+        base?: string;
+        strong?: string;
+        soft?: string;
+    };
+    info?: {
+        base?: string;
+        strong?: string;
+        soft?: string;
+    };
+    warm?: {
+        base?: string;
+        strong?: string;
+    };
+}
+export interface TreeseedPluginReference {
+    package: string;
+    enabled?: boolean;
+    config?: Record<string, unknown>;
+}
+export interface TreeseedProviderSelections {
+    forms: string;
+    agents: {
+        execution: string;
+        mutation: string;
+        repository: string;
+        verification: string;
+        notification: string;
+        research: string;
+    };
+    deploy: string;
+    content?: {
+        docs: string;
+    };
+    site?: string;
+}
+export interface TreeseedDeployConfig {
+    name: string;
+    slug: string;
+    siteUrl: string;
+    contactEmail: string;
+    cloudflare: {
+        accountId: string;
+        workerName?: string;
+    };
+    plugins: TreeseedPluginReference[];
+    providers: TreeseedProviderSelections;
+    smtp?: {
+        enabled?: boolean;
+    };
+    turnstile?: {
+        enabled?: boolean;
+    };
+}
+export interface TreeseedTenantConfig {
+    id: string;
+    siteConfigPath: string;
+    content: TreeseedContentMap;
+    features: TreeseedFeatureModules;
+    overrides?: {
+        pagesRoot?: string;
+        stylesRoot?: string;
+        componentsRoot?: string;
+    };
+}

package/dist/deploy/config.d.ts

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

package/dist/deploy/config.js

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { resolveTreeseedTenantRoot } from "../tenant/config.js";
+import {
+  TREESEED_DEFAULT_PLUGIN_REFERENCES,
+  TREESEED_DEFAULT_PROVIDER_SELECTIONS
+} from "../plugins/constants.js";
+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 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"),
+    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 parseDeployConfig(raw) {
+  const parsed = parseYaml(raw) ?? {};
+  const cloudflare = 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: optionalString(cloudflare.accountId) ?? optionalString(process.env.CLOUDFLARE_ACCOUNT_ID) ?? "replace-with-cloudflare-account-id",
+      workerName: optionalString(cloudflare.workerName)
+    },
+    plugins: parsePluginReferences(parsed.plugins),
+    providers: parseProviderSelections(parsed.providers),
+    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/deploy/runtime.js

@@ -0,0 +1,77 @@
+import { loadTreeseedDeployConfig } from "./config.js";
+import {
+  TREESEED_DEFAULT_PLUGIN_REFERENCES,
+  TREESEED_DEFAULT_PROVIDER_SELECTIONS
+} from "../plugins/constants.js";
+let cachedDeployConfig = null;
+function defaultDeployConfig() {
+  return {
+    name: "Treeseed Site",
+    slug: "treeseed-site",
+    siteUrl: "https://example.com",
+    contactEmail: "contact@example.com",
+    cloudflare: {
+      accountId: "",
+      workerName: "treeseed-site"
+    },
+    plugins: [...TREESEED_DEFAULT_PLUGIN_REFERENCES],
+    providers: structuredClone(TREESEED_DEFAULT_PROVIDER_SELECTIONS),
+    smtp: {
+      enabled: false
+    },
+    turnstile: {
+      enabled: true
+    }
+  };
+}
+function getTreeseedDeployConfig() {
+  if (cachedDeployConfig) {
+    return cachedDeployConfig;
+  }
+  if (typeof __TREESEED_DEPLOY_CONFIG__ !== "undefined" && __TREESEED_DEPLOY_CONFIG__) {
+    cachedDeployConfig = __TREESEED_DEPLOY_CONFIG__;
+    return cachedDeployConfig;
+  }
+  try {
+    cachedDeployConfig = loadTreeseedDeployConfig();
+    return cachedDeployConfig;
+  } catch {
+    cachedDeployConfig = defaultDeployConfig();
+    return cachedDeployConfig;
+  }
+}
+function resetTreeseedDeployConfigForTests() {
+  cachedDeployConfig = null;
+}
+function getTreeseedFormsProvider() {
+  return getTreeseedDeployConfig().providers?.forms ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.forms;
+}
+function getTreeseedAgentProviderSelections() {
+  return getTreeseedDeployConfig().providers?.agents ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.agents;
+}
+function getTreeseedDeployProvider() {
+  return getTreeseedDeployConfig().providers?.deploy ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.deploy;
+}
+function getTreeseedDocsProvider() {
+  return getTreeseedDeployConfig().providers?.content?.docs ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.content.docs;
+}
+function getTreeseedSiteProvider() {
+  return getTreeseedDeployConfig().providers?.site ?? TREESEED_DEFAULT_PROVIDER_SELECTIONS.site;
+}
+function isTreeseedSmtpEnabled() {
+  return getTreeseedDeployConfig().smtp?.enabled ?? false;
+}
+function isTreeseedTurnstileEnabled() {
+  return getTreeseedDeployConfig().turnstile?.enabled ?? true;
+}
+export {
+  getTreeseedAgentProviderSelections,
+  getTreeseedDeployConfig,
+  getTreeseedDeployProvider,
+  getTreeseedDocsProvider,
+  getTreeseedFormsProvider,
+  getTreeseedSiteProvider,
+  isTreeseedSmtpEnabled,
+  isTreeseedTurnstileEnabled,
+  resetTreeseedDeployConfigForTests
+};