@treeseed/sdk 0.1.1 → 0.3.0

package/dist/platform/tenant/config.js

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
+import { normalizeAliasedRecord } from "../../field-aliases.js";
+function resolvePackageRoot() {
+  const moduleUrl = typeof import.meta?.url === "string" ? import.meta.url : null;
+  if (!moduleUrl) {
+    return process.cwd();
+  }
+  return resolve(dirname(fileURLToPath(moduleUrl)), "../..");
+}
+const packageRoot = resolvePackageRoot();
+const packageFixtureRoot = resolve(packageRoot, ".fixtures", "treeseed-fixtures", "sites", "working-site");
+const explicitTenantRoot = process.env.TREESEED_TENANT_ROOT ? resolve(process.env.TREESEED_TENANT_ROOT) : null;
+const manifestFieldAliases = {
+  siteConfigPath: { key: "siteConfigPath", aliases: ["site_config_path"] }
+};
+const manifestContentFieldAliases = {
+  pages: { key: "pages", aliases: ["page_root", "pages_root"] },
+  notes: { key: "notes", aliases: ["notes_root"] },
+  questions: { key: "questions", aliases: ["questions_root"] },
+  objectives: { key: "objectives", aliases: ["objectives_root"] },
+  people: { key: "people", aliases: ["people_root"] },
+  agents: { key: "agents", aliases: ["agents_root"] },
+  books: { key: "books", aliases: ["books_root"] },
+  docs: { key: "docs", aliases: ["knowledge", "knowledge_root", "docs_root"] }
+};
+const manifestOverrideFieldAliases = {
+  pagesRoot: { key: "pagesRoot", aliases: ["pages_root"] },
+  stylesRoot: { key: "stylesRoot", aliases: ["styles_root"] },
+  componentsRoot: { key: "componentsRoot", aliases: ["components_root"] }
+};
+function pathWithin(parent, candidate) {
+  const normalizedParent = resolve(parent);
+  const normalizedCandidate = resolve(candidate);
+  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
+}
+function collectTenantRootCandidates(start) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(
+      current,
+      resolve(current, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
+      resolve(current, "fixture")
+    );
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates;
+}
+function uniqueCandidates(entries) {
+  return [...new Set(entries.map((entry) => resolve(entry)))];
+}
+function tenantRootCandidates() {
+  const cwd = resolve(process.cwd());
+  const cwdCandidates = collectTenantRootCandidates(cwd);
+  const packageCandidates = collectTenantRootCandidates(packageRoot);
+  if (explicitTenantRoot) {
+    return uniqueCandidates([explicitTenantRoot, ...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+  }
+  if (pathWithin(packageRoot, cwd)) {
+    return uniqueCandidates([packageFixtureRoot, ...cwdCandidates, ...packageCandidates]);
+  }
+  return uniqueCandidates([...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+}
+function resolveTenantPath(manifestPath) {
+  if (existsSync(manifestPath)) {
+    return resolve(manifestPath);
+  }
+  const candidates = tenantRootCandidates().map((root) => resolve(root, manifestPath));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve Treeseed tenant manifest at "${manifestPath}" from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function resolveTenantRoot() {
+  const candidates = tenantRootCandidates();
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, "src/manifest.yaml"))) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve a Treeseed tenant root from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function defineTreeseedTenant(tenantConfig) {
+  return tenantConfig;
+}
+function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
+  const resolvedManifestPath = resolveTenantPath(manifestPath);
+  const tenantRoot = resolve(dirname(resolvedManifestPath), "..");
+  const parsed = normalizeAliasedRecord(
+    manifestFieldAliases,
+    parseYaml(readFileSync(resolvedManifestPath, "utf8"))
+  );
+  const content = normalizeAliasedRecord(
+    manifestContentFieldAliases,
+    parsed.content ?? {}
+  );
+  const overrides = parsed.overrides ? normalizeAliasedRecord(
+    manifestOverrideFieldAliases,
+    parsed.overrides
+  ) : void 0;
+  const tenantConfig = defineTreeseedTenant({
+    ...parsed,
+    siteConfigPath: resolve(tenantRoot, parsed.siteConfigPath),
+    content: Object.fromEntries(
+      Object.entries(content ?? {}).map(([collectionName, rootPath]) => [
+        collectionName,
+        resolve(tenantRoot, String(rootPath))
+      ])
+    ),
+    overrides: overrides ? {
+      pagesRoot: overrides.pagesRoot ? resolve(tenantRoot, overrides.pagesRoot) : void 0,
+      stylesRoot: overrides.stylesRoot ? resolve(tenantRoot, overrides.stylesRoot) : void 0,
+      componentsRoot: overrides.componentsRoot ? resolve(tenantRoot, overrides.componentsRoot) : void 0
+    } : void 0
+  });
+  Object.defineProperty(tenantConfig, "__tenantRoot", {
+    value: tenantRoot,
+    enumerable: false
+  });
+  return tenantConfig;
+}
+const loadTreeseedTenantManifest = loadTreeseedManifest;
+const resolveTreeseedTenantRoot = resolveTenantRoot;
+function getTenantContentRoot(tenantConfig, collectionName) {
+  const root = tenantConfig.content[collectionName];
+  if (!root) {
+    throw new Error(`Unknown tenant content collection: ${collectionName}`);
+  }
+  return root;
+}
+function tenantFeatureEnabled(tenantConfig, featureName) {
+  return tenantConfig.features?.[featureName] !== false;
+}
+export {
+  defineTreeseedTenant,
+  getTenantContentRoot,
+  loadTreeseedManifest,
+  loadTreeseedTenantManifest,
+  resolveTreeseedTenantRoot,
+  tenantFeatureEnabled
+};

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

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

package/dist/platform/tenant/runtime-config.js

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import { loadTreeseedManifest } from "./config.js";
+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();
+const RUNTIME_SITE_CONFIG = injectedSiteConfig ?? (() => {
+  try {
+    return parseSiteConfig(readFileSync(RUNTIME_TENANT.siteConfigPath, "utf8"));
+  } catch {
+    return null;
+  }
+})();
+export {
+  RUNTIME_PROJECT_ROOT,
+  RUNTIME_SITE_CONFIG,
+  RUNTIME_TENANT
+};

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

@@ -0,0 +1 @@
+export * from './tenant/config.ts';

package/dist/platform/tenant-config.js

@@ -0,0 +1 @@
+export * from "./tenant/config.js";

package/dist/platform/utils/books-data.d.ts

@@ -0,0 +1,29 @@
+import type { TreeseedBookDefinition, TreeseedTenantConfig } from '../contracts.ts';
+interface DocsLibraryDownload {
+    downloadFileName: string;
+    downloadHref: string;
+    downloadTitle: string;
+}
+interface TenantBookRuntime {
+    BOOKS: TreeseedBookDefinition[];
+    BOOKS_LINK: {
+        label: string;
+        link: string;
+    };
+    TREESEED_LINKS: {
+        home: string;
+    };
+    TREESEED_LIBRARY_DOWNLOAD: DocsLibraryDownload;
+}
+export declare function buildTenantBookRuntime(tenantConfig: Pick<TreeseedTenantConfig, 'content'>, options?: {
+    projectRoot?: string;
+    docsHomePath?: string;
+    docsLibraryDownload?: DocsLibraryDownload;
+}): TenantBookRuntime;
+export declare const BOOKS: TreeseedBookDefinition[], BOOKS_LINK: {
+    label: string;
+    link: string;
+}, TREESEED_LINKS: {
+    home: string;
+}, TREESEED_LIBRARY_DOWNLOAD: DocsLibraryDownload;
+export {};

package/dist/platform/utils/books-data.js

@@ -0,0 +1,82 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { getTenantContentRoot } from "../tenant/config.js";
+import { RUNTIME_PROJECT_ROOT, RUNTIME_TENANT } from "../tenant/runtime-config.js";
+function sortPaths(paths) {
+  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
+}
+function collectMarkdownFiles(rootPath) {
+  const stats = statSync(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  return sortPaths(
+    readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
+      const fullPath = path.join(rootPath, entry.name);
+      if (entry.isDirectory()) {
+        return collectMarkdownFiles(fullPath);
+      }
+      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+        return [fullPath];
+      }
+      return [];
+    })
+  );
+}
+function parseFrontmatter(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    throw new Error(`Book content entry is missing frontmatter: ${filePath}`);
+  }
+  return parseYaml(match[1]);
+}
+function inferDocsLibraryDownload(book) {
+  const title = book?.title ? `${book.title} Library` : "Knowledge Library";
+  return {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: title
+  };
+}
+function buildTenantBookRuntime(tenantConfig, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const booksContentRoot = path.resolve(projectRoot, getTenantContentRoot(tenantConfig, "books"));
+  const books = collectMarkdownFiles(booksContentRoot).map((filePath) => {
+    const frontmatter = parseFrontmatter(filePath);
+    return {
+      ...frontmatter,
+      id: path.basename(filePath, path.extname(filePath))
+    };
+  }).sort((left, right) => left.order - right.order);
+  const docsHomePath = options.docsHomePath ?? "/knowledge/";
+  const docsLibraryDownload = options.docsLibraryDownload ?? inferDocsLibraryDownload(tenantConfig);
+  return {
+    BOOKS: books,
+    BOOKS_LINK: {
+      label: "Books",
+      link: docsHomePath
+    },
+    TREESEED_LINKS: {
+      home: docsHomePath
+    },
+    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
+  };
+}
+const runtime = buildTenantBookRuntime(RUNTIME_TENANT, {
+  projectRoot: RUNTIME_PROJECT_ROOT,
+  docsLibraryDownload: {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: "TreeSeed Knowledge Library"
+  }
+});
+const { BOOKS, BOOKS_LINK, TREESEED_LINKS, TREESEED_LIBRARY_DOWNLOAD } = runtime;
+export {
+  BOOKS,
+  BOOKS_LINK,
+  TREESEED_LIBRARY_DOWNLOAD,
+  TREESEED_LINKS,
+  buildTenantBookRuntime
+};

package/dist/platform/utils/site-config-schema.js

@@ -0,0 +1,321 @@
+import { parse as parseYaml } from 'yaml';
+import { normalizeAliasedRecord } from '../../field-aliases.js';
+
+/** @typedef {import('../../field-aliases.js').TreeseedFieldAliasRegistry} TreeseedFieldAliasRegistry */
+
+function isRecord(value) {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function expectRecord(value, path) {
+	if (!isRecord(value)) {
+		throw new Error(`Expected ${path} to be an object.`);
+	}
+
+	return value;
+}
+
+function expectString(value, path) {
+	if (typeof value !== 'string' || value.trim().length === 0) {
+		throw new Error(`Expected ${path} to be a non-empty string.`);
+	}
+
+	return value.trim();
+}
+
+function optionalString(value, path) {
+	if (value === undefined || value === null || value === '') {
+		return undefined;
+	}
+
+	return expectString(value, path);
+}
+
+function optionalBoolean(value, path) {
+	if (value === undefined || value === null) {
+		return undefined;
+	}
+
+	if (typeof value !== 'boolean') {
+		throw new Error(`Expected ${path} to be a boolean.`);
+	}
+
+	return value;
+}
+
+function optionalRecord(value, path) {
+	if (value === undefined || value === null) {
+		return undefined;
+	}
+
+	return expectRecord(value, path);
+}
+
+function stringArray(value, path) {
+	if (value === undefined || value === null) {
+		return [];
+	}
+
+	if (!Array.isArray(value)) {
+		throw new Error(`Expected ${path} to be an array.`);
+	}
+
+	return value.map((entry, index) => expectString(entry, `${path}[${index}]`));
+}
+
+function parseMenuGroups(value, path) {
+	if (!Array.isArray(value)) {
+		throw new Error(`Expected ${path} to be an array.`);
+	}
+
+	return value.map((group, groupIndex) => {
+		const parsedGroup = expectRecord(group, `${path}[${groupIndex}]`);
+		const items = parsedGroup.items;
+		if (!Array.isArray(items) || items.length === 0) {
+			throw new Error(`Expected ${path}[${groupIndex}].items to contain at least one menu item.`);
+		}
+
+		return {
+			label: expectString(parsedGroup.label, `${path}[${groupIndex}].label`),
+			items: items.map((item, itemIndex) => {
+				const parsedItem = expectRecord(item, `${path}[${groupIndex}].items[${itemIndex}]`);
+				return {
+					label: expectString(parsedItem.label, `${path}[${groupIndex}].items[${itemIndex}].label`),
+					href: expectString(parsedItem.href, `${path}[${groupIndex}].items[${itemIndex}].href`),
+				};
+			}),
+		};
+	});
+}
+
+function parseContactRouting(value, path) {
+	const parsedValue = expectRecord(value ?? {}, path);
+	const keys = ['default', 'question', 'feedback', 'collaboration', 'issue'];
+
+	return Object.fromEntries(
+		keys.flatMap((key) => {
+			if (!(key in parsedValue)) {
+				return [];
+			}
+
+			return [[key, stringArray(parsedValue[key], `${path}.${key}`)]];
+		}),
+	);
+}
+
+function parseTheme(value, path) {
+	const theme = optionalRecord(value, path);
+	if (!theme) {
+		return undefined;
+	}
+
+	const surfaces = optionalRecord(theme.surfaces, `${path}.surfaces`);
+	const text = optionalRecord(theme.text, `${path}.text`);
+	const border = optionalRecord(theme.border, `${path}.border`);
+	const accent = optionalRecord(theme.accent, `${path}.accent`);
+	const info = optionalRecord(theme.info, `${path}.info`);
+	const warm = optionalRecord(theme.warm, `${path}.warm`);
+
+	return {
+		surfaces: surfaces
+			? {
+				background: optionalString(surfaces.background, `${path}.surfaces.background`),
+				backgroundElevated: optionalString(
+					surfaces.backgroundElevated,
+					`${path}.surfaces.backgroundElevated`,
+				),
+				backgroundSoft: optionalString(surfaces.backgroundSoft, `${path}.surfaces.backgroundSoft`),
+				panel: optionalString(surfaces.panel, `${path}.surfaces.panel`),
+				panelStrong: optionalString(surfaces.panelStrong, `${path}.surfaces.panelStrong`),
+			}
+			: undefined,
+		text: text
+			? {
+				body: optionalString(text.body, `${path}.text.body`),
+				muted: optionalString(text.muted, `${path}.text.muted`),
+				soft: optionalString(text.soft, `${path}.text.soft`),
+			}
+			: undefined,
+		border: border
+			? {
+				base: optionalString(border.base, `${path}.border.base`),
+				strong: optionalString(border.strong, `${path}.border.strong`),
+				grid: optionalString(border.grid, `${path}.border.grid`),
+			}
+			: undefined,
+		accent: accent
+			? {
+				base: optionalString(accent.base, `${path}.accent.base`),
+				strong: optionalString(accent.strong, `${path}.accent.strong`),
+				soft: optionalString(accent.soft, `${path}.accent.soft`),
+			}
+			: undefined,
+		info: info
+			? {
+				base: optionalString(info.base, `${path}.info.base`),
+				strong: optionalString(info.strong, `${path}.info.strong`),
+				soft: optionalString(info.soft, `${path}.info.soft`),
+			}
+			: undefined,
+		warm: warm
+			? {
+				base: optionalString(warm.base, `${path}.warm.base`),
+				strong: optionalString(warm.strong, `${path}.warm.strong`),
+			}
+			: undefined,
+	};
+}
+
+/** @type {TreeseedFieldAliasRegistry} */
+const siteFieldAliases = {
+	siteUrl: { key: 'siteUrl', aliases: ['site_url'] },
+	githubRepository: { key: 'githubRepository', aliases: ['github_repository'] },
+	discordLink: { key: 'discordLink', aliases: ['discord_link'] },
+	headerMenu: { key: 'headerMenu', aliases: ['header_menu'] },
+	footerMenu: { key: 'footerMenu', aliases: ['footer_menu'] },
+	emailNotifications: { key: 'emailNotifications', aliases: ['email_notifications'] },
+	projectStage: { key: 'projectStage', aliases: ['project_stage'] },
+	projectStageDetail: { key: 'projectStageDetail', aliases: ['project_stage_detail'] },
+};
+
+/** @type {TreeseedFieldAliasRegistry} */
+const pageDefaultsFieldAliases = {
+	pageLayout: { key: 'pageLayout', aliases: ['page_layout'] },
+};
+
+/** @type {TreeseedFieldAliasRegistry} */
+const agentDefaultsFieldAliases = {
+	runtimeStatus: { key: 'runtimeStatus', aliases: ['runtime_status'] },
+};
+
+/** @type {TreeseedFieldAliasRegistry} */
+const formsFieldAliases = {
+	apiBaseUrl: { key: 'apiBaseUrl', aliases: ['api_base_url'] },
+};
+
+/** @type {TreeseedFieldAliasRegistry} */
+const emailNotificationFieldAliases = {
+	contactRouting: { key: 'contactRouting', aliases: ['contact_routing'] },
+	subscribeRecipients: { key: 'subscribeRecipients', aliases: ['subscribe_recipients'] },
+};
+
+/**
+ * @param {string} source
+ */
+export function parseSiteConfig(source) {
+	const parsed = expectRecord(parseYaml(source), 'config');
+	const site = normalizeAliasedRecord(siteFieldAliases, expectRecord(parsed.site, 'site'));
+	const models = expectRecord(parsed.models ?? {}, 'models');
+	const pageModel = expectRecord(models.pages ?? {}, 'models.pages');
+	const noteModel = expectRecord(models.notes ?? {}, 'models.notes');
+	const questionModel = expectRecord(models.questions ?? {}, 'models.questions');
+	const objectiveModel = expectRecord(models.objectives ?? {}, 'models.objectives');
+	const peopleModel = expectRecord(models.people ?? {}, 'models.people');
+	const agentModel = expectRecord(models.agents ?? {}, 'models.agents');
+	const bookModel = expectRecord(models.books ?? {}, 'models.books');
+	const docsModel = expectRecord(models.docs ?? {}, 'models.docs');
+	const pageDefaults = normalizeAliasedRecord(pageDefaultsFieldAliases, expectRecord(pageModel.defaults ?? {}, 'models.pages.defaults'));
+	const noteDefaults = expectRecord(noteModel.defaults ?? {}, 'models.notes.defaults');
+	const questionDefaults = expectRecord(questionModel.defaults ?? {}, 'models.questions.defaults');
+	const objectiveDefaults = expectRecord(objectiveModel.defaults ?? {}, 'models.objectives.defaults');
+	const peopleDefaults = expectRecord(peopleModel.defaults ?? {}, 'models.people.defaults');
+	const agentDefaults = normalizeAliasedRecord(agentDefaultsFieldAliases, expectRecord(agentModel.defaults ?? {}, 'models.agents.defaults'));
+	const bookDefaults = expectRecord(bookModel.defaults ?? {}, 'models.books.defaults');
+	const docsDefaults = expectRecord(docsModel.defaults ?? {}, 'models.docs.defaults');
+	const logo = expectRecord(site.logo, 'site.logo');
+	const forms = normalizeAliasedRecord(formsFieldAliases, expectRecord(site.forms ?? {}, 'site.forms'));
+	const emailNotifications = normalizeAliasedRecord(
+		emailNotificationFieldAliases,
+		expectRecord(site.emailNotifications, 'site.emailNotifications'),
+	);
+
+	return {
+		site: {
+			logo: {
+				src: expectString(logo.src, 'site.logo.src'),
+				alt: expectString(logo.alt, 'site.logo.alt'),
+			},
+			name: expectString(site.name, 'site.name'),
+			statement: expectString(site.statement, 'site.statement'),
+			siteUrl: expectString(site.siteUrl, 'site.siteUrl'),
+			githubRepository: expectString(site.githubRepository, 'site.githubRepository'),
+			discordLink: expectString(site.discordLink, 'site.discordLink'),
+			headerMenu: parseMenuGroups(site.headerMenu, 'site.headerMenu'),
+			footerMenu: parseMenuGroups(site.footerMenu, 'site.footerMenu'),
+			forms: {
+				apiBaseUrl: optionalString(forms.apiBaseUrl, 'site.forms.apiBaseUrl'),
+			},
+			emailNotifications: {
+				contactRouting: parseContactRouting(
+					emailNotifications.contactRouting,
+					'site.emailNotifications.contactRouting',
+				),
+				subscribeRecipients: stringArray(
+					emailNotifications.subscribeRecipients,
+					'site.emailNotifications.subscribeRecipients',
+				),
+			},
+			summary: expectString(site.summary, 'site.summary'),
+			projectStage: expectString(site.projectStage, 'site.projectStage'),
+			projectStageDetail: expectString(site.projectStageDetail, 'site.projectStageDetail'),
+			theme: parseTheme(site.theme, 'site.theme'),
+		},
+		models: {
+			pages: {
+				defaults: {
+					pageLayout: optionalString(pageDefaults.pageLayout, 'models.pages.defaults.pageLayout'),
+					status: optionalString(pageDefaults.status, 'models.pages.defaults.status'),
+					stage: optionalString(pageDefaults.stage, 'models.pages.defaults.stage'),
+					audience: stringArray(pageDefaults.audience, 'models.pages.defaults.audience'),
+				},
+			},
+			notes: {
+				defaults: {
+					author: optionalString(noteDefaults.author, 'models.notes.defaults.author'),
+					draft: optionalBoolean(noteDefaults.draft, 'models.notes.defaults.draft'),
+					tags: stringArray(noteDefaults.tags, 'models.notes.defaults.tags'),
+					status: optionalString(noteDefaults.status, 'models.notes.defaults.status'),
+				},
+			},
+			questions: {
+				defaults: {
+					draft: optionalBoolean(questionDefaults.draft, 'models.questions.defaults.draft'),
+					tags: stringArray(questionDefaults.tags, 'models.questions.defaults.tags'),
+					status: optionalString(questionDefaults.status, 'models.questions.defaults.status'),
+				},
+			},
+			objectives: {
+				defaults: {
+					draft: optionalBoolean(objectiveDefaults.draft, 'models.objectives.defaults.draft'),
+					tags: stringArray(objectiveDefaults.tags, 'models.objectives.defaults.tags'),
+					status: optionalString(objectiveDefaults.status, 'models.objectives.defaults.status'),
+				},
+			},
+			people: {
+				defaults: {
+					status: optionalString(peopleDefaults.status, 'models.people.defaults.status'),
+					tags: stringArray(peopleDefaults.tags, 'models.people.defaults.tags'),
+				},
+			},
+			agents: {
+				defaults: {
+					tags: stringArray(agentDefaults.tags, 'models.agents.defaults.tags'),
+					runtimeStatus: optionalString(
+						agentDefaults.runtimeStatus,
+						'models.agents.defaults.runtimeStatus',
+					),
+				},
+			},
+			books: {
+				defaults: {
+					tags: stringArray(bookDefaults.tags, 'models.books.defaults.tags'),
+				},
+			},
+			docs: {
+				defaults: {
+					tags: stringArray(docsDefaults.tags, 'models.docs.defaults.tags'),
+				},
+			},
+		},
+	};
+}