@contractspec/lib.contracts-spec 2.0.0

package/dist/index.js

@@ -0,0 +1,2195 @@
+// @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/capabilities/capabilities.ts
+import { compareVersions } from "compare-versions";
+var capKey = (key, version) => `${key}.v${version}`;
+
+class CapabilityRegistry {
+  items = new Map;
+  surfaceIndex = null;
+  register(spec) {
+    const key = capKey(spec.meta.key, spec.meta.version);
+    if (this.items.has(key))
+      throw new Error(`Duplicate capability ${key}`);
+    this.items.set(key, spec);
+    this.surfaceIndex = null;
+    return this;
+  }
+  list() {
+    return [...this.items.values()];
+  }
+  get(key, version) {
+    if (version != null)
+      return this.items.get(capKey(key, version));
+    let candidate;
+    for (const spec of this.items.values()) {
+      if (spec.meta.key !== key)
+        continue;
+      if (!candidate || compareVersions(spec.meta.version, candidate.meta.version) > 0) {
+        candidate = spec;
+      }
+    }
+    return candidate;
+  }
+  satisfies(requirement, additional) {
+    if (requirement.optional)
+      return true;
+    if (additional?.some((ref) => matchesRequirement(ref, requirement)))
+      return true;
+    const spec = requirement.version ? this.get(requirement.key, requirement.version) : this.get(requirement.key);
+    if (!spec)
+      return false;
+    if (requirement.kind && spec.meta.kind !== requirement.kind)
+      return false;
+    if (requirement.version != null && spec.meta.version !== requirement.version)
+      return false;
+    return true;
+  }
+  buildSurfaceIndex() {
+    if (this.surfaceIndex)
+      return this.surfaceIndex;
+    this.surfaceIndex = new Map;
+    for (const spec of this.items.values()) {
+      const capabilityKey = capKey(spec.meta.key, spec.meta.version);
+      for (const surface of spec.provides ?? []) {
+        const surfaceKey = `${surface.surface}:${surface.key}`;
+        if (!this.surfaceIndex.has(surfaceKey)) {
+          this.surfaceIndex.set(surfaceKey, new Set);
+        }
+        this.surfaceIndex.get(surfaceKey)?.add(capabilityKey);
+      }
+    }
+    return this.surfaceIndex;
+  }
+  getOperationsFor(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    return spec.provides?.filter((s) => s.surface === "operation").map((s) => s.key) ?? [];
+  }
+  getEventsFor(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    return spec.provides?.filter((s) => s.surface === "event").map((s) => s.key) ?? [];
+  }
+  getPresentationsFor(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    return spec.provides?.filter((s) => s.surface === "presentation").map((s) => s.key) ?? [];
+  }
+  getWorkflowsFor(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    return spec.provides?.filter((s) => s.surface === "workflow").map((s) => s.key) ?? [];
+  }
+  getResourcesFor(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    return spec.provides?.filter((s) => s.surface === "resource").map((s) => s.key) ?? [];
+  }
+  getCapabilitiesForOperation(operationKey) {
+    const index = this.buildSurfaceIndex();
+    const capKeys = index.get(`operation:${operationKey}`);
+    if (!capKeys)
+      return [];
+    return [...capKeys].map((k) => {
+      const spec = this.items.get(k);
+      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
+    });
+  }
+  getCapabilitiesForEvent(eventKey) {
+    const index = this.buildSurfaceIndex();
+    const capKeys = index.get(`event:${eventKey}`);
+    if (!capKeys)
+      return [];
+    return [...capKeys].map((k) => {
+      const spec = this.items.get(k);
+      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
+    });
+  }
+  getCapabilitiesForPresentation(presentationKey) {
+    const index = this.buildSurfaceIndex();
+    const capKeys = index.get(`presentation:${presentationKey}`);
+    if (!capKeys)
+      return [];
+    return [...capKeys].map((k) => {
+      const spec = this.items.get(k);
+      return { key: spec?.meta.key ?? "", version: spec?.meta.version ?? "" };
+    });
+  }
+  getAncestors(capabilityKey, version) {
+    const ancestors = [];
+    const visited = new Set;
+    let current = this.get(capabilityKey, version);
+    while (current?.extends) {
+      const parentKey = capKey(current.extends.key, current.extends.version);
+      if (visited.has(parentKey)) {
+        break;
+      }
+      visited.add(parentKey);
+      const parent = this.get(current.extends.key, current.extends.version);
+      if (!parent)
+        break;
+      ancestors.push(parent);
+      current = parent;
+    }
+    return ancestors;
+  }
+  getEffectiveRequirements(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    const ancestors = this.getAncestors(capabilityKey, version);
+    const requirementMap = new Map;
+    for (const ancestor of [...ancestors].reverse()) {
+      for (const req of ancestor.requires ?? []) {
+        requirementMap.set(req.key, req);
+      }
+    }
+    for (const req of spec.requires ?? []) {
+      requirementMap.set(req.key, req);
+    }
+    return [...requirementMap.values()];
+  }
+  getEffectiveSurfaces(capabilityKey, version) {
+    const spec = this.get(capabilityKey, version);
+    if (!spec)
+      return [];
+    const ancestors = this.getAncestors(capabilityKey, version);
+    const surfaces = [];
+    for (const ancestor of [...ancestors].reverse()) {
+      surfaces.push(...ancestor.provides ?? []);
+    }
+    surfaces.push(...spec.provides ?? []);
+    return surfaces;
+  }
+}
+function matchesRequirement(ref, requirement) {
+  if (ref.key !== requirement.key)
+    return false;
+  if (requirement.version != null && ref.version !== requirement.version)
+    return false;
+  return true;
+}
+function capabilityKey(spec) {
+  return capKey(spec.meta.key, spec.meta.version);
+}
+function defineCapability(spec) {
+  return spec;
+}
+
+// src/capabilities/validation.ts
+function validateCapabilityConsistency(deps) {
+  const errors = [];
+  const warnings = [];
+  for (const capability of deps.capabilities.list()) {
+    const capKey2 = `${capability.meta.key}.v${capability.meta.version}`;
+    for (const surface of capability.provides ?? []) {
+      const exists = checkSurfaceExists(deps, surface.surface, surface.key);
+      if (!exists) {
+        errors.push({
+          type: "missing_surface_spec",
+          message: `Capability "${capKey2}" provides ${surface.surface} "${surface.key}" but spec not found`,
+          capabilityKey: capKey2,
+          surface: surface.surface,
+          specKey: surface.key
+        });
+      }
+    }
+  }
+  if (deps.operations) {
+    for (const op of deps.operations.list()) {
+      if (op.capability) {
+        const capSpec = deps.capabilities.get(op.capability.key, op.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Operation "${op.meta.key}" references capability "${op.capability.key}.v${op.capability.version}" but capability not found`,
+            specKey: op.meta.key,
+            capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+            surface: "operation"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "operation" && p.key === op.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Operation "${op.meta.key}" claims capability "${op.capability.key}.v${op.capability.version}" but not in capability's provides`,
+              specKey: op.meta.key,
+              capabilityKey: `${op.capability.key}.v${op.capability.version}`,
+              surface: "operation"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (deps.events) {
+    for (const event of deps.events.list()) {
+      if (event.capability) {
+        const capSpec = deps.capabilities.get(event.capability.key, event.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Event "${event.meta.key}" references capability "${event.capability.key}.v${event.capability.version}" but capability not found`,
+            specKey: event.meta.key,
+            capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+            surface: "event"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "event" && p.key === event.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Event "${event.meta.key}" claims capability "${event.capability.key}.v${event.capability.version}" but not in capability's provides`,
+              specKey: event.meta.key,
+              capabilityKey: `${event.capability.key}.v${event.capability.version}`,
+              surface: "event"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (deps.presentations) {
+    for (const pres of deps.presentations.list()) {
+      if (pres.capability) {
+        const capSpec = deps.capabilities.get(pres.capability.key, pres.capability.version);
+        if (!capSpec) {
+          errors.push({
+            type: "capability_not_found",
+            message: `Presentation "${pres.meta.key}" references capability "${pres.capability.key}.v${pres.capability.version}" but capability not found`,
+            specKey: pres.meta.key,
+            capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+            surface: "presentation"
+          });
+        } else {
+          const inProvides = capSpec.provides?.some((p) => p.surface === "presentation" && p.key === pres.meta.key);
+          if (!inProvides) {
+            errors.push({
+              type: "surface_not_in_provides",
+              message: `Presentation "${pres.meta.key}" claims capability "${pres.capability.key}.v${pres.capability.version}" but not in capability's provides`,
+              specKey: pres.meta.key,
+              capabilityKey: `${pres.capability.key}.v${pres.capability.version}`,
+              surface: "presentation"
+            });
+          }
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function checkSurfaceExists(deps, surface, key) {
+  switch (surface) {
+    case "operation":
+      return deps.operations?.has(key) ?? true;
+    case "event":
+      return deps.events?.has(key) ?? true;
+    case "presentation":
+      return deps.presentations?.has(key) ?? true;
+    case "workflow":
+    case "resource":
+      return true;
+    default:
+      return true;
+  }
+}
+function findOrphanSpecs(deps) {
+  const result = {
+    operations: [],
+    events: [],
+    presentations: []
+  };
+  if (deps.operations) {
+    for (const op of deps.operations.list()) {
+      if (!op.capability) {
+        result.operations.push(op.meta.key);
+      }
+    }
+  }
+  if (deps.events) {
+    for (const event of deps.events.list()) {
+      if (!event.capability) {
+        result.events.push(event.meta.key);
+      }
+    }
+  }
+  if (deps.presentations) {
+    for (const pres of deps.presentations.list()) {
+      if (!pres.capability) {
+        result.presentations.push(pres.meta.key);
+      }
+    }
+  }
+  return result;
+}
+
+// src/capabilities/context.ts
+class CapabilityMissingError extends Error {
+  capabilityKey;
+  requiredVersion;
+  constructor(capabilityKey2, requiredVersion) {
+    const versionSuffix = requiredVersion ? `.v${requiredVersion}` : "";
+    super(`Missing required capability: ${capabilityKey2}${versionSuffix}`);
+    this.name = "CapabilityMissingError";
+    this.capabilityKey = capabilityKey2;
+    this.requiredVersion = requiredVersion;
+  }
+}
+
+class CapabilityContextImpl {
+  capabilities;
+  capabilityVersions;
+  constructor(enabledCapabilities) {
+    const capSet = new Set;
+    const versionMap = new Map;
+    for (const cap of enabledCapabilities) {
+      capSet.add(cap.key);
+      versionMap.set(cap.key, cap.version);
+    }
+    this.capabilities = capSet;
+    this.capabilityVersions = versionMap;
+  }
+  hasCapability(key, version) {
+    if (!this.capabilities.has(key))
+      return false;
+    if (version != null) {
+      const enabledVersion = this.capabilityVersions.get(key);
+      return enabledVersion === version;
+    }
+    return true;
+  }
+  requireCapability(key, version) {
+    if (!this.hasCapability(key, version)) {
+      throw new CapabilityMissingError(key, version);
+    }
+  }
+  hasAllCapabilities(keys) {
+    return keys.every((k) => this.capabilities.has(k));
+  }
+  hasAnyCapability(keys) {
+    return keys.some((k) => this.capabilities.has(k));
+  }
+  getMatchingCapabilities(pattern) {
+    if (!pattern.includes("*")) {
+      return this.capabilities.has(pattern) ? [pattern] : [];
+    }
+    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return [...this.capabilities].filter((key) => regex.test(key));
+  }
+}
+function createCapabilityContext(enabledCapabilities) {
+  return new CapabilityContextImpl(enabledCapabilities);
+}
+function createEmptyCapabilityContext() {
+  return new CapabilityContextImpl([]);
+}
+function createBypassCapabilityContext(allCapabilities) {
+  return new CapabilityContextImpl(allCapabilities);
+}
+
+// src/capabilities/guards.ts
+function checkCapabilityForOperation(ctx, operation) {
+  if (!operation.capability) {
+    return { allowed: true };
+  }
+  const { key, version } = operation.capability;
+  if (ctx.hasCapability(key, version)) {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    missingCapability: { key, version },
+    reason: `Operation "${operation.meta.key}" requires capability "${key}.v${version}"`
+  };
+}
+function assertCapabilityForOperation(ctx, operation) {
+  const result = checkCapabilityForOperation(ctx, operation);
+  if (!result.allowed && result.missingCapability) {
+    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+  }
+}
+function checkCapabilityForEvent(ctx, event) {
+  if (!event.capability) {
+    return { allowed: true };
+  }
+  const { key, version } = event.capability;
+  if (ctx.hasCapability(key, version)) {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    missingCapability: { key, version },
+    reason: `Event "${event.meta.key}" requires capability "${key}.v${version}"`
+  };
+}
+function assertCapabilityForEvent(ctx, event) {
+  const result = checkCapabilityForEvent(ctx, event);
+  if (!result.allowed && result.missingCapability) {
+    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+  }
+}
+function checkCapabilityForPresentation(ctx, presentation) {
+  if (!presentation.capability) {
+    return { allowed: true };
+  }
+  const { key, version } = presentation.capability;
+  if (ctx.hasCapability(key, version)) {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    missingCapability: { key, version },
+    reason: `Presentation "${presentation.meta.key}" requires capability "${key}.v${version}"`
+  };
+}
+function assertCapabilityForPresentation(ctx, presentation) {
+  const result = checkCapabilityForPresentation(ctx, presentation);
+  if (!result.allowed && result.missingCapability) {
+    throw new CapabilityMissingError(result.missingCapability.key, result.missingCapability.version);
+  }
+}
+function filterOperationsByCapability(ctx, operations) {
+  return operations.filter((op) => checkCapabilityForOperation(ctx, op).allowed);
+}
+function filterEventsByCapability(ctx, events) {
+  return events.filter((ev) => checkCapabilityForEvent(ctx, ev).allowed);
+}
+function filterPresentationsByCapability(ctx, presentations) {
+  return presentations.filter((pres) => checkCapabilityForPresentation(ctx, pres).allowed);
+}
+
+// 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/capabilities/openbanking.ts
+var OWNERS = ["platform.finance"];
+var TAGS = ["open-banking", "finance"];
+var openBankingAccountsReadCapability = {
+  meta: {
+    key: "openbanking.accounts.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Accounts (Read)",
+    description: "Provides read-only access to linked bank accounts, including account summaries and metadata.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.accounts.list",
+      version: "1.0.0",
+      description: "List bank accounts linked to a Powens open banking connection."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.accounts.get",
+      version: "1.0.0",
+      description: "Retrieve the canonical bank account record for a specific account."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.accounts.sync",
+      version: "1.0.0",
+      description: "Trigger a refresh of bank account metadata from the open banking provider."
+    }
+  ]
+};
+var openBankingTransactionsReadCapability = {
+  meta: {
+    key: "openbanking.transactions.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Transactions (Read)",
+    description: "Enables retrieval of transaction history for linked bank accounts via open banking providers.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS, "transactions"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.transactions.list",
+      version: "1.0.0",
+      description: "List transactions for a given bank account with optional date filtering."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.transactions.sync",
+      version: "1.0.0",
+      description: "Synchronise transactions from the open banking provider into the canonical ledger."
+    }
+  ]
+};
+var openBankingBalancesReadCapability = {
+  meta: {
+    key: "openbanking.balances.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Open Banking Balances (Read)",
+    description: "Allows querying of current and available balances for linked bank accounts via open banking providers.",
+    domain: "finance",
+    owners: [...OWNERS],
+    tags: [...TAGS, "balances"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "openbanking.balances.get",
+      version: "1.0.0",
+      description: "Retrieve the latest known balances for a specified bank account."
+    },
+    {
+      surface: "operation",
+      key: "openbanking.balances.refresh",
+      version: "1.0.0",
+      description: "Force a balance refresh from the open banking provider."
+    }
+  ]
+};
+function registerOpenBankingCapabilities(registry) {
+  return registry.register(openBankingAccountsReadCapability).register(openBankingTransactionsReadCapability).register(openBankingBalancesReadCapability);
+}
+
+// src/capabilities/meeting-recorder.ts
+var OWNERS2 = ["platform.integrations"];
+var TAGS2 = ["meeting-recorder", "transcripts", "integrations"];
+var meetingRecorderMeetingsReadCapability = {
+  meta: {
+    key: "meeting-recorder.meetings.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Meetings (Read)",
+    description: "Provides read-only access to recorded meetings and their metadata.",
+    domain: "integrations",
+    owners: [...OWNERS2],
+    tags: [...TAGS2, "meetings"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.meetings.list",
+      version: "1.0.0",
+      description: "List meetings available from the recorder provider."
+    },
+    {
+      surface: "operation",
+      key: "meeting-recorder.meetings.get",
+      version: "1.0.0",
+      description: "Fetch detailed metadata for a specific meeting."
+    }
+  ]
+};
+var meetingRecorderTranscriptsReadCapability = {
+  meta: {
+    key: "meeting-recorder.transcripts.read",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Transcripts (Read)",
+    description: "Enables retrieval of transcripts for recorded meetings from external providers.",
+    domain: "integrations",
+    owners: [...OWNERS2],
+    tags: [...TAGS2, "transcripts"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.transcripts.get",
+      version: "1.0.0",
+      description: "Fetch the transcript for a specific meeting recording."
+    },
+    {
+      surface: "operation",
+      key: "meeting-recorder.transcripts.sync",
+      version: "1.0.0",
+      description: "Trigger a transcript sync from the recorder provider."
+    }
+  ]
+};
+var meetingRecorderWebhooksCapability = {
+  meta: {
+    key: "meeting-recorder.webhooks",
+    version: "1.0.0",
+    kind: "integration",
+    title: "Meeting Recorder Webhooks",
+    description: "Allows processing of webhook events for meeting transcript readiness.",
+    domain: "integrations",
+    owners: [...OWNERS2],
+    tags: [...TAGS2, "webhooks"],
+    stability: StabilityEnum.Experimental
+  },
+  provides: [
+    {
+      surface: "operation",
+      key: "meeting-recorder.webhooks.ingest",
+      version: "1.0.0",
+      description: "Ingest and verify meeting recorder webhook payloads."
+    }
+  ]
+};
+function registerMeetingRecorderCapabilities(registry) {
+  return registry.register(meetingRecorderMeetingsReadCapability).register(meetingRecorderTranscriptsReadCapability).register(meetingRecorderWebhooksCapability);
+}
+// 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 as compareVersions2 } 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 || compareVersions2(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/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/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 compareVersions3 } 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 || compareVersions3(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 = "truthy", value } = pred.when;
+    const v = getAtPath(values, path);
+    switch (op) {
+      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/examples/define.ts
+var defineExample = (spec) => spec;
+
+// src/examples/registry.ts
+class ExampleRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("example", items);
+  }
+  listByKind(kind) {
+    return this.list().filter((spec) => spec.meta.kind === kind);
+  }
+  listByVisibility(visibility) {
+    return this.list().filter((spec) => spec.meta.visibility === visibility);
+  }
+  listByDomain(domain) {
+    return this.list().filter((spec) => spec.meta.domain === domain);
+  }
+  listBySurface(surface) {
+    return this.list().filter((spec) => {
+      if (surface === "templates")
+        return spec.surfaces.templates;
+      if (surface === "sandbox")
+        return spec.surfaces.sandbox.enabled;
+      if (surface === "studio")
+        return spec.surfaces.studio.enabled;
+      if (surface === "mcp")
+        return spec.surfaces.mcp.enabled;
+      return false;
+    });
+  }
+  listInstallable() {
+    return this.list().filter((spec) => spec.surfaces.studio.installable);
+  }
+  groupByKind() {
+    const result = new Map;
+    for (const spec of this.list()) {
+      const existing = result.get(spec.meta.kind) ?? [];
+      existing.push(spec);
+      result.set(spec.meta.kind, existing);
+    }
+    return result;
+  }
+  getUniqueKinds() {
+    const kinds = new Set;
+    for (const spec of this.list()) {
+      kinds.add(spec.meta.kind);
+    }
+    return [...kinds];
+  }
+  getUniqueDomains() {
+    const domains = new Set;
+    for (const spec of this.list()) {
+      if (spec.meta.domain) {
+        domains.add(spec.meta.domain);
+      }
+    }
+    return [...domains];
+  }
+  search(query) {
+    const q = query.toLowerCase().trim();
+    if (!q)
+      return this.list();
+    return this.list().filter((spec) => {
+      const hay = [
+        spec.meta.key,
+        spec.meta.title ?? "",
+        spec.meta.description,
+        spec.meta.summary ?? "",
+        ...spec.meta.tags
+      ].join(" ").toLowerCase();
+      return hay.includes(q);
+    });
+  }
+}
+
+// src/features/registry.ts
+init_registry_utils();
+function keyOf(f) {
+  return f.meta.key;
+}
+
+class FeatureRegistry {
+  items = new Map;
+  register(f) {
+    const key = keyOf(f);
+    if (this.items.has(key))
+      throw new Error(`Duplicate feature ${key}`);
+    this.items.set(key, f);
+    return this;
+  }
+  list() {
+    return [...this.items.values()];
+  }
+  get(key) {
+    return this.items.get(key);
+  }
+  filter(criteria) {
+    return filterBy(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) {
+    return groupBy(this.list(), keyFn);
+  }
+  getUniqueTags() {
+    return getUniqueTags(this.list());
+  }
+}
+
+// src/features/install.ts
+function installFeature(feature, deps) {
+  if (deps.ops && feature.operations) {
+    for (const o of feature.operations) {
+      const s = deps.ops.get(o.key, o.version);
+      if (!s)
+        throw new Error(`installFeature: operation not found ${o.key}.v${o.version}`);
+    }
+  }
+  if (deps.presentations && feature.presentations) {
+    for (const p of feature.presentations) {
+      const pres = deps.presentations.get(p.key, p.version);
+      if (!pres)
+        throw new Error(`installFeature: presentation not found ${p.key}.v${p.version}`);
+    }
+  }
+  if (feature.presentationsTargets && deps.descriptors) {
+    for (const req of feature.presentationsTargets) {
+      const d = deps.descriptors.find((x) => x.meta.key === req.key && x.meta.version === req.version);
+      if (!d)
+        throw new Error(`installFeature: V2 descriptor not found ${req.key}.v${req.version}`);
+      for (const t of req.targets) {
+        if (!d.targets.includes(t))
+          throw new Error(`installFeature: descriptor ${req.key}.v${req.version} missing target ${t}`);
+      }
+    }
+  }
+  if (feature.opToPresentation && feature.opToPresentation.length > 0) {
+    for (const link of feature.opToPresentation) {
+      if (deps.ops) {
+        const s = deps.ops.get(link.op.key, link.op.version);
+        if (!s)
+          throw new Error(`installFeature: linked op not found ${link.op.key}.v${link.op.version}`);
+      }
+      if (deps.presentations) {
+        const pres = deps.presentations.get(link.pres.key, link.pres.version);
+        if (!pres)
+          throw new Error(`installFeature: linked presentation not found ${link.pres.key}.v${link.pres.version}`);
+      }
+    }
+  }
+  if (deps.capabilities && feature.capabilities?.provides) {
+    for (const cap of feature.capabilities.provides) {
+      const spec = deps.capabilities.get(cap.key, cap.version);
+      if (!spec)
+        throw new Error(`installFeature: capability not registered ${cap.key}.v${cap.version}`);
+    }
+  }
+  if (feature.capabilities?.requires?.length) {
+    if (!deps.capabilities)
+      throw new Error(`installFeature: capability registry required to validate capability requirements for ${feature.meta.key}`);
+    const provided = feature.capabilities.provides ?? [];
+    for (const req of feature.capabilities.requires) {
+      const satisfied = deps.capabilities.satisfies(req, provided);
+      if (!satisfied)
+        throw new Error(`installFeature: capability requirement not satisfied ${req.key}${req.version ? `.v${req.version}` : ""}`);
+    }
+  }
+  deps.features.register(feature);
+  return deps.features;
+}
+
+// src/features/validation.ts
+function validateFeatureTargetsV2(feature, descriptors) {
+  if (!feature.presentationsTargets || feature.presentationsTargets.length === 0)
+    return true;
+  for (const req of feature.presentationsTargets) {
+    const d = descriptors.find((x) => x.meta.key === req.key && x.meta.version === req.version);
+    if (!d)
+      throw new Error(`V2 descriptor not found ${req.key}.v${req.version}`);
+    for (const t of req.targets)
+      if (!d.targets.includes(t))
+        throw new Error(`Descriptor ${req.key}.v${req.version} missing target ${t}`);
+  }
+  return true;
+}
+
+// src/features/types.ts
+var defineFeature = (spec) => spec;
+// 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/prompt.ts
+function definePrompt(spec) {
+  return spec;
+}
+
+// src/promptRegistry.ts
+import { compareVersions as compareVersions4 } from "compare-versions";
+
+class PromptRegistry {
+  prompts = new Map;
+  register(p) {
+    const key = `${p.meta.key}-v${p.meta.version}`;
+    if (this.prompts.has(key))
+      throw new Error(`Duplicate prompt ${key}`);
+    this.prompts.set(key, p);
+    return this;
+  }
+  list() {
+    return [...this.prompts.values()];
+  }
+  get(name, version) {
+    if (version != null)
+      return this.prompts.get(`${name}-v${version}`);
+    let candidate;
+    for (const [k, p] of this.prompts.entries()) {
+      if (!k.startsWith(`${name}.v`))
+        continue;
+      if (!candidate || compareVersions4(p.meta.version, candidate.meta.version) > 0) {
+        candidate = p;
+      }
+    }
+    return candidate;
+  }
+}
+
+// src/resources.ts
+function defineResourceTemplate(spec) {
+  return spec;
+}
+
+class ResourceRegistry {
+  templates = [];
+  register(tmpl) {
+    this.templates.push(tmpl);
+    return this;
+  }
+  listTemplates() {
+    return [...this.templates];
+  }
+  match(uri) {
+    for (const tmpl of this.templates) {
+      const re = new RegExp("^" + tmpl.meta.uriTemplate.replace(/\{[^}]+\}/g, "([^/]+)") + "$");
+      const m = uri.match(re);
+      if (!m)
+        continue;
+      const names = [...tmpl.meta.uriTemplate.matchAll(/\{([^}]+)\}/g)].map((x) => x[1]);
+      const params = {};
+      names.forEach((n, i) => {
+        const val = m[i + 1];
+        if (n && val) {
+          params[n] = decodeURIComponent(val);
+        }
+      });
+      return { tmpl, params };
+    }
+    return;
+  }
+}
+function resourceRef(uriTemplate, opts) {
+  return {
+    kind: "resource_ref",
+    uriTemplate,
+    varName: opts.varName ?? "id",
+    graphQLType: opts.graphQLType,
+    many: opts.many
+  };
+}
+function isResourceRef(x) {
+  const o = x;
+  return !!o && o.kind === "resource_ref" && typeof o.uriTemplate === "string";
+}
+
+// src/themes.ts
+class ThemeRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("theme", items);
+  }
+}
+function makeThemeRef(spec) {
+  return { key: spec.meta.key, version: spec.meta.version };
+}
+
+// src/migrations.ts
+import { compareVersions as compareVersions5 } from "compare-versions";
+var migrationKey = (name, version) => `${name}.v${version}`;
+
+class MigrationRegistry {
+  items = new Map;
+  register(spec) {
+    const key = migrationKey(spec.meta.key, spec.meta.version);
+    if (this.items.has(key))
+      throw new Error(`Duplicate migration ${key}`);
+    this.items.set(key, spec);
+    return this;
+  }
+  list() {
+    return [...this.items.values()].sort((a, b) => {
+      const byName = a.meta.key.localeCompare(b.meta.key);
+      return byName !== 0 ? byName : compareVersions5(a.meta.version, b.meta.version);
+    });
+  }
+  get(name, version) {
+    if (version != null)
+      return this.items.get(migrationKey(name, version));
+    let candidate;
+    for (const spec of this.items.values()) {
+      if (spec.meta.key !== name)
+        continue;
+      if (!candidate || compareVersions5(spec.meta.version, candidate.meta.version) > 0) {
+        candidate = spec;
+      }
+    }
+    return candidate;
+  }
+}
+// src/versioning/refs.ts
+function isVersionedSpecRef(ref) {
+  return typeof ref === "object" && ref !== null && "key" in ref && typeof ref.key === "string" && ref.key.length > 0 && "version" in ref && typeof ref.version === "string" && ref.version.length > 0;
+}
+function isOptionalVersionedSpecRef(ref) {
+  if (typeof ref !== "object" || ref === null)
+    return false;
+  if (!("key" in ref))
+    return false;
+  if (typeof ref.key !== "string" || ref.key.length === 0) {
+    return false;
+  }
+  if ("version" in ref && ref.version != null) {
+    return typeof ref.version === "string";
+  }
+  return true;
+}
+function isSpecKeyRef(ref) {
+  return typeof ref === "object" && ref !== null && "key" in ref && typeof ref.key === "string" && ref.key.length > 0;
+}
+function createVersionedRef(key, version) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  if (!version || version.trim().length === 0) {
+    throw new Error("Spec version cannot be empty");
+  }
+  return { key: key.trim(), version: version.trim() };
+}
+function createOptionalRef(key, version) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  const ref = { key: key.trim() };
+  if (version != null && version.trim().length > 0) {
+    ref.version = version.trim();
+  }
+  return ref;
+}
+function createKeyRef(key) {
+  if (!key || key.trim().length === 0) {
+    throw new Error("Spec key cannot be empty");
+  }
+  return { key: key.trim() };
+}
+function formatVersionedRefKey(ref) {
+  return `${ref.key}.v${ref.version}`;
+}
+function parseVersionedRefKey(refKey) {
+  const match = refKey.match(/^(.+)\.v(\d+\.\d+\.\d+(?:-.+)?)$/);
+  if (!match)
+    return;
+  const key = match[1];
+  const version = match[2];
+  if (!key || !version)
+    return;
+  return { key, version };
+}
+
+// src/versioning/types.ts
+function isChangelogDocBlock(doc) {
+  return doc.kind === "changelog" && "specKey" in doc && "entries" in doc;
+}
+function isVersionBumpType(value) {
+  return value === "patch" || value === "minor" || value === "major";
+}
+function isChangeType(value) {
+  const validTypes = [
+    "added",
+    "changed",
+    "fixed",
+    "removed",
+    "deprecated",
+    "breaking",
+    "security"
+  ];
+  return typeof value === "string" && validTypes.includes(value);
+}
+
+// src/versioning/utils.ts
+var SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*))?(?:\+([a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*))?$/;
+function parseVersion(version) {
+  const match = version.trim().match(SEMVER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const majorStr = match[1];
+  const minorStr = match[2];
+  const patchStr = match[3];
+  const prerelease = match[4];
+  const build = match[5];
+  if (!majorStr || !minorStr || !patchStr) {
+    return null;
+  }
+  return {
+    major: parseInt(majorStr, 10),
+    minor: parseInt(minorStr, 10),
+    patch: parseInt(patchStr, 10),
+    ...prerelease && { prerelease },
+    ...build && { build }
+  };
+}
+function parseVersionStrict(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) {
+    throw new Error(`Invalid semantic version: "${version}"`);
+  }
+  return parsed;
+}
+function formatVersion(version) {
+  let result = `${version.major}.${version.minor}.${version.patch}`;
+  if (version.prerelease) {
+    result += `-${version.prerelease}`;
+  }
+  if (version.build) {
+    result += `+${version.build}`;
+  }
+  return result;
+}
+function compareVersions6(a, b) {
+  const versionA = parseVersionStrict(a);
+  const versionB = parseVersionStrict(b);
+  if (versionA.major !== versionB.major) {
+    return versionA.major > versionB.major ? 1 : -1;
+  }
+  if (versionA.minor !== versionB.minor) {
+    return versionA.minor > versionB.minor ? 1 : -1;
+  }
+  if (versionA.patch !== versionB.patch) {
+    return versionA.patch > versionB.patch ? 1 : -1;
+  }
+  if (versionA.prerelease && !versionB.prerelease) {
+    return -1;
+  }
+  if (!versionA.prerelease && versionB.prerelease) {
+    return 1;
+  }
+  if (versionA.prerelease && versionB.prerelease) {
+    return versionA.prerelease < versionB.prerelease ? -1 : versionA.prerelease > versionB.prerelease ? 1 : 0;
+  }
+  return 0;
+}
+function isVersionGreater(a, b) {
+  return compareVersions6(a, b) === 1;
+}
+function isVersionLess(a, b) {
+  return compareVersions6(a, b) === -1;
+}
+function isVersionEqual(a, b) {
+  return compareVersions6(a, b) === 0;
+}
+function bumpVersion(current, bumpType) {
+  const version = parseVersionStrict(current);
+  switch (bumpType) {
+    case "major":
+      return formatVersion({
+        major: version.major + 1,
+        minor: 0,
+        patch: 0
+      });
+    case "minor":
+      return formatVersion({
+        major: version.major,
+        minor: version.minor + 1,
+        patch: 0
+      });
+    case "patch":
+      return formatVersion({
+        major: version.major,
+        minor: version.minor,
+        patch: version.patch + 1
+      });
+  }
+}
+function determineBumpType(hasBreaking, hasNonBreaking) {
+  if (hasBreaking) {
+    return "major";
+  }
+  if (hasNonBreaking) {
+    return "minor";
+  }
+  return "patch";
+}
+function getBumpTypePriority(bumpType) {
+  switch (bumpType) {
+    case "major":
+      return 3;
+    case "minor":
+      return 2;
+    case "patch":
+      return 1;
+  }
+}
+function getMaxBumpType(bumpTypes) {
+  if (bumpTypes.length === 0) {
+    return null;
+  }
+  return bumpTypes.reduce((max, current) => getBumpTypePriority(current) > getBumpTypePriority(max) ? current : max);
+}
+function isValidVersion(version) {
+  return parseVersion(version) !== null;
+}
+function validateVersion(version) {
+  const errors = [];
+  if (!version || typeof version !== "string") {
+    errors.push("Version must be a non-empty string");
+    return errors;
+  }
+  const trimmed = version.trim();
+  if (trimmed !== version) {
+    errors.push("Version should not have leading or trailing whitespace");
+  }
+  if (!parseVersion(trimmed)) {
+    errors.push(`Invalid semantic version format: "${version}". Expected format: MAJOR.MINOR.PATCH[-prerelease][+build]`);
+  }
+  return errors;
+}
+// src/serialization/serializers.ts
+function isResourceRefDescriptor(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "resource_ref";
+}
+function getTypeName(type) {
+  if (!type)
+    return "unknown";
+  if (typeof type === "string")
+    return type;
+  if (typeof type === "object") {
+    if ("config" in type && type.config?.name) {
+      return type.config.name;
+    }
+    if ("name" in type && typeof type.name === "string") {
+      return type.name;
+    }
+  }
+  return "unknown";
+}
+function serializeSchemaModel(model) {
+  if (!model)
+    return null;
+  if (isResourceRefDescriptor(model)) {
+    return {
+      name: `ResourceRef<${model.graphQLType}>`,
+      description: `Reference to ${model.graphQLType} resource (${model.uriTemplate})`,
+      fields: {}
+    };
+  }
+  if ("config" in model && model.config) {
+    const config = model.config;
+    return {
+      name: config.name,
+      description: config.description,
+      fields: Object.fromEntries(Object.entries(config.fields).map(([key, field]) => [
+        key,
+        {
+          typeName: getTypeName(field.type),
+          isOptional: field.isOptional,
+          isArray: field.isArray
+        }
+      ]))
+    };
+  }
+  return {
+    name: "unknown",
+    fields: {}
+  };
+}
+function serializeOperationSpec(spec) {
+  if (!spec)
+    return null;
+  return {
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      stability: spec.meta.stability,
+      owners: spec.meta.owners,
+      tags: spec.meta.tags,
+      description: spec.meta.description,
+      goal: spec.meta.goal,
+      context: spec.meta.context
+    },
+    io: {
+      input: serializeSchemaModel(spec.io.input),
+      output: serializeSchemaModel(spec.io.output)
+    },
+    policy: spec.policy ? { auth: spec.policy.auth } : undefined
+  };
+}
+function serializeEventSpec(spec) {
+  if (!spec)
+    return null;
+  return {
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      stability: spec.meta.stability,
+      owners: spec.meta.owners,
+      tags: spec.meta.tags,
+      description: spec.meta.description
+    },
+    payload: serializeSchemaModel(spec.payload)
+  };
+}
+function serializePresentationSpec(spec) {
+  if (!spec)
+    return null;
+  return {
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      stability: spec.meta.stability,
+      owners: spec.meta.owners,
+      tags: spec.meta.tags,
+      description: spec.meta.description,
+      goal: spec.meta.goal,
+      context: spec.meta.context
+    },
+    source: {
+      type: spec.source.type,
+      framework: spec.source.type === "component" ? spec.source.framework : undefined,
+      componentKey: spec.source.type === "component" ? spec.source.componentKey : undefined
+    },
+    targets: spec.targets
+  };
+}
+function serializeDataViewSpec(spec) {
+  if (!spec)
+    return null;
+  return {
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      stability: spec.meta.stability,
+      owners: spec.meta.owners,
+      tags: spec.meta.tags,
+      description: spec.meta.description,
+      title: spec.meta.title
+    },
+    source: spec.source,
+    view: spec.view
+  };
+}
+function serializeFormSpec(spec) {
+  if (!spec)
+    return null;
+  return {
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      stability: spec.meta.stability,
+      owners: spec.meta.owners,
+      tags: spec.meta.tags,
+      description: spec.meta.description,
+      title: spec.meta.title
+    },
+    fields: spec.fields,
+    actions: spec.actions
+  };
+}
+// src/index.ts
+init_registry_utils();
+import { defineSchemaModel } from "@contractspec/lib.schema";
+export {
+  validateVersion,
+  validateFeatureTargetsV2,
+  validateCapabilityConsistency,
+  serializeSchemaModel,
+  serializePresentationSpec,
+  serializeOperationSpec,
+  serializeFormSpec,
+  serializeEventSpec,
+  serializeDataViewSpec,
+  resourceRef,
+  registerOpenBankingCapabilities,
+  registerMeetingRecorderCapabilities,
+  registerDocBlocks,
+  parseVersionedRefKey,
+  parseVersionStrict,
+  parseVersion,
+  openBankingTransactionsReadCapability,
+  openBankingBalancesReadCapability,
+  openBankingAccountsReadCapability,
+  opKey,
+  op,
+  meetingRecorderWebhooksCapability,
+  meetingRecorderTranscriptsReadCapability,
+  meetingRecorderMeetingsReadCapability,
+  makeThemeRef,
+  makeEmit,
+  listRegisteredDocBlocks,
+  isVersionedSpecRef,
+  isVersionLess,
+  isVersionGreater,
+  isVersionEqual,
+  isVersionBumpType,
+  isValidVersion,
+  isSpecKeyRef,
+  isResourceRef,
+  isOptionalVersionedSpecRef,
+  isEmitDeclRef,
+  isChangelogDocBlock,
+  isChangeType,
+  installOp,
+  installFeature,
+  groupByToArray,
+  groupByMultiple,
+  groupBy,
+  getUniqueTags,
+  getUniqueOwners,
+  getUniqueDomains,
+  getMaxBumpType,
+  getBumpTypePriority,
+  formatVersionedRefKey,
+  formatVersion,
+  findOrphanSpecs,
+  filterPresentationsByCapability,
+  filterOperationsByCapability,
+  filterEventsByCapability,
+  filterBy,
+  eventKey,
+  evalPredicate,
+  docId,
+  determineBumpType,
+  defineSchemaModel,
+  defineResourceTemplate,
+  defineQuery,
+  definePrompt,
+  definePresentation,
+  defineFormSpec,
+  defineFeature,
+  defineExample,
+  defineEvent,
+  defineCommand,
+  defineCapability,
+  defaultDocRegistry,
+  createVersionedRef,
+  createOptionalRef,
+  createKeyRef,
+  createEmptyCapabilityContext,
+  createCapabilityContext,
+  createBypassCapabilityContext,
+  compareVersions6 as compareVersions,
+  checkCapabilityForPresentation,
+  checkCapabilityForOperation,
+  checkCapabilityForEvent,
+  capabilityKey,
+  bumpVersion,
+  buildZodWithRelations,
+  assertCapabilityForPresentation,
+  assertCapabilityForOperation,
+  assertCapabilityForEvent,
+  ThemeRegistry,
+  TagsEnum,
+  Tags,
+  StabilityEnum,
+  ResourceRegistry,
+  PromptRegistry,
+  PresentationRegistry,
+  OwnersEnum,
+  Owners,
+  OperationSpecRegistry,
+  MigrationRegistry,
+  GroupingStrategies,
+  FormRegistry,
+  FeatureRegistry,
+  ExampleRegistry,
+  EventRegistry,
+  DocRegistry,
+  CapabilityRegistry,
+  CapabilityMissingError
+};