@pikku/cli 0.12.91 → 0.12.92

package/skills/pikku-queue/SKILL.md

@@ -1,240 +0,0 @@
----
-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 all`:
-
-```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

@@ -1,212 +0,0 @@
----
-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.
-
-## Resolving the server URL
-
-Every client (`createPikku`, realtime, the auth client) resolves its base
-through one shared helper in `src/lib/env.ts`. Write this once:
-
-```ts
-// Endpoints come from env, never hardcoded.
-export function apiUrl(): string {
-  // SSR: the client hooks only run in the browser, so a placeholder is fine.
-  if (import.meta.env.SSR) {
-    return import.meta.env.VITE_API_URL ?? '/__api'
-  }
-  return import.meta.env.VITE_API_URL ?? `${window.location.origin}/api`
-}
-```
-
-**Never fall back to `http://localhost:3000`.** `import.meta.env.VITE_API_URL`
-is substituted by Vite at *build* time, so any deploy that supplies the URL as
-a *runtime* env var or platform binding leaves it `undefined` in the shipped
-bundle — the fallback is then the only branch that ever runs in the browser. A
-localhost fallback means every request from a deployed app goes to the user's
-own machine. `origin + '/api'` is same-origin, needs no build-time knowledge of
-the domain, and is correct wherever the app is served from.
-
-For local dev, set `VITE_API_URL`, or proxy `/api` → your backend in
-`vite.config.ts` under `server.proxy`. One `/api` entry also covers
-`/api/auth/*`; only add more entries for root-level routes outside `/api`.
-
-## 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'
-import { apiUrl } from './lib/env'
-
-const pikku = createPikku(PikkuFetch, PikkuRPC, {
-  serverUrl: apiUrl(),
-})
-
-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: apiUrl(),
-})
-// 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: apiUrl(),
-  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

@@ -1,242 +0,0 @@
----
-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'
-
-import { apiUrl } from './lib/env'
-
-const queryClient = new QueryClient()
-const pikku = createPikku(PikkuFetch, PikkuRPC, {
-  serverUrl: apiUrl(),
-})
-
-<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`).
-
-`apiUrl()` is the shared server-URL helper — see **pikku-react**. Never
-inline `?? 'http://localhost:3000'`: a deploy that supplies the URL as a
-runtime binding leaves `import.meta.env.VITE_API_URL` undefined in the
-bundle, so the fallback is the branch that actually runs.
-
-## TanStack Start (SSR)
-
-Under Start the provider mounts in `routes/__root.tsx` rather than
-`main.tsx`, and the same module is evaluated on the server. Three things
-differ:
-
-1. **`apiUrl()` must have an SSR branch.** `window` is undefined during
-   render; return the build-time var or a placeholder (the client hooks
-   only fire in the browser).
-2. **Build auth clients lazily.** Better Auth validates its baseURL with
-   `new URL(...)` at construction, so a module-scope `createAuthClient`
-   crashes SSR on the placeholder. Memoize it behind a getter:
-
-   ```ts
-   let _authClient: ReturnType<typeof createAuthClient> | undefined
-   export const authClient = () =>
-     (_authClient ??= createAuthClient({ baseURL: `${apiUrl()}/auth` }))
-   ```
-
-3. **The auth baseURL needs the `/auth` suffix.** Better Auth only
-   appends its default `/api/auth` when the baseURL carries no path.
-   `apiUrl()` already ends in `/api`, so a bare `apiUrl()` leaves the
-   client calling `/api/get-session` and 404ing.
-
-Server functions that need typed RPC access use the generated shim:
-
-```bash
-pikku tanstack-start   # emits the makeApi server-function shim
-```
-
-## 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.