@pikku/cli 0.12.20 → 0.12.22

package/skills/pikku-pino/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: pikku-pino
+description: 'Use when setting up structured logging with Pino in a Pikku app. Covers PinoLogger setup and log levels.
+TRIGGER when: code uses PinoLogger, user asks about structured logging, Pino, or @pikku/pino.
+DO NOT TRIGGER when: user asks about ConsoleLogger (use pikku-services) or general service setup.'
+---
+
+# Pikku Pino (Structured Logging)
+
+## Agent Operating Procedure
+
+Use this skill as an execution checklist, not reference material.
+
+1. Discover before editing. Prefer OpenCode tools such as `pikku-meta` when available; otherwise run the relevant `pikku meta ... --json` command and inspect only the focused output you need.
+2. Identify the source files that own the behavior. Do not start by reading generated output, `.pikku`, `node_modules`, vendored packages, or broad build artifacts.
+3. Make the smallest source change that satisfies the task. Keep generated files generated, and avoid hand-editing SDKs, schema output, or typegen.
+4. Validate with the narrowest relevant command first, then run `pikku-verify` or `pikku all` when functions, wirings, schemas, or generated clients may have changed.
+5. If validation fails, fix the source cause and rerun validation. Do not paper over generated errors by editing generated files.
+
+`@pikku/pino` provides structured JSON logging via [Pino](https://getpino.io/). Implements the `Logger` interface from `@pikku/core`.
+
+## Installation
+
+```bash
+yarn add @pikku/pino
+```
+
+## API Reference
+
+### `PinoLogger`
+
+```typescript
+import { PinoLogger } from '@pikku/pino'
+
+const logger = new PinoLogger()
+```
+
+No constructor parameters. Creates a Pino logger instance.
+
+**Properties:**
+
+- `pino: pino.Logger` — Access the underlying Pino instance for advanced config.
+
+**Methods:**
+
+- `setLevel(level: LogLevel): void` — Set minimum log level.
+- `info(messageOrObj: string | Record<string, any> | Error): void`
+- `warn(messageOrObj: string | Record<string, any> | Error): void`
+- `error(messageOrObj: string | Record<string, any> | Error): void`
+- `debug(messageOrObj: string | Record<string, any>): void`
+
+## Usage Patterns
+
+### Basic Setup
+
+```typescript
+import { PinoLogger } from '@pikku/pino'
+
+const logger = new PinoLogger()
+logger.setLevel('debug')
+```
+
+### With Pikku Services
+
+```typescript
+const createSingletonServices = pikkuServices(async (config) => {
+  const logger = new PinoLogger()
+  return { config, logger }
+})
+```
+
+### Accessing Underlying Pino
+
+```typescript
+const logger = new PinoLogger()
+logger.pino.child({ module: 'auth' }).info('Token verified')
+```

package/skills/pikku-queue/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: pikku-queue
+description: 'Use when adding background job processing, async task queues, or distributed workers to a Pikku app. Covers wireQueueWorker, job enqueuing, progress tracking, retries, BullMQ and PgBoss adapters.
+TRIGGER when: code uses wireQueueWorker, user asks about background jobs, task queues, async processing, BullMQ, PgBoss, or job retries.
+DO NOT TRIGGER when: user asks about scheduled cron tasks (use pikku-cron) or event-driven triggers (use pikku-trigger).'
+installGroups: [core]
+---
+
+# Pikku Queue Wiring
+
+## Agent Operating Procedure
+
+Use this skill as an execution checklist, not reference material.
+
+1. Discover before editing. Prefer OpenCode tools such as `pikku-meta` when available; otherwise run the relevant `pikku meta ... --json` command and inspect only the focused output you need.
+2. Identify the source files that own the behavior. Do not start by reading generated output, `.pikku`, `node_modules`, vendored packages, or broad build artifacts.
+3. Make the smallest source change that satisfies the task. Keep generated files generated, and avoid hand-editing SDKs, schema output, or typegen.
+4. Validate with the narrowest relevant command first, then run `pikku-verify` or `pikku all` when functions, wirings, schemas, or generated clients may have changed.
+5. If validation fails, fix the source cause and rerun validation. Do not paper over generated errors by editing generated files.
+
+Wire Pikku functions as background queue workers. Supports job control (progress, retry, discard), configurable concurrency, and type-safe job publishing.
+
+## Before You Start
+
+```bash
+pikku info functions --verbose   # See existing functions and their types
+pikku info tags --verbose        # Understand project organization
+```
+
+See `pikku-concepts` for the core mental model.
+
+## API Reference
+
+### `wireQueueWorker(config)`
+
+```typescript
+import { wireQueueWorker } from '@pikku/core/queue'
+
+wireQueueWorker({
+  name: string,            // Queue name (unique identifier)
+  func: PikkuFunc,         // Worker function
+  config?: {
+    batchSize?: number,    // Process N jobs at once
+    removeOnComplete?: number | boolean,  // Clean up completed jobs
+  },
+})
+```
+
+### Wire Object (`wire.queue`)
+
+Inside queue worker functions:
+
+```typescript
+wire.queue.updateProgress(percent: number)  // Report progress (0-100)
+wire.queue.discard(reason: string)          // Silently discard job
+wire.queue.fail(reason: string)             // Mark job as failed
+```
+
+### Job Publishing
+
+```typescript
+const jobId = await queue.add(queueName, data, options?)
+```
+
+Options:
+
+```typescript
+{
+  priority?: number,       // Higher = processed first
+  delay?: number,          // Delay in ms before processing
+  attempts?: number,       // Max retry attempts
+  backoff?: {
+    type: 'exponential' | 'fixed',
+    delay: number,         // Base delay in ms
+  },
+}
+```
+
+## Usage Patterns
+
+### Basic Queue Worker
+
+```typescript
+const processReminder = pikkuSessionlessFunc({
+  title: 'Process Reminder',
+  func: async ({ db, emailService }, { todoId, userId }) => {
+    const todo = await db.getTodo(todoId)
+    await emailService.sendReminder(userId, todo)
+    return { sent: true }
+  },
+})
+
+wireQueueWorker({
+  name: 'todo-reminders',
+  func: processReminder,
+})
+```
+
+### Job Control (Progress, Discard, Fail)
+
+```typescript
+const processReminder = pikkuSessionlessFunc({
+  title: 'Process Reminder',
+  func: async ({ db }, { todoId }, wire) => {
+    await wire.queue.updateProgress(25)
+
+    const todo = await db.getTodo(todoId)
+    if (!todo) {
+      await wire.queue.discard('Todo not found')
+      return
+    }
+
+    if (todo.completed) {
+      await wire.queue.fail('Todo already completed')
+      return
+    }
+
+    await wire.queue.updateProgress(100)
+    return { sent: true }
+  },
+})
+```
+
+### Retries & Configuration
+
+```typescript
+wireQueueWorker({
+  name: 'todo-reminders',
+  func: processReminder,
+  config: {
+    batchSize: 5,
+    removeOnComplete: 100,
+  },
+})
+
+// Enqueue with retry options
+const jobId = await queue.add(
+  'todo-reminders',
+  {
+    todoId: 'abc-123',
+    userId: 'user-456',
+  },
+  {
+    priority: 10,
+    delay: 5000,
+    attempts: 3,
+    backoff: { type: 'exponential', delay: 1000 },
+  }
+)
+```
+
+### Type-Safe Queue Publishing
+
+After `npx pikku prebuild`:
+
+```typescript
+import { PikkuQueue } from '.pikku/pikku-queue.gen.js'
+
+const queue = new PikkuQueue(queueService)
+
+const jobId = await queue.add('todo-reminders', {
+  todoId: 'abc-123',
+  userId: 'user-456',
+})
+
+const job = await queue.getJob('todo-reminders', jobId)
+const status = await job.status() // 'waiting' | 'active' | 'completed' | 'failed'
+const result = await job.waitForCompletion(30_000)
+```
+
+### Queue Adapters
+
+**BullMQ** (Redis-based):
+
+```typescript
+import { BullMQQueueService } from '@pikku/queue-bullmq'
+
+const queueService = new BullMQQueueService({
+  connection: { host: 'localhost', port: 6379 },
+})
+```
+
+**PgBoss** (PostgreSQL-based):
+
+```typescript
+import { PgBossQueueService } from '@pikku/queue-pg-boss'
+
+const queueService = new PgBossQueueService({
+  connectionString: 'postgres://...',
+})
+```
+
+## Complete Example
+
+```typescript
+// functions/email.functions.ts
+export const sendWelcomeEmail = pikkuSessionlessFunc({
+  title: 'Send Welcome Email',
+  func: async ({ emailService, db }, { userId }, wire) => {
+    await wire.queue.updateProgress(10)
+
+    const user = await db.getUser(userId)
+    if (!user) {
+      await wire.queue.discard('User not found')
+      return
+    }
+
+    await wire.queue.updateProgress(50)
+    await emailService.send({
+      to: user.email,
+      subject: 'Welcome!',
+      template: 'welcome',
+      data: { name: user.name },
+    })
+
+    await wire.queue.updateProgress(100)
+    return { sent: true, email: user.email }
+  },
+})
+
+// wirings/queue.wiring.ts
+wireQueueWorker({
+  name: 'welcome-emails',
+  func: sendWelcomeEmail,
+  config: { removeOnComplete: 100 },
+})
+
+// Enqueue from another function
+export const registerUser = pikkuSessionlessFunc({
+  title: 'Register User',
+  func: async ({ db, queue }, { email, name }) => {
+    const user = await db.createUser({ email, name })
+    await queue.add('welcome-emails', { userId: user.id })
+    return { user }
+  },
+})
+```

package/skills/pikku-react/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: pikku-react
+description: 'Set up @pikku/react in a React app: PikkuProvider context, createPikku factory, and the usePikkuRPC / usePikkuFetch hooks for direct (non-React-Query) calls. TRIGGER when: the user is bootstrapping a React frontend that talks to a Pikku backend, asks how to wire `PikkuProvider`, or needs to make one-off RPC calls outside of useQuery/useMutation. DO NOT TRIGGER when: the user is asking about useQuery/useMutation hooks (use pikku-react-query) or about workflows (use pikku-workflows-client).'
+installGroups: [core]
+---
+
+# Pikku React
+
+## Agent Operating Procedure
+
+Use this skill as an execution checklist, not reference material.
+
+1. Discover before editing. Prefer OpenCode tools such as `pikku-meta` when available; otherwise run the relevant `pikku meta ... --json` command and inspect only the focused output you need.
+2. Identify the source files that own the behavior. Do not start by reading generated output, `.pikku`, `node_modules`, vendored packages, or broad build artifacts.
+3. Make the smallest source change that satisfies the task. Keep generated files generated, and avoid hand-editing SDKs, schema output, or typegen.
+4. Validate with the narrowest relevant command first, then run `pikku-verify` or `pikku all` when functions, wirings, schemas, or generated clients may have changed.
+5. If validation fails, fix the source cause and rerun validation. Do not paper over generated errors by editing generated files.
+
+`@pikku/react` is the smallest possible binding: a Context provider plus
+two hooks. It does **not** depend on React Query — that's a separate
+opt-in via the generated `api.gen.ts`. Use this skill when setting up the
+provider or making direct RPC calls.
+
+## What ships
+
+```tsx
+import {
+  PikkuProvider,
+  createPikku,
+  usePikkuFetch,
+  usePikkuRPC,
+  usePikkuRealtime,
+} from '@pikku/react'
+```
+
+Five exports. `usePikkuRealtime` is only valid when you wired a
+`PikkuRealtime` class via `createPikku` — see step 3 below.
+
+## Setup at the app root
+
+```tsx
+import { createPikku, PikkuProvider } from '@pikku/react'
+import { PikkuFetch } from './pikku/pikku-fetch.gen'
+import { PikkuRPC } from './pikku/pikku-rpc.gen'
+
+const pikku = createPikku(PikkuFetch, PikkuRPC, {
+  serverUrl: import.meta.env.VITE_API_URL ?? 'http://localhost:3000',
+})
+
+createRoot(document.getElementById('root')!).render(
+  <PikkuProvider pikku={pikku}>
+    <App />
+  </PikkuProvider>
+)
+```
+
+If the project also exposes realtime events (see **pikku-realtime**), pass
+the `PikkuRealtime` class as the third argument and the instance gets a
+`realtime` field too:
+
+```tsx
+import { PikkuRealtime } from './pikku/realtime.gen'
+
+const pikku = createPikku(PikkuFetch, PikkuRPC, PikkuRealtime, {
+  serverUrl: import.meta.env.VITE_API_URL ?? 'http://localhost:3000',
+})
+// pikku.fetch / pikku.rpc / pikku.realtime — all share the same fetch
+// (server URL + auth configured once).
+```
+
+The generated classes come from your `pikku.config.json`:
+
+| config field                 | generated file                                        |
+| ---------------------------- | ----------------------------------------------------- |
+| `clientFiles.fetchFile`      | typed HTTP client (`PikkuFetch` class)                |
+| `clientFiles.rpcWiringsFile` | RPC client (`PikkuRPC` class) calling all exposed fns |
+| `clientFiles.realtimeFile`   | `PikkuRealtime` (websocket events + SSE + channels)   |
+
+If a file isn't being generated, that field is missing from the config —
+add it and re-run `pikku all`.
+
+`createPikku(...)` accepts the same `CorePikkuFetchOptions` as `PikkuFetch`
+plus `serverUrl`. Auth headers, request interceptors, etc. are configured
+on the fetch instance — RPC and realtime inherit them automatically.
+
+## Calling an RPC directly (no React Query)
+
+Inside a component:
+
+```tsx
+import { usePikkuRPC } from '@pikku/react'
+
+function Logout() {
+  const rpc = usePikkuRPC()
+  return <button onClick={() => rpc.invoke('logoutUser', {})}>Sign out</button>
+}
+```
+
+`rpc.invoke(name, data)` is typed against `FlattenedRPCMap` — `name` must
+be an exposed function id, `data` matches the input schema, return value
+matches the output schema.
+
+You also have `rpc.<funcName>(data)` if the generated RPC client builds
+direct methods (project-dependent).
+
+## Calling fetch directly
+
+```tsx
+const fetch = usePikkuFetch()
+const data = await fetch.get('/some-rest-route', { searchParams: {...} })
+```
+
+Use this only when the function is wired via HTTP (REST shape) and you
+need a path-style call. For RPC calls, `usePikkuRPC()` is cleaner.
+
+## Realtime subscriptions
+
+If you wired a `PikkuRealtime` class into `createPikku`, use
+`usePikkuRealtime()` to grab the shared instance:
+
+```tsx
+import { usePikkuRealtime } from '@pikku/react'
+import type { PikkuRealtime } from './pikku/realtime.gen'
+
+function TodoList() {
+  const realtime = usePikkuRealtime<PikkuRealtime>()
+  useEffect(() => {
+    return realtime.subscribe('todo-created', ({ todo }) => {
+      /* ... */
+    })
+  }, [realtime])
+  // ...
+}
+```
+
+The hook throws if no `PikkuRealtime` was wired — that's how you know to
+add it to `createPikku(...)`. Full event-hub setup, publishing, and SSE
+helpers live in **pikku-realtime**.
+
+## When to reach for what
+
+| Need                                | Use                                           |
+| ----------------------------------- | --------------------------------------------- |
+| Render data, dedupe + cache         | **usePikkuQuery** (react-query)               |
+| Trigger a write, wait for result    | **usePikkuMutation** (react-query)            |
+| Paginate                            | **usePikkuInfiniteQuery** (react-query)       |
+| One-off call from an event handler  | `usePikkuRPC()` direct                        |
+| Hit a REST endpoint (not RPC)       | `usePikkuFetch()`                             |
+| Run a workflow                      | **pikku-workflows-client**                    |
+| Subscribe to events / SSE / channel | `usePikkuRealtime()` (see **pikku-realtime**) |
+
+The first three live in your generated `api.gen.ts` (see the
+**pikku-react-query** skill). This skill covers the bottom four rows.
+
+## Authentication
+
+Auth is handled at the `PikkuFetch` layer — pass options to `createPikku`
+or set headers on the fetch instance after creation. Common pattern:
+
+```tsx
+const pikku = createPikku(PikkuFetch, PikkuRPC, {
+  serverUrl: '...',
+  fetchOptions: {
+    onRequest: (req) => {
+      const token = localStorage.getItem('token')
+      if (token) req.headers.set('Authorization', `Bearer ${token}`)
+    },
+  },
+})
+```
+
+Exact option names depend on the `@pikku/fetch` version — read
+`PikkuFetch`'s constructor type if unsure.
+
+## What NOT to do
+
+- Don't instantiate `PikkuFetch`/`PikkuRPC` inside a component — `createPikku`
+  goes once at the app root, the instance flows through Context.
+- Don't call `usePikkuRPC()` outside a `<PikkuProvider>` — it throws.
+- Don't write a custom RPC client. The generated one already covers every
+  exposed function with full types.
+- Don't hardcode user-facing strings. Every display string goes through an
+  i18n token — see **pikku-i18n** for the setup (it's English-only by default).

package/skills/pikku-react-query/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: pikku-react-query
+description: 'Use the Pikku auto-generated React Query hooks (`usePikkuQuery`, `usePikkuMutation`, `usePikkuInfiniteQuery`) to call backend RPC functions from a React frontend with full type safety. TRIGGER when: writing React components that need to call a Pikku function, fetch data, mutate data, or paginate; user mentions React Query, useQuery, useMutation, or building a frontend that talks to a Pikku backend. DO NOT TRIGGER when: working on the backend (use pikku-rpc / pikku-feature) or wiring a non-React frontend.'
+installGroups: [core]
+---
+
+# Pikku React Query Hooks
+
+## Agent Operating Procedure
+
+Use this skill as an execution checklist, not reference material.
+
+1. Discover before editing. Prefer OpenCode tools such as `pikku-meta` when available; otherwise run the relevant `pikku meta ... --json` command and inspect only the focused output you need.
+2. Identify the source files that own the behavior. Do not start by reading generated output, `.pikku`, `node_modules`, vendored packages, or broad build artifacts.
+3. Make the smallest source change that satisfies the task. Keep generated files generated, and avoid hand-editing SDKs, schema output, or typegen.
+4. Validate with the narrowest relevant command first, then run `pikku-verify` or `pikku all` when functions, wirings, schemas, or generated clients may have changed.
+5. If validation fails, fix the source cause and rerun validation. Do not paper over generated errors by editing generated files.
+
+Pikku generates a typed React Query layer from your backend `expose: true`
+functions. You don''t write `useQuery`/`useMutation` against `fetch`
+yourself — you call hooks named after RPCs and get full type inference for
+input + output.
+
+## Discover what's available on the client
+
+Before writing a hook, get the full client surface in one call:
+
+```bash
+yarn pikku meta clients --json
+```
+
+Returns RPCs, workflows, and channels with descriptions and type names:
+
+```json
+{
+  "rpcs": [
+    { "name": "createTodo", "description": "Create a todo",
+      "readonly": false, "input": "CreateTodoInput", "output": "CreateTodoOutput" },
+    { "name": "listTodos", "description": "List all todos",
+      "readonly": true,  "input": null,              "output": "ListTodosOutput" }
+  ],
+  "workflows": [...],
+  "channels": [...]
+}
+```
+
+The `name` is the RPC identifier; pass it to the hooks below. Input/output
+shapes are inferred automatically — the hook is typed against
+`FlattenedRPCMap[name]['input' | 'output']`. Use `description` to pick the
+right RPC; use `readonly` to choose `usePikkuQuery` vs `usePikkuMutation`.
+
+## Setup (once per app)
+
+In your app entry (e.g. `main.tsx`):
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { PikkuProvider, createPikku } from '@pikku/react'
+import { PikkuFetch } from './pikku/pikku-fetch.gen'
+import { PikkuRPC } from './pikku/pikku-rpc.gen'
+
+const queryClient = new QueryClient()
+const pikku = createPikku(PikkuFetch, PikkuRPC, {
+  serverUrl: import.meta.env.VITE_API_URL ?? 'http://localhost:3000',
+})
+
+<QueryClientProvider client={queryClient}>
+  <PikkuProvider pikku={pikku}>
+    <App />
+  </PikkuProvider>
+</QueryClientProvider>
+```
+
+The two generated files come from `pikku.config.json`'s
+`clientFiles.fetchFile` and `clientFiles.rpcWiringsFile`. Hooks live in
+the file at `clientFiles.reactQueryFile` (typically `api.gen.ts`).
+
+## The hooks
+
+All hooks are imported from your generated `api.gen.ts`:
+
+```tsx
+import {
+  usePikkuQuery,
+  usePikkuMutation,
+  usePikkuInfiniteQuery,
+} from './pikku/api.gen'
+```
+
+### `usePikkuQuery(name, data, options?)`
+
+For RPCs that **read** data. Cacheable. The hook is typed against the RPC's
+input + output.
+
+```tsx
+export function TodoList() {
+  const { data, isLoading, error } = usePikkuQuery('listTodos', {})
+
+  if (isLoading) return <p>Loading…</p>
+  if (error) return <p>{error.message}</p>
+  return (
+    <ul>
+      {data?.todos.map((t) => (
+        <li key={t.id}>{t.title}</li>
+      ))}
+    </ul>
+  )
+}
+```
+
+The query key is `[name, data]` automatically — no manual key wrangling.
+Pass standard `useQuery` options through (`staleTime`, `enabled`, etc.).
+
+### `usePikkuMutation(name, options?)`
+
+For RPCs that **write**. Returns a React Query mutation object.
+
+```tsx
+export function CreateTodoForm() {
+  const queryClient = useQueryClient()
+  const mutation = usePikkuMutation('createTodo', {
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['listTodos'] }),
+  })
+
+  const onSubmit = (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault()
+    const title = (
+      e.currentTarget.elements.namedItem('title') as HTMLInputElement
+    ).value
+    mutation.mutate({ title })
+  }
+
+  return (
+    <form onSubmit={onSubmit}>
+      <input name="title" />
+      <button type="submit" disabled={mutation.isPending}>
+        {mutation.isPending ? 'Adding…' : 'Add'}
+      </button>
+    </form>
+  )
+}
+```
+
+The input passed to `mutation.mutate(...)` is type-checked against the RPC's
+input schema. After success, **invalidate** any list/get queries that should
+refetch.
+
+### `usePikkuInfiniteQuery(name, data, options?)`
+
+Only available for RPCs whose output has a `nextCursor?: string | null`
+field — typically a list endpoint with pagination. The hook auto-feeds
+`nextCursor` into the next page's request.
+
+```tsx
+const { data, fetchNextPage, hasNextPage, isFetchingNextPage } =
+  usePikkuInfiniteQuery('listTodos', { limit: 20 })
+
+const todos = data?.pages.flatMap((p) => p.rows) ?? []
+```
+
+If the hook isn't generated for an RPC, the RPC's output doesn't include
+`nextCursor` — paginate it on the backend or use `usePikkuQuery` with
+manual cursor state.
+
+## Workflow hooks
+
+When the project has workflows (`capabilities.workflow: true`), three
+extra hooks are generated. See the **pikku-workflows-client** skill.
+
+## Calling RPCs without React Query
+
+For one-off calls (event handlers outside of state, side effects), use
+`usePikkuRPC()` from `@pikku/react`:
+
+```tsx
+const rpc = usePikkuRPC()
+const handleClick = async () => {
+  const result = await rpc.invoke('createTodo', { title: 'inline' })
+}
+```
+
+But prefer the React Query hooks for anything that touches render state —
+caching, retries, dedup, and dev-tools come for free.
+
+## Common patterns
+
+- **Optimistic updates**: pass `onMutate` to `usePikkuMutation` to update
+  the cache before the server responds. Standard React Query pattern;
+  Pikku doesn't add anything special.
+- **Conditional fetching**: pass `enabled: !!someValue` to skip a query
+  until you have the input.
+- **Refetch on focus**: enabled by default in React Query; disable with
+  `refetchOnWindowFocus: false` in options.
+
+## What NOT to do
+
+- Don't import the RPC client directly and call it inside `useEffect` —
+  use the hooks. They handle dedup, caching, and unmount safely.
+- Don't hand-write `useQuery({ queryKey: ['listTodos'], queryFn: ... })`
+  — `usePikkuQuery('listTodos', {})` does it correctly with one line.
+- Don't construct hook names dynamically. Hook names = RPC names known at
+  generation time.
+- Don't bypass the type system with `as any` — if a hook's types don't
+  match what you expect, the backend's input/output schemas are wrong;
+  fix those first.