@muxoai/sdk 1.2.3 → 1.4.2

package/dist/composio-catalog.js

@@ -0,0 +1,1894 @@
+/** SDK-free Composio enterprise toolkit and trigger catalogue shared by the Node server and the edge worker. */
+export const COMPOSIO_V3_WEBHOOK_EVENTS = [
+    "composio.trigger.message",
+    "composio.trigger.disabled",
+    "composio.connected_account.expired",
+    "composio.connected_account.activated",
+];
+export const ENTERPRISE_TOOLKITS_CATALOG = [
+    {
+        slug: "github",
+        name: "GitHub",
+        description: "Repositories, pull requests, issues, releases, Actions workflows, and code search.",
+        categories: ["developer", "git", "devops"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["repo:status", "public_repo", "read:org", "read:user"],
+        fullAccessScopes: ["repo", "workflow", "read:org", "admin:repo_hook"],
+        sampleActions: [
+            { upstreamSlug: "GITHUB_CREATE_AN_ISSUE", muxoSlug: "app.github.create_issue", name: "GitHub: Create Issue", riskLevel: "write" },
+            { upstreamSlug: "GITHUB_LIST_REPOSITORY_ISSUES", muxoSlug: "app.github.list_issues", name: "GitHub: List Issues", riskLevel: "read" },
+        ],
+    },
+    {
+        slug: "gmail",
+        name: "Gmail",
+        description: "Read threads, draft replies, search messages, and send transactional or support emails.",
+        categories: ["email", "communication", "google"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["https://www.googleapis.com/auth/gmail.readonly"],
+        fullAccessScopes: ["https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.send"],
+        sampleActions: [
+            { upstreamSlug: "GMAIL_FETCH_EMAILS", muxoSlug: "app.gmail.list_messages", name: "Gmail: List Messages", riskLevel: "read" },
+            { upstreamSlug: "GMAIL_SEND_EMAIL", muxoSlug: "app.gmail.send_email", name: "Gmail: Send Email", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "slack",
+        name: "Slack",
+        description: "Post channel notifications, read thread context, and coordinate incident response.",
+        categories: ["messaging", "chat", "incident"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["channels:history", "channels:read", "users:read"],
+        fullAccessScopes: ["channels:history", "channels:read", "chat:write", "reactions:write"],
+        sampleActions: [
+            { upstreamSlug: "SLACK_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL", muxoSlug: "app.slack.send_message", name: "Slack: Send Channel Message", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "notion",
+        name: "Notion",
+        description: "Search workspaces, create knowledge base pages, and query structured databases.",
+        categories: ["docs", "wiki", "productivity"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["read_content"],
+        fullAccessScopes: ["read_content", "update_content", "insert_content"],
+        sampleActions: [
+            { upstreamSlug: "NOTION_SEARCH_NOTION_PAGE", muxoSlug: "app.notion.search_pages", name: "Notion: Search Pages", riskLevel: "read" },
+            { upstreamSlug: "NOTION_CREATE_NOTION_PAGE", muxoSlug: "app.notion.create_page", name: "Notion: Create Page", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "linear",
+        name: "Linear",
+        description: "Create engineering issues, triage bugs, manage cycles, and track project roadmaps.",
+        categories: ["project_management", "engineering"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["read"],
+        fullAccessScopes: ["read", "write", "issues:create"],
+        sampleActions: [
+            { upstreamSlug: "LINEAR_CREATE_LINEAR_ISSUE", muxoSlug: "app.linear.create_issue", name: "Linear: Create Issue", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "googlecalendar",
+        name: "Google Calendar",
+        description: "List upcoming meetings, check availability, and schedule calendar events.",
+        categories: ["calendar", "scheduling", "google"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["https://www.googleapis.com/auth/calendar.readonly"],
+        fullAccessScopes: ["https://www.googleapis.com/auth/calendar.events"],
+        sampleActions: [
+            { upstreamSlug: "GOOGLECALENDAR_EVENTS_LIST", muxoSlug: "app.googlecalendar.list_events", name: "Google Calendar: List Events", riskLevel: "read" },
+            { upstreamSlug: "GOOGLECALENDAR_CREATE_EVENT", muxoSlug: "app.googlecalendar.create_event", name: "Google Calendar: Create Event", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "hubspot",
+        name: "HubSpot CRM",
+        description: "Manage CRM contacts, deals, company records, and sales pipeline stages.",
+        categories: ["crm", "sales", "marketing"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["crm.objects.contacts.read", "crm.objects.deals.read"],
+        fullAccessScopes: ["crm.objects.contacts.read", "crm.objects.contacts.write", "crm.objects.deals.write"],
+        sampleActions: [
+            { upstreamSlug: "HUBSPOT_SEARCH_CONTACTS", muxoSlug: "app.hubspot.search_contacts", name: "HubSpot: Search Contacts", riskLevel: "read" },
+            { upstreamSlug: "HUBSPOT_CREATE_CONTACT", muxoSlug: "app.hubspot.create_contact", name: "HubSpot: Create Contact", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "jira",
+        name: "Jira Software",
+        description: "Search JQL issues, create sprint tickets, transition workflows, and link incidents.",
+        categories: ["project_management", "engineering", "enterprise"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["read:jira-work", "read:jira-user"],
+        fullAccessScopes: ["read:jira-work", "write:jira-work"],
+        sampleActions: [
+            { upstreamSlug: "JIRA_SEARCH_ISSUES", muxoSlug: "app.jira.search_issues", name: "Jira: Search Issues (JQL)", riskLevel: "read" },
+            { upstreamSlug: "JIRA_CREATE_ISSUE", muxoSlug: "app.jira.create_issue", name: "Jira: Create Issue", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "salesforce",
+        name: "Salesforce",
+        description: "Query SOQL objects, manage leads, accounts, opportunities, and enterprise cases.",
+        categories: ["crm", "enterprise", "sales"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["api", "refresh_token"],
+        fullAccessScopes: ["api", "full", "refresh_token"],
+        sampleActions: [
+            { upstreamSlug: "SALESFORCE_RUN_SOQL_QUERY", muxoSlug: "app.salesforce.soql_query", name: "Salesforce: Run SOQL Query", riskLevel: "read" },
+            { upstreamSlug: "SALESFORCE_CREATE_LEAD", muxoSlug: "app.salesforce.create_lead", name: "Salesforce: Create Lead", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "zendesk",
+        name: "Zendesk Support",
+        description: "Triage customer support tickets, post internal notes, and update ticket priority.",
+        categories: ["support", "customer_success", "helpdesk"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["tickets:read", "users:read"],
+        fullAccessScopes: ["tickets:read", "tickets:write", "users:read"],
+        sampleActions: [
+            { upstreamSlug: "ZENDESK_LIST_TICKETS", muxoSlug: "app.zendesk.list_tickets", name: "Zendesk: List Tickets", riskLevel: "read" },
+            { upstreamSlug: "ZENDESK_REPLY_TICKET", muxoSlug: "app.zendesk.reply_ticket", name: "Zendesk: Reply to Ticket", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "shopify",
+        name: "Shopify",
+        description: "Inspect store orders, inventory levels, customer records, refunds, and provision hosted Shopify storefronts via Stripe Projects.",
+        categories: ["commerce", "orders", "retail", "stripe_projects", "infrastructure"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["read_orders", "read_products", "read_customers"],
+        fullAccessScopes: ["read_orders", "write_orders", "read_products", "write_products"],
+        sampleActions: [
+            { upstreamSlug: "SHOPIFY_GET_ORDERS", muxoSlug: "app.shopify.list_orders", name: "Shopify: List Orders", riskLevel: "read" },
+            { upstreamSlug: "SHOPIFY_CREATE_REFUND", muxoSlug: "app.shopify.create_refund", name: "Shopify: Create Refund", riskLevel: "financial" },
+            { upstreamSlug: "shopify/store", muxoSlug: "resource.shopify.store", name: "Shopify: Provision Hosted Online Storefront (deployable)", riskLevel: "provisioning" },
+        ],
+    },
+    {
+        slug: "pagerduty",
+        name: "PagerDuty",
+        description: "Acknowledge on-call incidents, list escalation policies, and trigger alert paging.",
+        categories: ["incident", "devops", "sre"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["incidents.read", "services.read"],
+        fullAccessScopes: ["incidents.read", "incidents.write", "services.read"],
+        sampleActions: [
+            { upstreamSlug: "PAGERDUTY_LIST_INCIDENTS", muxoSlug: "app.pagerduty.list_incidents", name: "PagerDuty: List Incidents", riskLevel: "read" },
+            { upstreamSlug: "PAGERDUTY_CREATE_INCIDENT", muxoSlug: "app.pagerduty.create_incident", name: "PagerDuty: Trigger Incident", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "discord",
+        name: "Discord",
+        description: "Send channel messages, manage server roles, and read guild threads.",
+        categories: ["communication", "chat", "messaging"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["identify", "guilds"],
+        fullAccessScopes: ["identify", "guilds", "bot", "messages.read"],
+        sampleActions: [
+            { upstreamSlug: "DISCORD_SEND_MESSAGE", muxoSlug: "app.discord.send_message", name: "Discord: Send Channel Message", riskLevel: "write" },
+        ],
+    },
+    {
+        slug: "googledrive",
+        name: "Google Drive",
+        description: "Search files and folders, manage permissions, and export workspace documents.",
+        categories: ["storage", "docs", "productivity", "google"],
+        authSchemes: ["OAUTH2"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["https://www.googleapis.com/auth/drive.readonly"],
+        fullAccessScopes: ["https://www.googleapis.com/auth/drive"],
+        sampleActions: [
+            { upstreamSlug: "GOOGLEDRIVE_FIND_FILE", muxoSlug: "app.googledrive.search_files", name: "Google Drive: Search Files & Folders", riskLevel: "read" },
+        ],
+    },
+    {
+        slug: "airtable",
+        name: "Airtable",
+        description: "List, create, and update structured records across Airtable bases and tables.",
+        categories: ["database", "productivity"],
+        authSchemes: ["OAUTH2", "API_KEY"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["data.records:read", "schema.bases:read"],
+        fullAccessScopes: ["data.records:read", "data.records:write", "schema.bases:read"],
+        sampleActions: [
+            { upstreamSlug: "AIRTABLE_LIST_RECORDS", muxoSlug: "app.airtable.list_records", name: "Airtable: List Base Records", riskLevel: "read" },
+        ],
+    },
+    {
+        slug: "sentry",
+        name: "Sentry",
+        description: "Inspect production issues, stack traces, release health, error events, and provision Sentry projects via Stripe Projects.",
+        categories: ["devops", "monitoring", "engineering", "stripe_projects", "infrastructure"],
+        authSchemes: ["API_KEY", "BEARER_TOKEN"],
+        pinnedVersion: "20260901_00",
+        readOnlyScopes: ["project:read", "event:read", "org:read"],
+        fullAccessScopes: ["project:read", "event:read", "event:write", "org:read"],
+        sampleActions: [
+            { upstreamSlug: "SENTRY_LIST_ISSUES", muxoSlug: "app.sentry.list_issues", name: "Sentry: List Project Issues", riskLevel: "read" },
+            { upstreamSlug: "sentry/project", muxoSlug: "resource.sentry.project", name: "Sentry: Provision Error Tracking & Performance Monitoring Project (deployable)", riskLevel: "provisioning" },
+        ],
+    },
+];
+const SAMPLE_ACTION_SCHEMAS = {
+    "app.github.list_issues": {
+        type: "object",
+        required: ["owner", "repo"],
+        properties: {
+            owner: { type: "string", description: "Repository owner" },
+            repo: { type: "string", description: "Repository name" },
+            state: { type: "string", enum: ["open", "closed", "all"], default: "open" },
+        },
+    },
+    "app.slack.send_message": {
+        type: "object",
+        required: ["channel", "text"],
+        properties: {
+            channel: { type: "string", description: "Slack channel ID or name" },
+            text: { type: "string", description: "Message text" },
+        },
+    },
+    "app.notion.create_page": {
+        type: "object",
+        required: ["parent_id", "title"],
+        properties: {
+            parent_id: { type: "string", description: "Parent page or database ID" },
+            title: { type: "string", description: "Page title" },
+            content: { type: "string", description: "Markdown content" },
+        },
+    },
+    "app.googlecalendar.list_events": {
+        type: "object",
+        properties: {
+            calendarId: { type: "string", default: "primary" },
+            maxResults: { type: "number", default: 10 },
+        },
+    },
+    "app.googlecalendar.create_event": {
+        type: "object",
+        required: ["summary", "start_datetime", "end_datetime"],
+        properties: {
+            calendarId: { type: "string", default: "primary" },
+            summary: { type: "string", description: "Event title" },
+            start_datetime: { type: "string", description: "ISO 8601 start timestamp" },
+            end_datetime: { type: "string", description: "ISO 8601 end timestamp" },
+        },
+    },
+    "app.hubspot.search_contacts": {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Contact name, email, or company search query" },
+            limit: { type: "number", default: 10 },
+        },
+    },
+    "app.hubspot.create_contact": {
+        type: "object",
+        required: ["email"],
+        properties: {
+            email: { type: "string", description: "Contact email address" },
+            firstname: { type: "string" },
+            lastname: { type: "string" },
+            company: { type: "string" },
+        },
+    },
+    "app.jira.search_issues": {
+        type: "object",
+        properties: {
+            jql: { type: "string", description: "JQL query string" },
+            max_results: { type: "number", default: 25 },
+        },
+    },
+    "app.jira.create_issue": {
+        type: "object",
+        required: ["project_key", "summary"],
+        properties: {
+            project_key: { type: "string", description: "Jira project key (e.g. ENG)" },
+            summary: { type: "string", description: "Issue summary" },
+            description: { type: "string", description: "Issue description" },
+            issue_type: { type: "string", default: "Task" },
+        },
+    },
+    "app.salesforce.soql_query": {
+        type: "object",
+        required: ["query"],
+        properties: {
+            query: { type: "string", description: "SOQL query string" },
+        },
+    },
+    "app.salesforce.create_lead": {
+        type: "object",
+        required: ["LastName", "Company"],
+        properties: {
+            FirstName: { type: "string" },
+            LastName: { type: "string" },
+            Company: { type: "string" },
+            Email: { type: "string" },
+        },
+    },
+    "app.zendesk.list_tickets": {
+        type: "object",
+        properties: {
+            status: { type: "string", default: "open" },
+            per_page: { type: "number", default: 25 },
+        },
+    },
+    "app.zendesk.reply_ticket": {
+        type: "object",
+        required: ["ticket_id", "body"],
+        properties: {
+            ticket_id: { type: "number", description: "Zendesk ticket ID" },
+            body: { type: "string", description: "Reply comment text" },
+            public: { type: "boolean", default: true },
+        },
+    },
+    "app.shopify.list_orders": {
+        type: "object",
+        properties: {
+            status: { type: "string", default: "any" },
+            limit: { type: "number", default: 25 },
+        },
+    },
+    "app.shopify.create_refund": {
+        type: "object",
+        required: ["order_id"],
+        properties: {
+            order_id: { type: "string", description: "Shopify order ID" },
+            reason: { type: "string", description: "Refund reason" },
+            amount_cents: { type: "number", description: "Optional refund amount in cents" },
+        },
+    },
+    "app.pagerduty.list_incidents": {
+        type: "object",
+        properties: {
+            statuses: { type: "array", items: { type: "string" } },
+            limit: { type: "number", default: 25 },
+        },
+    },
+    "app.pagerduty.create_incident": {
+        type: "object",
+        required: ["title", "service_id"],
+        properties: {
+            title: { type: "string", description: "Incident summary title" },
+            service_id: { type: "string", description: "PagerDuty service ID" },
+            urgency: { type: "string", enum: ["high", "low"], default: "high" },
+        },
+    },
+    "app.discord.send_message": {
+        type: "object",
+        required: ["channel_id", "content"],
+        properties: {
+            channel_id: { type: "string", description: "Discord channel ID" },
+            content: { type: "string", description: "Message content" },
+        },
+    },
+    "app.googledrive.search_files": {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "File or folder search query" },
+            pageSize: { type: "number", default: 10 },
+        },
+    },
+    "app.airtable.list_records": {
+        type: "object",
+        required: ["base_id", "table_name"],
+        properties: {
+            base_id: { type: "string", description: "Airtable Base ID" },
+            table_name: { type: "string", description: "Table name or ID" },
+            max_records: { type: "number", default: 20 },
+        },
+    },
+    "app.sentry.list_issues": {
+        type: "object",
+        properties: {
+            project_slug: { type: "string", description: "Sentry project slug" },
+            query: { type: "string", description: "Issue search query", default: "is:unresolved" },
+        },
+    },
+};
+export function getSampleActionSchema(muxoSlug, upstreamSlug) {
+    return (SAMPLE_ACTION_SCHEMAS[muxoSlug] ||
+        (upstreamSlug ? SAMPLE_ACTION_SCHEMAS[upstreamSlug] : undefined) || {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query or identifier" },
+            payload: { type: "object", description: "Structured action parameters" },
+        },
+    });
+}
+export const COMPOSIO_TRIGGER_CATALOGUE = [
+    {
+        slug: "GITHUB_COMMIT_EVENT",
+        providerSlug: "github",
+        name: "GitHub Commit Pushed",
+        description: "Fires when a commit is pushed to a monitored repository branch.",
+        config: {
+            type: "object",
+            required: ["owner", "repo"],
+            properties: {
+                owner: { type: "string", description: "Owner of the repository" },
+                repo: { type: "string", description: "Repository name" },
+            },
+        },
+    },
+    {
+        slug: "GITHUB_PULL_REQUEST_EVENT",
+        providerSlug: "github",
+        name: "GitHub Pull Request Event",
+        description: "Fires when a pull request is opened, synchronized, or merged.",
+        config: {
+            type: "object",
+            required: ["owner", "repo"],
+            properties: {
+                owner: { type: "string", description: "Owner of the repository" },
+                repo: { type: "string", description: "Repository name" },
+            },
+        },
+    },
+    {
+        slug: "SLACK_RECEIVE_MESSAGE",
+        providerSlug: "slack",
+        name: "Slack Channel Message Received",
+        description: "Fires when a new message is posted in a monitored Slack channel.",
+        config: {
+            type: "object",
+            properties: {
+                channel: { type: "string", description: "Slack channel ID to monitor" },
+            },
+        },
+    },
+    {
+        slug: "GMAIL_NEW_GMAIL_MESSAGE",
+        providerSlug: "gmail",
+        name: "Gmail New Inbound Email",
+        description: "Fires when a new email arrives in the connected Gmail inbox.",
+        config: {
+            type: "object",
+            properties: {
+                userId: { type: "string", default: "me", description: "Gmail userId (default: 'me')" },
+                labelIds: { type: "string", default: "INBOX", description: "Comma-separated Gmail label IDs" },
+            },
+        },
+    },
+    {
+        slug: "LINEAR_ISSUE_CREATED",
+        providerSlug: "linear",
+        name: "Linear Issue Created",
+        description: "Fires when a new issue is created in a Linear team.",
+        config: {
+            type: "object",
+            properties: {
+                team_id: { type: "string", description: "Linear team ID" },
+            },
+        },
+    },
+    {
+        slug: "HUBSPOT_CONTACT_CREATED",
+        providerSlug: "hubspot",
+        name: "HubSpot New CRM Contact",
+        description: "Fires when a new contact lead enters HubSpot CRM.",
+        config: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+export function listComposioTriggerTypes(providerSlug) {
+    if (!providerSlug)
+        return COMPOSIO_TRIGGER_CATALOGUE.map((t) => ({ ...t }));
+    const p = providerSlug.toLowerCase().trim();
+    return COMPOSIO_TRIGGER_CATALOGUE.filter((c) => c.providerSlug === p).map((t) => ({ ...t }));
+}
+export function getComposioTriggerType(slug) {
+    const normalized = String(slug || "").toUpperCase().trim();
+    if (!normalized)
+        return null;
+    const found = COMPOSIO_TRIGGER_CATALOGUE.find((t) => t.slug === normalized);
+    if (found)
+        return { ...found };
+    const providerSlug = normalized.split("_")[0]?.toLowerCase() || "github";
+    return {
+        slug: normalized,
+        providerSlug,
+        name: normalized,
+        description: `Composio trigger ${normalized} for ${providerSlug}.`,
+        config: {
+            type: "object",
+            properties: {},
+        },
+    };
+}
+function timingSafeStringEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return diff === 0;
+}
+/**
+ * Verifies a Composio V3 webhook HMAC-SHA256 signature (`v1,<base64>`) across Node and Cloudflare Workers.
+ * Signing input: `${webhookId}.${webhookTimestamp}.${rawPayload}`
+ */
+export async function verifyComposioWebhookSignature(params) {
+    const secret = String(params.secret || "").trim();
+    const signature = String(params.signatureHeader || "").trim();
+    const webhookId = String(params.webhookIdHeader || "").trim();
+    const webhookTimestamp = String(params.webhookTimestampHeader || "").trim();
+    if (!secret) {
+        return { verified: false, reason: "no_secret_configured" };
+    }
+    if (!signature || !webhookId || !webhookTimestamp) {
+        return { verified: false, reason: "missing_webhook_headers" };
+    }
+    const tolerance = params.toleranceSeconds ?? 300;
+    if (tolerance > 0) {
+        const tsSec = Number.parseInt(webhookTimestamp, 10);
+        if (!Number.isFinite(tsSec)) {
+            return { verified: false, reason: "invalid_webhook_timestamp" };
+        }
+        const ageSeconds = Math.abs(Date.now() - tsSec * 1000) / 1000;
+        if (ageSeconds > tolerance) {
+            return { verified: false, reason: "webhook_timestamp_expired" };
+        }
+    }
+    const v1Signatures = [];
+    for (const part of signature.split(" ")) {
+        const [ver, val] = part.split(",");
+        if (ver === "v1" && val) {
+            v1Signatures.push(val.trim());
+        }
+    }
+    if (v1Signatures.length === 0) {
+        return { verified: false, reason: "missing_v1_signature" };
+    }
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signingInput = `${webhookId}.${webhookTimestamp}.${params.rawPayload}`;
+    const macBuffer = await crypto.subtle.sign("HMAC", key, encoder.encode(signingInput));
+    const bytes = new Uint8Array(macBuffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i += 1) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    const expectedBase64 = btoa(binary);
+    for (const candidate of v1Signatures) {
+        if (timingSafeStringEqual(candidate, expectedBase64)) {
+            return { verified: true };
+        }
+    }
+    return { verified: false, reason: "signature_mismatch" };
+}
+/**
+ * Normalizes Composio V3 webhook events (`composio.trigger.message`, `composio.trigger.disabled`,
+ * `composio.connected_account.expired`, `composio.connected_account.activated`) as well as direct
+ * trigger webhook payloads into a single canonical envelope.
+ */
+export function parseComposioWebhookEnvelope(body, headers) {
+    const rawType = String(body.type || "").trim();
+    const isV3Event = rawType.startsWith("composio.");
+    const metadata = body.metadata && typeof body.metadata === "object"
+        ? body.metadata
+        : {};
+    const dataObj = body.data && typeof body.data === "object"
+        ? body.data
+        : body.payload && typeof body.payload === "object"
+            ? body.payload
+            : body;
+    const toolkitObj = dataObj.toolkit && typeof dataObj.toolkit === "object"
+        ? dataObj.toolkit
+        : {};
+    const triggerSlugRaw = String(metadata.trigger_slug ||
+        dataObj.trigger_slug ||
+        body.triggerSlug ||
+        body.trigger_slug ||
+        (isV3Event && rawType !== "composio.trigger.message" ? rawType.toUpperCase().replace(/\./g, "_") : "") ||
+        body.type ||
+        "GITHUB_COMMIT_EVENT")
+        .toUpperCase()
+        .trim();
+    const providerSlugRaw = String(toolkitObj.slug ||
+        metadata.toolkit_slug ||
+        dataObj.toolkit_slug ||
+        body.providerSlug ||
+        body.provider ||
+        (triggerSlugRaw.startsWith("COMPOSIO_") ? "composio" : triggerSlugRaw.split("_")[0]) ||
+        "github")
+        .toLowerCase()
+        .trim();
+    const triggerId = typeof metadata.trigger_id === "string"
+        ? metadata.trigger_id
+        : typeof dataObj.trigger_id === "string"
+            ? dataObj.trigger_id
+            : typeof body.triggerId === "string"
+                ? body.triggerId
+                : undefined;
+    const connectedAccountId = typeof metadata.connected_account_id === "string"
+        ? metadata.connected_account_id
+        : typeof dataObj.connected_account_id === "string"
+            ? dataObj.connected_account_id
+            : rawType.startsWith("composio.connected_account.") && typeof dataObj.id === "string"
+                ? dataObj.id
+                : typeof body.connectedAccountId === "string"
+                    ? body.connectedAccountId
+                    : undefined;
+    const userId = typeof metadata.user_id === "string" && metadata.user_id
+        ? metadata.user_id
+        : typeof dataObj.user_id === "string" && dataObj.user_id
+            ? dataObj.user_id
+            : typeof body.user_id === "string" && body.user_id
+                ? body.user_id
+                : typeof body.workspaceId === "string" && body.workspaceId
+                    ? body.workspaceId
+                    : undefined;
+    const projectId = typeof metadata.project_id === "string" ? metadata.project_id : undefined;
+    const orgId = typeof metadata.org_id === "string" ? metadata.org_id : undefined;
+    let connectionStatus;
+    if (rawType === "composio.connected_account.activated") {
+        connectionStatus = "active";
+    }
+    else if (rawType === "composio.connected_account.expired") {
+        connectionStatus = "expired";
+    }
+    else if (rawType === "composio.trigger.disabled") {
+        connectionStatus = "disabled";
+    }
+    const headerVer = String(headers?.webhookVersion || "").toUpperCase();
+    const webhookVersion = isV3Event || headerVer === "V3"
+        ? "V3"
+        : headerVer === "V2"
+            ? "V2"
+            : headerVer === "V1"
+                ? "V1"
+                : "direct";
+    return {
+        eventType: isV3Event ? rawType : "composio.trigger.message",
+        webhookVersion,
+        webhookId: (typeof headers?.webhookId === "string" && headers.webhookId) ||
+            (typeof body.id === "string" ? body.id : undefined),
+        timestamp: (typeof headers?.webhookTimestamp === "string" && headers.webhookTimestamp) ||
+            (typeof body.timestamp === "string" ? body.timestamp : undefined),
+        triggerId,
+        triggerSlug: triggerSlugRaw,
+        providerSlug: providerSlugRaw,
+        connectedAccountId,
+        connectionStatus,
+        userId,
+        projectId,
+        orgId,
+        payloadObj: dataObj,
+    };
+}
+export function filterComposioToolkits(params) {
+    const q = (params?.search || "").trim().toLowerCase();
+    const cat = (params?.category || "").trim().toLowerCase();
+    let list = [...ENTERPRISE_TOOLKITS_CATALOG, ...STRIPE_PROJECTS_TOOLKITS_CATALOG];
+    if (q) {
+        list = list.filter((t) => t.slug.includes(q) ||
+            t.name.toLowerCase().includes(q) ||
+            t.description.toLowerCase().includes(q) ||
+            t.categories.some((c) => c.toLowerCase().includes(q)) ||
+            t.sampleActions.some((a) => a.muxoSlug.toLowerCase().includes(q) ||
+                a.upstreamSlug.toLowerCase().includes(q) ||
+                a.name.toLowerCase().includes(q)));
+    }
+    if (cat) {
+        list = list.filter((t) => t.categories.some((c) => c.toLowerCase() === cat));
+    }
+    return list;
+}
+/** Least-privilege scopes for a custom auth config: explicit scopes win, then the toolkit's read-only or full set. */
+export function composioAuthConfigScopes(toolkitSlug, scopeMode, customScopes) {
+    if (customScopes && customScopes.length > 0)
+        return customScopes;
+    const meta = ENTERPRISE_TOOLKITS_CATALOG.find((t) => t.slug === toolkitSlug) ||
+        STRIPE_PROJECTS_TOOLKITS_CATALOG.find((t) => t.slug === toolkitSlug);
+    return scopeMode === "read_only"
+        ? meta?.readOnlyScopes || ["read"]
+        : meta?.fullAccessScopes || ["read", "write"];
+}
+export function ensureOAuthCallbackParams(callbackUrl, workspaceId, providerSlug) {
+    try {
+        const parsed = new URL(callbackUrl);
+        if (workspaceId && !parsed.searchParams.get("workspace_id") && !parsed.searchParams.get("user_id")) {
+            parsed.searchParams.set("workspace_id", workspaceId);
+        }
+        if (providerSlug && !parsed.searchParams.get("provider") && !parsed.searchParams.get("toolkit")) {
+            parsed.searchParams.set("provider", providerSlug);
+        }
+        return parsed.toString();
+    }
+    catch {
+        return callbackUrl;
+    }
+}
+/**
+ * Normalizes upstream Composio hosted link URLs (`connect.composio.dev/link/lk_...`,
+ * `dashboard.composio.dev/link/lk_...`, `backend.composio.dev/api/v3/s/...`, or
+ * legacy `/oauth/connect/lk_...`) directly to Composio's native hosted OAuth URL
+ * (`https://connect.composio.dev/link/<token>`), avoiding intermediate custom pages.
+ */
+export function wrapMuxoConnectUrl(rawUrl, _baseUrl, _params) {
+    if (!rawUrl)
+        return null;
+    const trimmed = String(rawUrl).trim();
+    if (!trimmed)
+        return null;
+    // Unwrap any legacy /oauth/connect/<token> or /connect/<token> URLs back to native Composio link
+    const wrappedMatch = trimmed.match(/\/(?:oauth\/)?connect\/(lk_[A-Za-z0-9_-]+|s_[A-Za-z0-9_-]+)/);
+    if (wrappedMatch) {
+        const token = wrappedMatch[1];
+        if (token.startsWith("s_")) {
+            return `https://backend.composio.dev/api/v3/s/${encodeURIComponent(token.slice(2))}`;
+        }
+        return `https://connect.composio.dev/link/${encodeURIComponent(token)}`;
+    }
+    const linkMatch = trimmed.match(/\/link\/(lk_[A-Za-z0-9_-]+)/);
+    if (linkMatch) {
+        return `https://connect.composio.dev/link/${encodeURIComponent(linkMatch[1])}`;
+    }
+    const shortMatch = trimmed.match(/\/api\/v3\/s\/([A-Za-z0-9_-]+)/);
+    if (shortMatch) {
+        return `https://backend.composio.dev/api/v3/s/${encodeURIComponent(shortMatch[1])}`;
+    }
+    return trimmed;
+}
+function formatToolkitDisplayName(slug) {
+    const clean = (slug || "app").toLowerCase().replace(/^app\./, "");
+    const known = ENTERPRISE_TOOLKITS_CATALOG.find((t) => t.slug === clean) ||
+        STRIPE_PROJECTS_TOOLKITS_CATALOG.find((t) => t.slug === clean);
+    if (known)
+        return known.name;
+    return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+export async function fetchMuxoConnectLinkMetadata(token, fallback) {
+    const cleanToken = String(token || "").trim();
+    const fallbackSlug = (fallback?.providerSlug || "github").toLowerCase().replace(/^app\./, "");
+    const defaultMeta = {
+        token: cleanToken,
+        toolkitSlug: fallbackSlug,
+        toolkitName: formatToolkitDisplayName(fallbackSlug),
+        connectedAccountId: fallback?.connectedAccountId || null,
+        authMode: "OAUTH2",
+        status: "INITIALIZING",
+        callbackUrl: fallback?.callbackUrl || null,
+        expectedInputFields: [],
+    };
+    if (!cleanToken || cleanToken.startsWith("s_") || cleanToken.startsWith("lk_test")) {
+        return defaultMeta;
+    }
+    try {
+        const res = await fetch(`https://backend.composio.dev/api/v3.1/internal/connected_accounts/link/${encodeURIComponent(cleanToken)}`, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok)
+            return defaultMeta;
+        const data = (await res.json());
+        const tkSlug = String(data.toolkit?.slug || fallbackSlug).toLowerCase();
+        const tkName = String(data.toolkit?.name || formatToolkitDisplayName(tkSlug));
+        const rawFields = Array.isArray(data.connected_account?.expected_input_fields)
+            ? data.connected_account.expected_input_fields
+            : [];
+        const expectedInputFields = rawFields
+            .filter((f) => f && typeof f === "object" && typeof f.name === "string")
+            .map((f) => ({
+            name: String(f.name),
+            type: typeof f.type === "string" ? f.type : "text",
+            label: typeof f.displayName === "string"
+                ? f.displayName
+                : typeof f.label === "string"
+                    ? f.label
+                    : String(f.name),
+            description: typeof f.description === "string" ? f.description : undefined,
+            required: f.required !== false,
+            default: typeof f.default === "string" ? f.default : null,
+        }));
+        return {
+            token: cleanToken,
+            toolkitSlug: tkSlug,
+            toolkitName: tkName,
+            connectedAccountId: data.connected_account?.id || defaultMeta.connectedAccountId,
+            authMode: String(data.connected_account?.mode || "OAUTH2"),
+            status: String(data.connected_account?.status || "INITIALIZING"),
+            callbackUrl: data.connected_account?.callback_url || defaultMeta.callbackUrl,
+            expectedInputFields,
+        };
+    }
+    catch {
+        return defaultMeta;
+    }
+}
+async function resolveShortRedirectUrl(url) {
+    if (!url.includes("/api/v3/s/"))
+        return url;
+    try {
+        const res = await fetch(url, {
+            method: "GET",
+            redirect: "manual",
+            signal: AbortSignal.timeout(5000),
+        });
+        const loc = res.headers.get("location");
+        return loc || url;
+    }
+    catch {
+        return url;
+    }
+}
+export async function submitMuxoConnectLink(token, input = {}, fallback) {
+    const cleanToken = String(token || "").trim();
+    if (!cleanToken) {
+        return {
+            ok: false,
+            status: "FAILED",
+            redirectUrl: null,
+            connectedAccountId: null,
+            error: "Missing connection token.",
+        };
+    }
+    if (cleanToken.startsWith("s_")) {
+        const shortCode = cleanToken.slice(2);
+        const shortUrl = `https://backend.composio.dev/api/v3/s/${encodeURIComponent(shortCode)}`;
+        const resolved = await resolveShortRedirectUrl(shortUrl);
+        return {
+            ok: true,
+            status: "INITIATED",
+            redirectUrl: resolved,
+            connectedAccountId: fallback?.connectedAccountId || null,
+        };
+    }
+    if (cleanToken.startsWith("lk_test")) {
+        const cb = fallback?.callbackUrl ||
+            `https://api.muxo.ai/oauth/callback?workspace_id=${encodeURIComponent(fallback?.workspaceId || "ws_default")}&provider=${encodeURIComponent(fallback?.providerSlug || "github")}&status=success`;
+        return {
+            ok: true,
+            status: "ACTIVE",
+            redirectUrl: cb,
+            connectedAccountId: fallback?.connectedAccountId || `ca_${cleanToken}`,
+        };
+    }
+    try {
+        const res = await fetch(`https://backend.composio.dev/api/v3.1/internal/connected_accounts/link/${encodeURIComponent(cleanToken)}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            body: JSON.stringify({ input: input || {} }),
+            signal: AbortSignal.timeout(8000),
+        });
+        const data = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            if (cleanToken.startsWith("lk_")) {
+                return {
+                    ok: true,
+                    status: "INITIATED",
+                    redirectUrl: `https://connect.composio.dev/link/${encodeURIComponent(cleanToken)}`,
+                    connectedAccountId: fallback?.connectedAccountId || null,
+                };
+            }
+            const errMsg = typeof data.error === "object" && data.error?.message
+                ? data.error.message
+                : typeof data.error === "string"
+                    ? data.error
+                    : data.message || `Authorization handoff failed (HTTP ${res.status})`;
+            return {
+                ok: false,
+                status: "FAILED",
+                redirectUrl: null,
+                connectedAccountId: fallback?.connectedAccountId || null,
+                error: errMsg,
+            };
+        }
+        if (data.redirect_url) {
+            const directUrl = await resolveShortRedirectUrl(data.redirect_url);
+            return {
+                ok: true,
+                status: data.status || "INITIATED",
+                redirectUrl: directUrl,
+                connectedAccountId: data.connected_account_id || fallback?.connectedAccountId || null,
+            };
+        }
+        const finalUrl = data.final_redirect_url ||
+            data.callback_url ||
+            fallback?.callbackUrl ||
+            "/";
+        return {
+            ok: true,
+            status: data.status || "ACTIVE",
+            redirectUrl: finalUrl,
+            connectedAccountId: data.connected_account_id || fallback?.connectedAccountId || null,
+        };
+    }
+    catch (err) {
+        if (cleanToken.startsWith("lk_")) {
+            return {
+                ok: true,
+                status: "INITIATED",
+                redirectUrl: `https://connect.composio.dev/link/${encodeURIComponent(cleanToken)}`,
+                connectedAccountId: fallback?.connectedAccountId || null,
+            };
+        }
+        return {
+            ok: false,
+            status: "FAILED",
+            redirectUrl: null,
+            connectedAccountId: fallback?.connectedAccountId || null,
+            error: err?.message || "Unable to reach upstream authorization service.",
+        };
+    }
+}
+const STRIPE_PROJECTS_PROVIDER_ALIASES = {
+    "customer.io": "customerio",
+    customer_io: "customerio",
+    "wordpress.com": "wordpress",
+    wordpresscom: "wordpress",
+    wordpress_com: "wordpress",
+    base44: "base44_projects",
+    "base-44": "base44_projects",
+    base_44: "base44_projects",
+    laravel: "laravel_cloud",
+    laravelcloud: "laravel_cloud",
+    "laravel-cloud": "laravel_cloud",
+    fly: "flyio",
+    "fly.io": "flyio",
+    "fly-io": "flyio",
+    "here.now": "herenow",
+    "here-now": "herenow",
+    here_now: "herenow",
+    planet_scale: "planetscale",
+    eleven_labs: "elevenlabs",
+    open_router: "openrouter",
+    browser_base: "browserbase",
+    super_memory: "supermemory",
+    agent_mail: "agentmail",
+    agent_phone: "agentphone",
+    revenue_cat: "revenuecat",
+};
+/**
+ * Canonical Stripe Projects Cloud Infrastructure providers (`stripe_projects` lane).
+ * These providers are provisioned and deployed directly through Stripe Projects
+ * (and/or Muxo instant cloud provisioning) without Composio OAuth handoffs.
+ */
+export const STRIPE_PROJECTS_PROVIDER_SLUGS = new Set([
+    // Hosting, Edge, Sites & App Platforms (14)
+    "vercel",
+    "cloudflare",
+    "netlify",
+    "render",
+    "railway",
+    "flyio",
+    "herenow",
+    "createos",
+    "laravel_cloud",
+    "base44_projects",
+    "wordpress",
+    "squarespace",
+    "wix",
+    "gitlab",
+    // Databases, Vector DBs, Cache & Storage (9)
+    "turso",
+    "neon",
+    "supabase",
+    "upstash",
+    "prisma",
+    "planetscale",
+    "clickhouse",
+    "chroma",
+    "mongodb",
+    // Auth, Identity & Wallets (4)
+    "clerk",
+    "workos",
+    "auth0",
+    "privy",
+    // Compute, Devboxes & Sandboxes (6)
+    "e2b",
+    "daytona",
+    "blaxel",
+    "modal",
+    "runloop",
+    "depot",
+    // Browser & Web Automation (3)
+    "browserbase",
+    "steel",
+    "kernel",
+    // AI, Search, Scrape, Memory, Voice & Video Infrastructure (12)
+    "exa",
+    "firecrawl",
+    "perplexity",
+    "openrouter",
+    "supermemory",
+    "elevenlabs",
+    "tabstack",
+    "algolia",
+    "parallel",
+    "heygen",
+    "athena",
+    "chatbase",
+    // Email, Messaging, Notifications & Physical Mail (8)
+    "resend",
+    "agentmail",
+    "agentphone",
+    "twilio",
+    "customerio",
+    "knock",
+    "postalform",
+    "quo",
+    // Analytics, Observability, Workflows, Media & Domains (8)
+    "posthog",
+    "datadog",
+    "inngest",
+    "cloudinary",
+    "spaceship",
+    "amplitude",
+    "mixpanel",
+    "pydantic",
+    // Feature Flags, Entitlements, Metering, Retention & Subscriptions (5)
+    "schematic",
+    "stigg",
+    "metronome",
+    "churnkey",
+    "revenuecat",
+]);
+export const STRIPE_PROJECTS_HOSTING_PROVIDERS = new Set([
+    "vercel",
+    "herenow",
+    "netlify",
+    "render",
+    "cloudflare",
+    "railway",
+    "flyio",
+    "createos",
+    "laravel_cloud",
+    "base44_projects",
+    "wordpress",
+    "squarespace",
+    "wix",
+]);
+export const STRIPE_PROJECTS_DATABASE_PROVIDERS = new Set([
+    "turso",
+    "neon",
+    "supabase",
+    "upstash",
+    "prisma",
+    "planetscale",
+    "clickhouse",
+    "chroma",
+    "mongodb",
+]);
+export const STRIPE_PROJECTS_MESSAGING_PROVIDERS = new Set([
+    "resend",
+    "agentmail",
+    "agentphone",
+    "twilio",
+    "customerio",
+    "knock",
+    "postalform",
+    "quo",
+]);
+export const STRIPE_PROJECTS_AI_SEARCH_PROVIDERS = new Set([
+    "exa",
+    "firecrawl",
+    "perplexity",
+    "openrouter",
+    "supermemory",
+    "elevenlabs",
+    "tabstack",
+    "algolia",
+    "parallel",
+    "heygen",
+    "athena",
+    "chatbase",
+]);
+export const STRIPE_PROJECTS_SANDBOX_BROWSER_PROVIDERS = new Set([
+    "e2b",
+    "daytona",
+    "blaxel",
+    "modal",
+    "runloop",
+    "depot",
+    "browserbase",
+    "steel",
+    "kernel",
+]);
+export const STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG = {
+    // Hosting & Edge
+    vercel: "resource.vercel.project",
+    cloudflare: "resource.cloudflare.worker",
+    netlify: "resource.netlify.project",
+    render: "resource.render.static_site",
+    railway: "resource.railway.hosting",
+    flyio: "resource.flyio.app",
+    herenow: "resource.herenow.hosting",
+    createos: "resource.createos.project",
+    laravel_cloud: "resource.laravel_cloud.application",
+    base44_projects: "resource.base44_projects.app",
+    wordpress: "resource.wordpress.site",
+    squarespace: "resource.squarespace.domain",
+    wix: "resource.wix.headless",
+    gitlab: "resource.gitlab.project",
+    // Databases & Storage
+    turso: "resource.turso.database",
+    neon: "resource.neon.postgres",
+    supabase: "resource.supabase.project",
+    upstash: "resource.upstash.redis",
+    prisma: "resource.prisma.database",
+    planetscale: "resource.planetscale.postgresql",
+    clickhouse: "resource.clickhouse.clickhouse",
+    chroma: "resource.chroma.database",
+    mongodb: "resource.mongodb.atlas",
+    // Auth & Wallets
+    clerk: "resource.clerk.auth",
+    workos: "resource.workos.auth",
+    auth0: "resource.auth0.client",
+    privy: "resource.privy.app",
+    // Sandboxes & Compute
+    e2b: "resource.e2b.sandboxes",
+    daytona: "resource.daytona.sandbox",
+    blaxel: "resource.blaxel.sandbox",
+    modal: "resource.modal.serverless_gpu",
+    runloop: "resource.runloop.sandbox",
+    depot: "resource.depot.api",
+    // Cloud Browsers
+    browserbase: "resource.browserbase.project",
+    steel: "resource.steel.browser",
+    kernel: "resource.kernel.project",
+    // AI, Search, Scrape, Memory, Voice & Video
+    exa: "resource.exa.search",
+    firecrawl: "resource.firecrawl.api",
+    perplexity: "resource.perplexity.api",
+    openrouter: "resource.openrouter.api",
+    supermemory: "resource.supermemory.memory",
+    elevenlabs: "resource.elevenlabs.tts",
+    tabstack: "resource.tabstack.api",
+    algolia: "resource.algolia.application",
+    parallel: "resource.parallel.api",
+    heygen: "resource.heygen.api",
+    athena: "resource.athena.agents",
+    chatbase: "resource.chatbase.agent",
+    // Email, Messaging, Notifications & Mail
+    resend: "resource.resend.email",
+    agentmail: "resource.agentmail.api",
+    agentphone: "resource.agentphone.number",
+    twilio: "resource.twilio.email",
+    customerio: "resource.customerio.workspace",
+    knock: "resource.knock.project",
+    postalform: "resource.postalform.mail",
+    quo: "resource.quo.app",
+    // Analytics, Observability, Workflows, Media & Domains
+    posthog: "resource.posthog.analytics",
+    datadog: "resource.datadog.observability",
+    inngest: "resource.inngest.app",
+    cloudinary: "resource.cloudinary.media",
+    spaceship: "resource.spaceship.domain",
+    amplitude: "resource.amplitude.analytics",
+    mixpanel: "resource.mixpanel.analytics",
+    pydantic: "resource.pydantic.logfire",
+    // Feature Flags, Entitlements, Metering & Retention
+    schematic: "resource.schematic.schematic_environment",
+    stigg: "resource.stigg.environment",
+    metronome: "resource.metronome.sandbox",
+    churnkey: "resource.churnkey.retention",
+    revenuecat: "resource.revenuecat.app",
+};
+/**
+ * Multi-service deployable slugs supported per Stripe Projects provider.
+ */
+export const STRIPE_PROJECTS_MULTI_SERVICE_MAP = {
+    cloudflare: {
+        worker: "resource.cloudflare.worker",
+        workers: "resource.cloudflare.worker",
+        d1: "resource.cloudflare.d1",
+        kv: "resource.cloudflare.kv",
+        r2: "resource.cloudflare.r2",
+        bucket: "resource.cloudflare.r2",
+        storage: "resource.cloudflare.r2",
+        queues: "resource.cloudflare.queues",
+        queue: "resource.cloudflare.queues",
+        hyperdrive: "resource.cloudflare.hyperdrive",
+        browser_run: "resource.cloudflare.browser_run",
+        "browser-run": "resource.cloudflare.browser_run",
+        workers_ai: "resource.cloudflare.workers_ai",
+        "workers-ai": "resource.cloudflare.workers_ai",
+        pages: "resource.cloudflare.pages",
+    },
+    railway: {
+        hosting: "resource.railway.hosting",
+        postgres: "resource.railway.postgres",
+        postgresql: "resource.railway.postgres",
+        redis: "resource.railway.redis",
+        mongo: "resource.railway.mongo",
+        mongodb: "resource.railway.mongo",
+        bucket: "resource.railway.bucket",
+        storage: "resource.railway.bucket",
+    },
+    render: {
+        static_site: "resource.render.static_site",
+        "static-site": "resource.render.static_site",
+        web_service: "resource.render.web_service",
+        "web-service": "resource.render.web_service",
+        postgres: "resource.render.postgres",
+        postgresql: "resource.render.postgres",
+    },
+    upstash: {
+        redis: "resource.upstash.redis",
+        vector: "resource.upstash.vector",
+        qstash: "resource.upstash.qstash",
+        search: "resource.upstash.search",
+    },
+    planetscale: {
+        postgresql: "resource.planetscale.postgresql",
+        postgres: "resource.planetscale.postgresql",
+        mysql: "resource.planetscale.mysql",
+        vitess: "resource.planetscale.mysql",
+    },
+    clickhouse: {
+        clickhouse: "resource.clickhouse.clickhouse",
+        analytics: "resource.clickhouse.clickhouse",
+        postgres: "resource.clickhouse.postgres",
+    },
+    flyio: {
+        app: "resource.flyio.app",
+        mpg: "resource.flyio.mpg",
+        postgres: "resource.flyio.mpg",
+    },
+    blaxel: {
+        sandbox: "resource.blaxel.sandbox",
+        agent_drive: "resource.blaxel.agent_drive",
+        "agent-drive": "resource.blaxel.agent_drive",
+    },
+    stripe: {
+        sandbox: "resource.stripe.sandbox",
+        livemode: "resource.stripe.livemode",
+    },
+};
+export const STRIPE_PROJECTS_DEPLOYABLE_CATALOG = [
+    // Hosting & Edge
+    { slug: "resource.vercel.project", upstreamSlug: "vercel/project", providerSlug: "vercel", providerName: "Vercel", serviceId: "project", name: "Vercel: Provision & Deploy Frontend / Static Site Project (deployable)", description: "Provision a Vercel project and optionally deploy static HTML, landing pages, or web files directly to a live URL via Stripe Projects Cloud Infrastructure (zero OAuth handoff required).", categories: ["compute", "hosting", "cdn", "deployment", "frontend", "static_site", "publish", "website", "infrastructure"], defaultPlan: "hobby", availablePlans: ["hobby", "pro"], providerUrl: "https://vercel.com", llmContextUrl: "https://vercel.com/llms.txt" },
+    { slug: "resource.cloudflare.worker", upstreamSlug: "cloudflare/workers", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "workers", name: "Cloudflare: Provision & Deploy Edge Worker / Static Site (deployable)", description: "Provision a Cloudflare Worker and optionally deploy static HTML or edge scripts via Stripe Projects (zero OAuth handoff).", categories: ["compute", "hosting", "edge", "cdn", "deployment", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/llms.txt" },
+    { slug: "resource.cloudflare.d1", upstreamSlug: "cloudflare/d1", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "d1", name: "Cloudflare: Provision D1 Serverless SQL Database (deployable)", description: "Provision a Cloudflare D1 serverless SQLite database and optionally apply SQL migrations via Stripe Projects.", categories: ["database", "sql", "sqlite", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/d1/llms.txt" },
+    { slug: "resource.cloudflare.kv", upstreamSlug: "cloudflare/kv", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "kv", name: "Cloudflare: Provision Workers KV Key-Value Store (deployable)", description: "Provision a globally distributed Cloudflare Workers KV namespace via Stripe Projects.", categories: ["database", "kv", "cache", "storage", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/kv/llms.txt" },
+    { slug: "resource.cloudflare.r2", upstreamSlug: "cloudflare/r2", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "r2", name: "Cloudflare: Provision R2 Zero-Egress Object Storage Bucket (deployable)", description: "Provision an S3-compatible Cloudflare R2 object storage bucket via Stripe Projects.", categories: ["storage", "object_storage", "cdn", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/r2/llms.txt" },
+    { slug: "resource.cloudflare.queues", upstreamSlug: "cloudflare/queues", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "queues", name: "Cloudflare: Provision Message Queue (deployable)", description: "Provision a Cloudflare Queue for guaranteed message delivery and background workers via Stripe Projects.", categories: ["queues", "messaging", "compute", "edge", "infrastructure"], defaultPlan: "paid", availablePlans: ["workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/queues/llms.txt" },
+    { slug: "resource.cloudflare.hyperdrive", upstreamSlug: "cloudflare/hyperdrive", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "hyperdrive", name: "Cloudflare: Provision Hyperdrive Database Accelerator (deployable)", description: "Provision Cloudflare Hyperdrive connection pooling and query caching for Postgres/MySQL via Stripe Projects.", categories: ["database", "networking", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/hyperdrive/llms.txt" },
+    { slug: "resource.cloudflare.browser_run", upstreamSlug: "cloudflare/browser-run", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "browser-run", name: "Cloudflare: Provision Browser Rendering API (deployable)", description: "Provision headless Cloudflare Browser Rendering for Playwright/Puppeteer automation at the edge via Stripe Projects.", categories: ["browser", "automation", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/browser-rendering/llms.txt" },
+    { slug: "resource.cloudflare.workers_ai", upstreamSlug: "cloudflare/workers-ai", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "workers-ai", name: "Cloudflare: Provision Workers AI Serverless GPU Inference (deployable)", description: "Provision serverless GPU inference on Cloudflare Workers AI via Stripe Projects.", categories: ["ai", "inference", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/workers-ai/llms.txt" },
+    { slug: "resource.cloudflare.pages", upstreamSlug: "cloudflare/pages", providerSlug: "cloudflare", providerName: "Cloudflare", serviceId: "pages", name: "Cloudflare: Provision & Deploy Cloudflare Pages Site (deployable)", description: "Provision and deploy a static or full-stack Cloudflare Pages project via Stripe Projects.", categories: ["hosting", "deployment", "frontend", "static_site", "cdn", "infrastructure"], defaultPlan: "free", availablePlans: ["workers:free", "workers:paid"], providerUrl: "https://cloudflare.com", llmContextUrl: "https://developers.cloudflare.com/pages/llms.txt" },
+    { slug: "resource.netlify.project", upstreamSlug: "netlify/project", providerSlug: "netlify", providerName: "Netlify", serviceId: "project", name: "Netlify: Provision & Deploy Web Project / Static Site (deployable)", description: "Provision a Netlify site and optionally deploy static HTML/files directly to a live URL via Stripe Projects.", categories: ["compute", "hosting", "deployment", "frontend", "static_site", "publish", "website", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://netlify.com", llmContextUrl: "https://docs.netlify.com/llms.txt" },
+    { slug: "resource.render.static_site", upstreamSlug: "render/static-site", providerSlug: "render", providerName: "Render", serviceId: "static-site", name: "Render: Provision & Deploy Static Site (deployable)", description: "Provision a Render static site and optionally publish HTML/files directly via Stripe Projects.", categories: ["compute", "hosting", "deployment", "frontend", "static_site", "publish", "website", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "professional"], providerUrl: "https://render.com", llmContextUrl: "https://render.com/docs/llms.txt" },
+    { slug: "resource.render.web_service", upstreamSlug: "render/web-service", providerSlug: "render", providerName: "Render", serviceId: "web-service", name: "Render: Provision Managed Web Service (deployable)", description: "Provision a managed Render web service for Node, Python, Go, or Docker apps via Stripe Projects.", categories: ["compute", "hosting", "deployment", "containers", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "professional"], providerUrl: "https://render.com", llmContextUrl: "https://render.com/docs/llms.txt" },
+    { slug: "resource.render.postgres", upstreamSlug: "render/postgres", providerSlug: "render", providerName: "Render", serviceId: "postgres", name: "Render: Provision Managed PostgreSQL Database (deployable)", description: "Provision a managed Render PostgreSQL database and apply SQL migrations via Stripe Projects.", categories: ["database", "postgresql", "sql", "migration", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "professional"], providerUrl: "https://render.com", llmContextUrl: "https://render.com/docs/llms.txt" },
+    { slug: "resource.railway.hosting", upstreamSlug: "railway/hosting", providerSlug: "railway", providerName: "Railway", serviceId: "hosting", name: "Railway: Provision & Deploy Full-Stack Hosting Service (deployable)", description: "Provision Railway full-stack application hosting and optionally deploy HTML/files via Stripe Projects.", categories: ["compute", "hosting", "deployment", "containers", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://railway.com", llmContextUrl: "https://docs.railway.com/llms.txt" },
+    { slug: "resource.railway.postgres", upstreamSlug: "railway/postgres", providerSlug: "railway", providerName: "Railway", serviceId: "postgres", name: "Railway: Provision Managed Postgres Database (deployable)", description: "Provision a Railway PostgreSQL database and optionally run SQL migrations via Stripe Projects.", categories: ["database", "postgresql", "sql", "migration", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://railway.com", llmContextUrl: "https://docs.railway.com/llms.txt" },
+    { slug: "resource.railway.redis", upstreamSlug: "railway/redis", providerSlug: "railway", providerName: "Railway", serviceId: "redis", name: "Railway: Provision Managed Redis Cache (deployable)", description: "Provision a Railway Redis instance for caching, sessions, and queues via Stripe Projects.", categories: ["database", "redis", "cache", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://railway.com", llmContextUrl: "https://docs.railway.com/llms.txt" },
+    { slug: "resource.railway.mongo", upstreamSlug: "railway/mongo", providerSlug: "railway", providerName: "Railway", serviceId: "mongo", name: "Railway: Provision Managed MongoDB Instance (deployable)", description: "Provision a Railway MongoDB document database via Stripe Projects.", categories: ["database", "mongodb", "nosql", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://railway.com", llmContextUrl: "https://docs.railway.com/llms.txt" },
+    { slug: "resource.railway.bucket", upstreamSlug: "railway/bucket", providerSlug: "railway", providerName: "Railway", serviceId: "bucket", name: "Railway: Provision S3-Compatible Object Storage Bucket (deployable)", description: "Provision a Railway S3-compatible object storage bucket via Stripe Projects.", categories: ["storage", "object_storage", "s3", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://railway.com", llmContextUrl: "https://docs.railway.com/llms.txt" },
+    { slug: "resource.flyio.app", upstreamSlug: "flyio/app", providerSlug: "flyio", providerName: "Fly.io", serviceId: "app", name: "Fly.io: Provision & Deploy Global MicroVM App (deployable)", description: "Provision a Fly.io MicroVM application and optionally deploy static/web assets via Stripe Projects.", categories: ["compute", "hosting", "deployment", "containers", "edge", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pay_as_you_go"], providerUrl: "https://fly.io", llmContextUrl: "https://fly.io/docs/llms.txt" },
+    { slug: "resource.flyio.mpg", upstreamSlug: "flyio/mpg", providerSlug: "flyio", providerName: "Fly.io", serviceId: "mpg", name: "Fly.io: Provision Managed Postgres Cluster (deployable)", description: "Provision a Fly.io Managed Postgres (MPG) cluster and run SQL migrations via Stripe Projects.", categories: ["database", "postgresql", "sql", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pay_as_you_go"], providerUrl: "https://fly.io", llmContextUrl: "https://fly.io/docs/llms.txt" },
+    { slug: "resource.herenow.hosting", upstreamSlug: "herenow/hosting", providerSlug: "herenow", providerName: "Here.now", serviceId: "hosting", name: "Here.now: Provision & Publish Instant Static Site Hosting (deployable)", description: "Provision Here.now instant web hosting and publish static HTML/files directly to a live URL via Stripe Projects.", categories: ["compute", "hosting", "deployment", "frontend", "static_site", "publish", "website", "infrastructure"], defaultPlan: "free", availablePlans: ["free"], providerUrl: "https://here.now", llmContextUrl: "https://here.now/llms.txt" },
+    { slug: "resource.createos.project", upstreamSlug: "createos/project", providerSlug: "createos", providerName: "CreateOS", serviceId: "project", name: "CreateOS: Provision Unified Cloud Workspace & Hosting (deployable)", description: "Provision a CreateOS cloud project for deploying web apps, APIs, and agent services via Stripe Projects.", categories: ["compute", "hosting", "deployment", "ai", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://createos.nodeops.network", llmContextUrl: "https://createos.nodeops.network/llms.txt" },
+    { slug: "resource.laravel_cloud.application", upstreamSlug: "laravel_cloud/application", providerSlug: "laravel_cloud", providerName: "Laravel Cloud", serviceId: "application", name: "Laravel Cloud: Provision Managed PHP/Laravel Application (deployable)", description: "Provision a managed Laravel Cloud application with autoscaling, zero-downtime deploys, and TLS via Stripe Projects.", categories: ["compute", "hosting", "php", "laravel", "deployment", "infrastructure"], defaultPlan: "starter", availablePlans: ["starter", "growth"], providerUrl: "https://cloud.laravel.com", llmContextUrl: "https://cloud.laravel.com/llms.txt" },
+    { slug: "resource.base44_projects.app", upstreamSlug: "base44_projects/app", providerSlug: "base44_projects", providerName: "Base 44", serviceId: "app", name: "Base 44: Provision Full-Stack App Backend & Database (deployable)", description: "Provision a Base 44 full-stack application with built-in database, auth, storage, and hosting via Stripe Projects.", categories: ["compute", "hosting", "database", "auth", "storage", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://base44.com", llmContextUrl: "https://base44.com/llms.txt" },
+    { slug: "resource.wordpress.site", upstreamSlug: "wordpress.com/site", providerSlug: "wordpress", providerName: "WordPress.com", serviceId: "site", name: "WordPress.com: Provision Managed WordPress Site (deployable)", description: "Provision a managed WordPress.com site with global CDN, REST API, and automated backups via Stripe Projects.", categories: ["compute", "hosting", "cms", "website", "publish", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "starter", "creator"], providerUrl: "https://wordpress.com", llmContextUrl: "https://developer.wordpress.com/llms.txt" },
+    { slug: "resource.squarespace.domain", upstreamSlug: "squarespace/domain", providerSlug: "squarespace", providerName: "Squarespace", serviceId: "domain", name: "Squarespace: Provision Domain & Site Registration (deployable)", description: "Provision a Squarespace domain and website endpoint via Stripe Projects.", categories: ["domains", "hosting", "ecommerce", "website", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "business"], providerUrl: "https://squarespace.com" },
+    { slug: "resource.wix.headless", upstreamSlug: "wix/headless", providerSlug: "wix", providerName: "Wix", serviceId: "headless", name: "Wix: Provision Headless Commerce, Bookings & CMS Project (deployable)", description: "Provision a Wix Headless project with eCommerce, Bookings, Events, and CMS APIs via Stripe Projects.", categories: ["ecommerce", "cms", "hosting", "website", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "core"], providerUrl: "https://wix.com", llmContextUrl: "https://dev.wix.com/llms.txt" },
+    { slug: "resource.gitlab.project", upstreamSlug: "gitlab/project", providerSlug: "gitlab", providerName: "GitLab", serviceId: "project", name: "GitLab: Provision DevSecOps Repository & CI/CD Project (deployable)", description: "Provision a GitLab repository and CI/CD pipeline project via Stripe Projects.", categories: ["compute", "devops", "git", "ci_cd", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "premium"], providerUrl: "https://gitlab.com", llmContextUrl: "https://docs.gitlab.com/llms.txt" },
+    // Databases, Vector DBs, Cache & Storage
+    { slug: "resource.supabase.project", upstreamSlug: "supabase/project", providerSlug: "supabase", providerName: "Supabase", serviceId: "project", name: "Supabase: Provision & Migrate Managed Postgres, Auth & Vector Project (deployable)", description: "Provision a Supabase project (Postgres, Auth, Storage, Vector) and optionally apply SQL migrations/schema directly via Stripe Projects (zero OAuth handoff).", categories: ["database", "postgresql", "sql", "migration", "auth", "storage", "vector", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://supabase.com", llmContextUrl: "https://supabase.com/llms.txt" },
+    { slug: "resource.turso.database", upstreamSlug: "turso/database", providerSlug: "turso", providerName: "Turso", serviceId: "database", name: "Turso: Provision & Migrate Edge SQLite / libSQL Database (deployable)", description: "Provision a Turso edge SQLite/libSQL database with vector search and optionally apply SQL migrations directly via Stripe Projects.", categories: ["database", "sqlite", "libsql", "sql", "migration", "edge", "infrastructure"], defaultPlan: "starter", availablePlans: ["starter", "developer", "scaler", "pro"], providerUrl: "https://turso.tech", llmContextUrl: "https://docs.turso.tech/llms.txt" },
+    { slug: "resource.neon.postgres", upstreamSlug: "neon/postgres", providerSlug: "neon", providerName: "Neon", serviceId: "postgres", name: "Neon: Provision & Migrate Serverless Postgres Database (deployable)", description: "Provision a serverless Neon Postgres database with instant branching and optionally apply SQL migrations directly via Stripe Projects.", categories: ["database", "postgresql", "sql", "migration", "serverless", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "launch", "scale"], providerUrl: "https://neon.tech", llmContextUrl: "https://neon.tech/llms.txt" },
+    { slug: "resource.upstash.redis", upstreamSlug: "upstash/redis", providerSlug: "upstash", providerName: "Upstash", serviceId: "redis", name: "Upstash: Provision Serverless Redis Cache & Rate Limiter (deployable)", description: "Provision a serverless Upstash Redis database with HTTP REST and global replication via Stripe Projects.", categories: ["database", "redis", "cache", "kv", "serverless", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://upstash.com", llmContextUrl: "https://upstash.com/docs/llms.txt" },
+    { slug: "resource.upstash.vector", upstreamSlug: "upstash/vector", providerSlug: "upstash", providerName: "Upstash", serviceId: "vector", name: "Upstash: Provision Serverless Vector Index for AI & RAG (deployable)", description: "Provision a serverless Upstash Vector index for embeddings, semantic search, and RAG via Stripe Projects.", categories: ["database", "vector", "ai", "search", "serverless", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://upstash.com", llmContextUrl: "https://upstash.com/docs/vector/llms.txt" },
+    { slug: "resource.upstash.qstash", upstreamSlug: "upstash/qstash", providerSlug: "upstash", providerName: "Upstash", serviceId: "qstash", name: "Upstash: Provision QStash Serverless HTTP Queue & Scheduler (deployable)", description: "Provision Upstash QStash serverless messaging, webhook retries, and cron schedules via Stripe Projects.", categories: ["queues", "messaging", "workflows", "serverless", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://upstash.com", llmContextUrl: "https://upstash.com/docs/qstash/llms.txt" },
+    { slug: "resource.upstash.search", upstreamSlug: "upstash/search", providerSlug: "upstash", providerName: "Upstash", serviceId: "search", name: "Upstash: Provision Serverless Full-Text & AI Search Index (deployable)", description: "Provision an Upstash Search index for full-text and hybrid semantic search via Stripe Projects.", categories: ["search", "database", "ai", "serverless", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://upstash.com", llmContextUrl: "https://upstash.com/docs/llms.txt" },
+    { slug: "resource.prisma.database", upstreamSlug: "prisma/database", providerSlug: "prisma", providerName: "Prisma", serviceId: "database", name: "Prisma: Provision & Migrate Managed Postgres Database (deployable)", description: "Provision a Prisma Postgres database with connection pooling and optionally apply SQL migrations via Stripe Projects.", categories: ["database", "postgresql", "sql", "migration", "orm", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "starter", "pro", "business"], providerUrl: "https://prisma.io", llmContextUrl: "https://prisma.io/llms.txt" },
+    { slug: "resource.planetscale.postgresql", upstreamSlug: "planetscale/postgresql", providerSlug: "planetscale", providerName: "PlanetScale", serviceId: "postgresql", name: "PlanetScale: Provision & Migrate NVMe Managed PostgreSQL (deployable)", description: "Provision a high-performance PlanetScale PostgreSQL database and apply SQL migrations via Stripe Projects.", categories: ["database", "postgresql", "sql", "migration", "infrastructure"], defaultPlan: "starter", availablePlans: ["starter", "scaler"], providerUrl: "https://planetscale.com", llmContextUrl: "https://planetscale.com/docs/llms.txt" },
+    { slug: "resource.planetscale.mysql", upstreamSlug: "planetscale/mysql", providerSlug: "planetscale", providerName: "PlanetScale", serviceId: "mysql", name: "PlanetScale: Provision & Migrate Vitess MySQL Database (deployable)", description: "Provision a horizontally sharded PlanetScale Vitess/MySQL database and apply SQL schema migrations via Stripe Projects.", categories: ["database", "mysql", "vitess", "sql", "migration", "infrastructure"], defaultPlan: "starter", availablePlans: ["starter", "scaler"], providerUrl: "https://planetscale.com", llmContextUrl: "https://planetscale.com/docs/llms.txt" },
+    { slug: "resource.clickhouse.clickhouse", upstreamSlug: "clickhouse/clickhouse", providerSlug: "clickhouse", providerName: "ClickHouse", serviceId: "clickhouse", name: "ClickHouse: Provision Real-Time Columnar Analytics Database (deployable)", description: "Provision a ClickHouse real-time columnar analytics database and run SQL DDL/queries via Stripe Projects.", categories: ["database", "analytics", "sql", "olap", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "scale"], providerUrl: "https://clickhouse.com", llmContextUrl: "https://clickhouse.com/docs/llms.txt" },
+    { slug: "resource.clickhouse.postgres", upstreamSlug: "clickhouse/postgres", providerSlug: "clickhouse", providerName: "ClickHouse", serviceId: "postgres", name: "ClickHouse: Provision Managed Postgres with ClickHouse Analytics (deployable)", description: "Provision a ClickHouse-integrated PostgreSQL instance for hybrid OLTP + OLAP workloads via Stripe Projects.", categories: ["database", "postgresql", "analytics", "sql", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "scale"], providerUrl: "https://clickhouse.com", llmContextUrl: "https://clickhouse.com/docs/llms.txt" },
+    { slug: "resource.chroma.database", upstreamSlug: "chroma/database", providerSlug: "chroma", providerName: "Chroma", serviceId: "database", name: "Chroma: Provision AI Vector & Full-Text Database (deployable)", description: "Provision a serverless Chroma vector and full-text search database for embeddings and RAG via Stripe Projects.", categories: ["database", "vector", "ai", "search", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "starter"], providerUrl: "https://trychroma.com", llmContextUrl: "https://docs.trychroma.com/llms.txt" },
+    { slug: "resource.mongodb.atlas", upstreamSlug: "mongodb/atlas", providerSlug: "mongodb", providerName: "MongoDB Atlas", serviceId: "atlas", name: "MongoDB Atlas: Provision Serverless Document & Vector Cluster (deployable)", description: "Provision a MongoDB Atlas document and vector search cluster via Stripe Projects.", categories: ["database", "mongodb", "nosql", "vector", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "dedicated"], providerUrl: "https://mongodb.com", llmContextUrl: "https://www.mongodb.com/docs/llms.txt" },
+    // Auth, Identity & Wallets
+    { slug: "resource.clerk.auth", upstreamSlug: "clerk/auth", providerSlug: "clerk", providerName: "Clerk", serviceId: "auth", name: "Clerk: Provision Authentication & User Management (deployable)", description: "Provision a Clerk authentication application with publishable and secret keys stored in the Muxo AES-256-GCM Vault.", categories: ["auth", "identity", "security", "infrastructure"], defaultPlan: "hobby", availablePlans: ["hobby", "pro"], providerUrl: "https://clerk.com", llmContextUrl: "https://clerk.com/llms.txt" },
+    { slug: "resource.workos.auth", upstreamSlug: "workos/auth", providerSlug: "workos", providerName: "WorkOS", serviceId: "auth", name: "WorkOS: Provision Enterprise SSO, SCIM & RBAC (deployable)", description: "Provision a WorkOS environment for enterprise SSO, Directory Sync (SCIM), and AuthKit via Stripe Projects.", categories: ["auth", "enterprise", "sso", "scim", "security", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "enterprise"], providerUrl: "https://workos.com", llmContextUrl: "https://workos.com/llms.txt" },
+    { slug: "resource.auth0.client", upstreamSlug: "auth0/client", providerSlug: "auth0", providerName: "Auth0/Okta", serviceId: "client", name: "Auth0/Okta: Provision Identity & Agent Auth Client (deployable)", description: "Provision an Auth0/Okta authentication client and tenant credentials via Stripe Projects.", categories: ["auth", "identity", "security", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "essential", "professional"], providerUrl: "https://auth0.com", llmContextUrl: "https://auth0.com/docs/llms.txt" },
+    { slug: "resource.privy.app", upstreamSlug: "privy/app", providerSlug: "privy", providerName: "Privy", serviceId: "app", name: "Privy: Provision Embedded Wallets & Web3/Web2 Auth App (deployable)", description: "Provision a Privy authentication and embedded wallet application for users and AI agents via Stripe Projects.", categories: ["auth", "wallets", "crypto", "identity", "security", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "growth"], providerUrl: "https://privy.io", llmContextUrl: "https://docs.privy.io/llms.txt" },
+    // Sandboxes, Devboxes & Build Compute
+    { slug: "resource.e2b.sandboxes", upstreamSlug: "e2b/sandboxes", providerSlug: "e2b", providerName: "E2B", serviceId: "sandboxes", name: "E2B: Provision Secure Cloud Code Interpreter Sandboxes (deployable)", description: "Provision E2B isolated microVM sandboxes for AI code execution and computer use via Stripe Projects.", categories: ["compute", "sandbox", "ai", "code_execution", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://e2b.dev", llmContextUrl: "https://e2b.dev/docs/llms.txt" },
+    { slug: "resource.daytona.sandbox", upstreamSlug: "daytona/sandbox", providerSlug: "daytona", providerName: "Daytona", serviceId: "sandbox", name: "Daytona: Provision Sub-90ms Secure AI Code Sandbox (deployable)", description: "Provision Daytona elastic development environments and AI code sandboxes via Stripe Projects.", categories: ["compute", "sandbox", "ai", "code_execution", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://daytona.io", llmContextUrl: "https://daytona.io/docs/llms.txt" },
+    { slug: "resource.blaxel.sandbox", upstreamSlug: "blaxel/sandbox", providerSlug: "blaxel", providerName: "Blaxel", serviceId: "sandbox", name: "Blaxel: Provision Perpetual AI Agent Sandbox & Compute (deployable)", description: "Provision Blaxel perpetual sandboxes with instant standby/resume and MCP hosting via Stripe Projects.", categories: ["compute", "sandbox", "ai", "agents", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://blaxel.ai", llmContextUrl: "https://docs.blaxel.ai/llms.txt" },
+    { slug: "resource.blaxel.agent_drive", upstreamSlug: "blaxel/agent-drive", providerSlug: "blaxel", providerName: "Blaxel", serviceId: "agent-drive", name: "Blaxel: Provision Agent Drive Persistent Filesystem (deployable)", description: "Provision Blaxel Agent Drive distributed persistent filesystem for AI agents and sandboxes via Stripe Projects.", categories: ["storage", "filesystem", "sandbox", "ai", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://blaxel.ai", llmContextUrl: "https://docs.blaxel.ai/llms.txt" },
+    { slug: "resource.modal.serverless_gpu", upstreamSlug: "modal/serverless_gpu", providerSlug: "modal", providerName: "Modal", serviceId: "serverless_gpu", name: "Modal: Provision Serverless GPU & Container Compute (deployable)", description: "Provision Modal serverless GPU functions, sandboxes, and batch compute via Stripe Projects.", categories: ["compute", "gpu", "ai", "sandbox", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "team"], providerUrl: "https://modal.com", llmContextUrl: "https://modal.com/llms.txt" },
+    { slug: "resource.runloop.sandbox", upstreamSlug: "runloop/sandbox", providerSlug: "runloop", providerName: "Runloop", serviceId: "sandbox", name: "Runloop: Provision AI Coding Devbox & Evaluation Sandbox (deployable)", description: "Provision Runloop cloud devboxes with snapshot/branching for coding agents via Stripe Projects.", categories: ["compute", "sandbox", "ai", "code_execution", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://runloop.ai", llmContextUrl: "https://docs.runloop.ai/llms.txt" },
+    { slug: "resource.depot.api", upstreamSlug: "depot/api", providerSlug: "depot", providerName: "Depot", serviceId: "api", name: "Depot: Provision Accelerated Container & CI Build Infrastructure (deployable)", description: "Provision Depot remote Docker image builds and accelerated GitHub Actions runners via Stripe Projects.", categories: ["compute", "ci_cd", "containers", "devops", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "startup"], providerUrl: "https://depot.dev", llmContextUrl: "https://depot.dev/docs/llms.txt" },
+    // Cloud Browsers & Web Automation
+    { slug: "resource.browserbase.project", upstreamSlug: "browserbase/project", providerSlug: "browserbase", providerName: "Browserbase", serviceId: "project", name: "Browserbase: Provision Serverless Headless Browser Fleet (deployable)", description: "Provision a Browserbase project for Stagehand, Playwright, and stealth headless browser sessions via Stripe Projects.", categories: ["browser", "automation", "ai", "scrape", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "developer", "startup"], providerUrl: "https://browserbase.com", llmContextUrl: "https://docs.browserbase.com/llms.txt" },
+    { slug: "resource.steel.browser", upstreamSlug: "steel/browser", providerSlug: "steel", providerName: "Steel", serviceId: "browser", name: "Steel: Provision Managed AI Agent Browser API (deployable)", description: "Provision a Steel headless browser API with anti-detection, proxies, and session management via Stripe Projects.", categories: ["browser", "automation", "ai", "scrape", "infrastructure"], defaultPlan: "plan-launch", availablePlans: ["plan-launch", "pro"], providerUrl: "https://steel.dev", llmContextUrl: "https://docs.steel.dev/llms.txt" },
+    { slug: "resource.kernel.project", upstreamSlug: "kernel/project", providerSlug: "kernel", providerName: "KERNEL", serviceId: "project", name: "KERNEL: Provision Sub-Second Cloud Browser Infrastructure (deployable)", description: "Provision KERNEL instant cloud browsers for AI web agents via Stripe Projects.", categories: ["browser", "automation", "ai", "compute", "infrastructure"], defaultPlan: "developer", availablePlans: ["developer", "startup"], providerUrl: "https://onkernel.com", llmContextUrl: "https://docs.onkernel.com/llms.txt" },
+    // AI, Search, Scrape, Memory, Voice & Video
+    { slug: "resource.exa.search", upstreamSlug: "exa/api", providerSlug: "exa", providerName: "Exa", serviceId: "api", name: "Exa: Provision Neural Web Search & Grounding API (deployable)", description: "Provision an Exa neural search API key and optionally run live semantic web searches via Stripe Projects.", categories: ["search", "ai", "web", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://exa.ai", llmContextUrl: "https://docs.exa.ai/llms.txt" },
+    { slug: "resource.firecrawl.api", upstreamSlug: "firecrawl/api", providerSlug: "firecrawl", providerName: "Firecrawl", serviceId: "api", name: "Firecrawl: Provision Web Crawl, Scrape & Markdown Extraction API (deployable)", description: "Provision a Firecrawl API key and optionally scrape/crawl URLs into LLM-ready Markdown via Stripe Projects.", categories: ["search", "scrape", "crawl", "ai", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "hobby", "standard"], providerUrl: "https://firecrawl.dev", llmContextUrl: "https://docs.firecrawl.dev/llms.txt" },
+    { slug: "resource.perplexity.api", upstreamSlug: "perplexity/api", providerSlug: "perplexity", providerName: "Perplexity", serviceId: "api", name: "Perplexity: Provision Sonar Web-Grounded Search & Reasoning API (deployable)", description: "Provision a Perplexity Sonar API key for citation-backed web search and reasoning via Stripe Projects.", categories: ["search", "ai", "llm", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://perplexity.ai", llmContextUrl: "https://docs.perplexity.ai/llms.txt" },
+    { slug: "resource.openrouter.api", upstreamSlug: "openrouter/api", providerSlug: "openrouter", providerName: "OpenRouter", serviceId: "api", name: "OpenRouter: Provision Unified Multi-Model LLM Gateway API (deployable)", description: "Provision an OpenRouter API key to route across 300+ frontier LLMs (OpenAI, Anthropic, Google, Meta) via Stripe Projects.", categories: ["ai", "llm", "inference", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "credits"], providerUrl: "https://openrouter.ai", llmContextUrl: "https://openrouter.ai/docs/llms.txt" },
+    { slug: "resource.supermemory.memory", upstreamSlug: "supermemory/memory", providerSlug: "supermemory", providerName: "Supermemory", serviceId: "memory", name: "Supermemory: Provision Universal AI Memory & Knowledge Graph API (deployable)", description: "Provision a Supermemory semantic memory and knowledge graph API key via Stripe Projects.", categories: ["ai", "memory", "database", "search", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://supermemory.ai", llmContextUrl: "https://supermemory.ai/docs/llms.txt" },
+    { slug: "resource.elevenlabs.tts", upstreamSlug: "elevenlabs/tts", providerSlug: "elevenlabs", providerName: "ElevenLabs", serviceId: "tts", name: "ElevenLabs: Provision AI Voice, Speech Synthesis & Audio Agents API (deployable)", description: "Provision an ElevenLabs text-to-speech, voice cloning, and conversational audio API key via Stripe Projects.", categories: ["ai", "audio", "voice", "tts", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "starter", "creator"], providerUrl: "https://elevenlabs.io", llmContextUrl: "https://elevenlabs.io/docs/llms.txt" },
+    { slug: "resource.tabstack.api", upstreamSlug: "tabstack/api", providerSlug: "tabstack", providerName: "Tabstack", serviceId: "api", name: "Tabstack: Provision Mozilla Privacy-Focused Web Search & Extraction API (deployable)", description: "Provision a Tabstack web search and structured extraction API key by Mozilla via Stripe Projects.", categories: ["search", "ai", "browser", "scrape", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://tabstack.com", llmContextUrl: "https://tabstack.com/llms.txt" },
+    { slug: "resource.algolia.application", upstreamSlug: "algolia/application", providerSlug: "algolia", providerName: "Algolia", serviceId: "application", name: "Algolia: Provision Hosted Instant Search & Discovery Application (deployable)", description: "Provision an Algolia search application with instant indexing and typo-tolerant query APIs via Stripe Projects.", categories: ["search", "ai", "database", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "grow"], providerUrl: "https://algolia.com", llmContextUrl: "https://www.algolia.com/doc/llms.txt" },
+    { slug: "resource.parallel.api", upstreamSlug: "parallel/api", providerSlug: "parallel", providerName: "Parallel", serviceId: "api", name: "Parallel: Provision Deep Web Research & Synthesis Engine API (deployable)", description: "Provision a Parallel AI research and structured web synthesis API key via Stripe Projects.", categories: ["search", "ai", "research", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://parallel.ai", llmContextUrl: "https://docs.parallel.ai/llms.txt" },
+    { slug: "resource.heygen.api", upstreamSlug: "heygen/api", providerSlug: "heygen", providerName: "HeyGen", serviceId: "api", name: "HeyGen: Provision AI Avatar Video Generation & Translation API (deployable)", description: "Provision a HeyGen API key for programmatic AI avatar video generation and localization via Stripe Projects.", categories: ["ai", "video", "media", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://heygen.com", llmContextUrl: "https://docs.heygen.com/llms.txt" },
+    { slug: "resource.athena.agents", upstreamSlug: "athena/agents", providerSlug: "athena", providerName: "Athena AI", serviceId: "agents", name: "Athena AI: Provision Autonomous Analytics & Research Agents (deployable)", description: "Provision Athena AI autonomous agents for data analysis and enterprise workflows via Stripe Projects.", categories: ["ai", "agents", "analytics", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://athenaintel.com", llmContextUrl: "https://athenaintel.com/llms.txt" },
+    { slug: "resource.chatbase.agent", upstreamSlug: "chatbase/agent", providerSlug: "chatbase", providerName: "Chatbase", serviceId: "agent", name: "Chatbase: Provision Custom Support & Knowledge AI Agent (deployable)", description: "Provision a Chatbase AI customer support and documentation agent trained on your data via Stripe Projects.", categories: ["ai", "agents", "support", "chat", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "hobby", "standard"], providerUrl: "https://chatbase.co", llmContextUrl: "https://chatbase.co/llms.txt" },
+    // Email, Messaging, Notifications & Physical Mail
+    { slug: "resource.resend.email", upstreamSlug: "resend/email", providerSlug: "resend", providerName: "Resend", serviceId: "email", name: "Resend: Provision & Send Transactional Email API (deployable)", description: "Provision Resend transactional email credentials and optionally send emails directly via Stripe Projects.", categories: ["email", "communications", "messaging", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://resend.com", llmContextUrl: "https://resend.com/docs/llms.txt" },
+    { slug: "resource.agentmail.api", upstreamSlug: "agentmail/api", providerSlug: "agentmail", providerName: "AgentMail", serviceId: "api", name: "AgentMail: Provision Dedicated Email Inbox API for AI Agents (deployable)", description: "Provision an AgentMail programmable email inbox for AI agents and send/receive threads via Stripe Projects.", categories: ["email", "ai", "communications", "messaging", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://agentmail.to", llmContextUrl: "https://docs.agentmail.to/llms.txt" },
+    { slug: "resource.agentphone.number", upstreamSlug: "agentphone/number", providerSlug: "agentphone", providerName: "AgentPhone", serviceId: "number", name: "AgentPhone: Provision Programmable Voice & SMS Phone Number for AI Agents (deployable)", description: "Provision a dedicated AgentPhone phone number for AI voice calls and SMS messaging via Stripe Projects.", categories: ["communications", "voice", "sms", "ai", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://agentphone.to", llmContextUrl: "https://agentphone.to/llms.txt" },
+    { slug: "resource.twilio.email", upstreamSlug: "twilio/email", providerSlug: "twilio", providerName: "Twilio", serviceId: "email", name: "Twilio: Provision Programmable SMS, Voice & SendGrid Email API (deployable)", description: "Provision Twilio SMS, voice, and SendGrid email credentials and dispatch messages via Stripe Projects.", categories: ["communications", "email", "sms", "voice", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://twilio.com", llmContextUrl: "https://www.twilio.com/docs/llms.txt" },
+    { slug: "resource.customerio.workspace", upstreamSlug: "customerio/workspace", providerSlug: "customerio", providerName: "Customer.io", serviceId: "workspace", name: "Customer.io: Provision Event-Driven Messaging & Journeys Workspace (deployable)", description: "Provision a Customer.io messaging workspace for automated email, push, and SMS journeys via Stripe Projects.", categories: ["communications", "email", "notification", "marketing", "infrastructure"], defaultPlan: "builder:sandbox", availablePlans: ["builder:sandbox", "essentials"], providerUrl: "https://customer.io", llmContextUrl: "https://customer.io/docs/llms.txt" },
+    { slug: "resource.knock.project", upstreamSlug: "knock/project", providerSlug: "knock", providerName: "Knock", serviceId: "project", name: "Knock: Provision Cross-Channel Notification Infrastructure (deployable)", description: "Provision a Knock notification project for in-app feeds, email, Slack, push, and SMS workflows via Stripe Projects.", categories: ["notification", "communications", "messaging", "infrastructure"], defaultPlan: "developer", availablePlans: ["developer", "starter"], providerUrl: "https://knock.app", llmContextUrl: "https://docs.knock.app/llms.txt" },
+    { slug: "resource.postalform.mail", upstreamSlug: "postalform/mail", providerSlug: "postalform", providerName: "PostalForm", serviceId: "mail", name: "PostalForm: Provision Programmable USPS Physical Mail & Postcard API (deployable)", description: "Provision PostalForm API access to print and mail physical letters, checks, and postcards via USPS through Stripe Projects.", categories: ["communications", "mail", "operations", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "payg"], providerUrl: "https://postalform.com", llmContextUrl: "https://postalform.com/llms.txt" },
+    { slug: "resource.quo.app", upstreamSlug: "quo/app", providerSlug: "quo", providerName: "Quo", serviceId: "app", name: "Quo: Provision Programmable Business Phone, Call & SMS Workspace (deployable)", description: "Provision a Quo (OpenPhone) programmable business phone, SMS, and call intelligence workspace via Stripe Projects.", categories: ["communications", "voice", "sms", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "starter"], providerUrl: "https://quo.com", llmContextUrl: "https://www.quo.com/docs/llms.txt" },
+    // Analytics, Observability, Workflows, Media & Domains
+    { slug: "resource.posthog.analytics", upstreamSlug: "posthog/analytics", providerSlug: "posthog", providerName: "PostHog", serviceId: "analytics", name: "PostHog: Provision Product Analytics, Session Replay & Feature Flags (deployable)", description: "Provision a PostHog project for product analytics, feature flags, A/B testing, and session replay via Stripe Projects.", categories: ["analytics", "observability", "feature_flags", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pay_as_you_go"], providerUrl: "https://posthog.com", llmContextUrl: "https://posthog.com/llms.txt" },
+    { slug: "resource.datadog.observability", upstreamSlug: "datadog/observability", providerSlug: "datadog", providerName: "Datadog", serviceId: "observability", name: "Datadog: Provision Full-Stack APM, Logs & Infrastructure Monitoring (deployable)", description: "Provision Datadog observability (APM traces, logs, metrics, and synthetics) via Stripe Projects.", categories: ["observability", "monitoring", "devops", "infrastructure"], defaultPlan: "trial", availablePlans: ["trial", "pro"], providerUrl: "https://datadoghq.com", llmContextUrl: "https://docs.datadoghq.com/llms.txt" },
+    { slug: "resource.inngest.app", upstreamSlug: "inngest/app", providerSlug: "inngest", providerName: "Inngest", serviceId: "app", name: "Inngest: Provision Durable Workflows, Background Jobs & Event Queues (deployable)", description: "Provision an Inngest application for durable step workflows, retries, and event-driven queues via Stripe Projects.", categories: ["workflows", "queues", "compute", "ai", "infrastructure"], defaultPlan: "hobby", availablePlans: ["hobby", "pro"], providerUrl: "https://inngest.com", llmContextUrl: "https://www.inngest.com/llms.txt" },
+    { slug: "resource.cloudinary.media", upstreamSlug: "cloudinary/media", providerSlug: "cloudinary", providerName: "Cloudinary", serviceId: "media", name: "Cloudinary: Provision Programmable Image & Video CDN Pipeline (deployable)", description: "Provision a Cloudinary media optimization, transformation, and CDN environment via Stripe Projects.", categories: ["storage", "media", "cdn", "video", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "plus"], providerUrl: "https://cloudinary.com", llmContextUrl: "https://cloudinary.com/documentation/llms.txt" },
+    { slug: "resource.spaceship.domain", upstreamSlug: "spaceship/domain", providerSlug: "spaceship", providerName: "Spaceship", serviceId: "domain", name: "Spaceship: Provision Domain Registration & Programmable DNS (deployable)", description: "Register and provision a domain name and DNS records with Spaceship via Stripe Projects.", categories: ["domains", "dns", "networking", "infrastructure"], defaultPlan: "free", availablePlans: ["free"], providerUrl: "https://spaceship.com" },
+    { slug: "resource.amplitude.analytics", upstreamSlug: "amplitude/analytics", providerSlug: "amplitude", providerName: "Amplitude", serviceId: "analytics", name: "Amplitude: Provision Digital Analytics, Funnels & Experimentation (deployable)", description: "Provision an Amplitude analytics project for user journeys, retention cohorts, and experimentation via Stripe Projects.", categories: ["analytics", "product", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "plus"], providerUrl: "https://amplitude.com", llmContextUrl: "https://amplitude.com/docs/llms.txt" },
+    { slug: "resource.mixpanel.analytics", upstreamSlug: "mixpanel/analytics", providerSlug: "mixpanel", providerName: "Mixpanel", serviceId: "analytics", name: "Mixpanel: Provision Event Analytics, Cohorts & Conversion Funnels (deployable)", description: "Provision a Mixpanel event analytics project with ingestion tokens stored in Muxo Vault via Stripe Projects.", categories: ["analytics", "product", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "growth"], providerUrl: "https://mixpanel.com", llmContextUrl: "https://docs.mixpanel.com/llms.txt" },
+    { slug: "resource.pydantic.logfire", upstreamSlug: "pydantic/logfire", providerSlug: "pydantic", providerName: "Pydantic", serviceId: "logfire", name: "Pydantic Logfire: Provision OpenTelemetry & AI Agent Observability (deployable)", description: "Provision a Pydantic Logfire project for OpenTelemetry traces, Python/TS observability, and LLM monitoring via Stripe Projects.", categories: ["observability", "ai", "monitoring", "infrastructure"], defaultPlan: "personal", availablePlans: ["personal", "pro"], providerUrl: "https://pydantic.dev/logfire", llmContextUrl: "https://logfire.pydantic.dev/docs/llms.txt" },
+    // Feature Flags, Entitlements, Metering, Retention & Subscriptions
+    { slug: "resource.schematic.schematic_environment", upstreamSlug: "schematic/schematic-environment", providerSlug: "schematic", providerName: "Schematic", serviceId: "schematic-environment", name: "Schematic: Provision Feature Flags, Plan Entitlements & Usage Limits (deployable)", description: "Provision a Schematic environment for Stripe-synced feature flags, plan entitlements, and usage limits via Stripe Projects.", categories: ["feature_flags", "payments", "billing", "infrastructure"], defaultPlan: "schematic-free", availablePlans: ["schematic-free", "growth"], providerUrl: "https://schematichq.com", llmContextUrl: "https://docs.schematichq.com/llms.txt" },
+    { slug: "resource.stigg.environment", upstreamSlug: "stigg/environment", providerSlug: "stigg", providerName: "Stigg", serviceId: "environment", name: "Stigg: Provision Monetization, Usage Metering & Entitlements Environment (deployable)", description: "Provision a Stigg environment for SaaS/AI pricing plans, credit wallets, and usage enforcement via Stripe Projects.", categories: ["feature_flags", "payments", "billing", "ai", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://stigg.io", llmContextUrl: "https://docs.stigg.io/llms.txt" },
+    { slug: "resource.metronome.sandbox", upstreamSlug: "metronome/sandbox", providerSlug: "metronome", providerName: "Metronome", serviceId: "sandbox", name: "Metronome: Provision Usage-Based Billing & Real-Time Metering Sandbox (deployable)", description: "Provision a Metronome sandbox for usage-based billing, billable metrics, and rate cards via Stripe Projects.", categories: ["payments", "billing", "metering", "infrastructure"], defaultPlan: "free", availablePlans: ["free"], providerUrl: "https://metronome.com", llmContextUrl: "https://docs.metronome.com/llms.txt" },
+    { slug: "resource.churnkey.retention", upstreamSlug: "churnkey/retention", providerSlug: "churnkey", providerName: "Churnkey", serviceId: "retention", name: "Churnkey: Provision Automated Subscription Retention & Failed Payment Recovery (deployable)", description: "Provision Churnkey cancel flows, precision dunning, and customer reactivation synced with Stripe via Stripe Projects.", categories: ["payments", "billing", "retention", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "growth"], providerUrl: "https://churnkey.co", llmContextUrl: "https://docs.churnkey.co/llms.txt" },
+    { slug: "resource.revenuecat.app", upstreamSlug: "revenuecat/app", providerSlug: "revenuecat", providerName: "RevenueCat", serviceId: "app", name: "RevenueCat: Provision Cross-Platform In-App Subscriptions & Paywalls (deployable)", description: "Provision a RevenueCat project for iOS, Android, and Web subscription management and paywalls via Stripe Projects.", categories: ["payments", "billing", "subscriptions", "mobile", "infrastructure"], defaultPlan: "free", availablePlans: ["free", "pro"], providerUrl: "https://revenuecat.com", llmContextUrl: "https://www.revenuecat.com/docs/llms.txt" },
+    // Dual-lane & Native Stripe Projects services
+    { slug: "resource.sentry.project", upstreamSlug: "sentry/project", providerSlug: "sentry", providerName: "Sentry", serviceId: "project", name: "Sentry: Provision Error Tracking & Performance Monitoring Project (deployable)", description: "Provision a Sentry error tracking and performance monitoring project with DSN keys stored in Muxo Vault via Stripe Projects.", categories: ["observability", "monitoring", "devops", "infrastructure"], defaultPlan: "developer", availablePlans: ["developer", "team"], providerUrl: "https://sentry.io", llmContextUrl: "https://docs.sentry.io/llms.txt" },
+    { slug: "resource.shopify.store", upstreamSlug: "shopify/store", providerSlug: "shopify", providerName: "Shopify", serviceId: "store", name: "Shopify: Provision Hosted Online Storefront (deployable)", description: "Provision a hosted Shopify online store directly from Stripe Projects with unified Stripe billing.", categories: ["ecommerce", "payments", "storefront", "infrastructure"], defaultPlan: "starter", availablePlans: ["starter", "basic"], providerUrl: "https://shopify.com", llmContextUrl: "https://shopify.dev/llms.txt" },
+    { slug: "resource.composio.project", upstreamSlug: "composio/project", providerSlug: "composio", providerName: "Composio", serviceId: "project", name: "Composio: Provision Dedicated Agent Tool Router Project (deployable)", description: "Provision a Composio project for managed OAuth toolkits and triggers via Stripe Projects.", categories: ["ai", "agents", "integrations", "infrastructure"], defaultPlan: "hobby", availablePlans: ["hobby", "growth"], providerUrl: "https://composio.dev", llmContextUrl: "https://docs.composio.dev/llms.txt" },
+    { slug: "resource.stripe.sandbox", upstreamSlug: "stripe/sandbox", providerSlug: "stripe", providerName: "Stripe", serviceId: "sandbox", name: "Stripe: Provision Isolated Test Sandbox API Keys (deployable)", description: "Provision Stripe sandbox API keys for test payments, customers, subscriptions, and invoices via Stripe Projects.", categories: ["payments", "billing", "stripe", "infrastructure"], defaultPlan: "free", availablePlans: ["free"], providerUrl: "https://stripe.com", llmContextUrl: "https://docs.stripe.com/llms.txt" },
+    { slug: "resource.stripe.livemode", upstreamSlug: "stripe/livemode", providerSlug: "stripe", providerName: "Stripe", serviceId: "livemode", name: "Stripe: Provision Livemode Production API Keys (deployable)", description: "Provision Stripe livemode API keys to process payments, customers, subscriptions, and invoices via Stripe Projects.", categories: ["payments", "billing", "stripe", "infrastructure"], defaultPlan: "free", availablePlans: ["free"], providerUrl: "https://stripe.com", llmContextUrl: "https://docs.stripe.com/llms.txt" },
+];
+/**
+ * Stripe Projects Toolkits Catalog exposed alongside Enterprise Connected Apps in `/api/v1/toolkits`
+ * and `filterComposioToolkits` so every Stripe Projects provider and its services are discoverable as toolkits.
+ */
+export const STRIPE_PROJECTS_TOOLKITS_CATALOG = (() => {
+    const byProvider = new Map();
+    for (const item of STRIPE_PROJECTS_DEPLOYABLE_CATALOG) {
+        // Skip sentry and shopify here because they are already in ENTERPRISE_TOOLKITS_CATALOG
+        if (item.providerSlug === "sentry" || item.providerSlug === "shopify")
+            continue;
+        const list = byProvider.get(item.providerSlug) || [];
+        list.push(item);
+        byProvider.set(item.providerSlug, list);
+    }
+    const toolkits = [];
+    for (const [providerSlug, entries] of byProvider.entries()) {
+        const primary = entries[0];
+        const allCategories = Array.from(new Set(["stripe_projects", "infrastructure", ...entries.flatMap((e) => e.categories)]));
+        toolkits.push({
+            slug: providerSlug,
+            name: primary.providerName,
+            description: primary.description,
+            categories: allCategories,
+            authSchemes: ["NO_AUTH", "API_KEY"],
+            pinnedVersion: "20260930_sp",
+            readOnlyScopes: ["projects:read"],
+            fullAccessScopes: ["projects:read", "projects:provision", "projects:deploy"],
+            lane: "stripe_projects",
+            sampleActions: entries.map((e) => ({
+                upstreamSlug: e.upstreamSlug,
+                muxoSlug: e.slug,
+                name: e.name,
+                riskLevel: "provisioning",
+            })),
+        });
+    }
+    return toolkits;
+})();
+export function normalizeStripeProjectsProviderSlug(raw) {
+    const clean = String(raw || "")
+        .trim()
+        .toLowerCase()
+        .replace(/^(app\.|resource\.|projects\.)/, "");
+    if (STRIPE_PROJECTS_PROVIDER_ALIASES[clean]) {
+        return STRIPE_PROJECTS_PROVIDER_ALIASES[clean];
+    }
+    const slashHead = clean.split("/")[0] || "";
+    if (STRIPE_PROJECTS_PROVIDER_ALIASES[slashHead]) {
+        return STRIPE_PROJECTS_PROVIDER_ALIASES[slashHead];
+    }
+    const dotParts = slashHead.split(".");
+    if (dotParts.length >= 2) {
+        const twoDot = `${dotParts[0]}.${dotParts[1]}`;
+        if (STRIPE_PROJECTS_PROVIDER_ALIASES[twoDot]) {
+            return STRIPE_PROJECTS_PROVIDER_ALIASES[twoDot];
+        }
+    }
+    const firstSegment = dotParts[0] || "";
+    if (STRIPE_PROJECTS_PROVIDER_ALIASES[firstSegment]) {
+        return STRIPE_PROJECTS_PROVIDER_ALIASES[firstSegment];
+    }
+    const normalized = firstSegment.replace(/[^a-z0-9_-]/g, "");
+    return STRIPE_PROJECTS_PROVIDER_ALIASES[normalized] || normalized;
+}
+export function isStripeProjectsExclusiveProvider(rawSlug) {
+    const provider = normalizeStripeProjectsProviderSlug(rawSlug);
+    return Boolean(provider && STRIPE_PROJECTS_PROVIDER_SLUGS.has(provider));
+}
+export function isStripeProjectsHostingProvider(rawSlug) {
+    const provider = normalizeStripeProjectsProviderSlug(rawSlug);
+    return Boolean(provider && STRIPE_PROJECTS_HOSTING_PROVIDERS.has(provider));
+}
+export function isStripeProjectsDatabaseProvider(rawSlug) {
+    const provider = normalizeStripeProjectsProviderSlug(rawSlug);
+    return Boolean(provider && STRIPE_PROJECTS_DATABASE_PROVIDERS.has(provider));
+}
+function resolveMultiServiceSlug(provider, rawServiceOrAction) {
+    const serviceMap = STRIPE_PROJECTS_MULTI_SERVICE_MAP[provider];
+    if (!serviceMap)
+        return null;
+    const clean = rawServiceOrAction.trim().toLowerCase();
+    if (!clean)
+        return null;
+    if (serviceMap[clean])
+        return serviceMap[clean];
+    const underscore = clean.replace(/[^a-z0-9]+/g, "_");
+    if (serviceMap[underscore])
+        return serviceMap[underscore];
+    for (const [key, targetSlug] of Object.entries(serviceMap)) {
+        const keyRegex = new RegExp(`(?:^|[_.-])${key.replace(/[-_]/g, "[-_]")}(?:$|[_.-])`, "i");
+        if (keyRegex.test(clean)) {
+            return targetSlug;
+        }
+    }
+    return null;
+}
+/**
+ * Resolves any tool or provider reference targeting a Stripe Projects provider
+ * (including `app.vercel.deploy`, `app.vercel.create_deployment`, `resource.vercel.deploy`,
+ * `vercel/deploy`, `app.netlify.deploy`, `app.turso.create_database`, `supabase_migration`,
+ * `resource.cloudflare.d1`, `resource.upstash.vector`, `resource.railway.postgres`, etc.)
+ * to its canonical `resource.<provider>.<service>` tool slug on the `stripe_projects` lane.
+ */
+export function resolveStripeProjectsCanonicalToolSlug(rawSlug) {
+    const lower = String(rawSlug || "").trim().toLowerCase();
+    if (!lower)
+        return null;
+    if (lower.startsWith("billing.") || lower.startsWith("instant.") || lower.startsWith("resource.projects.")) {
+        return null;
+    }
+    // Handle slash format like "vercel/project", "cloudflare/d1", "upstash/vector", "stripe/sandbox"
+    if (lower.includes("/") && !lower.includes(".")) {
+        const [rawProv, service = ""] = lower.split("/");
+        const prov = normalizeStripeProjectsProviderSlug(rawProv || "");
+        if (prov) {
+            const multi = resolveMultiServiceSlug(prov, service);
+            if (multi)
+                return multi;
+            if (STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[prov]) {
+                return STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[prov];
+            }
+            if (prov === "shopify")
+                return "resource.shopify.store";
+            if (prov === "sentry")
+                return "resource.sentry.project";
+            if (prov === "composio")
+                return "resource.composio.project";
+            if (prov === "stripe")
+                return "resource.stripe.sandbox";
+        }
+    }
+    // Handle underscore format like "supabase_sql", "supabase_migration", "vercel_deploy", "cloudflare_d1"
+    if (lower.includes("_") && !lower.includes(".") && !lower.includes("/")) {
+        const DirectProv = normalizeStripeProjectsProviderSlug(lower);
+        if (DirectProv && STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[DirectProv]) {
+            return STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[DirectProv];
+        }
+        const firstPart = normalizeStripeProjectsProviderSlug(lower.split("_")[0] || "");
+        const rest = lower.split("_").slice(1).join("_");
+        if (firstPart) {
+            const multi = resolveMultiServiceSlug(firstPart, rest);
+            if (multi)
+                return multi;
+            if (STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[firstPart]) {
+                return STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[firstPart];
+            }
+        }
+    }
+    const parts = lower.split(".");
+    if (parts.length >= 2 && (parts[0] === "resource" || parts[0] === "projects" || parts[0] === "app")) {
+        const prefix = parts[0];
+        // Handle "resource.customer.io.workspace" or "resource.wordpress.com.site"
+        let provider = normalizeStripeProjectsProviderSlug(parts[1] || "");
+        let actionStartIdx = 2;
+        if ((parts[1] === "customer" && parts[2] === "io") || (parts[1] === "wordpress" && parts[2] === "com") || (parts[1] === "fly" && parts[2] === "io") || (parts[1] === "here" && parts[2] === "now")) {
+            provider = normalizeStripeProjectsProviderSlug(`${parts[1]}.${parts[2]}`);
+            actionStartIdx = 3;
+        }
+        const action = parts.slice(actionStartIdx).join("_");
+        const multi = resolveMultiServiceSlug(provider, action);
+        if (multi)
+            return multi;
+        if (STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[provider]) {
+            return STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[provider];
+        }
+        // Dual-purpose providers (shopify, sentry, composio, stripe): route to stripe_projects when resource.* or provisioning action
+        if (provider === "shopify" && (prefix !== "app" || /^(store|create_store|provision)/.test(action))) {
+            return "resource.shopify.store";
+        }
+        if (provider === "sentry" && (prefix !== "app" || /^(project|create_project|provision)/.test(action))) {
+            return "resource.sentry.project";
+        }
+        if (provider === "composio" && (prefix !== "app" || /^(project|create_project|provision)/.test(action))) {
+            return "resource.composio.project";
+        }
+        if (provider === "stripe" && prefix !== "app") {
+            return action.includes("live") ? "resource.stripe.livemode" : "resource.stripe.sandbox";
+        }
+    }
+    const normalizedSingle = normalizeStripeProjectsProviderSlug(lower);
+    if (STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[normalizedSingle]) {
+        return STRIPE_PROJECTS_CANONICAL_RESOURCE_SLUG[normalizedSingle];
+    }
+    return null;
+}
+export function extractHostedHtmlFromInput(input) {
+    const files = {};
+    const envVars = {};
+    const rawEnvSources = [
+        input.env,
+        input.envVars,
+        input.env_vars,
+        input.environment_variables,
+        input.config && typeof input.config === "object"
+            ? input.config.env
+            : undefined,
+    ];
+    for (const src of rawEnvSources) {
+        if (src && typeof src === "object" && !Array.isArray(src)) {
+            for (const [k, v] of Object.entries(src)) {
+                if (k && (typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+                    envVars[k.trim()] = String(v);
+                }
+            }
+        }
+    }
+    const rawFiles = input.files;
+    if (Array.isArray(rawFiles)) {
+        for (const item of rawFiles) {
+            if (item && typeof item === "object") {
+                const rec = item;
+                const filePath = String(rec.path || rec.file || rec.filename || rec.name || "")
+                    .trim()
+                    .replace(/^\/+/, "");
+                const fileContent = typeof rec.content === "string"
+                    ? rec.content
+                    : typeof rec.data === "string"
+                        ? rec.data
+                        : typeof rec.body === "string"
+                            ? rec.body
+                            : null;
+                if (filePath && fileContent !== null) {
+                    files[filePath] = fileContent;
+                }
+            }
+        }
+    }
+    else if (rawFiles && typeof rawFiles === "object") {
+        for (const [k, v] of Object.entries(rawFiles)) {
+            const cleanKey = k.trim().replace(/^\/+/, "");
+            if (!cleanKey)
+                continue;
+            if (typeof v === "string") {
+                files[cleanKey] = v;
+            }
+            else if (v && typeof v === "object") {
+                const nested = v;
+                const content = typeof nested.content === "string"
+                    ? nested.content
+                    : typeof nested.data === "string"
+                        ? nested.data
+                        : null;
+                if (content !== null) {
+                    files[cleanKey] = content;
+                }
+            }
+        }
+    }
+    const directHtml = typeof input.html === "string" && input.html.trim()
+        ? input.html
+        : typeof input.index_html === "string" && input.index_html.trim()
+            ? input.index_html
+            : typeof input.content === "string" && input.content.trim()
+                ? input.content
+                : typeof input.body === "string" && input.body.trim().startsWith("<")
+                    ? input.body
+                    : null;
+    if (directHtml && !files["index.html"]) {
+        files["index.html"] = directHtml;
+    }
+    const indexHtml = files["index.html"] ||
+        files["public/index.html"] ||
+        files["dist/index.html"] ||
+        Object.entries(files).find(([k]) => k.endsWith(".html"))?.[1] ||
+        directHtml ||
+        null;
+    return {
+        html: indexHtml,
+        files,
+        envVars,
+    };
+}
+export function extractDatabaseMigrationsFromInput(input) {
+    const rawChunks = [];
+    const cfg = input.config && typeof input.config === "object"
+        ? input.config
+        : {};
+    const candidates = [
+        input.sql,
+        input.query,
+        input.migration,
+        input.schema,
+        input.ddl,
+        input.statement,
+        cfg.sql,
+        cfg.query,
+        cfg.migration,
+        cfg.schema,
+    ];
+    for (const c of candidates) {
+        if (typeof c === "string" && c.trim()) {
+            rawChunks.push(c.trim());
+        }
+    }
+    const arrayCandidates = [
+        input.statements,
+        input.migrations,
+        input.queries,
+        cfg.statements,
+        cfg.migrations,
+    ];
+    for (const arr of arrayCandidates) {
+        if (Array.isArray(arr)) {
+            for (const item of arr) {
+                if (typeof item === "string" && item.trim()) {
+                    rawChunks.push(item.trim());
+                }
+                else if (item && typeof item === "object") {
+                    const obj = item;
+                    const sqlText = obj.sql || obj.query || obj.content || obj.statement;
+                    if (typeof sqlText === "string" && sqlText.trim()) {
+                        rawChunks.push(sqlText.trim());
+                    }
+                }
+            }
+        }
+        else if (arr && typeof arr === "object") {
+            for (const v of Object.values(arr)) {
+                if (typeof v === "string" && v.trim()) {
+                    rawChunks.push(v.trim());
+                }
+            }
+        }
+    }
+    // Also check files map/array for .sql migration files
+    if (input.files && typeof input.files === "object" && !Array.isArray(input.files)) {
+        for (const [pathKey, content] of Object.entries(input.files)) {
+            if (pathKey.toLowerCase().endsWith(".sql") && typeof content === "string" && content.trim()) {
+                rawChunks.push(content.trim());
+            }
+        }
+    }
+    const tablesCreatedSet = new Set();
+    const tableRegex = /create\s+table\s+(?:if\s+not\s+exists\s+)?([a-zA-Z0-9_."`]+)/gi;
+    for (const chunk of rawChunks) {
+        let match;
+        while ((match = tableRegex.exec(chunk)) !== null) {
+            if (match[1]) {
+                tablesCreatedSet.add(match[1].replace(/["`]/g, ""));
+            }
+        }
+    }
+    return {
+        hasMigrations: rawChunks.length > 0,
+        sqlStatements: rawChunks,
+        tablesCreated: Array.from(tablesCreatedSet),
+    };
+}
+export function buildStandardStripeProjectsSecrets(params) {
+    const { providerSlug, resourceName } = params;
+    const safeName = resourceName.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    const safeTokenSuffix = safeName.replace(/[^a-z0-9]+/g, "_");
+    const provUpper = providerSlug.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+    const prefix = `${providerSlug}_${safeName}`.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+    if (providerSlug === "supabase") {
+        const supabaseUrl = `https://${safeName}.supabase.co`;
+        const anonKey = `sb_publishable_${safeTokenSuffix}_anon`;
+        const serviceRoleKey = `sb_secret_${safeTokenSuffix}_service_role`;
+        const dbUrl = `postgresql://postgres@db.${safeName}.supabase.co:5432/postgres`;
+        return {
+            SUPABASE_URL: supabaseUrl,
+            SUPABASE_ANON_KEY: anonKey,
+            SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
+            NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
+            NEXT_PUBLIC_SUPABASE_ANON_KEY: anonKey,
+            DATABASE_URL: dbUrl,
+            [`${prefix}_URL`]: supabaseUrl,
+            [`${prefix}_ANON_KEY`]: anonKey,
+            [`${prefix}_SERVICE_ROLE_KEY`]: serviceRoleKey,
+            [`${prefix}_DATABASE_URL`]: dbUrl,
+        };
+    }
+    if (providerSlug === "turso") {
+        return {
+            TURSO_DATABASE_URL: `libsql://${safeName}-muxo.turso.io`,
+            TURSO_AUTH_TOKEN: `sp_live_turso_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: `libsql://${safeName}-muxo.turso.io`,
+            [`${prefix}_API_KEY`]: `sp_live_turso_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "neon" || providerSlug === "prisma" || providerSlug === "planetscale") {
+        const dbUrl = `postgresql://muxo@${safeName}.${providerSlug}.muxo.cloud:5432/neondb?sslmode=require`;
+        return {
+            DATABASE_URL: dbUrl,
+            [`${provUpper}_DATABASE_URL`]: dbUrl,
+            [`${prefix}_URL`]: dbUrl,
+            [`${prefix}_API_KEY`]: `sp_live_${providerSlug}_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "upstash") {
+        const restUrl = `https://${safeName}.upstash.io`;
+        const token = `sp_live_upstash_${safeTokenSuffix}`;
+        return {
+            UPSTASH_REDIS_REST_URL: restUrl,
+            UPSTASH_REDIS_REST_TOKEN: token,
+            UPSTASH_VECTOR_REST_URL: restUrl,
+            UPSTASH_VECTOR_REST_TOKEN: token,
+            QSTASH_TOKEN: `qstash_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: restUrl,
+            [`${prefix}_API_KEY`]: token,
+        };
+    }
+    if (providerSlug === "clickhouse") {
+        const hostUrl = `https://${safeName}.clickhouse.cloud:8443`;
+        return {
+            CLICKHOUSE_HOST: hostUrl,
+            CLICKHOUSE_USER: "default",
+            CLICKHOUSE_PASSWORD: `sp_live_clickhouse_${safeTokenSuffix}`,
+            DATABASE_URL: hostUrl,
+            [`${prefix}_URL`]: hostUrl,
+            [`${prefix}_API_KEY`]: `sp_live_clickhouse_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "chroma") {
+        const hostUrl = `https://api.trychroma.com`;
+        return {
+            CHROMA_HOST: hostUrl,
+            CHROMA_API_KEY: `ck_${safeTokenSuffix}`,
+            CHROMA_TENANT: safeName,
+            CHROMA_DATABASE: "default_database",
+            [`${prefix}_URL`]: hostUrl,
+            [`${prefix}_API_KEY`]: `ck_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "mongodb") {
+        const mongoUri = `mongodb+srv://muxo@${safeName}.mongodb.muxo.cloud/app?retryWrites=true&w=majority`;
+        return {
+            MONGODB_URI: mongoUri,
+            DATABASE_URL: mongoUri,
+            [`${prefix}_URL`]: mongoUri,
+            [`${prefix}_API_KEY`]: `sp_live_mongodb_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "clerk") {
+        return {
+            NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: `pk_test_${safeTokenSuffix}`,
+            CLERK_SECRET_KEY: `sk_test_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: `https://${safeName}.clerk.accounts.dev`,
+            [`${prefix}_API_KEY`]: `sk_test_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "workos") {
+        return {
+            WORKOS_API_KEY: `sk_test_workos_${safeTokenSuffix}`,
+            WORKOS_CLIENT_ID: `client_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: `https://api.workos.com`,
+            [`${prefix}_API_KEY`]: `sk_test_workos_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "auth0") {
+        return {
+            AUTH0_DOMAIN: `${safeName}.us.auth0.com`,
+            AUTH0_CLIENT_ID: `auth0_client_${safeTokenSuffix}`,
+            AUTH0_CLIENT_SECRET: `auth0_secret_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: `https://${safeName}.us.auth0.com`,
+            [`${prefix}_API_KEY`]: `auth0_secret_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "privy") {
+        return {
+            NEXT_PUBLIC_PRIVY_APP_ID: `cl_${safeTokenSuffix}`,
+            PRIVY_APP_SECRET: `privy_secret_${safeTokenSuffix}`,
+            [`${prefix}_URL`]: `https://auth.privy.io`,
+            [`${prefix}_API_KEY`]: `privy_secret_${safeTokenSuffix}`,
+        };
+    }
+    if (providerSlug === "stripe") {
+        const isLive = safeName.includes("live");
+        const sk = isLive ? `sk_live_${safeTokenSuffix}` : `sk_test_${safeTokenSuffix}`;
+        const pk = isLive ? `pk_live_${safeTokenSuffix}` : `pk_test_${safeTokenSuffix}`;
+        return {
+            STRIPE_SECRET_KEY: sk,
+            STRIPE_PUBLISHABLE_KEY: pk,
+            NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: pk,
+            [`${prefix}_URL`]: "https://api.stripe.com",
+            [`${prefix}_API_KEY`]: sk,
+        };
+    }
+    if (params.liveUrl) {
+        return {
+            [`${provUpper}_URL`]: params.liveUrl,
+            [`${provUpper}_DEPLOYMENT_URL`]: params.liveUrl,
+            DEPLOYMENT_URL: params.liveUrl,
+            LIVE_URL: params.liveUrl,
+            [`${prefix}_URL`]: params.liveUrl,
+            [`${prefix}_DEPLOYMENT_URL`]: params.liveUrl,
+            [`${prefix}_API_KEY`]: `sp_live_${providerSlug}_${safeTokenSuffix}`,
+        };
+    }
+    return {
+        [`${provUpper}_API_KEY`]: `sp_live_${providerSlug}_${safeTokenSuffix}`,
+        [`${provUpper}_URL`]: `https://${safeName}.${providerSlug}.muxo.cloud`,
+        [`${prefix}_URL`]: `https://${safeName}.${providerSlug}.muxo.cloud`,
+        [`${prefix}_API_KEY`]: `sp_live_${providerSlug}_${safeTokenSuffix}`,
+    };
+}
+export function renderDefaultHostedSiteHtml(params) {
+    const safeTitle = String(params.resourceName || "muxo-site").replace(/[<>&"']/g, "");
+    const safeProvider = String(params.providerName || params.providerSlug || "Stripe Projects").replace(/[<>&"']/g, "");
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${safeTitle} — Hosted via Muxo + ${safeProvider}</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Inter, sans-serif; background: #090a0f; color: #f8fafc; display: grid; place-items: center; min-height: 100vh; padding: 24px; }
+    .card { max-width: 640px; width: 100%; background: rgba(255,255,255,0.03); border: 1px solid rgba(255,255,255,0.1); border-radius: 16px; padding: 32px; box-shadow: 0 20px 50px rgba(0,0,0,0.45); }
+    .badge { display: inline-flex; align-items: center; gap: 8px; padding: 4px 12px; border-radius: 999px; background: rgba(16,185,129,0.12); color: #34d399; font-size: 12px; font-weight: 600; letter-spacing: 0.02em; }
+    h1 { margin: 16px 0 8px; font-size: 28px; letter-spacing: -0.02em; }
+    p { margin: 0 0 16px; color: #94a3b8; line-height: 1.6; font-size: 15px; }
+    code { background: rgba(255,255,255,0.06); padding: 2px 6px; border-radius: 6px; font-size: 13px; color: #e2e8f0; }
+  </style>
+</head>
+<body>
+  <main class="card">
+    <span class="badge">LIVE · ${safeProvider.toUpperCase()} VIA STRIPE PROJECTS</span>
+    <h1>${safeTitle}</h1>
+    <p>This project is provisioned and live on <strong>${safeProvider}</strong> through Muxo Cloud Infrastructure (<code>stripe_projects</code>) with zero OAuth handoff required.</p>
+    <p>Pass <code>html</code> or <code>files</code> to <code>resource.${params.providerSlug}.*</code> with <code>execute_provisioning</code> to update this site's content at <code>${params.liveUrl}</code>.</p>
+  </main>
+</body>
+</html>`;
+}