@treeseed/core 0.4.13 → 0.5.2

package/dist/services/worker-capacity.js

@@ -0,0 +1,208 @@
+import { createWorkerPoolScaler } from "./worker-pool-scaler.js";
+function integerFromEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+function parseJson(value, fallback) {
+  if (typeof value !== "string" || !value.trim()) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function readNumber(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number.parseFloat(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value : [];
+}
+function resolveAutoscalePolicyFromEnv() {
+  return {
+    minWorkers: integerFromEnv("TREESEED_AGENT_POOL_MIN_WORKERS", 0),
+    maxWorkers: integerFromEnv("TREESEED_AGENT_POOL_MAX_WORKERS", 1),
+    targetQueueDepth: Math.max(1, integerFromEnv("TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH", 1)),
+    cooldownSeconds: Math.max(0, integerFromEnv("TREESEED_AGENT_POOL_COOLDOWN_SECONDS", 60))
+  };
+}
+function resolveWorkerPoolIdentityFromEnv(projectId) {
+  const environment = envValue("TREESEED_DEPLOY_ENVIRONMENT") || (process.env.NODE_ENV === "production" ? "prod" : "local");
+  const resolvedProjectId = projectId?.trim() || envValue("TREESEED_PROJECT_ID") || "treeseed-market";
+  return {
+    projectId: resolvedProjectId,
+    environment,
+    poolName: envValue("TREESEED_AGENT_POOL_NAME") || `${resolvedProjectId}-${environment}`
+  };
+}
+function computeDesiredWorkerCount(autoscale, metrics) {
+  const { minWorkers, maxWorkers, targetQueueDepth } = autoscale;
+  if (metrics.queuedCount <= 0 && metrics.activeLeases <= 0) {
+    return minWorkers;
+  }
+  const requiredByQueue = Math.ceil(metrics.queuedCount / Math.max(1, targetQueueDepth));
+  const minimumActive = metrics.activeLeases > 0 ? 1 : 0;
+  return Math.max(minWorkers, Math.min(maxWorkers, Math.max(requiredByQueue, minimumActive)));
+}
+function applyScaleCooldown(autoscale, latestDecision, nextDesired, now) {
+  if (!latestDecision) {
+    return nextDesired;
+  }
+  if (nextDesired >= latestDecision.desiredWorkers) {
+    return nextDesired;
+  }
+  const cooldownMs = Math.max(0, autoscale.cooldownSeconds) * 1e3;
+  if (cooldownMs === 0) {
+    return nextDesired;
+  }
+  const lastChangedAt = new Date(latestDecision.createdAt);
+  if (!Number.isFinite(lastChangedAt.valueOf())) {
+    return nextDesired;
+  }
+  return now.valueOf() - lastChangedAt.valueOf() < cooldownMs ? latestDecision.desiredWorkers : nextDesired;
+}
+function applyInteractiveWakeUpOverride(options) {
+  if (options.priorityClass !== "interactive") {
+    return options.desiredWorkers;
+  }
+  if (options.queuedCount <= 0 || options.currentWorkers > 0 || options.desiredWorkers > 0) {
+    return options.desiredWorkers;
+  }
+  return 1;
+}
+async function collectTaskMetrics(sdk, workDayId) {
+  const [queuedEnvelope, activeEnvelope] = await Promise.all([
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["pending", "queued"]
+    }),
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["claimed", "running"]
+    })
+  ]);
+  const queuedTasks = asRecords(queuedEnvelope.payload);
+  const activeTasks = asRecords(activeEnvelope.payload);
+  const queuedCredits = queuedTasks.reduce((total, task) => {
+    const payload = parseJson(String(task.payloadJson ?? "{}"), {});
+    const credits = readNumber(payload, "estimatedCredits") ?? 1;
+    return total + credits;
+  }, 0);
+  return {
+    queuedTasks,
+    activeTasks,
+    queuedCount: queuedTasks.length,
+    activeLeases: activeTasks.length,
+    queuedCredits
+  };
+}
+async function enqueueTaskAndEnsureCapacity(sdk, request) {
+  await request.enqueueTask(sdk, {
+    taskId: request.taskId,
+    queueName: request.queueName,
+    deliveryDelaySeconds: request.deliveryDelaySeconds,
+    actor: request.actor
+  });
+  const now = request.now ?? /* @__PURE__ */ new Date();
+  const identity = request.identity ?? resolveWorkerPoolIdentityFromEnv(request.projectId);
+  const autoscale = request.autoscale ?? resolveAutoscalePolicyFromEnv();
+  const scaler = request.scaler ?? createWorkerPoolScaler();
+  const metrics = await collectTaskMetrics(sdk);
+  const latestScaleDecision = await sdk.getLatestScaleDecision(identity.projectId, identity.environment, identity.poolName);
+  const currentWorkers = Math.max(0, Number(latestScaleDecision.payload?.desiredWorkers ?? 0));
+  const rawDesiredWorkers = computeDesiredWorkerCount(autoscale, metrics);
+  const desiredAfterCooldown = applyScaleCooldown(autoscale, latestScaleDecision.payload, rawDesiredWorkers, now);
+  const desiredWorkers = applyInteractiveWakeUpOverride({
+    priorityClass: request.priorityClass ?? "background",
+    queuedCount: metrics.queuedCount,
+    currentWorkers,
+    desiredWorkers: desiredAfterCooldown
+  });
+  const coldStartTriggered = (request.priorityClass ?? "background") === "interactive" && currentWorkers <= 0 && desiredWorkers > 0;
+  const scaleReason = desiredWorkers !== desiredAfterCooldown ? "interactive_cold_start" : coldStartTriggered ? "interactive_cold_start" : desiredWorkers !== rawDesiredWorkers ? "cooldown_hold" : request.priorityClass === "interactive" ? "interactive_enqueue" : "enqueue";
+  const recordedScaleDecision = await sdk.recordScaleDecision({
+    projectId: identity.projectId,
+    environment: identity.environment,
+    poolName: identity.poolName,
+    workDayId: null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: scaleReason,
+    metadata: {
+      priorityClass: request.priorityClass ?? "background",
+      taskId: request.taskId
+    }
+  });
+  const scaleDecision = recordedScaleDecision.payload ?? {
+    projectId: identity.projectId,
+    environment: identity.environment,
+    poolName: identity.poolName,
+    workDayId: null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: scaleReason,
+    metadata: {
+      priorityClass: request.priorityClass ?? "background",
+      taskId: request.taskId
+    },
+    createdAt: now.toISOString()
+  };
+  let scaleResult;
+  try {
+    scaleResult = await scaler.scale(scaleDecision);
+  } catch (error) {
+    scaleResult = {
+      applied: false,
+      provider: "error",
+      desiredWorkers,
+      metadata: {
+        reason: "scale_failed",
+        error: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  return {
+    ok: true,
+    taskId: request.taskId,
+    queued: true,
+    workerState: currentWorkers > 0 ? "warm" : desiredWorkers > 0 ? "cold_starting" : "warm",
+    desiredWorkers,
+    scaleApplied: scaleResult.applied,
+    scaleReason,
+    scaleDecision,
+    scaleResult,
+    metrics
+  };
+}
+export {
+  applyInteractiveWakeUpOverride,
+  applyScaleCooldown,
+  collectTaskMetrics,
+  computeDesiredWorkerCount,
+  enqueueTaskAndEnsureCapacity,
+  resolveAutoscalePolicyFromEnv,
+  resolveWorkerPoolIdentityFromEnv
+};

package/dist/services/worker.js

@@ -1,10 +1,70 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
-import { buildTaskContext, createQueueClient, createServiceSdk, resolveWorkerConfig } from "./common.js";
+import { AgentKernel } from "../agents/kernel/agent-kernel.js";
+import { buildTaskContext, createQueueClient, createServiceSdk, resolveServiceRepoRoot, resolveWorkerConfig } from "./common.js";
+function parseTaskPayload(task) {
+  const raw = typeof task?.payloadJson === "string" ? task.payloadJson : "{}";
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function executeQueuedTask(options) {
+  const context = await buildTaskContext(options.sdk, options.taskId);
+  const task = context.task;
+  const payload = parseTaskPayload(task);
+  const executionKind = typeof payload.executionKind === "string" ? payload.executionKind : null;
+  if (executionKind === "workflow_dispatch" || executionKind === "sdk_dispatch") {
+    const namespace = typeof payload.namespace === "string" ? payload.namespace : "workflow";
+    const operation = typeof payload.operation === "string" ? payload.operation : "";
+    if (!operation) {
+      throw new Error(`Task ${options.taskId} does not define a dispatch operation.`);
+    }
+    const input = payload.input && typeof payload.input === "object" ? payload.input : {};
+    const result = await options.sdk.dispatch({
+      namespace,
+      operation,
+      input,
+      preferredMode: "prefer_local"
+    });
+    return {
+      workerId: options.workerId,
+      queueAttempt: options.queueAttempt,
+      executionKind,
+      namespace,
+      operation,
+      result,
+      summary: {
+        status: "completed",
+        workerId: options.workerId,
+        summary: `Executed ${namespace}:${operation}`
+      }
+    };
+  }
+  const agentSlug = typeof payload.agentSlug === "string" && payload.agentSlug ? payload.agentSlug : typeof context.agent?.slug === "string" && context.agent.slug ? context.agent.slug : typeof task?.agentId === "string" && task.agentId ? task.agentId : typeof task?.agent_id === "string" && task.agent_id ? task.agent_id : "";
+  if (!agentSlug) {
+    throw new Error(`Task ${options.taskId} does not resolve to an agent slug.`);
+  }
+  const invocation = payload.invocation && typeof payload.invocation === "object" ? payload.invocation : null;
+  const agentResult = await options.kernel.runAgent(agentSlug, invocation ? "manual" : "auto", invocation);
+  return {
+    workerId: options.workerId,
+    queueAttempt: options.queueAttempt,
+    agentSlug,
+    result: agentResult,
+    summary: {
+      status: agentResult.status,
+      workerId: options.workerId,
+      summary: agentResult.summary
+    }
+  };
+}
 async function runWorkerCycle() {
   const sdk = createServiceSdk();
   const queue = createQueueClient();
   const config = resolveWorkerConfig();
+  const kernel = new AgentKernel(sdk, resolveServiceRepoRoot());
   if (!queue) {
     if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
       return { ok: true, processed: 0, idle: true, reason: "queue_unconfigured" };
@@ -27,9 +87,6 @@ async function runWorkerCycle() {
         leaseSeconds: config.leaseSeconds,
         actor: "worker"
       });
-      const context = await buildTaskContext(sdk, message.body.taskId);
-      const task = context.task;
-      const payload = task && typeof task.payloadJson === "string" ? JSON.parse(task.payloadJson) : {};
       await sdk.recordTaskProgress({
         id: message.body.taskId,
         workerId: config.workerId,
@@ -40,17 +97,17 @@ async function runWorkerCycle() {
         },
         actor: "worker"
       });
+      const output = await executeQueuedTask({
+        sdk,
+        kernel,
+        taskId: message.body.taskId,
+        workerId: config.workerId,
+        queueAttempt: message.attempts
+      });
       await sdk.completeTask({
         id: message.body.taskId,
-        output: {
-          workerId: config.workerId,
-          queueAttempt: message.attempts,
-          payload
-        },
-        summary: {
-          status: "completed",
-          workerId: config.workerId
-        },
+        output,
+        summary: output.summary,
         actor: "worker"
       });
       await queue.ack([message.leaseId]);

package/dist/site.js

@@ -11,6 +11,7 @@ import { buildTenantBookRuntime } from "@treeseed/sdk/platform/books-data";
 import { getStarlightSidebarConfigFromRuntime } from "./utils/starlight-nav.js";
 import { buildTenantThemeCss } from "./utils/theme.js";
 import { loadTreeseedDeployConfig } from "@treeseed/sdk/platform/deploy-config";
+import { getTreeseedContentServingMode } from "@treeseed/sdk/platform/deploy-runtime";
 import { loadTreeseedPluginRuntime } from "@treeseed/sdk/platform/plugins";
 import {
   buildTreeseedSiteLayers,
@@ -48,8 +49,12 @@ const PACKAGE_ROUTE_ENTRIES = [
   { 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: "/proposals", resourcePath: "pages/proposals/index.astro", model: "proposals" },
+  { pattern: "/proposals/[slug]", resourcePath: "pages/proposals/[slug].astro", model: "proposals" },
   { pattern: "/people", resourcePath: "pages/people/index.astro", model: "people" },
   { pattern: "/people/[slug]", resourcePath: "pages/people/[slug].astro", model: "people" },
+  { pattern: "/decisions", resourcePath: "pages/decisions/index.astro", model: "decisions" },
+  { pattern: "/decisions/[slug]", resourcePath: "pages/decisions/[slug].astro", model: "decisions" },
   { pattern: "/questions", resourcePath: "pages/questions/index.astro", model: "questions" },
   { pattern: "/questions/[slug]", resourcePath: "pages/questions/[slug].astro", model: "questions" }
 ];
@@ -223,15 +228,20 @@ function createTreeseedSite(tenantConfig, { starlight }) {
     siteConfig,
     deployConfig
   });
-  const resolvedRoutes = [...PACKAGE_ROUTE_ENTRIES, ...siteExtensions.routes].map(
-    (route) => resolveRouteEntry(route, siteLayers)
-  );
   const injectedTenantConfig = JSON.stringify(tenantConfig);
   const injectedProjectRoot = JSON.stringify(projectRoot);
   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";
+  const publishedRuntime = getTreeseedContentServingMode() === "published_runtime";
+  const packageRoutes = [
+    ...PACKAGE_ROUTE_ENTRIES,
+    ...docsRendered && publishedRuntime ? [
+      { pattern: "/knowledge", resourcePath: "pages/docs-runtime/index.astro", model: "docs" },
+      { pattern: "/knowledge/[...slug]", resourcePath: "pages/docs-runtime/[...slug].astro", model: "docs" }
+    ] : []
+  ];
   return defineConfig({
     adapter: serverRendered ? cloudflare({ imageService: "compile" }) : void 0,
     output: serverRendered ? "server" : "static",
@@ -292,8 +302,11 @@ function createTreeseedSite(tenantConfig, { starlight }) {
       }
     },
     integrations: [
-      createTreeseedRoutesIntegration(tenantConfig, resolvedRoutes),
-      ...docsRendered ? [starlight({
+      createTreeseedRoutesIntegration(tenantConfig, [
+        ...packageRoutes.map((route) => resolveRouteEntry(route, siteLayers)),
+        ...siteExtensions.routes.map((route) => resolveRouteEntry(route, siteLayers))
+      ]),
+      ...docsRendered && !publishedRuntime ? [starlight({
         prerender: !serverRendered,
         pagefind: !serverRendered,
         disable404Route: true,

package/dist/tenant/runtime-config.js

@@ -15,6 +15,8 @@ function fallbackTenantConfig(projectRoot) {
       notes: resolve(projectRoot, "src/content/notes"),
       questions: resolve(projectRoot, "src/content/questions"),
       objectives: resolve(projectRoot, "src/content/objectives"),
+      proposals: resolve(projectRoot, "src/content/proposals"),
+      decisions: resolve(projectRoot, "src/content/decisions"),
       people: resolve(projectRoot, "src/content/people"),
       agents: resolve(projectRoot, "src/content/agents"),
       books: resolve(projectRoot, "src/content/books"),
@@ -25,7 +27,12 @@ function fallbackTenantConfig(projectRoot) {
     },
     features: {
       docs: true,
-      books: true
+      books: true,
+      notes: true,
+      questions: true,
+      objectives: true,
+      proposals: true,
+      decisions: true
     }
   };
 }

package/dist/utils/hub-content.js

@@ -25,6 +25,18 @@ async function getPublishedObjectives() {
   }
   return sortEntriesByDateDescending(await getCollection("objectives", ({ data }) => !data.draft));
 }
+async function getPublishedProposals() {
+  if (!siteModelRendered("proposals")) {
+    return [];
+  }
+  return sortEntriesByDateDescending(await getCollection("proposals", ({ data }) => !data.draft));
+}
+async function getPublishedDecisions() {
+  if (!siteModelRendered("decisions")) {
+    return [];
+  }
+  return sortEntriesByDateDescending(await getCollection("decisions", ({ data }) => !data.draft));
+}
 async function getPublishedNotes() {
   if (!siteModelRendered("notes")) {
     return [];
@@ -52,9 +64,11 @@ async function getPublishedBooks() {
 export {
   getPublishedAgents,
   getPublishedBooks,
+  getPublishedDecisions,
   getPublishedNotes,
   getPublishedObjectives,
   getPublishedPeople,
+  getPublishedProposals,
   getPublishedQuestions,
   resolveContributor,
   resolveContributorsForEntries,

package/dist/utils/published-content.js

@@ -54,7 +54,20 @@ async function loadHostedBookRuntime(locals) {
   }
   return provider.getObject(pointer);
 }
+async function loadHostedDocsTree(locals) {
+  const provider = resolveHostedContentRuntimeProvider(locals);
+  if (!provider) {
+    return null;
+  }
+  const manifest = await provider.getManifest();
+  const pointer = manifest.runtime?.docsTree;
+  if (!pointer) {
+    return null;
+  }
+  return provider.getObject(pointer);
+}
 export {
   loadHostedBookRuntime,
+  loadHostedDocsTree,
   resolveHostedContentRuntimeProvider
 };

package/dist/utils/site-config.js

@@ -35,6 +35,8 @@ const PAGE_MODEL_DEFAULTS = SITE_CONFIG.models.pages.defaults;
 const NOTE_MODEL_DEFAULTS = SITE_CONFIG.models.notes.defaults;
 const QUESTION_MODEL_DEFAULTS = SITE_CONFIG.models.questions.defaults;
 const OBJECTIVE_MODEL_DEFAULTS = SITE_CONFIG.models.objectives.defaults;
+const PROPOSAL_MODEL_DEFAULTS = SITE_CONFIG.models.proposals.defaults;
+const DECISION_MODEL_DEFAULTS = SITE_CONFIG.models.decisions.defaults;
 const PEOPLE_MODEL_DEFAULTS = SITE_CONFIG.models.people.defaults;
 const AGENT_MODEL_DEFAULTS = SITE_CONFIG.models.agents.defaults;
 const BOOK_MODEL_DEFAULTS = SITE_CONFIG.models.books.defaults;
@@ -67,6 +69,20 @@ function applyObjectiveModelDefaults(value) {
     tags: value.tags ?? OBJECTIVE_MODEL_DEFAULTS.tags ?? []
   };
 }
+function applyProposalModelDefaults(value) {
+  return {
+    ...PROPOSAL_MODEL_DEFAULTS,
+    ...value,
+    tags: value.tags ?? PROPOSAL_MODEL_DEFAULTS.tags ?? []
+  };
+}
+function applyDecisionModelDefaults(value) {
+  return {
+    ...DECISION_MODEL_DEFAULTS,
+    ...value,
+    tags: value.tags ?? DECISION_MODEL_DEFAULTS.tags ?? []
+  };
+}
 function applyPeopleModelDefaults(value) {
   return {
     ...PEOPLE_MODEL_DEFAULTS,
@@ -98,10 +114,12 @@ function applyDocsModelDefaults(value) {
 export {
   AGENT_MODEL_DEFAULTS,
   BOOK_MODEL_DEFAULTS,
+  DECISION_MODEL_DEFAULTS,
   NOTE_MODEL_DEFAULTS,
   OBJECTIVE_MODEL_DEFAULTS,
   PAGE_MODEL_DEFAULTS,
   PEOPLE_MODEL_DEFAULTS,
+  PROPOSAL_MODEL_DEFAULTS,
   QUESTION_MODEL_DEFAULTS,
   SITE,
   SITE_CONFIG,
@@ -113,10 +131,12 @@ export {
   TREESEED_MODEL_DEFAULTS,
   applyAgentModelDefaults,
   applyBookModelDefaults,
+  applyDecisionModelDefaults,
   applyDocsModelDefaults,
   applyNoteModelDefaults,
   applyObjectiveModelDefaults,
   applyPageModelDefaults,
   applyPeopleModelDefaults,
+  applyProposalModelDefaults,
   applyQuestionModelDefaults
 };

package/dist/utils/site-content-runtime.js

@@ -0,0 +1,185 @@
+import { createMarkdownProcessor } from "@astrojs/markdown-remark";
+import rehypeKatex from "rehype-katex";
+import remarkMath from "remark-math";
+import { getTreeseedContentServingMode } from "@treeseed/sdk/platform/deploy-runtime";
+import { resolveHostedContentRuntimeProvider } from "./published-content.js";
+let markdownProcessorPromise = null;
+function markdownProcessor() {
+  if (!markdownProcessorPromise) {
+    markdownProcessorPromise = createMarkdownProcessor({
+      remarkPlugins: [remarkMath],
+      rehypePlugins: [[rehypeKatex, { strict: "ignore" }]]
+    });
+  }
+  return markdownProcessorPromise;
+}
+function providerForLocals(locals) {
+  return resolveHostedContentRuntimeProvider(locals);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function strings(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  return [];
+}
+function dateValue(value) {
+  if (value instanceof Date && Number.isFinite(value.valueOf())) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = new Date(value);
+    if (Number.isFinite(parsed.valueOf())) {
+      return parsed;
+    }
+  }
+  return null;
+}
+function normalizeTags(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function normalizeLinks(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => record(entry)).map((entry) => ({
+    label: typeof entry.label === "string" ? entry.label : "",
+    href: typeof entry.href === "string" ? entry.href : ""
+  })).filter((entry) => entry.label && entry.href);
+}
+function normalizePublishedEntry(entry, content) {
+  const frontmatter = record(content?.frontmatter);
+  const data = {
+    ...frontmatter,
+    title: typeof frontmatter.title === "string" ? frontmatter.title : entry.title,
+    summary: typeof frontmatter.summary === "string" ? frontmatter.summary : entry.summary,
+    status: typeof frontmatter.status === "string" ? frontmatter.status : entry.status,
+    slug: typeof frontmatter.slug === "string" ? frontmatter.slug : entry.slug,
+    tags: normalizeTags(frontmatter.tags),
+    links: normalizeLinks(frontmatter.links)
+  };
+  const date = dateValue(frontmatter.date ?? entry.publishedAt);
+  if (date) {
+    data.date = date;
+  }
+  const updated = dateValue(content?.updatedAt ?? frontmatter.updated ?? entry.updatedAt);
+  if (updated) {
+    data.updated = updated;
+  }
+  return {
+    id: entry.id,
+    model: entry.model,
+    slug: entry.slug,
+    data
+  };
+}
+function isPublishedRuntimeContentMode() {
+  return getTreeseedContentServingMode() === "published_runtime";
+}
+async function renderPublishedMarkdown(body) {
+  const rendered = await (await markdownProcessor()).render(body ?? "", {
+    frontmatter: {}
+  });
+  return rendered.code;
+}
+async function loadPublishedCollection(locals, model) {
+  const provider = providerForLocals(locals);
+  if (!provider) {
+    return [];
+  }
+  const entries = await provider.listCollection(model);
+  const resolved = await Promise.all(entries.map(async (entry) => {
+    const content = await provider.getObject(entry.content);
+    return normalizePublishedEntry(entry, content);
+  }));
+  return resolved;
+}
+async function loadPublishedEntry(locals, model, slugOrId) {
+  const provider = providerForLocals(locals);
+  if (!provider) {
+    return null;
+  }
+  const entry = await provider.getEntry(model, slugOrId);
+  if (!entry) {
+    return null;
+  }
+  const content = await provider.getObject(entry.content);
+  if (!content) {
+    return null;
+  }
+  return {
+    publishedEntry: entry,
+    entry: normalizePublishedEntry(entry, content),
+    content,
+    html: await renderPublishedMarkdown(content.body ?? "")
+  };
+}
+async function resolvePublishedReferences(locals, model, references) {
+  const provider = providerForLocals(locals);
+  if (!provider) {
+    return [];
+  }
+  const resolved = await Promise.all(strings(references).map(async (slugOrId) => {
+    const entry = await provider.getEntry(model, slugOrId);
+    if (!entry) {
+      return null;
+    }
+    const content = await provider.getObject(entry.content);
+    return normalizePublishedEntry(entry, content);
+  }));
+  return resolved.filter(Boolean);
+}
+async function resolvePublishedContributor(locals, reference) {
+  const provider = providerForLocals(locals);
+  if (!provider) {
+    return null;
+  }
+  for (const model of ["people", "agents"]) {
+    for (const slugOrId of strings(reference)) {
+      const entry = await provider.getEntry(model, slugOrId);
+      if (entry) {
+        const content = await provider.getObject(entry.content);
+        return normalizePublishedEntry(entry, content);
+      }
+    }
+  }
+  return null;
+}
+function metadataFromPublishedContent(content) {
+  return record(content?.frontmatter);
+}
+function publishedDate(content, ...fallbacks) {
+  for (const candidate of [content?.frontmatter?.date, ...fallbacks]) {
+    const parsed = dateValue(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  return /* @__PURE__ */ new Date(0);
+}
+function publishedUpdated(content, ...fallbacks) {
+  for (const candidate of [content?.updatedAt, content?.frontmatter?.updated, ...fallbacks]) {
+    const parsed = dateValue(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  return /* @__PURE__ */ new Date(0);
+}
+export {
+  isPublishedRuntimeContentMode,
+  loadPublishedCollection,
+  loadPublishedEntry,
+  metadataFromPublishedContent,
+  normalizePublishedEntry,
+  publishedDate,
+  publishedUpdated,
+  renderPublishedMarkdown,
+  resolvePublishedContributor,
+  resolvePublishedReferences
+};