@alfredmouelle/create-stack 0.1.2 → 0.2.0

package/README.md

@@ -4,9 +4,10 @@
 
 Interactive, **deterministic** project installer. It forks a fully-wired base app
 (**Next.js App Router** or **TanStack Start**) and strips it down to exactly the
-foundations and provider you pick — Drizzle, tRPC, better-auth, data tables and a
-mailer — then stamps identity, generates `.env`, initializes git and verifies the
-result (typecheck + Biome).
+foundations and provider you pick — Drizzle, tRPC, better-auth, data tables, a
+mailer and optional capabilities (storage, cache, jobs, logger, analytics,
+error-tracking) — then stamps identity, generates `.env`, initializes git and
+verifies the result (typecheck + Biome).
 
 No template guesswork: the output is a real, buildable app from day one.
 
@@ -46,12 +47,20 @@ not exist yet. In non-interactive mode it is required.
 | `--framework` | `tanstack` \| `next` | `tanstack` | Base app to fork. |
 | `--foundations` | csv of `drizzle,trpc,better-auth,data-table` | all | Foundations to keep; the rest are stripped. |
 | `--mailer` | `resend` \| `brevo` \| `ses` \| `none` | `resend` | Mailer provider. `none` is rejected when `better-auth` is kept. |
+| `--storage` | `s3` \| `r2` \| `gcs` \| `local` | `s3` | Object storage capability (omit to skip). |
+| `--cache` | `redis` \| `memory` | `redis` | Key/value cache capability (omit to skip). |
+| `--jobs` | `inngest` \| `trigger` \| `memory` | `inngest` | Background jobs capability (omit to skip). `inngest` also scaffolds the serve route. |
+| `--logger` | `pino` \| `console` | `pino` | Structured logging capability (omit to skip). |
+| `--analytics` | `posthog` \| `plausible` \| `noop` | `posthog` | Product analytics capability (omit to skip). |
+| `--error-tracking` | `sentry` \| `console` | `sentry` | Error reporting capability (omit to skip). |
 | `--no-install` | — | install on | Skip `pnpm install` + verification. |
 | `--yes`, `-y` | — | — | Non-interactive with all defaults. |
 
-Passing any of `--framework`, `--foundations`, `--mailer` or `--no-install`
-(or `--yes`) switches the CLI to non-interactive mode; missing values fall back
-to the defaults above.
+Each capability flag is optional: pass it (bare for the default adapter, or with a
+value) to vendor that capability; omit it to leave it out. Passing any selection
+flag — `--framework`, `--foundations`, `--mailer`, any capability, or `--no-install`
+(or `--yes`) — switches the CLI to non-interactive mode; missing values fall back to
+the defaults above.
 
 ### Dependency resolution
 
@@ -75,6 +84,10 @@ pnpm dlx @alfredmouelle/create-stack api --framework next \
 
 # Minimal: Drizzle only, no mailer
 pnpm dlx @alfredmouelle/create-stack db-svc --foundations drizzle --mailer none
+
+# With capabilities: R2 storage, Redis cache, Inngest jobs, Sentry errors
+pnpm dlx @alfredmouelle/create-stack my-app \
+  --storage r2 --cache --jobs --error-tracking
 ```
 
 ## What you get
@@ -92,12 +105,27 @@ pnpm dlx @alfredmouelle/create-stack db-svc --foundations drizzle --mailer none
 Unselected foundations are removed cleanly (files, deps, env vars and wiring),
 and the project is left **bootable and green** (typecheck + Biome).
 
-## Adding more capabilities
+## Capabilities
+
+Beyond the **mailer** (always baked in, chosen via `--mailer`), the CLI can vendor
+any of the swappable capabilities at scaffold time — pick them in the wizard or via
+flags. Each is copied behind a port (into `src/server/<capability>/`) with a generated
+composition root that reads typed env and constructs the adapter lazily, so the app
+boots even before you fill in the keys:
+
+| Capability | Adapters | Notes |
+| --- | --- | --- |
+| `storage` | s3, r2, gcs, local | `getStorage()` accessor. |
+| `cache` | redis, memory | `getCache()` accessor. |
+| `jobs` | inngest, trigger, memory | `inngest` also scaffolds `serve.ts` + the framework route. |
+| `logger` | pino, console | `getLogger()` accessor. |
+| `analytics` | posthog, plausible, noop | `plausible` vendors `~/lib/http`. |
+| `error-tracking` | sentry, console | `getErrorTracking()` accessor. |
 
-The base bakes in the **mailer** (chosen via `--mailer`). Other capabilities —
-storage, jobs, cache, logger, analytics, error-tracking, http — are added *after*
-scaffolding with the `add-capability` skill (it wires each adapter's env/config per
-provider, which this CLI deliberately leaves out).
+Adapter deps and env keys are wired into `package.json` and `src/env.ts` automatically;
+cross-package imports (`@alfredmouelle/http`) are vendored into `src/lib/http` and
+rewritten. To add a capability to an **existing** project (or swap an adapter), use the
+`add-capability` skill.
 
 ## After scaffolding
 
@@ -110,8 +138,8 @@ pnpm dev
 
 ## Notes
 
-- The published package is **self-contained**: the base apps, pattern manifests
-  and mailer adapters are bundled at publish time, so `pnpm dlx` needs nothing but
-  this package.
+- The published package is **self-contained**: the base apps, the mailer adapters
+  and every capability package (`+ http`) are bundled at publish time, so `pnpm dlx`
+  needs nothing but this package.
 - The generated project is a fresh git repo (`git init`, files staged) — make your
   first commit when ready.

package/_stack/packages/analytics/capability.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "../../capability.schema.json",
+  "name": "analytics",
+  "description": "Product analytics behind a swappable port. Capture events and identify users; flush/shutdown to drain pending events.",
+  "port": "src/core/port.ts",
+  "defaultAdapter": "posthog",
+  "adapters": {
+    "posthog": {
+      "deps": ["posthog-node"],
+      "env": ["POSTHOG_API_KEY", "POSTHOG_HOST"],
+      "files": ["src/adapters/posthog"]
+    },
+    "plausible": {
+      "deps": ["@alfredmouelle/http"],
+      "env": ["PLAUSIBLE_DOMAIN", "PLAUSIBLE_API_HOST"],
+      "files": ["src/adapters/plausible"]
+    },
+    "noop": {
+      "deps": [],
+      "env": [],
+      "files": ["src/adapters/noop"]
+    }
+  },
+  "sharedDeps": ["valibot"],
+  "sharedFiles": ["src/core", "src/index.ts"]
+}

package/_stack/packages/analytics/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@alfredmouelle/analytics",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@alfredmouelle/http": "workspace:*",
+    "posthog-node": "^5.38.2",
+    "valibot": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  }
+}

package/_stack/packages/analytics/src/adapters/noop/index.ts

@@ -0,0 +1,12 @@
+import type { AnalyticsPort } from '../../core/port.js'
+
+/** No-op analytics adapter (dev/tests/disabled); call sites still depend on the port. */
+export function noopAdapter(): AnalyticsPort {
+  return {
+    name: 'noop',
+    capture() {},
+    identify() {},
+    async flush() {},
+    async shutdown() {},
+  }
+}

package/_stack/packages/analytics/src/adapters/plausible/config.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot'
+
+export const PlausibleConfigSchema = v.object({
+  /** Site domain as registered in Plausible (e.g. `acme.com`). */
+  domain: v.pipe(v.string(), v.minLength(1, 'Plausible domain is required')),
+  /** Plausible host. Defaults to `https://plausible.io`. */
+  apiHost: v.optional(v.string()),
+})
+
+export type PlausibleConfig = v.InferOutput<typeof PlausibleConfigSchema>

package/_stack/packages/analytics/src/adapters/plausible/index.ts

@@ -0,0 +1,94 @@
+import { apiFetch } from '@alfredmouelle/http'
+import * as v from 'valibot'
+import type { AnalyticsPort, CaptureEvent } from '../../core/port.js'
+import { PlausibleConfigSchema } from './config.js'
+
+const DEFAULT_API_HOST = 'https://plausible.io'
+const DEFAULT_USER_AGENT = '@alfredmouelle/analytics (+https://plausible.io)'
+
+export interface PlausibleAdapterOptions {
+  /** Site domain as registered in Plausible (e.g. `acme.com`). */
+  domain: string
+  /** Plausible host. Defaults to `https://plausible.io`. */
+  apiHost?: string
+  /** Fallback page URL when an event has no `url`. */
+  defaultUrl?: string
+  /** User-Agent sent to Plausible; it derives the cookieless visitor id from UA + client IP, so use a realistic value. */
+  userAgent?: string
+  /** Inject a custom fetch (mock/scoped client). */
+  fetchImpl?: typeof globalThis.fetch
+  /** Called on fire-and-forget request failure; defaults to swallowing. */
+  onError?: (error: unknown) => void
+}
+
+interface PlausibleEventPayload {
+  name: string
+  domain: string
+  url: string
+  referrer?: string
+  props?: Record<string, unknown>
+}
+
+/**
+ * Plausible adapter via server-side Events API (`POST /api/event`). `capture` is
+ * fire-and-forget; requests are tracked so `flush`/`shutdown` drain them.
+ * Cookieless, no person profiles, so `identify` is a no-op; `distinctId` is
+ * forwarded as a `distinct_id` prop for visibility only (counting uses UA + IP).
+ * `url`/`referrer`/`ip` read from event `properties`; `url` falls back to `defaultUrl`.
+ */
+export function plausibleAdapter(options: PlausibleAdapterOptions): AnalyticsPort {
+  const config = v.parse(PlausibleConfigSchema, {
+    domain: options.domain,
+    apiHost: options.apiHost,
+  })
+  const apiHost = config.apiHost ?? DEFAULT_API_HOST
+  const userAgent = options.userAgent ?? DEFAULT_USER_AGENT
+  const defaultUrl = options.defaultUrl ?? `https://${config.domain}/`
+  const onError = options.onError ?? (() => {})
+  const pending = new Set<Promise<void>>()
+
+  function send(payload: PlausibleEventPayload, ip?: string): void {
+    const headers: Record<string, string> = { 'User-Agent': userAgent }
+    if (ip) headers['X-Forwarded-For'] = ip
+
+    const request = apiFetch('/api/event', {
+      method: 'POST',
+      baseUrl: apiHost,
+      headers,
+      body: payload,
+      parseAs: 'none',
+      fetchImpl: options.fetchImpl,
+    })
+      .then(() => {})
+      .catch(onError)
+
+    pending.add(request)
+    void request.finally(() => pending.delete(request))
+  }
+
+  return {
+    name: 'plausible',
+    capture(event: CaptureEvent) {
+      const { url, referrer, ip, ...rest } = (event.properties ?? {}) as Record<string, unknown>
+      send(
+        {
+          name: event.event,
+          domain: config.domain,
+          url: typeof url === 'string' ? url : defaultUrl,
+          referrer: typeof referrer === 'string' ? referrer : undefined,
+          props: { distinct_id: event.distinctId, ...rest },
+        },
+        typeof ip === 'string' ? ip : undefined,
+      )
+    },
+    identify() {
+      // Cookieless, no person profiles — nothing to do.
+    },
+    async flush() {
+      await Promise.all([...pending])
+    },
+    async shutdown() {
+      await Promise.all([...pending])
+    },
+  }
+}

package/_stack/packages/analytics/src/adapters/posthog/config.ts

@@ -0,0 +1,7 @@
+import * as v from 'valibot'
+
+export const PostHogConfigSchema = v.object({
+  apiKey: v.pipe(v.string(), v.minLength(1, 'POSTHOG_API_KEY is required')),
+})
+
+export type PostHogConfig = v.InferOutput<typeof PostHogConfigSchema>

package/_stack/packages/analytics/src/adapters/posthog/index.ts

@@ -0,0 +1,50 @@
+import { PostHog } from 'posthog-node'
+import * as v from 'valibot'
+import type { AnalyticsPort, CaptureEvent, IdentifyParams } from '../../core/port.js'
+import { PostHogConfigSchema } from './config.js'
+
+/** Minimal structural view of the PostHog client (eases testing). */
+export interface PostHogLike {
+  capture(payload: CaptureEvent): void
+  identify(payload: IdentifyParams): void
+  flush(): Promise<void>
+  shutdown(): Promise<void>
+}
+
+export interface PostHogAdapterOptions {
+  apiKey: string
+  /** PostHog host (defaults to PostHog's default). */
+  host?: string
+  /** Inject a custom/mock client; defaults to a real `PostHog`. */
+  client?: PostHogLike
+}
+
+export function posthogAdapter(options: PostHogAdapterOptions): AnalyticsPort {
+  // Validate early: missing key fails at construction, not at capture().
+  const config = v.parse(PostHogConfigSchema, { apiKey: options.apiKey })
+  const client: PostHogLike =
+    options.client ?? (new PostHog(config.apiKey, { host: options.host }) as unknown as PostHogLike)
+
+  return {
+    name: 'posthog',
+    capture(event: CaptureEvent) {
+      client.capture({
+        distinctId: event.distinctId,
+        event: event.event,
+        properties: event.properties,
+      })
+    },
+    identify(params: IdentifyParams) {
+      client.identify({
+        distinctId: params.distinctId,
+        properties: params.properties,
+      })
+    },
+    flush() {
+      return client.flush()
+    },
+    shutdown() {
+      return client.shutdown()
+    },
+  }
+}

package/_stack/packages/analytics/src/core/port.ts

@@ -0,0 +1,30 @@
+/** Analytics event to capture. Fire-and-forget. */
+export interface CaptureEvent {
+  /** Event name, e.g. `'user_signed_up'`. */
+  event: string
+  /** Stable user/actor id. */
+  distinctId: string
+  /** Event metadata. */
+  properties?: Record<string, unknown>
+}
+
+/** Set/update properties on a user/actor. Fire-and-forget. */
+export interface IdentifyParams {
+  /** Stable user/actor id. */
+  distinctId: string
+  /** Person properties to set. */
+  properties?: Record<string, unknown>
+}
+
+/**
+ * App-facing port; swap adapters at the composition root, never this interface.
+ * `capture`/`identify` are fire-and-forget (like PostHog SDK): enqueue and return.
+ * `flush` drains pending events; `shutdown` flushes + releases before exit.
+ */
+export interface AnalyticsPort {
+  readonly name: string
+  capture(event: CaptureEvent): void
+  identify(params: IdentifyParams): void
+  flush(): Promise<void>
+  shutdown(): Promise<void>
+}

package/_stack/packages/analytics/src/index.ts

@@ -0,0 +1,17 @@
+export { noopAdapter } from './adapters/noop/index.js'
+export { type PlausibleConfig, PlausibleConfigSchema } from './adapters/plausible/config.js'
+export {
+  type PlausibleAdapterOptions,
+  plausibleAdapter,
+} from './adapters/plausible/index.js'
+export { type PostHogConfig, PostHogConfigSchema } from './adapters/posthog/config.js'
+export {
+  type PostHogAdapterOptions,
+  type PostHogLike,
+  posthogAdapter,
+} from './adapters/posthog/index.js'
+export type {
+  AnalyticsPort,
+  CaptureEvent,
+  IdentifyParams,
+} from './core/port.js'

package/_stack/packages/cache/capability.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../../capability.schema.json",
+  "name": "cache",
+  "description": "Key/value cache behind a swappable port. Values are serialized as JSON for remote stores.",
+  "port": "src/core/port.ts",
+  "defaultAdapter": "redis",
+  "adapters": {
+    "redis": {
+      "deps": ["ioredis"],
+      "env": ["REDIS_URL"],
+      "files": ["src/adapters/redis"]
+    },
+    "memory": {
+      "deps": [],
+      "env": [],
+      "files": ["src/adapters/memory"]
+    }
+  },
+  "sharedDeps": ["valibot"],
+  "sharedFiles": ["src/core", "src/index.ts"]
+}

package/_stack/packages/cache/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@alfredmouelle/cache",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ioredis": "^5.11.1",
+    "valibot": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  }
+}

package/_stack/packages/cache/src/adapters/memory/index.ts

@@ -0,0 +1,51 @@
+import type { CachePort } from '../../core/port.js'
+import { wrapValue } from '../../core/wrap.js'
+
+interface Entry {
+  value: unknown
+  /** Epoch ms expiry; `undefined` = no expiry. */
+  expiresAt?: number
+}
+
+export interface MemoryAdapterOptions {
+  /** Seed store (mostly for tests). */
+  store?: Map<string, Entry>
+}
+
+/** In-process `Map` cache with lazy per-key expiry; no deps. Dev/tests. */
+export function memoryAdapter(options: MemoryAdapterOptions = {}): CachePort {
+  const store = options.store ?? new Map<string, Entry>()
+
+  function read(key: string): Entry | null {
+    const entry = store.get(key)
+    if (entry === undefined) return null
+    if (entry.expiresAt !== undefined && entry.expiresAt <= Date.now()) {
+      store.delete(key)
+      return null
+    }
+    return entry
+  }
+
+  const port: CachePort = {
+    name: 'memory',
+    async get<T>(key: string) {
+      const entry = read(key)
+      return entry === null ? null : (entry.value as T)
+    },
+    async set<T>(key: string, value: T, ttlSeconds?: number) {
+      const expiresAt = ttlSeconds === undefined ? undefined : Date.now() + ttlSeconds * 1000
+      store.set(key, { value, expiresAt })
+    },
+    async delete(key: string) {
+      store.delete(key)
+    },
+    async has(key: string) {
+      return read(key) !== null
+    },
+    wrap<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number) {
+      return wrapValue(port, key, factory, ttlSeconds)
+    },
+  }
+
+  return port
+}

package/_stack/packages/cache/src/adapters/redis/config.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot'
+
+export const RedisConfigSchema = v.object({
+  url: v.optional(v.string()),
+  keyPrefix: v.optional(v.string()),
+})
+
+export type RedisConfig = v.InferOutput<typeof RedisConfigSchema>

package/_stack/packages/cache/src/adapters/redis/index.ts

@@ -0,0 +1,73 @@
+import { Redis } from 'ioredis'
+import * as v from 'valibot'
+import { CacheError, type CachePort } from '../../core/port.js'
+import { wrapValue } from '../../core/wrap.js'
+import { RedisConfigSchema } from './config.js'
+
+/** Minimal structural view of the Redis client (eases testing). */
+export interface RedisLike {
+  get(key: string): Promise<string | null>
+  set(key: string, value: string, secondsToken?: 'EX', seconds?: number): Promise<unknown>
+  del(key: string): Promise<unknown>
+  exists(key: string): Promise<number>
+}
+
+export interface RedisAdapterOptions {
+  /** Inject a custom/mock client; defaults to a real `Redis`. */
+  client?: RedisLike
+  /** Connection URL when no `client` is injected. */
+  url?: string
+  /** Prepended to every key. */
+  keyPrefix?: string
+}
+
+export function redisAdapter(options: RedisAdapterOptions = {}): CachePort {
+  // Validate early: bad option fails at construction, not at use.
+  const config = v.parse(RedisConfigSchema, { url: options.url, keyPrefix: options.keyPrefix })
+  const defaultClient = () =>
+    (config.url ? new Redis(config.url) : new Redis()) as unknown as RedisLike
+  const client: RedisLike = options.client ?? defaultClient()
+  const prefix = config.keyPrefix ?? ''
+  const k = (key: string) => `${prefix}${key}`
+
+  const port: CachePort = {
+    name: 'redis',
+    async get<T>(key: string) {
+      try {
+        const raw = await client.get(k(key))
+        if (raw === null) return null
+        return JSON.parse(raw) as T
+      } catch (cause) {
+        throw new CacheError('Failed to read from Redis', { adapter: 'redis', cause })
+      }
+    },
+    async set<T>(key: string, value: T, ttlSeconds?: number) {
+      try {
+        const json = JSON.stringify(value)
+        if (ttlSeconds === undefined) await client.set(k(key), json)
+        else await client.set(k(key), json, 'EX', ttlSeconds)
+      } catch (cause) {
+        throw new CacheError('Failed to write to Redis', { adapter: 'redis', cause })
+      }
+    },
+    async delete(key: string) {
+      try {
+        await client.del(k(key))
+      } catch (cause) {
+        throw new CacheError('Failed to delete from Redis', { adapter: 'redis', cause })
+      }
+    },
+    async has(key: string) {
+      try {
+        return (await client.exists(k(key))) > 0
+      } catch (cause) {
+        throw new CacheError('Failed to query Redis', { adapter: 'redis', cause })
+      }
+    },
+    wrap<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number) {
+      return wrapValue(port, key, factory, ttlSeconds)
+    },
+  }
+
+  return port
+}

package/_stack/packages/cache/src/core/port.ts

@@ -0,0 +1,29 @@
+/**
+ * App-facing port; swap adapters at the composition root, never this interface.
+ * Values are JSON-serialized for remote stores, so stored values must be JSON-serializable.
+ */
+export interface CachePort {
+  /** Backing adapter name (`redis`, `memory`, …). */
+  readonly name: string
+  /** Read a value, or `null` if absent/expired. */
+  get<T>(key: string): Promise<T | null>
+  /** Store a value, optionally expiring after `ttlSeconds`. */
+  set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>
+  /** Remove a key (no-op if absent). */
+  delete(key: string): Promise<void>
+  /** Whether a non-expired value exists. */
+  has(key: string): Promise<boolean>
+  /** Read-through: cached value, else `factory()` stored with `ttlSeconds`. */
+  wrap<T>(key: string, factory: () => Promise<T>, ttlSeconds?: number): Promise<T>
+}
+
+/** Normalized adapter error; callers never catch backend types. */
+export class CacheError extends Error {
+  readonly adapter: string
+
+  constructor(message: string, options: { adapter: string; cause?: unknown }) {
+    super(message, { cause: options.cause })
+    this.name = 'CacheError'
+    this.adapter = options.adapter
+  }
+}

package/_stack/packages/cache/src/core/wrap.ts

@@ -0,0 +1,20 @@
+/** Minimal read/write pair `wrap` needs; adapters pass their own `get`/`set`. */
+export interface WrapStore {
+  get<T>(key: string): Promise<T | null>
+  set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>
+}
+
+/** Read-through: return cached value, else call `factory()`, store with `ttlSeconds`, return. */
+export async function wrapValue<T>(
+  store: WrapStore,
+  key: string,
+  factory: () => Promise<T>,
+  ttlSeconds?: number,
+): Promise<T> {
+  const cached = await store.get<T>(key)
+  if (cached !== null) return cached
+
+  const value = await factory()
+  await store.set(key, value, ttlSeconds)
+  return value
+}

package/_stack/packages/cache/src/index.ts

@@ -0,0 +1,12 @@
+export {
+  type MemoryAdapterOptions,
+  memoryAdapter,
+} from './adapters/memory/index.js'
+export { type RedisConfig, RedisConfigSchema } from './adapters/redis/config.js'
+export {
+  type RedisAdapterOptions,
+  type RedisLike,
+  redisAdapter,
+} from './adapters/redis/index.js'
+export type { CachePort } from './core/port.js'
+export { CacheError } from './core/port.js'

package/_stack/packages/error-tracking/capability.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../../capability.schema.json",
+  "name": "error-tracking",
+  "description": "Error reporting behind a swappable port. Capture exceptions, messages, breadcrumbs and user context, then ship them to a provider.",
+  "port": "src/core/port.ts",
+  "defaultAdapter": "sentry",
+  "adapters": {
+    "sentry": {
+      "deps": ["@sentry/node"],
+      "env": ["SENTRY_DSN", "SENTRY_ENVIRONMENT"],
+      "files": ["src/adapters/sentry"]
+    },
+    "console": {
+      "deps": [],
+      "env": [],
+      "files": ["src/adapters/console"]
+    }
+  },
+  "sharedDeps": ["valibot"],
+  "sharedFiles": ["src/core", "src/index.ts"]
+}