@contractspec/lib.contracts 1.62.0 → 1.64.0

package/dist/integrations/index.js

@@ -1,3984 +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/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/index.ts
-var defineFeature = (spec) => spec;
-
-// src/integrations/spec.ts
-var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
-
-class IntegrationSpecRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("integration", items);
-  }
-  getByCategory(category) {
-    return this.list().filter((spec) => spec.meta.category === category);
-  }
-}
-function makeIntegrationSpecKey(meta) {
-  return integrationKey(meta);
-}
-var defineIntegration = (spec) => spec;
-// src/integrations/providers/stripe.ts
-var stripeIntegrationSpec = defineIntegration({
-  meta: {
-    key: "payments.stripe",
-    version: "1.0.0",
-    category: "payments",
-    title: "Stripe Payments",
-    description: "Stripe integration for payment processing, charges, and payouts.",
-    domain: "payments",
-    owners: ["platform.payments"],
-    tags: ["payments", "psp"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "payments.psp", version: "1.0.0" }],
-    requires: [
-      {
-        key: "platform.webhooks",
-        optional: true,
-        reason: "Recommended for reliable event ingestion"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        accountId: {
-          type: "string",
-          description: "Connected account ID when using Stripe Connect (BYOK)."
-        },
-        region: {
-          type: "string",
-          description: "Optional Stripe region or data residency hint."
-        }
-      }
-    },
-    example: {
-      accountId: "acct_123",
-      region: "us-east-1"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey", "webhookSecret"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Stripe secret API key (sk_live_... or sk_test_...)."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Signing secret for webhook verification."
-        }
-      }
-    },
-    example: {
-      apiKey: "sk_live_***",
-      webhookSecret: "whsec_***"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://stripe.com/docs/api",
-  constraints: {
-    rateLimit: {
-      rpm: 1000,
-      rph: 20000
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a restricted Stripe API key with write access to Charges and provide a webhook signing secret.",
-    requiredScopes: ["charges:write", "customers:read"]
-  }
-});
-function registerStripeIntegration(registry2) {
-  return registry2.register(stripeIntegrationSpec);
-}
-
-// src/integrations/providers/postmark.ts
-var postmarkIntegrationSpec = defineIntegration({
-  meta: {
-    key: "email.postmark",
-    version: "1.0.0",
-    category: "email",
-    title: "Postmark Transactional Email",
-    description: "Postmark integration for transactional email delivery.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["email", "transactional"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "email.transactional", version: "1.0.0" }],
-    requires: [
-      {
-        key: "platform.webhooks",
-        optional: true,
-        reason: "Optional for inbound bounce handling"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        messageStream: {
-          type: "string",
-          description: "Optional message stream identifier (e.g., transactional)."
-        },
-        fromEmail: {
-          type: "string",
-          description: "Default From address used for outbound messages."
-        }
-      }
-    },
-    example: {
-      messageStream: "outbound",
-      fromEmail: "notifications@example.com"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["serverToken"],
-      properties: {
-        serverToken: {
-          type: "string",
-          description: "Server token for the Postmark account."
-        }
-      }
-    },
-    example: {
-      serverToken: "server-***"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 3000
-  },
-  docsUrl: "https://postmarkapp.com/developer",
-  constraints: {
-    rateLimit: {
-      rpm: 500
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Postmark server token with outbound send permissions and configure allowed from addresses."
-  }
-});
-function registerPostmarkIntegration(registry2) {
-  return registry2.register(postmarkIntegrationSpec);
-}
-
-// src/integrations/providers/qdrant.ts
-var qdrantIntegrationSpec = defineIntegration({
-  meta: {
-    key: "vectordb.qdrant",
-    version: "1.0.0",
-    category: "vector-db",
-    title: "Qdrant Vector Database",
-    description: "Qdrant integration for vector search and embeddings storage.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["vector-db", "search"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "vector-db.search", version: "1.0.0" },
-      { key: "vector-db.storage", version: "1.0.0" }
-    ],
-    requires: [
-      {
-        key: "ai.embeddings",
-        optional: true,
-        reason: "Required if vectors are generated via hosted embedding services"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiUrl: {
-          type: "string",
-          description: "Base URL for the Qdrant instance (e.g., https://qdrant.example.com)."
-        },
-        collectionPrefix: {
-          type: "string",
-          description: "Prefix applied to all collection names for this tenant."
-        }
-      }
-    },
-    example: {
-      apiUrl: "https://qdrant.example.com",
-      collectionPrefix: "tenant_"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "API key or token when authentication is enabled."
-        }
-      }
-    },
-    example: {
-      apiKey: "qdrant-api-key"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://qdrant.tech/documentation/quick-start/",
-  constraints: {
-    quotas: {
-      collections: 100,
-      pointsPerCollection: 1e6
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Provide the HTTPS endpoint of your Qdrant cluster and generate an API key with read/write access to the collections that will be managed."
-  }
-});
-function registerQdrantIntegration(registry2) {
-  return registry2.register(qdrantIntegrationSpec);
-}
-
-// src/integrations/providers/supabase-vector.ts
-var supabaseVectorIntegrationSpec = defineIntegration({
-  meta: {
-    key: "vectordb.supabase",
-    version: "1.0.0",
-    category: "vector-db",
-    title: "Supabase Vector Database (pgvector)",
-    description: "Supabase integration for embedding storage and vector similarity search using pgvector.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["vector-db", "supabase", "pgvector"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "vector-db.search", version: "1.0.0" },
-      { key: "vector-db.storage", version: "1.0.0" }
-    ],
-    requires: [
-      {
-        key: "ai.embeddings",
-        optional: true,
-        reason: "Required when vectors are generated by a hosted embedding provider."
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        schema: {
-          type: "string",
-          description: "Schema name containing the pgvector table (default: public)."
-        },
-        table: {
-          type: "string",
-          description: "Table used to store vectors and metadata (default: contractspec_vectors)."
-        },
-        createTableIfMissing: {
-          type: "boolean",
-          description: "Automatically create pgvector extension and table when first writing vectors."
-        },
-        distanceMetric: {
-          type: "string",
-          enum: ["cosine", "l2", "inner_product"],
-          description: "Distance metric used for nearest-neighbor search."
-        }
-      }
-    },
-    example: {
-      schema: "public",
-      table: "contractspec_vectors",
-      createTableIfMissing: true,
-      distanceMetric: "cosine"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["databaseUrl"],
-      properties: {
-        databaseUrl: {
-          type: "string",
-          description: "Supabase Postgres connection string with privileges to read/write vector rows."
-        }
-      }
-    },
-    example: {
-      databaseUrl: "postgresql://postgres.[project-ref]:password@aws-0-region.pooler.supabase.com:6543/postgres"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://supabase.com/docs/guides/ai/vector-columns",
-  byokSetup: {
-    setupInstructions: "Create or reuse a Supabase project, enable pgvector, and provide a Postgres connection string with read/write access to the target vector table."
-  }
-});
-function registerSupabaseVectorIntegration(registry2) {
-  return registry2.register(supabaseVectorIntegrationSpec);
-}
-
-// src/integrations/providers/supabase-postgres.ts
-var supabasePostgresIntegrationSpec = defineIntegration({
-  meta: {
-    key: "database.supabase",
-    version: "1.0.0",
-    category: "database",
-    title: "Supabase Postgres",
-    description: "Supabase Postgres integration for SQL query execution and transactional workloads.",
-    domain: "infrastructure",
-    owners: ["platform.infrastructure"],
-    tags: ["database", "postgres", "supabase"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "database.sql", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        maxConnections: {
-          type: "number",
-          description: "Optional connection pool size when opening a Postgres client to Supabase."
-        },
-        sslMode: {
-          type: "string",
-          enum: ["require", "allow", "prefer"],
-          description: "TLS mode used by the Postgres client."
-        }
-      }
-    },
-    example: {
-      maxConnections: 10,
-      sslMode: "require"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["databaseUrl"],
-      properties: {
-        databaseUrl: {
-          type: "string",
-          description: "Supabase Postgres connection string (transaction or session pooler endpoint)."
-        }
-      }
-    },
-    example: {
-      databaseUrl: "postgresql://postgres.[project-ref]:password@aws-0-region.pooler.supabase.com:6543/postgres"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://supabase.com/docs/guides/database/connecting-to-postgres",
-  byokSetup: {
-    setupInstructions: "Create or reuse a Supabase project and provide a Postgres connection string with permissions aligned to your workload."
-  }
-});
-function registerSupabasePostgresIntegration(registry2) {
-  return registry2.register(supabasePostgresIntegrationSpec);
-}
-
-// src/integrations/providers/mistral.ts
-var mistralIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-llm.mistral",
-    version: "1.0.0",
-    category: "ai-llm",
-    title: "Mistral Large Language Model",
-    description: "Mistral integration providing chat completions and embedding generation.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["ai", "llm", "embeddings"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "ai.chat", version: "1.0.0" },
-      { key: "ai.embeddings", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        model: {
-          type: "string",
-          description: "Default chat completion model (e.g., mistral-large-latest)."
-        },
-        embeddingModel: {
-          type: "string",
-          description: "Embedding model identifier."
-        }
-      }
-    },
-    example: {
-      model: "mistral-large-latest",
-      embeddingModel: "mistral-embed"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Mistral API key with access to chat and embeddings endpoints."
-        }
-      }
-    },
-    example: {
-      apiKey: "mistral-***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://docs.mistral.ai/platform/endpoints",
-  constraints: {
-    rateLimit: {
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Generate an API key within the Mistral console and ensure the selected models are enabled for the account."
-  }
-});
-function registerMistralIntegration(registry2) {
-  return registry2.register(mistralIntegrationSpec);
-}
-
-// src/integrations/providers/elevenlabs.ts
-var elevenLabsIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.elevenlabs",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "ElevenLabs Text-to-Speech",
-    description: "ElevenLabs integration for neural voice synthesis and voice catalog access.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        defaultVoiceId: {
-          type: "string",
-          description: "Optional default voice identifier for synthesis requests."
-        }
-      }
-    },
-    example: {
-      defaultVoiceId: "pNInz6obpgDQGcFmaJgB"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "ElevenLabs API key with text-to-speech permissions."
-        }
-      }
-    },
-    example: {
-      apiKey: "eleven-***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://elevenlabs.io/docs/api-reference/text-to-speech",
-  constraints: {
-    rateLimit: {
-      rpm: 120
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create an ElevenLabs API key and ensure the desired voices are accessible to the key scope."
-  }
-});
-function registerElevenLabsIntegration(registry2) {
-  return registry2.register(elevenLabsIntegrationSpec);
-}
-
-// src/integrations/providers/gradium.ts
-var gradiumIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.gradium",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "Gradium Text-to-Speech",
-    description: "Gradium integration for low-latency voice synthesis and voice catalog access.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts", "realtime"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        defaultVoiceId: {
-          type: "string",
-          description: "Optional default voice identifier used for synthesis."
-        },
-        region: {
-          type: "string",
-          enum: ["eu", "us"],
-          description: "Gradium region used by the SDK (eu or us)."
-        },
-        baseUrl: {
-          type: "string",
-          description: "Optional API base URL override for private routing or proxies."
-        },
-        timeoutMs: {
-          type: "number",
-          description: "Optional request timeout in milliseconds."
-        },
-        outputFormat: {
-          type: "string",
-          enum: [
-            "wav",
-            "pcm",
-            "opus",
-            "ulaw_8000",
-            "alaw_8000",
-            "pcm_16000",
-            "pcm_24000"
-          ],
-          description: "Optional default output format used when no format is specified."
-        }
-      }
-    },
-    example: {
-      defaultVoiceId: "YTpq7expH9539ERJ",
-      region: "eu",
-      timeoutMs: 15000,
-      outputFormat: "wav"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Gradium API key with TTS access."
-        }
-      }
-    },
-    example: {
-      apiKey: "gd_***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://gradium.ai/api_docs.html",
-  byokSetup: {
-    setupInstructions: "Create a Gradium API key, select the target region, and store credentials in your tenant secret provider."
-  }
-});
-function registerGradiumIntegration(registry2) {
-  return registry2.register(gradiumIntegrationSpec);
-}
-
-// src/integrations/providers/fal.ts
-var falIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.fal",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "Fal Chatterbox Text-to-Speech",
-    description: "Fal integration for voice synthesis using Chatterbox text-to-speech models.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts", "chatterbox"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        modelId: {
-          type: "string",
-          description: "Fal model endpoint identifier (e.g. fal-ai/chatterbox/text-to-speech)."
-        },
-        defaultVoiceUrl: {
-          type: "string",
-          description: "Optional reference audio URL used as default voice conditioning input."
-        },
-        defaultExaggeration: {
-          type: "number",
-          minimum: 0,
-          maximum: 1,
-          description: "Optional default exaggeration value for speech output."
-        },
-        defaultTemperature: {
-          type: "number",
-          minimum: 0.05,
-          maximum: 2,
-          description: "Optional default temperature for synthesis requests."
-        },
-        defaultCfg: {
-          type: "number",
-          minimum: 0.1,
-          maximum: 1,
-          description: "Optional default cfg value for synthesis requests."
-        },
-        pollIntervalMs: {
-          type: "number",
-          description: "Optional queue polling interval in milliseconds."
-        }
-      }
-    },
-    example: {
-      modelId: "fal-ai/chatterbox/text-to-speech",
-      defaultVoiceUrl: "https://storage.googleapis.com/chatterbox-demo-samples/prompts/male_rickmorty.mp3",
-      defaultExaggeration: 0.25,
-      defaultTemperature: 0.7,
-      defaultCfg: 0.5,
-      pollIntervalMs: 1000
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fal API key (FAL_KEY)."
-        }
-      }
-    },
-    example: {
-      apiKey: "key-id:key-secret"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 7000
-  },
-  docsUrl: "https://fal.ai/models/fal-ai/chatterbox/text-to-speech/api",
-  byokSetup: {
-    setupInstructions: "Create a Fal API key and configure the desired voice model endpoint before connecting tenants."
-  }
-});
-function registerFalIntegration(registry2) {
-  return registry2.register(falIntegrationSpec);
-}
-
-// src/integrations/providers/gmail.ts
-var gmailIntegrationSpec = defineIntegration({
-  meta: {
-    key: "email.gmail",
-    version: "1.0.0",
-    category: "email",
-    title: "Google Gmail API",
-    description: "Gmail integration supporting inbound thread ingestion and outbound transactional email.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["email", "gmail"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "email.inbound", version: "1.0.0" },
-      { key: "email.outbound", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        labelIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional list of label IDs to scope inbound sync."
-        },
-        includeSpamTrash: {
-          type: "boolean",
-          description: "Whether to include spam or trash messages during sync."
-        }
-      }
-    },
-    example: {
-      labelIds: ["INBOX"],
-      includeSpamTrash: false
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientId", "clientSecret", "refreshToken"],
-      properties: {
-        clientId: {
-          type: "string",
-          description: "OAuth client ID for the Google Cloud project."
-        },
-        clientSecret: {
-          type: "string",
-          description: "OAuth client secret for the Google Cloud project."
-        },
-        refreshToken: {
-          type: "string",
-          description: "OAuth refresh token for delegated Gmail access."
-        },
-        redirectUri: {
-          type: "string",
-          description: "Optional redirect URI used when issuing the refresh token."
-        }
-      }
-    },
-    example: {
-      clientId: "xxx.apps.googleusercontent.com",
-      clientSecret: "secret",
-      refreshToken: "refresh-token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.google.com/gmail/api",
-  constraints: {
-    rateLimit: {
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create an OAuth consent screen and credentials within Google Cloud Console, then authorize the Gmail scopes and store the resulting refresh token."
-  }
-});
-function registerGmailIntegration(registry2) {
-  return registry2.register(gmailIntegrationSpec);
-}
-
-// src/integrations/providers/google-calendar.ts
-var googleCalendarIntegrationSpec = defineIntegration({
-  meta: {
-    key: "calendar.google",
-    version: "1.0.0",
-    category: "calendar",
-    title: "Google Calendar API",
-    description: "Google Calendar integration for event creation, updates, and scheduling automations.",
-    domain: "productivity",
-    owners: ["platform.messaging"],
-    tags: ["calendar", "google"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "calendar.events", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        calendarId: {
-          type: "string",
-          description: "Default calendar identifier (defaults to primary)."
-        }
-      }
-    },
-    example: {
-      calendarId: "primary"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientEmail", "privateKey"],
-      properties: {
-        clientEmail: {
-          type: "string",
-          description: "Service account client email."
-        },
-        privateKey: {
-          type: "string",
-          description: "Service account private key."
-        },
-        projectId: {
-          type: "string",
-          description: "Google Cloud project ID."
-        }
-      }
-    },
-    example: {
-      clientEmail: "svc-calendar@example.iam.gserviceaccount.com",
-      privateKey: "-----BEGIN PRIVATE KEY-----...",
-      projectId: "calendar-project"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.google.com/calendar/api",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Google service account with Calendar access and share the target calendars with the service account email."
-  }
-});
-function registerGoogleCalendarIntegration(registry2) {
-  return registry2.register(googleCalendarIntegrationSpec);
-}
-
-// src/integrations/providers/twilio-sms.ts
-var twilioSmsIntegrationSpec = defineIntegration({
-  meta: {
-    key: "sms.twilio",
-    version: "1.0.0",
-    category: "sms",
-    title: "Twilio Messaging",
-    description: "Twilio SMS integration for transactional and notification messaging.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["sms", "messaging"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "sms.outbound", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        fromNumber: {
-          type: "string",
-          description: "Default Twilio phone number used as sender."
-        }
-      }
-    },
-    example: {
-      fromNumber: "+15551234567"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["accountSid", "authToken"],
-      properties: {
-        accountSid: {
-          type: "string",
-          description: "Twilio Account SID."
-        },
-        authToken: {
-          type: "string",
-          description: "Twilio Auth Token."
-        }
-      }
-    },
-    example: {
-      accountSid: "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      authToken: "auth-token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 3000
-  },
-  docsUrl: "https://www.twilio.com/docs/sms/api",
-  constraints: {
-    rateLimit: {
-      rpm: 200
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Provide a Twilio account SID, auth token, and verify the outbound sending numbers used by the integration."
-  }
-});
-function registerTwilioSmsIntegration(registry2) {
-  return registry2.register(twilioSmsIntegrationSpec);
-}
-
-// src/integrations/providers/gcs-storage.ts
-var gcsStorageIntegrationSpec = defineIntegration({
-  meta: {
-    key: "storage.gcs",
-    version: "1.0.0",
-    category: "storage",
-    title: "Google Cloud Storage Buckets",
-    description: "Google Cloud Storage integration for object storage and retrieval.",
-    domain: "infrastructure",
-    owners: ["platform.infrastructure"],
-    tags: ["storage", "gcs", "google-cloud"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "storage.objects", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["bucket"],
-      properties: {
-        bucket: {
-          type: "string",
-          description: "Primary bucket name used for storing objects."
-        },
-        prefix: {
-          type: "string",
-          description: "Optional prefix applied to object keys."
-        }
-      }
-    },
-    example: {
-      bucket: "pfo-tenant-assets",
-      prefix: "documents/"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          description: "Service account type field from Google credentials JSON (if provided)."
-        },
-        client_email: { type: "string" },
-        private_key: { type: "string" },
-        project_id: { type: "string" }
-      }
-    },
-    example: {
-      type: "service_account",
-      client_email: "svc-account@example.iam.gserviceaccount.com",
-      private_key: "-----BEGIN PRIVATE KEY-----...",
-      project_id: "example-project"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://cloud.google.com/storage/docs/apis",
-  constraints: {
-    quotas: {
-      storageGb: 5120
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Google Cloud service account with Storage Object Admin role and upload the JSON credentials to the secret store."
-  }
-});
-function registerGcsStorageIntegration(registry2) {
-  return registry2.register(gcsStorageIntegrationSpec);
-}
-
-// src/integrations/providers/powens.ts
-var powensIntegrationSpec = defineIntegration({
-  meta: {
-    key: "openbanking.powens",
-    version: "1.0.0",
-    category: "open-banking",
-    title: "Powens Open Banking (Read)",
-    description: "Read-only Open Banking integration powered by Powens, exposing accounts, transactions, and balances.",
-    domain: "finance",
-    owners: ["platform.finance"],
-    tags: ["open-banking", "powens", "finance"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "openbanking.accounts.read", version: "1.0.0" },
-      { key: "openbanking.transactions.read", version: "1.0.0" },
-      { key: "openbanking.balances.read", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["environment"],
-      properties: {
-        environment: {
-          type: "string",
-          enum: ["sandbox", "production"],
-          description: "Powens environment to target. Sandbox uses Powens test API base URL, production uses live endpoints."
-        },
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Powens API base URL. Defaults to Powens environment defaults."
-        },
-        region: {
-          type: "string",
-          description: "Optional Powens region identifier when targeting a specific data residency cluster."
-        },
-        pollingIntervalMs: {
-          type: "number",
-          description: "Optional custom polling interval in milliseconds for background sync jobs (defaults to platform standard)."
-        }
-      }
-    },
-    example: {
-      environment: "sandbox",
-      baseUrl: "https://api-sandbox.powens.com/v2",
-      region: "eu-west-1",
-      pollingIntervalMs: 300000
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientId", "clientSecret"],
-      properties: {
-        clientId: {
-          type: "string",
-          description: "Powens OAuth client identifier obtained from the Powens Console (BYOK project)."
-        },
-        clientSecret: {
-          type: "string",
-          description: "Powens OAuth client secret used to exchange for access tokens."
-        },
-        apiKey: {
-          type: "string",
-          description: "Optional Powens API key (if the tenant project exposes a dedicated API token)."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook signing secret used to verify Powens webhook payloads."
-        }
-      }
-    },
-    example: {
-      clientId: "powens-client-id",
-      clientSecret: "powens-client-secret",
-      apiKey: "powens-api-key",
-      webhookSecret: "powens-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://docs.powens.com/",
-  constraints: {
-    rateLimit: {
-      rph: 1e4,
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Powens BYOK project, generate OAuth credentials, and optionally configure webhook delivery for account/transaction updates.",
-    requiredScopes: ["accounts:read", "transactions:read", "balances:read"]
-  }
-});
-function registerPowensIntegration(registry2) {
-  return registry2.register(powensIntegrationSpec);
-}
-
-// src/integrations/providers/posthog.ts
-var posthogIntegrationSpec = defineIntegration({
-  meta: {
-    key: "analytics.posthog",
-    version: "1.1.0",
-    category: "analytics",
-    title: "PostHog",
-    description: "PostHog integration for product analytics, feature flags, HogQL queries, and LLM analytics with evaluations.",
-    domain: "analytics",
-    owners: ["@platform.integrations"],
-    tags: ["analytics", "posthog", "llm", "ai"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "analytics.events", version: "1.0.0" },
-      { key: "analytics.feature-flags", version: "1.0.0" },
-      { key: "analytics.query", version: "1.0.0" },
-      { key: "analytics.events.read", version: "1.0.0" },
-      { key: "analytics.persons", version: "1.0.0" },
-      { key: "analytics.insights", version: "1.0.0" },
-      { key: "analytics.cohorts", version: "1.0.0" },
-      { key: "analytics.annotations", version: "1.0.0" },
-      { key: "analytics.llm-tracing", version: "1.0.0" },
-      { key: "analytics.llm-evaluations", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        host: {
-          type: "string",
-          description: "PostHog host (e.g., https://app.posthog.com or self-hosted URL)."
-        },
-        projectId: {
-          type: "string",
-          description: "PostHog project ID for API queries."
-        },
-        mcpUrl: {
-          type: "string",
-          description: "Optional MCP endpoint URL for PostHog tools."
-        }
-      }
-    },
-    example: {
-      host: "https://app.posthog.com",
-      projectId: "12345"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["personalApiKey"],
-      properties: {
-        personalApiKey: {
-          type: "string",
-          description: "PostHog personal API key (required for API reads/writes)."
-        },
-        projectApiKey: {
-          type: "string",
-          description: "PostHog project API key (required for capture/ingest events)."
-        }
-      }
-    },
-    example: {
-      personalApiKey: "phx_personal_api_key",
-      projectApiKey: "phc_project_api_key"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://posthog.com/docs",
-  byokSetup: {
-    setupInstructions: "Generate a PostHog personal API key for read/write operations and a project API key for event capture."
-  }
-});
-function registerPosthogIntegration(registry2) {
-  return registry2.register(posthogIntegrationSpec);
-}
-
-// src/integrations/providers/posthog-llm-telemetry.ts
-var posthogLLMTelemetrySpec = {
-  meta: {
-    key: "analytics.posthog.llm",
-    version: "1.0.0",
-    title: "PostHog LLM Analytics Telemetry",
-    description: "Telemetry events for PostHog LLM Analytics: generation tracing, token usage, and evaluation-ready metadata.",
-    domain: "analytics",
-    owners: ["@platform.integrations"],
-    tags: ["analytics", "posthog", "llm", "ai", "telemetry"],
-    stability: StabilityEnum.Beta
-  },
-  events: [
-    {
-      key: "posthog.llm.generation",
-      version: "1.0.0",
-      semantics: {
-        who: "AI agent or LLM consumer",
-        what: "Captures an LLM generation call with full observability metadata",
-        why: "Enable LLM performance monitoring, cost tracking, and automated quality evaluations via PostHog"
-      },
-      properties: {
-        $ai_model: {
-          type: "string",
-          required: true,
-          description: "The LLM model identifier (e.g., gpt-4o, claude-sonnet-4-20250514)"
-        },
-        $ai_provider: {
-          type: "string",
-          required: true,
-          description: "The LLM provider (e.g., openai, anthropic, contractspec)"
-        },
-        $ai_latency: {
-          type: "number",
-          required: false,
-          description: "LLM call latency in seconds"
-        },
-        $ai_input_tokens: {
-          type: "number",
-          required: false,
-          description: "Number of input/prompt tokens consumed"
-        },
-        $ai_output_tokens: {
-          type: "number",
-          required: false,
-          description: "Number of output/completion tokens generated"
-        },
-        $ai_total_cost_usd: {
-          type: "number",
-          required: false,
-          description: "Total cost in USD (input + output)"
-        },
-        $ai_is_error: {
-          type: "boolean",
-          required: false,
-          description: "Whether the generation resulted in an error"
-        },
-        $ai_trace_id: {
-          type: "string",
-          required: false,
-          description: "Trace ID for grouping related generations"
-        },
-        $ai_stream: {
-          type: "boolean",
-          required: false,
-          description: "Whether the response was streamed"
-        },
-        $ai_time_to_first_token: {
-          type: "number",
-          required: false,
-          description: "Time to first token in seconds (streaming only)"
-        },
-        $ai_tools: {
-          type: "json",
-          required: false,
-          description: "Tools/functions available to the LLM"
-        },
-        $ai_input: {
-          type: "json",
-          required: false,
-          pii: true,
-          redact: true,
-          description: "Messages sent to the LLM (may contain PII)"
-        },
-        $ai_output_choices: {
-          type: "json",
-          required: false,
-          pii: true,
-          redact: true,
-          description: "Response choices from the LLM (may contain PII)"
-        },
-        contractspec_operation: {
-          type: "string",
-          required: false,
-          description: "ContractSpec operation name"
-        },
-        contractspec_version: {
-          type: "string",
-          required: false,
-          description: "ContractSpec operation version"
-        },
-        contractspec_agent_id: {
-          type: "string",
-          required: false,
-          description: "ContractSpec agent identifier"
-        },
-        contractspec_finish_reason: {
-          type: "string",
-          required: false,
-          description: "AI SDK finish reason (stop, tool-calls, error, etc.)"
-        },
-        contractspec_tool_count: {
-          type: "number",
-          required: false,
-          description: "Number of tool calls made in this step"
-        }
-      },
-      privacy: "internal",
-      tags: ["llm", "generation", "posthog"]
-    }
-  ],
-  config: {
-    defaultRetentionDays: 90,
-    defaultSamplingRate: 1,
-    providers: [
-      {
-        type: "posthog",
-        config: {
-          eventName: "$ai_generation",
-          enableEvaluations: true,
-          evaluationTemplates: [
-            "relevance",
-            "helpfulness",
-            "jailbreak",
-            "hallucination",
-            "toxicity"
-          ]
-        }
-      }
-    ]
-  }
-};
-var POSTHOG_LLM_PII_FIELDS = [
-  "$ai_input",
-  "$ai_output_choices"
-];
-var POSTHOG_LLM_TELEMETRY_EVENTS = {
-  generation: "$ai_generation",
-  span: "$ai_span",
-  evaluation: "$ai_evaluation"
-};
-var POSTHOG_EVALUATION_TEMPLATES = {
-  relevance: "relevance",
-  helpfulness: "helpfulness",
-  jailbreak: "jailbreak",
-  hallucination: "hallucination",
-  toxicity: "toxicity"
-};
-function redactPostHogLLMTelemetryPayload(payload) {
-  const redacted = { ...payload };
-  for (const field of POSTHOG_LLM_PII_FIELDS) {
-    if (field in redacted) {
-      redacted[field] = "[REDACTED]";
-    }
-  }
-  return redacted;
-}
-
-// src/integrations/providers/linear.ts
-var linearIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.linear",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Linear",
-    description: "Linear integration for issue tracking and project management workflows.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "linear"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["teamId"],
-      properties: {
-        teamId: {
-          type: "string",
-          description: "Linear team ID that owns created issues."
-        },
-        projectId: {
-          type: "string",
-          description: "Optional default project ID for new issues."
-        },
-        stateId: {
-          type: "string",
-          description: "Optional default workflow state ID."
-        },
-        assigneeId: {
-          type: "string",
-          description: "Optional default assignee ID."
-        },
-        labelIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional label IDs applied to each issue."
-        },
-        tagLabelMap: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional mapping of tags to Linear label IDs (tag -> labelId)."
-        }
-      }
-    },
-    example: {
-      teamId: "team_123",
-      projectId: "proj_456",
-      labelIds: ["label_1", "label_2"]
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Linear API key (personal or service token)."
-        }
-      }
-    },
-    example: {
-      apiKey: "lin_api_key"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.linear.app",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Linear API key with issue:write permission and store it as a secret."
-  }
-});
-function registerLinearIntegration(registry2) {
-  return registry2.register(linearIntegrationSpec);
-}
-
-// src/integrations/providers/jira.ts
-var jiraIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.jira",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Jira Cloud",
-    description: "Jira Cloud integration for creating and tracking work items.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "jira"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["siteUrl"],
-      properties: {
-        siteUrl: {
-          type: "string",
-          description: "Jira Cloud site URL (e.g., https://acme.atlassian.net)."
-        },
-        projectKey: {
-          type: "string",
-          description: "Default Jira project key for new issues."
-        },
-        issueType: {
-          type: "string",
-          description: "Default Jira issue type (e.g., Task, Story)."
-        },
-        defaultLabels: {
-          type: "array",
-          items: { type: "string" },
-          description: "Labels applied to each issue by default."
-        },
-        issueTypeMap: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional mapping from work item types to Jira issue types."
-        }
-      }
-    },
-    example: {
-      siteUrl: "https://acme.atlassian.net",
-      projectKey: "PM",
-      issueType: "Task"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["email", "apiToken"],
-      properties: {
-        email: {
-          type: "string",
-          description: "Jira account email used for API token auth."
-        },
-        apiToken: {
-          type: "string",
-          description: "Jira Cloud API token for the account."
-        }
-      }
-    },
-    example: {
-      email: "user@acme.com",
-      apiToken: "jira_api_token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Jira API token and store it with the associated account email."
-  }
-});
-function registerJiraIntegration(registry2) {
-  return registry2.register(jiraIntegrationSpec);
-}
-
-// src/integrations/providers/notion.ts
-var notionIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.notion",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Notion",
-    description: "Notion integration for creating shared project summaries and task entries.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "notion"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        databaseId: {
-          type: "string",
-          description: "Optional Notion database ID to store tasks."
-        },
-        summaryParentPageId: {
-          type: "string",
-          description: "Optional parent page ID for summary pages."
-        },
-        titleProperty: {
-          type: "string",
-          description: 'Database title property name (defaults to "Name").'
-        },
-        statusProperty: {
-          type: "string",
-          description: "Database status/select property name."
-        },
-        priorityProperty: {
-          type: "string",
-          description: "Database priority/select property name."
-        },
-        tagsProperty: {
-          type: "string",
-          description: "Database multi-select tags property name."
-        },
-        dueDateProperty: {
-          type: "string",
-          description: "Database date property name for due dates."
-        },
-        descriptionProperty: {
-          type: "string",
-          description: "Database rich-text property for descriptions."
-        }
-      }
-    },
-    example: {
-      databaseId: "xxxxxxxxxxxxxxxx",
-      summaryParentPageId: "yyyyyyyyyyyyyyyy",
-      titleProperty: "Name",
-      statusProperty: "Status"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Notion integration secret token."
-        }
-      }
-    },
-    example: {
-      apiKey: "secret_notion_token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.notion.com",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Notion internal integration, share the target database/page with it, and store the secret token."
-  }
-});
-function registerNotionIntegration(registry2) {
-  return registry2.register(notionIntegrationSpec);
-}
-
-// src/integrations/providers/granola.ts
-var granolaIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.granola",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Granola Meeting Notes",
-    description: "Granola meeting notes and transcripts via Enterprise API or MCP transport.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "granola", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Granola API base URL. Defaults to https://public-api.granola.ai for API transport."
-        },
-        transport: {
-          type: "string",
-          enum: ["api", "mcp"],
-          description: "Transport mode for Granola integration. Use api for Enterprise API or mcp for broader MCP access."
-        },
-        mcpUrl: {
-          type: "string",
-          description: "Optional override for Granola MCP URL. Defaults to https://mcp.granola.ai/mcp."
-        },
-        mcpHeaders: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional static headers for MCP gateway/proxy setups."
-        },
-        pageSize: {
-          type: "number",
-          description: "Page size for listing notes (maximum 30 per Granola API)."
-        }
-      }
-    },
-    example: {
-      transport: "mcp",
-      mcpUrl: "https://mcp.granola.ai/mcp",
-      pageSize: 10
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Granola API key used as a Bearer token for Enterprise API requests (transport=api)."
-        },
-        mcpAccessToken: {
-          type: "string",
-          description: "Optional bearer token for MCP proxy/gateway auth (transport=mcp)."
-        }
-      }
-    },
-    example: {
-      mcpAccessToken: "granola-mcp-***"
-    }
-  },
-  healthCheck: {
-    method: "list",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://docs.granola.ai/help-center/sharing/integrations/mcp",
-  byokSetup: {
-    setupInstructions: "Use Granola MCP for browser OAuth access, or configure an Enterprise API key for REST transport."
-  }
-});
-function registerGranolaIntegration(registry2) {
-  return registry2.register(granolaIntegrationSpec);
-}
-
-// src/integrations/providers/tldv.ts
-var tldvIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.tldv",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "tl;dv Meeting Recorder",
-    description: "tl;dv Public API for meeting recordings, transcripts, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "tldv", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the tl;dv API base URL. Defaults to https://pasta.tldv.io/v1alpha1."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL configured in tl;dv settings (MeetingReady/TranscriptReady)."
-        },
-        webhookEvents: {
-          type: "array",
-          items: { type: "string" },
-          description: "Webhook triggers to enable (MeetingReady, TranscriptReady)."
-        },
-        webhookScope: {
-          type: "string",
-          description: "Webhook scope to configure (user, team, or organization)."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://pasta.tldv.io/v1alpha1",
-      webhookUrl: "https://example.com/webhooks/tldv",
-      webhookEvents: ["MeetingReady", "TranscriptReady"],
-      webhookScope: "team"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "tl;dv API key used in the x-api-key header for API requests."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional shared secret for webhook verification if configured in your environment."
-        }
-      }
-    },
-    example: {
-      apiKey: "tldv-***",
-      webhookSecret: "tldv-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 6000
-  },
-  docsUrl: "https://doc.tldv.io/index.html",
-  byokSetup: {
-    setupInstructions: "Generate a tl;dv API key and optionally configure MeetingReady/TranscriptReady webhooks."
-  }
-});
-function registerTldvIntegration(registry2) {
-  return registry2.register(tldvIntegrationSpec);
-}
-
-// src/integrations/providers/fireflies.ts
-var firefliesIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.fireflies",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Fireflies.ai Meeting Recorder",
-    description: "Fireflies GraphQL API for meeting transcripts, metadata, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "fireflies", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Fireflies GraphQL endpoint. Defaults to https://api.fireflies.ai/graphql."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL configured in Fireflies developer settings."
-        },
-        webhookEvents: {
-          type: "array",
-          items: { type: "string" },
-          description: "Webhook events to subscribe to (e.g., Transcription completed)."
-        },
-        transcriptsPageSize: {
-          type: "number",
-          description: "Number of transcripts to request per GraphQL query."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://api.fireflies.ai/graphql",
-      webhookUrl: "https://example.com/webhooks/fireflies",
-      webhookEvents: ["Transcription completed"],
-      transcriptsPageSize: 25
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fireflies API key for GraphQL requests."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook secret used to verify x-hub-signature HMAC payloads."
-        }
-      }
-    },
-    example: {
-      apiKey: "fireflies-***",
-      webhookSecret: "fireflies-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 6000
-  },
-  docsUrl: "https://docs.fireflies.ai/getting-started/introduction",
-  byokSetup: {
-    setupInstructions: "Create a Fireflies API key and optionally configure webhook settings in Developer Settings."
-  }
-});
-function registerFirefliesIntegration(registry2) {
-  return registry2.register(firefliesIntegrationSpec);
-}
-
-// src/integrations/providers/fathom.ts
-var fathomIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.fathom",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Fathom Meeting Recorder",
-    description: "Fathom External API for meetings, transcripts, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "fathom", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Fathom API base URL. Defaults to https://api.fathom.ai/external/v1."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL used when registering Fathom webhooks."
-        },
-        includeTranscript: {
-          type: "boolean",
-          description: "Include transcript data in Fathom webhook payloads."
-        },
-        includeSummary: {
-          type: "boolean",
-          description: "Include summary data in Fathom webhook payloads."
-        },
-        includeActionItems: {
-          type: "boolean",
-          description: "Include action items in Fathom webhook payloads."
-        },
-        includeCrmMatches: {
-          type: "boolean",
-          description: "Include CRM matches in Fathom webhook payloads."
-        },
-        triggeredFor: {
-          type: "array",
-          items: { type: "string" },
-          description: "Recording scopes to trigger webhooks for (e.g., my_recordings)."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://api.fathom.ai/external/v1",
-      webhookUrl: "https://example.com/webhooks/fathom",
-      includeTranscript: true,
-      includeSummary: true,
-      includeActionItems: false,
-      includeCrmMatches: false,
-      triggeredFor: ["my_recordings"]
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fathom API key used in the X-Api-Key header."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook secret used to verify Fathom webhook signatures."
-        }
-      }
-    },
-    example: {
-      apiKey: "fathom-***",
-      webhookSecret: "whsec_***"
-    }
-  },
-  healthCheck: {
-    method: "list",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://developers.fathom.ai/",
-  constraints: {
-    rateLimit: {
-      rpm: 60
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Generate an API key in Fathom settings and optionally configure webhooks for meeting content readiness."
-  }
-});
-function registerFathomIntegration(registry2) {
-  return registry2.register(fathomIntegrationSpec);
-}
-// src/integrations/providers/registry.ts
-function createDefaultIntegrationSpecRegistry() {
-  const registry2 = new IntegrationSpecRegistry;
-  registerStripeIntegration(registry2);
-  registerPostmarkIntegration(registry2);
-  registerQdrantIntegration(registry2);
-  registerSupabaseVectorIntegration(registry2);
-  registerSupabasePostgresIntegration(registry2);
-  registerMistralIntegration(registry2);
-  registerElevenLabsIntegration(registry2);
-  registerGradiumIntegration(registry2);
-  registerFalIntegration(registry2);
-  registerGmailIntegration(registry2);
-  registerGoogleCalendarIntegration(registry2);
-  registerPosthogIntegration(registry2);
-  registerTwilioSmsIntegration(registry2);
-  registerGcsStorageIntegration(registry2);
-  registerPowensIntegration(registry2);
-  registerLinearIntegration(registry2);
-  registerJiraIntegration(registry2);
-  registerNotionIntegration(registry2);
-  registerGranolaIntegration(registry2);
-  registerTldvIntegration(registry2);
-  registerFirefliesIntegration(registry2);
-  registerFathomIntegration(registry2);
-  return registry2;
-}
-// src/integrations/openbanking/models.ts
-import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
-var BankAccountRecord = new SchemaModel2({
-  name: "BankAccountRecord",
-  description: "Canonical representation of a bank account synced from an open banking provider.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    institutionId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    institutionName: {
-      type: ScalarTypeEnum2.NonEmptyString(),
-      isOptional: false
-    },
-    institutionLogoUrl: { type: ScalarTypeEnum2.URL(), isOptional: true },
-    iban: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    bic: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    accountType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    displayName: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    accountNumberMasked: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    productCode: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    balance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
-    availableBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    lastSyncedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
-  }
-});
-var BankTransactionRecord = new SchemaModel2({
-  name: "BankTransactionRecord",
-  description: "Canonical transaction entry mapped from Powens into the open banking ledger.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    amount: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    date: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    bookingDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    valueDate: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
-    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    counterpartyName: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    counterpartyAccount: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    merchantCategoryCode: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    rawCategory: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    standardizedCategory: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: true
-    },
-    transactionType: {
-      type: ScalarTypeEnum2.NonEmptyString(),
-      isOptional: false
-    },
-    status: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    runningBalance: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var AccountBalanceRecord = new SchemaModel2({
-  name: "AccountBalanceRecord",
-  description: "Canonical balance snapshot computed from Powens balance payloads.",
-  fields: {
-    id: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
-    balanceType: { type: ScalarTypeEnum2.NonEmptyString(), isOptional: false },
-    currentBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: false
-    },
-    availableBalance: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    currency: { type: ScalarTypeEnum2.Currency(), isOptional: false },
-    lastUpdatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    metadata: { type: ScalarTypeEnum2.JSONObject(), isOptional: true }
-  }
-});
-
-// src/integrations/openbanking/telemetry.ts
-var OPENBANKING_PII_FIELDS = [
-  "iban",
-  "bic",
-  "accountNumberMasked",
-  "accountNumber",
-  "counterpartyName",
-  "counterpartyAccount",
-  "description",
-  "merchantName",
-  "merchantCategoryCode",
-  "reference"
-];
-var OPENBANKING_TELEMETRY_EVENTS = {
-  accountsSynced: "openbanking.accounts.synced",
-  accountsSyncFailed: "openbanking.accounts.sync_failed",
-  transactionsSynced: "openbanking.transactions.synced",
-  transactionsSyncFailed: "openbanking.transactions.sync_failed",
-  balancesRefreshed: "openbanking.balances.refreshed",
-  balancesRefreshFailed: "openbanking.balances.refresh_failed",
-  overviewGenerated: "openbanking.overview.generated"
-};
-function redactOpenBankingTelemetryPayload(payload) {
-  const redacted = {};
-  for (const [key, value] of Object.entries(payload)) {
-    if (OPENBANKING_PII_FIELDS.includes(key)) {
-      redacted[key] = maskValue(value);
-    } else if (Array.isArray(value)) {
-      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactOpenBankingTelemetryPayload(item) : item);
-    } else if (typeof value === "object" && value !== null) {
-      redacted[key] = redactOpenBankingTelemetryPayload(value);
-    } else {
-      redacted[key] = value;
-    }
-  }
-  return redacted;
-}
-function maskValue(value) {
-  if (value == null)
-    return "";
-  const str = String(value);
-  if (str.length <= 4)
-    return "*".repeat(str.length);
-  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
-}
-
-// src/integrations/openbanking/contracts/accounts.ts
-import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
-var OpenBankingListAccountsInput = new SchemaModel3({
-  name: "OpenBankingListAccountsInput",
-  description: "Parameters for listing bank accounts through the open banking provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
-    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    institutionId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    cursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    pageSize: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
-  }
-});
-var OpenBankingListAccountsOutput = new SchemaModel3({
-  name: "OpenBankingListAccountsOutput",
-  description: "Paginated list of bank accounts available to the tenant and user.",
-  fields: {
-    accounts: {
-      type: BankAccountRecord,
-      isOptional: false,
-      isArray: true
-    },
-    nextCursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingGetAccountInput = new SchemaModel3({
-  name: "OpenBankingGetAccountInput",
-  description: "Parameters for retrieving a specific bank account.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    includeBalances: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    includeLatestTransactions: {
-      type: ScalarTypeEnum3.Boolean(),
-      isOptional: true
-    }
-  }
-});
-var OpenBankingSyncAccountsInput = new SchemaModel3({
-  name: "OpenBankingSyncAccountsInput",
-  description: "Command payload to trigger an account synchronisation against the open banking provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    userId: { type: ScalarTypeEnum3.ID(), isOptional: true },
-    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: false },
-    accountIds: {
-      type: ScalarTypeEnum3.ID(),
-      isArray: true,
-      isOptional: true
-    },
-    forceFullRefresh: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
-    triggerWorkflows: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingSyncAccountsOutput = new SchemaModel3({
-  name: "OpenBankingSyncAccountsOutput",
-  description: "Result of a bank account synchronisation run.",
-  fields: {
-    synced: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    failed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    errors: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    },
-    nextSyncSuggestedAt: {
-      type: ScalarTypeEnum3.DateTime(),
-      isOptional: true
-    }
-  }
-});
-var OpenBankingListAccounts = defineQuery({
-  meta: {
-    key: "openbanking.accounts.list",
-    version: "1.0.0",
-    description: "List bank accounts available to a tenant/user via Powens Open Banking.",
-    goal: "Provide downstream workflows with the set of accounts accessible via the configured open banking connection.",
-    context: "Used by Pocket Family Office dashboards and sync workflows to enumerate bank accounts prior to syncing balances or transactions.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingListAccountsInput,
-    output: OpenBankingListAccountsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingGetAccount = defineQuery({
-  meta: {
-    key: "openbanking.accounts.get",
-    version: "1.0.0",
-    description: "Retrieve the canonical bank account record for the given account identifier.",
-    goal: "Allow user-facing experiences and automations to display up-to-date account metadata.",
-    context: "Invoked by UI surfaces and workflow automation steps that require detailed metadata for a specific bank account.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingGetAccountInput,
-    output: BankAccountRecord
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingSyncAccounts = defineCommand({
-  meta: {
-    key: "openbanking.accounts.sync",
-    version: "1.0.0",
-    description: "Initiate a synchronisation run to refresh bank account metadata from Powens.",
-    goal: "Keep canonical bank account records aligned with the external open banking provider.",
-    context: "Triggered by scheduled workflows or manual operator actions to reconcile account metadata prior to transaction/balance syncs.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "accounts"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingSyncAccountsInput,
-    output: OpenBankingSyncAccountsOutput
-  },
-  policy: {
-    auth: "admin"
-  },
-  telemetry: {
-    success: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSynced },
-      properties: ({ input, output }) => {
-        const payload = input;
-        const result = output;
-        return {
-          tenantId: payload?.tenantId,
-          connectionId: payload?.connectionId,
-          synced: result?.synced,
-          failed: result?.failed
-        };
-      }
-    },
-    failure: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSyncFailed },
-      properties: ({ input, error }) => {
-        const payload = input;
-        return {
-          tenantId: payload?.tenantId,
-          connectionId: payload?.connectionId,
-          error: error instanceof Error ? error.message : String(error ?? "unknown")
-        };
-      }
-    }
-  }
-});
-var openBankingAccountContracts = {
-  OpenBankingListAccounts,
-  OpenBankingGetAccount,
-  OpenBankingSyncAccounts
-};
-function registerOpenBankingAccountContracts(registry3) {
-  return registry3.register(OpenBankingListAccounts).register(OpenBankingGetAccount).register(OpenBankingSyncAccounts);
-}
-
-// src/integrations/openbanking/contracts/transactions.ts
-import { ScalarTypeEnum as ScalarTypeEnum4, SchemaModel as SchemaModel4 } from "@contractspec/lib.schema";
-var OpenBankingListTransactionsInput = new SchemaModel4({
-  name: "OpenBankingListTransactionsInput",
-  description: "Parameters for listing bank transactions from the canonical ledger.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum4.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum4.ID(), isOptional: false },
-    from: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    to: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    cursor: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    pageSize: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true },
-    direction: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    minimumAmount: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: true },
-    maximumAmount: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: true },
-    category: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true }
-  }
-});
-var OpenBankingListTransactionsOutput = new SchemaModel4({
-  name: "OpenBankingListTransactionsOutput",
-  description: "Paginated list of transactions for a bank account.",
-  fields: {
-    transactions: {
-      type: BankTransactionRecord,
-      isOptional: false,
-      isArray: true
-    },
-    nextCursor: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
-    hasMore: { type: ScalarTypeEnum4.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingSyncTransactionsInput = new SchemaModel4({
-  name: "OpenBankingSyncTransactionsInput",
-  description: "Command payload to synchronise transactions from the open banking provider into the canonical ledger.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum4.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum4.ID(), isOptional: false },
-    from: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    to: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    connectionId: { type: ScalarTypeEnum4.ID(), isOptional: true },
-    includePending: { type: ScalarTypeEnum4.Boolean(), isOptional: true },
-    backfillDays: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: true }
-  }
-});
-var OpenBankingSyncTransactionsOutput = new SchemaModel4({
-  name: "OpenBankingSyncTransactionsOutput",
-  description: "Result of a transaction synchronisation run.",
-  fields: {
-    synced: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
-    failed: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
-    earliestSyncedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    latestSyncedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true },
-    nextSinceToken: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isOptional: true
-    },
-    errors: {
-      type: ScalarTypeEnum4.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    }
-  }
-});
-var OpenBankingListTransactions = defineQuery({
-  meta: {
-    key: "openbanking.transactions.list",
-    version: "1.0.0",
-    description: "List bank transactions that have been normalised into the canonical ledger.",
-    goal: "Allow downstream analytics and UI surfaces to page through canonical bank transactions.",
-    context: "Used by Pocket Family Office dashboards, reconciliation workflows, and analytics data views.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "transactions"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingListTransactionsInput,
-    output: OpenBankingListTransactionsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingSyncTransactions = defineCommand({
-  meta: {
-    key: "openbanking.transactions.sync",
-    version: "1.0.0",
-    description: "Synchronise transactions for a bank account by calling the configured open banking provider.",
-    goal: "Ensure the canonical transaction ledger stays aligned with the external provider.",
-    context: "Triggered by scheduled workflows or on-demand actions when activity is expected on an account.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "transactions"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingSyncTransactionsInput,
-    output: OpenBankingSyncTransactionsOutput
-  },
-  policy: {
-    auth: "admin"
-  },
-  telemetry: {
-    success: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.transactionsSynced },
-      properties: ({ input, output }) => {
-        const payload = input;
-        const result = output;
-        return {
-          tenantId: payload?.tenantId,
-          accountId: payload?.accountId,
-          synced: result?.synced,
-          failed: result?.failed,
-          earliestSyncedAt: result?.earliestSyncedAt,
-          latestSyncedAt: result?.latestSyncedAt
-        };
-      }
-    },
-    failure: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.transactionsSyncFailed },
-      properties: ({ input, error }) => {
-        const payload = input;
-        return {
-          tenantId: payload?.tenantId,
-          accountId: payload?.accountId,
-          error: error instanceof Error ? error.message : String(error ?? "unknown")
-        };
-      }
-    }
-  }
-});
-var openBankingTransactionContracts = {
-  OpenBankingListTransactions,
-  OpenBankingSyncTransactions
-};
-function registerOpenBankingTransactionContracts(registry3) {
-  return registry3.register(OpenBankingListTransactions).register(OpenBankingSyncTransactions);
-}
-
-// src/integrations/openbanking/contracts/balances.ts
-import { ScalarTypeEnum as ScalarTypeEnum5, SchemaModel as SchemaModel5 } from "@contractspec/lib.schema";
-var OpenBankingGetBalancesInput = new SchemaModel5({
-  name: "OpenBankingGetBalancesInput",
-  description: "Parameters for retrieving bank account balances from the canonical ledger.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum5.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum5.ID(), isOptional: false },
-    balanceTypes: {
-      type: ScalarTypeEnum5.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    }
-  }
-});
-var OpenBankingGetBalancesOutput = new SchemaModel5({
-  name: "OpenBankingGetBalancesOutput",
-  description: "Canonical balances for a bank account.",
-  fields: {
-    balances: {
-      type: AccountBalanceRecord,
-      isOptional: false,
-      isArray: true
-    },
-    asOf: { type: ScalarTypeEnum5.DateTime(), isOptional: true }
-  }
-});
-var OpenBankingRefreshBalancesInput = new SchemaModel5({
-  name: "OpenBankingRefreshBalancesInput",
-  description: "Command payload to refresh balances for a bank account via the open banking provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum5.ID(), isOptional: false },
-    accountId: { type: ScalarTypeEnum5.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum5.ID(), isOptional: true },
-    balanceTypes: {
-      type: ScalarTypeEnum5.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    },
-    forceRefresh: { type: ScalarTypeEnum5.Boolean(), isOptional: true }
-  }
-});
-var OpenBankingRefreshBalancesOutput = new SchemaModel5({
-  name: "OpenBankingRefreshBalancesOutput",
-  description: "Result of a balance refresh against the open banking provider.",
-  fields: {
-    balances: {
-      type: AccountBalanceRecord,
-      isOptional: false,
-      isArray: true
-    },
-    refreshedAt: { type: ScalarTypeEnum5.DateTime(), isOptional: false },
-    errors: {
-      type: ScalarTypeEnum5.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    }
-  }
-});
-var OpenBankingGetBalances = defineQuery({
-  meta: {
-    key: "openbanking.balances.get",
-    version: "1.0.0",
-    description: "Retrieve the latest cached balances for a bank account.",
-    goal: "Expose current and available balances required by dashboards and analytics.",
-    context: "Used by Pocket Family Office UI surfaces and automation steps that require balance totals prior to generating summaries.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "balances"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingGetBalancesInput,
-    output: OpenBankingGetBalancesOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var OpenBankingRefreshBalances = defineCommand({
-  meta: {
-    key: "openbanking.balances.refresh",
-    version: "1.0.0",
-    description: "Refresh balances for a bank account via the configured open banking provider.",
-    goal: "Ensure canonical balance records reflect the latest values from Powens.",
-    context: "Triggered by scheduled workflows before generating summaries or forecasting cashflow.",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "balances"],
-    stability: "experimental"
-  },
-  io: {
-    input: OpenBankingRefreshBalancesInput,
-    output: OpenBankingRefreshBalancesOutput
-  },
-  policy: {
-    auth: "admin"
-  },
-  telemetry: {
-    success: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.balancesRefreshed },
-      properties: ({ input, output }) => {
-        const payload = input;
-        const result = output;
-        return {
-          tenantId: payload?.tenantId,
-          accountId: payload?.accountId,
-          refreshedAt: result?.refreshedAt,
-          balanceCount: Array.isArray(result?.balances) ? result?.balances.length : undefined
-        };
-      }
-    },
-    failure: {
-      event: { key: OPENBANKING_TELEMETRY_EVENTS.balancesRefreshFailed },
-      properties: ({ input, error }) => {
-        const payload = input;
-        return {
-          tenantId: payload?.tenantId,
-          accountId: payload?.accountId,
-          error: error instanceof Error ? error.message : String(error ?? "unknown")
-        };
-      }
-    }
-  }
-});
-var openBankingBalanceContracts = {
-  OpenBankingGetBalances,
-  OpenBankingRefreshBalances
-};
-function registerOpenBankingBalanceContracts(registry3) {
-  return registry3.register(OpenBankingGetBalances).register(OpenBankingRefreshBalances);
-}
-
-// src/integrations/openbanking/openbanking.feature.ts
-var OpenBankingFeature = defineFeature({
-  meta: {
-    key: "openbanking",
-    version: "1.0.0",
-    title: "Open Banking Integration",
-    description: "Open banking account sync, balance refresh, and transaction synchronization",
-    domain: "integrations",
-    owners: ["@platform.finance"],
-    tags: ["open-banking", "powens", "finance", "banking"],
-    stability: "experimental"
-  },
-  operations: [
-    { key: "openbanking.accounts.sync", version: "1.0.0" },
-    { key: "openbanking.accounts.list", version: "1.0.0" },
-    { key: "openbanking.accounts.get", version: "1.0.0" },
-    { key: "openbanking.balances.refresh", version: "1.0.0" },
-    { key: "openbanking.balances.get", version: "1.0.0" },
-    { key: "openbanking.transactions.sync", version: "1.0.0" },
-    { key: "openbanking.transactions.list", version: "1.0.0" }
-  ],
-  events: [],
-  presentations: [],
-  opToPresentation: [],
-  presentationsTargets: [],
-  capabilities: {
-    provides: [{ key: "openbanking", version: "1.0.0" }],
-    requires: [{ key: "identity", version: "1.0.0" }]
-  }
-});
-// src/integrations/openbanking/contracts/index.ts
-function registerOpenBankingContracts(registry3) {
-  return registerOpenBankingBalanceContracts(registerOpenBankingTransactionContracts(registerOpenBankingAccountContracts(registry3)));
-}
-
-// src/integrations/openbanking/guards.ts
-var PRIMARY_SLOT_ID = "primaryOpenBanking";
-function ensurePrimaryOpenBankingIntegration(config) {
-  const integration = config.integrations.find((item) => item.slot.slotId === PRIMARY_SLOT_ID);
-  if (!integration) {
-    return {
-      ok: false,
-      error: "primaryOpenBanking slot is not bound in the resolved app config."
-    };
-  }
-  const status = integration.connection.status;
-  if (status === "error" || status === "disconnected") {
-    return {
-      ok: false,
-      integration,
-      error: `primaryOpenBanking connection is in status "${status}".`
-    };
-  }
-  if (status === "unknown") {
-    return {
-      ok: false,
-      integration,
-      error: "primaryOpenBanking connection health is unknown."
-    };
-  }
-  return { ok: true, integration };
-}
-function assertPrimaryOpenBankingReady(config) {
-  const result = ensurePrimaryOpenBankingIntegration(config);
-  if (!result.ok) {
-    throw new Error(result.error ?? "Open banking integration not available.");
-  }
-  if (!result.integration) {
-    throw new Error(result.error ?? "Open banking integration not available.");
-  }
-  return result.integration;
-}
-
-// src/integrations/meeting-recorder/models.ts
-import { ScalarTypeEnum as ScalarTypeEnum6, SchemaModel as SchemaModel6 } from "@contractspec/lib.schema";
-var MeetingParticipantRecord = new SchemaModel6({
-  name: "MeetingParticipantRecord",
-  description: "Canonical participant entry for meetings and transcripts from recorder providers.",
-  fields: {
-    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    externalId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    name: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    email: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    role: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    isExternal: { type: ScalarTypeEnum6.Boolean(), isOptional: true },
-    metadata: { type: ScalarTypeEnum6.JSONObject(), isOptional: true }
-  }
-});
-var MeetingTranscriptSegmentRecord = new SchemaModel6({
-  name: "MeetingTranscriptSegmentRecord",
-  description: "A single transcript segment with speaker attribution.",
-  fields: {
-    index: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
-    speakerId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    speakerName: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    speakerEmail: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    text: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    startTimeMs: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: true },
-    endTimeMs: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: true },
-    startTime: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    endTime: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    confidence: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum6.JSONObject(), isOptional: true }
-  }
-});
-var MeetingRecord = new SchemaModel6({
-  name: "MeetingRecord",
-  description: "Canonical meeting metadata synced from meeting recorder providers.",
-  fields: {
-    id: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
-    title: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    summary: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    organizer: { type: MeetingParticipantRecord, isOptional: true },
-    invitees: {
-      type: MeetingParticipantRecord,
-      isArray: true,
-      isOptional: true
-    },
-    participants: {
-      type: MeetingParticipantRecord,
-      isArray: true,
-      isOptional: true
-    },
-    scheduledStartAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    scheduledEndAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    recordingStartAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    recordingEndAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    durationSeconds: {
-      type: ScalarTypeEnum6.Float_unsecure(),
-      isOptional: true
-    },
-    meetingUrl: { type: ScalarTypeEnum6.URL(), isOptional: true },
-    recordingUrl: { type: ScalarTypeEnum6.URL(), isOptional: true },
-    shareUrl: { type: ScalarTypeEnum6.URL(), isOptional: true },
-    sourcePlatform: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: true
-    },
-    language: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    transcriptAvailable: { type: ScalarTypeEnum6.Boolean(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    updatedAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    metadata: { type: ScalarTypeEnum6.JSONObject(), isOptional: true }
-  }
-});
-var MeetingTranscriptRecord = new SchemaModel6({
-  name: "MeetingTranscriptRecord",
-  description: "Canonical transcript payload for a recorded meeting.",
-  fields: {
-    id: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    meetingId: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    tenantId: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum6.ID(), isOptional: false },
-    externalId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    format: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    text: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    segments: {
-      type: MeetingTranscriptSegmentRecord,
-      isArray: true,
-      isOptional: true
-    },
-    language: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    sourceUrl: { type: ScalarTypeEnum6.URL(), isOptional: true },
-    generatedAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    metadata: { type: ScalarTypeEnum6.JSONObject(), isOptional: true },
-    raw: { type: ScalarTypeEnum6.JSON(), isOptional: true }
-  }
-});
-var MeetingRecorderWebhookEventRecord = new SchemaModel6({
-  name: "MeetingRecorderWebhookEventRecord",
-  description: "Normalized webhook event from a meeting recorder provider.",
-  fields: {
-    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    providerKey: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    eventType: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    meetingId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    transcriptId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    recordingId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    receivedAt: { type: ScalarTypeEnum6.DateTime(), isOptional: true },
-    verified: { type: ScalarTypeEnum6.Boolean(), isOptional: true },
-    payload: { type: ScalarTypeEnum6.JSON(), isOptional: true },
-    metadata: { type: ScalarTypeEnum6.JSONObject(), isOptional: true }
-  }
-});
-
-// src/integrations/meeting-recorder/contracts/meetings.ts
-import { ScalarTypeEnum as ScalarTypeEnum7, SchemaModel as SchemaModel7 } from "@contractspec/lib.schema";
-var MeetingRecorderListMeetingsInput = new SchemaModel7({
-  name: "MeetingRecorderListMeetingsInput",
-  description: "Parameters for listing meetings from a meeting recorder provider.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum7.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum7.ID(), isOptional: true },
-    from: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
-    to: { type: ScalarTypeEnum7.DateTime(), isOptional: true },
-    cursor: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    pageSize: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: true },
-    query: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    organizerEmail: {
-      type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: true
-    },
-    participantEmail: {
-      type: ScalarTypeEnum7.String_unsecure(),
-      isOptional: true
-    },
-    includeTranscript: { type: ScalarTypeEnum7.Boolean(), isOptional: true },
-    includeSummary: { type: ScalarTypeEnum7.Boolean(), isOptional: true }
-  }
-});
-var MeetingRecorderListMeetingsOutput = new SchemaModel7({
-  name: "MeetingRecorderListMeetingsOutput",
-  description: "Paginated list of meetings for a recorder provider.",
-  fields: {
-    meetings: {
-      type: MeetingRecord,
-      isOptional: false,
-      isArray: true
-    },
-    nextCursor: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
-    hasMore: { type: ScalarTypeEnum7.Boolean(), isOptional: true }
-  }
-});
-var MeetingRecorderGetMeetingInput = new SchemaModel7({
-  name: "MeetingRecorderGetMeetingInput",
-  description: "Parameters for retrieving a single meeting record.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum7.ID(), isOptional: false },
-    meetingId: { type: ScalarTypeEnum7.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum7.ID(), isOptional: true },
-    includeTranscript: { type: ScalarTypeEnum7.Boolean(), isOptional: true },
-    includeSummary: { type: ScalarTypeEnum7.Boolean(), isOptional: true }
-  }
-});
-var MeetingRecorderListMeetings = defineQuery({
-  meta: {
-    key: "meeting-recorder.meetings.list",
-    version: "1.0.0",
-    description: "List meetings recorded by the configured meeting provider.",
-    goal: "Provide downstream workflows with recent meetings and metadata.",
-    context: "Used by integration hubs and sync workflows to enumerate meetings before pulling transcripts.",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "meetings", "transcripts"],
-    stability: "experimental"
-  },
-  io: {
-    input: MeetingRecorderListMeetingsInput,
-    output: MeetingRecorderListMeetingsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var MeetingRecorderGetMeeting = defineQuery({
-  meta: {
-    key: "meeting-recorder.meetings.get",
-    version: "1.0.0",
-    description: "Retrieve metadata for a single meeting recording.",
-    goal: "Allow downstream experiences to display detailed meeting metadata.",
-    context: "Used when drilling into a specific meeting from a transcript or integration dashboard.",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "meetings"],
-    stability: "experimental"
-  },
-  io: {
-    input: MeetingRecorderGetMeetingInput,
-    output: MeetingRecord
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var meetingRecorderMeetingContracts = {
-  MeetingRecorderListMeetings,
-  MeetingRecorderGetMeeting
-};
-function registerMeetingRecorderMeetingContracts(registry3) {
-  return registry3.register(MeetingRecorderListMeetings).register(MeetingRecorderGetMeeting);
-}
-
-// src/integrations/meeting-recorder/telemetry.ts
-var MEETING_RECORDER_PII_FIELDS = [
-  "email",
-  "organizerEmail",
-  "participantEmail",
-  "participants",
-  "invitees",
-  "attendees",
-  "speakerName",
-  "speakerEmail",
-  "name",
-  "phone",
-  "phoneNumber",
-  "displayName"
-];
-var MEETING_RECORDER_TELEMETRY_EVENTS = {
-  meetingsSynced: "meeting-recorder.meetings.synced",
-  meetingsSyncFailed: "meeting-recorder.meetings.sync_failed",
-  transcriptsFetched: "meeting-recorder.transcripts.fetched",
-  transcriptsFetchFailed: "meeting-recorder.transcripts.fetch_failed",
-  transcriptsSynced: "meeting-recorder.transcripts.synced",
-  transcriptsSyncFailed: "meeting-recorder.transcripts.sync_failed",
-  webhookReceived: "meeting-recorder.webhooks.received",
-  webhookRejected: "meeting-recorder.webhooks.rejected"
-};
-function redactMeetingRecorderTelemetryPayload(payload) {
-  const redacted = {};
-  for (const [key, value] of Object.entries(payload)) {
-    if (MEETING_RECORDER_PII_FIELDS.includes(key)) {
-      redacted[key] = maskValue2(value);
-    } else if (Array.isArray(value)) {
-      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactMeetingRecorderTelemetryPayload(item) : item);
-    } else if (typeof value === "object" && value !== null) {
-      redacted[key] = redactMeetingRecorderTelemetryPayload(value);
-    } else {
-      redacted[key] = value;
-    }
-  }
-  return redacted;
-}
-function maskValue2(value) {
-  if (value == null)
-    return "";
-  const str = String(value);
-  if (str.length <= 4)
-    return "*".repeat(str.length);
-  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
-}
-
-// src/integrations/meeting-recorder/contracts/transcripts.ts
-import { ScalarTypeEnum as ScalarTypeEnum8, SchemaModel as SchemaModel8 } from "@contractspec/lib.schema";
-var MeetingRecorderGetTranscriptInput = new SchemaModel8({
-  name: "MeetingRecorderGetTranscriptInput",
-  description: "Parameters for fetching a meeting transcript.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum8.ID(), isOptional: false },
-    meetingId: { type: ScalarTypeEnum8.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum8.ID(), isOptional: true },
-    includeSegments: { type: ScalarTypeEnum8.Boolean(), isOptional: true },
-    format: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
-  }
-});
-var MeetingRecorderSyncTranscriptInput = new SchemaModel8({
-  name: "MeetingRecorderSyncTranscriptInput",
-  description: "Command payload to synchronise meeting transcripts.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum8.ID(), isOptional: false },
-    meetingId: { type: ScalarTypeEnum8.ID(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum8.ID(), isOptional: true },
-    forceRefresh: { type: ScalarTypeEnum8.Boolean(), isOptional: true },
-    triggerWebhooks: { type: ScalarTypeEnum8.Boolean(), isOptional: true }
-  }
-});
-var MeetingRecorderSyncTranscriptOutput = new SchemaModel8({
-  name: "MeetingRecorderSyncTranscriptOutput",
-  description: "Result of a transcript synchronisation run.",
-  fields: {
-    synced: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
-    failed: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
-    errors: {
-      type: ScalarTypeEnum8.String_unsecure(),
-      isArray: true,
-      isOptional: true
-    },
-    nextSyncSuggestedAt: {
-      type: ScalarTypeEnum8.DateTime(),
-      isOptional: true
-    }
-  }
-});
-var MeetingRecorderGetTranscript = defineQuery({
-  meta: {
-    key: "meeting-recorder.transcripts.get",
-    version: "1.0.0",
-    description: "Fetch the transcript for a specific meeting recording.",
-    goal: "Expose meeting transcripts for downstream knowledge and analytics flows.",
-    context: "Used by agents and dashboards to access the transcript for a selected meeting.",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "transcripts"],
-    stability: "experimental"
-  },
-  io: {
-    input: MeetingRecorderGetTranscriptInput,
-    output: MeetingTranscriptRecord
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var MeetingRecorderSyncTranscript = defineCommand({
-  meta: {
-    key: "meeting-recorder.transcripts.sync",
-    version: "1.0.0",
-    description: "Trigger a transcript sync from the meeting recorder provider.",
-    goal: "Keep canonical transcripts aligned with external meeting providers.",
-    context: "Invoked by scheduled jobs or webhooks when new transcripts are ready.",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "transcripts", "sync"],
-    stability: "experimental"
-  },
-  io: {
-    input: MeetingRecorderSyncTranscriptInput,
-    output: MeetingRecorderSyncTranscriptOutput
-  },
-  policy: {
-    auth: "admin"
-  },
-  telemetry: {
-    success: {
-      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSynced },
-      properties: ({ input, output }) => {
-        const payload = input;
-        const result = output;
-        return {
-          tenantId: payload?.tenantId,
-          meetingId: payload?.meetingId,
-          synced: result?.synced,
-          failed: result?.failed
-        };
-      }
-    },
-    failure: {
-      event: { key: MEETING_RECORDER_TELEMETRY_EVENTS.transcriptsSyncFailed },
-      properties: ({ input, error }) => {
-        const payload = input;
-        return {
-          tenantId: payload?.tenantId,
-          meetingId: payload?.meetingId,
-          error: error instanceof Error ? error.message : String(error ?? "unknown")
-        };
-      }
-    }
-  }
-});
-var meetingRecorderTranscriptContracts = {
-  MeetingRecorderGetTranscript,
-  MeetingRecorderSyncTranscript
-};
-function registerMeetingRecorderTranscriptContracts(registry3) {
-  return registry3.register(MeetingRecorderGetTranscript).register(MeetingRecorderSyncTranscript);
-}
-
-// src/integrations/meeting-recorder/contracts/webhooks.ts
-import { ScalarTypeEnum as ScalarTypeEnum9, SchemaModel as SchemaModel9 } from "@contractspec/lib.schema";
-var MeetingRecorderWebhookIngestInput = new SchemaModel9({
-  name: "MeetingRecorderWebhookIngestInput",
-  description: "Payload for ingesting a meeting recorder webhook event.",
-  fields: {
-    tenantId: { type: ScalarTypeEnum9.ID(), isOptional: false },
-    providerKey: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    connectionId: { type: ScalarTypeEnum9.ID(), isOptional: true },
-    webhookId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    headers: { type: ScalarTypeEnum9.JSON(), isOptional: true },
-    payload: { type: ScalarTypeEnum9.JSON(), isOptional: false },
-    receivedAt: { type: ScalarTypeEnum9.DateTime(), isOptional: true }
-  }
-});
-var MeetingRecorderWebhookIngestOutput = new SchemaModel9({
-  name: "MeetingRecorderWebhookIngestOutput",
-  description: "Result of processing a meeting recorder webhook.",
-  fields: {
-    accepted: { type: ScalarTypeEnum9.Boolean(), isOptional: false },
-    event: { type: MeetingRecorderWebhookEventRecord, isOptional: true }
-  }
-});
-var MeetingRecorderWebhookIngest = defineCommand({
-  meta: {
-    key: "meeting-recorder.webhooks.ingest",
-    version: "1.0.0",
-    description: "Ingest a webhook from a meeting recorder provider.",
-    goal: "Trigger transcript syncs or downstream workflows without polling.",
-    context: "Used by webhook handlers to validate and normalize provider webhook events.",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "webhooks", "transcripts"],
-    stability: "experimental"
-  },
-  io: {
-    input: MeetingRecorderWebhookIngestInput,
-    output: MeetingRecorderWebhookIngestOutput
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var meetingRecorderWebhookContracts = {
-  MeetingRecorderWebhookIngest
-};
-function registerMeetingRecorderWebhookContracts(registry3) {
-  return registry3.register(MeetingRecorderWebhookIngest);
-}
-
-// src/integrations/meeting-recorder/meeting-recorder.feature.ts
-var MeetingRecorderFeature = defineFeature({
-  meta: {
-    key: "meeting-recorder",
-    version: "1.0.0",
-    title: "Meeting Recorder Integration",
-    description: "Meeting metadata, transcript retrieval, and webhook ingestion for meeting recorder providers.",
-    domain: "integrations",
-    owners: ["@platform.integrations"],
-    tags: ["meeting-recorder", "transcripts", "integrations"],
-    stability: "experimental"
-  },
-  operations: [
-    { key: "meeting-recorder.meetings.list", version: "1.0.0" },
-    { key: "meeting-recorder.meetings.get", version: "1.0.0" },
-    { key: "meeting-recorder.transcripts.get", version: "1.0.0" },
-    { key: "meeting-recorder.transcripts.sync", version: "1.0.0" },
-    { key: "meeting-recorder.webhooks.ingest", version: "1.0.0" }
-  ],
-  events: [],
-  presentations: [],
-  opToPresentation: [],
-  presentationsTargets: [],
-  capabilities: {
-    provides: [{ key: "meeting-recorder", version: "1.0.0" }],
-    requires: [{ key: "identity", version: "1.0.0" }]
-  }
-});
-// src/integrations/meeting-recorder/contracts/index.ts
-function registerMeetingRecorderContracts(registry3) {
-  return registerMeetingRecorderWebhookContracts(registerMeetingRecorderTranscriptContracts(registerMeetingRecorderMeetingContracts(registry3)));
-}
-export {
-  twilioSmsIntegrationSpec,
-  tldvIntegrationSpec,
-  supabaseVectorIntegrationSpec,
-  supabasePostgresIntegrationSpec,
-  stripeIntegrationSpec,
-  registerTwilioSmsIntegration,
-  registerTldvIntegration,
-  registerSupabaseVectorIntegration,
-  registerSupabasePostgresIntegration,
-  registerStripeIntegration,
-  registerQdrantIntegration,
-  registerPowensIntegration,
-  registerPostmarkIntegration,
-  registerPosthogIntegration,
-  registerOpenBankingContracts,
-  registerNotionIntegration,
-  registerMistralIntegration,
-  registerMeetingRecorderContracts,
-  registerLinearIntegration,
-  registerJiraIntegration,
-  registerGranolaIntegration,
-  registerGradiumIntegration,
-  registerGoogleCalendarIntegration,
-  registerGmailIntegration,
-  registerGcsStorageIntegration,
-  registerFirefliesIntegration,
-  registerFathomIntegration,
-  registerFalIntegration,
-  registerElevenLabsIntegration,
-  redactPostHogLLMTelemetryPayload,
-  redactOpenBankingTelemetryPayload,
-  redactMeetingRecorderTelemetryPayload,
-  qdrantIntegrationSpec,
-  powensIntegrationSpec,
-  postmarkIntegrationSpec,
-  posthogLLMTelemetrySpec,
-  posthogIntegrationSpec,
-  notionIntegrationSpec,
-  mistralIntegrationSpec,
-  makeIntegrationSpecKey,
-  linearIntegrationSpec,
-  jiraIntegrationSpec,
-  granolaIntegrationSpec,
-  gradiumIntegrationSpec,
-  googleCalendarIntegrationSpec,
-  gmailIntegrationSpec,
-  gcsStorageIntegrationSpec,
-  firefliesIntegrationSpec,
-  fathomIntegrationSpec,
-  falIntegrationSpec,
-  ensurePrimaryOpenBankingIntegration,
-  elevenLabsIntegrationSpec,
-  defineIntegration,
-  createDefaultIntegrationSpecRegistry,
-  assertPrimaryOpenBankingReady,
-  POSTHOG_LLM_TELEMETRY_EVENTS,
-  POSTHOG_LLM_PII_FIELDS,
-  POSTHOG_EVALUATION_TEMPLATES,
-  OpenBankingSyncTransactions,
-  OpenBankingSyncAccounts,
-  OpenBankingRefreshBalances,
-  OpenBankingListTransactions,
-  OpenBankingListAccounts,
-  OpenBankingGetBalances,
-  OpenBankingGetAccount,
-  OpenBankingFeature,
-  OPENBANKING_TELEMETRY_EVENTS,
-  OPENBANKING_PII_FIELDS,
-  MeetingTranscriptSegmentRecord,
-  MeetingTranscriptRecord as MeetingTranscriptRecordModel,
-  MeetingRecorderWebhookIngest,
-  MeetingRecorderWebhookEventRecord,
-  MeetingRecorderSyncTranscript,
-  MeetingRecorderListMeetings,
-  MeetingRecorderGetTranscript,
-  MeetingRecorderGetMeeting,
-  MeetingRecorderFeature,
-  MeetingRecord as MeetingRecordModel,
-  MeetingParticipantRecord,
-  MEETING_RECORDER_TELEMETRY_EVENTS,
-  MEETING_RECORDER_PII_FIELDS,
-  IntegrationSpecRegistry,
-  BankTransactionRecord,
-  BankAccountRecord,
-  AccountBalanceRecord
-};