@shaferllc/keel 0.83.0 → 0.83.1

package/README.md

@@ -160,7 +160,7 @@ src/core/            The framework
 src/db/              Database adapters (D1, Postgres, libSQL)
 src/api/             CRUD REST resources from a model
 src/openapi/         Generates an OpenAPI spec from the routes
-src/billing/         Subscription billing — Stripe + Paddle (Cashier port)
+src/billing/         Subscription billing — Stripe + Paddle
 src/watch/           The debug dashboard
 src/mcp/             The MCP server (docs + API for AI agents)
 src/vite/            The Vite plugin
@@ -228,7 +228,7 @@ See [docs/architecture.md](./docs/architecture.md) for the full picture.
 | [Internationalization](./docs/i18n.md) | ICU messages, `Intl` formatters, locale detection |
 | [Pages](./docs/pages.md) | Page-based routing — a file is a route |
 | [Packages](./docs/packages.md) | Redistributable slices of an app: routes, migrations, commands |
-| [Billing](./docs/billing.md) | Subscriptions, charges & webhooks — Stripe + Paddle (Cashier port) |
+| [Billing](./docs/billing.md) | Subscriptions, charges & webhooks — Stripe + Paddle |
 | [Watch](./docs/watch.md) | Debug dashboard — requests, queries, jobs, logs at `/watch` |
 | [Views](./docs/views.md) | Hono JSX components, layouts, the View service |
 | [Templates](./docs/templates.md) | `{{ }}` + `@`-tag templating engine, edge-safe |

package/dist/billing/billable.d.ts

@@ -1,7 +1,6 @@
 /**
- * The `Billable` mixin — Cashier's Billable trait, as a TypeScript mixin. Apply
- * it to a model to give that model a gateway customer, subscriptions, charges,
- * and checkout:
+ * The `Billable` mixin — apply it to a model to give that model a gateway
+ * customer, subscriptions, charges, and checkout:
  *
  *   class User extends Billable(Model) {
  *     static table = "users";

package/dist/billing/billable.js

@@ -1,7 +1,6 @@
 /**
- * The `Billable` mixin — Cashier's Billable trait, as a TypeScript mixin. Apply
- * it to a model to give that model a gateway customer, subscriptions, charges,
- * and checkout:
+ * The `Billable` mixin — apply it to a model to give that model a gateway
+ * customer, subscriptions, charges, and checkout:
  *
  *   class User extends Billable(Model) {
  *     static table = "users";

package/dist/billing/billing.config.stub

@@ -1,7 +1,7 @@
 import { env } from "@shaferllc/keel/core";
 
 /**
- * Billing configuration — a Cashier-style port covering Stripe and Paddle.
+ * Billing configuration — subscriptions and charges, covering Stripe and Paddle.
  * Published with `keel vendor:publish --tag billing-config`.
  */
 export default {

package/dist/billing/builder.d.ts

@@ -1,6 +1,6 @@
 /**
- * The fluent subscription builder — Cashier's `newSubscription(...)->create()`.
- * The `Billable` mixin hands it a small `BillableTarget` (so this file needn't
+ * The fluent subscription builder — `newSubscription(...).create()`. The
+ * `Billable` mixin hands it a small `BillableTarget` (so this file needn't
  * import the mixin, avoiding a cycle); the builder shapes the request, calls the
  * gateway, and persists a local `Subscription` synced from the result.
  *

package/dist/billing/builder.js

@@ -1,6 +1,6 @@
 /**
- * The fluent subscription builder — Cashier's `newSubscription(...)->create()`.
- * The `Billable` mixin hands it a small `BillableTarget` (so this file needn't
+ * The fluent subscription builder — `newSubscription(...).create()`. The
+ * `Billable` mixin hands it a small `BillableTarget` (so this file needn't
  * import the mixin, avoiding a cycle); the builder shapes the request, calls the
  * gateway, and persists a local `Subscription` synced from the result.
  *

package/dist/billing/provider.d.ts

@@ -1,5 +1,5 @@
 /**
- * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel Billing — subscription billing covering Stripe and Paddle, shipped as a
  * Keel package. One line in `bootstrap/providers.ts` turns it on:
  *
  *   app.register(BillingServiceProvider)

package/dist/billing/provider.js

@@ -1,5 +1,5 @@
 /**
- * Keel Billing — a Cashier-style port covering Stripe and Paddle, shipped as a
+ * Keel Billing — subscription billing covering Stripe and Paddle, shipped as a
  * Keel package. One line in `bootstrap/providers.ts` turns it on:
  *
  *   app.register(BillingServiceProvider)
@@ -29,7 +29,7 @@ export class BillingServiceProvider extends PackageProvider {
         registerDefaultGateways(this.manager);
         setBilling(this.manager);
         this.app.instance(BillingManager, this.manager);
-        // Cashier targets the standard `users` billable table.
+        // Default billable table is `users`.
         this.migrations([billingMigration("users")]);
         this.publishes({ [join(here, "billing.config.stub")]: "config/billing.ts" }, "billing-config");
     }

package/dist/billing/subscription-item.d.ts

@@ -1,7 +1,6 @@
 /**
  * One line of a subscription — a single price and its quantity. A single-price
  * subscription has exactly one item; a multi-product subscription has several.
- * Mirrors Cashier's `subscription_items` table.
  */
 import { Model } from "../core/model.js";
 import type { Casts } from "../core/casts.js";

package/dist/billing/subscription-item.js

@@ -1,7 +1,6 @@
 /**
  * One line of a subscription — a single price and its quantity. A single-price
  * subscription has exactly one item; a multi-product subscription has several.
- * Mirrors Cashier's `subscription_items` table.
  */
 import { Model } from "../core/model.js";
 export class SubscriptionItem extends Model {

package/dist/core/decorators.d.ts

@@ -1,10 +1,9 @@
 /**
  * Request decorators — attach named, computed values to the current request,
- * resolved lazily and memoized for the life of that request. Inspired by
- * Fastify's `decorateRequest`, but without its footguns: you register a resolver
- * once, and Keel computes it on first access and caches it per request (keyed off
- * the Hono context via a WeakMap, so there's no shared-state leak between
- * requests and no V8 shape deopt to design around).
+ * resolved lazily and memoized for the life of that request. You register a
+ * resolver once, and Keel computes it on first access and caches it per request
+ * (keyed off the Hono context via a WeakMap, so there's no shared-state leak
+ * between requests and no V8 shape deopt to design around).
  *
  *   decorateRequest("user", async (c) => findUser(c.req.header("authorization")));
  *
@@ -18,8 +17,7 @@ import type { Context } from "hono";
 /** Resolves a decorator's value from the current request context. */
 export type RequestResolver<T = unknown> = (c: Context) => T | Promise<T>;
 /**
- * Register a request decorator. Throws if `name` is already registered — a
- * collision guard, like Fastify's.
+ * Register a request decorator. Throws if `name` is already registered.
  */
 export declare function decorateRequest<T>(name: string, resolver: RequestResolver<T>): void;
 /** Whether a request decorator has been registered. */

package/dist/core/decorators.js

@@ -1,10 +1,9 @@
 /**
  * Request decorators — attach named, computed values to the current request,
- * resolved lazily and memoized for the life of that request. Inspired by
- * Fastify's `decorateRequest`, but without its footguns: you register a resolver
- * once, and Keel computes it on first access and caches it per request (keyed off
- * the Hono context via a WeakMap, so there's no shared-state leak between
- * requests and no V8 shape deopt to design around).
+ * resolved lazily and memoized for the life of that request. You register a
+ * resolver once, and Keel computes it on first access and caches it per request
+ * (keyed off the Hono context via a WeakMap, so there's no shared-state leak
+ * between requests and no V8 shape deopt to design around).
  *
  *   decorateRequest("user", async (c) => findUser(c.req.header("authorization")));
  *
@@ -27,8 +26,7 @@ function bag(c) {
     return b;
 }
 /**
- * Register a request decorator. Throws if `name` is already registered — a
- * collision guard, like Fastify's.
+ * Register a request decorator. Throws if `name` is already registered.
  */
 export function decorateRequest(name, resolver) {
     if (resolvers.has(name)) {

package/dist/core/exceptions.d.ts

@@ -92,9 +92,8 @@ export declare class ServiceUnavailableException extends HttpException {
 }
 /**
  * Mint a reusable, coded `HttpException` subclass — the ergonomic way to define
- * app-specific errors with a stable, machine-readable `code`. Inspired by
- * `@fastify/error`. The `message` may carry `%s` placeholders, filled in order
- * from the constructor arguments.
+ * app-specific errors with a stable, machine-readable `code`. The `message` may
+ * carry `%s` placeholders, filled in order from the constructor arguments.
  *
  *   const InsufficientFunds = createError("E_FUNDS", "Balance too low: need %s", 402);
  *   throw new InsufficientFunds("$40");

package/dist/core/exceptions.js

@@ -196,9 +196,8 @@ export class ServiceUnavailableException extends HttpException {
 }
 /**
  * Mint a reusable, coded `HttpException` subclass — the ergonomic way to define
- * app-specific errors with a stable, machine-readable `code`. Inspired by
- * `@fastify/error`. The `message` may carry `%s` placeholders, filled in order
- * from the constructor arguments.
+ * app-specific errors with a stable, machine-readable `code`. The `message` may
+ * carry `%s` placeholders, filled in order from the constructor arguments.
  *
  *   const InsufficientFunds = createError("E_FUNDS", "Balance too low: need %s", 402);
  *   throw new InsufficientFunds("$40");

package/dist/core/model-query.d.ts

@@ -1,7 +1,7 @@
 /**
  * A model-aware query builder — what `Model.query()` sugar and eager loading are
  * built on. It wraps the plain `QueryBuilder`, hydrates rows into models (firing
- * `retrieved`), and adds the relationship-aware operations Eloquent has and a raw
+ * `retrieved`), and adds the relationship-aware operations a query builder lacks and a raw
  * builder can't: `with()` (nested eager loading), `withCount()`, and existence
  * filters `has()` / `whereHas()` / `doesntHave()`.
  *

package/dist/core/model-query.js

@@ -1,7 +1,7 @@
 /**
  * A model-aware query builder — what `Model.query()` sugar and eager loading are
  * built on. It wraps the plain `QueryBuilder`, hydrates rows into models (firing
- * `retrieved`), and adds the relationship-aware operations Eloquent has and a raw
+ * `retrieved`), and adds the relationship-aware operations a query builder lacks and a raw
  * builder can't: `with()` (nested eager loading), `withCount()`, and existence
  * filters `has()` / `whereHas()` / `doesntHave()`.
  *

package/dist/core/request-logger.d.ts

@@ -1,8 +1,8 @@
 /**
  * Per-request logging. `requestLogger()` middleware binds a child logger to each
  * request with a generated `reqId`, so every log line within that request
- * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
- * also log the request start and completion (method, path, status, duration).
+ * correlates — built on Keel's `Logger.child()`. It can also log the request
+ * start and completion (method, path, status, duration).
  *
  *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
  *   requestLog().info("charging card");   // anywhere in the request → carries reqId

package/dist/core/request-logger.js

@@ -1,8 +1,8 @@
 /**
  * Per-request logging. `requestLogger()` middleware binds a child logger to each
  * request with a generated `reqId`, so every log line within that request
- * correlates — Fastify's `request.log`, built on Keel's `Logger.child()`. It can
- * also log the request start and completion (method, path, status, duration).
+ * correlates — built on Keel's `Logger.child()`. It can also log the request
+ * start and completion (method, path, status, duration).
  *
  *   kernel.use(requestLogger());          // in app/Http/Kernel.ts
  *   requestLog().info("charging card");   // anywhere in the request → carries reqId

package/dist/core/request.js

@@ -112,7 +112,7 @@ export function html(body, status) {
 }
 export function redirect(location, status) {
     const c = maybeCtx();
-    // Koa-style `redirect("back")`: bounce to the Referer, or "/" if there isn't one.
+    // `redirect("back")`: bounce to the Referer, or "/" if there isn't one.
     if (location === "back")
         location = c?.req.header("referer") ?? "/";
     return c

package/dist/core/testing.d.ts

@@ -1,8 +1,8 @@
 /**
  * A test client for Keel apps — inject requests without a live server and assert
- * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
- * instance (which already does fetch-style request injection), adding verb
- * helpers with JSON bodies and fluent response assertions.
+ * on the response. Wraps the app's Hono instance (which already does fetch-style
+ * request injection), adding verb helpers with JSON bodies and fluent response
+ * assertions.
  *
  *   const client = await testClient(app);
  *   const res = await client.post("/users", { email: "a@b.com" });

package/dist/core/testing.js

@@ -1,8 +1,8 @@
 /**
  * A test client for Keel apps — inject requests without a live server and assert
- * on the response, the way Fastify's `inject()` does. Wraps the app's Hono
- * instance (which already does fetch-style request injection), adding verb
- * helpers with JSON bodies and fluent response assertions.
+ * on the response. Wraps the app's Hono instance (which already does fetch-style
+ * request injection), adding verb helpers with JSON bodies and fluent response
+ * assertions.
  *
  *   const client = await testClient(app);
  *   const res = await client.post("/users", { email: "a@b.com" });

package/docs/ai-manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaferllc/keel",
-  "version": "0.83.0",
+  "version": "0.83.1",
   "description": "The house framework for Node.js — a service container, providers, routing, JSX views, and a code-generating console.",
   "repo": "https://github.com/shaferllc/keel",
   "generated": "run `npm run build:ai` to regenerate",
@@ -50,7 +50,7 @@
     {
       "slug": "billing",
       "title": "Billing",
-      "summary": "Keel Billing is a subscription-billing layer — a port of Laravel Cashier — for charging customers, managing subscriptions, and reconciling gateway state through webhooks.",
+      "summary": "Keel Billing is a subscription-billing layer for charging customers, managing subscriptions, and reconciling gateway state through webhooks.",
       "path": "docs/billing.md",
       "example": null
     },

package/docs/billing.md

@@ -1,9 +1,8 @@
 # Billing
 
-Keel Billing is a subscription-billing layer — a port of [Laravel
-Cashier](https://laravel.com/docs/13.x/billing) — for charging customers,
-managing subscriptions, and reconciling gateway state through webhooks. It ships
-as a Keel [package](./packages.md) and supports two gateways behind one API:
+Keel Billing is a subscription-billing layer for charging customers, managing
+subscriptions, and reconciling gateway state through webhooks. It ships as a
+Keel [package](./packages.md) and supports two gateways behind one API:
 **Stripe** and **Paddle**.
 
 It attaches to a model with a mixin. Your `User` becomes billable, gains a
@@ -221,8 +220,8 @@ resolveBillableUsing(async (customerId) => {
 The migration is gateway-neutral: `subscriptions` (with `gateway`,
 `provider_id`, `provider_status`, `provider_price`, trial/grace timestamps),
 `subscription_items`, and columns on `users` (`billing_gateway`,
-`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). Cashier
-targets the standard `users` billable table.
+`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). The default
+migration targets the standard `users` billable table.
 
 ## Testing
 

package/docs/changelog.md

@@ -4,6 +4,92 @@ All notable changes to Keel are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project aims to
 adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.83.0] — 2026-07-12
+
+### Added
+
+- **Starter kits, and a generator that can't fall behind.** Four curated
+  applications — `minimal`, `api`, `app` (views, sessions, register/login, password
+  reset, two-factor), and `saas` (teams, roles, invitations, billing,
+  multi-tenancy):
+
+  ```bash
+  npm create keeljs@latest my-app -- --preset saas
+  ```
+
+  The templates ship **inside this package**, so the version a kit is generated from
+  is, by construction, the version it was written for. The old standalone starter
+  drifted to five releases behind and nothing noticed; CI now generates all four kits
+  on every push and typechecks, migrates, boots, serves a request, bundles the
+  Worker, and runs their tests.
+
+- **Teams (`@shaferllc/keel/teams`)** — multi-tenancy, membership, roles, and
+  invitations. `TenantModel` makes isolation the default rather than a habit: reads
+  are constrained by an inherited global scope (so even `find(id)` returns `null` for
+  another team's row — not a filter you can forget), and writes are stamped with the
+  current team, so a row can't be born ownerless.
+
+  Outside a team context a tenant query **throws**. A job, console command, or
+  webhook has no request and therefore no team; returning everything is how one
+  customer's data reaches another, and `team_id = NULL` means jobs quietly do
+  nothing. So work says which team it is for — `runForTeam(team, fn)` — or says out
+  loud that it spans all of them — `withoutTenant(fn)`. Both are greppable at audit
+  time.
+
+- **Accounts (`@shaferllc/keel/accounts`)** — password reset, email verification, and
+  two-factor, mounted with one provider. A correct password on a 2FA account yields a
+  short-lived, single-purpose **challenge, not a session**, so there is no
+  half-authenticated state for a route to forget to check. TOTP is RFC 6238, verified
+  against the RFC's published vectors, WebCrypto-only, and therefore edge-safe. No
+  tokens table: reset links carry their own purpose and expiry and are bound to a
+  fingerprint of the current password hash, so spending one kills it.
+
+- **D1 over HTTP (`@shaferllc/keel/db/d1-http`).** The D1 binding only exists inside a
+  Worker, so `keel migrate` had nowhere to point and you could not create your
+  tables. The same `Connection` over D1's HTTP API closes that: migrations run from a
+  laptop and from CI. It treats an error in the response *body* as an error even when
+  the status is 200 — which is how Cloudflare often reports them, and trusting the
+  status would let a failed migration look like it succeeded.
+
+- **`Model.withoutGlobalScope(...)` / `withoutGlobalScopes()`** — escaping a scope
+  should be typed out and greppable, never something you arrive at by forgetting a
+  `where`.
+
+### Fixed
+
+- **Global scopes and model hooks now inherit.** Both were keyed by the exact class,
+  so a scope or a `creating` hook declared on a *base* class was silently ignored by
+  every subclass. The models guide advertises global scopes as "the base for
+  multi-tenancy", and that was precisely the case that didn't work: the scope did
+  nothing, the query returned every tenant's rows, and nothing complained. It failed
+  **open**. Both now walk the prototype chain, and a scope is passed the model it is
+  scoping so a base class can read each subclass's own configuration.
+
+- **The official `@libsql/client` no longer needs a cast.** Under
+  `strictFunctionTypes` the narrower parameter types made the real `Client`
+  unassignable to `LibSqlLike`, so wiring libSQL the obvious way required
+  `client as unknown as LibSqlLike` — a cast even Keel's own tests carried.
+
+- **`createTeam()` could not give two people with the same name a team.** It slugged
+  the name into a `UNIQUE` column, so the second "Ada" to sign up got a 500. Looking
+  for a free slug first is check-then-act and loses the race anyway; the unique index
+  is the only real arbiter, so it now arbitrates and the insert retries.
+
+## [0.82.0] — 2026-07-12
+
+### Added
+
+- **Query builder: the methods people actually reach for.** `join`/`leftJoin`,
+  `groupBy`/`having`/`distinct`, `whereColumn`/`whereRaw`/`orderByRaw`, `when`,
+  `increment`/`decrement`, `upsert`/`insertOrIgnore`, and `chunk`, with docs.
+
+## [0.81.2] — 2026-07-12
+
+### Documentation
+
+- **The changelog is published to the docs site** (`docs/changelog.md`), so releases
+  are readable at keeljs.com rather than only in the repository.
+
 ## [0.81.1] — 2026-07-12
 
 ### Documentation
@@ -25,8 +111,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
-- **ORM: Eloquent-parity features.** The active-record `Model` grows most of the
-  Eloquent surface people reach for, all backward-compatible and still on the
+- **ORM: the features people reach for.** The active-record `Model` grows the
+  surface a real ORM needs, all backward-compatible and still on the
   driver-agnostic query builder (no JOINs, edge-safe):
 
   - **Lifecycle events & observers** — `creating`/`created`, `updating`/
@@ -91,8 +177,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
-- **Billing** — a new `@shaferllc/keel/billing` package: a Cashier-style
-  subscription layer with **one gateway-neutral API over Stripe and Paddle**
+- **Billing** — a new `@shaferllc/keel/billing` package: a subscription
+  layer with **one gateway-neutral API over Stripe and Paddle**
   (switching gateways is a config change). `class User extends Billable(Model)`
   gives a gateway customer, subscriptions (create/swap/quantity/trials/cancel/
   resume + status checks), single charges + refunds, invoices, hosted checkout,
@@ -286,7 +372,7 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
-- **Removed the Remult references** from the API-resources guide and source
+- **Removed comparisons to other frameworks** from the API-resources guide and source
   comments. Keel isn't that, and the docs shouldn't read as a comparison to another
   framework. The surrounding sentences are rewritten so they still say what the
   feature does rather than leaving a hole. No behavior change.
@@ -960,7 +1046,7 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   connection. They honor `X-Forwarded-Proto` / `X-Forwarded-Host` over the raw
   URL, so an app behind a TLS-terminating proxy or load balancer sees the
   client's real scheme and host — use `origin` to build absolute links and
-  `secure` to gate insecure requests. (Koa-inspired.)
+  `secure` to gate insecure requests.
 - **`response.back(fallback?)` and `redirect("back")`.** Redirect to the
   request's `Referer`, falling back to `fallback` (default `"/"`) when it's
   absent — the "return where you came from" shortcut for post-form flows.
@@ -1189,7 +1275,7 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - **Route config / metadata.** Attach arbitrary data to a route or group with
   `.config({ … })` and read it in the handler or route middleware via
   `request.route.config` — per-route flags like an auth scope, rate tier, or
-  layout choice (Fastify's route `config`). Group config merges into every route,
+  layout choice. Group config merges into every route,
   with a route's own keys winning. The matched-route context is now set *before*
   a route's middleware, so route/group middleware can branch on `request.route`.
   See [docs/routing.md](./docs/routing.md#route-config).
@@ -1236,7 +1322,7 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - **Response header helpers.** The `response` accessor gains `headers({...})` (set
   several at once), `getHeader(name)`, and `hasHeader(name)` — so middleware can
   inspect and conditionally set what a handler already put on the response (e.g.
-  a default `cache-control`). Brings `response` to parity with Fastify's Reply.
+  a default `cache-control`).
   See [docs/request-response.md](./docs/request-response.md).
 - **Design principles** documented in
   [docs/architecture.md](./docs/architecture.md#design-principles) — edge-safe /
@@ -1253,9 +1339,9 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   options at registration: `app.register(RateLimitProvider, { max: 100 })`, typed
   via `ServiceProvider<{ max: number }>` and read as `this.options`. The same
   provider class can register more than once with different options, so a provider
-  is now genuinely reusable (Fastify's `register(plugin, options)`). Backward
-  compatible — options default to `{}`. (Keel providers stay un-encapsulated by
-  design; per-request scoping is [middleware](./docs/middleware.md).) See
+  is now genuinely reusable. Backward compatible — options default to `{}`.
+  (Keel providers stay un-encapsulated by design; per-request scoping is
+  [middleware](./docs/middleware.md).) See
   [docs/providers.md](./docs/providers.md#providers-are-keels-plugin-system).
 
 [0.50.0]: https://github.com/shaferllc/keel/releases/tag/v0.50.0
@@ -1350,8 +1436,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   a bad request with a `422` `ValidationException` (errors from every part
   aggregated, keyed `body.field` / `query.field` / `params.field`) so the handler
   only ever sees valid input. `validated(part)` returns the parsed, typed value.
-  The declarative counterpart to Fastify's route schemas, built on the same
-  schema-agnostic `validate()` engine (bring your own Zod-style schema). See
+  Built on the same schema-agnostic `validate()` engine (bring your own
+  Zod-style schema). See
   [docs/validation.md](./docs/validation.md#declarative-validation-before-the-handler).
 
 [0.44.0]: https://github.com/shaferllc/keel/releases/tag/v0.44.0
@@ -1362,7 +1448,7 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - **Per-request logging.** `requestLogger()` middleware binds a child logger with
   a generated `reqId` to each request, so every log line within a request
-  correlates (Fastify's `request.log`). It logs request start/completion
+  correlates. It logs request start/completion
   (method, path, status, ms) by default; options for `genReqId`, reusing an
   incoming `idHeader` (distributed tracing), and disabling the auto lines.
   `requestLog()` reaches the current request's logger anywhere (falls back to the
@@ -1400,8 +1486,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   through the default path (with `code` in the JSON body) and passes
   `instanceof HttpException`. The built-in exceptions now carry stable codes too
   (`E_NOT_FOUND`, `E_UNAUTHORIZED`, `E_FORBIDDEN`, `E_VALIDATION`), so `code`
-  surfaces without any work. Inspired by Fastify's `@fastify/error`. Also
-  documented: serving over **HTTP/2** needs no framework code — it's a transport
+  surfaces without any work. Also documented: serving over **HTTP/2** needs no
+  framework code — it's a transport
   concern handled by the edge platform, a reverse proxy, or a `@hono/node-server`
   `node:http2` option. See [docs/errors.md](./docs/errors.md#coded-errors-with-createerror)
   and [docs/hono.md](./docs/hono.md#serving-over-http2).
@@ -1435,8 +1521,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - **Raw request-body accessors.** `request.text()`, `request.arrayBuffer()`, and
   `request.blob()` read the body for content types `json()` / `all()` don't
   handle — XML, CSV, protobuf, msgpack, or any custom format — which you then
-  parse yourself. Keel keeps body parsing explicit (no Fastify-style content-type
-  parser registry): you call the accessor you want. See
+  parse yourself. Keel keeps body parsing explicit (no content-type parser
+  registry): you call the accessor you want. See
   [docs/request-response.md](./docs/request-response.md#other-content-types).
 
 [0.40.1]: https://github.com/shaferllc/keel/releases/tag/v0.40.1
@@ -1450,9 +1536,8 @@ adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   life of the request. `decorateRequest(name, resolver)` registers a resolver
   (sync or async), `decorated(name)` reads it (computed once, then cached),
   `setRequestValue(name, value)` sets it imperatively (e.g. from middleware), and
-  `hasRequestDecorator(name)` checks. Inspired by Fastify's `decorateRequest`,
-  but without the null-placeholder/`onRequest`-hook dance — the per-request memo
-  is keyed off the context via a WeakMap, so nothing leaks between requests.
+  `hasRequestDecorator(name)` checks. The per-request memo is keyed off the
+  context via a WeakMap, so nothing leaks between requests.
   (Decorating the *app* is already the container's job.) See
   [docs/decorators.md](./docs/decorators.md).
 

package/docs/decorators.md

@@ -2,10 +2,9 @@
 
 Attach named, computed values to the current request — `request.user`,
 `request.tenant`, `request.locale` — resolved **lazily** and **memoized for the
-life of the request**. Inspired by [Fastify's decorators](https://fastify.dev/docs/latest/Reference/Decorators/),
-but without the footguns: you register a resolver once, and Keel computes it on
+life of the request**. You register a resolver once, and Keel computes it on
 first access and caches it per request. No null-placeholder declaration, no
-`onRequest` hook to remember, no shared-state leak between requests.
+shared-state leak between requests.
 
 > Decorating the **application** is already the [service container's](./container.md)
 > job — `bind` / `singleton` / `instance` / `make`, with `bound()` as
@@ -53,9 +52,6 @@ setRequestValue("user", theAuthenticatedUser);
 const user = await decorated("user"); // returns the value set above, no re-lookup
 ```
 
-This is the clean version of Fastify's "declare a placeholder, set it in an
-`onRequest` hook" pattern.
-
 ## Why lazy + memoized
 
 Resolving the current user (or tenant, or locale, or a feature-flag set) is the

package/docs/errors.md

@@ -185,7 +185,7 @@ subclasses don't define either — they render through the default path.
 
 When all you want is a coded error class — a stable `code`, a message, a status —
 skip the boilerplate and mint one with `createError`. It's the ergonomic shortcut
-for the common case, inspired by Fastify's `@fastify/error`:
+for the common case:
 
 ```ts
 import { createError } from "@shaferllc/keel/core";

package/docs/hooks.md

@@ -1,9 +1,7 @@
 # Lifecycle Hooks
 
 Tap into the **application lifecycle** — run code once the app is ready, clean up
-on shutdown, and observe route registration. Inspired by
-[Fastify's hooks](https://fastify.dev/docs/latest/Reference/Hooks/), scoped to the
-parts Keel doesn't already cover.
+on shutdown, and observe route registration.
 
 > **Request-lifecycle hooks** (before/after a request, on error) are
 > [middleware](./middleware.md) in Keel — `HttpKernel.use()`, route/group

package/docs/logger.md

@@ -156,8 +156,8 @@ With no options it defaults to `level: "info"`, `pretty: false`, and no bindings
 
 `requestLogger()` is a built-in middleware that binds a **child logger with a
 generated `reqId` to each request**, so every log line within a request
-correlates — Fastify's `request.log`. Install it in your HTTP kernel, then reach
-the request's logger anywhere with `requestLog()`:
+correlates. Install it in your HTTP kernel, then reach the request's logger
+anywhere with `requestLog()`:
 
 ```ts
 import { requestLogger, requestLog } from "@shaferllc/keel/core";

package/docs/packages.md

@@ -7,9 +7,9 @@ adds the conventions a *shippable* package needs so it can carry its own schema
 and assets instead of asking the app to wire them by hand.
 
 [Keel Watch](./watch.md) — the debug dashboard — is a first-party package and the
-reference implementation of everything below. [Billing](./billing.md) (a Cashier
-port for Stripe and Paddle) is another, and shows a package contributing models,
-a schema migration, gateway drivers, and verified webhook routes.
+reference implementation of everything below. [Billing](./billing.md) (Stripe and
+Paddle subscriptions) is another, and shows a package contributing models, a
+schema migration, gateway drivers, and verified webhook routes.
 
 ## The shape of a package
 

package/docs/providers.md

@@ -111,12 +111,12 @@ app.register(RateLimitProvider, { max: 100 }); // parameterized, like a plugin
 The same provider class can be registered more than once with different options.
 Without options, `this.options` is an empty object.
 
-> Unlike Fastify plugins, Keel providers are **not encapsulated** — bindings,
-> decorators, and routes are registered into the one global container. That's a
-> deliberate simplification: there's a single, predictable scope, and no
-> plugin-boundary rules to reason about. For per-request behavior in the HTTP
-> pipeline (auth, logging, etc.), reach for [middleware](./middleware.md), which
-> *is* scoped to the routes you attach it to.
+> Keel providers are **not encapsulated** — bindings, decorators, and routes are
+> registered into the one global container. That's a deliberate simplification:
+> there's a single, predictable scope, and no plugin-boundary rules to reason
+> about. For per-request behavior in the HTTP pipeline (auth, logging, etc.),
+> reach for [middleware](./middleware.md), which *is* scoped to the routes you
+> attach it to.
 
 ## Generating a provider
 

package/docs/request-response.md

@@ -51,8 +51,8 @@ and host (handy for building absolute links or forcing HTTPS).
 
 `all()` understands JSON and form bodies. For anything else — XML, CSV, a binary
 payload, a custom format — read the raw body and parse it yourself. There's no
-content-type parser registry to configure (unlike Fastify): parsing is explicit,
-so you call the accessor you want.
+content-type parser registry to configure: parsing is explicit, so you call the
+accessor you want.
 
 ```ts
 await request.text();          // the body as a string  (XML, CSV, …)

package/docs/testing.md

@@ -2,8 +2,7 @@
 
 Test your app by **injecting requests** — no server, no port, no network — and
 asserting on the response. `testClient()` wraps your app's Hono instance (which
-already does fetch-style injection) with verb helpers and fluent assertions, the
-way Fastify's `inject()` works.
+already does fetch-style injection) with verb helpers and fluent assertions.
 
 ## The client
 

package/docs/validation.md

@@ -112,8 +112,7 @@ router.get("/posts/:id", [Posts, "show"]).middleware([
 
 `validated(part)` returns the parsed, typed value for that part (defaults to
 `"body"`). Coercion (`z.coerce.number()`) is the schema's job — it applies before
-your handler sees the value. This is the declarative counterpart to Fastify's
-route schemas, on top of the same `validate()` engine.
+your handler sees the value. Built on the same `validate()` engine.
 
 ## Body parsing is JSON-only
 

package/llms-full.txt

@@ -1233,12 +1233,12 @@ app.register(RateLimitProvider, { max: 100 }); // parameterized, like a plugin
 The same provider class can be registered more than once with different options.
 Without options, `this.options` is an empty object.
 
-> Unlike Fastify plugins, Keel providers are **not encapsulated** — bindings,
-> decorators, and routes are registered into the one global container. That's a
-> deliberate simplification: there's a single, predictable scope, and no
-> plugin-boundary rules to reason about. For per-request behavior in the HTTP
-> pipeline (auth, logging, etc.), reach for [middleware](./middleware.md), which
-> *is* scoped to the routes you attach it to.
+> Keel providers are **not encapsulated** — bindings, decorators, and routes are
+> registered into the one global container. That's a deliberate simplification:
+> there's a single, predictable scope, and no plugin-boundary rules to reason
+> about. For per-request behavior in the HTTP pipeline (auth, logging, etc.),
+> reach for [middleware](./middleware.md), which *is* scoped to the routes you
+> attach it to.
 
 ## Generating a provider
 
@@ -3102,8 +3102,8 @@ and host (handy for building absolute links or forcing HTTPS).
 
 `all()` understands JSON and form bodies. For anything else — XML, CSV, a binary
 payload, a custom format — read the raw body and parse it yourself. There's no
-content-type parser registry to configure (unlike Fastify): parsing is explicit,
-so you call the accessor you want.
+content-type parser registry to configure: parsing is explicit, so you call the
+accessor you want.
 
 ```ts
 await request.text();          // the body as a string  (XML, CSV, …)
@@ -5559,10 +5559,9 @@ all gates/policies/hooks (a test helper).
 
 # Billing
 
-Keel Billing is a subscription-billing layer — a port of [Laravel
-Cashier](https://laravel.com/docs/13.x/billing) — for charging customers,
-managing subscriptions, and reconciling gateway state through webhooks. It ships
-as a Keel [package](./packages.md) and supports two gateways behind one API:
+Keel Billing is a subscription-billing layer for charging customers, managing
+subscriptions, and reconciling gateway state through webhooks. It ships as a
+Keel [package](./packages.md) and supports two gateways behind one API:
 **Stripe** and **Paddle**.
 
 It attaches to a model with a mixin. Your `User` becomes billable, gains a
@@ -5780,8 +5779,8 @@ resolveBillableUsing(async (customerId) => {
 The migration is gateway-neutral: `subscriptions` (with `gateway`,
 `provider_id`, `provider_status`, `provider_price`, trial/grace timestamps),
 `subscription_items`, and columns on `users` (`billing_gateway`,
-`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). Cashier
-targets the standard `users` billable table.
+`billing_customer_id`, `pm_type`, `pm_last_four`, `trial_ends_at`). The default
+migration targets the standard `users` billable table.
 
 ## Testing
 
@@ -8162,10 +8161,9 @@ arguments still halts the request and renders an empty page.
 
 Attach named, computed values to the current request — `request.user`,
 `request.tenant`, `request.locale` — resolved **lazily** and **memoized for the
-life of the request**. Inspired by [Fastify's decorators](https://fastify.dev/docs/latest/Reference/Decorators/),
-but without the footguns: you register a resolver once, and Keel computes it on
+life of the request**. You register a resolver once, and Keel computes it on
 first access and caches it per request. No null-placeholder declaration, no
-`onRequest` hook to remember, no shared-state leak between requests.
+shared-state leak between requests.
 
 > Decorating the **application** is already the [service container's](./container.md)
 > job — `bind` / `singleton` / `instance` / `make`, with `bound()` as
@@ -8213,9 +8211,6 @@ setRequestValue("user", theAuthenticatedUser);
 const user = await decorated("user"); // returns the value set above, no re-lookup
 ```
 
-This is the clean version of Fastify's "declare a placeholder, set it in an
-`onRequest` hook" pattern.
-
 ## Why lazy + memoized
 
 Resolving the current user (or tenant, or locale, or a feature-flag set) is the
@@ -8479,7 +8474,7 @@ subclasses don't define either — they render through the default path.
 
 When all you want is a coded error class — a stable `code`, a message, a status —
 skip the boilerplate and mint one with `createError`. It's the ergonomic shortcut
-for the common case, inspired by Fastify's `@fastify/error`:
+for the common case:
 
 ```ts
 import { createError } from "@shaferllc/keel/core";
@@ -10418,9 +10413,7 @@ implementing anything — the same `fetch` handler just gets served over it.
 # Lifecycle Hooks
 
 Tap into the **application lifecycle** — run code once the app is ready, clean up
-on shutdown, and observe route registration. Inspired by
-[Fastify's hooks](https://fastify.dev/docs/latest/Reference/Hooks/), scoped to the
-parts Keel doesn't already cover.
+on shutdown, and observe route registration.
 
 > **Request-lifecycle hooks** (before/after a request, on error) are
 > [middleware](./middleware.md) in Keel — `HttpKernel.use()`, route/group
@@ -11585,8 +11578,8 @@ With no options it defaults to `level: "info"`, `pretty: false`, and no bindings
 
 `requestLogger()` is a built-in middleware that binds a **child logger with a
 generated `reqId` to each request**, so every log line within a request
-correlates — Fastify's `request.log`. Install it in your HTTP kernel, then reach
-the request's logger anywhere with `requestLog()`:
+correlates. Install it in your HTTP kernel, then reach the request's logger
+anywhere with `requestLog()`:
 
 ```ts
 import { requestLogger, requestLog } from "@shaferllc/keel/core";
@@ -14956,9 +14949,9 @@ adds the conventions a *shippable* package needs so it can carry its own schema
 and assets instead of asking the app to wire them by hand.
 
 [Keel Watch](./watch.md) — the debug dashboard — is a first-party package and the
-reference implementation of everything below. [Billing](./billing.md) (a Cashier
-port for Stripe and Paddle) is another, and shows a package contributing models,
-a schema migration, gateway drivers, and verified webhook routes.
+reference implementation of everything below. [Billing](./billing.md) (Stripe and
+Paddle subscriptions) is another, and shows a package contributing models, a
+schema migration, gateway drivers, and verified webhook routes.
 
 ## The shape of a package
 
@@ -19171,8 +19164,7 @@ construct it directly.
 
 Test your app by **injecting requests** — no server, no port, no network — and
 asserting on the response. `testClient()` wraps your app's Hono instance (which
-already does fetch-style injection) with verb helpers and fluent assertions, the
-way Fastify's `inject()` works.
+already does fetch-style injection) with verb helpers and fluent assertions.
 
 ## The client
 
@@ -20355,8 +20347,7 @@ router.get("/posts/:id", [Posts, "show"]).middleware([
 
 `validated(part)` returns the parsed, typed value for that part (defaults to
 `"body"`). Coercion (`z.coerce.number()`) is the schema's job — it applies before
-your handler sees the value. This is the declarative counterpart to Fastify's
-route schemas, on top of the same `validate()` engine.
+your handler sees the value. Built on the same `validate()` engine.
 
 ## Body parsing is JSON-only
 

package/llms.txt

@@ -15,7 +15,7 @@ Userland imports everything from `@shaferllc/keel/core`.
 - [Architecture](https://github.com/shaferllc/keel/blob/main/docs/architecture.md): Keel is small on purpose. This page maps the pieces and traces a request from socket to response. Nothing here is magic — every layer is a short, readable file in src/core/, and this guide is mostly a reading order for it.
 - [Authentication](https://github.com/shaferllc/keel/blob/main/docs/authentication.md): Session-based auth built on the pieces you already have: sessions hold the login, hashing checks passwords.
 - [Authorization](https://github.com/shaferllc/keel/blob/main/docs/authorization.md): Where authentication answers who you are, authorization answers what you're allowed to do.
-- [Billing](https://github.com/shaferllc/keel/blob/main/docs/billing.md): Keel Billing is a subscription-billing layer — a port of Laravel Cashier — for charging customers, managing subscriptions, and reconciling gateway state through webhooks.
+- [Billing](https://github.com/shaferllc/keel/blob/main/docs/billing.md): Keel Billing is a subscription-billing layer for charging customers, managing subscriptions, and reconciling gateway state through webhooks.
 - [Broadcasting](https://github.com/shaferllc/keel/blob/main/docs/broadcasting.md): Push events to clients in real time over named channels.
 - [Service Broker](https://github.com/shaferllc/keel/blob/main/docs/broker.md): Structure an application as services that talk to each other by name instead of by import.
 - [Cache](https://github.com/shaferllc/keel/blob/main/docs/cache.md): A small cache with TTLs and the remember pattern.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaferllc/keel",
-  "version": "0.83.0",
+  "version": "0.83.1",
   "type": "module",
   "description": "The house framework for Node.js — a service container, providers, routing, JSX views, and a code-generating console.",
   "license": "MIT",