@treeseed/core 0.4.10 → 0.4.12

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

@@ -6,6 +6,9 @@ async function runWorkerCycle() {
   const queue = createQueueClient();
   const config = resolveWorkerConfig();
   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({

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
     ]
   });

package/dist/templates.d.ts

@@ -0,0 +1,98 @@
+import type { CatalogItem, CatalogItemOfferMode } from '@treeseed/sdk/types';
+export interface TemplateContentEntry {
+    id: string;
+    data: {
+        slug: string;
+        title: string;
+        summary: string;
+        description: string;
+        status: string;
+        category: string;
+        featured?: boolean;
+        publisher: {
+            name: string;
+        };
+        templateVersion: string;
+        templateApiVersion: number;
+        minCliVersion: string;
+        minCoreVersion: string;
+        offer?: {
+            priceModel?: CatalogItemOfferMode | string;
+        };
+        fulfillment: {
+            mode?: string;
+            source: {
+                kind: 'git';
+                repoUrl: string;
+                directory: string;
+                ref: string;
+            } | {
+                kind: 'r2';
+                objectKey: string;
+                version: string;
+                publicUrl?: string;
+            };
+            hooksPolicy?: string;
+            supportsReconcile?: boolean;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface TemplateCatalogProviderContext {
+    locals?: object | null | undefined;
+}
+export interface TemplateCatalogProvider {
+    listItems?(context: TemplateCatalogProviderContext): Promise<CatalogItem[]>;
+    getItemBySlug?(slug: string, context: TemplateCatalogProviderContext): Promise<CatalogItem | null>;
+}
+export interface TemplateSiteCard {
+    slug: string;
+    title: string;
+    summary: string;
+    category: string;
+    featured: boolean;
+    publisherName: string;
+    templateVersion?: string;
+    priceModel?: CatalogItemOfferMode | string;
+    source: 'catalog' | 'content';
+}
+export interface TemplateSiteDetail extends TemplateSiteCard {
+    description: string;
+    compatibility: {
+        templateVersion?: string;
+        templateApiVersion?: number | string;
+        minCliVersion?: string;
+        minCoreVersion?: string;
+    };
+    fulfillment: {
+        mode: string;
+        sourceLabel: string;
+        artifactKey?: string | null;
+        manifestKey?: string | null;
+        repoUrl?: string;
+        directory?: string;
+        ref?: string;
+        objectKey?: string;
+        version?: string;
+        publicUrl?: string;
+        hooksPolicy?: string | null;
+        supportsReconcile?: boolean | null;
+    };
+    contentEntry: TemplateContentEntry | null;
+    catalogItem: CatalogItem | null;
+}
+type TemplateSourceOptions = TemplateCatalogProviderContext & {
+    catalogProvider?: TemplateCatalogProvider | null;
+    listLocalEntries?: (() => Promise<TemplateContentEntry[]>) | null;
+};
+export interface TemplateSiteListingResult {
+    rendered: boolean;
+    items: TemplateSiteCard[];
+}
+export interface ResolvedSiteTemplateResult {
+    rendered: boolean;
+    item: TemplateSiteDetail | null;
+}
+export declare function listSiteTemplates(context?: TemplateSourceOptions): Promise<TemplateSiteListingResult>;
+export declare function resolveSiteTemplate(slug: string, context?: TemplateSourceOptions): Promise<ResolvedSiteTemplateResult>;
+export {};

package/dist/templates.js

@@ -0,0 +1,170 @@
+import { getCollection } from "astro:content";
+import { RUNTIME_TENANT } from "./tenant/runtime-config.js";
+import { siteModelRendered } from "./utils/site-models.js";
+function sortTemplateCards(entries) {
+  return [...entries].sort((left, right) => {
+    const featuredDelta = Number(Boolean(right.featured)) - Number(Boolean(left.featured));
+    if (featuredDelta !== 0) {
+      return featuredDelta;
+    }
+    return String(left.title ?? "").localeCompare(String(right.title ?? ""), void 0, { sensitivity: "base" });
+  });
+}
+async function listLocalTemplateEntries(listLocalEntries) {
+  if (typeof listLocalEntries === "function") {
+    return listLocalEntries();
+  }
+  if (!RUNTIME_TENANT.content.templates) {
+    return [];
+  }
+  return getCollection("templates");
+}
+function catalogString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function catalogNumber(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "number" ? value : void 0;
+}
+function contentCardFromEntry(entry) {
+  if (entry.data.status !== "live") {
+    return null;
+  }
+  return {
+    slug: entry.data.slug,
+    title: entry.data.title,
+    summary: entry.data.summary,
+    category: entry.data.category,
+    featured: entry.data.featured === true,
+    publisherName: entry.data.publisher.name,
+    templateVersion: entry.data.templateVersion,
+    priceModel: entry.data.offer?.priceModel,
+    source: "content"
+  };
+}
+function detailFromContentEntry(entry) {
+  const source = entry.data.fulfillment.source;
+  return {
+    ...contentCardFromEntry(entry),
+    description: entry.data.description,
+    compatibility: {
+      templateVersion: entry.data.templateVersion,
+      templateApiVersion: entry.data.templateApiVersion,
+      minCliVersion: entry.data.minCliVersion,
+      minCoreVersion: entry.data.minCoreVersion
+    },
+    fulfillment: source.kind === "r2" ? {
+      mode: entry.data.fulfillment.mode ?? "r2",
+      sourceLabel: "R2 artifact",
+      objectKey: source.objectKey,
+      version: source.version,
+      publicUrl: source.publicUrl,
+      hooksPolicy: entry.data.fulfillment.hooksPolicy,
+      supportsReconcile: entry.data.fulfillment.supportsReconcile
+    } : {
+      mode: entry.data.fulfillment.mode ?? "git",
+      sourceLabel: "Git",
+      repoUrl: source.repoUrl,
+      directory: source.directory,
+      ref: source.ref,
+      hooksPolicy: entry.data.fulfillment.hooksPolicy,
+      supportsReconcile: entry.data.fulfillment.supportsReconcile
+    },
+    contentEntry: entry,
+    catalogItem: null
+  };
+}
+function cardFromCatalogItem(item) {
+  return {
+    slug: item.slug,
+    title: item.title,
+    summary: item.summary ?? "",
+    category: catalogString(item.metadata, "category") ?? "Template",
+    featured: item.metadata?.featured === true,
+    publisherName: catalogString(item.metadata, "publisherName") ?? item.teamId,
+    templateVersion: catalogString(item.metadata, "templateVersion"),
+    priceModel: item.offerMode,
+    source: "catalog"
+  };
+}
+function detailFromCatalogItem(item) {
+  return {
+    ...cardFromCatalogItem(item),
+    description: item.summary ?? "This template is managed through the central market catalog.",
+    compatibility: {
+      templateVersion: catalogString(item.metadata, "templateVersion"),
+      templateApiVersion: catalogNumber(item.metadata, "templateApiVersion"),
+      minCliVersion: catalogString(item.metadata, "minCliVersion"),
+      minCoreVersion: catalogString(item.metadata, "minCoreVersion")
+    },
+    fulfillment: {
+      mode: catalogString(item.metadata, "fulfillmentMode") ?? "r2",
+      sourceLabel: item.artifactKey ? "R2 artifact" : "Catalog metadata",
+      artifactKey: item.artifactKey,
+      manifestKey: item.manifestKey
+    },
+    contentEntry: null,
+    catalogItem: item
+  };
+}
+async function selectCatalogItemBySlug(slug, context) {
+  if (!context.catalogProvider) {
+    return null;
+  }
+  if (typeof context.catalogProvider.getItemBySlug === "function") {
+    return context.catalogProvider.getItemBySlug(slug, { locals: context.locals });
+  }
+  if (typeof context.catalogProvider.listItems === "function") {
+    const items = await context.catalogProvider.listItems({ locals: context.locals });
+    return items.find((item) => item.slug === slug) ?? null;
+  }
+  return null;
+}
+async function listSiteTemplates(context = {}) {
+  if (!siteModelRendered("templates")) {
+    return {
+      rendered: false,
+      items: []
+    };
+  }
+  const catalogItems = context.catalogProvider && typeof context.catalogProvider.listItems === "function" ? await context.catalogProvider.listItems({ locals: context.locals }) : [];
+  if (catalogItems.length > 0) {
+    return {
+      rendered: true,
+      items: sortTemplateCards(catalogItems.map(cardFromCatalogItem))
+    };
+  }
+  const entries = await listLocalTemplateEntries(context.listLocalEntries);
+  return {
+    rendered: true,
+    items: sortTemplateCards(
+      entries.map(contentCardFromEntry).filter((entry) => Boolean(entry))
+    )
+  };
+}
+async function resolveSiteTemplate(slug, context = {}) {
+  if (!siteModelRendered("templates")) {
+    return {
+      rendered: false,
+      item: null
+    };
+  }
+  const catalogItem = await selectCatalogItemBySlug(slug, context);
+  if (catalogItem) {
+    return {
+      rendered: true,
+      item: detailFromCatalogItem(catalogItem)
+    };
+  }
+  const entries = await listLocalTemplateEntries(context.listLocalEntries);
+  const entry = entries.find((candidate) => candidate.data.slug === slug && candidate.data.status === "live") ?? null;
+  return {
+    rendered: true,
+    item: entry ? detailFromContentEntry(entry) : null
+  };
+}
+export {
+  listSiteTemplates,
+  resolveSiteTemplate
+};

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

@@ -0,0 +1,4 @@
+import type { TreeseedTenantConfig } from '@treeseed/sdk/platform/contracts';
+export declare const RUNTIME_PROJECT_ROOT: string;
+export declare const RUNTIME_TENANT: TreeseedTenantConfig;
+export declare const RUNTIME_SITE_CONFIG: any;

package/dist/tenant/runtime-config.js

@@ -1,11 +1,44 @@
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { loadTreeseedManifest } from "@treeseed/sdk/platform/tenant-config";
 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;
 const injectedSiteConfig = typeof __TREESEED_SITE_CONFIG__ !== "undefined" ? __TREESEED_SITE_CONFIG__ : null;
-const RUNTIME_TENANT = injectedTenantConfig ?? loadTreeseedManifest();
 const RUNTIME_PROJECT_ROOT = injectedProjectRoot ?? process.cwd();
+function fallbackTenantConfig(projectRoot) {
+  return {
+    id: "treeseed-runtime",
+    siteConfigPath: resolve(projectRoot, "treeseed.site.yaml"),
+    content: {
+      pages: resolve(projectRoot, "src/content/pages"),
+      notes: resolve(projectRoot, "src/content/notes"),
+      questions: resolve(projectRoot, "src/content/questions"),
+      objectives: resolve(projectRoot, "src/content/objectives"),
+      people: resolve(projectRoot, "src/content/people"),
+      agents: resolve(projectRoot, "src/content/agents"),
+      books: resolve(projectRoot, "src/content/books"),
+      docs: resolve(projectRoot, "src/content/knowledge"),
+      templates: resolve(projectRoot, "src/content/templates"),
+      knowledge_packs: resolve(projectRoot, "src/content/knowledge-packs"),
+      workdays: resolve(projectRoot, "src/content/workdays")
+    },
+    features: {
+      docs: true,
+      books: true
+    }
+  };
+}
+const RUNTIME_TENANT = (() => {
+  if (injectedTenantConfig) {
+    return injectedTenantConfig;
+  }
+  try {
+    return loadTreeseedManifest();
+  } catch {
+    return fallbackTenantConfig(RUNTIME_PROJECT_ROOT);
+  }
+})();
 const RUNTIME_SITE_CONFIG = injectedSiteConfig ?? (() => {
   try {
     return parseSiteConfig(readFileSync(RUNTIME_TENANT.siteConfigPath, "utf8"));