@mesh-tech/mesh-cli 0.35.2 → 0.37.0

package/dist/bin/mesh.preview-3IP34TDO.js

@@ -0,0 +1,2410 @@
+import {
+  DEFAULT_SANDBOX_MODE,
+  buildDocsSource,
+  docsImageUrl,
+  docsPage,
+  tryItAllows
+} from "./mesh.chunk-J6DVWKRW.js";
+import {
+  findPackageRoot
+} from "./mesh.chunk-MCBMHWXP.js";
+import {
+  logError,
+  logInfo,
+  logSuccess,
+  logWarn
+} from "./mesh.chunk-WFFDF346.js";
+import "./mesh.chunk-IQOBTL42.js";
+
+// packages/mesh-cli/src/docs/preview.ts
+import { createServer } from "node:http";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join as join2, relative, resolve as resolve2 } from "node:path";
+import * as React from "react";
+import { renderToString } from "react-dom/server";
+
+// packages/api-docs-engine/src/search.ts
+var FIELD_WEIGHTS = {
+  name: 3,
+  id: 3,
+  entity: 2,
+  service: 1,
+  description: 1
+};
+function splitIdentifierWords(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_\-./]+/g, " ").split(/\s+/).filter(Boolean);
+}
+function tokenizeIdentifier(s) {
+  return splitIdentifierWords(s).join(" ").toLowerCase();
+}
+function scoreRecord(fields, tokens) {
+  let score = 0;
+  Object.keys(FIELD_WEIGHTS).forEach((f) => {
+    const text = fields[f];
+    for (const t of tokens) if (text.includes(t)) score += FIELD_WEIGHTS[f];
+  });
+  if (tokens.every((t) => fields.name.includes(t))) score += 5;
+  else if (tokens.every((t) => fields.id.includes(t))) score += 4;
+  return score;
+}
+function searchRecords(records, query, filters) {
+  let pool = records;
+  if (filters?.entity) pool = pool.filter((r) => r.entry.entity === filters.entity);
+  if (filters?.capability) pool = pool.filter((r) => r.entry.capability === filters.capability);
+  if (filters?.service) pool = pool.filter((r) => r.entry.service === filters.service);
+  const q = query.trim().toLowerCase();
+  if (!q) return pool.map((r) => r.entry);
+  const tokens = [...new Set(q.split(/\s+/))].filter(Boolean);
+  return pool.map((r) => ({ entry: r.entry, score: scoreRecord(r.fields, tokens) })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id)).map((x) => x.entry);
+}
+
+// packages/api-docs-engine/src/entity.ts
+function deriveEntity(id) {
+  const [token] = splitIdentifierWords(id);
+  return token ?? id;
+}
+
+// packages/api-docs-engine/src/capability.ts
+var HEALTH = /health|heartbeat|readiness|liveness|(?:^|[^a-z])ping(?:$|[^a-z])/i;
+var VALIDATION = /validate|verify|eligib/i;
+var READ_VERB = /^(get|list|search|lookup|inquir|retrieve|fetch|find|query|read|view|export|download|show)/i;
+var READ_METHODS = /* @__PURE__ */ new Set(["get", "head"]);
+function deriveCapability(method, id) {
+  const m = method.toLowerCase();
+  if (HEALTH.test(id) || id.toLowerCase() === "status") return "health";
+  if (VALIDATION.test(id)) return "validation";
+  if (READ_METHODS.has(m)) return "read";
+  if (READ_VERB.test(id)) return "read";
+  return "mutation";
+}
+
+// packages/api-docs-engine/src/normalize.ts
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "trace"
+];
+function operationKey(op, method, route) {
+  const native = op["x-native-operation"];
+  if (typeof native === "string" && native) return native;
+  const oid = op.operationId;
+  if (typeof oid === "string" && oid) return oid;
+  return `${method.toUpperCase()} ${route}`;
+}
+function normalizeOps(doc, subset) {
+  const ops = [];
+  for (const [route, item] of Object.entries(doc.paths ?? {})) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    for (const method of HTTP_METHODS) {
+      const op = record[method];
+      if (!op || typeof op !== "object") continue;
+      const operation = op;
+      const id = operationKey(operation, method, route);
+      if (subset && !subset.has(id)) continue;
+      ops.push({ id, method, route, op: operation });
+    }
+  }
+  ops.sort((a, b) => a.id.localeCompare(b.id));
+  return ops;
+}
+
+// packages/api-docs-engine/src/index-build.ts
+function buildIndex(doc, subset) {
+  const entries = [];
+  for (const { id, method, route, op } of normalizeOps(doc, subset)) {
+    const domain = op["x-entity-domain"];
+    const tags = Array.isArray(op.tags) ? op.tags.filter((t) => typeof t === "string") : [];
+    entries.push({
+      id,
+      name: op.summary ?? id,
+      // Prefer the generator's curated group; fall back to the CamelCase token.
+      entity: op["x-entity-group"] ?? deriveEntity(id),
+      ...domain ? { domain } : {},
+      capability: op["x-capability-kind"] ?? deriveCapability(method, id),
+      service: op.tags?.[0] ?? "Other",
+      method,
+      route,
+      ...tags.length > 0 ? { tags } : {},
+      ...typeof op.summary === "string" ? { summary: op.summary } : {}
+    });
+  }
+  entries.sort((a, b) => a.id.localeCompare(b.id));
+  return entries;
+}
+
+// packages/api-docs-engine/src/schema-util.ts
+function refName(ref) {
+  return ref ? ref.replace(/^#\/components\/schemas\//, "") : void 0;
+}
+function refFromSchema(schema) {
+  if (!schema) return void 0;
+  if (typeof schema.$ref === "string") return schema.$ref;
+  for (const key of ["oneOf", "anyOf", "allOf"]) {
+    for (const branch of schema[key] ?? []) {
+      const ref = refFromSchema(branch);
+      if (ref) return ref;
+    }
+  }
+  return void 0;
+}
+function resolveRef(prop) {
+  if (prop.$ref) return refName(prop.$ref);
+  const allOfRef = prop.allOf?.find((s) => s.$ref)?.$ref;
+  if (allOfRef) return refName(allOfRef);
+  const unionRef = (prop.anyOf ?? prop.oneOf)?.find((s) => s.$ref)?.$ref;
+  if (unionRef) return refName(unionRef);
+  if (prop.items) {
+    if (prop.items.$ref) return refName(prop.items.$ref);
+    const itemsAllOfRef = prop.items.allOf?.find((s) => s.$ref)?.$ref;
+    if (itemsAllOfRef) return refName(itemsAllOfRef);
+  }
+  return void 0;
+}
+function isArray(prop) {
+  return prop.type === "array" || Array.isArray(prop.type) && prop.type.includes("array");
+}
+var PRIMITIVES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "array"]);
+function directType(prop) {
+  return Array.isArray(prop.type) ? prop.type.find((t) => t !== "null") : prop.type;
+}
+function primitiveType(prop) {
+  const direct = directType(prop);
+  if (direct && direct !== "object") return direct;
+  const union = prop.anyOf ?? prop.oneOf;
+  if (union) {
+    for (const member of union) {
+      const mt = directType(member);
+      if (mt && PRIMITIVES.has(mt)) return mt;
+      const inner = member.anyOf ?? member.oneOf;
+      if (inner) {
+        for (const m of inner) {
+          const it = directType(m);
+          if (it && PRIMITIVES.has(it)) return it;
+        }
+      }
+    }
+  }
+  if (direct === "object") return "object";
+  return void 0;
+}
+var MAX_ALLOF_HOPS = 8;
+function composesAllOf(schema) {
+  const members = Array.isArray(schema.allOf) ? schema.allOf : [];
+  return members.length > 1 || members.length > 0 && !!schema.properties;
+}
+function mergeAllOf(doc, schema) {
+  const properties = {};
+  const required = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const schemas = doc.components?.schemas ?? {};
+  const visit = (s, hops) => {
+    if (!s || typeof s !== "object" || hops > MAX_ALLOF_HOPS) return;
+    if (typeof s.$ref === "string") {
+      const name = refName(s.$ref);
+      if (seen.has(name) || !Object.hasOwn(schemas, name)) return;
+      seen.add(name);
+      visit(schemas[name], hops + 1);
+      return;
+    }
+    for (const member of Array.isArray(s.allOf) ? s.allOf : []) visit(member, hops + 1);
+    Object.assign(properties, s.properties ?? {});
+    for (const name of Array.isArray(s.required) ? s.required : []) required.add(name);
+  };
+  visit(schema, 0);
+  const { allOf: _allOf, $ref: _ref, ...rest } = schema;
+  return { ...rest, properties, ...required.size > 0 ? { required: [...required] } : {} };
+}
+
+// packages/api-docs-engine/src/fields.ts
+var NATIVE_PAREN = /\s*\(native:\s*([^)]+)\)\s*$/;
+var NATIVE_BARE = /^native:\s*(.+)$/;
+function parseDescription(raw) {
+  if (!raw) return {};
+  const paren = raw.match(NATIVE_PAREN);
+  if (paren) {
+    const description = raw.slice(0, paren.index ?? raw.length).trim();
+    return { nativeName: (paren[1] ?? "").trim() || void 0, description: description || void 0 };
+  }
+  const bare = raw.match(NATIVE_BARE);
+  if (bare) return { nativeName: (bare[1] ?? "").trim() || void 0 };
+  const trimmed = raw.trim();
+  return trimmed ? { description: trimmed } : {};
+}
+function descriptionOf(prop) {
+  if (prop.description) return prop.description;
+  return prop.allOf?.find((s) => s.description)?.description;
+}
+function typeLabel(prop, ref) {
+  if (ref) return isArray(prop) ? `${ref}[]` : ref;
+  return primitiveType(prop) ?? "unknown";
+}
+function isInlineObject(prop, ref) {
+  return !ref && !!prop.properties && Object.keys(prop.properties).length > 0;
+}
+var MAX_INLINE_DEPTH = 3;
+function resolveFields(schema, depth) {
+  if (!schema.properties) return [];
+  const required = new Set(schema.required ?? []);
+  return Object.entries(schema.properties).map(([name, prop]) => {
+    const ref = resolveRef(prop);
+    const { description, nativeName } = parseDescription(descriptionOf(prop));
+    const node = {
+      name,
+      nativeName,
+      type: typeLabel(prop, ref),
+      ref,
+      required: required.has(name),
+      deprecated: prop.deprecated === true,
+      description,
+      enumValues: prop.enum
+    };
+    if (prop.default !== void 0) node.defaultValue = String(prop.default);
+    const canonical = prop["x-canonical-values"];
+    if (Array.isArray(canonical)) {
+      node.canonicalValues = canonical;
+    }
+    if (isInlineObject(prop, ref) && depth < MAX_INLINE_DEPTH) {
+      node.children = resolveFields(prop, depth + 1);
+    }
+    return node;
+  });
+}
+function resolveComponentFields(doc, componentName) {
+  const comp = doc.components.schemas[componentName];
+  if (!comp) return [];
+  if (!comp.properties && isArray(comp)) {
+    const itemRef = resolveRef(comp);
+    const item = itemRef ? doc.components.schemas[itemRef] : comp.items;
+    if (item?.properties) return resolveFields(item, 0);
+  }
+  if (Array.isArray(comp.allOf) && comp.allOf.length > 0) return resolveFields(mergeAllOf(doc, comp), 0);
+  if (!comp.properties) return [];
+  return resolveFields(comp, 0);
+}
+function resolveSchemaFields(doc, schema) {
+  if (!schema) return [];
+  if (composesAllOf(schema)) return resolveFields(mergeAllOf(doc, schema), 0);
+  const ref = refName(refFromSchema(schema));
+  if (ref) return resolveComponentFields(doc, ref);
+  if (schema.properties) return resolveFields(schema, 0);
+  if (isArray(schema)) {
+    const itemRef = resolveRef(schema);
+    const item = itemRef ? doc.components.schemas[itemRef] : schema.items;
+    if (item?.properties) return resolveFields(item, 0);
+  }
+  return [];
+}
+
+// packages/api-docs-engine/src/sample.ts
+var MAX_REF_DEPTH = 1;
+var MAX_INLINE_DEPTH2 = 4;
+function placeholder(doc, prop, depth) {
+  const ref = resolveRef(prop);
+  if (ref) {
+    const nested = depth >= MAX_REF_DEPTH ? {} : synthFromComponent(doc, ref, depth + 1);
+    return isArray(prop) ? [nested] : nested;
+  }
+  if (prop.properties && Object.keys(prop.properties).length > 0) {
+    const nested = depth >= MAX_INLINE_DEPTH2 ? {} : synthFromSchema(doc, prop, depth + 1);
+    return isArray(prop) ? [nested] : nested;
+  }
+  if (prop.enum?.length) return prop.enum[0];
+  const t = primitiveType(prop);
+  switch (t) {
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    default:
+      return "string";
+  }
+}
+function schemaExample(schema) {
+  if (schema.example !== void 0) return schema.example;
+  const ex = schema.examples;
+  if (Array.isArray(ex) && ex.length > 0) return ex[0];
+  return void 0;
+}
+function synthFromSchema(doc, raw, depth) {
+  const example = schemaExample(raw);
+  if (example !== void 0) return example;
+  const schema = Array.isArray(raw.allOf) && raw.allOf.length > 0 ? mergeAllOf(doc, raw) : raw;
+  if (!schema.properties && isArray(schema) && schema.items) {
+    return [placeholder(doc, schema.items, depth)];
+  }
+  if (!schema.properties) return {};
+  const requiredList = schema.required ?? [];
+  const required = new Set(requiredList);
+  const includeAll = requiredList.length === 0;
+  const out = {};
+  for (const [name, prop] of Object.entries(schema.properties)) {
+    if (!includeAll && !required.has(name)) continue;
+    out[name] = placeholder(doc, prop, depth);
+  }
+  return out;
+}
+function synthFromComponent(doc, componentName, depth) {
+  const comp = doc.components.schemas[componentName];
+  if (!comp) return {};
+  return synthFromSchema(doc, comp, depth);
+}
+function synthesizeSample(doc, componentName, depth = 0) {
+  return synthFromComponent(doc, componentName, depth);
+}
+function synthesizeSchemaSample(doc, schema) {
+  if (composesAllOf(schema)) return synthFromSchema(doc, schema, 0);
+  const ref = refName(refFromSchema(schema));
+  if (ref) return synthFromComponent(doc, ref, 0);
+  return synthFromSchema(doc, schema, 0);
+}
+
+// packages/api-docs-engine/src/operation-detail.ts
+var MAX_SCHEMA_HOPS = 8;
+var PARAM_LOCATIONS = /* @__PURE__ */ new Set(["path", "query", "header", "cookie"]);
+function unescapePointer(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveComponent(doc, value, section) {
+  const prefix = `#/components/${section}/`;
+  const seen = /* @__PURE__ */ new Set();
+  let current = value;
+  while (current && typeof current === "object" && typeof current.$ref === "string") {
+    const ref = current.$ref;
+    if (seen.has(ref) || !ref.startsWith(prefix)) return void 0;
+    seen.add(ref);
+    const table = doc.components?.[section];
+    current = table?.[unescapePointer(ref.slice(prefix.length))];
+  }
+  return current && typeof current === "object" ? current : void 0;
+}
+function pickJsonMedia(content) {
+  if (!content) return void 0;
+  const exact = content["application/json"];
+  if (exact) return { contentType: "application/json", media: exact };
+  for (const [contentType, media] of Object.entries(content)) {
+    const base = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+    if (base === "application/json" || base.endsWith("+json")) return { contentType, media };
+  }
+  return void 0;
+}
+function mediaExamples(doc, media) {
+  const out = [];
+  if (media.example !== void 0) out.push({ name: "example", value: media.example });
+  for (const [name, raw] of Object.entries(media.examples ?? {})) {
+    const example = resolveComponent(doc, raw, "examples");
+    if (!example || example.value === void 0) continue;
+    out.push({
+      name,
+      ...typeof example.summary === "string" ? { summary: example.summary } : {},
+      value: example.value
+    });
+  }
+  return out;
+}
+function admitsNull(schema) {
+  if (schema.nullable === true) return true;
+  if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+  return [...schema.anyOf ?? [], ...schema.oneOf ?? []].some(
+    (member) => member?.type === "null" || Array.isArray(member?.type) && member.type.length === 1 && member.type[0] === "null"
+  );
+}
+function flattenSchema(doc, schema) {
+  if (!schema) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  let merged = {};
+  let nullable = false;
+  let current = schema;
+  while (current) {
+    nullable ||= admitsNull(current);
+    const name = refName(refFromSchema(current));
+    const target = name && !seen.has(name) && seen.size < MAX_SCHEMA_HOPS ? doc.components.schemas[name] : void 0;
+    if (!name || !target) {
+      merged = { ...current, ...merged };
+      break;
+    }
+    seen.add(name);
+    const { $ref: _ref, allOf: _allOf, anyOf: _anyOf, oneOf: _oneOf, ...local } = current;
+    merged = { ...local, ...merged };
+    current = target;
+  }
+  return nullable ? { ...merged, nullable: true } : merged;
+}
+function parameterSchema(doc, raw) {
+  const schema = flattenSchema(doc, raw);
+  if (!schema) return void 0;
+  const out = {};
+  let type = primitiveType(schema);
+  const items = type === "array" ? flattenSchema(doc, schema.items) : void 0;
+  if (items) {
+    const itemType = primitiveType(items);
+    if (itemType && itemType !== "object" && itemType !== "array") type = `${itemType}[]`;
+  }
+  if (type) out.type = type;
+  if (typeof schema.format === "string") out.format = schema.format;
+  const enumValues = Array.isArray(schema.enum) ? schema.enum : items?.enum;
+  if (Array.isArray(enumValues)) out.enum = [...enumValues];
+  if (schema.default !== void 0) out.default = schema.default;
+  if (typeof schema.minimum === "number") out.minimum = schema.minimum;
+  if (typeof schema.maximum === "number") out.maximum = schema.maximum;
+  if (typeof schema.pattern === "string") out.pattern = schema.pattern;
+  if (schema.nullable === true) out.nullable = true;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function toDocsParameter(doc, param) {
+  const location = param.in;
+  if (typeof param.name !== "string" || !PARAM_LOCATIONS.has(location)) return void 0;
+  const rawSchema = param.schema ?? Object.values(param.content ?? {})[0]?.schema;
+  const schema = parameterSchema(doc, rawSchema);
+  const firstNamed = Object.values(param.examples ?? {}).map((raw) => resolveComponent(doc, raw, "examples")).find((ex) => ex?.value !== void 0)?.value;
+  const example = param.example ?? firstNamed ?? flattenSchema(doc, rawSchema)?.example;
+  return {
+    name: param.name,
+    in: location,
+    required: location === "path" ? true : param.required === true,
+    ...typeof param.description === "string" ? { description: param.description } : {},
+    ...param.deprecated === true ? { deprecated: true } : {},
+    ...schema ? { schema } : {},
+    ...example !== void 0 ? { example } : {}
+  };
+}
+function operationParameters(doc, pathItem, op) {
+  const merged = [];
+  const position = /* @__PURE__ */ new Map();
+  const add = (raw, override) => {
+    const resolved = resolveComponent(doc, raw, "parameters");
+    const param = resolved ? toDocsParameter(doc, resolved) : void 0;
+    if (!param) return;
+    const key = `${param.in}\0${param.name}`;
+    const at = position.get(key);
+    if (at !== void 0) {
+      if (override) merged[at] = param;
+      return;
+    }
+    position.set(key, merged.length);
+    merged.push(param);
+  };
+  for (const raw of Array.isArray(pathItem?.parameters) ? pathItem.parameters : []) add(raw, false);
+  for (const raw of Array.isArray(op.parameters) ? op.parameters : []) add(raw, true);
+  return merged;
+}
+function statusRank(status) {
+  if (/^\d{3}$/.test(status)) return Number(status);
+  const range = status.match(/^([1-5])XX$/i);
+  if (range) return Number(range[1]) * 100 + 99.5;
+  if (status.toLowerCase() === "default") return Number.POSITIVE_INFINITY;
+  return Number.MAX_SAFE_INTEGER;
+}
+function responseHeaders(doc, response) {
+  const out = [];
+  const declared = response?.headers;
+  if (!declared || typeof declared !== "object") return out;
+  for (const [name, raw] of Object.entries(declared)) {
+    if (name.toLowerCase() === "content-type") continue;
+    const header = resolveComponent(doc, raw, "headers");
+    const entry = { name };
+    if (typeof header?.description === "string") entry.description = header.description;
+    if (header?.required === true) entry.required = true;
+    const facts = parameterSchema(doc, header?.schema ?? Object.values(header?.content ?? {})[0]?.schema);
+    if (facts?.type || facts?.format) {
+      entry.schema = {
+        ...facts.type ? { type: facts.type } : {},
+        ...facts.format ? { format: facts.format } : {}
+      };
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function operationResponses(doc, op) {
+  const entries = Object.entries(op.responses ?? {});
+  entries.sort(([a], [b]) => statusRank(a) - statusRank(b) || a.localeCompare(b));
+  return entries.map(([status, raw]) => {
+    const response = resolveComponent(doc, raw, "responses");
+    const out = { status };
+    const description = response?.description ?? raw?.description;
+    if (typeof description === "string") out.description = description;
+    const headers = responseHeaders(doc, response);
+    if (headers.length > 0) out.headers = headers;
+    const json = pickJsonMedia(response?.content);
+    if (!json) {
+      const first = Object.keys(response?.content ?? {})[0];
+      if (first) out.contentType = first;
+      return out;
+    }
+    out.contentType = json.contentType;
+    const examples = mediaExamples(doc, json.media);
+    if (json.media.schema) out.fields = resolveSchemaFields(doc, json.media.schema);
+    if (examples.length > 0) {
+      out.sample = examples[0]?.value;
+      out.examples = examples;
+    } else if (json.media.schema) {
+      out.sample = synthesizeSchemaSample(doc, json.media.schema);
+    }
+    return out;
+  });
+}
+function schemeDetail(scheme) {
+  switch (scheme.type) {
+    case "http":
+      return typeof scheme.scheme === "string" ? scheme.scheme.toLowerCase() : void 0;
+    case "apiKey":
+      return scheme.in && scheme.name ? `${scheme.in} ${scheme.name}` : void 0;
+    case "openIdConnect":
+      return scheme.openIdConnectUrl;
+    default:
+      return void 0;
+  }
+}
+function securityScheme(doc, name, scopes) {
+  const scheme = resolveComponent(doc, doc.components?.securitySchemes?.[name], "securitySchemes");
+  const entry = { scheme: name };
+  if (typeof scheme?.type === "string") entry.type = scheme.type;
+  const detail = scheme ? schemeDetail(scheme) : void 0;
+  if (detail) entry.schemeDetail = detail;
+  if (typeof scheme?.bearerFormat === "string") entry.bearerFormat = scheme.bearerFormat;
+  if (typeof scheme?.description === "string") entry.description = scheme.description;
+  const named = Array.isArray(scopes) ? scopes.filter((s) => typeof s === "string") : [];
+  if (named.length > 0) entry.scopes = [...new Set(named)];
+  return entry;
+}
+function operationSecurity(doc, op) {
+  const requirements = op.security !== void 0 ? op.security : doc.security;
+  if (!Array.isArray(requirements)) return void 0;
+  const out = [];
+  for (const requirement of requirements) {
+    if (!requirement || typeof requirement !== "object" || Array.isArray(requirement)) continue;
+    out.push({
+      schemes: Object.entries(requirement).map(([name, scopes]) => securityScheme(doc, name, scopes))
+    });
+  }
+  return out;
+}
+function operationRequestBody(doc, op) {
+  const body = resolveComponent(doc, op.requestBody, "requestBodies");
+  if (!body) return void 0;
+  const requestBody = { required: body.required === true, fields: [] };
+  if (typeof body.description === "string") requestBody.description = body.description;
+  const content = body.content && typeof body.content === "object" ? body.content : void 0;
+  const json = pickJsonMedia(content);
+  if (!json) {
+    const first = Object.keys(content ?? {})[0];
+    if (first) requestBody.contentType = first;
+    return { requestBody, sample: {} };
+  }
+  requestBody.contentType = json.contentType;
+  const schema = json.media.schema;
+  if (schema) requestBody.fields = resolveSchemaFields(doc, schema);
+  const examples = mediaExamples(doc, json.media);
+  if (examples.length > 0) requestBody.examples = examples;
+  const sample = examples.length > 0 ? examples[0]?.value : schema ? synthesizeSchemaSample(doc, schema) : {};
+  return { requestBody, sample };
+}
+
+// packages/api-docs-engine/src/slices.ts
+var DOCS_URL = /Vendor docs:\s*(https?:\S+)/;
+function dedupeRefs(fields) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of fields) if (f.ref) seen.add(f.ref);
+  return [...seen].sort((a, b) => a.localeCompare(b));
+}
+function getType(doc, name) {
+  const comp = doc.components.schemas[name];
+  if (!comp) return null;
+  const fields = resolveComponentFields(doc, name);
+  return {
+    name,
+    description: comp.description,
+    deprecated: comp.deprecated === true,
+    fields,
+    refs: dedupeRefs(fields)
+  };
+}
+function responseSchema(post) {
+  const responses = post.responses ?? {};
+  const code = "200" in responses ? "200" : Object.keys(responses).find((c) => /^2\d\d$/.test(c)) ?? ["default", "DEFAULT"].find((c) => c in responses);
+  if (!code) return void 0;
+  return responses[code]?.content?.["application/json"]?.schema;
+}
+function reqResponseComponent(post, kind) {
+  const schema = kind === "req" ? post.requestBody?.content?.["application/json"]?.schema : responseSchema(post);
+  const ref = refFromSchema(schema);
+  return ref ? ref.replace(/^#\/components\/schemas\//, "") : void 0;
+}
+function buildOpSlice(doc, norm) {
+  const { id, method, route, op } = norm;
+  const body = operationRequestBody(doc, op);
+  const rsComp = reqResponseComponent(op, "rs");
+  const request = body?.requestBody.fields ?? [];
+  const response = rsComp ? resolveComponentFields(doc, rsComp) : [];
+  const docsUrl = op.externalDocs?.url ?? op.description?.match(DOCS_URL)?.[1];
+  const { description } = parseDescription(op.description);
+  const refs = [.../* @__PURE__ */ new Set([...dedupeRefs(request), ...dedupeRefs(response)])].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const requestExamples = body?.requestBody.examples ?? [];
+  const security = operationSecurity(doc, op);
+  const tags = Array.isArray(op.tags) ? op.tags.filter((t) => typeof t === "string") : [];
+  return {
+    id,
+    name: op.summary ?? id,
+    // Prefer the generator's curated group; fall back to the CamelCase token.
+    entity: op["x-entity-group"] ?? deriveEntity(id),
+    capability: op["x-capability-kind"] ?? deriveCapability(method, id),
+    service: op.tags?.[0] ?? "Other",
+    method,
+    route,
+    description,
+    docsUrl,
+    developerResources: op["x-developer-resources"],
+    request,
+    response,
+    // A document-supplied request example beats the synthesized skeleton.
+    sampleRequest: body ? body.sample : {},
+    sampleResponse: rsComp ? synthesizeSample(doc, rsComp) : {},
+    refs,
+    ...typeof op.operationId === "string" && op.operationId ? { operationId: op.operationId } : {},
+    ...typeof op.summary === "string" ? { summary: op.summary } : {},
+    ...tags.length > 0 ? { tags } : {},
+    ...op.deprecated === true ? { deprecated: true } : {},
+    parameters: operationParameters(doc, doc.paths?.[route], op),
+    responses: operationResponses(doc, op),
+    ...requestExamples.length > 0 ? { requestExamples } : {},
+    ...body ? { requestBody: body.requestBody } : {},
+    ...security ? { security } : {}
+  };
+}
+
+// packages/api-docs-engine/src/tags.ts
+function collectTags(doc, ops, scoped) {
+  const used = /* @__PURE__ */ new Set();
+  for (const { op } of ops) {
+    for (const tag of Array.isArray(op.tags) ? op.tags : []) {
+      if (typeof tag === "string") used.add(tag);
+    }
+  }
+  const out = [];
+  const declared = /* @__PURE__ */ new Set();
+  for (const tag of Array.isArray(doc.tags) ? doc.tags : []) {
+    if (!tag || typeof tag.name !== "string" || declared.has(tag.name)) continue;
+    declared.add(tag.name);
+    if (scoped && !used.has(tag.name)) continue;
+    out.push({
+      name: tag.name,
+      ...typeof tag.description === "string" ? { description: tag.description } : {}
+    });
+  }
+  const undeclared = [...used].filter((name) => !declared.has(name)).sort((a, b) => a.localeCompare(b));
+  for (const name of undeclared) out.push({ name });
+  return out;
+}
+
+// packages/api-docs-engine/src/engine.ts
+function buildEngine(doc, subset) {
+  const index = buildIndex(doc, subset);
+  const idSet = new Set(index.map((e) => e.id));
+  const ops = normalizeOps(doc, subset);
+  const opById = /* @__PURE__ */ new Map();
+  for (const norm of ops) opById.set(norm.id, norm);
+  const tags = collectTags(doc, ops, subset !== void 0);
+  const records = index.map((entry) => {
+    const norm = opById.get(entry.id);
+    const { description } = parseDescription(norm?.op.description);
+    return {
+      entry,
+      fields: {
+        name: entry.name.toLowerCase(),
+        id: tokenizeIdentifier(entry.id),
+        entity: entry.entity.toLowerCase(),
+        service: entry.service.toLowerCase(),
+        description: (description ?? "").toLowerCase()
+      }
+    };
+  });
+  return {
+    index: () => index,
+    tags: () => tags,
+    search: (query, filters) => searchRecords(records, query, filters),
+    getType: (name) => getType(doc, name),
+    getOp: (id) => {
+      if (!idSet.has(id)) return null;
+      const norm = opById.get(id);
+      return norm ? buildOpSlice(doc, norm) : null;
+    }
+  };
+}
+
+// packages/canvas-api-docs/src/panes/field-list.tsx
+import { useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function fieldRowKey(field, i) {
+  return field.name || `#${i}`;
+}
+function FieldRow({
+  field,
+  depth,
+  onDrill,
+  onOpenField,
+  loadType,
+  renderText
+}) {
+  const inlineChildren = field.children && field.children.length > 0 ? field.children : null;
+  const expandableRef = !!field.ref && !!loadType;
+  const expandable = !!inlineChildren || expandableRef;
+  const [open, setOpen] = useState(depth === 0 && !!inlineChildren);
+  const [refFields, setRefFields] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const indent = 12 + depth * 16;
+  const toggle = () => {
+    const next = !open;
+    setOpen(next);
+    if (next && expandableRef && refFields === null && !loading) {
+      setLoading(true);
+      loadType(field.ref).then((fs) => setRefFields(fs)).catch(() => setRefFields([])).finally(() => setLoading(false));
+    }
+  };
+  const childFields = inlineChildren ?? refFields;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("tr", { className: "border-b align-top transition-colors last:border-0 hover:bg-muted/30", children: [
+      /* @__PURE__ */ jsxs("td", { className: "py-1.5 pr-3 align-top", style: { paddingLeft: indent }, children: [
+        /* @__PURE__ */ jsxs("span", { className: "flex items-start gap-1 whitespace-nowrap", children: [
+          expandable ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: toggle,
+              "aria-label": open ? "Collapse" : "Expand",
+              className: "mt-px flex size-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground",
+              children: /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  viewBox: "0 0 20 20",
+                  fill: "currentColor",
+                  "aria-hidden": "true",
+                  className: `size-3.5 transition-transform duration-150 ${open ? "rotate-90" : ""}`,
+                  children: /* @__PURE__ */ jsx("path", { d: "M7 5l6 5-6 5z" })
+                }
+              )
+            }
+          ) : /* @__PURE__ */ jsx("span", { className: "inline-block size-4 shrink-0" }),
+          onOpenField ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => onOpenField(field),
+              className: "font-mono text-xs font-medium hover:text-primary hover:underline",
+              children: field.name
+            }
+          ) : /* @__PURE__ */ jsx("span", { className: "font-mono text-xs font-medium", children: field.name }),
+          field.required && /* @__PURE__ */ jsx("span", { className: "text-destructive", children: "*" }),
+          field.deprecated && /* @__PURE__ */ jsx("span", { className: "shrink-0 rounded bg-amber-500/15 px-1 py-0.5 text-[9px] font-medium uppercase text-amber-700 dark:text-amber-300", children: "deprecated" })
+        ] }),
+        field.nativeName && field.nativeName !== field.name && /* @__PURE__ */ jsx("div", { className: "ml-4 mt-0.5 whitespace-nowrap font-mono text-[10px] text-muted-foreground/70", children: field.nativeName })
+      ] }),
+      /* @__PURE__ */ jsx("td", { className: "whitespace-nowrap px-3 py-1.5 align-top", children: field.ref && onDrill ? (
+        // Referenced object: props expand inline (the caret); the type name
+        // is a small muted link out to the full type pane.
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => onDrill?.(field.ref),
+            title: "Open type",
+            className: "text-left font-mono text-[11px] text-muted-foreground hover:text-primary hover:underline",
+            children: [
+              field.type,
+              " \u2197"
+            ]
+          }
+        )
+      ) : /* @__PURE__ */ jsx("span", { className: "inline-block rounded bg-muted px-1.5 py-0.5 font-mono text-[11px] text-muted-foreground", children: field.type }) }),
+      /* @__PURE__ */ jsx("td", { className: "px-3 py-1.5 align-top", children: field.description && /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "line-clamp-2 max-w-[360px] min-w-[180px] text-xs text-muted-foreground",
+          title: field.description,
+          children: renderText ? renderText(field.description) : field.description
+        }
+      ) })
+    ] }),
+    open && loading && /* @__PURE__ */ jsx("tr", { className: "border-b last:border-0", children: /* @__PURE__ */ jsxs("td", { colSpan: 3, className: "whitespace-nowrap py-1 text-[10px] text-muted-foreground", style: { paddingLeft: indent + 28 }, children: [
+      "Loading ",
+      field.type,
+      "\u2026"
+    ] }) }),
+    open && childFields?.map((c, i) => /* @__PURE__ */ jsx(
+      FieldRow,
+      {
+        field: c,
+        depth: depth + 1,
+        onDrill,
+        onOpenField,
+        loadType,
+        renderText
+      },
+      fieldRowKey(c, i)
+    ))
+  ] });
+}
+function FieldRows({
+  fields,
+  onDrill,
+  onOpenField,
+  loadType,
+  renderText
+}) {
+  if (fields.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "rounded-md border px-3 py-2 text-xs text-muted-foreground", children: "No fields." });
+  }
+  return /* @__PURE__ */ jsx("div", { className: "overflow-x-auto rounded-md border", children: /* @__PURE__ */ jsxs("table", { className: "min-w-full border-collapse text-sm", children: [
+    /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { className: "border-b bg-muted/40 text-left text-[11px] uppercase tracking-wide text-muted-foreground", children: [
+      /* @__PURE__ */ jsx("th", { className: "whitespace-nowrap px-3 py-1.5 font-medium", children: "Field" }),
+      /* @__PURE__ */ jsx("th", { className: "whitespace-nowrap px-3 py-1.5 font-medium", children: "Type" }),
+      /* @__PURE__ */ jsx("th", { className: "w-full px-3 py-1.5 font-medium", children: "Description" })
+    ] }) }),
+    /* @__PURE__ */ jsx("tbody", { children: fields.map((f, i) => /* @__PURE__ */ jsx(
+      FieldRow,
+      {
+        field: f,
+        depth: 0,
+        onDrill,
+        onOpenField,
+        loadType,
+        renderText
+      },
+      fieldRowKey(f, i)
+    )) })
+  ] }) });
+}
+
+// packages/canvas-api-docs/src/docs/json-schema.ts
+var MAX_DEPTH = 4;
+var MAX_COMPOSITION_DEPTH = 8;
+var MAX_NODES = 2e3;
+var MAX_REF_CHAIN = 32;
+var MAX_LABEL_LENGTH = 200;
+var SCHEMA_TRUNCATED_FIELD = "(schema truncated)";
+function exhausted(budget) {
+  if (budget.nodes > 0) return false;
+  budget.truncated = true;
+  return true;
+}
+function spend(budget) {
+  if (budget.nodes <= 0) {
+    budget.truncated = true;
+    return false;
+  }
+  budget.nodes -= 1;
+  return true;
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function deref(schema, root, trail, budget) {
+  let current = schema;
+  let hops = 0;
+  while (current?.$ref) {
+    const m = /^#\/(definitions|\$defs)\/(.+)$/.exec(current.$ref);
+    if (!m || trail.has(current.$ref)) return {};
+    if (hops >= MAX_REF_CHAIN) {
+      budget.truncated = true;
+      return {};
+    }
+    if (!spend(budget)) return {};
+    hops += 1;
+    trail.add(current.$ref);
+    const table = root[m[1]];
+    const name = decodeSegment(m[2]);
+    current = table && Object.hasOwn(table, name) ? table[name] : void 0;
+  }
+  return current;
+}
+function objectShape(schema, root, seen, budget, hops) {
+  if (!spend(budget)) return { props: {}, required: /* @__PURE__ */ new Set() };
+  const trail = new Set(seen);
+  const s = deref(schema, root, trail, budget);
+  const props = { ...s?.properties ?? {} };
+  const required = new Set(Array.isArray(s?.required) ? s.required : []);
+  for (const part of s?.allOf ?? []) {
+    if (hops >= MAX_COMPOSITION_DEPTH) {
+      budget.truncated = true;
+      break;
+    }
+    const merged = objectShape(part, root, trail, budget, hops + 1);
+    Object.assign(props, merged.props);
+    for (const r of merged.required) required.add(r);
+  }
+  return { props, required };
+}
+function capLabel(label, budget) {
+  if (label.length <= MAX_LABEL_LENGTH) return label;
+  budget.truncated = true;
+  return `${label.slice(0, MAX_LABEL_LENGTH - 1)}\u2026`;
+}
+function typeLabel2(schema, root, seen, budget, hops = 0) {
+  if (!spend(budget)) return "\u2026";
+  const trail = new Set(seen);
+  const s = deref(schema, root, trail, budget);
+  if (!s) return "object";
+  const alternatives = s.oneOf ?? s.anyOf;
+  if (alternatives && alternatives.length > 0) {
+    if (hops >= MAX_COMPOSITION_DEPTH) {
+      budget.truncated = true;
+      return "one of: \u2026";
+    }
+    let label = "one of: ";
+    for (const [i, a] of alternatives.entries()) {
+      if (label.length > MAX_LABEL_LENGTH) break;
+      label += `${i > 0 ? " | " : ""}${typeLabel2(a, root, trail, budget, hops + 1)}`;
+    }
+    return capLabel(label, budget);
+  }
+  const base = Array.isArray(s.type) ? s.type.filter((t) => t !== "null").join(" | ") : s.type;
+  if (base === "array") {
+    if (hops >= MAX_COMPOSITION_DEPTH) {
+      budget.truncated = true;
+      return "\u2026[]";
+    }
+    return capLabel(`${typeLabel2(s.items, root, trail, budget, hops + 1)}[]`, budget);
+  }
+  const ref = schema?.$ref?.split("/").pop();
+  if (ref && (base === void 0 || base === "object")) return decodeSegment(ref);
+  return base ?? "object";
+}
+function fieldsOf(schema, root, depth, seen, budget, hops) {
+  if (depth > MAX_DEPTH) return [];
+  if (hops > MAX_COMPOSITION_DEPTH) {
+    budget.truncated = true;
+    return [];
+  }
+  if (!spend(budget)) return [];
+  const trail = new Set(seen);
+  const s = deref(schema, root, trail, budget);
+  if (!s) return [];
+  if (s.type === "array" || Array.isArray(s.type) && s.type.includes("array")) return fieldsOf(s.items, root, depth, trail, budget, hops + 1);
+  const alternatives = s.oneOf ?? s.anyOf;
+  if (alternatives && !s.properties) {
+    const fields2 = [];
+    for (const a of alternatives) {
+      if (exhausted(budget)) break;
+      for (const f of fieldsOf(a, root, depth, trail, budget, hops + 1)) fields2.push({ ...f, required: false });
+    }
+    return fields2;
+  }
+  const { props, required } = objectShape(s, root, trail, budget, hops);
+  const fields = [];
+  for (const [name, raw] of Object.entries(props)) {
+    if (name.startsWith("x-")) continue;
+    if (exhausted(budget)) break;
+    const p = deref(raw, root, new Set(trail), budget) ?? {};
+    const children = fieldsOf(raw, root, depth + 1, trail, budget, hops);
+    fields.push({
+      name,
+      type: typeLabel2(raw, root, trail, budget),
+      required: required.has(name),
+      deprecated: p.deprecated === true,
+      ...p.description ? { description: p.description } : {},
+      ...Array.isArray(p.enum) ? { enumValues: p.enum.map(String) } : {},
+      ...p.default !== void 0 ? { defaultValue: String(p.default) } : {},
+      ...children.length > 0 ? { children } : {}
+    });
+  }
+  return fields;
+}
+function jsonSchemaFields(schema) {
+  const root = schema ?? {};
+  if (typeof schema !== "object" || schema === null) return [];
+  const budget = { nodes: MAX_NODES, truncated: false };
+  const fields = fieldsOf(root, root, 0, /* @__PURE__ */ new Set(), budget, 0);
+  if (!budget.truncated) return fields;
+  return [
+    ...fields,
+    {
+      name: SCHEMA_TRUNCATED_FIELD,
+      type: "\u2026",
+      required: false,
+      deprecated: false,
+      description: "This payload schema is too large or too deeply nested to show in full; the published schema is the whole contract."
+    }
+  ];
+}
+
+// packages/canvas-api-docs/src/docs/markdown.tsx
+import { createContext, useContext, useId as useId2 } from "react";
+
+// packages/rich-markdown/src/rich-markdown.tsx
+import { memo, useMemo } from "react";
+import ReactMarkdown from "react-markdown";
+import rehypeHighlight from "rehype-highlight";
+
+// packages/rich-markdown/src/cn.ts
+function cn(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+
+// packages/rich-markdown/src/code-block.tsx
+import { useRef, useState as useState2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function CodeBlock({ language, children }) {
+  const codeRef = useRef(null);
+  const [copied, setCopied] = useState2(false);
+  const onCopy = () => {
+    const text = codeRef.current?.textContent ?? "";
+    void navigator.clipboard?.writeText(text).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    });
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "not-prose group my-3 overflow-hidden rounded border border-border", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between border-b border-border bg-muted/50 px-3 py-1.5", children: [
+      /* @__PURE__ */ jsx2("span", { className: "text-xs font-medium text-muted-foreground", children: language }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          onClick: onCopy,
+          className: "rounded px-2 py-0.5 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground",
+          "aria-label": "Copy code",
+          children: copied ? "Copied" : "Copy"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2("pre", { className: "overflow-x-auto p-3 text-[12px] leading-relaxed", children: /* @__PURE__ */ jsx2("code", { ref: codeRef, className: "hljs", children }) })
+  ] });
+}
+
+// packages/rich-markdown/src/hast.ts
+function isElement(node) {
+  return node.type === "element";
+}
+function hastToString(node) {
+  if (node.type === "text") return String(node.value);
+  const children = node.children;
+  return children ? children.map(hastToString).join("") : "";
+}
+
+// packages/rich-markdown/src/images.ts
+var BUNDLED_IMAGE_URL = /^data:image\/(?:png|jpeg|gif|webp);base64,[A-Za-z0-9+/]*={0,2}$/;
+function isBundledImageUrl(url) {
+  return BUNDLED_IMAGE_URL.test(url);
+}
+function imagePlaceholderText(alt) {
+  const label = typeof alt === "string" ? alt.trim() : "";
+  return label ? `[image: ${label}]` : "[image]";
+}
+function replaceImages(node, insideLink, keep) {
+  const children = node.children;
+  if (!children) return;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!isElement(child)) {
+      replaceImages(child, insideLink, keep);
+      continue;
+    }
+    if (child.tagName === "img") {
+      const src = child.properties.src;
+      if (keep && typeof src === "string" && keep(src)) continue;
+      const text = { type: "text", value: imagePlaceholderText(child.properties.alt) };
+      const replacement = insideLink || typeof src !== "string" || src === "" ? { type: "element", tagName: "span", properties: { dataImagePlaceholder: "" }, children: [text] } : { type: "element", tagName: "a", properties: { href: src, dataImagePlaceholder: "" }, children: [text] };
+      children[i] = replacement;
+      continue;
+    }
+    replaceImages(child, insideLink || child.tagName === "a", keep);
+  }
+}
+function rehypeBlockImages(options = {}) {
+  return (tree) => {
+    replaceImages(tree, false, options.keep);
+  };
+}
+
+// packages/rich-markdown/src/mermaid-block.tsx
+import { useEffect as useEffect2, useId, useState as useState4 } from "react";
+
+// packages/rich-markdown/src/use-is-dark-class.ts
+import { useEffect, useState as useState3 } from "react";
+function useIsDarkClass() {
+  const [isDark, setIsDark] = useState3(
+    () => typeof document !== "undefined" && document.documentElement.classList.contains("dark")
+  );
+  useEffect(() => {
+    const root = document.documentElement;
+    const update = () => setIsDark(root.classList.contains("dark"));
+    update();
+    const observer = new MutationObserver(update);
+    observer.observe(root, { attributes: true, attributeFilter: ["class"] });
+    return () => observer.disconnect();
+  }, []);
+  return isDark;
+}
+
+// packages/rich-markdown/src/mermaid-block.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function mermaidTheme(isDark) {
+  return isDark ? "dark" : "default";
+}
+async function renderMermaid(mermaid, id, diagram, isDark) {
+  try {
+    mermaid.initialize({ securityLevel: "strict", startOnLoad: false, theme: mermaidTheme(isDark) });
+    const { svg } = await mermaid.render(id, diagram);
+    return { ok: true, svg };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function MermaidBlock({ diagram }) {
+  const reactId = useId();
+  const id = `mermaid-${reactId.replace(/:/g, "")}`;
+  const isDark = useIsDarkClass();
+  const [result, setResult] = useState4(null);
+  useEffect2(() => {
+    let cancelled = false;
+    void (async () => {
+      const mermaid = (await import("mermaid")).default;
+      const r = await renderMermaid(mermaid, id, diagram, isDark);
+      if (!cancelled) setResult(r);
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [diagram, isDark, id]);
+  if (result?.ok) {
+    return /* @__PURE__ */ jsx3(
+      "div",
+      {
+        "data-mermaid": true,
+        className: "rich-md-mermaid my-4 flex justify-center",
+        dangerouslySetInnerHTML: { __html: result.svg }
+      }
+    );
+  }
+  if (result && !result.ok) {
+    return /* @__PURE__ */ jsxs3("div", { "data-mermaid": true, className: "rich-md-mermaid my-4", children: [
+      /* @__PURE__ */ jsxs3("p", { className: "mb-1 text-xs text-destructive", children: [
+        "Failed to render diagram: ",
+        result.error
+      ] }),
+      /* @__PURE__ */ jsx3("pre", { className: "overflow-auto rounded bg-muted p-3 font-mono text-[12px] text-foreground", children: /* @__PURE__ */ jsx3("code", { children: diagram }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsx3("div", { "data-mermaid": true, className: "rich-md-mermaid my-4 text-xs text-muted-foreground", children: "Rendering diagram\u2026" });
+}
+
+// packages/rich-markdown/src/url-policy.ts
+var LINK_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+var RESOURCE_SCHEMES = /* @__PURE__ */ new Set(["http", "https"]);
+var EXTERNAL_LINK_REL = "noopener noreferrer nofollow";
+function urlScheme(url) {
+  const colon = url.indexOf(":");
+  if (colon === -1) return null;
+  for (const separator of ["/", "?", "#"]) {
+    const at = url.indexOf(separator);
+    if (at !== -1 && at < colon) return null;
+  }
+  return url.slice(0, colon).toLowerCase();
+}
+function isExternalHref(href) {
+  if (href.startsWith("//")) return true;
+  const scheme = urlScheme(href);
+  return scheme === "http" || scheme === "https";
+}
+function makeUrlTransform({ allowDocLinks }) {
+  return (url, key) => {
+    if (key === "href") return isAllowedLinkHref(url, allowDocLinks) ? url : void 0;
+    const scheme = urlScheme(url);
+    if (scheme === null) return url;
+    return RESOURCE_SCHEMES.has(scheme) ? url : void 0;
+  };
+}
+function isAllowedLinkHref(href, allowDocLinks) {
+  const scheme = urlScheme(href);
+  if (scheme === null) return true;
+  return LINK_SCHEMES.has(scheme) || allowDocLinks && scheme === "doc";
+}
+function isRelativeHref(href) {
+  return !href.startsWith("#") && !href.startsWith("//") && urlScheme(href) === null;
+}
+function resolveLinkTarget(href, isFootnoteLink, policy) {
+  if (href === void 0) return {};
+  if (href.startsWith("#")) {
+    if (!policy.fragmentPrefix || href === "#" || isFootnoteLink) return { href };
+    return { href: `#${policy.fragmentPrefix}${href.slice(1)}` };
+  }
+  if (!isRelativeHref(href)) return { href };
+  if (policy.resolveRelativeLink) {
+    const resolved = policy.resolveRelativeLink(href);
+    if (!resolved || !isAllowedLinkHref(resolved.href, policy.allowDocLinks)) return {};
+    return resolved.onClick ? { href: resolved.href, onClick: resolved.onClick } : { href: resolved.href };
+  }
+  return policy.inertRelativeLinks ? {} : { href };
+}
+
+// packages/rich-markdown/src/components.tsx
+import { Fragment as Fragment2, jsx as jsx4 } from "react/jsx-runtime";
+function components({ onLinkClick, embeds, mermaid, links, resolveImage }) {
+  return {
+    img: ({ node: _n, src, alt, ...props }) => {
+      if (resolveImage && typeof src === "string" && isRelativeHref(src)) {
+        const resolved = src ? resolveImage(src) : null;
+        if (!resolved) return /* @__PURE__ */ jsx4("span", { "data-image-placeholder": "", children: imagePlaceholderText(alt) });
+        return /* @__PURE__ */ jsx4("img", { ...props, src: resolved, alt: alt ?? "", className: "max-w-full" });
+      }
+      return /* @__PURE__ */ jsx4("img", { ...props, src, alt });
+    },
+    h1: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("h1", { className: "mb-3 mt-4 text-xl font-semibold text-foreground first:mt-0", ...props }),
+    h2: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("h2", { className: "mb-2 mt-4 text-lg font-semibold text-foreground", ...props }),
+    h3: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("h3", { className: "mb-2 mt-3 text-base font-semibold text-foreground", ...props }),
+    p: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("p", { className: "mb-3 text-sm leading-relaxed text-foreground", ...props }),
+    /**
+     * `pl-5`, NOT `ml-5`.
+     *
+     * A margin moves the whole `ul` box right, and `list-style-position` defaults
+     * to `outside` — so the marker is drawn in the space to the LEFT of the
+     * content box, which the margin had just vacated. Net effect: the bullet
+     * lands back at the container's left edge, flush with the surrounding
+     * paragraphs, and only the item's text looks indented. Padding puts that
+     * space inside the box, so the marker sits within the indent where it
+     * belongs. Tailwind's preflight zeroes the browser's default `padding-left`,
+     * which is why this has to be stated at all.
+     */
+    ul: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("ul", { className: "mb-3 pl-5 list-disc space-y-1 text-sm text-foreground", ...props }),
+    ol: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("ol", { className: "mb-3 pl-5 list-decimal space-y-1 text-sm text-foreground", ...props }),
+    li: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("li", { className: "text-sm leading-relaxed", ...props }),
+    a: ({ node, href: sourceHref, children, ...props }) => {
+      const properties = node?.properties ?? {};
+      const isFootnoteLink = properties.dataFootnoteRef !== void 0 || properties.dataFootnoteBackref !== void 0;
+      const { href, onClick } = resolveLinkTarget(sourceHref, isFootnoteLink, links);
+      return /* @__PURE__ */ jsx4(
+        "a",
+        {
+          href,
+          className: "text-primary underline underline-offset-2",
+          onClick: (e) => {
+            if (!href) return;
+            onClick?.(e);
+            onLinkClick?.(href, e);
+          },
+          ...props,
+          ...href && isExternalHref(href) ? { rel: EXTERNAL_LINK_REL, target: "_blank" } : {},
+          children
+        }
+      );
+    },
+    strong: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("strong", { className: "font-semibold text-foreground", ...props }),
+    blockquote: ({ node: _n, ...props }) => /* @__PURE__ */ jsx4("blockquote", { className: "mb-3 border-l-2 border-border pl-3 text-sm italic text-muted-foreground", ...props }),
+    code: ({ className, children, node }) => {
+      const match = /language-(\w+)/.exec(className || "");
+      const lang = match?.[1];
+      if (lang === "mermaid") {
+        if (!mermaid) return /* @__PURE__ */ jsx4(CodeBlock, { language: "mermaid", children });
+        return /* @__PURE__ */ jsx4(MermaidBlock, { diagram: String(children).replace(/\n$/, "") });
+      }
+      if (lang && embeds && embeds[lang]) {
+        return /* @__PURE__ */ jsx4(Fragment2, { children: embeds[lang](String(children).replace(/\n$/, "")) });
+      }
+      if (lang) {
+        return /* @__PURE__ */ jsx4(CodeBlock, { language: lang, children });
+      }
+      const isBlock = node?.position && String(children).includes("\n");
+      if (isBlock) return /* @__PURE__ */ jsx4(CodeBlock, { language: "text", children });
+      return /* @__PURE__ */ jsx4("code", { className: "rounded bg-muted px-1.5 py-0.5 font-mono text-[0.9em] text-foreground", children });
+    },
+    pre: ({ children }) => /* @__PURE__ */ jsx4(Fragment2, { children }),
+    table: ({ children }) => /* @__PURE__ */ jsx4("div", { className: "mb-3 overflow-auto rounded border border-border", children: /* @__PURE__ */ jsx4("table", { className: "w-full border-collapse text-sm", children }) }),
+    th: ({ children }) => /* @__PURE__ */ jsx4("th", { className: "border-b border-border bg-muted/40 px-2 py-1 text-left font-semibold text-foreground", children }),
+    td: ({ children }) => /* @__PURE__ */ jsx4("td", { className: "border-b border-border/60 px-2 py-1 text-foreground", children })
+  };
+}
+
+// packages/rich-markdown/src/headings.ts
+import Markdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+var REMARK_PLUGINS = [remarkGfm];
+var HEADING_TAG = /^h([1-6])$/;
+var SLUG_STRIP = /[^\p{L}\p{M}\p{N}\p{Pc}\s-]/gu;
+function headingSlug(text) {
+  const slug = text.trim().toLowerCase().replace(SLUG_STRIP, "").replace(/\s/g, "-");
+  return slug || "section";
+}
+function createSlugger() {
+  const occurrences = /* @__PURE__ */ new Map();
+  return (text) => {
+    const base = headingSlug(text);
+    let slug = base;
+    while (occurrences.has(slug)) {
+      const next = occurrences.get(base) + 1;
+      occurrences.set(base, next);
+      slug = `${base}-${next}`;
+    }
+    occurrences.set(slug, 0);
+    return slug;
+  };
+}
+function assignIds(node, slug, onHeading, idPrefix = "") {
+  const children = node.children;
+  if (!children) return;
+  for (const child of children) {
+    if (!isElement(child)) continue;
+    const match = HEADING_TAG.exec(child.tagName);
+    if (match && child.properties.id === void 0) {
+      const text = hastToString(child).trim();
+      const id = `${idPrefix}${slug(text)}`;
+      child.properties.id = id;
+      onHeading?.({ depth: Number(match[1]), text, id });
+      continue;
+    }
+    assignIds(child, slug, onHeading, idPrefix);
+  }
+}
+function rehypeHeadingIds(options = {}) {
+  return (tree) => {
+    assignIds(tree, createSlugger(), options.onHeading, options.idPrefix);
+  };
+}
+function extractHeadings(markdown, options = {}) {
+  const headings = [];
+  if (!markdown) return headings;
+  Markdown({
+    children: markdown,
+    remarkPlugins: REMARK_PLUGINS,
+    rehypePlugins: [
+      [rehypeHeadingIds, { onHeading: (h) => headings.push(h), idPrefix: options.idPrefix }]
+    ],
+    allowElement: () => false
+  });
+  return headings;
+}
+
+// packages/rich-markdown/src/rich-markdown.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var URL_TRANSFORM = makeUrlTransform({ allowDocLinks: false });
+var URL_TRANSFORM_WITH_DOC_LINKS = makeUrlTransform({ allowDocLinks: true });
+var HIGHLIGHT = [rehypeHighlight, { ignoreMissing: true, plainText: ["mermaid"] }];
+var PLUGINS_BLOCKING_IMAGES = [rehypeHeadingIds, rehypeBlockImages, HIGHLIGHT];
+var PLUGINS_ALLOWING_IMAGES = [rehypeHeadingIds, HIGHLIGHT];
+function rehypePluginsFor(images, headingIdPrefix, keep) {
+  if (!headingIdPrefix && !keep) return images === "allow" ? PLUGINS_ALLOWING_IMAGES : PLUGINS_BLOCKING_IMAGES;
+  const ids = headingIdPrefix ? [rehypeHeadingIds, { idPrefix: headingIdPrefix }] : rehypeHeadingIds;
+  return images === "allow" ? [ids, HIGHLIGHT] : [ids, [rehypeBlockImages, { keep }], HIGHLIGHT];
+}
+function resolvedImage(resolveImage, src) {
+  if (!resolveImage || !isRelativeHref(src) || src === "") return null;
+  const url = resolveImage(src);
+  return url !== null && isBundledImageUrl(url) ? url : null;
+}
+var UNTRUSTED_HEADING_ID_PREFIX = "md-";
+var RichMarkdown = memo(function RichMarkdown2({
+  text,
+  className,
+  onLinkClick,
+  embeds,
+  untrusted = false,
+  allowDocLinks = false,
+  images = "allow",
+  mermaid = true,
+  headingIdPrefix,
+  resolveRelativeLink,
+  resolveImage
+}) {
+  const docLinks = untrusted ? false : allowDocLinks;
+  const imagePolicy = untrusted ? "block" : images;
+  const idPrefix = untrusted ? headingIdPrefix || UNTRUSTED_HEADING_ID_PREFIX : headingIdPrefix;
+  const rehypePlugins = useMemo(
+    () => rehypePluginsFor(
+      imagePolicy,
+      idPrefix,
+      resolveImage ? (src) => resolvedImage(resolveImage, src) !== null : void 0
+    ),
+    [imagePolicy, idPrefix, resolveImage]
+  );
+  if (!text) return null;
+  const links = {
+    allowDocLinks: docLinks,
+    resolveRelativeLink,
+    inertRelativeLinks: untrusted,
+    fragmentPrefix: idPrefix
+  };
+  return /* @__PURE__ */ jsx5("div", { className: cn("rich-md", className), children: /* @__PURE__ */ jsx5(
+    ReactMarkdown,
+    {
+      remarkPlugins: REMARK_PLUGINS,
+      rehypePlugins,
+      urlTransform: docLinks ? URL_TRANSFORM_WITH_DOC_LINKS : URL_TRANSFORM,
+      components: components({
+        onLinkClick,
+        embeds,
+        mermaid: untrusted ? false : mermaid,
+        links,
+        ...resolveImage ? { resolveImage: (src) => resolvedImage(resolveImage, src) } : {}
+      }),
+      children: text
+    }
+  ) });
+});
+
+// packages/canvas-api-docs/src/docs/markdown.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var DocsLinkContext = createContext(void 0);
+var DOCS_HEADING_ID_PREFIX = "docs-";
+function DocsMarkdown({
+  text,
+  className,
+  idPrefix,
+  resolveImage
+}) {
+  const scope = useId2().replace(/[^a-zA-Z0-9]/g, "");
+  const resolveRelativeLink = useContext(DocsLinkContext);
+  return /* @__PURE__ */ jsx6(
+    RichMarkdown,
+    {
+      text,
+      className,
+      untrusted: true,
+      headingIdPrefix: idPrefix ?? `${DOCS_HEADING_ID_PREFIX}${scope}-`,
+      ...resolveRelativeLink ? { resolveRelativeLink } : {},
+      ...resolveImage ? { resolveImage } : {}
+    }
+  );
+}
+
+// packages/canvas-api-docs/src/docs/events-view.tsx
+import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function EventsView({ catalog, focus }) {
+  const { delivery } = catalog;
+  return /* @__PURE__ */ jsxs4("div", { className: "space-y-6", children: [
+    /* @__PURE__ */ jsxs4("header", { className: "space-y-1", children: [
+      /* @__PURE__ */ jsx7("h1", { className: "text-2xl font-semibold", children: "Events" }),
+      /* @__PURE__ */ jsxs4("p", { className: "text-sm text-muted-foreground", children: [
+        catalog.types.length,
+        " event ",
+        catalog.types.length === 1 ? "type" : "types",
+        ", delivered by",
+        " ",
+        /* @__PURE__ */ jsx7("code", { className: "font-mono", children: catalog.service }),
+        "."
+      ] })
+    ] }),
+    delivery && /* @__PURE__ */ jsxs4("dl", { className: "grid grid-cols-[max-content_1fr] gap-x-4 gap-y-1 rounded-md border p-3 text-sm", children: [
+      delivery.payload && /* @__PURE__ */ jsxs4(Fragment3, { children: [
+        /* @__PURE__ */ jsx7("dt", { className: "text-muted-foreground", children: "Payload" }),
+        /* @__PURE__ */ jsx7("dd", { children: delivery.payload === "thin" ? "Identifiers only \u2014 fetch the resource from the API." : "The resource inline." })
+      ] }),
+      delivery.retry?.maxAttempts && /* @__PURE__ */ jsxs4(Fragment3, { children: [
+        /* @__PURE__ */ jsx7("dt", { className: "text-muted-foreground", children: "Retries" }),
+        /* @__PURE__ */ jsxs4("dd", { children: [
+          "Up to ",
+          delivery.retry.maxAttempts,
+          " attempts per endpoint."
+        ] })
+      ] }),
+      delivery.signing && delivery.signing.length > 0 && /* @__PURE__ */ jsxs4(Fragment3, { children: [
+        /* @__PURE__ */ jsx7("dt", { className: "text-muted-foreground", children: "Signing" }),
+        /* @__PURE__ */ jsx7("dd", { children: delivery.signing.join(", ") })
+      ] })
+    ] }),
+    catalog.types.map((type) => /* @__PURE__ */ jsxs4("section", { id: `event-${type.name}`, className: "space-y-2", "data-focused": focus === type.name || void 0, children: [
+      /* @__PURE__ */ jsxs4("h2", { className: "flex flex-wrap items-baseline gap-2 font-mono text-base font-semibold", children: [
+        type.name,
+        type.schemaVersion !== void 0 && /* @__PURE__ */ jsxs4("span", { className: "rounded bg-muted px-1.5 py-0.5 text-[11px] font-normal text-muted-foreground", children: [
+          "v",
+          type.schemaVersion
+        ] })
+      ] }),
+      type.description && /* @__PURE__ */ jsx7(DocsMarkdown, { text: type.description, className: "text-sm" }),
+      type.payloadSchema ? /* @__PURE__ */ jsx7(FieldRows, { fields: jsonSchemaFields(type.payloadSchema), renderText: (t) => /* @__PURE__ */ jsx7(DocsMarkdown, { text: t }) }) : /* @__PURE__ */ jsx7("p", { className: "text-xs text-muted-foreground", children: "This event's payload schema is not published." })
+    ] }, type.name))
+  ] });
+}
+
+// packages/canvas-api-docs/src/docs/guide-page.tsx
+import { useCallback } from "react";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function GuidePage({
+  page,
+  pageId,
+  images
+}) {
+  const resolveImage = useCallback(
+    (src) => pageId === void 0 ? null : docsImageUrl({ images }, pageId, src),
+    [images, pageId]
+  );
+  const toc = extractHeadings(page.markdown, { idPrefix: DOCS_HEADING_ID_PREFIX }).filter((h) => h.depth === 2 || h.depth === 3);
+  return /* @__PURE__ */ jsxs5("div", { className: "flex gap-8", children: [
+    /* @__PURE__ */ jsxs5("article", { className: "min-w-0 max-w-3xl flex-1 space-y-4", children: [
+      /* @__PURE__ */ jsxs5("header", { className: "space-y-1", children: [
+        /* @__PURE__ */ jsx8("h1", { className: "text-2xl font-semibold", children: page.title }),
+        page.description && /* @__PURE__ */ jsx8("p", { className: "text-sm text-muted-foreground", children: page.description })
+      ] }),
+      /* @__PURE__ */ jsx8(DocsMarkdown, { text: page.markdown, className: "text-sm", idPrefix: DOCS_HEADING_ID_PREFIX, resolveImage })
+    ] }),
+    toc.length > 1 && /* @__PURE__ */ jsxs5("nav", { "aria-label": "On this page", className: "hidden w-48 shrink-0 text-sm xl:block", children: [
+      /* @__PURE__ */ jsx8("p", { className: "mb-2 font-medium", children: "On this page" }),
+      /* @__PURE__ */ jsx8("ul", { className: "space-y-1", children: toc.map((h) => /* @__PURE__ */ jsx8("li", { className: h.depth === 3 ? "pl-3" : void 0, children: /* @__PURE__ */ jsx8("a", { href: `#${h.id}`, className: "text-muted-foreground hover:text-foreground", children: h.text }) }, h.id)) })
+    ] })
+  ] });
+}
+
+// packages/canvas-api-docs/src/docs/model.ts
+function initialLocation(bundle) {
+  const landing = bundle?.config.landing;
+  return landing && docsPage(bundle, landing) ? { kind: "page", page: landing } : { kind: "reference" };
+}
+function locationToParams(location) {
+  const params = new URLSearchParams();
+  if (location.kind === "page") params.set("page", location.page);
+  else if (location.kind === "reference") {
+    params.set("section", "reference");
+    if (location.op) params.set("op", location.op);
+  } else {
+    params.set("section", "events");
+    if (location.event) params.set("event", location.event);
+  }
+  return params;
+}
+function locationFromParams(params, bundle) {
+  const page = params.get("page");
+  if (page && docsPage(bundle, page)) return { kind: "page", page };
+  const section = params.get("section");
+  if (section === "reference" && bundle?.config.reference !== false) {
+    const op = params.get("op");
+    return op ? { kind: "reference", op } : { kind: "reference" };
+  }
+  if (section === "events" && bundle?.events) {
+    const event = params.get("event");
+    return event ? { kind: "events", event } : { kind: "events" };
+  }
+  return initialLocation(bundle);
+}
+function navGroups(bundle) {
+  if (!bundle) return [];
+  return (bundle.config.nav ?? []).map((g) => ({
+    group: g.group,
+    pages: g.pages.flatMap((id) => {
+      const page = docsPage(bundle, id);
+      return page ? [{ id, title: page.title }] : [];
+    })
+  })).filter((g) => g.pages.length > 0);
+}
+var UNTAGGED_GROUP = "Other";
+function referenceGroups(index, tags) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of tags) groups.set(t.name, { tag: t.name, ...t.description ? { description: t.description } : {}, ops: [] });
+  const untagged = [];
+  for (const entry of index) {
+    const tag = entry.tags?.[0];
+    if (!tag) {
+      untagged.push(entry);
+      continue;
+    }
+    if (!groups.has(tag)) groups.set(tag, { tag, ops: [] });
+    groups.get(tag).ops.push(entry);
+  }
+  const out = [...groups.values()].filter((g) => g.ops.length > 0);
+  if (untagged.length > 0) out.push({ tag: UNTAGGED_GROUP, ops: untagged });
+  return out;
+}
+var AVAILABILITY_LABELS = {
+  available: "Available",
+  not_enabled: "Not enabled here",
+  not_implemented: "Not implemented",
+  not_supported: "Not supported"
+};
+function availabilityOf(bundle, opId) {
+  const availability = bundle?.availability;
+  return availability && Object.hasOwn(availability, opId) ? availability[opId] : void 0;
+}
+function tryItGate(input) {
+  const { availability } = input;
+  if (!availability && input.availabilityPublished) {
+    return { runnable: false, reason: "This deployment publishes no availability for this operation." };
+  }
+  if (availability && availability.state !== "available") {
+    const label = AVAILABILITY_LABELS[availability.state];
+    return { runnable: false, reason: availability.reason ? `${label} \u2014 ${availability.reason}` : label };
+  }
+  if (input.sandbox === null) return { runnable: true };
+  const sandbox = input.sandbox ?? DEFAULT_SANDBOX_MODE;
+  const allowed = input.write === void 0 ? tryItAllows(input.method, sandbox) : !input.write || sandbox !== "live";
+  if (!allowed) {
+    return { runnable: false, reason: `Read-only here: this deployment is ${sandbox}, so writes do not run.` };
+  }
+  return { runnable: true };
+}
+var SANDBOX_LABELS = {
+  live: "Live \u2014 reads only",
+  mock: "Mock \u2014 writes run against fixtures",
+  "vendor-sandbox": "Vendor sandbox \u2014 writes run against the vendor's sandbox"
+};
+var MAX_DOCS_HREF_LENGTH = 2048;
+function resolveDocsLink(href, bundle) {
+  if (!href || href.length > MAX_DOCS_HREF_LENGTH) return null;
+  if (href.startsWith("/") || href.startsWith("?") || href.startsWith("#")) return null;
+  let path = href.split("#")[0].split("?")[0];
+  while (path.startsWith("./") || path.startsWith("../")) path = path.slice(path.startsWith("./") ? 2 : 3);
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") end--;
+  path = path.slice(0, end);
+  if (path.endsWith(".md")) path = path.slice(0, -3);
+  if (!path) return null;
+  if (path === "api") return { kind: "reference" };
+  if (path.startsWith("api/")) {
+    const op = path.slice(4);
+    return op && !op.includes("/") ? { kind: "reference", op } : { kind: "reference" };
+  }
+  if (path === "events") return bundle?.events ? { kind: "events" } : null;
+  return docsPage(bundle, path) ? { kind: "page", page: path } : null;
+}
+
+// packages/canvas-api-docs/src/docs/reference-view.tsx
+import { useEffect as useEffect3, useState as useState5 } from "react";
+
+// packages/canvas-api-docs/src/docs/availability-badge.tsx
+import { jsxs as jsxs6 } from "react/jsx-runtime";
+var TONE = {
+  available: "border-emerald-500/40 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300",
+  not_enabled: "border-amber-500/40 bg-amber-500/10 text-amber-700 dark:text-amber-300",
+  not_implemented: "border-muted-foreground/30 bg-muted text-muted-foreground",
+  not_supported: "border-muted-foreground/30 bg-muted text-muted-foreground"
+};
+function AvailabilityBadge({ availability }) {
+  if (!availability) return null;
+  const label = AVAILABILITY_LABELS[availability.state];
+  return /* @__PURE__ */ jsxs6(
+    "span",
+    {
+      className: `inline-flex items-center rounded border px-1.5 py-0.5 text-[11px] font-medium ${TONE[availability.state]}`,
+      title: availability.reason ?? label,
+      "data-availability": availability.state,
+      children: [
+        label,
+        availability.reason ? /* @__PURE__ */ jsxs6("span", { className: "sr-only", children: [
+          " \u2014 ",
+          availability.reason
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// packages/canvas-api-docs/src/docs/op-doc.tsx
+import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var md = (text) => /* @__PURE__ */ jsx9(DocsMarkdown, { text });
+function Section({ title, children }) {
+  return /* @__PURE__ */ jsxs7("section", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsx9("h3", { className: "text-sm font-semibold", children: title }),
+    children
+  ] });
+}
+function JsonBlock({ value, label }) {
+  return /* @__PURE__ */ jsxs7("figure", { className: "space-y-1", children: [
+    label && /* @__PURE__ */ jsx9("figcaption", { className: "text-xs text-muted-foreground", children: label }),
+    /* @__PURE__ */ jsx9("pre", { className: "max-h-96 overflow-auto rounded-md border bg-muted/40 p-3 font-mono text-xs", children: JSON.stringify(value, null, 2) })
+  ] });
+}
+function isShownSample(value) {
+  if (value === void 0) return false;
+  return !(typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0);
+}
+function ParametersTable({ parameters }) {
+  return /* @__PURE__ */ jsx9("div", { className: "overflow-x-auto rounded-md border", children: /* @__PURE__ */ jsxs7("table", { className: "min-w-full border-collapse text-sm", children: [
+    /* @__PURE__ */ jsx9("thead", { children: /* @__PURE__ */ jsxs7("tr", { className: "border-b bg-muted/40 text-left text-[11px] uppercase tracking-wide text-muted-foreground", children: [
+      /* @__PURE__ */ jsx9("th", { className: "px-3 py-1.5 font-medium", children: "Name" }),
+      /* @__PURE__ */ jsx9("th", { className: "px-3 py-1.5 font-medium", children: "In" }),
+      /* @__PURE__ */ jsx9("th", { className: "px-3 py-1.5 font-medium", children: "Type" }),
+      /* @__PURE__ */ jsx9("th", { className: "w-full px-3 py-1.5 font-medium", children: "Description" })
+    ] }) }),
+    /* @__PURE__ */ jsx9("tbody", { children: parameters.map((p) => /* @__PURE__ */ jsxs7("tr", { className: "border-b align-top last:border-0", children: [
+      /* @__PURE__ */ jsxs7("td", { className: "whitespace-nowrap px-3 py-1.5 font-mono text-xs", children: [
+        p.name,
+        p.required && /* @__PURE__ */ jsx9("span", { className: "ml-1 text-destructive", title: "Required", children: "*" }),
+        p.deprecated && /* @__PURE__ */ jsx9("span", { className: "ml-1 text-[10px] text-muted-foreground", children: "deprecated" })
+      ] }),
+      /* @__PURE__ */ jsx9("td", { className: "px-3 py-1.5 text-xs text-muted-foreground", children: p.in }),
+      /* @__PURE__ */ jsx9("td", { className: "whitespace-nowrap px-3 py-1.5", children: /* @__PURE__ */ jsxs7("span", { className: "inline-block rounded bg-muted px-1.5 py-0.5 font-mono text-[11px] text-muted-foreground", children: [
+        p.schema?.type ?? "string",
+        p.schema?.format ? ` (${p.schema.format})` : ""
+      ] }) }),
+      /* @__PURE__ */ jsxs7("td", { className: "px-3 py-1.5 text-xs text-muted-foreground", children: [
+        p.description && md(p.description),
+        p.schema?.enum && /* @__PURE__ */ jsxs7("p", { children: [
+          "One of: ",
+          /* @__PURE__ */ jsx9("code", { className: "font-mono", children: p.schema.enum.map(String).join(", ") })
+        ] }),
+        p.schema?.default !== void 0 && /* @__PURE__ */ jsxs7("p", { children: [
+          "Default: ",
+          /* @__PURE__ */ jsx9("code", { className: "font-mono", children: String(p.schema.default) })
+        ] }),
+        (p.schema?.minimum !== void 0 || p.schema?.maximum !== void 0) && /* @__PURE__ */ jsxs7("p", { children: [
+          "Range: ",
+          p.schema?.minimum ?? "\u2026",
+          "\u2013",
+          p.schema?.maximum ?? "\u2026"
+        ] })
+      ] })
+    ] }, `${p.in}:${p.name}`)) })
+  ] }) });
+}
+function Examples({ examples }) {
+  return /* @__PURE__ */ jsx9("div", { className: "space-y-2", children: examples.map((ex) => /* @__PURE__ */ jsx9(JsonBlock, { value: ex.value, label: ex.summary ?? ex.name }, ex.name)) });
+}
+function ResponseBlock({
+  response,
+  loadType
+}) {
+  const ok = response.status.startsWith("2");
+  return /* @__PURE__ */ jsxs7("details", { className: "rounded-md border", open: ok || void 0, children: [
+    /* @__PURE__ */ jsxs7("summary", { className: "flex cursor-pointer select-none items-center gap-2 px-3 py-2 text-sm", children: [
+      /* @__PURE__ */ jsx9(
+        "span",
+        {
+          className: `rounded px-1.5 py-0.5 font-mono text-[11px] font-semibold ${ok ? "bg-emerald-500/10 text-emerald-700 dark:text-emerald-300" : "bg-muted text-muted-foreground"}`,
+          children: response.status
+        }
+      ),
+      /* @__PURE__ */ jsx9("span", { className: "text-muted-foreground", children: response.description ?? "" }),
+      response.contentType && /* @__PURE__ */ jsx9("span", { className: "ml-auto font-mono text-[11px] text-muted-foreground", children: response.contentType })
+    ] }),
+    /* @__PURE__ */ jsxs7("div", { className: "space-y-3 border-t p-3", children: [
+      response.headers && response.headers.length > 0 && /* @__PURE__ */ jsxs7("div", { className: "space-y-1", "data-response-headers": true, children: [
+        /* @__PURE__ */ jsx9("p", { className: "text-xs font-medium text-muted-foreground", children: "Headers" }),
+        /* @__PURE__ */ jsx9("dl", { className: "grid grid-cols-[max-content_1fr] gap-x-3 gap-y-1 text-xs", children: response.headers.map((h) => /* @__PURE__ */ jsxs7("div", { className: "contents", children: [
+          /* @__PURE__ */ jsxs7("dt", { className: "font-mono", children: [
+            h.name,
+            h.schema?.type ? /* @__PURE__ */ jsxs7("span", { className: "text-muted-foreground", children: [
+              " ",
+              h.schema.type
+            ] }) : null
+          ] }),
+          /* @__PURE__ */ jsx9("dd", { className: "text-muted-foreground", children: h.description ? md(h.description) : null })
+        ] }, h.name)) })
+      ] }),
+      response.fields && response.fields.length > 0 && /* @__PURE__ */ jsx9(FieldRows, { fields: response.fields, loadType, renderText: md }),
+      response.examples && response.examples.length > 0 ? /* @__PURE__ */ jsx9(Examples, { examples: response.examples }) : isShownSample(response.sample) ? /* @__PURE__ */ jsx9(JsonBlock, { value: response.sample, label: "Example" }) : null
+    ] })
+  ] });
+}
+function SchemeLine({ scheme }) {
+  return /* @__PURE__ */ jsxs7(Fragment4, { children: [
+    /* @__PURE__ */ jsx9("code", { className: "font-mono", children: scheme.scheme }),
+    scheme.schemeDetail ? /* @__PURE__ */ jsxs7("span", { className: "text-muted-foreground", children: [
+      " \u2014 ",
+      scheme.schemeDetail
+    ] }) : null,
+    scheme.scopes && scheme.scopes.length > 0 ? /* @__PURE__ */ jsxs7("span", { className: "text-muted-foreground", children: [
+      " (scopes: ",
+      scheme.scopes.join(", "),
+      ")"
+    ] }) : null
+  ] });
+}
+function SecurityRequirements({ requirements }) {
+  if (requirements.length === 0) {
+    return /* @__PURE__ */ jsx9("p", { className: "text-sm text-muted-foreground", children: "None \u2014 this operation is public." });
+  }
+  const optional = requirements.some((r) => r.schemes.length === 0);
+  const alternatives = requirements.filter((r) => r.schemes.length > 0);
+  if (alternatives.length === 0) {
+    return /* @__PURE__ */ jsx9("p", { className: "text-sm text-muted-foreground", "data-security": "none", children: "None \u2014 this operation needs no credential." });
+  }
+  const lead = optional ? "Optional \u2014 a request may carry no credential, or:" : alternatives.length > 1 ? "Any one of:" : null;
+  return /* @__PURE__ */ jsxs7("div", { className: "space-y-1 text-sm", "data-security": optional ? "optional" : alternatives.length > 1 ? "any-of" : "required", children: [
+    lead && /* @__PURE__ */ jsx9("p", { className: "text-muted-foreground", children: lead }),
+    /* @__PURE__ */ jsx9("ul", { className: "space-y-1", children: alternatives.map((r, i) => /* @__PURE__ */ jsx9("li", { children: r.schemes.map((scheme, j) => /* @__PURE__ */ jsxs7("span", { children: [
+      j > 0 ? /* @__PURE__ */ jsx9("span", { className: "text-muted-foreground", children: " and " }) : null,
+      /* @__PURE__ */ jsx9(SchemeLine, { scheme })
+    ] }, scheme.scheme)) }, i)) })
+  ] });
+}
+function OpDoc({
+  op,
+  availability,
+  availabilityPublished,
+  sandbox,
+  host
+}) {
+  const gate = tryItGate({
+    method: op.method,
+    ...host.isWrite ? { write: host.isWrite(op) } : {},
+    availability,
+    availabilityPublished,
+    sandbox
+  });
+  const requestExamples = op.requestExamples ?? [];
+  const loadType = host.loadType ? (ref) => host.loadType(ref) : void 0;
+  return /* @__PURE__ */ jsxs7("article", { className: "space-y-5", "data-op": op.id, children: [
+    /* @__PURE__ */ jsxs7("header", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsxs7("div", { className: "flex flex-wrap items-center gap-2", children: [
+        /* @__PURE__ */ jsx9(MethodLabel, { method: op.method }),
+        /* @__PURE__ */ jsx9("code", { className: "font-mono text-sm", children: op.route }),
+        /* @__PURE__ */ jsx9(AvailabilityBadge, { availability }),
+        op.deprecated && /* @__PURE__ */ jsx9("span", { className: "rounded border px-1.5 py-0.5 text-[11px] text-muted-foreground", children: "Deprecated" })
+      ] }),
+      /* @__PURE__ */ jsx9("h2", { className: "text-lg font-semibold", children: op.summary ?? op.name }),
+      op.operationId && /* @__PURE__ */ jsx9("p", { className: "font-mono text-[11px] text-muted-foreground", children: op.operationId })
+    ] }),
+    op.description && /* @__PURE__ */ jsx9(DocsMarkdown, { text: op.description, className: "text-sm" }),
+    op.security && /* @__PURE__ */ jsx9(Section, { title: "Authentication", children: /* @__PURE__ */ jsx9(SecurityRequirements, { requirements: op.security }) }),
+    op.parameters && op.parameters.length > 0 && /* @__PURE__ */ jsx9(Section, { title: "Parameters", children: /* @__PURE__ */ jsx9(ParametersTable, { parameters: op.parameters }) }),
+    (op.requestBody || op.request.length > 0) && /* @__PURE__ */ jsxs7(Section, { title: "Request body", children: [
+      op.requestBody && /* @__PURE__ */ jsxs7("p", { className: "text-xs text-muted-foreground", "data-request-body": true, children: [
+        op.requestBody.required ? "Required" : "Optional",
+        op.requestBody.contentType ? /* @__PURE__ */ jsxs7(Fragment4, { children: [
+          " \xB7 ",
+          /* @__PURE__ */ jsx9("code", { className: "font-mono", children: op.requestBody.contentType })
+        ] }) : null
+      ] }),
+      op.requestBody?.description && /* @__PURE__ */ jsx9(DocsMarkdown, { text: op.requestBody.description, className: "text-sm" }),
+      op.request.length > 0 && /* @__PURE__ */ jsx9(FieldRows, { fields: op.request, loadType, renderText: md }),
+      requestExamples.length > 0 ? /* @__PURE__ */ jsx9(Examples, { examples: requestExamples }) : isShownSample(op.sampleRequest) ? /* @__PURE__ */ jsx9(JsonBlock, { value: op.sampleRequest, label: "Example" }) : null
+    ] }),
+    op.responses && op.responses.length > 0 && /* @__PURE__ */ jsx9(Section, { title: "Responses", children: /* @__PURE__ */ jsx9("div", { className: "space-y-2", children: op.responses.map((r) => /* @__PURE__ */ jsx9(ResponseBlock, { response: r, loadType }, r.status)) }) }),
+    host.renderTryIt ? /* @__PURE__ */ jsxs7(Section, { title: "Try it", children: [
+      !gate.runnable && /* @__PURE__ */ jsx9("p", { className: "text-sm text-muted-foreground", "data-try-it-refused": true, children: gate.reason }),
+      host.renderTryIt(op, gate)
+    ] }) : null
+  ] });
+}
+
+// packages/canvas-api-docs/src/docs/reference-view.tsx
+import { Fragment as Fragment5, jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var METHOD_TONE = {
+  GET: "text-emerald-700 dark:text-emerald-400",
+  POST: "text-blue-700 dark:text-blue-400",
+  PUT: "text-amber-700 dark:text-amber-400",
+  PATCH: "text-amber-700 dark:text-amber-400",
+  DELETE: "text-red-700 dark:text-red-400"
+};
+function MethodLabel({ method }) {
+  const m = method.toUpperCase();
+  return /* @__PURE__ */ jsx10("span", { className: `inline-block w-14 shrink-0 font-mono text-[11px] font-semibold ${METHOD_TONE[m] ?? "text-muted-foreground"}`, children: m });
+}
+function ReferenceView(props) {
+  const { selected, host } = props;
+  const loadOp = host.loadOp;
+  const groups = referenceGroups(props.index, props.tags);
+  const [fetched, setFetched] = useState5(null);
+  const preloaded = selected && props.preloadedOp?.id === selected ? props.preloadedOp : void 0;
+  const loaded = preloaded ? { id: preloaded.id, op: preloaded } : fetched;
+  useEffect3(() => {
+    if (!selected) {
+      setFetched(null);
+      return;
+    }
+    if (preloaded) return;
+    let cancelled = false;
+    loadOp(selected).then(
+      (op) => !cancelled && setFetched({ id: selected, op }),
+      () => !cancelled && setFetched({ id: selected, error: "This operation's documentation could not be read." })
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [selected, loadOp, preloaded]);
+  return /* @__PURE__ */ jsxs8("div", { className: "space-y-6", children: [
+    /* @__PURE__ */ jsxs8("header", { className: "space-y-1", children: [
+      /* @__PURE__ */ jsx10("h1", { className: "text-2xl font-semibold", children: props.label }),
+      /* @__PURE__ */ jsxs8("p", { className: "text-sm text-muted-foreground", children: [
+        props.index.length,
+        " operations",
+        props.serverUrl ? /* @__PURE__ */ jsxs8(Fragment5, { children: [
+          " ",
+          "on ",
+          /* @__PURE__ */ jsx10("code", { className: "font-mono", children: props.serverUrl })
+        ] }) : null,
+        ".",
+        !props.serverUrl && props.calledThrough ? /* @__PURE__ */ jsxs8("span", { "data-testid": "docs-called-through", children: [
+          " ",
+          props.calledThrough,
+          "."
+        ] }) : null
+      ] })
+    ] }),
+    selected && /* @__PURE__ */ jsx10("section", { "aria-live": "polite", className: "rounded-md border p-4", children: !loaded || loaded.id !== selected ? /* @__PURE__ */ jsx10("p", { className: "text-sm text-muted-foreground", children: "Loading\u2026" }) : "error" in loaded ? /* @__PURE__ */ jsx10("p", { className: "text-sm text-destructive", children: loaded.error }) : /* @__PURE__ */ jsx10(
+      OpDoc,
+      {
+        op: loaded.op,
+        availability: availabilityOf(props.bundle, selected),
+        availabilityPublished: Boolean(props.bundle?.availability),
+        sandbox: props.sandbox,
+        host
+      }
+    ) }),
+    /* @__PURE__ */ jsx10("div", { className: "space-y-2", children: groups.map((g) => /* @__PURE__ */ jsxs8("details", { className: "rounded-md border", open: g.ops.some((o) => o.id === selected) || void 0, children: [
+      /* @__PURE__ */ jsxs8("summary", { className: "cursor-pointer select-none px-3 py-2 text-sm font-medium", children: [
+        g.tag,
+        " ",
+        /* @__PURE__ */ jsxs8("span", { className: "text-muted-foreground", children: [
+          "(",
+          g.ops.length,
+          ")"
+        ] })
+      ] }),
+      g.description && /* @__PURE__ */ jsx10(DocsMarkdown, { text: g.description, className: "px-3 pb-2 text-xs text-muted-foreground" }),
+      /* @__PURE__ */ jsx10("ul", { className: "border-t", children: g.ops.map((o) => /* @__PURE__ */ jsx10("li", { children: /* @__PURE__ */ jsxs8(
+        "a",
+        {
+          href: props.hrefFor(o.id),
+          "aria-current": o.id === selected ? "true" : void 0,
+          onClick: (e) => {
+            if (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0) return;
+            e.preventDefault();
+            props.onSelect(o.id);
+          },
+          className: `flex items-center gap-2 px-3 py-1.5 text-sm hover:bg-muted/50 ${o.id === selected ? "bg-muted" : ""}`,
+          children: [
+            /* @__PURE__ */ jsx10(MethodLabel, { method: o.method }),
+            /* @__PURE__ */ jsx10("span", { className: "min-w-0 flex-1 truncate font-mono text-xs", children: o.route }),
+            /* @__PURE__ */ jsx10("span", { className: "hidden truncate text-xs text-muted-foreground md:inline", children: o.summary ?? o.name }),
+            /* @__PURE__ */ jsx10(AvailabilityBadge, { availability: availabilityOf(props.bundle, o.id) })
+          ]
+        }
+      ) }, o.id)) })
+    ] }, g.tag)) })
+  ] });
+}
+
+// packages/canvas-api-docs/src/docs/docs-source-view.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function NavLink({
+  active,
+  href,
+  onClick,
+  children
+}) {
+  return /* @__PURE__ */ jsx11(
+    "a",
+    {
+      href,
+      "aria-current": active ? "page" : void 0,
+      onClick: (e) => {
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0) return;
+        e.preventDefault();
+        onClick();
+      },
+      className: `block rounded px-2 py-1 text-sm ${active ? "bg-muted font-medium text-foreground" : "text-muted-foreground hover:bg-muted/60 hover:text-foreground"}`,
+      children
+    }
+  );
+}
+function DocsSourceView(props) {
+  const { bundle, location, onNavigate, hrefFor, sandbox } = props;
+  const groups = navGroups(bundle);
+  const landing = bundle?.config.landing;
+  const title = bundle?.config.title ?? props.title;
+  const reference = bundle?.config.reference;
+  const hasReference = reference !== false;
+  const referenceLabel = (reference || void 0)?.label ?? "API Reference";
+  const go = (loc) => () => onNavigate(loc);
+  const page = location.kind === "page" ? docsPage(bundle, location.page) : void 0;
+  const landingPage = landing ? docsPage(bundle, landing) : void 0;
+  let main;
+  if (page) {
+    main = /* @__PURE__ */ jsx11(GuidePage, { page, pageId: location.kind === "page" ? location.page : void 0, images: bundle?.images });
+  } else if (location.kind === "events" && bundle?.events) {
+    main = /* @__PURE__ */ jsx11(EventsView, { catalog: bundle.events, focus: location.event });
+  } else if (!hasReference) {
+    main = landingPage ? /* @__PURE__ */ jsx11(GuidePage, { page: landingPage, pageId: landing, images: bundle?.images }) : null;
+  } else {
+    main = /* @__PURE__ */ jsx11(
+      ReferenceView,
+      {
+        label: referenceLabel,
+        index: props.index,
+        tags: props.tags,
+        bundle,
+        sandbox,
+        serverUrl: bundle?.config.serverUrl,
+        calledThrough: props.host.calledThrough,
+        selected: location.kind === "reference" ? location.op : void 0,
+        preloadedOp: props.preloadedOp,
+        onSelect: (op) => onNavigate({ kind: "reference", ...op ? { op } : {} }),
+        hrefFor: (op) => hrefFor({ kind: "reference", op }),
+        host: props.host
+      }
+    );
+  }
+  const resolveRelativeLink = (href) => {
+    const loc = resolveDocsLink(href, bundle);
+    if (!loc) return null;
+    return {
+      href: hrefFor(loc),
+      onClick: (e) => {
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0) return;
+        e.preventDefault();
+        onNavigate(loc);
+      }
+    };
+  };
+  return /* @__PURE__ */ jsx11(DocsLinkContext.Provider, { value: resolveRelativeLink, children: /* @__PURE__ */ jsxs9("div", { className: "flex min-h-0 gap-6", "data-docs-source": title, children: [
+    /* @__PURE__ */ jsxs9("aside", { className: "w-56 shrink-0 space-y-4", "aria-label": `${title} documentation`, children: [
+      /* @__PURE__ */ jsxs9("div", { className: "space-y-1 px-2", children: [
+        /* @__PURE__ */ jsx11("p", { className: "font-semibold leading-tight", children: title }),
+        sandbox !== null && /* @__PURE__ */ jsx11("p", { className: "text-[11px] text-muted-foreground", "data-sandbox": sandbox ?? "live", children: SANDBOX_LABELS[sandbox ?? "live"] })
+      ] }),
+      landing && landingPage && /* @__PURE__ */ jsx11(
+        NavLink,
+        {
+          active: location.kind === "page" && location.page === landing,
+          href: hrefFor({ kind: "page", page: landing }),
+          onClick: go({ kind: "page", page: landing }),
+          children: landingPage.title
+        }
+      ),
+      groups.map((g) => /* @__PURE__ */ jsxs9("div", { className: "space-y-0.5", children: [
+        /* @__PURE__ */ jsx11("p", { className: "px-2 text-[11px] font-medium uppercase tracking-wide text-muted-foreground", children: g.group }),
+        g.pages.map((p) => /* @__PURE__ */ jsx11(
+          NavLink,
+          {
+            active: location.kind === "page" && location.page === p.id,
+            href: hrefFor({ kind: "page", page: p.id }),
+            onClick: go({ kind: "page", page: p.id }),
+            children: p.title
+          },
+          p.id
+        ))
+      ] }, g.group)),
+      /* @__PURE__ */ jsxs9("div", { className: "space-y-0.5", children: [
+        hasReference && /* @__PURE__ */ jsx11(
+          NavLink,
+          {
+            active: location.kind === "reference",
+            href: hrefFor({ kind: "reference" }),
+            onClick: go({ kind: "reference" }),
+            children: referenceLabel
+          }
+        ),
+        bundle?.events && /* @__PURE__ */ jsx11(NavLink, { active: location.kind === "events", href: hrefFor({ kind: "events" }), onClick: go({ kind: "events" }), children: "Events" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx11("div", { className: "min-w-0 flex-1", children: main })
+  ] }) });
+}
+
+// packages/mesh-cli/src/docs/preview-source.ts
+import { readFileSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+function resolveDocsConfigPath(target) {
+  const abs = resolve(target);
+  let stat;
+  try {
+    stat = statSync(abs);
+  } catch {
+    throw new Error(`No docs source at ${abs} \u2014 pass the directory that holds docs.yaml, or docs.yaml itself`);
+  }
+  if (stat.isFile()) {
+    if (basename(abs) !== "docs.yaml") throw new Error(`${abs} is not a docs.yaml`);
+    return abs;
+  }
+  const configPath = join(abs, "docs.yaml");
+  try {
+    if (statSync(configPath).isFile()) return configPath;
+  } catch {
+  }
+  throw new Error(`No docs.yaml in ${abs}`);
+}
+function missingEventsCatalogProblem(service) {
+  return `docs.yaml names events "${service}", but no events catalog was supplied`;
+}
+function readPreviewSource(configPath, opts = {}) {
+  const built = buildDocsSource({ configPath, ...opts.specPath ? { specPath: resolve(opts.specPath) } : {} });
+  const { config } = built.bundle;
+  const notes = [];
+  let problems = built.problems;
+  if (config.events) {
+    const expected = missingEventsCatalogProblem(config.events);
+    if (problems.includes(expected)) {
+      problems = problems.filter((p) => p !== expected);
+      notes.push(
+        `events: the catalog of ${config.events} is built from the app's event definitions at deploy, so the preview has no Events section`
+      );
+    }
+  }
+  notes.push("availability: each operation's availability is published by the deploy, so the preview shows none");
+  let specText;
+  try {
+    specText = readFileSync(built.specPath, "utf8");
+  } catch {
+    specText = void 0;
+  }
+  return {
+    configPath: resolve(configPath),
+    specPath: built.specPath,
+    bundle: built.bundle,
+    ...specText !== void 0 ? { specText } : {},
+    problems,
+    notes
+  };
+}
+
+// packages/mesh-cli/src/docs/preview.ts
+globalThis.React ??= React;
+var PREVIEW_CSS_PATH = "/docs-preview.css";
+function previewCssFile() {
+  return join2(findPackageRoot(), "assets", "docs-preview.css");
+}
+function displayPath(file) {
+  const rel = relative(process.cwd(), file);
+  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : file;
+}
+function escapeHtml(text) {
+  return text.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+function engineCache() {
+  let last;
+  return (specText) => {
+    if (specText === void 0) return void 0;
+    if (last?.text === specText) return last.engine;
+    let engine;
+    try {
+      engine = buildEngine(JSON.parse(specText));
+    } catch {
+      engine = void 0;
+    }
+    last = { text: specText, engine };
+    return engine;
+  };
+}
+function renderPreviewPage(input) {
+  const { source, engine, search } = input;
+  const { bundle } = source;
+  const title = bundle.config.title;
+  const notices = [];
+  let status = 200;
+  let location = locationFromParams(search, bundle);
+  const askedPage = search.get("page");
+  if (askedPage && !(location.kind === "page" && location.page === askedPage)) {
+    status = 404;
+    notices.push(`This source has no page "${askedPage}".`);
+  }
+  if (search.get("section") === "events" && !bundle.events) {
+    notices.push(
+      bundle.config.events ? `The events of ${bundle.config.events} are documented from the catalog the deploy builds; the preview has none.` : "This source documents no events."
+    );
+  }
+  let op;
+  if (location.kind === "reference" && location.op) {
+    op = engine?.getOp(location.op) ?? void 0;
+    if (!op) {
+      status = 404;
+      notices.push(`The spec has no operation "${location.op}".`);
+      location = { kind: "reference" };
+    }
+  }
+  const view = React.createElement(DocsSourceView, {
+    bundle,
+    title,
+    index: engine?.index() ?? [],
+    tags: engine?.tags() ?? [],
+    location,
+    onNavigate: () => {
+    },
+    hrefFor: (loc) => `?${locationToParams(loc).toString()}`,
+    host: {
+      loadOp: (id) => {
+        const slice = engine?.getOp(id);
+        return slice ? Promise.resolve(slice) : Promise.reject(new Error(`no operation ${id}`));
+      }
+    },
+    ...op ? { preloadedOp: op } : {}
+  });
+  const heading = location.kind === "page" ? docsPage(bundle, location.page)?.title ?? title : location.kind === "events" ? "Events" : op ? op.summary ?? op.name : (bundle.config.reference || void 0)?.label ?? "API Reference";
+  return {
+    status,
+    html: previewDocument({
+      title: heading === title ? title : `${heading} \xB7 ${title}`,
+      source,
+      notices,
+      body: renderToString(view)
+    })
+  };
+}
+function previewChrome(source) {
+  const where = displayPath(source.configPath);
+  return `<header class="border-b bg-muted/40">
+<div class="mx-auto flex max-w-7xl flex-wrap items-center gap-x-4 gap-y-1 px-6 py-3 text-sm">
+<span class="font-semibold">Docs preview</span>
+<code class="font-mono text-xs text-muted-foreground">${escapeHtml(where)}</code>
+<span class="ml-auto text-xs text-muted-foreground" data-preview-try-it>Try-it runs in the Hub \u2014 this preview renders the docs only.</span>
+</div>
+</header>`;
+}
+function list(items) {
+  return `<ul class="mt-2 list-disc space-y-1 pl-5">${items.map((i) => `<li>${escapeHtml(i)}</li>`).join("")}</ul>`;
+}
+function previewDocument(input) {
+  const { source, notices } = input;
+  const problems = source.problems.length ? `<section role="alert" class="mx-auto max-w-7xl px-6 pt-4" data-preview-problems="${source.problems.length}">
+<div class="rounded-md border border-destructive/50 bg-destructive/5 p-4 text-sm">
+<p class="font-semibold text-destructive">${source.problems.length} problem${source.problems.length === 1 ? "" : "s"} \u2014 the deploy refuses this source until ${source.problems.length === 1 ? "it is" : "they are"} fixed</p>
+${list(source.problems)}
+</div>
+</section>` : "";
+  const noticeBlock = notices.length ? `<section class="mx-auto max-w-7xl px-6 pt-4" data-preview-notices>
+<div class="rounded-md border bg-muted/40 p-4 text-sm">${list(notices)}</div>
+</section>` : "";
+  const notes = source.notes.length ? `<details class="mx-auto max-w-7xl px-6 pt-4 text-xs text-muted-foreground">
+<summary class="cursor-pointer select-none">What the preview does not show</summary>
+${list(source.notes)}
+</details>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(input.title)} \u2014 docs preview</title>
+<link rel="stylesheet" href="${PREVIEW_CSS_PATH}">
+</head>
+<body class="bg-background text-foreground antialiased">
+${previewChrome(source)}
+${problems}
+${noticeBlock}
+${notes}
+<main class="mx-auto max-w-7xl px-6 py-6">${input.body}</main>
+</body>
+</html>
+`;
+}
+function errorDocument(configPath, heading, message) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(heading)} \u2014 docs preview</title>
+<link rel="stylesheet" href="${PREVIEW_CSS_PATH}">
+</head>
+<body class="bg-background text-foreground antialiased">
+${previewChrome({ configPath })}
+<section role="alert" class="mx-auto max-w-7xl px-6 pt-4">
+<div class="rounded-md border border-destructive/50 bg-destructive/5 p-4 text-sm">
+<p class="font-semibold text-destructive">${escapeHtml(heading)}</p>
+<pre class="mt-2 whitespace-pre-wrap font-mono text-xs">${escapeHtml(message)}</pre>
+</div>
+</section>
+</body>
+</html>
+`;
+}
+async function startPreviewServer(args) {
+  const engineFor = engineCache();
+  const cssFile = args.cssFile ?? previewCssFile();
+  const message = (error) => error instanceof Error ? error.message : String(error);
+  const pageFor = (search) => {
+    let source;
+    try {
+      source = readPreviewSource(args.configPath, { specPath: args.specPath });
+    } catch (error) {
+      return { status: 500, html: errorDocument(args.configPath, "The source cannot be read", message(error)) };
+    }
+    try {
+      return renderPreviewPage({ source, engine: engineFor(source.specText), search });
+    } catch (error) {
+      return { status: 500, html: errorDocument(args.configPath, "The page cannot be rendered", message(error)) };
+    }
+  };
+  const handle = (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { allow: "GET, HEAD", "content-type": "text/plain; charset=utf-8" }).end("Method not allowed\n");
+      return;
+    }
+    if (url.pathname === PREVIEW_CSS_PATH) {
+      let css;
+      try {
+        css = readFileSync2(cssFile, "utf8");
+      } catch {
+        res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Stylesheet not found\n");
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/css; charset=utf-8", "cache-control": "no-cache" }).end(css);
+      return;
+    }
+    if (url.pathname !== "/") {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Not found \u2014 the preview is served at /\n");
+      return;
+    }
+    const page = pageFor(url.searchParams);
+    res.writeHead(page.status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+    res.end(req.method === "HEAD" ? void 0 : page.html);
+  };
+  const server = createServer(handle);
+  await new Promise((resolvePromise, reject) => {
+    server.once("error", (error) => {
+      reject(
+        error.code === "EADDRINUSE" ? new Error(`Port ${args.port} is already in use \u2014 pass --port <n> for another one (0 picks a free port)`) : error
+      );
+    });
+    server.listen(args.port, "127.0.0.1", () => resolvePromise());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : args.port;
+  return {
+    url: `http://localhost:${port}`,
+    port,
+    close: () => new Promise((resolvePromise) => server.close(() => resolvePromise()))
+  };
+}
+function reportProblems(source) {
+  if (source.problems.length === 0) {
+    logSuccess(`${source.bundle.config.title}: no problems`);
+  } else {
+    logWarn(
+      `${source.bundle.config.title}: ${source.problems.length} problem${source.problems.length === 1 ? "" : "s"} \u2014 the deploy refuses this source until ${source.problems.length === 1 ? "it is" : "they are"} fixed:`
+    );
+    for (const problem of source.problems) console.error(`    - ${problem}`);
+  }
+  for (const note of source.notes) logInfo(`note \u2014 ${note}`);
+}
+async function runDocsPreview(opts) {
+  const configPath = resolveDocsConfigPath(opts.target);
+  if (opts.check || opts.out) {
+    const source = readPreviewSource(configPath, { specPath: opts.spec });
+    reportProblems(source);
+    if (opts.out) {
+      const outPath = resolve2(opts.out);
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, `${JSON.stringify(source.bundle, null, 2)}
+`);
+      logSuccess(`Docs source bundle \u2192 ${displayPath(outPath)}`);
+    }
+    return !opts.check || source.problems.length === 0;
+  }
+  const port = Number(opts.port);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`--port must be a port number (0 picks a free one), not "${opts.port}"`);
+  }
+  try {
+    reportProblems(readPreviewSource(configPath, { specPath: opts.spec }));
+  } catch (error) {
+    logError(error instanceof Error ? error.message : String(error));
+  }
+  const server = await startPreviewServer({ configPath, ...opts.spec ? { specPath: opts.spec } : {}, port });
+  logSuccess(`Docs preview \u2192 ${server.url}/  (re-reads ${displayPath(configPath)} on every request; Ctrl-C to stop)`);
+  await new Promise((resolvePromise) => {
+    const stop = () => void server.close().then(resolvePromise);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  return true;
+}
+export {
+  PREVIEW_CSS_PATH,
+  previewCssFile,
+  renderPreviewPage,
+  runDocsPreview,
+  startPreviewServer
+};