@treeseed/core 0.4.9 → 0.4.11

package/dist/services/workday-start.d.ts

@@ -1,2 +1,175 @@
 #!/usr/bin/env node
-export declare function runWorkdayStart(): Promise<any>;
+export declare function runWorkdayStart(): Promise<{
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "prod" | "staging";
+    insideWorkWindow: boolean;
+    workPolicy: import("@treeseed/sdk").WorkdayPolicy;
+    workDay: Record<string, unknown>;
+    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+    seededTasks: {
+        [x: string]: unknown;
+    }[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+    workdaySummary: Record<string, unknown>;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: Record<string, unknown>;
+    skipped?: undefined;
+    reason?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    summary?: undefined;
+    scale?: undefined;
+} | {
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
+    summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        workDayId: string;
+        state: string;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string;
+        priorityItemCount: number;
+        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string;
+            type: string;
+            state: string;
+            priority: number;
+            idempotencyKey: string;
+            createdAt: string;
+            startedAt: string;
+            completedAt: string;
+            lastErrorCode: string;
+            lastErrorMessage: string;
+            lastEventKind: string;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string;
+            commitSha: string;
+            sourceRef: string;
+            startedAt: string;
+            finishedAt: string;
+            createdAt: string;
+        }[];
+        scaleDecision: import("@treeseed/sdk").ScaleDecision;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        generatedAt: string;
+    };
+    scale: import("@treeseed/sdk").WorkerPoolScaleResult;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    workDayId?: undefined;
+    summary?: undefined;
+} | {
+    ok: boolean;
+    workDayId: unknown;
+    summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        projectId: string;
+        environment: "local" | "prod" | "staging";
+        workDayId: string;
+        state: string;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string;
+        priorityItemCount: number;
+        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string;
+            type: string;
+            state: string;
+            priority: number;
+            idempotencyKey: string;
+            createdAt: string;
+            startedAt: string;
+            completedAt: string;
+            lastErrorCode: string;
+            lastErrorMessage: string;
+            lastEventKind: string;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string;
+            commitSha: string;
+            sourceRef: string;
+            startedAt: string;
+            finishedAt: string;
+            createdAt: string;
+        }[];
+        scaleDecision: import("@treeseed/sdk").ScaleDecision;
+        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
+        generatedAt: string;
+    };
+    skipped?: undefined;
+    reason?: undefined;
+}>;

package/dist/services/workday-start.js

@@ -1,20 +1,10 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { resolveWorkerConfig } from "./common.js";
+import { runManagerAction } from "./manager.js";
 async function runWorkdayStart() {
-  const managerBaseUrl = resolveWorkerConfig().managerBaseUrl;
-  const response = await fetch(`${managerBaseUrl}/internal/workdays/start`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({})
+  return runManagerAction({
+    mode: "open-workday"
   });
-  if (!response.ok) {
-    throw new Error(`Workday start failed with ${response.status}.`);
-  }
-  return response.json();
 }
 const currentFile = fileURLToPath(import.meta.url);
 const entryFile = process.argv[1] ?? "";

package/dist/services/worker-pool-scaler.d.ts

@@ -0,0 +1,27 @@
+import type { ScaleDecision, WorkerPoolScaleResult, WorkerPoolScaler } from '@treeseed/sdk';
+export type WorkerPoolScalerKind = 'noop' | 'railway';
+export interface RailwayWorkerPoolScalerOptions {
+    apiToken?: string | null;
+    apiUrl?: string | null;
+    serviceId?: string | null;
+    environmentId?: string | null;
+    projectId?: string | null;
+    fetchImpl?: typeof fetch;
+    mutation?: string | null;
+}
+export declare class NoopWorkerPoolScaler implements WorkerPoolScaler {
+    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
+}
+export declare class RailwayWorkerPoolScaler implements WorkerPoolScaler {
+    private readonly apiToken;
+    private readonly apiUrl;
+    private readonly serviceId;
+    private readonly environmentId;
+    private readonly projectId;
+    private readonly fetchImpl;
+    private readonly mutation;
+    constructor(options?: RailwayWorkerPoolScalerOptions);
+    private configured;
+    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
+}
+export declare function createWorkerPoolScaler(kind?: WorkerPoolScalerKind | null, options?: RailwayWorkerPoolScalerOptions): WorkerPoolScaler;

package/dist/services/worker-pool-scaler.js

@@ -0,0 +1,109 @@
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+const DEFAULT_RAILWAY_API_URL = "https://backboard.railway.com/graphql/v2";
+const DEFAULT_SCALE_MUTATION = `
+mutation TreeseedScaleService($serviceId: String!, $environmentId: String!, $replicas: Int!) {
+	serviceInstanceUpdate(
+		serviceId: $serviceId
+		environmentId: $environmentId
+		input: { numReplicas: $replicas }
+	) {
+		id
+	}
+}
+`.trim();
+class NoopWorkerPoolScaler {
+  async scale(decision) {
+    return {
+      applied: false,
+      provider: "noop",
+      desiredWorkers: decision.desiredWorkers,
+      metadata: {
+        reason: "scaler_unconfigured"
+      }
+    };
+  }
+}
+class RailwayWorkerPoolScaler {
+  apiToken;
+  apiUrl;
+  serviceId;
+  environmentId;
+  projectId;
+  fetchImpl;
+  mutation;
+  constructor(options = {}) {
+    this.apiToken = options.apiToken?.trim() || envValue("RAILWAY_API_TOKEN") || envValue("RAILWAY_TOKEN") || null;
+    this.apiUrl = options.apiUrl?.trim() || envValue("TREESEED_RAILWAY_API_URL") || DEFAULT_RAILWAY_API_URL;
+    this.serviceId = options.serviceId?.trim() || envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID") || null;
+    this.environmentId = options.environmentId?.trim() || envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") || null;
+    this.projectId = options.projectId?.trim() || envValue("TREESEED_RAILWAY_PROJECT_ID") || null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.mutation = options.mutation?.trim() || envValue("TREESEED_RAILWAY_SCALE_MUTATION") || DEFAULT_SCALE_MUTATION;
+  }
+  configured() {
+    return Boolean(this.apiToken && this.serviceId && this.environmentId);
+  }
+  async scale(decision) {
+    if (!this.configured() || !this.apiToken || !this.serviceId || !this.environmentId) {
+      return {
+        applied: false,
+        provider: "railway",
+        desiredWorkers: decision.desiredWorkers,
+        metadata: {
+          reason: "railway_scaler_unconfigured",
+          projectId: this.projectId,
+          serviceId: this.serviceId,
+          environmentId: this.environmentId
+        }
+      };
+    }
+    const response = await this.fetchImpl(this.apiUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        query: this.mutation,
+        variables: {
+          serviceId: this.serviceId,
+          environmentId: this.environmentId,
+          replicas: decision.desiredWorkers
+        }
+      })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || Array.isArray(payload.errors) && payload.errors.length > 0) {
+      throw new Error(
+        payload.errors?.[0]?.message ?? `Railway worker scale request failed with ${response.status}.`
+      );
+    }
+    return {
+      applied: true,
+      provider: "railway",
+      desiredWorkers: decision.desiredWorkers,
+      metadata: {
+        projectId: this.projectId,
+        serviceId: this.serviceId,
+        environmentId: this.environmentId
+      }
+    };
+  }
+}
+function createWorkerPoolScaler(kind, options = {}) {
+  const configuredKind = envValue("TREESEED_WORKER_POOL_SCALER") || null;
+  const inferredKind = envValue("RAILWAY_API_TOKEN") && (envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID")) ? "railway" : "noop";
+  const resolvedKind = kind ?? configuredKind ?? inferredKind;
+  if (resolvedKind === "railway") {
+    return new RailwayWorkerPoolScaler(options);
+  }
+  return new NoopWorkerPoolScaler();
+}
+export {
+  NoopWorkerPoolScaler,
+  RailwayWorkerPoolScaler,
+  createWorkerPoolScaler
+};

package/dist/services/worker.d.ts

@@ -2,5 +2,12 @@
 export declare function runWorkerCycle(): Promise<{
     ok: boolean;
     processed: number;
+    idle: boolean;
+    reason: string;
+} | {
+    ok: boolean;
+    processed: number;
+    idle?: undefined;
+    reason?: undefined;
 }>;
 export declare function startWorkerLoop(): Promise<void>;

package/dist/services/worker.js

@@ -1,27 +1,15 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { createGatewayClient, createQueueClient, resolveWorkerConfig } from "./common.js";
-async function managerRequest(baseUrl, path, body) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  const payload = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(typeof payload.error === "string" ? payload.error : `Manager request failed with ${response.status}.`);
-  }
-  return payload;
-}
+import { buildTaskContext, createQueueClient, createServiceSdk, resolveWorkerConfig } from "./common.js";
 async function runWorkerCycle() {
-  const gateway = createGatewayClient();
+  const sdk = createServiceSdk();
   const queue = createQueueClient();
   const config = resolveWorkerConfig();
-  if (!gateway || !queue) {
-    throw new Error("Worker requires TREESEED_GATEWAY_BASE_URL, TREESEED_GATEWAY_BEARER_TOKEN, CLOUDFLARE_ACCOUNT_ID, TREESEED_QUEUE_ID, and TREESEED_QUEUE_PULL_TOKEN.");
+  if (!queue) {
+    if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
+      return { ok: true, processed: 0, idle: true, reason: "queue_unconfigured" };
+    }
+    throw new Error("Worker requires CLOUDFLARE_ACCOUNT_ID, TREESEED_QUEUE_ID, and TREESEED_QUEUE_PULL_TOKEN.");
   }
   const pulled = await queue.pull({
     batchSize: config.batchSize,
@@ -33,52 +21,48 @@ async function runWorkerCycle() {
   let processed = 0;
   for (const message of pulled.messages) {
     try {
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/claim`, {
-        body: {
-          workerId: config.workerId,
-          leaseSeconds: config.leaseSeconds
-        }
+      await sdk.claimTask({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        leaseSeconds: config.leaseSeconds,
+        actor: "worker"
       });
-      const context = await managerRequest(
-        config.managerBaseUrl,
-        "/internal/context/resolve-task",
-        { taskId: message.body.taskId }
-      );
-      const task = context.payload.task;
+      const context = await buildTaskContext(sdk, message.body.taskId);
+      const task = context.task;
       const payload = task && typeof task.payloadJson === "string" ? JSON.parse(task.payloadJson) : {};
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/progress`, {
-        body: {
-          workerId: config.workerId,
-          state: "running",
-          appendEvent: {
-            kind: "worker_started",
-            data: { workerId: config.workerId, queueAttempt: message.attempts }
-          }
-        }
+      await sdk.recordTaskProgress({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        state: "running",
+        appendEvent: {
+          kind: "worker_started",
+          data: { workerId: config.workerId, queueAttempt: message.attempts }
+        },
+        actor: "worker"
       });
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/complete`, {
-        body: {
-          output: {
-            workerId: config.workerId,
-            queueAttempt: message.attempts,
-            payload
-          },
-          summary: {
-            status: "completed",
-            workerId: config.workerId
-          }
-        }
+      await sdk.completeTask({
+        id: message.body.taskId,
+        output: {
+          workerId: config.workerId,
+          queueAttempt: message.attempts,
+          payload
+        },
+        summary: {
+          status: "completed",
+          workerId: config.workerId
+        },
+        actor: "worker"
       });
       await queue.ack([message.leaseId]);
       processed += 1;
     } catch (error) {
       const retryDelaySeconds = Math.min(300, Math.max(15, message.attempts * 30));
-      await gateway.requestJson(`/tasks/${encodeURIComponent(message.body.taskId)}/fail`, {
-        body: {
-          errorMessage: error instanceof Error ? error.message : String(error),
-          retryable: true,
-          nextVisibleAt: new Date(Date.now() + retryDelaySeconds * 1e3).toISOString()
-        }
+      await sdk.failTask({
+        id: message.body.taskId,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        retryable: true,
+        nextVisibleAt: new Date(Date.now() + retryDelaySeconds * 1e3).toISOString(),
+        actor: "worker"
       }).catch(() => null);
       await queue.retry([{ leaseId: message.leaseId, delaySeconds: retryDelaySeconds }]);
     }

package/dist/site.js

@@ -18,6 +18,7 @@ import {
   resolveTreeseedSiteResource,
   resolveTreeseedStyleEntrypoint
 } from "./site-resources.js";
+import { isSiteRenderedModel } from "./utils/site-models.js";
 const TENANT_THEME_VIRTUAL_ID = "virtual:treeseed/tenant-theme.css";
 const RESOLVED_TENANT_THEME_VIRTUAL_ID = "\0treeseed:tenant-theme.css";
 function packageFile(relativePath) {
@@ -37,20 +38,20 @@ const PACKAGE_ROUTE_ENTRIES = [
   { pattern: "/", resourcePath: "pages/index.astro" },
   { pattern: "/404", resourcePath: "pages/404.astro" },
   { pattern: "/contact", resourcePath: "pages/contact.astro" },
-  { pattern: "/feed.xml", resourcePath: "pages/feed.xml" },
-  { pattern: "/[slug]", resourcePath: "pages/[slug].astro" },
-  { pattern: "/agents", resourcePath: "pages/agents/index.astro" },
-  { pattern: "/agents/[slug]", resourcePath: "pages/agents/[slug].astro" },
-  { pattern: "/books", resourcePath: "pages/books/index.astro" },
-  { pattern: "/books/[slug]", resourcePath: "pages/books/[slug].astro" },
-  { pattern: "/notes", resourcePath: "pages/notes/index.astro" },
-  { pattern: "/notes/[slug]", resourcePath: "pages/notes/[slug].astro" },
-  { pattern: "/objectives", resourcePath: "pages/objectives/index.astro" },
-  { pattern: "/objectives/[slug]", resourcePath: "pages/objectives/[slug].astro" },
-  { pattern: "/people", resourcePath: "pages/people/index.astro" },
-  { pattern: "/people/[slug]", resourcePath: "pages/people/[slug].astro" },
-  { pattern: "/questions", resourcePath: "pages/questions/index.astro" },
-  { pattern: "/questions/[slug]", resourcePath: "pages/questions/[slug].astro" }
+  { pattern: "/feed.xml", resourcePath: "pages/feed.xml", model: "notes" },
+  { pattern: "/[slug]", resourcePath: "pages/[slug].astro", model: "pages" },
+  { pattern: "/agents", resourcePath: "pages/agents/index.astro", model: "agents" },
+  { pattern: "/agents/[slug]", resourcePath: "pages/agents/[slug].astro", model: "agents" },
+  { pattern: "/books", resourcePath: "pages/books/index.astro", model: "books" },
+  { pattern: "/books/[slug]", resourcePath: "pages/books/[slug].astro", model: "books" },
+  { pattern: "/notes", resourcePath: "pages/notes/index.astro", model: "notes" },
+  { pattern: "/notes/[slug]", resourcePath: "pages/notes/[slug].astro", model: "notes" },
+  { pattern: "/objectives", resourcePath: "pages/objectives/index.astro", model: "objectives" },
+  { pattern: "/objectives/[slug]", resourcePath: "pages/objectives/[slug].astro", model: "objectives" },
+  { pattern: "/people", resourcePath: "pages/people/index.astro", model: "people" },
+  { pattern: "/people/[slug]", resourcePath: "pages/people/[slug].astro", model: "people" },
+  { pattern: "/questions", resourcePath: "pages/questions/index.astro", model: "questions" },
+  { pattern: "/questions/[slug]", resourcePath: "pages/questions/[slug].astro", model: "questions" }
 ];
 function createTreeseedRoutesIntegration(tenantConfig, routes = []) {
   return {
@@ -58,11 +59,7 @@ function createTreeseedRoutesIntegration(tenantConfig, routes = []) {
     hooks: {
       "astro:config:setup"({ injectRoute }) {
         for (const route of routes) {
-          if (route.pattern.startsWith("/agents") && tenantConfig.features?.agents === false) continue;
-          if (route.pattern.startsWith("/books") && tenantConfig.features?.books === false) continue;
-          if (route.pattern.startsWith("/notes") && tenantConfig.features?.notes === false) continue;
-          if (route.pattern.startsWith("/objectives") && tenantConfig.features?.objectives === false) continue;
-          if (route.pattern.startsWith("/questions") && tenantConfig.features?.questions === false) continue;
+          if (route.model && !isSiteRenderedModel(tenantConfig, route.model)) continue;
           injectRoute(route);
         }
       }
@@ -80,14 +77,16 @@ function resolveRouteEntry(route, siteLayers) {
     return {
       pattern: route.pattern,
       entrypoint: route.entrypoint,
-      resourcePath: route.resourcePath
+      resourcePath: route.resourcePath,
+      model: route.model
     };
   }
   if (route.resourcePath) {
     return {
       pattern: route.pattern,
       entrypoint: resolveTreeseedPageEntrypoint(siteLayers, route.resourcePath),
-      resourcePath: route.resourcePath
+      resourcePath: route.resourcePath,
+      model: route.model
     };
   }
   throw new Error(`Treeseed route "${route.pattern}" must define either entrypoint or resourcePath.`);
@@ -208,6 +207,8 @@ function createTreeseedSite(tenantConfig, { starlight }) {
   const deployConfig = loadTreeseedDeployConfig();
   const pluginRuntime = loadTreeseedPluginRuntime(deployConfig);
   const bookRuntime = buildTenantBookRuntime(tenantConfig, { projectRoot });
+  const docsRendered = isSiteRenderedModel(tenantConfig, "docs");
+  const booksRendered = isSiteRenderedModel(tenantConfig, "books");
   const tenantThemeCss = buildTenantThemeCss(siteConfig.site.theme);
   const siteLayers = buildTreeseedSiteLayers(pluginRuntime, {
     coreRoot: fileURLToPath(new URL(".", import.meta.url)),
@@ -230,10 +231,16 @@ function createTreeseedSite(tenantConfig, { starlight }) {
   const injectedSiteConfig = JSON.stringify(siteConfig);
   const injectedDeployConfig = JSON.stringify(deployConfig);
   const resolvedGlobalCss = resolveTreeseedStyleEntrypoint(siteLayers, "styles/global.css");
+  const serverRendered = deployConfig.surfaces?.web?.provider === "cloudflare" || deployConfig.providers.deploy === "cloudflare";
   return defineConfig({
-    adapter: deployConfig.surfaces?.web?.provider === "cloudflare" || deployConfig.providers.deploy === "cloudflare" ? cloudflare() : void 0,
-    output: deployConfig.surfaces?.web?.provider === "cloudflare" || deployConfig.providers.deploy === "cloudflare" ? "server" : "static",
+    adapter: serverRendered ? cloudflare({ imageService: "compile" }) : void 0,
+    output: serverRendered ? "server" : "static",
     site: siteConfig.site.siteUrl,
+    image: {
+      service: {
+        entrypoint: "astro/assets/services/sharp"
+      }
+    },
     vite: {
       define: {
         __TREESEED_TENANT_CONFIG__: injectedTenantConfig,
@@ -247,7 +254,7 @@ function createTreeseedSite(tenantConfig, { starlight }) {
         ...siteExtensions.vitePlugins
       ],
       ssr: {
-        external: ["node:fs", "node:path", "node:url"]
+        external: ["node:async_hooks", "node:crypto", "node:fs", "node:module", "node:path", "node:url"]
       }
     },
     markdown: {
@@ -268,6 +275,13 @@ function createTreeseedSite(tenantConfig, { starlight }) {
         TREESEED_SMTP_FROM: envField.string({ context: "server", access: "secret", optional: true }),
         TREESEED_SMTP_REPLY_TO: envField.string({ context: "server", access: "secret", optional: true }),
         TREESEED_FORM_TOKEN_SECRET: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_EDITORIAL_PREVIEW_SECRET: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_EDITORIAL_PREVIEW_ROOT: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_EDITORIAL_PREVIEW_TTL_HOURS: envField.number({ context: "server", access: "secret", optional: true }),
+        TREESEED_CONTENT_BUCKET_NAME: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_CONTENT_DEFAULT_TEAM_ID: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_CONTENT_MANIFEST_KEY_TEMPLATE: envField.string({ context: "server", access: "secret", optional: true }),
+        TREESEED_CONTENT_PREVIEW_ROOT_TEMPLATE: envField.string({ context: "server", access: "secret", optional: true }),
         TREESEED_LOCAL_DEV_MODE: envField.enum({ values: ["cloudflare"], context: "server", access: "secret", optional: true }),
         TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: envField.boolean({ context: "server", access: "secret", optional: true }),
         TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: envField.boolean({ context: "server", access: "secret", optional: true }),
@@ -279,7 +293,9 @@ function createTreeseedSite(tenantConfig, { starlight }) {
     },
     integrations: [
       createTreeseedRoutesIntegration(tenantConfig, resolvedRoutes),
-      starlight({
+      ...docsRendered ? [starlight({
+        prerender: !serverRendered,
+        pagefind: !serverRendered,
         disable404Route: true,
         expressiveCode: false,
         customCss: [resolvedGlobalCss, TENANT_THEME_VIRTUAL_ID, ...siteExtensions.customCss],
@@ -303,9 +319,9 @@ function createTreeseedSite(tenantConfig, { starlight }) {
           ThemeSelect: resolveCoreComponentEntrypoint(siteLayers, "components/docs/ThemeSelect.astro", "./components/docs/ThemeSelect.astro"),
           ...siteExtensions.starlightComponents
         },
-        sidebar: getStarlightSidebarConfigFromRuntime(bookRuntime),
+        sidebar: booksRendered ? getStarlightSidebarConfigFromRuntime(bookRuntime) : [],
         routeMiddleware: [packageModuleFile("./middleware/starlightRouteData"), ...siteExtensions.routeMiddleware]
-      }),
+      })] : [],
       ...siteExtensions.integrations
     ]
   });