@ayepi/core 0.1.0 → 0.2.0

package/ayepi-core-types.md

@@ -0,0 +1,253 @@
+<!--
+ayepi-core-types.md — reference for `@ayepi/core`, written for coding agents.
+
+Copy this file into any project that depends on `@ayepi/core` (e.g. into your repo's
+`docs/` or `.claude/` directory) and reference it from your agents and slash commands.
+It documents the public API, the patterns the package expects, and how it works under the
+hood, with copy-pasteable examples. Keep it in sync with the installed package version.
+-->
+
+# `@ayepi/core` — types under the hood
+
+This file explains the "painfully-typed" machinery: how definition-time validation, disjoint
+kinds, and payload inference are derived purely at the type level. Most consumers never touch
+these directly — they exist so that `endpoint()`, `client().call()`, and handlers infer
+precisely with **no `any`/`unknown`** leaking to your editor. For the runtime fields see
+`ayepi-core-endpoints.md` (`Manifest`); for usage see `ayepi-core-client.md`.
+
+## `CheckCfg` — definition-time config validation
+
+`endpoint()` / `.group()` / `.endpoint()` intersect your config with `CheckCfg<C, LP, PFX>`:
+
+```ts
+function endpoint<const C extends EndpointConfig>(cfg: C & CheckCfg<C, EmptyObject, EmptyObject>): Endpoint<C, …>
+```
+
+`CheckCfg` is a type that resolves to `{}` (an empty constraint, valid) **or** to an object
+whose offending property holds an **error tuple**. Because the error lands on the actual
+property (`path`, `params`, `query`, `body`, `files`), the compile error points at the exact
+field you got wrong. It enforces:
+
+- a custom string path may only reference **declared** param keys;
+- each param key is declared exactly once (own template vs prefix vs `params` schema);
+- kinds are **disjoint**: query ∉ path, body ∉ path∪query, files ∉ path∪query∪body;
+- a **non-object body excludes** params/query/files (it *is* the data).
+
+```ts
+// the error type form (simplified):
+//   { readonly query: readonly ['query keys collide with path params:', <colliding keys>] }
+```
+
+Errors are emitted as `readonly ['message', Keys]` **tuples** (not plain strings) on purpose:
+two conflicting messages on the same property won't collapse to `never`, so the diagnostic
+survives. Cross-prefix position coverage is additionally validated at `spec()` time (runtime
+throw). The negative cases in [`example.ts`](./example.ts) (`@ts-expect-error`) pin every one
+of these checks.
+
+The `path`` tag has its own compile guard (`CheckTplParts`): each interpolated schema must
+accept **string** input, else the error tuple
+`['path param schema must accept string input:', K]` lands on that segment.
+
+## Disjoint-kind proofs
+
+The disjointness `CheckCfg` proves at compile time is what makes the **single `data`
+payload** lossless and reversible. Because path/query/body/files own disjoint key sets:
+
+- the client merges them into one `data` to send, and the server splits one `data` back into
+  kinds by walking the manifest's `p`/`q`/`b`/`f` key tables (`splitData` / `kindsFromData`) —
+  a trivial key-table lookup, no ambiguity;
+- a **non-object body** can't merge, so it *is* the `data` and the other kinds are banned
+  alongside it.
+
+The same disjointness is re-checked at `spec()` time (`normalizeEndpoint` throws on any
+collision, duplicate param declaration, or position/coverage mismatch) so misconfiguration
+fails at module init even if types were bypassed (e.g. via `as never`).
+
+## Payload inference
+
+All of these are pure type derivations over an `AnyEndpoint`'s config (`payload.ts`), keyed
+on `z.input` (request side) vs `z.output` (response/handler side).
+
+### `ClientData<E>` — the single `data` argument
+
+The merged path + query + body + files object the client sends, or the raw value when the
+body is a non-object:
+
+```ts
+type ClientData<E> = NonMergeableBody<E> extends true ? BRaw<E,'in'> : ClientFlat<E>
+```
+
+```ts
+ClientData<getUser>     // { id: string }
+ClientData<updateUser>  // { id: string; name: string; age?: number }   (path :id + body merged)
+ClientData<searchDocs>  // { q: string; limit?: unknown; filters: string[] }  (query + body)
+ClientData<echoText>    // string                                       (non-object body IS data)
+ClientData<uploadDoc>   // { doc: File; title: string }                 (files + body merged)
+ClientData<health>      // {}                                           (no data)
+```
+
+### `CallArgs<E>` — the positional `call()` arguments
+
+Computed per endpoint so the call site is exactly right:
+
+```ts
+sdk.call('health')                          // CallArgs = [opts?]            — no data
+sdk.call('echoText', 'hi')                  // CallArgs = [data, opts?]      — non-object body required
+sdk.call('getUser', { id })                 // CallArgs = [data, opts?]      — required data (some key required)
+sdk.call('ingestData', { tag }, { stream }) // CallArgs = [data, opts]       — streamIn forces required opts
+```
+
+Rules (from `CallArgs`): streaming-input endpoints **require** `opts` (it carries `stream`);
+a non-object body is a required positional value; data-less endpoints take `opts?` first; an
+all-optional `data` becomes `data?`.
+
+### `CallOpts<E>` — the per-call options
+
+```ts
+type CallOpts<E> = CallOptsBase
+  & (IsHttpOnly<E> extends true ? { transport?: 'http' } : { transport?: 'http' | 'ws' })
+  & (HasRawStreamIn<E>  extends true ? { stream: StreamBody }
+     : HasItemStreamIn<E> extends true ? { stream: AsyncIterable<…> | (() => AsyncIterable<…>) }
+     : {})
+```
+
+- `transport` is **narrowed to `'http'`** for httpOnly endpoints (files / raw streams) — so
+  `{ transport: 'ws' }` is a compile error there.
+- `stream` is **required** (not optional) on streaming-input endpoints: `StreamBody`
+  (`ReadableStream<Uint8Array> | Blob | ArrayBuffer | string`) for raw, or a typed
+  `AsyncIterable` for item streams.
+- `CallOptsBase` also carries `signal?` (abort), `headers?` (per-call), and
+  `onUploadProgress?: (p: UploadProgress) => void` — request-upload progress for file/body
+  uploads (routes the request via `XMLHttpRequest`; browser-only, see `ayepi-core-client.md`).
+
+`IsHttpOnly<E>` is `true` when `httpOnly: true`, or files, or a raw `streamIn`/`streamOut`
+are present — typed item streams stay ws-eligible.
+
+### `CallReturn<E>` — what `call()` resolves to
+
+```ts
+CallReturn<streamRows>    // AsyncIterable<{ i: number; squared: number }>      — typed item stream
+CallReturn<downloadZip>   // Promise<ReadableStream<Uint8Array>>                — raw stream
+CallReturn<createThing>   // Promise<{ status: 200; data: … } | { status: 201; data: … }>  — multi-status union
+CallReturn<getUser>       // Promise<{ id: string; name: string; role: … }>     — single response
+CallReturn<health>        // Promise<void>                                      — no response
+```
+
+### `HandlerPayload<S, E>` — what a handler receives
+
+The middleware context spreads at the **root**, alongside a single merged `data` and gated
+extras. Note: there are **no `params`/`query`/`body` objects** — only the merged `data`.
+
+```ts
+type GetUserP = HandlerPayload<Api, getUser>
+GetUserP['data']    // { id: string }
+GetUserP['user']    // User           — from auth middleware ctx, at the root
+GetUserP['req']     // Request
+GetUserP['signal']  // AbortSignal
+GetUserP['emit']    // EmitFn<S>
+GetUserP['status']  // (code: number) => void
+GetUserP['cookie']  // (name, value, opts?: CookieOptions) => void
+```
+
+Always present: `req`, `signal`, `emit`, `status()`, `header()`, `cookie()`. **Gated** by
+config:
+
+- `data` — present unless there's no data at all;
+- `stream` — `ReadableStream<Uint8Array>` (raw `streamIn`) or typed `AsyncIterable` (item `streamIn`);
+- `out` / `download()` / `length()` — only on **raw `streamOut`** endpoints (pipe target,
+  dynamic filename, declared byte length for Range/Content-Length/HEAD);
+- `headers` / `cookies` — only when declared (the parsed `z.output`);
+- `fail` — only when `errors` are declared (`FailFn`).
+
+```ts
+type FailFn<Errors> = <S extends keyof Errors & number>(
+  status: S, data: Errors[S] extends z.ZodType ? z.input<Errors[S]> : never,
+) => never
+```
+
+Reserved root names (a middleware ctx key colliding with one throws at runtime): `data`,
+`stream`, `headers`, `cookies`, `out`, `download`, `length`, `fail`, `status`, `header`,
+`cookie`, `req`, `signal`, `emit`.
+
+### `HandlerReturn<E>` — what a handler may return
+
+Mirrors `CallReturn`, wrapped in `MaybePromise<T> = T | Promise<T>`:
+
+```ts
+HandlerReturn<streamRows>  // MaybePromise<AsyncIterable<{ i; squared }>>                  — async generator
+HandlerReturn<downloadZip> // MaybePromise<ReadableStream<Uint8Array> | AsyncIterable<string|Uint8Array> | void>
+HandlerReturn<createThing> // MaybePromise<{ status: 200; data } | { status: 201; data }>  — pick a status
+HandlerReturn<getUser>     // MaybePromise<{ id; name; role }>
+```
+
+`HandlerFor<S, E> = (payload: HandlerPayload<S,E>) => HandlerReturn<E>` is the type each
+`implement(spec).handlers({...})` entry is checked against — a wrong shape or missing handler
+is a compile error.
+
+### `emit` types
+
+```ts
+type EmitArgs<Ev> = Get<Ev,'params'> extends z.ZodType
+  ? [params: z.input<…>, data: z.input<Ev['data']>]   // parameterized channel
+  : [data: z.input<Ev['data']>]                        // broadcast channel
+type EmitFn<S> = <K extends keyof EventsOf<S> & string>(name: K, ...args: EmitArgs<EventsOf<S>[K]>) => void
+```
+
+## Multi-status unions
+
+A `responses` map produces a discriminated `{ status, data }` union in **both** directions.
+The handler returns one branch (often `as const` so the literal status narrows), and the
+client receives the union to switch on:
+
+```ts
+// handler:
+createThing: ({ data }) =>
+  data.name === 'existing'
+    ? ({ status: 200, data: { existing: data.name } } as const)
+    : ({ status: 201, data: { id: `thing-${data.name}` } } as const)
+
+// client:
+const r = await sdk.call('createThing', { name })
+if (r.status === 201) r.data.id          // narrowed to the 201 branch
+```
+
+Returning an undeclared status is a compile error (and a runtime throw at the server's
+validation step). `multi: true` in the manifest tells the client to read `{ status, data }`.
+
+## The `Manifest` types
+
+```ts
+interface Manifest {
+  readonly endpoints: Readonly<Record<string, ManifestEndpoint>>
+  readonly events: Readonly<Record<string, ManifestEvent>>
+}
+```
+
+`ManifestEndpoint` / `ManifestEvent` are the zod-free runtime routing data (full field list
+in `ayepi-core-endpoints.md`). They carry exactly enough — `method`, `path`, `ws`,
+`httpOnly`, streaming flags, and the `p`/`q`/`b`/`f` key tables — for the client to build a
+request, split/merge `data`, and pick a transport **without any zod schemas**.
+
+## Why the spec is a single source of truth (shared type-only with the client)
+
+- The **server** consumes the spec at runtime (it holds the zod schemas, parses inputs,
+  validates outputs, generates docs and the manifest).
+- The **client** consumes the spec's **type** only — `client<typeof api>(...)`. Since
+  `import type` is erased at build, the client's argument/return types are derived precisely
+  from the same declaration the server uses, while the runtime stays zod-free and routes from
+  the plain `Manifest`.
+
+One declaration ⇒ server validation, client types, wire format, docs, and manifest all stay
+in lockstep. There is no second schema to drift. (`example.ts` enforces this with
+`Expect<Equal<…>>` type tests and `@ts-expect-error` negatives — when this doc and the
+example disagree, the example wins.)
+
+## Exported type-utility helpers
+
+`Simplify<T>` (flatten an intersection into one object literal), `MaybePromise<T>`
+(`T | Promise<T>`), and `Json` (the closed JSON-shaped value the doc generators produce and
+accept in patch callbacks). The payload types above are all exported:
+`ClientData`, `CallArgs`, `CallOpts`, `CallOptsBase`, `UploadProgress`, `CallReturn`, `HandlerPayload`,
+`HandlerReturn`, `HandlerFor`, `FailFn`, `StreamBody`, `IsHttpOnly`, `EmitArgs`, `EmitFn`,
+plus `CheckCfg`, `Endpoint`, `AnyEndpoint`, `EndpointConfig`, `AnySpec`, `SpecShape`,
+`EventConfig`, `EventsOf`, and the `Manifest` types.

package/ayepi-core.md

@@ -0,0 +1,235 @@
+<!--
+ayepi-core.md — reference for `@ayepi/core`, written for coding agents.
+
+Copy this file into any project that depends on `@ayepi/core` (e.g. into your repo's
+`docs/` or `.claude/` directory) and reference it from your agents and slash commands.
+It documents the public API, the patterns the package expects, and how it works under the
+hood, with copy-pasteable examples. Keep it in sync with the installed package version.
+-->
+
+# `@ayepi/core` — overview
+
+`@ayepi/core` is a **zod-first, painfully-typed HTTP + WebSocket API library**. You
+declare endpoints and events **once** with [zod v4](https://zod.dev) schemas as the
+single source of truth, and from that one declaration you get:
+
+- a **typed server** (`app.fetch(Request) => Response`, plus a ws frame handler),
+- a **typed client** (`sdk.call` / `sdk.url` / `sdk.on`),
+- **OpenAPI 3.1 + AsyncAPI 3.0** documents,
+- a **zod-free runtime manifest** the browser can route from without shipping schemas.
+
+It is **fetch-native**: web-standard `Request`/`Response`/streams everywhere. It runs on
+Node, Bun, Deno, Cloudflare Workers, and Lambda. Runtime adapters (`@ayepi/node`,
+`@ayepi/bun`, `@ayepi/deno`) only add WebSocket-upgrade glue at the edge.
+
+```sh
+pnpm add @ayepi/core zod      # zod is a peer dependency (^4)
+```
+
+```ts
+import { spec, endpoint, server, client } from '@ayepi/core'
+import { client } from '@ayepi/core/client'   // zod-free browser entry
+```
+
+## The mental model
+
+Five ideas carry the whole library:
+
+1. **Schemas are the source of truth.** Every endpoint kind (path params, query, body,
+   files, headers, cookies) is a zod schema. From them, the request/response types, the
+   handler payload type, the client `call()` signature, the wire format, and the docs are
+   all derived. You never restate a shape.
+
+2. **Disjoint kinds → one `data` payload.** Path params, query, body, and files own
+   *disjoint* keys and merge losslessly into a single typed `data` object — in both
+   directions (client sends one `data`, handler receives one `data`). Disjointness is
+   proven at compile time (via `CheckCfg`) and re-checked at `spec()` time. A *non-object*
+   body can't merge, so it **is** the `data`. (Headers and cookies are separate kinds —
+   they ride `opts.headers` and surface as their own `headers`/`cookies` payload props,
+   never merged into `data`.)
+
+3. **HTTP _and_ WebSocket from one declaration.** Every eligible endpoint is callable over
+   either transport; typed item streams ride both. Raw byte streams and file uploads are
+   HTTP-only.
+
+4. **The client routes from a zod-free `Manifest`.** The manifest is a plain-data routing
+   table — key tables per endpoint plus method/path/streaming flags. The browser bundle
+   needs the manifest, never the schemas.
+
+5. **No `any`.** The public generic surface infers precisely; the painful typing is an
+   implementation detail (see `ayepi-core-types.md`).
+
+## The pipeline: `spec()` → `implement()` → `server()` → `client()`
+
+```ts
+spec({ endpoints, events, doc? })              // validate + brand the declaration (defs only — frontend-safe)
+  → implement(spec)                            // chainable builder…
+      .middleware(def, impl)                   //   …bind each middleware def to its impl
+      .handlers({ ... })                       //   …type each handler against its endpoint
+  → server(spec, [builder], opts?)             // assemble app.fetch + app.ws + app.emit + docs
+  → client<typeof spec>({ ... })               // typed sdk.call / sdk.url / sdk.on
+```
+
+- **`spec(shape)`** finalizes endpoints + events into a validated spec object. It runs
+  every runtime sanity check (flag exclusivity, kind shapes) and full path / coverage /
+  disjointness validation, throwing immediately so misconfiguration fails at module init.
+  The spec references middleware only as **defs** (contracts, no runtime code), so it stays
+  **frontend-safe** — importable from the browser bundle without pulling in secrets or node
+  deps. See `ayepi-core-middleware.md`.
+- **`implement(spec)`** returns a **chainable builder**. `.middleware(def, impl)` binds a
+  middleware def to its runtime impl; `.handlers({...})` / `.handle(name, fn)` type each
+  handler against its endpoint. Every method returns the builder, so calls chain. Split
+  handlers/bindings across multiple builders if you like.
+- **`server(spec, [builders], opts?)`** assembles the runtime from the builders produced by
+  `implement()`. A **missing handler is a compile error naming the endpoint**; duplicate/unknown
+  handlers throw at startup; and **any middleware def left unbound throws at assembly**.
+- **`client<typeof spec>({...})`** creates the typed SDK. It needs a `Manifest` (or the
+  spec) and a `baseUrl`; the spec type parameter is **type-only** (erased at build).
+
+## A complete minimal end-to-end example
+
+```ts
+// api.ts (frontend-safe: @ayepi/core + zod only) — defs + spec
+import { z } from 'zod'
+import { middleware, endpoint, spec, ctx } from '@ayepi/core'
+
+/* 1. middleware def — declares it provides { user }; the impl is bound later */
+const auth = middleware('auth', { provides: ctx<{ user: { id: string; name: string } }>() })
+
+/* 2. spec — schemas are the single source of truth */
+export const api = spec({
+  endpoints: {
+    health: endpoint({}),                       // POST /health, no input, 204
+    ...auth.group({
+      getUser: { params: z.object({ id: z.string() }), response: z.object({ id: z.string(), name: z.string() }) },
+      updateUser: {
+        method: 'PATCH',
+        path: '/users/:id',
+        params: z.object({ id: z.string() }),
+        body: z.object({ name: z.string().min(1) }), // merges with :id into one `data`
+        response: z.object({ id: z.string(), name: z.string() }),
+      },
+    }),
+  },
+  events: {
+    jobProgress: { params: z.object({ jobId: z.string() }), data: z.object({ pct: z.number() }) },
+  },
+})
+export { auth }
+```
+
+```ts
+// server.ts (secrets, node deps) — bind impls + handlers, then assemble
+import { implement, server, reject } from '@ayepi/core'
+import { api, auth } from './api'
+
+/* 3. one chainable builder: bind the middleware impl, then the handlers.
+      handlers get one merged `data`, ctx (`user`) at the root, and a typed `emit`. */
+const impl = implement(api)
+  /* auth impl — provides { user }; the value passed to next() matches the def's ctx<…>() */
+  .middleware(auth, async (io) => {
+    if (io.req.headers.get('authorization') !== 'Bearer secret') throw reject(401, 'UNAUTHORIZED')
+    return io.next({ user: { id: 'u1', name: 'Phil' } })
+  })
+  .handlers({
+    health: () => {},
+    getUser: ({ data, user }) => ({ id: data.id, name: user.name }),
+    updateUser: ({ data, emit }) => {
+      emit('jobProgress', { jobId: 'job-1' }, { pct: 100 })
+      return { id: data.id, name: data.name }
+    },
+  })
+
+/* 4. server — a missing handler OR an unbound middleware def is caught here
+      (handler: compile error naming the endpoint; unbound def: throws at assembly) */
+export const app = server(api, [impl], { cors: { origin: '*' } })
+```
+
+```ts
+/* 5. client — zod-free entry, type-only spec import */
+import { client } from '@ayepi/core/client'
+import type { api } from './api'
+
+const sdk = client<typeof api>({ baseUrl: 'https://api.example.dev', manifest })
+const user = await sdk.call('getUser', { id: 'u1' })          // { id: string; name: string }
+const off  = sdk.on('jobProgress', { jobId: 'job-1' }, (d) => console.log(d.pct))
+```
+
+`app.fetch(request)` is the entire HTTP surface — run it in-process (tests), on Node, Bun,
+Deno, or any fetch-native runtime. See the runnable, feature-exhaustive
+[`example.ts`](./example.ts) (it doubles as the type-test suite).
+
+## Docs and manifest generation
+
+A server exposes three generators, all derived from the same spec:
+
+```ts
+app.openapi({ title: 'API', version: '1.0.0' }) // OpenAPI 3.1 — paths, params, security, errors, multi-status
+app.asyncapi({ title, version })                // AsyncAPI 3.0 — event channels + endpoint ws channels
+app.manifest()                                  // the zod-free runtime routing table
+```
+
+For AsyncAPI, **WebSocket endpoints are modeled as request/reply over separate channels** —
+the reply channel documents both the success frame (`{ id, $status, data }`) and the error
+frame (`{ id, $status, $error, $code, data }`) — alongside the server-pushed event channels.
+
+You can also let the server host interactive docs (specs computed once, cached in memory;
+viewer pages loaded from a CDN, no bundled doc dependency):
+
+```ts
+const app = server(api, [handlers], { docs: true })
+// GET /docs/openapi.json  GET /docs/asyncapi.json
+// GET /docs/swagger → Swagger UI   GET /docs/redoc → ReDoc   GET /docs/asyncapi → AsyncAPI viewer
+```
+
+Customize or disable individual pages with a `DocsOptions` object
+(`{ swagger: '/api-docs', redoc: false, info: { title, version } }`). The HTML builders
+`swaggerHtml`, `redocHtml`, `asyncapiHtml` are exported if you'd rather mount them yourself.
+
+### Acquiring the manifest for the client
+
+The client routes from a **`Manifest`**. Get the manifest one of three ways:
+
+- `app.manifest()` on the running server,
+- `manifestFromSpec(spec)` from the spec (importing this pulls zod into the bundle),
+- pass the **spec itself** to `client({ manifest: spec })` (convenient, but ships zod).
+
+The recommended frontend pattern is to commit a prebuilt manifest (plain JSON) and import
+it as a value — the browser bundle then stays schema-free. See `ayepi-core-client.md`.
+
+## Hot install + in-process calls
+
+A running `Server` is mutable and self-callable:
+
+- **`app.install(spec, builders) → MountHandle`** mounts another spec's endpoints, events,
+  routes, and middleware **onto the live server** (the manifest + OpenAPI/AsyncAPI caches
+  refresh; collisions on endpoint name / `METHOD path` / ws id / event throw).
+  **`app.uninstall(handle)`** removes exactly them and clears their subscriptions. A shared
+  middleware def already bound by an earlier mount is reused (bind it once).
+- **`localClient(app, spec) → LocalClient<S>`** (and the loose `app.call(name, data, opts?)`)
+  invoke an endpoint **in-process** by name with just a data payload — full chain +
+  validation, no HTTP serialization; the invocation's `io.transport` is `'local'`.
+
+These are the primitives [`@ayepi/plugin`](../plugin) builds a hot-pluggable plugin system on.
+
+## This doc set
+
+- **`ayepi-core.md`** (this file) — overview, mental model, the pipeline, docs/manifest.
+- **`ayepi-core-endpoints.md`** — everything `endpoint()` / `spec()` accept: methods, paths
+  and the `` path`` `` tag, body/query/params/headers/cookies/files, streaming
+  (`streamIn`/`streamOut`), multi-status `responses`, declared `errors`, encodings,
+  downloads, ws ids, docs, and the `Manifest` field reference.
+- **`ayepi-core-middleware.md`** — the middleware **def** (`middleware()` /
+  `middleware.loader()` + `ctx<P>()` provides) vs **impl** split, binding via the chainable
+  `implement(api).middleware(def, impl)` builder and the binding requirement, the
+  `use(...)` free-function composition helper and the `.group()`/`.with()`/`.path()`/
+  `.endpoint()` builders, the per-invocation `io` context
+  (`transport`/`route`/`ws`/`signal`/`setHeader`/`status`), auth patterns, loaders, declared
+  errors and security-scheme docs, `reject()`, the new exported impl/bound types, and chain
+  execution semantics.
+- **`ayepi-core-client.md`** — `client()`, `wsTransport()`, `sdk.call`/`url`/`on`, transport
+  selection, typed item streams, events, opt-in validation, `ApiError`, the ws `$status`/
+  `$error` frame protocol, and the zod-free `@ayepi/core/client` entry.
+- **`ayepi-core-types.md`** — how the painful typing works: `CheckCfg`, disjoint-kind
+  proofs, payload inference (`ClientData`/`CallArgs`/`CallReturn`/`CallOpts`/
+  `HandlerPayload`/`HandlerReturn`), multi-status unions, and the `Manifest` types.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayepi/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "zod-first, painfully-typed HTTP + WebSocket API library with OpenAPI 3.1 + AsyncAPI 3.0 generation",
   "license": "MIT",
   "publishConfig": {
@@ -18,7 +18,8 @@
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "ayepi-*.md"
   ],
   "exports": {
     ".": {