@contractspec/lib.contracts-spec 2.0.0

package/dist/integrations/providers/registry.js

@@ -0,0 +1,1908 @@
+// @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/integrations/spec.ts
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
+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
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+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(registry) {
+  return registry.register(stripeIntegrationSpec);
+}
+
+// src/integrations/providers/postmark.ts
+import { StabilityEnum as StabilityEnum2 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum2.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(registry) {
+  return registry.register(postmarkIntegrationSpec);
+}
+
+// src/integrations/providers/qdrant.ts
+import { StabilityEnum as StabilityEnum3 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum3.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(registry) {
+  return registry.register(qdrantIntegrationSpec);
+}
+
+// src/integrations/providers/supabase-vector.ts
+import { StabilityEnum as StabilityEnum4 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum4.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(registry) {
+  return registry.register(supabaseVectorIntegrationSpec);
+}
+
+// src/integrations/providers/supabase-postgres.ts
+import { StabilityEnum as StabilityEnum5 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum5.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(registry) {
+  return registry.register(supabasePostgresIntegrationSpec);
+}
+
+// src/integrations/providers/mistral.ts
+import { StabilityEnum as StabilityEnum6 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum6.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(registry) {
+  return registry.register(mistralIntegrationSpec);
+}
+
+// src/integrations/providers/elevenlabs.ts
+import { StabilityEnum as StabilityEnum7 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum7.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(registry) {
+  return registry.register(elevenLabsIntegrationSpec);
+}
+
+// src/integrations/providers/gradium.ts
+import { StabilityEnum as StabilityEnum8 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum8.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(registry) {
+  return registry.register(gradiumIntegrationSpec);
+}
+
+// src/integrations/providers/fal.ts
+import { StabilityEnum as StabilityEnum9 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum9.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(registry) {
+  return registry.register(falIntegrationSpec);
+}
+
+// src/integrations/providers/gmail.ts
+import { StabilityEnum as StabilityEnum10 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum10.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(registry) {
+  return registry.register(gmailIntegrationSpec);
+}
+
+// src/integrations/providers/google-calendar.ts
+import { StabilityEnum as StabilityEnum11 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum11.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(registry) {
+  return registry.register(googleCalendarIntegrationSpec);
+}
+
+// src/integrations/providers/twilio-sms.ts
+import { StabilityEnum as StabilityEnum12 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum12.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(registry) {
+  return registry.register(twilioSmsIntegrationSpec);
+}
+
+// src/integrations/providers/gcs-storage.ts
+import { StabilityEnum as StabilityEnum13 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum13.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(registry) {
+  return registry.register(gcsStorageIntegrationSpec);
+}
+
+// src/integrations/providers/powens.ts
+import { StabilityEnum as StabilityEnum14 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum14.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(registry) {
+  return registry.register(powensIntegrationSpec);
+}
+
+// src/integrations/providers/posthog.ts
+import { StabilityEnum as StabilityEnum15 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum15.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(registry) {
+  return registry.register(posthogIntegrationSpec);
+}
+
+// src/integrations/providers/linear.ts
+import { StabilityEnum as StabilityEnum16 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum16.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(registry) {
+  return registry.register(linearIntegrationSpec);
+}
+
+// src/integrations/providers/jira.ts
+import { StabilityEnum as StabilityEnum17 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum17.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(registry) {
+  return registry.register(jiraIntegrationSpec);
+}
+
+// src/integrations/providers/notion.ts
+import { StabilityEnum as StabilityEnum18 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum18.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(registry) {
+  return registry.register(notionIntegrationSpec);
+}
+
+// src/integrations/providers/granola.ts
+import { StabilityEnum as StabilityEnum19 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum19.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(registry) {
+  return registry.register(granolaIntegrationSpec);
+}
+
+// src/integrations/providers/tldv.ts
+import { StabilityEnum as StabilityEnum20 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum20.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(registry) {
+  return registry.register(tldvIntegrationSpec);
+}
+
+// src/integrations/providers/fireflies.ts
+import { StabilityEnum as StabilityEnum21 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum21.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(registry) {
+  return registry.register(firefliesIntegrationSpec);
+}
+
+// src/integrations/providers/fathom.ts
+import { StabilityEnum as StabilityEnum22 } from "@contractspec/lib.contracts-spec/ownership";
+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: StabilityEnum22.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(registry) {
+  return registry.register(fathomIntegrationSpec);
+}
+
+// src/integrations/providers/registry.ts
+function createDefaultIntegrationSpecRegistry() {
+  const registry = new IntegrationSpecRegistry;
+  registerStripeIntegration(registry);
+  registerPostmarkIntegration(registry);
+  registerQdrantIntegration(registry);
+  registerSupabaseVectorIntegration(registry);
+  registerSupabasePostgresIntegration(registry);
+  registerMistralIntegration(registry);
+  registerElevenLabsIntegration(registry);
+  registerGradiumIntegration(registry);
+  registerFalIntegration(registry);
+  registerGmailIntegration(registry);
+  registerGoogleCalendarIntegration(registry);
+  registerPosthogIntegration(registry);
+  registerTwilioSmsIntegration(registry);
+  registerGcsStorageIntegration(registry);
+  registerPowensIntegration(registry);
+  registerLinearIntegration(registry);
+  registerJiraIntegration(registry);
+  registerNotionIntegration(registry);
+  registerGranolaIntegration(registry);
+  registerTldvIntegration(registry);
+  registerFirefliesIntegration(registry);
+  registerFathomIntegration(registry);
+  return registry;
+}
+export {
+  createDefaultIntegrationSpecRegistry
+};