@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/node/docs/presentations/docsReferencePage.presentation.js

@@ -0,0 +1,1090 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/registry-utils.ts
+var exports_registry_utils = {};
+__export(exports_registry_utils, {
+  groupByToArray: () => groupByToArray,
+  groupByMultiple: () => groupByMultiple,
+  groupBy: () => groupBy,
+  getUniqueTags: () => getUniqueTags,
+  getUniqueOwners: () => getUniqueOwners,
+  getUniqueDomains: () => getUniqueDomains,
+  filterBy: () => filterBy,
+  GroupingStrategies: () => GroupingStrategies
+});
+function filterBy(items, filter) {
+  return items.filter((item) => {
+    if (filter.tags?.length) {
+      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
+      if (!hasMatchingTag)
+        return false;
+    }
+    if (filter.owners?.length) {
+      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
+      if (!hasMatchingOwner)
+        return false;
+    }
+    if (filter.stability?.length) {
+      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
+        return false;
+      }
+    }
+    if (filter.domain) {
+      const itemDomain = GroupingStrategies.byDomain(item);
+      if (itemDomain !== filter.domain)
+        return false;
+    }
+    if (filter.keyPattern) {
+      const name = item.meta.key ?? item.meta.key ?? "";
+      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      if (!regex.test(name))
+        return false;
+    }
+    return true;
+  });
+}
+function groupBy(items, keyFn) {
+  const groups = new Map;
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+function groupByToArray(items, keyFn) {
+  const map = groupBy(items, keyFn);
+  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
+}
+function groupByMultiple(items, keysFn) {
+  const groups = new Map;
+  for (const item of items) {
+    const keys = keysFn(item);
+    for (const key of keys) {
+      const existing = groups.get(key);
+      if (existing) {
+        existing.push(item);
+      } else {
+        groups.set(key, [item]);
+      }
+    }
+  }
+  return groups;
+}
+function getUniqueTags(items) {
+  const tags = new Set;
+  for (const item of items) {
+    for (const tag of item.meta.tags ?? []) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
+function getUniqueOwners(items) {
+  const owners = new Set;
+  for (const item of items) {
+    for (const owner of item.meta.owners ?? []) {
+      owners.add(owner);
+    }
+  }
+  return Array.from(owners).sort();
+}
+function getUniqueDomains(items) {
+  const domains = new Set;
+  for (const item of items) {
+    domains.add(GroupingStrategies.byDomain(item));
+  }
+  return Array.from(domains).sort();
+}
+var GroupingStrategies;
+var init_registry_utils = __esm(() => {
+  GroupingStrategies = {
+    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
+    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
+    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
+    byDomain: (item) => {
+      const name = item.meta.key ?? item.meta.key ?? "";
+      return name.split(".")[0] ?? "default";
+    },
+    byStability: (item) => item.meta.stability ?? "stable",
+    byUrlPath: (level) => (item) => {
+      if (!item.path)
+        return "root";
+      const segments = item.path.split("/").filter(Boolean);
+      return segments.slice(0, level).join("/") || "root";
+    }
+  };
+});
+
+// src/ownership.ts
+var StabilityEnum = {
+  Idea: "idea",
+  InCreation: "in_creation",
+  Experimental: "experimental",
+  Beta: "beta",
+  Stable: "stable",
+  Deprecated: "deprecated"
+};
+var OwnersEnum = {
+  PlatformCore: "platform.core",
+  PlatformSigil: "platform.sigil",
+  PlatformMarketplace: "platform.marketplace",
+  PlatformMessaging: "platform.messaging",
+  PlatformContent: "platform.content",
+  PlatformFeatureFlags: "platform.featureflags",
+  PlatformFinance: "platform.finance"
+};
+var Owners = OwnersEnum;
+var TagsEnum = {
+  Spots: "spots",
+  Collectivity: "collectivity",
+  Marketplace: "marketplace",
+  Sellers: "sellers",
+  Auth: "auth",
+  Login: "login",
+  Signup: "signup",
+  Guide: "guide",
+  Docs: "docs",
+  I18n: "i18n",
+  Incident: "incident",
+  Automation: "automation",
+  Hygiene: "hygiene"
+};
+var Tags = TagsEnum;
+
+// src/registry.ts
+init_registry_utils();
+import { compareVersions } from "compare-versions";
+var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
+
+class SpecContractRegistry {
+  contractType;
+  items = new Map;
+  constructor(contractType, items) {
+    this.contractType = contractType;
+    if (items) {
+      items.forEach((p) => this.register(p));
+    }
+  }
+  register(p) {
+    const key = keyOfSpecContract(p);
+    if (this.items.has(key))
+      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
+    this.items.set(key, p);
+    return this;
+  }
+  count() {
+    return this.items.size;
+  }
+  list() {
+    return [...this.items.values()];
+  }
+  get(key, version) {
+    if (version != null)
+      return this.items.get(`${key}.v${version}`);
+    let candidate;
+    for (const [k, p] of this.items.entries()) {
+      if (!k.startsWith(`${key}.v`))
+        continue;
+      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
+        candidate = p;
+      }
+    }
+    return candidate;
+  }
+  has(key, version) {
+    return !!this.get(key, version);
+  }
+  filter(criteria) {
+    return filterBy(this.list(), criteria);
+  }
+  listByTag(tag) {
+    return this.list().filter((p) => p.meta.tags?.includes(tag));
+  }
+  listByOwner(owner) {
+    return this.list().filter((p) => p.meta.owners?.includes(owner));
+  }
+  groupBy(keyFn) {
+    return groupBy(this.list(), keyFn);
+  }
+  getUniqueTags() {
+    return getUniqueTags(this.list());
+  }
+}
+
+// src/docs/presentations.ts
+var DEFAULT_TARGETS = [
+  "markdown",
+  "react"
+];
+function normalizeRoute(route) {
+  if (!route.length)
+    return "/";
+  const withLeading = route.startsWith("/") ? route : `/${route}`;
+  return withLeading === "/" ? "/" : withLeading.replace(/\/+$/, "");
+}
+function deriveRoute(block, routePrefix) {
+  if (block.route)
+    return normalizeRoute(block.route);
+  const prefix = routePrefix ?? "/docs";
+  const slug = block.id.replace(/^docs\.?/, "").replace(/\./g, "/").replace(/\/+/g, "/");
+  const path = slug.startsWith("/") ? slug : `${prefix}/${slug}`;
+  return normalizeRoute(path);
+}
+function buildName(block, namespace) {
+  return namespace ? `${namespace}.${block.id}` : block.id;
+}
+function docBlockToPresentationSpec(block, options) {
+  const targets = options?.defaultTargets ?? DEFAULT_TARGETS;
+  const version = block.version ?? options?.defaultVersion ?? "1.0.0";
+  const stability = block.stability ?? options?.defaultStability ?? "stable";
+  return {
+    meta: {
+      key: buildName(block, options?.namespace),
+      title: block.title,
+      version,
+      description: block.summary ?? block.title,
+      tags: block.tags || [],
+      owners: block.owners || [],
+      domain: block.domain || "",
+      stability,
+      goal: `Documentation of: ${block.summary}`,
+      context: `Auto-generated`
+    },
+    policy: block.visibility && block.visibility !== "public" ? { flags: [block.visibility] } : undefined,
+    source: {
+      type: "blocknotejs",
+      docJson: block.body
+    },
+    targets
+  };
+}
+function docBlocksToPresentationRoutes(blocks, options) {
+  return blocks.map((block) => ({
+    block,
+    route: deriveRoute(block, options?.routePrefix),
+    descriptor: docBlockToPresentationSpec(block, options)
+  }));
+}
+function docBlocksToPresentationSpecs(blocks, options) {
+  return blocks.map((block) => docBlockToPresentationSpec(block, options));
+}
+function mapDocRoutes(routes) {
+  return routes.map(({ route, descriptor }) => [route, descriptor]);
+}
+
+// src/docs/registry.ts
+class DocRegistry {
+  routes = new Map;
+  constructor(blocks = [], options) {
+    blocks.forEach((block) => this.register(block, options));
+  }
+  register(block, options) {
+    const [route] = docBlocksToPresentationRoutes([block], options);
+    if (route) {
+      this.routes.set(block.id, route);
+    }
+    return this;
+  }
+  list() {
+    return [...this.routes.values()];
+  }
+  get(id) {
+    return this.routes.get(id);
+  }
+  toRouteTuples() {
+    return this.list().map(({ route, descriptor }) => [route, descriptor]);
+  }
+  toPresentationSpecs(options) {
+    return this.list().map(({ block }) => docBlockToPresentationSpec(block, options));
+  }
+}
+var requiredFields = [
+  "id",
+  "title",
+  "body",
+  "kind",
+  "visibility",
+  "route"
+];
+var defaultDocRegistry = new DocRegistry;
+function registerDocBlocks(blocks) {
+  for (const block of blocks) {
+    for (const field of requiredFields) {
+      if (!block[field]) {
+        throw new Error(`DocBlock ${block.id ?? "<missing id>"} missing field ${String(field)}`);
+      }
+    }
+    defaultDocRegistry.register(block);
+  }
+}
+function listRegisteredDocBlocks() {
+  return defaultDocRegistry.list().map((r) => r.block);
+}
+function docId(id) {
+  const found = defaultDocRegistry.get(id);
+  if (!found)
+    throw new Error(`DocBlock not registered: ${id}`);
+  return id;
+}
+
+// src/schema-to-markdown.ts
+import { isSchemaModel } from "@contractspec/lib.schema";
+function schemaToMarkdown(schema, data, options = {}) {
+  const { format = "auto", title, description, maxDepth = 2 } = options;
+  const lines = [];
+  if (title) {
+    lines.push(`# ${title}`, "");
+  }
+  if (description) {
+    lines.push(`> ${description}`, "");
+  }
+  const effectiveFormat = format === "auto" ? Array.isArray(data) ? "table" : "detail" : format;
+  if (effectiveFormat === "table" && Array.isArray(data)) {
+    lines.push(schemaToMarkdownTable(schema, data, options));
+  } else if (effectiveFormat === "list" && Array.isArray(data)) {
+    lines.push(schemaToMarkdownList(schema, data, options));
+  } else if (!Array.isArray(data) && data !== null && typeof data === "object") {
+    lines.push(schemaToMarkdownDetail(schema, data, { ...options, maxDepth }));
+  } else {
+    lines.push(`**Data:** ${String(data)}`, "");
+  }
+  return lines.join(`
+`);
+}
+function schemaToMarkdownTable(schema, items, options = {}) {
+  const { maxItems = 100, includeFields, excludeFields = [] } = options;
+  const fields = getFieldMeta(schema, includeFields, excludeFields);
+  if (fields.length === 0 || items.length === 0) {
+    return `_No data available_
+`;
+  }
+  const limitedItems = items.slice(0, maxItems);
+  const lines = [];
+  const headers = fields.map((f) => f.label);
+  lines.push(`| ${headers.join(" | ")} |`);
+  lines.push(`| ${headers.map(() => "---").join(" | ")} |`);
+  for (const item of limitedItems) {
+    const row = fields.map((f) => formatCellValue(getFieldValue(item, f.name)));
+    lines.push(`| ${row.join(" | ")} |`);
+  }
+  if (items.length > maxItems) {
+    lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function schemaToMarkdownList(schema, items, options = {}) {
+  const {
+    maxItems = 50,
+    summaryFields,
+    includeFields,
+    excludeFields = []
+  } = options;
+  const fields = getFieldMeta(schema, includeFields, excludeFields);
+  const displayFields = summaryFields ? fields.filter((f) => summaryFields.includes(f.name)) : fields.slice(0, 3);
+  if (displayFields.length === 0 || items.length === 0) {
+    return `_No data available_
+`;
+  }
+  const limitedItems = items.slice(0, maxItems);
+  const lines = [];
+  for (const item of limitedItems) {
+    const primaryValue = formatCellValue(getFieldValue(item, displayFields[0]?.name ?? "id"));
+    const secondaryValues = displayFields.slice(1).map((f) => `${f.label}: ${formatCellValue(getFieldValue(item, f.name))}`).join(" · ");
+    const itemLine = secondaryValues ? `- **${primaryValue}** (${secondaryValues})` : `- **${primaryValue}**`;
+    lines.push(itemLine);
+  }
+  if (items.length > maxItems) {
+    lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function schemaToMarkdownDetail(schema, item, options = {}) {
+  const { includeFields, excludeFields = [], maxDepth = 2 } = options;
+  if (item === null || typeof item !== "object") {
+    return `_No data available_
+`;
+  }
+  const fields = getFieldMeta(schema, includeFields, excludeFields);
+  if (fields.length === 0) {
+    return `_No fields to display_
+`;
+  }
+  const lines = [];
+  for (const field of fields) {
+    const value = getFieldValue(item, field.name);
+    const formattedValue = formatDetailValue(value, maxDepth, 0);
+    lines.push(`**${field.label}:** ${formattedValue}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function schemaToMarkdownSummary(items, options = {}) {
+  const { numericFields = [], countByField } = options;
+  const lines = [];
+  lines.push(`**Total Items:** ${items.length}`);
+  for (const fieldName of numericFields) {
+    const values = items.map((item) => getFieldValue(item, fieldName)).filter((v) => typeof v === "number");
+    if (values.length > 0) {
+      const sum = values.reduce((a, b) => a + b, 0);
+      const avg = sum / values.length;
+      const min = Math.min(...values);
+      const max = Math.max(...values);
+      lines.push(`**${formatFieldName(fieldName)}:** Sum: ${formatNumber(sum)}, Avg: ${formatNumber(avg)}, Min: ${formatNumber(min)}, Max: ${formatNumber(max)}`);
+    }
+  }
+  if (countByField) {
+    const counts = {};
+    for (const item of items) {
+      const value = String(getFieldValue(item, countByField) ?? "Unknown");
+      counts[value] = (counts[value] ?? 0) + 1;
+    }
+    lines.push("", `**By ${formatFieldName(countByField)}:**`);
+    for (const [value, count] of Object.entries(counts)) {
+      lines.push(`- ${value}: ${count}`);
+    }
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function getFieldMeta(schema, includeFields, excludeFields = []) {
+  if (!isSchemaModel(schema)) {
+    return [];
+  }
+  const schemaFields = schema.config.fields;
+  const fieldNames = Object.keys(schemaFields);
+  const filteredFields = fieldNames.filter((name) => {
+    if (excludeFields.includes(name))
+      return false;
+    if (includeFields && !includeFields.includes(name))
+      return false;
+    return true;
+  });
+  return filteredFields.map((name) => {
+    const fieldConfig = schemaFields[name];
+    const isNested = Boolean(fieldConfig?.type && typeof fieldConfig.type === "object" && "config" in fieldConfig.type && typeof fieldConfig.type.config?.fields === "object");
+    return {
+      name,
+      label: formatFieldName(name),
+      isOptional: fieldConfig?.isOptional ?? false,
+      isArray: fieldConfig?.isArray === true,
+      isNested
+    };
+  });
+}
+function getFieldValue(item, fieldName) {
+  if (item === null || typeof item !== "object")
+    return;
+  const obj = item;
+  if (fieldName.includes(".")) {
+    const parts = fieldName.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || typeof current !== "object")
+        return;
+      current = current[part];
+    }
+    return current;
+  }
+  return obj[fieldName];
+}
+function formatCellValue(value) {
+  if (value === null || value === undefined)
+    return "-";
+  if (typeof value === "boolean")
+    return value ? "✓" : "✗";
+  if (typeof value === "number")
+    return formatNumber(value);
+  if (value instanceof Date)
+    return formatDate(value);
+  if (typeof value === "string" && isISODate(value))
+    return formatDate(new Date(value));
+  if (Array.isArray(value))
+    return `[${value.length} items]`;
+  if (typeof value === "object")
+    return "[Object]";
+  const str = String(value);
+  return str.length > 50 ? `${str.slice(0, 47)}...` : str.replace(/\|/g, "\\|");
+}
+function formatDetailValue(value, maxDepth, currentDepth) {
+  if (value === null || value === undefined)
+    return "_none_";
+  if (typeof value === "boolean")
+    return value ? "Yes" : "No";
+  if (typeof value === "number")
+    return formatNumber(value);
+  if (value instanceof Date)
+    return formatDate(value);
+  if (typeof value === "string" && isISODate(value))
+    return formatDate(new Date(value));
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "_empty list_";
+    if (currentDepth >= maxDepth)
+      return `[${value.length} items]`;
+    if (value.length <= 5 && value.every((v) => typeof v !== "object")) {
+      return value.map((v) => formatCellValue(v)).join(", ");
+    }
+    return `[${value.length} items]`;
+  }
+  if (typeof value === "object") {
+    if (currentDepth >= maxDepth)
+      return "[Object]";
+    const keys = Object.keys(value);
+    return `{${keys.length} fields}`;
+  }
+  return String(value);
+}
+function formatFieldName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+}
+function formatNumber(value) {
+  if (Math.abs(value) >= 1000) {
+    return new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: 2
+    }).format(value);
+  }
+  if (Number.isInteger(value)) {
+    return String(value);
+  }
+  return value.toFixed(2);
+}
+function formatDate(date) {
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function isISODate(str) {
+  if (!/^\d{4}-\d{2}-\d{2}/.test(str))
+    return false;
+  const date = new Date(str);
+  return !isNaN(date.getTime());
+}
+
+// src/presentations/transform-engine.ts
+import React from "react";
+import TurndownService from "turndown";
+var turndown = new TurndownService;
+function renderTextNode(node) {
+  const text = node.text ?? "";
+  if (!node.marks || node.marks.length === 0)
+    return text;
+  return node.marks.reduce((acc, mark) => {
+    switch (mark.type) {
+      case "bold":
+        return `**${acc}**`;
+      case "italic":
+        return `*${acc}*`;
+      case "underline":
+        return `__${acc}__`;
+      case "strike":
+        return `~~${acc}~~`;
+      case "code":
+        return `\`${acc}\``;
+      case "link": {
+        const href = mark.attrs?.href ?? "";
+        return href ? `[${acc}](${href})` : acc;
+      }
+      default:
+        return acc;
+    }
+  }, text);
+}
+function renderInline(nodes) {
+  if (!nodes?.length)
+    return "";
+  return nodes.map((child) => renderNode(child)).join("");
+}
+function renderList(nodes, ordered = false) {
+  if (!nodes?.length)
+    return "";
+  let counter = 1;
+  return nodes.map((item) => {
+    const body = renderInline(item.content ?? []);
+    if (!body)
+      return "";
+    const prefix = ordered ? `${counter++}. ` : "- ";
+    return `${prefix}${body}`;
+  }).filter(Boolean).join(`
+`);
+}
+function renderNode(node) {
+  switch (node.type) {
+    case "doc":
+      return renderInline(node.content);
+    case "paragraph": {
+      const text = renderInline(node.content);
+      return text.trim().length ? text : "";
+    }
+    case "heading": {
+      const levelAttr = node.attrs?.level;
+      const levelVal = typeof levelAttr === "number" ? levelAttr : 1;
+      const level = Math.min(Math.max(levelVal, 1), 6);
+      return `${"#".repeat(level)} ${renderInline(node.content)}`.trim();
+    }
+    case "bullet_list":
+      return renderList(node.content, false);
+    case "ordered_list":
+      return renderList(node.content, true);
+    case "list_item":
+      return renderInline(node.content);
+    case "blockquote": {
+      const body = renderInline(node.content);
+      return body.split(`
+`).map((line) => `> ${line}`).join(`
+`);
+    }
+    case "code_block": {
+      const body = renderInline(node.content);
+      return body ? `\`\`\`
+${body}
+\`\`\`` : "";
+    }
+    case "horizontal_rule":
+      return "---";
+    case "hard_break":
+      return `
+`;
+    case "text":
+      return renderTextNode(node);
+    default:
+      if (node.text)
+        return renderTextNode(node);
+      return "";
+  }
+}
+function blockNoteToMarkdown(docJson) {
+  if (typeof docJson === "string")
+    return docJson;
+  if (docJson && typeof docJson === "object" && "html" in docJson) {
+    const html = String(docJson.html);
+    return turndown.turndown(html);
+  }
+  const root = docJson;
+  if (root?.type === "doc" || root?.content) {
+    const blocks = (root.content ?? []).map((n) => renderNode(n)).filter(Boolean);
+    return blocks.join(`
+
+`).trim();
+  }
+  try {
+    return JSON.stringify(docJson, null, 2);
+  } catch {
+    return String(docJson);
+  }
+}
+
+class TransformEngine {
+  renderers = new Map;
+  validators = [];
+  register(renderer) {
+    const arr = this.renderers.get(renderer.target) ?? [];
+    arr.push(renderer);
+    this.renderers.set(renderer.target, arr);
+    return this;
+  }
+  prependRegister(renderer) {
+    const arr = this.renderers.get(renderer.target) ?? [];
+    arr.unshift(renderer);
+    this.renderers.set(renderer.target, arr);
+    return this;
+  }
+  addValidator(v) {
+    this.validators.push(v);
+    return this;
+  }
+  async render(target, desc, ctx) {
+    if (!desc.targets.includes(target))
+      throw new Error(`Target ${target} not declared for ${desc.meta.key}.v${desc.meta.version}`);
+    for (const v of this.validators)
+      await v.validate(desc, target, ctx);
+    const arr = this.renderers.get(target) ?? [];
+    for (const r of arr) {
+      try {
+        const out = await r.render(desc, ctx);
+        return out;
+      } catch (_e) {}
+    }
+    throw new Error(`No renderer available for ${target}`);
+  }
+}
+function createDefaultTransformEngine() {
+  const engine = new TransformEngine;
+  const applyPii = (desc, obj) => {
+    const clone = JSON.parse(JSON.stringify(obj));
+    const paths = desc.policy?.pii ?? [];
+    const setAtPath = (root, path) => {
+      const segs = path.replace(/^\//, "").replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+      let cur = root;
+      for (let i = 0;i < segs.length - 1; i++) {
+        const k = segs[i];
+        if (!k)
+          continue;
+        if (cur && typeof cur === "object" && k in cur) {
+          cur = cur[k];
+        } else
+          return;
+      }
+      const last = segs[segs.length - 1];
+      if (cur && typeof cur === "object" && last && last in cur)
+        cur[last] = "[REDACTED]";
+    };
+    for (const p of paths)
+      setAtPath(clone, p);
+    return clone;
+  };
+  engine.register({
+    target: "markdown",
+    async render(desc, ctx) {
+      let data = ctx?.data;
+      if (!data && ctx?.fetchData) {
+        data = await ctx.fetchData();
+      }
+      if (desc.source.type === "component" && desc.source.props && data !== undefined) {
+        const isArray = Array.isArray(data);
+        const isSimpleObject = !isArray && typeof data === "object" && data !== null && !Object.values(data).some((v) => Array.isArray(v) || typeof v === "object" && v !== null);
+        if (isArray || isSimpleObject) {
+          const body = schemaToMarkdown(desc.source.props, data, {
+            title: desc.meta.description ?? desc.meta.key,
+            description: `${desc.meta.key} v${desc.meta.version}`
+          });
+          return { mimeType: "text/markdown", body };
+        }
+        throw new Error(`Complex data structure for ${desc.meta.key} - expecting custom renderer`);
+      }
+      if (desc.source.type === "blocknotejs") {
+        const markdown = blockNoteToMarkdown(desc.source.docJson);
+        const redacted = applyPii(desc, { text: markdown });
+        return { mimeType: "text/markdown", body: String(redacted.text) };
+      }
+      if (desc.source.type === "component" && data !== undefined) {
+        throw new Error(`No schema (source.props) available for ${desc.meta.key} - expecting custom renderer`);
+      }
+      if (desc.source.type === "component") {
+        const header = `# ${desc.meta.key} v${desc.meta.version}`;
+        const about = desc.meta.description ? `
+
+${desc.meta.description}` : "";
+        const tags = desc.meta.tags && desc.meta.tags.length ? `
+
+Tags: ${desc.meta.tags.join(", ")}` : "";
+        const owners = desc.meta.owners && desc.meta.owners.length ? `
+
+Owners: ${desc.meta.owners.join(", ")}` : "";
+        const comp = `
+
+Component: \`${desc.source.componentKey}\``;
+        const policy = desc.policy?.pii?.length ? `
+
+Redacted paths: ${desc.policy.pii.map((p) => `\`${p}\``).join(", ")}` : "";
+        const body = `${header}${about}${tags}${owners}${comp}${policy}`;
+        return { mimeType: "text/markdown", body };
+      }
+      throw new Error("unsupported");
+    }
+  });
+  engine.register({
+    target: "application/json",
+    async render(desc) {
+      const payload = applyPii(desc, { meta: desc.meta, source: desc.source });
+      return {
+        mimeType: "application/json",
+        body: JSON.stringify(payload, null, 2)
+      };
+    }
+  });
+  engine.register({
+    target: "application/xml",
+    async render(desc) {
+      const json = applyPii(desc, { meta: desc.meta, source: desc.source });
+      const body = `<presentation name="${desc.meta.key}" version="${desc.meta.version}"><json>${encodeURIComponent(JSON.stringify(json))}</json></presentation>`;
+      return { mimeType: "application/xml", body };
+    }
+  });
+  return engine;
+}
+function registerDefaultReactRenderer(engine) {
+  engine.register({
+    target: "react",
+    async render(desc) {
+      if (desc.source.type === "component") {
+        const props = desc.source.props ? desc.source.props.getZod().safeParse({}).success ? {} : undefined : undefined;
+        return {
+          kind: "react_component",
+          componentKey: desc.source.componentKey,
+          props
+        };
+      }
+      return {
+        kind: "blocknotejs",
+        docJson: desc.source.docJson,
+        blockConfig: desc.source.blockConfig
+      };
+    }
+  });
+  return engine;
+}
+function registerBasicValidation(engine) {
+  engine.addValidator({
+    validate(desc) {
+      if (!desc.meta.description || desc.meta.description.length < 3)
+        throw new Error(`Presentation ${desc.meta.key}.v${desc.meta.version} missing meta.description`);
+    }
+  });
+  return engine;
+}
+function registerReactToMarkdownRenderer(engine, componentMap) {
+  const turndownService = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-"
+  });
+  turndownService.addRule("link", {
+    filter: "a",
+    replacement: (content, node) => {
+      const href = node.href;
+      if (href && content) {
+        return `[${content}](${href})`;
+      }
+      return content || "";
+    }
+  });
+  engine.prependRegister({
+    target: "markdown",
+    async render(desc, _ctx) {
+      if (desc.source.type !== "component") {
+        throw new Error("React-to-markdown renderer only handles component presentations");
+      }
+      const { renderToStaticMarkup } = await import("react-dom/server");
+      const Component = componentMap[desc.source.componentKey];
+      if (!Component) {
+        throw new Error(`Component ${desc.source.componentKey} not found in componentMap`);
+      }
+      let html;
+      try {
+        const element = React.createElement(Component, desc.source.props ? {} : undefined);
+        html = renderToStaticMarkup(element);
+      } catch (error) {
+        throw new Error(`Failed to render component ${desc.source.componentKey}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      let markdown;
+      try {
+        markdown = turndownService.turndown(html);
+      } catch (error) {
+        throw new Error(`Failed to convert HTML to markdown: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+      if (desc.policy?.pii && desc.policy.pii.length > 0) {
+        const redacted = markdown.replace(/\[REDACTED\]/g, "[REDACTED]");
+        return { mimeType: "text/markdown", body: redacted };
+      }
+      return { mimeType: "text/markdown", body: markdown };
+    }
+  });
+  return engine;
+}
+
+// src/presentations/presentations.ts
+var definePresentation = (spec) => {
+  return spec;
+};
+
+// src/presentations/registry.ts
+class PresentationRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("presentation", items);
+  }
+}
+// src/docs/constants.ts
+var DOCS_DOMAIN = "docs";
+var DOCS_OWNERS = ["docs-platform"];
+var DOCS_TAGS = ["docs", "documentation"];
+var DOCS_STABILITY = StabilityEnum.Experimental;
+
+// src/docs/tech/docs-system.docblock.ts
+var docsSystemDocBlocks = [
+  {
+    id: "docs.tech.docs-system",
+    title: "Docs system overview",
+    summary: "How ContractSpec generates, indexes, and presents documentation.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/tech/docs/system",
+    tags: ["docs", "system", "contracts"],
+    body: `# Docs system overview
+
+ContractSpec treats documentation as a first-class output of your specs. The docs system combines:
+
+- Contract operations and schemas
+- DocBlocks (goal/how/usage/reference)
+- Presentations for rendering
+
+The result is a consistent docs surface across CLI, web, and MCP.
+
+## Key surfaces
+
+- Generation: \`docs.generate\`
+- Index/search: \`docs.search\`
+- Contract reference: \`docs.contract.reference\`
+- Publish: \`docs.publish\`
+`
+  },
+  {
+    id: "docs.tech.docs-generator",
+    title: "Docs generator",
+    summary: "Generate reference docs and metadata from ContractSpecs.",
+    kind: "how",
+    visibility: "public",
+    route: "/docs/tech/docs/generator",
+    tags: ["docs", "generator", "cli"],
+    body: `# Docs generator
+
+The generator produces documentation artifacts from registered ContractSpecs and DocBlocks.
+
+## Outputs
+
+- Reference pages for operations, events, forms, data views, and presentations
+- Search index metadata (DocBlocks + routes)
+- Contract schemas rendered to markdown or JSON
+`
+  },
+  {
+    id: "docs.tech.docs-search",
+    title: "Docs index and search",
+    summary: "Search DocBlocks by query, tag, kind, or visibility.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/tech/docs/search",
+    tags: ["docs", "search"],
+    body: `# Docs index and search
+
+The docs index is the canonical list of DocBlocks exposed to UI and MCP surfaces.
+
+## Query
+
+- Operation: \`docs.search\`
+- Filters: query, tag, kind, visibility
+`
+  },
+  {
+    id: "docs.tech.docs-reference",
+    title: "Contract reference pages",
+    summary: "Resolve any spec into a docs-ready reference payload.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/tech/docs/reference",
+    tags: ["docs", "reference"],
+    body: `# Contract reference
+
+Contract reference pages are generated from spec metadata plus schema details.
+
+## Query
+
+- Operation: \`docs.contract.reference\`
+`
+  },
+  {
+    id: "docs.tech.docs-publish",
+    title: "Docs publish",
+    summary: "Publish generated artifacts to the docs host.",
+    kind: "how",
+    visibility: "public",
+    route: "/docs/tech/docs/publish",
+    tags: ["docs", "publish"],
+    body: `# Docs publish
+
+Publishing moves generated artifacts to a hosting target with versioning.
+
+## Command
+
+- Operation: \`docs.publish\`
+`
+  },
+  {
+    id: "docs.tech.docs-examples",
+    title: "Examples catalog",
+    summary: "Document and surface example projects with sandbox support.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/tech/docs/examples",
+    tags: ["docs", "examples"],
+    body: `# Examples catalog
+
+Examples are registered as ExampleSpecs and surface DocBlocks for discovery.
+
+- Docs index tags should include \`examples\` to populate the catalog.
+- Sandbox support is available under \`/sandbox\`.
+`
+  }
+];
+registerDocBlocks(docsSystemDocBlocks);
+// src/docs/presentations/docsReferencePage.presentation.ts
+var DocsReferencePagePresentation = definePresentation({
+  meta: {
+    key: "docs.reference.page",
+    title: "Docs Reference Page",
+    version: "1.0.0",
+    description: "Reference page layout for contract documentation.",
+    goal: "Render contract references with consistent metadata and formatting.",
+    context: "Used by docs surfaces to present contract reference content and schemas.",
+    domain: DOCS_DOMAIN,
+    owners: DOCS_OWNERS,
+    tags: [...DOCS_TAGS, "reference"],
+    stability: DOCS_STABILITY,
+    docId: [docId("docs.tech.docs-reference")]
+  },
+  capability: {
+    key: "docs.system",
+    version: "1.0.0"
+  },
+  source: {
+    type: "component",
+    framework: "react",
+    componentKey: "docsReferencePage"
+  },
+  targets: ["react", "markdown"]
+});
+export {
+  DocsReferencePagePresentation
+};