@treeseed/core 0.4.10 → 0.4.12

package/dist/api/auth/rbac.d.ts

@@ -1,6 +1,6 @@
-export declare const CONTENT_RESOURCES: readonly ["pages", "notes", "questions", "objectives", "people", "agents", "books", "templates", "knowledge_downloads"];
+export declare const CONTENT_RESOURCES: readonly ["pages", "notes", "questions", "objectives", "people", "agents", "books", "templates", "knowledge_packs", "workdays"];
 export declare const PLATFORM_RESOURCES: readonly ["users", "roles", "api_tokens", "services", "jobs", "audit", "auth", "sdk", "agent", "operations"];
-export declare const ALL_PERMISSION_RESOURCES: readonly ["pages", "notes", "questions", "objectives", "people", "agents", "books", "templates", "knowledge_downloads", "users", "roles", "api_tokens", "services", "jobs", "audit", "auth", "sdk", "agent", "operations"];
+export declare const ALL_PERMISSION_RESOURCES: readonly ["pages", "notes", "questions", "objectives", "people", "agents", "books", "templates", "knowledge_packs", "workdays", "users", "roles", "api_tokens", "services", "jobs", "audit", "auth", "sdk", "agent", "operations"];
 export type PermissionResource = (typeof ALL_PERMISSION_RESOURCES)[number];
 export type PermissionAction = 'read' | 'create' | 'update' | 'delete' | 'manage' | 'execute' | 'impersonate';
 export type PermissionScope = 'self' | 'global';

package/dist/api/auth/rbac.js

@@ -7,7 +7,8 @@ const CONTENT_RESOURCES = [
   "agents",
   "books",
   "templates",
-  "knowledge_downloads"
+  "knowledge_packs",
+  "workdays"
 ];
 const PLATFORM_RESOURCES = [
   "users",

package/dist/components/site/RouteNotFound.astro

@@ -0,0 +1,25 @@
+---
+import MainLayout from '../../layouts/MainLayout.astro';
+
+const {
+	title = 'Page not found',
+	description = 'The requested Treeseed content could not be found.',
+	currentPath = '/404/',
+} = Astro.props;
+---
+
+<MainLayout title={title} description={description} currentPath={currentPath}>
+	<section class="mx-auto max-w-3xl space-y-6 py-20">
+		<p class="text-sm font-semibold uppercase tracking-[0.16em] text-[color:var(--site-accent-strong)]">404</p>
+		<h1 class="font-serif text-5xl text-[color:var(--site-text)]">{title}</h1>
+		<p class="text-lg leading-9 text-[color:var(--site-text-muted)]">{description}</p>
+		<div class="flex flex-wrap gap-4">
+			<a href="/" class="border border-[color:var(--site-accent)] bg-[color:var(--site-accent)] px-5 py-3 text-base font-semibold text-[color:var(--site-text)] transition hover:border-[color:var(--site-blue)] hover:bg-[color:var(--site-blue-soft)]">
+				Go home
+			</a>
+			<a href="/knowledge/" class="border border-[color:var(--site-border-strong)] px-5 py-3 text-base font-semibold text-[color:var(--site-text)] transition hover:border-[color:var(--site-blue)] hover:bg-[color:var(--site-blue-soft)]">
+				Open knowledge
+			</a>
+		</div>
+	</section>
+</MainLayout>

package/dist/content-config.d.ts

@@ -7,4 +7,5 @@ export declare function createTreeseedTenantCollections(manifestPath?: string):
 	agents: any;
 	books: any;
 	docs: any;
+	workdays?: any;
 };

package/dist/content.d.ts

@@ -0,0 +1 @@
+export declare function createTreeseedCollections(tenantConfig: any, dependencies: any): Record<string, any>;

package/dist/content.js

@@ -1,6 +1,7 @@
 import { defineCollection, reference } from "astro:content";
 import { z } from "astro/zod";
 import { glob } from "astro/loaders";
+import { existsSync, readdirSync } from "node:fs";
 import { AGENT_CLI_ALLOW_TOOLS } from "@treeseed/sdk/types/agents";
 import { loadTreeseedPluginRuntime } from "@treeseed/sdk/platform/plugins";
 import { loadTreeseedDeployConfig } from "@treeseed/sdk/platform/deploy-config";
@@ -22,6 +23,30 @@ 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 hasMarkdownContent(base) {
+  if (!existsSync(base)) {
+    return false;
+  }
+  for (const entry of readdirSync(base, { withFileTypes: true, recursive: true })) {
+    if (entry.isFile() && /\.(md|mdx)$/iu.test(entry.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function optionalMarkdownGlob(base) {
+  const delegate = glob({ pattern: "**/*.{md,mdx}", base });
+  return {
+    name: `treeseed-optional-markdown-glob:${base}`,
+    async load(context) {
+      if (!hasMarkdownContent(base)) {
+        context.store.clear();
+        return;
+      }
+      await delegate.load(context);
+    }
+  };
+}
 function withOptionalDefault(schema, defaultValue) {
   return defaultValue === void 0 ? schema : schema.default(defaultValue);
 }
@@ -244,8 +269,140 @@ function createTreeseedCollections(tenantConfig, { docsLoader, docsSchema }) {
     sidebarItems: z.array(sidebarItemSchema).min(1),
     tags: z.array(z.string()).default(BOOK_MODEL_DEFAULTS.tags ?? [])
   }));
+  const publisherSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    url: z.string().optional()
+  });
+  const templateGitSourceSchema = z.object({
+    kind: z.literal("git"),
+    repoUrl: z.string(),
+    directory: z.string(),
+    ref: z.string(),
+    integrity: z.string().optional()
+  });
+  const templateR2SourceSchema = z.object({
+    kind: z.literal("r2"),
+    bucket: z.string().optional(),
+    objectKey: z.string(),
+    version: z.string(),
+    publicUrl: z.string().optional(),
+    integrity: z.string().optional()
+  });
+  const templateProductSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    summary: z.string(),
+    status: z.enum(["draft", "live", "archived"]),
+    featured: z.boolean().default(false),
+    teamId: z.string().optional(),
+    listingEnabled: z.boolean().default(true),
+    category: z.string(),
+    audience: z.array(z.string()).default([]),
+    tags: z.array(z.string()).default([]),
+    publisher: publisherSchema,
+    publisherVerified: z.boolean().default(false),
+    templateVersion: z.string(),
+    templateApiVersion: z.number().int().positive(),
+    minCliVersion: z.string(),
+    minCoreVersion: z.string(),
+    fulfillment: z.object({
+      mode: z.enum(["packaged", "git", "r2"]).default("packaged"),
+      source: z.union([templateGitSourceSchema, templateR2SourceSchema]),
+      hooksPolicy: z.enum(["builtin_only", "trusted_only", "disabled"]).default("builtin_only"),
+      supportsReconcile: z.boolean().default(true)
+    }),
+    offer: z.object({
+      priceModel: z.enum(["free", "paid", "contact", "one_time_current_version", "subscription_updates", "private"]).default("free"),
+      license: z.string().optional(),
+      support: z.string().optional()
+    }).default({ priceModel: "free" }),
+    relatedBooks: z.array(z.string()).default([]),
+    relatedKnowledge: z.array(z.string()).default([]),
+    relatedObjectives: z.array(z.string()).default([])
+  });
+  const knowledgePackSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    status: z.enum(["draft", "live", "archived"]).default("draft")
+  });
+  const workdaySummaryTaskSchema = z.object({
+    id: z.string(),
+    agentId: z.string().optional(),
+    type: z.string().optional(),
+    state: z.string().optional(),
+    priority: z.number().optional(),
+    idempotencyKey: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    startedAt: z.coerce.date().optional(),
+    completedAt: z.coerce.date().optional(),
+    lastErrorCode: z.string().nullable().optional(),
+    lastErrorMessage: z.string().nullable().optional(),
+    lastEventKind: z.string().optional(),
+    outputCount: z.number().int().optional(),
+    changedFiles: z.array(z.string()).default([])
+  });
+  const workdayPriorityItemSchema = z.object({
+    id: z.string(),
+    model: z.string(),
+    slug: z.string().optional(),
+    title: z.string().optional(),
+    status: z.string().optional(),
+    priority: z.number(),
+    estimatedCredits: z.number().optional(),
+    reason: z.string().optional()
+  });
+  const workdayReleaseSchema = z.object({
+    id: z.string().optional(),
+    deploymentKind: z.string(),
+    status: z.string(),
+    releaseTag: z.string().nullable().optional(),
+    commitSha: z.string().nullable().optional(),
+    sourceRef: z.string().nullable().optional(),
+    startedAt: z.coerce.date().optional(),
+    finishedAt: z.coerce.date().optional(),
+    createdAt: z.coerce.date().optional()
+  });
+  const workdaySchema = z.object({
+    title: z.string(),
+    slug: z.string(),
+    workDayId: z.string(),
+    reportVersion: z.string(),
+    reportKind: z.string().default("workday_summary"),
+    projectId: z.string(),
+    teamId: z.string().optional(),
+    environment: z.string(),
+    status: z.string().default("live"),
+    visibility: z.enum(["public", "authenticated", "team", "private"]).default("team"),
+    workdayState: z.string(),
+    startedAt: z.coerce.date(),
+    endedAt: z.coerce.date().nullable().optional(),
+    generatedAt: z.coerce.date(),
+    createdAt: z.coerce.date().optional(),
+    summary: z.string(),
+    dailyTaskCreditBudget: z.number().default(0),
+    usedTaskCredits: z.number().default(0),
+    remainingTaskCredits: z.number().default(0),
+    creditLedgerEntries: z.number().int().default(0),
+    prioritySnapshotId: z.string().nullable().optional(),
+    priorityItemCount: z.number().int().default(0),
+    priorityItems: z.array(workdayPriorityItemSchema).default([]),
+    totalTasks: z.number().int().default(0),
+    completedTasks: z.number().int().default(0),
+    failedTasks: z.number().int().default(0),
+    queuedTasks: z.number().int().default(0),
+    activeTasks: z.number().int().default(0),
+    taskItems: z.array(workdaySummaryTaskSchema).default([]),
+    changedFiles: z.array(z.string()).default([]),
+    releases: z.array(workdayReleaseSchema).default([]),
+    scaleDecision: z.record(z.any()).default({}),
+    scaleResult: z.record(z.any()).default({}),
+    metadata: z.record(z.any()).default({})
+  });
   const docsCollectionProvider = resolveDocsCollectionProvider(tenantConfig, { docsLoader, docsSchema });
-  return {
+  const collections = {
     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 }),
@@ -258,6 +415,25 @@ function createTreeseedCollections(tenantConfig, { docsLoader, docsSchema }) {
       schema: docsCollectionProvider.schema
     })
   };
+  if (tenantConfig.content.workdays) {
+    collections.workdays = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.workdays),
+      schema: workdaySchema
+    });
+  }
+  if (tenantConfig.content.templates) {
+    collections.templates = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.templates),
+      schema: templateProductSchema
+    });
+  }
+  if (tenantConfig.content.knowledge_packs) {
+    collections.knowledge_packs = defineCollection({
+      loader: optionalMarkdownGlob(tenantConfig.content.knowledge_packs),
+      schema: knowledgePackSchema
+    });
+  }
+  return collections;
 }
 export {
   createTreeseedCollections

package/dist/dev.d.ts

@@ -3,7 +3,8 @@ export declare const TREESEED_DEFAULT_WEB_HOST = "127.0.0.1";
 export declare const TREESEED_DEFAULT_WEB_PORT = 4321;
 export declare const TREESEED_DEFAULT_API_HOST = "127.0.0.1";
 export declare const TREESEED_DEFAULT_API_PORT = 3000;
-export type TreeseedIntegratedDevSurface = 'integrated' | 'web' | 'api';
+export declare const TREESEED_DEFAULT_MANAGER_PORT = 3100;
+export type TreeseedIntegratedDevSurface = 'integrated' | 'services' | 'web' | 'api' | 'manager' | 'worker' | 'agents';
 export type TreeseedIntegratedDevOptions = {
     surface?: TreeseedIntegratedDevSurface;
     watch?: boolean;
@@ -14,9 +15,13 @@ export type TreeseedIntegratedDevOptions = {
     webPort?: number;
     apiHost?: string;
     apiPort?: number;
+    managerPort?: number;
+    includeServices?: boolean;
+    projectId?: string;
+    teamId?: string;
 };
 export type TreeseedIntegratedDevCommand = {
-    id: 'web' | 'api';
+    id: 'web' | 'api' | 'manager' | 'worker' | 'agents';
     label: string;
     command: string;
     args: string[];

package/dist/dev.js

@@ -10,6 +10,7 @@ const TREESEED_DEFAULT_WEB_HOST = "127.0.0.1";
 const TREESEED_DEFAULT_WEB_PORT = 4321;
 const TREESEED_DEFAULT_API_HOST = "127.0.0.1";
 const TREESEED_DEFAULT_API_PORT = 3e3;
+const TREESEED_DEFAULT_MANAGER_PORT = 3100;
 function resolvePackageRoot(packageName, tenantRoot) {
   const resolvedPath = require2.resolve(packageName, {
     paths: [tenantRoot, packageRoot, process.cwd()]
@@ -74,6 +75,10 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const webPort = normalizePort(options.webPort, TREESEED_DEFAULT_WEB_PORT);
   const apiHost = options.apiHost ?? TREESEED_DEFAULT_API_HOST;
   const apiPort = normalizePort(options.apiPort, TREESEED_DEFAULT_API_PORT);
+  const managerPort = normalizePort(options.managerPort, TREESEED_DEFAULT_MANAGER_PORT);
+  const includeServices = options.includeServices ?? (surface === "integrated" || surface === "services");
+  const projectId = options.projectId ?? process.env.TREESEED_PROJECT_ID;
+  const teamId = options.teamId ?? process.env.TREESEED_HOSTING_TEAM_ID;
   const mergedEnv = { ...process.env, ...options.env ?? {} };
   const apiBaseUrl = mergedEnv.TREESEED_API_BASE_URL?.trim() || `http://${apiHost}:${apiPort}`;
   const sdkPackageRoot = resolvePackageRoot("@treeseed/sdk", tenantRoot);
@@ -88,6 +93,21 @@ function createTreeseedIntegratedDevPlan(options = {}) {
     "src/api/server.ts",
     "dist/api/server.js"
   );
+  const managerEntrypoint = resolveNodeEntrypoint(
+    packageRoot,
+    "src/services/manager.ts",
+    "dist/services/manager.js"
+  );
+  const workerEntrypoint = resolveNodeEntrypoint(
+    packageRoot,
+    "src/services/worker.ts",
+    "dist/services/worker.js"
+  );
+  const agentsEntrypoint = resolveNodeEntrypoint(
+    packageRoot,
+    "src/services/agents.ts",
+    "dist/services/agents.js"
+  );
   const watchPaths = [
     resolve(packageRoot, existsSync(resolve(packageRoot, "src")) ? "src" : "dist"),
     resolve(tenantRoot, "src"),
@@ -97,7 +117,10 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const sharedEnv = {
     ...mergedEnv,
     TREESEED_LOCAL_DEV_MODE: mergedEnv.TREESEED_LOCAL_DEV_MODE ?? "cloudflare",
-    TREESEED_API_BASE_URL: apiBaseUrl
+    TREESEED_API_BASE_URL: apiBaseUrl,
+    TREESEED_MARKET_API_BASE_URL: mergedEnv.TREESEED_MARKET_API_BASE_URL ?? apiBaseUrl,
+    TREESEED_PROJECT_ID: projectId ?? mergedEnv.TREESEED_PROJECT_ID,
+    TREESEED_HOSTING_TEAM_ID: teamId ?? mergedEnv.TREESEED_HOSTING_TEAM_ID
   };
   if (watch) {
     sharedEnv.TREESEED_PUBLIC_DEV_WATCH_RELOAD = sharedEnv.TREESEED_PUBLIC_DEV_WATCH_RELOAD || "true";
@@ -126,6 +149,40 @@ function createTreeseedIntegratedDevPlan(options = {}) {
       }
     });
   }
+  if (includeServices || surface === "manager") {
+    commands.push({
+      id: "manager",
+      label: "Manager",
+      command: managerEntrypoint.command,
+      args: watch ? withWatchArgs(managerEntrypoint.args, watchPaths) : managerEntrypoint.args,
+      cwd: tenantRoot,
+      env: {
+        ...sharedEnv,
+        PORT: sharedEnv.PORT ?? String(managerPort),
+        TREESEED_MANAGER_BASE_URL: sharedEnv.TREESEED_MANAGER_BASE_URL ?? `http://${apiHost}:${managerPort}`
+      }
+    });
+  }
+  if (includeServices || surface === "worker") {
+    commands.push({
+      id: "worker",
+      label: "Worker",
+      command: workerEntrypoint.command,
+      args: watch ? withWatchArgs(workerEntrypoint.args, watchPaths) : workerEntrypoint.args,
+      cwd: tenantRoot,
+      env: sharedEnv
+    });
+  }
+  if (includeServices || surface === "agents") {
+    commands.push({
+      id: "agents",
+      label: "Agents",
+      command: agentsEntrypoint.command,
+      args: watch ? withWatchArgs(agentsEntrypoint.args, watchPaths) : agentsEntrypoint.args,
+      cwd: tenantRoot,
+      env: sharedEnv
+    });
+  }
   return {
     surface,
     tenantRoot,
@@ -205,6 +262,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
 export {
   TREESEED_DEFAULT_API_HOST,
   TREESEED_DEFAULT_API_PORT,
+  TREESEED_DEFAULT_MANAGER_PORT,
   TREESEED_DEFAULT_WEB_HOST,
   TREESEED_DEFAULT_WEB_PORT,
   createTreeseedIntegratedDevPlan,

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { createTreeseedApiApp } from './api/app';
 export { createRailwayTreeseedApiServer } from './api/railway';
 export { resolveApiConfig } from './api/config';
 export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';
+export { filterSiteRenderedModels, isSiteRenderedModel, siteModelRendered, } from './utils/site-models.ts';
 export type * from './api/types';

package/dist/index.js

@@ -18,6 +18,11 @@ import {
   createTreeseedIntegratedDevPlan,
   runTreeseedIntegratedDev
 } from "./dev.js";
+import {
+  filterSiteRenderedModels,
+  isSiteRenderedModel,
+  siteModelRendered
+} from "./utils/site-models.js";
 export {
   TREESEED_PLATFORM_RESOURCE_KINDS,
   TREESEED_SITE_RESOURCE_KINDS,
@@ -26,11 +31,14 @@ export {
   createRailwayTreeseedApiServer,
   createTreeseedApiApp,
   createTreeseedIntegratedDevPlan,
+  filterSiteRenderedModels,
+  isSiteRenderedModel,
   parseSiteConfig,
   resolveApiConfig,
   resolveTreeseedPageEntrypoint,
   resolveTreeseedPlatformResource,
   resolveTreeseedSiteResource,
   resolveTreeseedStyleEntrypoint,
-  runTreeseedIntegratedDev
+  runTreeseedIntegratedDev,
+  siteModelRendered
 };

package/dist/middleware/editorial-preview.d.ts

@@ -0,0 +1,26 @@
+import { type EditorialPreviewTokenPayload } from '@treeseed/sdk/platform/published-content';
+type CookieValue = {
+    value: string;
+} | undefined;
+export interface EditorialPreviewContextLike {
+    url: URL;
+    cookies: {
+        get(name: string): CookieValue;
+        set(name: string, value: string, options?: {
+            httpOnly?: boolean;
+            path?: string;
+            sameSite?: 'lax' | 'strict' | 'none';
+            secure?: boolean;
+            expires?: Date;
+        }): void;
+        delete(name: string, options?: {
+            path?: string;
+        }): void;
+    };
+    locals: object;
+}
+export declare function resolveEditorialPreview(context: EditorialPreviewContextLike, options?: {
+    secret?: string | null;
+    cookieName?: string;
+}): EditorialPreviewTokenPayload | null;
+export {};

package/dist/middleware/editorial-preview.js

@@ -0,0 +1,37 @@
+import {
+  EDITORIAL_PREVIEW_COOKIE,
+  verifyEditorialPreviewToken
+} from "@treeseed/sdk/platform/published-content";
+function previewSecretFromLocals(locals) {
+  const runtime = locals?.runtime;
+  return typeof runtime?.env?.TREESEED_EDITORIAL_PREVIEW_SECRET === "string" ? runtime.env.TREESEED_EDITORIAL_PREVIEW_SECRET : "";
+}
+function resolveEditorialPreview(context, options = {}) {
+  const cookieName = options.cookieName ?? EDITORIAL_PREVIEW_COOKIE;
+  const secret = typeof options.secret === "string" ? options.secret : previewSecretFromLocals(context.locals);
+  const queryPreview = context.url.searchParams.get("preview");
+  if (queryPreview === "clear") {
+    context.cookies.delete(cookieName, { path: "/" });
+    context.locals.contentPreview = null;
+    return null;
+  }
+  const cookiePreview = context.cookies.get(cookieName)?.value ?? null;
+  const activeToken = queryPreview || cookiePreview;
+  const resolvedPreview = activeToken && secret ? verifyEditorialPreviewToken(activeToken, secret) : null;
+  if (queryPreview && resolvedPreview) {
+    context.cookies.set(cookieName, queryPreview, {
+      httpOnly: true,
+      path: "/",
+      sameSite: "lax",
+      secure: context.url.protocol === "https:",
+      expires: new Date(resolvedPreview.expiresAt)
+    });
+  } else if (activeToken && !resolvedPreview) {
+    context.cookies.delete(cookieName, { path: "/" });
+  }
+  context.locals.contentPreview = resolvedPreview;
+  return resolvedPreview;
+}
+export {
+  resolveEditorialPreview
+};

package/dist/middleware/starlightRouteData.js

@@ -1,5 +1,8 @@
 import { defineRouteMiddleware } from "../vendor/starlight/route-data.js";
-import { BOOKS, TREESEED_LINKS, normalizeHref } from "../utils/starlight-nav.js";
+import { TREESEED_LINKS, buildStarlightSidebarEntriesFromRuntime, normalizeHref } from "../utils/starlight-nav.js";
+import { loadHostedBookRuntime } from "../utils/published-content.js";
+import { BOOKS, BOOKS_LINK, TREESEED_LIBRARY_DOWNLOAD } from "@treeseed/sdk/platform/books-data";
+import { loadTreeseedManifest, tenantModelRendered } from "@treeseed/sdk/platform/tenant-config";
 const copyLink = (entry) => ({ ...entry, attrs: { ...entry.attrs } });
 const copyEntry = (entry) => entry.type === "link" ? copyLink(entry) : {
   ...entry,
@@ -23,10 +26,18 @@ const setRouteSidebar = (route, currentPath, sidebar, paginationSource) => {
   route.hasSidebar = sidebar.length > 0;
   route.pagination = paginationSource ? buildPagination(paginationSource, currentPath) : { prev: void 0, next: void 0 };
 };
-const onRequest = defineRouteMiddleware((context) => {
+const defaultRuntime = { BOOKS, BOOKS_LINK, TREESEED_LIBRARY_DOWNLOAD, TREESEED_LINKS };
+const tenantConfig = loadTreeseedManifest();
+const onRequest = defineRouteMiddleware(async (context) => {
   const route = context.locals.starlightRoute;
   const currentPath = normalizeHref(context.url.pathname);
-  const activeBook = BOOKS.find(
+  if (!tenantModelRendered(tenantConfig, "books")) {
+    setRouteSidebar(route, currentPath, [], null);
+    return;
+  }
+  const runtime = await loadHostedBookRuntime(context.locals) ?? defaultRuntime;
+  route.sidebar = buildStarlightSidebarEntriesFromRuntime(runtime, currentPath);
+  const activeBook = runtime.BOOKS.find(
     (book) => currentPath.startsWith(normalizeHref(book.basePath))
   );
   if (activeBook) {
@@ -35,7 +46,7 @@ const onRequest = defineRouteMiddleware((context) => {
     setRouteSidebar(route, currentPath, [copyEntry(bookGroup)], bookGroup.entries);
     return;
   }
-  if (currentPath === normalizeHref(TREESEED_LINKS.home)) {
+  if (currentPath === normalizeHref(runtime.TREESEED_LINKS.home)) {
     setRouteSidebar(route, currentPath, [], null);
     return;
   }

package/dist/pages/[slug].astro

@@ -2,23 +2,25 @@
 import { getCollection, render } from 'astro:content';
 import ContentLayout from '../layouts/ContentLayout.astro';
 import BridgeLayout from '../layouts/BridgeLayout.astro';
+import RouteNotFound from '../components/site/RouteNotFound.astro';
 
-export async function getStaticPaths() {
-	const entries = await getCollection('pages');
+export const prerender = false;
 
-	return entries.map((entry) => ({
-		params: { slug: entry.data.slug },
-		props: { entry },
-	}));
+const slug = String(Astro.params.slug ?? '');
+const entries = await getCollection('pages');
+const entry = entries.find((candidate) => candidate.data.slug === slug) ?? null;
+if (!entry) {
+	Astro.response.status = 404;
 }
-
-const { entry } = Astro.props;
-const { Content } = await render(entry);
+const rendered = entry ? await render(entry) : null;
+const Content = rendered?.Content ?? null;
 const currentPath = Astro.url.pathname;
 ---
 
 {
-	entry.data.pageLayout === 'bridge' ? (
+	!entry || !Content ? (
+		<RouteNotFound title="Page not found" description="The requested page is not available in this Treeseed." currentPath={currentPath} />
+	) : entry.data.pageLayout === 'bridge' ? (
 		<BridgeLayout entry={entry.data} currentPath={currentPath}>
 			<Content />
 		</BridgeLayout>

package/dist/pages/agents/[slug].astro

@@ -2,28 +2,35 @@
 import { getCollection, render } from 'astro:content';
 import ProfileLayout from '../../layouts/ProfileLayout.astro';
 import { resolveReferences } from '../../utils/hub-content';
+import RouteNotFound from '../../components/site/RouteNotFound.astro';
 
-export async function getStaticPaths() {
-	const agents = await getCollection('agents');
-	return agents.map((agent) => ({
-		params: { slug: agent.id },
-		props: { agent },
-	}));
-}
+export const prerender = false;
 
-const { agent } = Astro.props;
-const { Content } = await render(agent);
-const relatedQuestions = await resolveReferences(agent.data.relatedQuestions);
-const relatedObjectives = await resolveReferences(agent.data.relatedObjectives);
+const slug = String(Astro.params.slug ?? '');
+const agents = await getCollection('agents');
+const agent = agents.find((candidate) => candidate.id === slug) ?? null;
+if (!agent) {
+	Astro.response.status = 404;
+}
+const rendered = agent ? await render(agent) : null;
+const Content = rendered?.Content ?? null;
+const relatedQuestions = agent ? await resolveReferences(agent.data.relatedQuestions) : [];
+const relatedObjectives = agent ? await resolveReferences(agent.data.relatedObjectives) : [];
 ---
 
-<ProfileLayout
-	entry={agent.data}
-	currentPath="/agents/"
-	metaLabel="Operator"
-	metaValue={`${agent.data.operator} · ${agent.data.runtimeStatus}`}
-	relatedQuestions={relatedQuestions}
-	relatedObjectives={relatedObjectives}
->
-	<Content />
-</ProfileLayout>
+{
+	!agent || !Content ? (
+		<RouteNotFound title="Agent not found" description="The requested agent profile could not be found in this Treeseed." currentPath="/agents/" />
+	) : (
+		<ProfileLayout
+			entry={agent.data}
+			currentPath="/agents/"
+			metaLabel="Operator"
+			metaValue={`${agent.data.operator} · ${agent.data.runtimeStatus}`}
+			relatedQuestions={relatedQuestions}
+			relatedObjectives={relatedObjectives}
+		>
+			<Content />
+		</ProfileLayout>
+	)
+}

package/dist/pages/books/[slug].astro

@@ -1,19 +1,26 @@
 ---
 import { getCollection, render } from 'astro:content';
 import BookLayout from '../../layouts/BookLayout.astro';
+import RouteNotFound from '../../components/site/RouteNotFound.astro';
 
-export async function getStaticPaths() {
-	const books = (await getCollection('books')).sort((a, b) => a.data.order - b.data.order);
-	return books.map((book) => ({
-		params: { slug: book.id },
-		props: { book },
-	}));
-}
+export const prerender = false;
 
-const { book } = Astro.props;
-const { Content } = await render(book);
+const slug = String(Astro.params.slug ?? '');
+const books = (await getCollection('books')).sort((a, b) => a.data.order - b.data.order);
+const book = books.find((candidate) => candidate.id === slug) ?? null;
+if (!book) {
+	Astro.response.status = 404;
+}
+const rendered = book ? await render(book) : null;
+const Content = rendered?.Content ?? null;
 ---
 
-<BookLayout entry={book.data} currentPath="/books/">
-	<Content />
-</BookLayout>
+{
+	!book || !Content ? (
+		<RouteNotFound title="Book not found" description="The requested book could not be found in this Treeseed." currentPath="/books/" />
+	) : (
+		<BookLayout entry={book.data} currentPath="/books/">
+			<Content />
+		</BookLayout>
+	)
+}