@nymbalhq/platform 0.2.0 → 1.0.0

package/dist/index.js

@@ -391,6 +391,9 @@ var InMemoryDocumentStore = class {
       this.#sweepTimer = null;
     }
   }
+  capabilities() {
+    return ["get", "put", "delete", "query", "batch", "ttl", "conditional-put"];
+  }
   async get(collection, key) {
     const entry = this.#data.get(collection)?.get(key);
     if (!entry) return null;
@@ -632,6 +635,9 @@ var InProcessEventBus = class {
   constructor(options = {}) {
     this.#logger = options.logger;
   }
+  capabilities() {
+    return ["publish", "subscribe", "wildcard", "replay"];
+  }
   async publish(event) {
     await this.#deliver(event, () => true);
   }
@@ -3170,7 +3176,12 @@ async function registerHandlers(deps) {
 
 // src/app.ts
 import { DEFAULT_JWT_SECRET } from "@nymbalhq/config";
-import { ConfigError as ConfigError4 } from "@nymbalhq/types";
+import { ConfigError as ConfigError6 } from "@nymbalhq/types";
+
+// src/adapters/registry.ts
+import {
+  ConfigError as ConfigError5
+} from "@nymbalhq/types";
 
 // src/adapters/security/headers.ts
 function buildSecurityHeaders(security) {
@@ -3203,7 +3214,7 @@ function createMiddlewareSecurityAdapter(deps) {
   const { logger } = deps;
   let lastAppliedAt = "";
   return {
-    capabilities: ["headers"],
+    capabilities: () => ["headers"],
     producesEvents: [],
     consumesEvents: [],
     initialize: noopInitialize,
@@ -3225,220 +3236,17 @@ function createMiddlewareSecurityAdapter(deps) {
   };
 }
 
-// src/adapters/payments/stripe-adapter.ts
-import Stripe from "stripe";
+// src/adapters/payments/native-stub.ts
+import { v7 as uuidv73 } from "uuid";
 import {
   EVT_PAYMENT_CAPTURED,
   EVT_PAYMENT_FAILED,
   EVT_PAYMENT_REFUNDED,
   PaymentError
 } from "@nymbalhq/types";
-function toIsoCurrency(currency) {
-  return currency.toUpperCase();
-}
-function mapStatus(status) {
-  switch (status) {
-    case "requires_payment_method":
-    case "requires_confirmation":
-    case "requires_action":
-    case "processing":
-    case "requires_capture":
-    case "succeeded":
-    case "canceled":
-      return status === "canceled" ? "cancelled" : status;
-    default:
-      return "failed";
-  }
-}
-function refundStatus(status) {
-  if (status === "succeeded") return "succeeded";
-  if (status === "failed" || status === "canceled") return "failed";
-  return "pending";
-}
-function isDefiniteRefusal(err) {
-  const type = err?.type;
-  return type === "StripeCardError" || type === "StripeInvalidRequestError";
-}
-function toIntent(intent) {
-  return {
-    id: intent.id,
-    clientSecret: intent.client_secret ?? "",
-    amountMinor: intent.amount,
-    currency: toIsoCurrency(intent.currency),
-    status: mapStatus(intent.status)
-  };
-}
-function createStripePaymentsAdapter(deps) {
-  const { logger } = deps;
-  const cfg = deps.config;
-  if (!cfg.secretKey) throw new PaymentError("not_configured", "Stripe secretKey missing");
-  if (!cfg.webhookSecret) throw new PaymentError("not_configured", "Stripe webhookSecret missing");
-  const stripeClient = new Stripe(cfg.secretKey, {
-    ...cfg.apiVersion !== void 0 && {
-      apiVersion: cfg.apiVersion
-    },
-    ...cfg.host !== void 0 && { host: cfg.host },
-    ...cfg.port !== void 0 && { port: cfg.port },
-    ...cfg.protocol !== void 0 && { protocol: cfg.protocol }
-  });
-  return {
-    kind: "payments",
-    providerName: "stripe",
-    capabilities: ["intent", "capture", "refund", "webhook"],
-    producesEvents: [EVT_PAYMENT_CAPTURED, EVT_PAYMENT_FAILED, EVT_PAYMENT_REFUNDED],
-    consumesEvents: [],
-    async initialize() {
-    },
-    async healthCheck() {
-      try {
-        await stripeClient.balance.retrieve();
-        return { status: "healthy" };
-      } catch (err) {
-        return {
-          status: "down",
-          detail: err instanceof Error ? err.message : String(err)
-        };
-      }
-    },
-    async createPaymentIntent(params) {
-      try {
-        const intent = await stripeClient.paymentIntents.create({
-          amount: params.amountMinor,
-          currency: params.currency.toLowerCase(),
-          automatic_payment_methods: { enabled: true },
-          ...params.receiptEmail !== void 0 && { receipt_email: params.receiptEmail },
-          metadata: {
-            ...params.metadata ?? {},
-            ...params.orderRef !== void 0 ? { orderRef: params.orderRef } : {},
-            ...params.customerId !== void 0 ? { customerId: params.customerId } : {}
-          }
-        });
-        return toIntent(intent);
-      } catch (err) {
-        throw new PaymentError("intent_failed", "Stripe createPaymentIntent failed", { cause: err });
-      }
-    },
-    async capturePayment(intentId, amountMinor) {
-      try {
-        const captured = await stripeClient.paymentIntents.capture(intentId, {
-          ...amountMinor !== void 0 && { amount_to_capture: amountMinor }
-        });
-        return {
-          paymentId: captured.id,
-          capturedAmountMinor: captured.amount_received ?? captured.amount,
-          currency: toIsoCurrency(captured.currency),
-          status: mapStatus(captured.status)
-        };
-      } catch (err) {
-        throw new PaymentError("capture_failed", "Stripe capturePayment failed", { cause: err });
-      }
-    },
-    async refund(paymentId, amountMinor, reason, opts) {
-      const params = {
-        payment_intent: paymentId,
-        ...amountMinor !== void 0 && { amount: amountMinor },
-        ...reason !== void 0 && { reason }
-      };
-      try {
-        const refund = opts?.idempotencyKey === void 0 ? await stripeClient.refunds.create(params) : await stripeClient.refunds.create(params, { idempotencyKey: opts.idempotencyKey });
-        return {
-          refundId: refund.id,
-          paymentId,
-          amountMinor: refund.amount,
-          currency: toIsoCurrency(refund.currency),
-          reason: refund.reason ?? null,
-          status: refundStatus(refund.status)
-        };
-      } catch (err) {
-        if (isDefiniteRefusal(err)) {
-          throw new PaymentError("refund_rejected", "Stripe refused the refund", { cause: err });
-        }
-        throw new PaymentError("refund_unknown", "Stripe refund outcome unknown", { cause: err });
-      }
-    },
-    async getPaymentStatus(intentId) {
-      const intent = await stripeClient.paymentIntents.retrieve(intentId);
-      return mapStatus(intent.status);
-    },
-    async getPaymentIntent(intentId) {
-      try {
-        return toIntent(await stripeClient.paymentIntents.retrieve(intentId));
-      } catch (err) {
-        throw new PaymentError("intent_failed", "Stripe getPaymentIntent failed", { cause: err });
-      }
-    },
-    async cancelPaymentIntent(intentId) {
-      try {
-        await stripeClient.paymentIntents.cancel(intentId);
-      } catch (err) {
-        const status = await stripeClient.paymentIntents.retrieve(intentId).then((intent) => intent.status).catch(() => void 0);
-        if (status === "canceled") return;
-        throw new PaymentError("cancel_refused", `Stripe would not cancel ${intentId}`, {
-          cause: err
-        });
-      }
-    },
-    async parseWebhook(rawBody, signature) {
-      let event;
-      try {
-        event = stripeClient.webhooks.constructEvent(rawBody, signature, cfg.webhookSecret);
-      } catch (err) {
-        throw new PaymentError("webhook_invalid", "Stripe webhook signature invalid", {
-          cause: err
-        });
-      }
-      const baseResult = { verified: true, eventId: event.id };
-      switch (event.type) {
-        case "payment_intent.succeeded": {
-          const intent = event.data.object;
-          return {
-            ...baseResult,
-            kind: "payment.captured",
-            paymentIntentId: intent.id,
-            amountMinor: intent.amount_received ?? intent.amount,
-            currency: toIsoCurrency(intent.currency),
-            raw: { ...intent }
-          };
-        }
-        case "payment_intent.payment_failed": {
-          const intent = event.data.object;
-          return {
-            ...baseResult,
-            kind: "payment.failed",
-            paymentIntentId: intent.id,
-            reason: intent.last_payment_error?.message ?? "payment failed"
-          };
-        }
-        case "charge.refunded": {
-          const charge = event.data.object;
-          const pi = typeof charge.payment_intent === "string" ? charge.payment_intent : charge.payment_intent?.id;
-          return {
-            ...baseResult,
-            kind: "payment.refunded",
-            ...pi !== void 0 && { paymentIntentId: pi },
-            amountMinor: charge.amount_refunded,
-            currency: toIsoCurrency(charge.currency)
-          };
-        }
-        default:
-          logger.debug({ type: event.type }, "stripe webhook ignored");
-          return { ...baseResult, kind: "ignored" };
-      }
-    }
-  };
-}
-
-// src/adapters/payments/native-stub.ts
-import { v7 as uuidv73 } from "uuid";
-import {
-  EVT_PAYMENT_CAPTURED as EVT_PAYMENT_CAPTURED2,
-  EVT_PAYMENT_FAILED as EVT_PAYMENT_FAILED2,
-  EVT_PAYMENT_REFUNDED as EVT_PAYMENT_REFUNDED2,
-  PaymentError as PaymentError2
-} from "@nymbalhq/types";
 var STUB_ID_PREFIX = "pi_stub_";
 function rejected(message) {
-  return new PaymentError2("refund_rejected", message);
+  return new PaymentError("refund_rejected", message);
 }
 function statusFor(receiptEmail) {
   const address = receiptEmail ?? "";
@@ -3448,7 +3256,7 @@ function statusFor(receiptEmail) {
   if (local.endsWith("+stub-decline")) return "failed";
   return "succeeded";
 }
-function toIntent2(intent) {
+function toIntent(intent) {
   return {
     id: intent.id,
     clientSecret: `${intent.id}_secret`,
@@ -3463,8 +3271,9 @@ function createNativeStubPaymentsAdapter(deps) {
   return {
     kind: "payments",
     providerName: "native-stub",
-    capabilities: ["intent", "capture", "refund", "webhook"],
-    producesEvents: [EVT_PAYMENT_CAPTURED2, EVT_PAYMENT_FAILED2, EVT_PAYMENT_REFUNDED2],
+    // No `webhook`: parseWebhook verifies no signature, so a template cannot rely on it.
+    capabilities: () => ["intent", "capture", "refund"],
+    producesEvents: [EVT_PAYMENT_CAPTURED, EVT_PAYMENT_FAILED, EVT_PAYMENT_REFUNDED],
     consumesEvents: [],
     initialize: noopInitialize,
     healthCheck: () => okHealth("stub \u2014 always healthy"),
@@ -3480,11 +3289,11 @@ function createNativeStubPaymentsAdapter(deps) {
       };
       intents.set(id, intent);
       logger.debug({ intentId: id, status: intent.status }, "stub payment intent created");
-      return toIntent2(intent);
+      return toIntent(intent);
     },
     async capturePayment(intentId) {
       const intent = intents.get(intentId);
-      if (!intent) throw new PaymentError2("capture_failed", `unknown intent ${intentId}`);
+      if (!intent) throw new PaymentError("capture_failed", `unknown intent ${intentId}`);
       intent.status = "succeeded";
       return {
         paymentId: intent.id,
@@ -3524,14 +3333,14 @@ function createNativeStubPaymentsAdapter(deps) {
     },
     async getPaymentIntent(intentId) {
       const intent = intents.get(intentId);
-      if (!intent) throw new PaymentError2("intent_failed", `unknown intent ${intentId}`);
-      return toIntent2(intent);
+      if (!intent) throw new PaymentError("intent_failed", `unknown intent ${intentId}`);
+      return toIntent(intent);
     },
     async cancelPaymentIntent(intentId) {
       const intent = intents.get(intentId);
       if (!intent) return;
       if (intent.status === "succeeded") {
-        throw new PaymentError2("cancel_refused", `intent ${intentId} is already captured`);
+        throw new PaymentError("cancel_refused", `intent ${intentId} is already captured`);
       }
       intent.status = "cancelled";
     },
@@ -3550,142 +3359,33 @@ function createNativeStubPaymentsAdapter(deps) {
           ...event.currency !== void 0 && { currency: event.currency }
         };
       } catch (err) {
-        throw new PaymentError2("webhook_invalid", "stub webhook body not JSON", { cause: err });
+        throw new PaymentError("webhook_invalid", "stub webhook body not JSON", { cause: err });
       }
     }
   };
 }
 
 // src/adapters/email/native-email-adapter.ts
-import nodemailer from "nodemailer";
 import {
-  AdapterError as AdapterError3,
   EVT_CART_ABANDONED as EVT_CART_ABANDONED2,
   EVT_CUSTOMER_CREATED as EVT_CUSTOMER_CREATED3,
   EVT_ORDER_PLACED as EVT_ORDER_PLACED2,
-  EVT_ORDER_SHIPPED as EVT_ORDER_SHIPPED3
+  EVT_ORDER_SHIPPED as EVT_ORDER_SHIPPED3,
+  renderEmailTemplate
 } from "@nymbalhq/types";
-
-// src/adapters/email/templates.ts
-function render(template, vars) {
-  return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_, path) => {
-    const parts = path.split(".");
-    let cur = vars;
-    for (const p of parts) {
-      if (cur && typeof cur === "object" && p in cur) {
-        cur = cur[p];
-      } else {
-        return "";
-      }
-    }
-    return cur == null ? "" : String(cur);
-  });
-}
-var TEMPLATES = {
-  "order-placed": {
-    subject: "Order {{orderNumber}} confirmed",
-    body: `Hi {{customerName}},
-
-Thank you for your order {{orderNumber}}. Total: {{totalFormatted}}.
-
-We'll let you know when it ships.`
-  },
-  "order-shipped": {
-    subject: "Order {{orderNumber}} is on its way",
-    body: `Hi {{customerName}},
-
-Your order {{orderNumber}} has shipped via {{carrier}}.
-Tracking: {{trackingNumber}}`
-  },
-  welcome: {
-    subject: "Welcome to {{storeName}}",
-    body: `Welcome {{customerName}}! Your account is ready.`
-  },
-  "cart-abandoned": {
-    subject: "Don't forget your cart at {{storeName}}",
-    body: `Hi,
-
-You left items in your cart. Pick up where you left off: {{resumeUrl}}`
-  }
-};
-function renderTemplate(template, vars) {
-  const t = TEMPLATES[template];
-  if (!t) {
-    return {
-      subject: `[nymbal] ${template}`,
-      text: JSON.stringify(vars),
-      html: `<pre>${JSON.stringify(vars, null, 2)}</pre>`
-    };
-  }
-  const subject = render(t.subject, vars);
-  const text = render(t.body, vars);
-  const html = `<pre>${text.replace(/</g, "&lt;")}</pre>`;
-  return { subject, text, html };
-}
-
-// src/adapters/email/native-email-adapter.ts
 function createNativeEmailAdapter(deps) {
   const log = deps.logger.child({ adapter: "email", provider: "native" });
-  let cfg = deps.config ?? { transport: "console" };
-  let transporter = null;
-  function ensureTransport() {
-    if (cfg.transport !== "smtp") return;
-    if (transporter) return;
-    if (!cfg.smtp) {
-      throw new AdapterError3("email.misconfigured", "SMTP transport selected but smtp.host not set");
-    }
-    transporter = nodemailer.createTransport({
-      host: cfg.smtp.host,
-      port: cfg.smtp.port,
-      secure: cfg.smtp.secure ?? cfg.smtp.port === 465,
-      ...cfg.smtp.user !== void 0 && cfg.smtp.pass !== void 0 ? { auth: { user: cfg.smtp.user, pass: cfg.smtp.pass } } : {}
-    });
-  }
   return {
     kind: "email",
     providerName: "native",
-    capabilities: ["transactional", "list-sync"],
+    capabilities: () => ["transactional", "list-sync"],
     producesEvents: [],
-    consumesEvents: [
-      EVT_ORDER_PLACED2,
-      EVT_ORDER_SHIPPED3,
-      EVT_CUSTOMER_CREATED3,
-      EVT_CART_ABANDONED2
-    ],
-    async initialize(rawConfig) {
-      cfg = { ...cfg, ...rawConfig };
-      if (cfg.transport === "smtp") ensureTransport();
-    },
-    async healthCheck() {
-      if (cfg.transport === "smtp" && transporter) {
-        try {
-          await transporter.verify();
-          return { status: "healthy", detail: "SMTP verified" };
-        } catch (err) {
-          return {
-            status: "degraded",
-            detail: `SMTP verify failed: ${err instanceof Error ? err.message : String(err)}`
-          };
-        }
-      }
-      return okHealth("console transport");
+    consumesEvents: [EVT_ORDER_PLACED2, EVT_ORDER_SHIPPED3, EVT_CUSTOMER_CREATED3, EVT_CART_ABANDONED2],
+    async initialize() {
     },
+    healthCheck: () => okHealth("console transport"),
     async sendTransactional(params) {
-      const rendered = renderTemplate(params.template, params.vars);
-      if (cfg.transport === "smtp") {
-        ensureTransport();
-        if (!transporter) {
-          throw new AdapterError3("email.transport_missing", "SMTP transport not initialised");
-        }
-        const info = await transporter.sendMail({
-          from: cfg.from ?? "no-reply@nymbal.dev",
-          to: params.to,
-          subject: rendered.subject,
-          text: rendered.text,
-          html: rendered.html
-        });
-        return { messageId: info.messageId ?? null, accepted: (info.accepted ?? []).length > 0 };
-      }
+      const rendered = renderEmailTemplate(params.template, params.vars);
       log.info(
         { to: params.to, subject: rendered.subject, template: params.template },
         "email.sent (console)"
@@ -3725,7 +3425,7 @@ function createNativeSearchAdapter(deps) {
   return {
     kind: "search",
     providerName: "native",
-    capabilities: ["index", "search", "facet"],
+    capabilities: () => ["index", "search", "facet"],
     producesEvents: [],
     consumesEvents: [EVT_PRODUCT_CREATED3, EVT_PRODUCT_UPDATED3, EVT_PRODUCT_DELETED3],
     initialize: noopInitialize,
@@ -3810,7 +3510,7 @@ function createNativeReviewsAdapter(deps) {
   return {
     kind: "reviews",
     providerName: "native",
-    capabilities: ["submit", "moderate", "aggregate"],
+    capabilities: () => ["submit", "moderate", "aggregate"],
     producesEvents: [],
     consumesEvents: [EVT_ORDER_DELIVERED3],
     initialize: noopInitialize,
@@ -3860,7 +3560,7 @@ function createNativeAnalyticsAdapter(logger) {
   return {
     kind: "analytics",
     providerName: "native",
-    capabilities: ["track", "identify"],
+    capabilities: () => ["track", "identify"],
     producesEvents: [],
     consumesEvents: [],
     initialize: noopInitialize,
@@ -3880,7 +3580,7 @@ function createNativeShippingAdapter(logger) {
   return {
     kind: "shipping",
     providerName: "native",
-    capabilities: ["flat-rate"],
+    capabilities: () => ["flat-rate"],
     producesEvents: [],
     consumesEvents: [],
     initialize: noopInitialize,
@@ -3919,7 +3619,7 @@ function createNativeTaxAdapter(logger, defaultRate = 0) {
   return {
     kind: "tax",
     providerName: "native",
-    capabilities: ["flat-rate"],
+    capabilities: () => ["flat-rate"],
     producesEvents: [],
     consumesEvents: [],
     initialize: noopInitialize,
@@ -3935,97 +3635,170 @@ function createNativeTaxAdapter(logger, defaultRate = 0) {
   };
 }
 
-// src/adapters/ai/native-adapter.ts
-import { AdapterError as AdapterError4 } from "@nymbalhq/types";
-function createNativeAiAdapter(_logger) {
-  return {
-    kind: "ai",
-    providerName: "native",
-    capabilities: [],
-    producesEvents: [],
-    consumesEvents: [],
-    initialize: noopInitialize,
-    healthCheck: () => okHealth("AI adapter is stubbed \u2014 configure a real provider for v1.0"),
-    async embed() {
-      throw new AdapterError4("not_configured", "AI embedding is not configured in v0.1");
-    },
-    async complete() {
-      throw new AdapterError4("not_configured", "AI completion is not configured in v0.1");
-    }
-  };
+// src/adapters/loader.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { ConfigError as ConfigError4 } from "@nymbalhq/types";
+var PROVIDER_PACKAGES = {
+  payments: { stripe: { package: "@nymbalhq/adapter-stripe", sdk: "stripe" } },
+  ai: { anthropic: { package: "@nymbalhq/adapter-anthropic", sdk: "@anthropic-ai/sdk" } },
+  email: { smtp: { package: "@nymbalhq/adapter-smtp", sdk: "nodemailer" } }
+};
+var INSTALL_VERBS = {
+  npm: "npm install",
+  pnpm: "pnpm add",
+  yarn: "yarn add",
+  bun: "bun add"
+};
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+];
+function packageManager(env, cwd) {
+  const agent = env["npm_config_user_agent"]?.split("/")[0];
+  if (agent !== void 0 && agent in INSTALL_VERBS) return agent;
+  for (const [file, pm] of LOCKFILES) {
+    if (existsSync(join2(cwd, file))) return pm;
+  }
+  return "npm";
 }
-
-// src/adapters/ai/anthropic-adapter.ts
-import Anthropic from "@anthropic-ai/sdk";
-import { AdapterError as AdapterError5 } from "@nymbalhq/types";
-function createAnthropicAiAdapter(config) {
-  const model = config.model ?? "claude-sonnet-4-6";
-  const client = new Anthropic({ apiKey: config.apiKey });
-  return {
-    kind: "ai",
-    providerName: "anthropic",
-    capabilities: ["complete"],
-    producesEvents: [],
-    consumesEvents: [],
-    initialize: noopInitialize,
-    healthCheck: () => okHealth(`Anthropic AI adapter using model ${model}`),
-    async embed() {
-      throw new AdapterError5("not_configured", "Embedding not yet supported by the Anthropic adapter");
-    },
-    async complete(prompt, opts) {
-      const maxTokens = opts?.maxTokens ?? 1024;
-      const message = await client.messages.create({
-        model,
-        max_tokens: maxTokens,
-        messages: [{ role: "user", content: prompt }]
-      });
-      const block = message.content[0];
-      if (!block || block.type !== "text") {
-        throw new AdapterError5("unexpected_response", "Anthropic returned no text content");
-      }
-      return block.text;
-    }
-  };
+function packageOf(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function missingPackage(error) {
+  if (error?.code !== "ERR_MODULE_NOT_FOUND") return null;
+  const match = /Cannot find (?:package|module) '([^']+)'/.exec(String(error.message));
+  return match?.[1] === void 0 ? null : packageOf(match[1]);
+}
+async function loadProviderAdapter(slot, provider, ctx) {
+  const entry = PROVIDER_PACKAGES[slot]?.[provider];
+  if (entry === void 0) return void 0;
+  let mod;
+  try {
+    mod = await import(entry.package);
+  } catch (error) {
+    const missing = missingPackage(error);
+    if (missing !== entry.package && missing !== entry.sdk) throw error;
+    const install = `${INSTALL_VERBS[packageManager(ctx.env, process.cwd())]} ${entry.package} ${entry.sdk}`;
+    throw new ConfigError4(`${slot}.provider '${provider}' needs ${entry.package}: ${install}`, {
+      code: "adapter.package_missing",
+      cause: error,
+      context: { slot, provider, missing, install }
+    });
+  }
+  if (typeof mod.createAdapter !== "function") {
+    throw new ConfigError4(`${entry.package} exports no createAdapter(ctx)`, {
+      code: "adapter.package_invalid",
+      context: { slot, provider, package: entry.package }
+    });
+  }
+  return mod.createAdapter({ ...ctx, slot });
 }
 
 // src/adapters/registry.ts
-function paymentsAdapterFor(provider) {
-  return provider === "stripe" ? "stripe" : "native-stub";
+var COMMERCE_SLOTS = [
+  "payments",
+  "email",
+  "reviews",
+  "search",
+  "analytics",
+  "shipping",
+  "tax",
+  "ai"
+];
+function checkInjectedAdapters(config, injected = {}) {
+  for (const slot of COMMERCE_SLOTS) {
+    const provider = config.commerce[slot].provider;
+    const given = injected[slot] !== void 0;
+    if (provider === "custom" && !given) {
+      throw new ConfigError5(
+        `commerce.${slot}.provider is 'custom' but createApp was given no ${slot} adapter (createApp(config, { adapters: { ${slot} } })). nymbal dev and nymbal start cannot inject one yet: run the app from an entry of your own that calls createApp.`,
+        { code: "adapter.custom_mismatch", context: { slot } }
+      );
+    }
+    if (provider !== "custom" && given) {
+      throw new ConfigError5(
+        `createApp was given a ${slot} adapter, but commerce.${slot}.provider is '${provider}'; set it to 'custom' to use the injected adapter.`,
+        { code: "adapter.custom_mismatch", context: { slot, provider } }
+      );
+    }
+  }
+}
+async function resolveSlot(slot, config, logger, injected, builtIns) {
+  const block = config.commerce[slot];
+  const blockConfig = block.config ?? {};
+  let adapter;
+  if (block.provider === "custom") {
+    adapter = injected[slot];
+  } else {
+    adapter = await loadProviderAdapter(slot, block.provider, {
+      config: blockConfig,
+      logger: logger.child({ adapter: slot }),
+      env: process.env
+    });
+    if (adapter === void 0 && Object.hasOwn(builtIns, block.provider)) {
+      adapter = builtIns[block.provider]();
+    }
+  }
+  if (adapter === void 0) {
+    throw new ConfigError5(`commerce.${slot}.provider '${block.provider}' has no adapter`, {
+      context: { slot, provider: block.provider }
+    });
+  }
+  await adapter?.initialize(blockConfig);
+  return adapter;
+}
+function resolvePaymentsAdapter(config, logger, injected = {}) {
+  return resolveSlot("payments", config, logger, injected, {
+    native: () => createNativeStubPaymentsAdapter({ logger: logger.child({ adapter: "payments" }) })
+  });
 }
 async function buildAdapters(deps) {
-  const { config, logger, documentStore, repos } = deps;
-  const payments = paymentsAdapterFor(config.commerce.payments.provider) === "stripe" ? createStripePaymentsAdapter({
-    logger: logger.child({ adapter: "payments" }),
-    config: config.commerce.payments.config ?? {}
-  }) : createNativeStubPaymentsAdapter({ logger: logger.child({ adapter: "payments" }) });
-  const email = createNativeEmailAdapter({
-    logger: logger.child({ adapter: "email" }),
-    config: config.commerce.email.config ?? {}
+  const { config, logger, documentStore, repos, payments } = deps;
+  const injected = deps.injected ?? {};
+  const slot = (name, builtIns) => resolveSlot(name, config, logger, injected, builtIns);
+  const email = await slot("email", {
+    native: () => createNativeEmailAdapter({ logger: logger.child({ adapter: "email" }) })
   });
-  await email.initialize(email ? config.commerce.email.config ?? {} : {});
-  const search = createNativeSearchAdapter({
-    documentStore,
-    logger: logger.child({ adapter: "search" })
+  const search = await slot("search", {
+    native: () => createNativeSearchAdapter({ documentStore, logger: logger.child({ adapter: "search" }) })
   });
-  const reviews3 = createNativeReviewsAdapter({
-    repos,
-    logger: logger.child({ adapter: "reviews" })
+  const reviews3 = await slot("reviews", {
+    native: () => createNativeReviewsAdapter({ repos, logger: logger.child({ adapter: "reviews" }) })
   });
-  const analytics = createNativeAnalyticsAdapter(logger);
-  const shipping = createNativeShippingAdapter(logger);
-  const tax = createNativeTaxAdapter(logger);
-  const aiProvider = config.commerce.ai?.provider;
-  const ai = aiProvider === "anthropic" ? createAnthropicAiAdapter({
-    apiKey: process.env["ANTHROPIC_API_KEY"] ?? "",
-    model: config.commerce.ai?.config?.["model"] ?? "claude-sonnet-4-6",
-    logger: logger.child({ adapter: "ai" })
-  }) : createNativeAiAdapter(logger);
+  const analytics = await slot("analytics", { native: () => createNativeAnalyticsAdapter(logger) });
+  const shipping = await slot("shipping", { native: () => createNativeShippingAdapter(logger) });
+  const tax = await slot("tax", { native: () => createNativeTaxAdapter(logger) });
+  const ai = await slot("ai", { none: () => null });
   const security = createMiddlewareSecurityAdapter({
     logger: logger.child({ adapter: "security" })
   });
   return { security, payments, email, search, reviews: reviews3, analytics, shipping, tax, ai };
 }
 
+// src/media/local-fs-storage.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+var LOCAL_FS_MEDIA_CAPABILITIES = ["put"];
+function createLocalFsMediaStorage(options) {
+  const { root } = options;
+  const urlPrefix = options.urlPrefix ?? "/imported-media";
+  return {
+    capabilities: () => LOCAL_FS_MEDIA_CAPABILITIES,
+    async put(key, body, _contentType) {
+      const dest = join3(root, key);
+      const dir = dest.substring(0, dest.lastIndexOf("/"));
+      await mkdir(dir, { recursive: true });
+      await writeFile(dest, body);
+      return { url: `${urlPrefix}/${key}` };
+    }
+  };
+}
+
 // src/services/product-service.ts
 import { v7 as uuidv75 } from "uuid";
 import {
@@ -4926,7 +4699,7 @@ function createOrderService(deps) {
 // src/services/inventory-service.ts
 import { v7 as uuidv711 } from "uuid";
 import {
-  AdapterError as AdapterError6,
+  AdapterError as AdapterError3,
   NotFoundError as NotFoundError6,
   ValidationError as ValidationError9,
   EVT_INVENTORY_CHANGED as EVT_INVENTORY_CHANGED2,
@@ -5025,7 +4798,7 @@ function createInventoryService(deps) {
     async reserveStock(variantId, qty, orderRef = null, ttlSeconds) {
       const taken = await take(variantId, qty, orderRef, ttlSeconds);
       if ("available" in taken) {
-        throw new AdapterError6(
+        throw new AdapterError3(
           "inventory.insufficient",
           `Insufficient stock for variant ${variantId}`,
           {
@@ -5126,12 +4899,12 @@ import {
   EVT_CART_CONVERTED,
   EVT_CART_UPDATED as EVT_CART_UPDATED2,
   EVT_ORDER_PAID as EVT_ORDER_PAID4,
-  EVT_PAYMENT_CAPTURED as EVT_PAYMENT_CAPTURED3,
-  EVT_PAYMENT_FAILED as EVT_PAYMENT_FAILED3,
-  EVT_PAYMENT_REFUNDED as EVT_PAYMENT_REFUNDED3,
+  EVT_PAYMENT_CAPTURED as EVT_PAYMENT_CAPTURED2,
+  EVT_PAYMENT_FAILED as EVT_PAYMENT_FAILED2,
+  EVT_PAYMENT_REFUNDED as EVT_PAYMENT_REFUNDED2,
   NotFoundError as NotFoundError7,
   OrderConflictError as OrderConflictError2,
-  PaymentError as PaymentError3,
+  PaymentError as PaymentError2,
   StatusTransitionError as StatusTransitionError2
 } from "@nymbalhq/types";
 var StockUnavailable = class extends Error {
@@ -5203,7 +4976,7 @@ function createCheckoutService(deps) {
     return recordOutcome(tx, paymentIntentId, order, `order_not_pending: ${order.status}`);
   }
   async function recordOutcome(tx, paymentIntentId, order, reason, detail) {
-    await publisher.publish(EVT_PAYMENT_FAILED3, {
+    await publisher.publish(EVT_PAYMENT_FAILED2, {
       paymentId: paymentIntentId,
       orderId: order?.id ?? "",
       reason
@@ -5259,7 +5032,7 @@ function createCheckoutService(deps) {
       }
       return settlement;
     } catch (err) {
-      if (err instanceof PaymentError3 && err.code === "payment.refund_rejected") {
+      if (err instanceof PaymentError2 && err.code === "payment.refund_rejected") {
         logger.error({ ...context2, err }, "provider refused the refund of a capture");
         return { status: "failed", providerRefundId: null, mismatch: false };
       }
@@ -5308,7 +5081,7 @@ function createCheckoutService(deps) {
       });
       await refreshRefunded(repos, tx, order.id, /* @__PURE__ */ new Date());
       if (settlement.status === "succeeded") {
-        await publisher.publish(EVT_PAYMENT_REFUNDED3, {
+        await publisher.publish(EVT_PAYMENT_REFUNDED2, {
           paymentId: paymentIntentId,
           orderId: order.id,
           refundId,
@@ -5383,7 +5156,7 @@ function createCheckoutService(deps) {
     if (order.customerId) {
       await repos.customer.incrementStats(tx, order.customerId, 1, paid.amountMinor, now);
     }
-    await publisher.publish(EVT_PAYMENT_CAPTURED3, {
+    await publisher.publish(EVT_PAYMENT_CAPTURED2, {
       paymentId: paymentIntentId,
       orderId: order.id,
       amountMinor: paid.amountMinor,
@@ -5525,7 +5298,7 @@ function createCheckoutService(deps) {
     try {
       await payments.cancelPaymentIntent(order.paymentIntentId);
     } catch (err) {
-      if (!(err instanceof PaymentError3 && err.code === "payment.cancel_refused")) throw err;
+      if (!(err instanceof PaymentError2 && err.code === "payment.cancel_refused")) throw err;
       throw new CheckoutError(
         "payment_in_progress",
         `The payment for order ${order.orderNumber} is already under way`,
@@ -5565,7 +5338,7 @@ function createCheckoutService(deps) {
       } else if (outcome === "failed") {
         const reason = `payment_${intent.status}`;
         await cancelDraft(order.id, reason);
-        await publisher.publish(EVT_PAYMENT_FAILED3, {
+        await publisher.publish(EVT_PAYMENT_FAILED2, {
           paymentId: intent.id,
           orderId: order.id,
           reason
@@ -5662,7 +5435,7 @@ function createCheckoutService(deps) {
         try {
           await payments.cancelPaymentIntent(found.paymentIntentId);
         } catch (err) {
-          if (!(err instanceof PaymentError3 && err.code === "payment.cancel_refused")) throw err;
+          if (!(err instanceof PaymentError2 && err.code === "payment.cancel_refused")) throw err;
           throw new OrderConflictError2(
             "order.payment_in_progress",
             `The payment for order ${found.orderNumber} is under way with the provider`,
@@ -5960,33 +5733,38 @@ function startEventRetentionSweeper(deps) {
 }
 
 // src/app.ts
-function refuseUnsafeProduction(config) {
+function refuseUnsafeProduction(config, payments) {
   if (process.env.NODE_ENV !== "production") return;
   const provider = config.commerce.payments.provider;
-  if (paymentsAdapterFor(provider) === "native-stub") {
-    throw new ConfigError4(
+  if (payments.providerName === "native-stub") {
+    throw new ConfigError6(
       `Payments provider "${provider}" resolves to the stub adapter, which verifies no webhook signature; configure a real payments provider for production.`,
       { code: "config.production_stub_payments", context: { provider } }
     );
   }
   if (config.security.auth.jwtSecret === DEFAULT_JWT_SECRET) {
-    throw new ConfigError4(
+    throw new ConfigError6(
       "security.auth.jwtSecret is the schema default; set a secret of your own for production.",
       { code: "config.production_default_jwt_secret" }
     );
   }
 }
 async function createApp(config, options = {}) {
-  refuseUnsafeProduction(config);
-  const platform = createPlatform(config, options);
+  const logger = options.logger ?? createLogger({ base: { store: config.store.name } });
+  const adapterLogger = logger.child({ layer: "adapter" });
+  checkInjectedAdapters(config, options.adapters);
+  const payments = await resolvePaymentsAdapter(config, adapterLogger, options.adapters);
+  refuseUnsafeProduction(config, payments);
+  const platform = createPlatform(config, { ...options, logger });
   const version = options.version ?? "0.1.0";
-  const logger = platform.logger;
   const repos = buildRepositories(platform.commandStore, platform.documentStore);
   const adapters = await buildAdapters({
     config,
-    logger: logger.child({ layer: "adapter" }),
+    logger: adapterLogger,
     documentStore: platform.documentStore,
-    repos
+    repos,
+    payments,
+    ...options.adapters !== void 0 && { injected: options.adapters }
   });
   const relay = createRelay({
     store: platform.commandStore,
@@ -6073,6 +5851,37 @@ async function createApp(config, options = {}) {
         adminRoot: options2.adminRoot !== void 0 ? options2.adminRoot : process.env["NYMBAL_ADMIN_DIST"]
       });
     },
+    capabilities() {
+      const commerce = Object.fromEntries(
+        COMMERCE_SLOTS.map((slot) => {
+          const adapter = adapters[slot];
+          return [
+            slot,
+            {
+              provider: config.commerce[slot].provider,
+              capabilities: adapter === null ? [] : adapter.capabilities()
+            }
+          ];
+        })
+      );
+      return {
+        ...commerce,
+        security: {
+          provider: config.security.adapter,
+          capabilities: adapters.security.capabilities()
+        },
+        documentStore: {
+          provider: config.infrastructure.documentStore,
+          capabilities: platform.documentStore.capabilities()
+        },
+        eventBus: {
+          provider: config.infrastructure.eventBus,
+          capabilities: platform.eventBus.capabilities()
+        },
+        // The kernel ships one media storage, on the local filesystem; the importer creates it per run.
+        media: { provider: "local-fs", capabilities: LOCAL_FS_MEDIA_CAPABILITIES }
+      };
+    },
     async stop() {
       await relay.stop();
       for (const s of sweepers) s.stop();
@@ -6141,6 +5950,26 @@ function compilePathPattern(pattern) {
   return new RegExp(`^${escaped}$`);
 }
 
+// src/adapters/ai/native-adapter.ts
+import { AdapterError as AdapterError4 } from "@nymbalhq/types";
+function createNativeAiAdapter(_logger) {
+  return {
+    kind: "ai",
+    providerName: "native",
+    capabilities: () => [],
+    producesEvents: [],
+    consumesEvents: [],
+    initialize: noopInitialize,
+    healthCheck: () => okHealth("AI adapter is stubbed \u2014 configure a real provider for v1.0"),
+    async embed() {
+      throw new AdapterError4("not_configured", "AI embedding is not configured in v0.1");
+    },
+    async complete() {
+      throw new AdapterError4("not_configured", "AI completion is not configured in v0.1");
+    }
+  };
+}
+
 // src/seed/run.ts
 import { inArray as inArray3 } from "drizzle-orm";
 import { v7 as uuidv713 } from "uuid";
@@ -6553,35 +6382,18 @@ async function runSeed(deps) {
     alreadySeeded: false
   };
 }
-
-// src/media/local-fs-storage.ts
-import { mkdir, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-function createLocalFsMediaStorage(options) {
-  const { root } = options;
-  const urlPrefix = options.urlPrefix ?? "/imported-media";
-  return {
-    async put(key, body, _contentType) {
-      const dest = join2(root, key);
-      const dir = dest.substring(0, dest.lastIndexOf("/"));
-      await mkdir(dir, { recursive: true });
-      await writeFile(dest, body);
-      return { url: `${urlPrefix}/${key}` };
-    }
-  };
-}
 export {
   CSRF_COOKIE,
   CSRF_HEADER,
   InMemoryDocumentStore,
   InProcessEventBus,
+  PROVIDER_PACKAGES,
   PROVIDER_REFUND_REASON,
   RateLimiter,
   buildAdapters,
   buildRepositories,
   buildSecurityHeaders,
   buildServices,
-  createAnthropicAiAdapter,
   createApp,
   createAuthService,
   createCartRepository,
@@ -6628,10 +6440,8 @@ export {
   createReviewRepository,
   createSearchService,
   createStockAdjustmentRepository,
-  createStripePaymentsAdapter,
   createVariantRepository,
   orderPayment,
-  paymentsAdapterFor,
   rawClients,
   refreshRefunded,
   registerAdminStaticRoute,