@contractspec/lib.contracts 1.62.0 → 1.63.0

package/dist/docs/contracts.js

@@ -1,2383 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/registry-utils.ts
-var exports_registry_utils = {};
-__export(exports_registry_utils, {
-  groupByToArray: () => groupByToArray,
-  groupByMultiple: () => groupByMultiple,
-  groupBy: () => groupBy,
-  getUniqueTags: () => getUniqueTags,
-  getUniqueOwners: () => getUniqueOwners,
-  getUniqueDomains: () => getUniqueDomains,
-  filterBy: () => filterBy,
-  GroupingStrategies: () => GroupingStrategies
-});
-function filterBy(items, filter) {
-  return items.filter((item) => {
-    if (filter.tags?.length) {
-      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
-      if (!hasMatchingTag)
-        return false;
-    }
-    if (filter.owners?.length) {
-      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
-      if (!hasMatchingOwner)
-        return false;
-    }
-    if (filter.stability?.length) {
-      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
-        return false;
-      }
-    }
-    if (filter.domain) {
-      const itemDomain = GroupingStrategies.byDomain(item);
-      if (itemDomain !== filter.domain)
-        return false;
-    }
-    if (filter.keyPattern) {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      if (!regex.test(name))
-        return false;
-    }
-    return true;
-  });
-}
-function groupBy(items, keyFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const key = keyFn(item);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      groups.set(key, [item]);
-    }
-  }
-  return groups;
-}
-function groupByToArray(items, keyFn) {
-  const map = groupBy(items, keyFn);
-  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
-}
-function groupByMultiple(items, keysFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const keys = keysFn(item);
-    for (const key of keys) {
-      const existing = groups.get(key);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(key, [item]);
-      }
-    }
-  }
-  return groups;
-}
-function getUniqueTags(items) {
-  const tags = new Set;
-  for (const item of items) {
-    for (const tag of item.meta.tags ?? []) {
-      tags.add(tag);
-    }
-  }
-  return Array.from(tags).sort();
-}
-function getUniqueOwners(items) {
-  const owners = new Set;
-  for (const item of items) {
-    for (const owner of item.meta.owners ?? []) {
-      owners.add(owner);
-    }
-  }
-  return Array.from(owners).sort();
-}
-function getUniqueDomains(items) {
-  const domains = new Set;
-  for (const item of items) {
-    domains.add(GroupingStrategies.byDomain(item));
-  }
-  return Array.from(domains).sort();
-}
-var GroupingStrategies;
-var init_registry_utils = __esm(() => {
-  GroupingStrategies = {
-    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
-    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
-    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
-    byDomain: (item) => {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      return name.split(".")[0] ?? "default";
-    },
-    byStability: (item) => item.meta.stability ?? "stable",
-    byUrlPath: (level) => (item) => {
-      if (!item.path)
-        return "root";
-      const segments = item.path.split("/").filter(Boolean);
-      return segments.slice(0, level).join("/") || "root";
-    }
-  };
-});
-
-// src/ownership.ts
-var StabilityEnum = {
-  Idea: "idea",
-  InCreation: "in_creation",
-  Experimental: "experimental",
-  Beta: "beta",
-  Stable: "stable",
-  Deprecated: "deprecated"
-};
-var OwnersEnum = {
-  PlatformCore: "platform.core",
-  PlatformSigil: "platform.sigil",
-  PlatformMarketplace: "platform.marketplace",
-  PlatformMessaging: "platform.messaging",
-  PlatformContent: "platform.content",
-  PlatformFeatureFlags: "platform.featureflags",
-  PlatformFinance: "platform.finance"
-};
-var Owners = OwnersEnum;
-var TagsEnum = {
-  Spots: "spots",
-  Collectivity: "collectivity",
-  Marketplace: "marketplace",
-  Sellers: "sellers",
-  Auth: "auth",
-  Login: "login",
-  Signup: "signup",
-  Guide: "guide",
-  Docs: "docs",
-  I18n: "i18n",
-  Incident: "incident",
-  Automation: "automation",
-  Hygiene: "hygiene"
-};
-var Tags = TagsEnum;
-
-// src/operations/operation.ts
-var isEmitDeclRef = (e) => ("ref" in e);
-var defineCommand = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "command" },
-  policy: {
-    ...spec.policy,
-    idempotent: spec.policy?.["policy"]?.idempotent ?? false
-  }
-});
-var defineQuery = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "query" },
-  policy: { ...spec.policy, idempotent: true }
-});
-
-// src/registry.ts
-init_registry_utils();
-import { compareVersions } from "compare-versions";
-var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
-
-class SpecContractRegistry {
-  contractType;
-  items = new Map;
-  constructor(contractType, items) {
-    this.contractType = contractType;
-    if (items) {
-      items.forEach((p) => this.register(p));
-    }
-  }
-  register(p) {
-    const key = keyOfSpecContract(p);
-    if (this.items.has(key))
-      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
-    this.items.set(key, p);
-    return this;
-  }
-  count() {
-    return this.items.size;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, p] of this.items.entries()) {
-      if (!k.startsWith(`${key}.v`))
-        continue;
-      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
-        candidate = p;
-      }
-    }
-    return candidate;
-  }
-  has(key, version) {
-    return !!this.get(key, version);
-  }
-  filter(criteria) {
-    return filterBy(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((p) => p.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((p) => p.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    return groupBy(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    return getUniqueTags(this.list());
-  }
-}
-
-// src/events.ts
-function defineEvent(e) {
-  return e;
-}
-var eventKey = (key, version) => `${key}.v${version}`;
-
-class EventRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("event", items);
-  }
-}
-
-// src/operations/registry.ts
-function opKey(key, version) {
-  return `${key}.v${version}`;
-}
-
-class OperationSpecRegistry extends SpecContractRegistry {
-  handlers = new Map;
-  constructor(items) {
-    super("operation", items);
-  }
-  bind(spec, handler) {
-    const key = opKey(spec.meta.key, spec.meta.version);
-    if (!this.items.has(key))
-      throw new Error(`Cannot bind; spec not found: ${key}`);
-    if (this.handlers.has(key))
-      throw new Error(`Handler already bound for ${key}`);
-    this.handlers.set(key, handler);
-    return this;
-  }
-  getHandler(key, version) {
-    const spec = this.get(key, version);
-    if (!spec)
-      return;
-    return this.handlers.get(opKey(spec.meta.key, spec.meta.version));
-  }
-  listBound() {
-    const out = [];
-    for (const [k, spec] of this.items.entries()) {
-      const h = this.handlers.get(k);
-      if (h)
-        out.push({ spec, handler: h });
-    }
-    return out;
-  }
-  async execute(key, version, rawInput, ctx) {
-    const baseSpec = this.get(key, version);
-    if (!baseSpec)
-      throw new Error(`Spec not found for ${key}${version ? `.v${version}` : ""}`);
-    const spec = await ctx.specVariantResolver?.resolve({
-      name: baseSpec.meta.key,
-      version: baseSpec.meta.version,
-      kind: baseSpec.meta.kind
-    }, ctx) ?? baseSpec;
-    let handlerKey = opKey(spec.meta.key, spec.meta.version);
-    let handler = this.handlers.get(handlerKey);
-    if (!handler) {
-      const fallbackKey = opKey(baseSpec.meta.key, baseSpec.meta.version);
-      handler = this.handlers.get(fallbackKey);
-      handlerKey = fallbackKey;
-    }
-    if (!handler)
-      throw new Error(`No handler bound for ${handlerKey}`);
-    const parsedInput = spec.io.input?.getZod().parse(rawInput);
-    if (ctx.decide) {
-      const [service, command] = spec.meta.key.split(".");
-      if (!service || !command)
-        throw new Error(`Invalid spec name: ${spec.meta.key}`);
-      const decision = await ctx.decide({
-        service,
-        command,
-        version: spec.meta.version,
-        actor: ctx.actor ?? "anonymous",
-        channel: ctx.channel,
-        roles: ctx.roles,
-        organizationId: ctx.organizationId,
-        userId: ctx.userId,
-        flags: []
-      });
-      if (decision.effect === "deny") {
-        throw new Error(`PolicyDenied: ${spec.meta.key}.v${spec.meta.version}`);
-      }
-      if (decision.rateLimit && ctx.rateLimit) {
-        const key2 = decision.rateLimit.key ?? "default";
-        const rpm = decision.rateLimit.rpm ?? 60;
-        await ctx.rateLimit(key2, 1, rpm);
-      }
-    }
-    const allowedEvents = new Map;
-    if (spec.sideEffects?.emits) {
-      for (const e of spec.sideEffects.emits) {
-        if (isEmitDeclRef(e)) {
-          const eventSpec = ctx.eventSpecResolver?.get(e.ref.key, e.ref.version);
-          if (eventSpec) {
-            allowedEvents.set(`${e.ref.key}.v${e.ref.version}`, eventSpec.payload);
-          }
-        } else {
-          allowedEvents.set(`${e.key}.v${e.version}`, e.payload);
-        }
-      }
-    }
-    const emitGuard = async (eventName, eventVersion, payload) => {
-      const key2 = eventKey(eventName, eventVersion);
-      const schema = allowedEvents.get(key2);
-      if (!schema)
-        throw new Error(`UndeclaredEvent: ${key2} not allowed by ${opKey(spec.meta.key, spec.meta.version)}`);
-      const parsed = schema.getZod().parse(payload);
-      await ctx.eventPublisher?.({
-        key: eventName,
-        version: eventVersion,
-        payload: parsed,
-        traceId: ctx.traceId
-      });
-    };
-    if (ctx.appConfig) {
-      if (!ctx.branding) {
-        ctx.branding = ctx.appConfig.branding;
-      }
-      if (!ctx.translation) {
-        ctx.translation = { config: ctx.appConfig.translation };
-      } else if (!ctx.translation.config) {
-        ctx.translation = {
-          ...ctx.translation,
-          config: ctx.appConfig.translation
-        };
-      }
-    }
-    const telemetryContext = ctx.telemetry;
-    const trackTelemetry = async (trigger, details) => {
-      if (!telemetryContext || !trigger?.event)
-        return;
-      try {
-        const props = trigger.properties?.(details) ?? {};
-        await telemetryContext.track(trigger.event.key, trigger.event.version ?? "1.0.0", props, {
-          tenantId: ctx.organizationId ?? undefined,
-          organizationId: ctx.organizationId,
-          userId: ctx.userId,
-          actor: ctx.actor,
-          channel: ctx.channel,
-          metadata: ctx.traceId ? { traceId: ctx.traceId } : undefined
-        });
-      } catch (_error) {}
-    };
-    let result;
-    try {
-      result = await handler(parsedInput, {
-        ...ctx,
-        __emitGuard__: emitGuard
-      });
-    } catch (error) {
-      if (spec.telemetry?.failure) {
-        await trackTelemetry(spec.telemetry.failure, {
-          input: parsedInput ?? rawInput,
-          error
-        });
-      }
-      throw error;
-    }
-    if (spec.telemetry?.success) {
-      await trackTelemetry(spec.telemetry.success, {
-        input: parsedInput ?? rawInput,
-        output: result
-      });
-    }
-    const outputModel = spec.io.output;
-    if (outputModel?.getZod) {
-      const parsedOutput = outputModel.getZod().parse(result);
-      return parsedOutput;
-    }
-    return result;
-  }
-}
-
-// src/operations/report/getContractVerificationStatus.ts
-import {
-  ScalarTypeEnum,
-  SchemaModel,
-  ZodSchemaType
-} from "@contractspec/lib.schema";
-import * as z from "zod";
-var REPORT_DOMAIN = "report";
-var REPORT_OWNERS = ["platform.core"];
-var REPORT_TAGS = ["report", "drift", "verification"];
-var REPORT_STABILITY = StabilityEnum.Experimental;
-var ContractVerificationStatusModel = new SchemaModel({
-  name: "ContractVerificationStatus",
-  fields: {
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    lastVerifiedSha: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    lastVerifiedDate: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    surfaces: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-      isArray: true
-    },
-    driftMismatches: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    }
-  }
-});
-var GetContractVerificationStatusInput = new SchemaModel({
-  name: "GetContractVerificationStatusInput",
-  fields: {
-    projectPath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    baseline: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var GetContractVerificationStatusOutput = new ZodSchemaType(z.object({
-  contracts: z.object({
-    name: z.string(),
-    lastVerifiedSha: z.string().optional(),
-    lastVerifiedDate: z.string().optional(),
-    surfaces: z.string().array(),
-    driftMismatches: z.int()
-  }).array()
-}), {
-  name: "GetContractVerificationStatusOutput"
-});
-var GetContractVerificationStatusQuery = defineQuery({
-  meta: {
-    key: "report.getContractVerificationStatus",
-    title: "Get Contract Verification Status",
-    version: "1.0.0",
-    description: "Retrieves per-contract verification status for the impact report.",
-    goal: "Enable stakeholders to see contract health at a glance.",
-    context: "Part of the impact report domain. Reads from drift check outputs and verified.json to provide a consolidated view of each contract's drift debt and surface coverage.",
-    domain: REPORT_DOMAIN,
-    owners: REPORT_OWNERS,
-    tags: REPORT_TAGS,
-    stability: REPORT_STABILITY
-  },
-  io: {
-    input: GetContractVerificationStatusInput,
-    output: GetContractVerificationStatusOutput,
-    errors: {
-      PROJECT_NOT_FOUND: {
-        description: "Project path does not exist.",
-        http: 404,
-        when: "The provided projectPath does not resolve to a valid directory."
-      }
-    }
-  },
-  policy: {
-    auth: "anonymous",
-    pii: []
-  }
-});
-
-// src/install.ts
-function makeEmit(_spec, ctx) {
-  return {
-    ref: async (ev, payload) => {
-      await ctx.__emitGuard__?.(ev.meta.key, ev.meta.version, payload);
-    },
-    key: async (key, version, payload) => {
-      await ctx.__emitGuard__?.(key, version, payload);
-    },
-    object: async (evt) => {
-      await ctx.__emitGuard__?.(evt.key, evt.version, evt.payload);
-    }
-  };
-}
-function installOp(reg, spec, handler) {
-  return reg.register(spec).bind(spec, handler);
-}
-function op(spec, handler) {
-  return {
-    spec,
-    handler,
-    install: (reg) => installOp(reg, spec, handler)
-  };
-}
-
-// src/data-views/spec.ts
-function defineDataView(spec) {
-  return spec;
-}
-
-// src/data-views/report/contractVerificationTable.ts
-var ContractVerificationTableDataView = defineDataView({
-  meta: {
-    key: "report.contractVerificationTable",
-    title: "Contract Verification Table",
-    version: "1.0.0",
-    description: "Table view of per-contract verification status for the impact report.",
-    domain: "report",
-    owners: ["platform.core"],
-    tags: ["report", "data-view", "verification"],
-    stability: StabilityEnum.Experimental,
-    entity: "contract-verification"
-  },
-  source: {
-    primary: {
-      key: GetContractVerificationStatusQuery.meta.key,
-      version: GetContractVerificationStatusQuery.meta.version
-    }
-  },
-  view: {
-    kind: "table",
-    fields: [
-      {
-        key: "name",
-        label: "Contract / Endpoint / Event",
-        dataPath: "name"
-      },
-      {
-        key: "timeSinceVerified",
-        label: "Time since verified",
-        dataPath: "lastVerifiedDate"
-      },
-      {
-        key: "driftMismatches",
-        label: "Drift debt",
-        dataPath: "driftMismatches",
-        format: "number",
-        sortable: true
-      },
-      {
-        key: "surfaces",
-        label: "Surfaces covered",
-        dataPath: "surfaces",
-        format: "badge"
-      },
-      {
-        key: "lastVerifiedSha",
-        label: "Last verified commit",
-        dataPath: "lastVerifiedSha",
-        width: "sm"
-      }
-    ],
-    primaryField: "name",
-    secondaryFields: ["driftMismatches", "timeSinceVerified"],
-    columns: [
-      { field: "name", width: "lg" },
-      { field: "lastVerifiedSha", width: "sm" },
-      { field: "timeSinceVerified", width: "sm" },
-      { field: "surfaces", width: "md" },
-      { field: "driftMismatches", width: "xs", align: "right" }
-    ]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-
-// src/operations/report/index.ts
-var getContractVerificationStatusHandler = async (input, _ctx) => {
-  try {
-    const cmdProcess = Bun.spawn(["contractspec", "impl", "status", "--format", "json", "--all"], {
-      cwd: input.projectPath
-    });
-    const cmdStdout = await cmdProcess.stdout;
-    const output = await Bun.readableStreamToText(cmdStdout);
-    if (!output) {
-      return { contracts: [] };
-    }
-    const cliOutput = JSON.parse(output);
-    const contracts = [];
-    for (const spec of cliOutput.results || []) {
-      const contract = {
-        name: spec.specKey,
-        lastVerifiedSha: spec.specHash,
-        lastVerifiedDate: spec.specHash ? new Date().toISOString() : undefined,
-        surfaces: spec.implementations.filter((impl) => impl.exists).map((impl) => impl.type),
-        driftMismatches: spec.implementations.filter((impl) => !impl.exists).length
-      };
-      contracts.push(contract);
-    }
-    return { contracts };
-  } catch (error) {
-    console.error("Failed to get contract verification status:", error);
-    return { contracts: [] };
-  }
-};
-function registerReportContracts(registry) {
-  installOp(registry, GetContractVerificationStatusQuery, getContractVerificationStatusHandler);
-  return registry;
-}
-// src/docs/presentations.ts
-var DEFAULT_TARGETS = [
-  "markdown",
-  "react"
-];
-function normalizeRoute(route) {
-  if (!route.length)
-    return "/";
-  const withLeading = route.startsWith("/") ? route : `/${route}`;
-  return withLeading === "/" ? "/" : withLeading.replace(/\/+$/, "");
-}
-function deriveRoute(block, routePrefix) {
-  if (block.route)
-    return normalizeRoute(block.route);
-  const prefix = routePrefix ?? "/docs";
-  const slug = block.id.replace(/^docs\.?/, "").replace(/\./g, "/").replace(/\/+/g, "/");
-  const path = slug.startsWith("/") ? slug : `${prefix}/${slug}`;
-  return normalizeRoute(path);
-}
-function buildName(block, namespace) {
-  return namespace ? `${namespace}.${block.id}` : block.id;
-}
-function docBlockToPresentationSpec(block, options) {
-  const targets = options?.defaultTargets ?? DEFAULT_TARGETS;
-  const version = block.version ?? options?.defaultVersion ?? "1.0.0";
-  const stability = block.stability ?? options?.defaultStability ?? "stable";
-  return {
-    meta: {
-      key: buildName(block, options?.namespace),
-      title: block.title,
-      version,
-      description: block.summary ?? block.title,
-      tags: block.tags || [],
-      owners: block.owners || [],
-      domain: block.domain || "",
-      stability,
-      goal: `Documentation of: ${block.summary}`,
-      context: `Auto-generated`
-    },
-    policy: block.visibility && block.visibility !== "public" ? { flags: [block.visibility] } : undefined,
-    source: {
-      type: "blocknotejs",
-      docJson: block.body
-    },
-    targets
-  };
-}
-function docBlocksToPresentationRoutes(blocks, options) {
-  return blocks.map((block) => ({
-    block,
-    route: deriveRoute(block, options?.routePrefix),
-    descriptor: docBlockToPresentationSpec(block, options)
-  }));
-}
-function docBlocksToPresentationSpecs(blocks, options) {
-  return blocks.map((block) => docBlockToPresentationSpec(block, options));
-}
-function mapDocRoutes(routes) {
-  return routes.map(({ route, descriptor }) => [route, descriptor]);
-}
-
-// src/docs/registry.ts
-class DocRegistry {
-  routes = new Map;
-  constructor(blocks = [], options) {
-    blocks.forEach((block) => this.register(block, options));
-  }
-  register(block, options) {
-    const [route] = docBlocksToPresentationRoutes([block], options);
-    if (route) {
-      this.routes.set(block.id, route);
-    }
-    return this;
-  }
-  list() {
-    return [...this.routes.values()];
-  }
-  get(id) {
-    return this.routes.get(id);
-  }
-  toRouteTuples() {
-    return this.list().map(({ route, descriptor }) => [route, descriptor]);
-  }
-  toPresentationSpecs(options) {
-    return this.list().map(({ block }) => docBlockToPresentationSpec(block, options));
-  }
-}
-var requiredFields = [
-  "id",
-  "title",
-  "body",
-  "kind",
-  "visibility",
-  "route"
-];
-var defaultDocRegistry = new DocRegistry;
-function registerDocBlocks(blocks) {
-  for (const block of blocks) {
-    for (const field of requiredFields) {
-      if (!block[field]) {
-        throw new Error(`DocBlock ${block.id ?? "<missing id>"} missing field ${String(field)}`);
-      }
-    }
-    defaultDocRegistry.register(block);
-  }
-}
-function listRegisteredDocBlocks() {
-  return defaultDocRegistry.list().map((r) => r.block);
-}
-function docId(id) {
-  const found = defaultDocRegistry.get(id);
-  if (!found)
-    throw new Error(`DocBlock not registered: ${id}`);
-  return id;
-}
-
-// src/schema-to-markdown.ts
-import { isSchemaModel } from "@contractspec/lib.schema";
-function schemaToMarkdown(schema, data, options = {}) {
-  const { format = "auto", title, description, maxDepth = 2 } = options;
-  const lines = [];
-  if (title) {
-    lines.push(`# ${title}`, "");
-  }
-  if (description) {
-    lines.push(`> ${description}`, "");
-  }
-  const effectiveFormat = format === "auto" ? Array.isArray(data) ? "table" : "detail" : format;
-  if (effectiveFormat === "table" && Array.isArray(data)) {
-    lines.push(schemaToMarkdownTable(schema, data, options));
-  } else if (effectiveFormat === "list" && Array.isArray(data)) {
-    lines.push(schemaToMarkdownList(schema, data, options));
-  } else if (!Array.isArray(data) && data !== null && typeof data === "object") {
-    lines.push(schemaToMarkdownDetail(schema, data, { ...options, maxDepth }));
-  } else {
-    lines.push(`**Data:** ${String(data)}`, "");
-  }
-  return lines.join(`
-`);
-}
-function schemaToMarkdownTable(schema, items, options = {}) {
-  const { maxItems = 100, includeFields, excludeFields = [] } = options;
-  const fields = getFieldMeta(schema, includeFields, excludeFields);
-  if (fields.length === 0 || items.length === 0) {
-    return `_No data available_
-`;
-  }
-  const limitedItems = items.slice(0, maxItems);
-  const lines = [];
-  const headers = fields.map((f) => f.label);
-  lines.push(`| ${headers.join(" | ")} |`);
-  lines.push(`| ${headers.map(() => "---").join(" | ")} |`);
-  for (const item of limitedItems) {
-    const row = fields.map((f) => formatCellValue(getFieldValue(item, f.name)));
-    lines.push(`| ${row.join(" | ")} |`);
-  }
-  if (items.length > maxItems) {
-    lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-function schemaToMarkdownList(schema, items, options = {}) {
-  const {
-    maxItems = 50,
-    summaryFields,
-    includeFields,
-    excludeFields = []
-  } = options;
-  const fields = getFieldMeta(schema, includeFields, excludeFields);
-  const displayFields = summaryFields ? fields.filter((f) => summaryFields.includes(f.name)) : fields.slice(0, 3);
-  if (displayFields.length === 0 || items.length === 0) {
-    return `_No data available_
-`;
-  }
-  const limitedItems = items.slice(0, maxItems);
-  const lines = [];
-  for (const item of limitedItems) {
-    const primaryValue = formatCellValue(getFieldValue(item, displayFields[0]?.name ?? "id"));
-    const secondaryValues = displayFields.slice(1).map((f) => `${f.label}: ${formatCellValue(getFieldValue(item, f.name))}`).join(" \xB7 ");
-    const itemLine = secondaryValues ? `- **${primaryValue}** (${secondaryValues})` : `- **${primaryValue}**`;
-    lines.push(itemLine);
-  }
-  if (items.length > maxItems) {
-    lines.push("", `_Showing ${maxItems} of ${items.length} items_`);
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-function schemaToMarkdownDetail(schema, item, options = {}) {
-  const { includeFields, excludeFields = [], maxDepth = 2 } = options;
-  if (item === null || typeof item !== "object") {
-    return `_No data available_
-`;
-  }
-  const fields = getFieldMeta(schema, includeFields, excludeFields);
-  if (fields.length === 0) {
-    return `_No fields to display_
-`;
-  }
-  const lines = [];
-  for (const field of fields) {
-    const value = getFieldValue(item, field.name);
-    const formattedValue = formatDetailValue(value, maxDepth, 0);
-    lines.push(`**${field.label}:** ${formattedValue}`);
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-function schemaToMarkdownSummary(items, options = {}) {
-  const { numericFields = [], countByField } = options;
-  const lines = [];
-  lines.push(`**Total Items:** ${items.length}`);
-  for (const fieldName of numericFields) {
-    const values = items.map((item) => getFieldValue(item, fieldName)).filter((v) => typeof v === "number");
-    if (values.length > 0) {
-      const sum = values.reduce((a, b) => a + b, 0);
-      const avg = sum / values.length;
-      const min = Math.min(...values);
-      const max = Math.max(...values);
-      lines.push(`**${formatFieldName(fieldName)}:** Sum: ${formatNumber(sum)}, Avg: ${formatNumber(avg)}, Min: ${formatNumber(min)}, Max: ${formatNumber(max)}`);
-    }
-  }
-  if (countByField) {
-    const counts = {};
-    for (const item of items) {
-      const value = String(getFieldValue(item, countByField) ?? "Unknown");
-      counts[value] = (counts[value] ?? 0) + 1;
-    }
-    lines.push("", `**By ${formatFieldName(countByField)}:**`);
-    for (const [value, count] of Object.entries(counts)) {
-      lines.push(`- ${value}: ${count}`);
-    }
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-function getFieldMeta(schema, includeFields, excludeFields = []) {
-  if (!isSchemaModel(schema)) {
-    return [];
-  }
-  const schemaFields = schema.config.fields;
-  const fieldNames = Object.keys(schemaFields);
-  const filteredFields = fieldNames.filter((name) => {
-    if (excludeFields.includes(name))
-      return false;
-    if (includeFields && !includeFields.includes(name))
-      return false;
-    return true;
-  });
-  return filteredFields.map((name) => {
-    const fieldConfig = schemaFields[name];
-    const isNested = Boolean(fieldConfig?.type && typeof fieldConfig.type === "object" && "config" in fieldConfig.type && typeof fieldConfig.type.config?.fields === "object");
-    return {
-      name,
-      label: formatFieldName(name),
-      isOptional: fieldConfig?.isOptional ?? false,
-      isArray: fieldConfig?.isArray === true,
-      isNested
-    };
-  });
-}
-function getFieldValue(item, fieldName) {
-  if (item === null || typeof item !== "object")
-    return;
-  const obj = item;
-  if (fieldName.includes(".")) {
-    const parts = fieldName.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (current === null || typeof current !== "object")
-        return;
-      current = current[part];
-    }
-    return current;
-  }
-  return obj[fieldName];
-}
-function formatCellValue(value) {
-  if (value === null || value === undefined)
-    return "-";
-  if (typeof value === "boolean")
-    return value ? "\u2713" : "\u2717";
-  if (typeof value === "number")
-    return formatNumber(value);
-  if (value instanceof Date)
-    return formatDate(value);
-  if (typeof value === "string" && isISODate(value))
-    return formatDate(new Date(value));
-  if (Array.isArray(value))
-    return `[${value.length} items]`;
-  if (typeof value === "object")
-    return "[Object]";
-  const str = String(value);
-  return str.length > 50 ? `${str.slice(0, 47)}...` : str.replace(/\|/g, "\\|");
-}
-function formatDetailValue(value, maxDepth, currentDepth) {
-  if (value === null || value === undefined)
-    return "_none_";
-  if (typeof value === "boolean")
-    return value ? "Yes" : "No";
-  if (typeof value === "number")
-    return formatNumber(value);
-  if (value instanceof Date)
-    return formatDate(value);
-  if (typeof value === "string" && isISODate(value))
-    return formatDate(new Date(value));
-  if (Array.isArray(value)) {
-    if (value.length === 0)
-      return "_empty list_";
-    if (currentDepth >= maxDepth)
-      return `[${value.length} items]`;
-    if (value.length <= 5 && value.every((v) => typeof v !== "object")) {
-      return value.map((v) => formatCellValue(v)).join(", ");
-    }
-    return `[${value.length} items]`;
-  }
-  if (typeof value === "object") {
-    if (currentDepth >= maxDepth)
-      return "[Object]";
-    const keys = Object.keys(value);
-    return `{${keys.length} fields}`;
-  }
-  return String(value);
-}
-function formatFieldName(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase());
-}
-function formatNumber(value) {
-  if (Math.abs(value) >= 1000) {
-    return new Intl.NumberFormat("en-US", {
-      maximumFractionDigits: 2
-    }).format(value);
-  }
-  if (Number.isInteger(value)) {
-    return String(value);
-  }
-  return value.toFixed(2);
-}
-function formatDate(date) {
-  return date.toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-}
-function isISODate(str) {
-  if (!/^\d{4}-\d{2}-\d{2}/.test(str))
-    return false;
-  const date = new Date(str);
-  return !isNaN(date.getTime());
-}
-
-// src/presentations/transform-engine.ts
-import React from "react";
-import TurndownService from "turndown";
-var turndown = new TurndownService;
-function renderTextNode(node) {
-  const text = node.text ?? "";
-  if (!node.marks || node.marks.length === 0)
-    return text;
-  return node.marks.reduce((acc, mark) => {
-    switch (mark.type) {
-      case "bold":
-        return `**${acc}**`;
-      case "italic":
-        return `*${acc}*`;
-      case "underline":
-        return `__${acc}__`;
-      case "strike":
-        return `~~${acc}~~`;
-      case "code":
-        return `\`${acc}\``;
-      case "link": {
-        const href = mark.attrs?.href ?? "";
-        return href ? `[${acc}](${href})` : acc;
-      }
-      default:
-        return acc;
-    }
-  }, text);
-}
-function renderInline(nodes) {
-  if (!nodes?.length)
-    return "";
-  return nodes.map((child) => renderNode(child)).join("");
-}
-function renderList(nodes, ordered = false) {
-  if (!nodes?.length)
-    return "";
-  let counter = 1;
-  return nodes.map((item) => {
-    const body = renderInline(item.content ?? []);
-    if (!body)
-      return "";
-    const prefix = ordered ? `${counter++}. ` : "- ";
-    return `${prefix}${body}`;
-  }).filter(Boolean).join(`
-`);
-}
-function renderNode(node) {
-  switch (node.type) {
-    case "doc":
-      return renderInline(node.content);
-    case "paragraph": {
-      const text = renderInline(node.content);
-      return text.trim().length ? text : "";
-    }
-    case "heading": {
-      const levelAttr = node.attrs?.level;
-      const levelVal = typeof levelAttr === "number" ? levelAttr : 1;
-      const level = Math.min(Math.max(levelVal, 1), 6);
-      return `${"#".repeat(level)} ${renderInline(node.content)}`.trim();
-    }
-    case "bullet_list":
-      return renderList(node.content, false);
-    case "ordered_list":
-      return renderList(node.content, true);
-    case "list_item":
-      return renderInline(node.content);
-    case "blockquote": {
-      const body = renderInline(node.content);
-      return body.split(`
-`).map((line) => `> ${line}`).join(`
-`);
-    }
-    case "code_block": {
-      const body = renderInline(node.content);
-      return body ? `\`\`\`
-${body}
-\`\`\`` : "";
-    }
-    case "horizontal_rule":
-      return "---";
-    case "hard_break":
-      return `
-`;
-    case "text":
-      return renderTextNode(node);
-    default:
-      if (node.text)
-        return renderTextNode(node);
-      return "";
-  }
-}
-function blockNoteToMarkdown(docJson) {
-  if (typeof docJson === "string")
-    return docJson;
-  if (docJson && typeof docJson === "object" && "html" in docJson) {
-    const html = String(docJson.html);
-    return turndown.turndown(html);
-  }
-  const root = docJson;
-  if (root?.type === "doc" || root?.content) {
-    const blocks = (root.content ?? []).map((n) => renderNode(n)).filter(Boolean);
-    return blocks.join(`
-
-`).trim();
-  }
-  try {
-    return JSON.stringify(docJson, null, 2);
-  } catch {
-    return String(docJson);
-  }
-}
-
-class TransformEngine {
-  renderers = new Map;
-  validators = [];
-  register(renderer) {
-    const arr = this.renderers.get(renderer.target) ?? [];
-    arr.push(renderer);
-    this.renderers.set(renderer.target, arr);
-    return this;
-  }
-  prependRegister(renderer) {
-    const arr = this.renderers.get(renderer.target) ?? [];
-    arr.unshift(renderer);
-    this.renderers.set(renderer.target, arr);
-    return this;
-  }
-  addValidator(v) {
-    this.validators.push(v);
-    return this;
-  }
-  async render(target, desc, ctx) {
-    if (!desc.targets.includes(target))
-      throw new Error(`Target ${target} not declared for ${desc.meta.key}.v${desc.meta.version}`);
-    for (const v of this.validators)
-      await v.validate(desc, target, ctx);
-    const arr = this.renderers.get(target) ?? [];
-    for (const r of arr) {
-      try {
-        const out = await r.render(desc, ctx);
-        return out;
-      } catch (_e) {}
-    }
-    throw new Error(`No renderer available for ${target}`);
-  }
-}
-function createDefaultTransformEngine() {
-  const engine = new TransformEngine;
-  const applyPii = (desc, obj) => {
-    const clone = JSON.parse(JSON.stringify(obj));
-    const paths = desc.policy?.pii ?? [];
-    const setAtPath = (root, path) => {
-      const segs = path.replace(/^\//, "").replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
-      let cur = root;
-      for (let i = 0;i < segs.length - 1; i++) {
-        const k = segs[i];
-        if (!k)
-          continue;
-        if (cur && typeof cur === "object" && k in cur) {
-          cur = cur[k];
-        } else
-          return;
-      }
-      const last = segs[segs.length - 1];
-      if (cur && typeof cur === "object" && last && last in cur)
-        cur[last] = "[REDACTED]";
-    };
-    for (const p of paths)
-      setAtPath(clone, p);
-    return clone;
-  };
-  engine.register({
-    target: "markdown",
-    async render(desc, ctx) {
-      let data = ctx?.data;
-      if (!data && ctx?.fetchData) {
-        data = await ctx.fetchData();
-      }
-      if (desc.source.type === "component" && desc.source.props && data !== undefined) {
-        const isArray = Array.isArray(data);
-        const isSimpleObject = !isArray && typeof data === "object" && data !== null && !Object.values(data).some((v) => Array.isArray(v) || typeof v === "object" && v !== null);
-        if (isArray || isSimpleObject) {
-          const body = schemaToMarkdown(desc.source.props, data, {
-            title: desc.meta.description ?? desc.meta.key,
-            description: `${desc.meta.key} v${desc.meta.version}`
-          });
-          return { mimeType: "text/markdown", body };
-        }
-        throw new Error(`Complex data structure for ${desc.meta.key} - expecting custom renderer`);
-      }
-      if (desc.source.type === "blocknotejs") {
-        const markdown = blockNoteToMarkdown(desc.source.docJson);
-        const redacted = applyPii(desc, { text: markdown });
-        return { mimeType: "text/markdown", body: String(redacted.text) };
-      }
-      if (desc.source.type === "component" && data !== undefined) {
-        throw new Error(`No schema (source.props) available for ${desc.meta.key} - expecting custom renderer`);
-      }
-      if (desc.source.type === "component") {
-        const header = `# ${desc.meta.key} v${desc.meta.version}`;
-        const about = desc.meta.description ? `
-
-${desc.meta.description}` : "";
-        const tags = desc.meta.tags && desc.meta.tags.length ? `
-
-Tags: ${desc.meta.tags.join(", ")}` : "";
-        const owners = desc.meta.owners && desc.meta.owners.length ? `
-
-Owners: ${desc.meta.owners.join(", ")}` : "";
-        const comp = `
-
-Component: \`${desc.source.componentKey}\``;
-        const policy = desc.policy?.pii?.length ? `
-
-Redacted paths: ${desc.policy.pii.map((p) => `\`${p}\``).join(", ")}` : "";
-        const body = `${header}${about}${tags}${owners}${comp}${policy}`;
-        return { mimeType: "text/markdown", body };
-      }
-      throw new Error("unsupported");
-    }
-  });
-  engine.register({
-    target: "application/json",
-    async render(desc) {
-      const payload = applyPii(desc, { meta: desc.meta, source: desc.source });
-      return {
-        mimeType: "application/json",
-        body: JSON.stringify(payload, null, 2)
-      };
-    }
-  });
-  engine.register({
-    target: "application/xml",
-    async render(desc) {
-      const json = applyPii(desc, { meta: desc.meta, source: desc.source });
-      const body = `<presentation name="${desc.meta.key}" version="${desc.meta.version}"><json>${encodeURIComponent(JSON.stringify(json))}</json></presentation>`;
-      return { mimeType: "application/xml", body };
-    }
-  });
-  return engine;
-}
-function registerDefaultReactRenderer(engine) {
-  engine.register({
-    target: "react",
-    async render(desc) {
-      if (desc.source.type === "component") {
-        const props = desc.source.props ? desc.source.props.getZod().safeParse({}).success ? {} : undefined : undefined;
-        return {
-          kind: "react_component",
-          componentKey: desc.source.componentKey,
-          props
-        };
-      }
-      return {
-        kind: "blocknotejs",
-        docJson: desc.source.docJson,
-        blockConfig: desc.source.blockConfig
-      };
-    }
-  });
-  return engine;
-}
-function registerBasicValidation(engine) {
-  engine.addValidator({
-    validate(desc) {
-      if (!desc.meta.description || desc.meta.description.length < 3)
-        throw new Error(`Presentation ${desc.meta.key}.v${desc.meta.version} missing meta.description`);
-    }
-  });
-  return engine;
-}
-function registerReactToMarkdownRenderer(engine, componentMap) {
-  const turndownService = new TurndownService({
-    headingStyle: "atx",
-    codeBlockStyle: "fenced",
-    bulletListMarker: "-"
-  });
-  turndownService.addRule("link", {
-    filter: "a",
-    replacement: (content, node) => {
-      const href = node.href;
-      if (href && content) {
-        return `[${content}](${href})`;
-      }
-      return content || "";
-    }
-  });
-  engine.prependRegister({
-    target: "markdown",
-    async render(desc, _ctx) {
-      if (desc.source.type !== "component") {
-        throw new Error("React-to-markdown renderer only handles component presentations");
-      }
-      const { renderToStaticMarkup } = await import("react-dom/server");
-      const Component = componentMap[desc.source.componentKey];
-      if (!Component) {
-        throw new Error(`Component ${desc.source.componentKey} not found in componentMap`);
-      }
-      let html;
-      try {
-        const element = React.createElement(Component, desc.source.props ? {} : undefined);
-        html = renderToStaticMarkup(element);
-      } catch (error) {
-        throw new Error(`Failed to render component ${desc.source.componentKey}: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-      let markdown;
-      try {
-        markdown = turndownService.turndown(html);
-      } catch (error) {
-        throw new Error(`Failed to convert HTML to markdown: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-      if (desc.policy?.pii && desc.policy.pii.length > 0) {
-        const redacted = markdown.replace(/\[REDACTED\]/g, "[REDACTED]");
-        return { mimeType: "text/markdown", body: redacted };
-      }
-      return { mimeType: "text/markdown", body: markdown };
-    }
-  });
-  return engine;
-}
-
-// src/presentations/presentations.ts
-var definePresentation = (spec) => {
-  return spec;
-};
-
-// src/presentations/registry.ts
-class PresentationRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("presentation", items);
-  }
-}
-// src/forms/forms.ts
-import { compareVersions as compareVersions2 } from "compare-versions";
-function formKey(meta) {
-  return `${meta.key}.v${meta.version}`;
-}
-
-class FormRegistry {
-  items = new Map;
-  register(spec) {
-    const key = formKey(spec.meta);
-    if (this.items.has(key))
-      throw new Error(`Duplicate form ${key}`);
-    this.items.set(key, spec);
-    return this;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, v] of this.items.entries()) {
-      if (v.meta.key !== key)
-        continue;
-      if (!candidate || compareVersions2(v.meta.version, candidate.meta.version) > 0) {
-        candidate = v;
-      }
-    }
-    return candidate;
-  }
-  filter(criteria) {
-    const { filterBy: filterBy2 } = (init_registry_utils(), __toCommonJS(exports_registry_utils));
-    return filterBy2(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((f) => f.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((f) => f.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    const { groupBy: groupBy2 } = (init_registry_utils(), __toCommonJS(exports_registry_utils));
-    return groupBy2(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    const { getUniqueTags: getUniqueTags2 } = (init_registry_utils(), __toCommonJS(exports_registry_utils));
-    return getUniqueTags2(this.list());
-  }
-}
-function getAtPath(values, path) {
-  if (!path)
-    return;
-  const segs = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
-  let cur = values;
-  for (const s of segs) {
-    if (cur == null)
-      return;
-    if (cur && typeof cur === "object" && s in cur) {
-      cur = cur[s];
-    } else {
-      return;
-    }
-  }
-  return cur;
-}
-function evalPredicate(values, pred) {
-  if (!pred)
-    return true;
-  if (pred.not)
-    return !evalPredicate(values, pred.not);
-  if (pred.all && pred.all.length)
-    return pred.all.every((p) => evalPredicate(values, p));
-  if (pred.anyOf && pred.anyOf.length)
-    return pred.anyOf.some((p) => evalPredicate(values, p));
-  if (pred.when) {
-    const { path, op: op2 = "truthy", value } = pred.when;
-    const v = getAtPath(values, path);
-    switch (op2) {
-      case "equals":
-        return v === value;
-      case "notEquals":
-        return v !== value;
-      case "in":
-        return Array.isArray(value) && value.includes(v);
-      case "notIn":
-        return Array.isArray(value) && !value.includes(v);
-      case "gt":
-        return Number(v) > Number(value);
-      case "gte":
-        return Number(v) >= Number(value);
-      case "lt":
-        return Number(v) < Number(value);
-      case "lte":
-        return Number(v) <= Number(value);
-      case "empty":
-        return v == null || (Array.isArray(v) ? v.length === 0 : String(v).length === 0);
-      case "lengthGt":
-        return (Array.isArray(v) || typeof v === "string") && v.length > Number(value ?? 0);
-      case "lengthGte":
-        return (Array.isArray(v) || typeof v === "string") && v.length >= Number(value ?? 0);
-      case "lengthLt":
-        return (Array.isArray(v) || typeof v === "string") && v.length < Number(value ?? 0);
-      case "lengthLte":
-        return (Array.isArray(v) || typeof v === "string") && v.length <= Number(value ?? 0);
-      case "truthy":
-      default:
-        return Boolean(v);
-    }
-  }
-  return true;
-}
-function buildZodWithRelations(spec, handlers) {
-  const base = spec.model.getZod();
-  return base.superRefine((values, ctx) => {
-    const visit = (field, parentPath) => {
-      const path = field.name ? parentPath ? `${parentPath}.${field.name}` : field.name : parentPath ?? "";
-      if (field.requiredWhen) {
-        const should = evalPredicate(values, field.requiredWhen);
-        if (should) {
-          const v = getAtPath(values, path);
-          const empty = v == null || typeof v === "string" && v.trim().length === 0 || Array.isArray(v) && v.length === 0;
-          if (empty)
-            ctx.addIssue({
-              code: "custom",
-              path: path.split("."),
-              message: "required"
-            });
-        }
-      }
-      if (field.kind === "array") {
-        const arr = getAtPath(values, path);
-        if (field.min != null && Array.isArray(arr) && arr.length < field.min) {
-          ctx.addIssue({
-            code: "custom",
-            path: path.split("."),
-            message: `min:${field.min}`
-          });
-        }
-        if (field.max != null && Array.isArray(arr) && arr.length > field.max) {
-          ctx.addIssue({
-            code: "custom",
-            path: path.split("."),
-            message: `max:${field.max}`
-          });
-        }
-        visit(field.of, path);
-      } else if (field.kind === "group") {
-        for (const child of field.fields)
-          visit(child, path);
-      }
-    };
-    for (const f of spec.fields)
-      visit(f);
-    if (spec.constraints && handlers) {
-      for (const c of spec.constraints) {
-        const fn = handlers[c.key];
-        if (!fn)
-          continue;
-        const res = fn(values, c.paths, c.args);
-        if (!res.ok) {
-          ctx.addIssue({
-            code: "custom",
-            path: (res.path ?? c.paths[0] ?? "").split(".").filter(Boolean),
-            message: res.message ?? c.messageI18n
-          });
-        }
-      }
-    }
-  });
-}
-function defineFormSpec(spec) {
-  return spec;
-}
-
-// src/data-views/registry.ts
-function dataViewKey(spec) {
-  return `${spec.meta.key}.v${spec.meta.version}`;
-}
-
-class DataViewRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("data-view", items);
-  }
-}
-// src/docs/constants.ts
-var DOCS_DOMAIN = "docs";
-var DOCS_OWNERS = ["docs-platform"];
-var DOCS_TAGS = ["docs", "documentation"];
-var DOCS_STABILITY = StabilityEnum.Experimental;
-
-// src/docs/tech/docs-system.docblock.ts
-var docsSystemDocBlocks = [
-  {
-    id: "docs.tech.docs-system",
-    title: "Docs system overview",
-    summary: "How ContractSpec generates, indexes, and presents documentation.",
-    kind: "reference",
-    visibility: "public",
-    route: "/docs/tech/docs/system",
-    tags: ["docs", "system", "contracts"],
-    body: `# Docs system overview
-
-ContractSpec treats documentation as a first-class output of your specs. The docs system combines:
-
-- Contract operations and schemas
-- DocBlocks (goal/how/usage/reference)
-- Presentations for rendering
-
-The result is a consistent docs surface across CLI, web, and MCP.
-
-## Key surfaces
-
-- Generation: \`docs.generate\`
-- Index/search: \`docs.search\`
-- Contract reference: \`docs.contract.reference\`
-- Publish: \`docs.publish\`
-`
-  },
-  {
-    id: "docs.tech.docs-generator",
-    title: "Docs generator",
-    summary: "Generate reference docs and metadata from ContractSpecs.",
-    kind: "how",
-    visibility: "public",
-    route: "/docs/tech/docs/generator",
-    tags: ["docs", "generator", "cli"],
-    body: `# Docs generator
-
-The generator produces documentation artifacts from registered ContractSpecs and DocBlocks.
-
-## Outputs
-
-- Reference pages for operations, events, forms, data views, and presentations
-- Search index metadata (DocBlocks + routes)
-- Contract schemas rendered to markdown or JSON
-`
-  },
-  {
-    id: "docs.tech.docs-search",
-    title: "Docs index and search",
-    summary: "Search DocBlocks by query, tag, kind, or visibility.",
-    kind: "reference",
-    visibility: "public",
-    route: "/docs/tech/docs/search",
-    tags: ["docs", "search"],
-    body: `# Docs index and search
-
-The docs index is the canonical list of DocBlocks exposed to UI and MCP surfaces.
-
-## Query
-
-- Operation: \`docs.search\`
-- Filters: query, tag, kind, visibility
-`
-  },
-  {
-    id: "docs.tech.docs-reference",
-    title: "Contract reference pages",
-    summary: "Resolve any spec into a docs-ready reference payload.",
-    kind: "reference",
-    visibility: "public",
-    route: "/docs/tech/docs/reference",
-    tags: ["docs", "reference"],
-    body: `# Contract reference
-
-Contract reference pages are generated from spec metadata plus schema details.
-
-## Query
-
-- Operation: \`docs.contract.reference\`
-`
-  },
-  {
-    id: "docs.tech.docs-publish",
-    title: "Docs publish",
-    summary: "Publish generated artifacts to the docs host.",
-    kind: "how",
-    visibility: "public",
-    route: "/docs/tech/docs/publish",
-    tags: ["docs", "publish"],
-    body: `# Docs publish
-
-Publishing moves generated artifacts to a hosting target with versioning.
-
-## Command
-
-- Operation: \`docs.publish\`
-`
-  },
-  {
-    id: "docs.tech.docs-examples",
-    title: "Examples catalog",
-    summary: "Document and surface example projects with sandbox support.",
-    kind: "reference",
-    visibility: "public",
-    route: "/docs/tech/docs/examples",
-    tags: ["docs", "examples"],
-    body: `# Examples catalog
-
-Examples are registered as ExampleSpecs and surface DocBlocks for discovery.
-
-- Docs index tags should include \`examples\` to populate the catalog.
-- Sandbox support is available under \`/sandbox\`.
-`
-  }
-];
-registerDocBlocks(docsSystemDocBlocks);
-// src/docs/events/docsGenerated.event.ts
-import { SchemaModel as SchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var DocsGeneratedPayload = new SchemaModel2({
-  name: "DocsGeneratedPayload",
-  fields: {
-    buildId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    generatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    outputDir: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    artifactCount: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
-    warnings: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    }
-  }
-});
-var DocsGeneratedEvent = defineEvent({
-  meta: {
-    key: "docs.generated",
-    version: "1.0.0",
-    description: "Emitted when documentation artifacts are generated.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "generation"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-generator")]
-  },
-  payload: DocsGeneratedPayload
-});
-
-// src/docs/commands/docsGenerate.command.ts
-import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
-var DocsArtifactModel = new SchemaModel3({
-  name: "DocsArtifact",
-  fields: {
-    path: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    format: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    bytes: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
-    kind: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
-  }
-});
-var DocsGenerateInput = new SchemaModel3({
-  name: "DocsGenerateInput",
-  fields: {
-    workspaceRoot: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    outputDir: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    version: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    formats: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    },
-    includeInternal: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    includeExperimental: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    contractFilter: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: true
-    },
-    docblockFilter: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: true
-    },
-    dryRun: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-  }
-});
-var DocsGenerateOutput = new SchemaModel3({
-  name: "DocsGenerateOutput",
-  fields: {
-    buildId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    generatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false },
-    outputDir: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    artifacts: { type: DocsArtifactModel, isOptional: true, isArray: true },
-    warnings: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    }
-  }
-});
-var DocsGenerateCommand = defineCommand({
-  meta: {
-    key: "docs.generate",
-    title: "Generate Documentation",
-    version: "1.0.0",
-    description: "Generate documentation artifacts from ContractSpecs.",
-    goal: "Produce up-to-date reference docs and guides from specs and DocBlocks.",
-    context: "Used by CLI and CI to keep docs in sync with contract definitions.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "generation"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-generator")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  io: {
-    input: DocsGenerateInput,
-    output: DocsGenerateOutput,
-    errors: {
-      OUTPUT_WRITE_FAILED: {
-        description: "Failed to write generated docs output.",
-        http: 500,
-        when: "The generator cannot persist artifacts to the output path."
-      }
-    }
-  },
-  policy: {
-    auth: "admin",
-    pii: []
-  },
-  sideEffects: {
-    emits: [
-      {
-        ref: DocsGeneratedEvent.meta,
-        when: "Docs generation completes successfully."
-      }
-    ]
-  }
-});
-
-// src/docs/events/docsPublished.event.ts
-import { SchemaModel as SchemaModel4, ScalarTypeEnum as ScalarTypeEnum4 } from "@contractspec/lib.schema";
-var DocsPublishedPayload = new SchemaModel4({
-  name: "DocsPublishedPayload",
-  fields: {
-    publishId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    environment: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    url: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    publishedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
-    status: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    warnings: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    }
-  }
-});
-var DocsPublishedEvent = defineEvent({
-  meta: {
-    key: "docs.published",
-    version: "1.0.0",
-    description: "Emitted when documentation is published.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "publish"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-publish")]
-  },
-  payload: DocsPublishedPayload
-});
-
-// src/docs/commands/docsPublish.command.ts
-import { ScalarTypeEnum as ScalarTypeEnum5, SchemaModel as SchemaModel5 } from "@contractspec/lib.schema";
-var DocsPublishInput = new SchemaModel5({
-  name: "DocsPublishInput",
-  fields: {
-    buildId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    environment: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    deployTarget: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    artifactPath: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    dryRun: { type: ScalarTypeEnum5.Boolean(), isOptional: true },
-    notes: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
-  }
-});
-var DocsPublishOutput = new SchemaModel5({
-  name: "DocsPublishOutput",
-  fields: {
-    publishId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    publishedAt: { type: ScalarTypeEnum5.DateTime(), isOptional: false },
-    url: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    status: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    warnings: {
-      type: ScalarTypeEnum5.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    }
-  }
-});
-var DocsPublishCommand = defineCommand({
-  meta: {
-    key: "docs.publish",
-    title: "Publish Documentation",
-    version: "1.0.0",
-    description: "Publish generated documentation artifacts.",
-    goal: "Deploy docs to the public docs surface with consistent versioning.",
-    context: "Used by release pipelines to push generated docs to hosting targets.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "publish"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-publish")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  io: {
-    input: DocsPublishInput,
-    output: DocsPublishOutput,
-    errors: {
-      DEPLOY_FAILED: {
-        description: "Failed to deploy documentation artifacts.",
-        http: 500,
-        when: "The docs publish step fails to deploy to the target host."
-      }
-    }
-  },
-  policy: {
-    auth: "admin",
-    pii: []
-  },
-  sideEffects: {
-    emits: [
-      {
-        ref: DocsPublishedEvent.meta,
-        when: "Docs publish completes successfully."
-      }
-    ]
-  }
-});
-// src/docs/queries/docsIndex.query.ts
-import { ScalarTypeEnum as ScalarTypeEnum6, SchemaModel as SchemaModel6 } from "@contractspec/lib.schema";
-var DocSummaryModel = new SchemaModel6({
-  name: "DocSummary",
-  fields: {
-    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    title: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    summary: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    route: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    visibility: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    kind: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    version: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    tags: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    }
-  }
-});
-var DocsIndexInput = new SchemaModel6({
-  name: "DocsIndexInput",
-  fields: {
-    query: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    tag: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    },
-    visibility: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    kind: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    limit: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
-    offset: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true }
-  }
-});
-var DocsIndexOutput = new SchemaModel6({
-  name: "DocsIndexOutput",
-  fields: {
-    items: { type: DocSummaryModel, isOptional: true, isArray: true },
-    docs: { type: DocSummaryModel, isOptional: false, isArray: true },
-    total: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
-    nextOffset: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true }
-  }
-});
-var DocsIndexQuery = defineQuery({
-  meta: {
-    key: "docs.search",
-    title: "Docs Index",
-    version: "1.0.0",
-    description: "Search and filter DocBlocks by query, tag, or visibility.",
-    goal: "Provide a consistent index of documentation entries for UI and MCP.",
-    context: "Used by docs surfaces to list and filter DocBlocks without coupling to storage.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "search", "index"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-search")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  io: {
-    input: DocsIndexInput,
-    output: DocsIndexOutput
-  },
-  policy: {
-    auth: "anonymous",
-    pii: []
-  }
-});
-
-// src/docs/queries/contractReference.query.ts
-import { ScalarTypeEnum as ScalarTypeEnum7, SchemaModel as SchemaModel7 } from "@contractspec/lib.schema";
-var ContractReferenceInput = new SchemaModel7({
-  name: "ContractReferenceInput",
-  fields: {
-    key: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    type: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    format: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    includeSchema: { type: ScalarTypeEnum7.Boolean(), isOptional: true }
-  }
-});
-var ContractReferenceModel = new SchemaModel7({
-  name: "ContractReference",
-  fields: {
-    key: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    version: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    type: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    title: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    description: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    markdown: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    route: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    schema: { type: ScalarTypeEnum7.JSONObject(), isOptional: true },
-    policy: { type: ScalarTypeEnum7.JSONObject(), isOptional: true },
-    tags: {
-      type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    },
-    owners: {
-      type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: true,
-      isArray: true
-    },
-    stability: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true }
-  }
-});
-var ContractReferenceOutput = new SchemaModel7({
-  name: "ContractReferenceOutput",
-  fields: {
-    reference: { type: ContractReferenceModel, isOptional: false }
-  }
-});
-var ContractReferenceQuery = defineQuery({
-  meta: {
-    key: "docs.contract.reference",
-    title: "Contract Reference",
-    version: "1.0.0",
-    description: "Resolve a contract into a documentation-ready reference.",
-    goal: "Expose a canonical reference view for any ContractSpec surface.",
-    context: "Used by docs generators and UI to render consistent reference pages.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "reference"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-reference")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  io: {
-    input: ContractReferenceInput,
-    output: ContractReferenceOutput
-  },
-  policy: {
-    auth: "anonymous",
-    pii: []
-  }
-});
-// src/docs/presentations/docsLayout.presentation.ts
-var DocsLayoutPresentation = definePresentation({
-  meta: {
-    key: "docs.layout",
-    title: "Docs Layout",
-    version: "1.0.0",
-    description: "Shared layout shell for documentation pages.",
-    goal: "Provide consistent navigation, layout, and docs UI scaffolding.",
-    context: "Used by web docs surfaces to render DocBlock-based content.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "layout"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-system")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "docsLayout"
-  },
-  targets: ["react"]
-});
-
-// src/docs/presentations/docsReferencePage.presentation.ts
-var DocsReferencePagePresentation = definePresentation({
-  meta: {
-    key: "docs.reference.page",
-    title: "Docs Reference Page",
-    version: "1.0.0",
-    description: "Reference page layout for contract documentation.",
-    goal: "Render contract references with consistent metadata and formatting.",
-    context: "Used by docs surfaces to present contract reference content and schemas.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "reference"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-reference")]
-  },
-  capability: {
-    key: "docs.system",
-    version: "1.0.0"
-  },
-  source: {
-    type: "component",
-    framework: "react",
-    componentKey: "docsReferencePage"
-  },
-  targets: ["react", "markdown"]
-});
-// src/docs/forms/docsSearch.form.ts
-import { SchemaModel as SchemaModel8, ScalarTypeEnum as ScalarTypeEnum8 } from "@contractspec/lib.schema";
-var DocsSearchFormModel = new SchemaModel8({
-  name: "DocsSearchFormModel",
-  fields: {
-    query: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
-    visibility: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
-    kind: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
-  }
-});
-var DocsSearchForm = defineFormSpec({
-  meta: {
-    key: "docs.search.form",
-    title: "Docs Search",
-    version: "1.0.0",
-    description: "Search form for documentation discovery.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "search"],
-    stability: DOCS_STABILITY,
-    docId: [docId("docs.tech.docs-search")]
-  },
-  model: DocsSearchFormModel,
-  fields: [
-    {
-      kind: "text",
-      name: "query",
-      labelI18n: "Search",
-      placeholderI18n: "Search docs"
-    },
-    {
-      kind: "select",
-      name: "visibility",
-      labelI18n: "Visibility",
-      options: {
-        kind: "static",
-        options: [
-          { labelI18n: "Public", value: "public" },
-          { labelI18n: "Internal", value: "internal" },
-          { labelI18n: "Mixed", value: "mixed" }
-        ]
-      }
-    },
-    {
-      kind: "select",
-      name: "kind",
-      labelI18n: "Kind",
-      options: {
-        kind: "static",
-        options: [
-          { labelI18n: "Goal", value: "goal" },
-          { labelI18n: "How", value: "how" },
-          { labelI18n: "Usage", value: "usage" },
-          { labelI18n: "Reference", value: "reference" },
-          { labelI18n: "FAQ", value: "faq" },
-          { labelI18n: "Changelog", value: "changelog" }
-        ]
-      }
-    }
-  ],
-  actions: [
-    {
-      key: "search",
-      labelI18n: "Search"
-    }
-  ],
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-// src/docs/views/docsIndex.dataView.ts
-var DocsIndexDataView = defineDataView({
-  meta: {
-    key: "docs.index.view",
-    title: "Docs Index",
-    version: "1.0.0",
-    description: "List and filter documentation entries.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "index"],
-    stability: DOCS_STABILITY,
-    entity: "docs",
-    docId: [docId("docs.tech.docs-search")]
-  },
-  source: {
-    primary: {
-      key: DocsIndexQuery.meta.key,
-      version: DocsIndexQuery.meta.version
-    }
-  },
-  view: {
-    kind: "list",
-    fields: [
-      { key: "id", label: "ID", dataPath: "id" },
-      { key: "title", label: "Title", dataPath: "title" },
-      { key: "summary", label: "Summary", dataPath: "summary" },
-      { key: "route", label: "Route", dataPath: "route" },
-      { key: "tags", label: "Tags", dataPath: "tags", format: "badge" },
-      { key: "kind", label: "Kind", dataPath: "kind" },
-      { key: "visibility", label: "Visibility", dataPath: "visibility" }
-    ],
-    primaryField: "title",
-    secondaryFields: ["summary", "route"],
-    filters: [
-      { key: "query", label: "Search", field: "query", type: "search" },
-      {
-        key: "visibility",
-        label: "Visibility",
-        field: "visibility",
-        type: "enum",
-        options: [
-          { value: "public", label: "Public" },
-          { value: "internal", label: "Internal" },
-          { value: "mixed", label: "Mixed" }
-        ]
-      },
-      {
-        key: "kind",
-        label: "Kind",
-        field: "kind",
-        type: "enum",
-        options: [
-          { value: "goal", label: "Goal" },
-          { value: "how", label: "How" },
-          { value: "usage", label: "Usage" },
-          { value: "reference", label: "Reference" },
-          { value: "faq", label: "FAQ" },
-          { value: "changelog", label: "Changelog" }
-        ]
-      }
-    ]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-
-// src/docs/views/contractReference.dataView.ts
-var ContractReferenceDataView = defineDataView({
-  meta: {
-    key: "docs.contract.reference.view",
-    title: "Contract Reference",
-    version: "1.0.0",
-    description: "Detail view for a single contract reference.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "reference"],
-    stability: DOCS_STABILITY,
-    entity: "contract-reference",
-    docId: [docId("docs.tech.docs-reference")]
-  },
-  source: {
-    primary: {
-      key: ContractReferenceQuery.meta.key,
-      version: ContractReferenceQuery.meta.version
-    }
-  },
-  view: {
-    kind: "detail",
-    fields: [
-      {
-        key: "key",
-        label: "Key",
-        dataPath: "reference.key"
-      },
-      {
-        key: "version",
-        label: "Version",
-        dataPath: "reference.version"
-      },
-      {
-        key: "type",
-        label: "Type",
-        dataPath: "reference.type"
-      },
-      {
-        key: "title",
-        label: "Title",
-        dataPath: "reference.title"
-      },
-      {
-        key: "description",
-        label: "Description",
-        dataPath: "reference.description",
-        format: "markdown"
-      },
-      {
-        key: "tags",
-        label: "Tags",
-        dataPath: "reference.tags"
-      },
-      {
-        key: "owners",
-        label: "Owners",
-        dataPath: "reference.owners"
-      },
-      {
-        key: "stability",
-        label: "Stability",
-        dataPath: "reference.stability"
-      }
-    ],
-    primaryField: "title",
-    secondaryFields: ["description"]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-
-// src/docs/views/exampleCatalog.dataView.ts
-var ExampleCatalogDataView = defineDataView({
-  meta: {
-    key: "docs.examples.catalog.view",
-    title: "Examples Catalog",
-    version: "1.0.0",
-    description: "Catalog view of ContractSpec examples and demos.",
-    domain: DOCS_DOMAIN,
-    owners: DOCS_OWNERS,
-    tags: [...DOCS_TAGS, "examples"],
-    stability: DOCS_STABILITY,
-    entity: "docs-examples",
-    docId: [docId("docs.tech.docs-examples")]
-  },
-  source: {
-    primary: {
-      key: DocsIndexQuery.meta.key,
-      version: DocsIndexQuery.meta.version
-    }
-  },
-  view: {
-    kind: "grid",
-    fields: [
-      { key: "id", label: "ID", dataPath: "id" },
-      { key: "title", label: "Title", dataPath: "title" },
-      { key: "summary", label: "Summary", dataPath: "summary" },
-      { key: "route", label: "Route", dataPath: "route" },
-      { key: "tags", label: "Tags", dataPath: "tags", format: "badge" }
-    ],
-    primaryField: "title",
-    secondaryFields: ["summary"],
-    filters: [
-      { key: "query", label: "Search", field: "query", type: "search" },
-      {
-        key: "tags",
-        label: "Tags",
-        field: "tag",
-        type: "enum",
-        options: [
-          { value: "examples", label: "Examples" },
-          { value: "templates", label: "Templates" },
-          { value: "sandbox", label: "Sandbox" }
-        ]
-      }
-    ]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-// src/docs/contracts.ts
-var docsOperationContracts = {
-  DocsIndexQuery,
-  ContractReferenceQuery,
-  DocsGenerateCommand,
-  DocsPublishCommand
-};
-var docsEventContracts = {
-  DocsGeneratedEvent,
-  DocsPublishedEvent
-};
-var docsPresentationContracts = {
-  DocsLayoutPresentation,
-  DocsReferencePagePresentation
-};
-var docsFormContracts = {
-  DocsSearchForm
-};
-var docsDataViewContracts = {
-  DocsIndexDataView,
-  ContractReferenceDataView,
-  ExampleCatalogDataView
-};
-function registerDocsOperations(registry3) {
-  return registry3.register(DocsIndexQuery).register(ContractReferenceQuery).register(DocsGenerateCommand).register(DocsPublishCommand);
-}
-function registerDocsEvents(registry3) {
-  return registry3.register(DocsGeneratedEvent).register(DocsPublishedEvent);
-}
-function registerDocsPresentations(registry3) {
-  return registry3.register(DocsLayoutPresentation).register(DocsReferencePagePresentation);
-}
-function registerDocsForms(registry3) {
-  return registry3.register(DocsSearchForm);
-}
-function registerDocsDataViews(registry3) {
-  return registry3.register(DocsIndexDataView).register(ContractReferenceDataView).register(ExampleCatalogDataView);
-}
-export {
-  registerDocsPresentations,
-  registerDocsOperations,
-  registerDocsForms,
-  registerDocsEvents,
-  registerDocsDataViews,
-  docsPresentationContracts,
-  docsOperationContracts,
-  docsFormContracts,
-  docsEventContracts,
-  docsDataViewContracts
-};