my-platform/
├── services/           # Your microservices
│   ├── orders/
│   └── notifications/
├── packages/
│   └── contracts/      # Event contracts (single source of truth)
├── infra/
│   └── services/       # Auto-generated Pulumi configs
└── .env.local          # Auto-generated from infra

The key insight: Services define their ports, env vars, and event subscriptions once. Everything else is derived.

{
  "pf": {
    "registry": "my-org/my-platform",
    "commands": {
      "deploy": {
        "cwd": "infra",
        "command": "pulumi up --yes",
        "description": "Deploy infrastructure to production"
      }
    },
    "paths": {
      "services": { "path": "services", "watch": true },
      "contracts": { "path": "packages/contracts" }
    }
  }
}

// infra/services/orders.ts
import { ports, type K8sServiceConfig } from '@crossdelta/infrastructure'

const config: K8sServiceConfig = {
  name: 'orders',
  ports: ports().http(4001).build(),
  replicas: 1,
  healthCheck: { httpPath: '/health' },
  resources: {
    requests: { cpu: '50m', memory: '64Mi' },
    limits: { cpu: '150m', memory: '128Mi' },
  },
}

export default config

See @crossdelta/infrastructure for full options.

Contracts live in packages/contracts/ as the single source of truth:

// packages/contracts/src/events/orders/created.ts
import { createContract } from '@crossdelta/cloudevents'
import { z } from 'zod'

export const OrderCreatedSchema = z.object({
  orderId: z.string(),
  total: z.number(),
})

export type OrderCreatedData = z.infer<typeof OrderCreatedSchema>

export const OrdersCreatedContract = createContract({
  type: 'order.created',
  channel: { stream: 'ORDERS' },
  schema: OrderCreatedSchema,
})

Handlers import contracts and delegate to use cases:

// services/notifications/src/events/order-created.handler.ts
import { handleEvent } from '@crossdelta/cloudevents'
import { OrdersCreatedContract } from '@my-platform/contracts'
import { sendOrderNotification } from '../use-cases/send-notification.use-case'

export default handleEvent(OrdersCreatedContract, async (data) => {
  await sendOrderNotification(data)
})

Handlers are auto-discovered. No manual subscriptions.

See @crossdelta/cloudevents for full event API.

Local NATS started by pf dev is development infrastructure. Production streams are materialized via Pulumi from contracts.

Every workspace includes pre-configured NATS with JetStream for development:

Development:

• Auto-started with pf dev (docker-based, ephemeral)
• Ports: 4222 (client), 8222 (monitoring)
• Health check: curl http://localhost:8222/healthz
• Streams: Auto-created by pf dev from contracts (memory, 1h retention)

Production:

• Deployed via Pulumi (infra/)
• Streams materialized from contracts with retention policies
• Persistent storage (file-based) with explicit limits

Services never create streams. In dev, pf dev auto-creates from contracts. In prod, Pulumi materializes.