@jskit-ai/agent-docs 0.1.282 → 0.1.284

package/skills/jskit/references/patterns/app/minimal-foundation/example/server.js

@@ -1,6 +1,6 @@
 import Fastify from "fastify";
 import SerializerSelector from "@fastify/fast-json-stringify-compiler";
-import { createCachedResponseSerializerFactory } from "@jskit-ai/kernel/server/http";
+import { createCachedResponseSerializerFactory, resolveTrustedProxies } from "@jskit-ai/kernel/server/http";
 import fastifyStatic from "@fastify/static";
 import { buildLoggerOptions } from "./server/lib/loggerOptions.js";
 import { resolveRuntimeEnv } from "./server/lib/runtimeEnv.js";
@@ -94,6 +94,9 @@ function canServeStaticFile(distRoot, relativePath) {
 async function createServer({ runtimeEnv }) {
   const app = Fastify({
     logger: buildLoggerOptions(),
+    // The proxies in front of the server (TRUSTED_PROXIES; loopback without it), so request.ip and the rate limits
+    // counted by it are each client's address behind them.
+    trustProxy: resolveTrustedProxies(runtimeEnv),
     schemaController: {
       compilersFactory: {
         buildSerializer: createCachedResponseSerializerFactory(SerializerSelector())

package/skills/jskit/references/patterns/app/shell-foundation/example/AGENTS.md

@@ -8,6 +8,10 @@ Framework references:
 - `https://mobily-enterprises.github.io/jskit-ai/guide/`
 - `https://mobily-enterprises.github.io/jskit-ai/patterns/`
 
+Before writing or reviewing code that reads or writes a database table, read
+the data access guide at
+`https://mobily-enterprises.github.io/jskit-ai/guide/framework/data-access`.
+
 Before writing or reviewing server code (a feature, provider, action, service,
 repository, route, error or test), read the typed features guide at
 `https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features`.

package/skills/jskit/references/patterns/app/shell-foundation/example/package.json

@@ -34,7 +34,7 @@
   "dependencies": {
     "@local/main": "0.1.0",
     "@fastify/static": "^10.1.3",
-    "@jskit-ai/kernel": "0.2.13",
+    "@jskit-ai/kernel": "0.2.14",
     "@jskit-ai/material-web": "0.1.3",
     "@tanstack/vue-query": "^5.101.0",
     "fastify": "^5.12.7",
@@ -44,14 +44,14 @@
     "vue": "^3.5.44",
     "vue-router": "^5.3.1",
     "vuetify": "^4.3.0",
-    "@jskit-ai/http-runtime": "0.2.13",
-    "@jskit-ai/shell-web": "0.2.16",
+    "@jskit-ai/http-runtime": "0.2.14",
+    "@jskit-ai/shell-web": "0.2.17",
     "@fastify/fast-json-stringify-compiler": "^5.1.0",
     "@vue/devtools-api": "^8.2.1"
   },
   "devDependencies": {
-    "@jskit-ai/config-eslint": "0.1.246",
-    "@jskit-ai/jskit-catalog": "0.2.34",
+    "@jskit-ai/config-eslint": "0.1.247",
+    "@jskit-ai/jskit-catalog": "0.2.36",
     "@playwright/test": "1.61.1",
     "@vitejs/plugin-vue": "^6.0.7",
     "eslint": "^10.8.0",

package/skills/jskit/references/patterns/app/shell-foundation/example/packages/main/package.json

@@ -9,7 +9,7 @@
   },
   "description": "App-local runtime composition and lightweight glue.",
   "dependencies": {
-    "@jskit-ai/kernel": "0.2.13"
+    "@jskit-ai/kernel": "0.2.14"
   },
   "jskit": {
     "kind": "runtime",

package/skills/jskit/references/patterns/app/shell-foundation/example/server.js

@@ -1,6 +1,6 @@
 import Fastify from "fastify";
 import SerializerSelector from "@fastify/fast-json-stringify-compiler";
-import { createCachedResponseSerializerFactory } from "@jskit-ai/kernel/server/http";
+import { createCachedResponseSerializerFactory, resolveTrustedProxies } from "@jskit-ai/kernel/server/http";
 import fastifyStatic from "@fastify/static";
 import { buildLoggerOptions } from "./server/lib/loggerOptions.js";
 import { resolveRuntimeEnv } from "./server/lib/runtimeEnv.js";
@@ -94,6 +94,9 @@ function canServeStaticFile(distRoot, relativePath) {
 async function createServer({ runtimeEnv }) {
   const app = Fastify({
     logger: buildLoggerOptions(),
+    // The proxies in front of the server (TRUSTED_PROXIES; loopback without it), so request.ip and the rate limits
+    // counted by it are each client's address behind them.
+    trustProxy: resolveTrustedProxies(runtimeEnv),
     schemaController: {
       compilersFactory: {
         buildSerializer: createCachedResponseSerializerFactory(SerializerSelector())

package/skills/jskit/references/patterns/assistant/assistant-surface/PATTERN.md

@@ -48,8 +48,11 @@ in source or a questionnaire transcript.
 
 Use `AssistantSurfaceClientElement` and `AssistantSettingsClientElement` from
 `@jskit-ai/assistant-runtime/client`. Install the runtime package through the
-normal package-capability path. Configure `assistantSurfaces` in public config
-and `assistantServer` in server config.
+normal package-capability path. Install `@jskit-ai/resource-runtime` and
+register `AssistantStoreFeature` from `@jskit-ai/assistant-runtime/server` in
+the ordinary server feature list; it owns the assistant's tables and provides the
+repositories the database-backed surface uses. Configure `assistantSurfaces` in
+public config and `assistantServer` in server config.
 
 ## Example files
 

package/skills/jskit/references/patterns/auth/accounts-hub/example/package.json

@@ -2,7 +2,8 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/database-runtime-mysql": "0.1.260",
-    "@jskit-ai/oidc-issuer-core": "0.1.21"
+    "@jskit-ai/database-runtime": "0.1.263",
+    "@jskit-ai/database-runtime-mysql": "0.1.261",
+    "@jskit-ai/oidc-issuer-core": "0.1.22"
   }
 }

package/skills/jskit/references/patterns/auth/auth-surface/PATTERN.md

@@ -120,6 +120,21 @@ the standard app-owned managed-preview identity executable,
 surface and placement declarations into the application's ordinary config and
 placement files.
 
+The pages live under `src/pages/auth/`, so the app defines an `auth` surface
+open to everyone in `config/public.js`, under the foundations' `public` access
+policy (`surfaceAccessPolicies.public = {}`):
+
+```js
+config.surfaceDefinitions.auth = {
+  id: "auth",
+  label: "Sign in",
+  pagesRoot: "auth",
+  requiresAuth: false,
+  requiresWorkspace: false,
+  accessPolicyId: "public"
+};
+```
+
 ## Variation points
 
 Change provider, routes, labels, page wrappers, permitted login methods, profile

package/skills/jskit/references/patterns/auth/oidc-sign-in/example/package.json

@@ -2,7 +2,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/auth-provider-oidc-core": "0.2.20",
-    "@jskit-ai/auth-web": "0.2.18"
+    "@jskit-ai/auth-provider-oidc-core": "0.2.21",
+    "@jskit-ai/auth-web": "0.2.19"
   }
 }

package/skills/jskit/references/patterns/auth/supabase-auth/example/package.json

@@ -2,6 +2,6 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/auth-provider-supabase-core": "0.2.15"
+    "@jskit-ai/auth-provider-supabase-core": "0.2.16"
   }
 }

package/skills/jskit/references/patterns/connectors/calendar-cli/example/package.json

@@ -7,10 +7,10 @@
     "db:migrate:status": "knex --knexfile ./knexfile.js migrate:list"
   },
   "dependencies": {
-    "@jskit-ai/connectors-core": "0.2.14",
-    "@jskit-ai/connector-google-calendar": "0.2.14",
-    "@jskit-ai/database-runtime": "0.1.262",
-    "@jskit-ai/database-runtime-mysql": "0.1.260",
+    "@jskit-ai/connectors-core": "0.2.15",
+    "@jskit-ai/connector-google-calendar": "0.2.15",
+    "@jskit-ai/database-runtime": "0.1.263",
+    "@jskit-ai/database-runtime-mysql": "0.1.261",
     "knex": "^3.1.0"
   }
 }

package/skills/jskit/references/patterns/crud/crud-contract/PATTERN.md

@@ -0,0 +1,133 @@
+---
+id: crud/crud-contract
+title: Owner-scoped CRUD contract
+summary: Define an application table resource whose records belong to the current user, and the authenticated CRUD contract that serves it.
+keywords: authenticated, crud, database, owner-scoped, resource, table, user
+requires: @jskit-ai/resource-core, @jskit-ai/resource-crud-core
+---
+
+# Owner-scoped CRUD contract
+
+## Use when
+
+Use this pattern when an authenticated application stores records that belong
+to one user and standard list, view, create, patch, and delete behaviour fits
+the product.
+
+The example is intentionally a normal source file. Copy it directly when the
+shape fits, adapt its fields and language for another entity, or read it as a
+reference for `defineTableResource()` and `defineCrudContract()`.
+
+## Do not use when
+
+Do not use this pattern for public records, workspace-owned records, inherited
+ownership, composite identities, or a domain whose operations do not match
+normal CRUD behaviour. Select a pattern matching the real ownership and
+operation model instead of changing `ownership` merely to make a test pass.
+
+## Product decisions
+
+Know these decisions before adapting the example:
+
+- whether records truly belong to the current user
+- which fields are required, optional, nullable, searchable, or hidden
+- whether a value is free text or a constrained vocabulary
+- which operations the product actually exposes
+- the user-facing success and failure language
+
+Those decisions come from the product conversation or existing application,
+not from a JSKIT questionnaire.
+
+## Invariants
+
+- The persisted table has a normal single-column primary key.
+- User ownership is represented by a non-null `user_id` column.
+- The resource's hidden `userId` field maps to that ownership column.
+- `ownership: "user"` is used only for genuine current-user ownership.
+- The table has exactly one table resource; the CRUD contract is built on it.
+- Each field the API shows or accepts has an entry in the CRUD contract's
+  `fields` stating its output, create and patch participation; a field without
+  one is neither shown nor accepted (see Field operations and lookups below).
+- Temporal database values use the declared storage serializer.
+- The source-controlled migration and the table resource agree.
+- Server policy tests prove that one user cannot read or mutate another user's
+  records.
+
+## Framework APIs
+
+The example uses `defineTableResource()` from
+`@jskit-ai/resource-core/shared/tableResource` for the table's facts (name,
+table, ownership, fields, search and sort) and `defineCrudContract()` from
+`@jskit-ai/resource-crud-core/shared/crudContract` for its HTTP surface
+(its required `namespace`, operations, access, field operations and messages). The CRUD contract derives
+the normal CRUD operation validators from the table resource's fields.
+
+Higher layers should consume this resource through JSKIT's CRUD service,
+repository, route, and UI APIs. They should not rebuild field validators or
+serialize requests independently.
+
+## Field operations and lookups
+
+The CRUD contract's `fields` name, for each field, the operations it takes part
+in: `output` (the record in every response), and `create` and `patch` (the
+request bodies; an enabled `replace` uses the `create` fields unless a field
+names `replace`). Each takes `"required"`, `"optional"` or an object, for
+example `title: { output: "required", create: "required", patch: "optional" }`.
+
+A contract shows and accepts only the fields it names: a field without an entry
+is not in any output, a body that sends it is refused, and the CRUD service
+leaves it out of the records it answers. So a column added to the table later
+stays out of every API until a contract names it. Every record output carries
+its `id` without an entry, and a stored `createdAt` or `updatedAt` is output
+without one.
+
+A stored `createdAt` or `updatedAt` is output only, and a contract that lets a
+request write one (a `create`, `patch` or `replace` entry, or an explicit body
+that takes it) is refused: the handle stamps `createdAt` on a create and
+`updatedAt` on every write, replacing what a request sends. Only a system
+context, as an import uses, sets its own.
+
+A lookup field (`lookup: "<namespace>"`) is the table resource's: the
+`database/table-resource` pattern lists what it expands to.
+
+## Example files
+
+- `example/bookResource.js` is a complete table resource (`bookResource`) and
+  CRUD contract (`bookCrud`) for personal book records.
+
+The example deliberately uses a concrete domain. Rename and edit normal source
+rather than feeding it through placeholder interpolation.
+
+## Variation points
+
+Safe adaptations include:
+
+- resource name, table name and CRUD namespace
+- product fields and validation
+- searchable fields and default sort
+- enabled CRUD operations
+- user-facing messages
+- lookup relationships supported by the resource APIs
+
+Changing ownership, access, identity, or persistence architecture selects a
+different pattern and requires corresponding policy and migration evidence.
+
+## Verification
+
+- Import the CRUD contract and prove all intended operations exist.
+- Validate representative accepted and rejected field values.
+- Rebuild the table from source-controlled migrations in a disposable database.
+- Run positive current-user CRUD tests.
+- Run negative cross-user read and mutation tests.
+- Run the application's focused tests and broad verifier at sign-off.
+
+## Avoid
+
+- generator provenance or scaffold-shape metadata
+- a field-by-field questionnaire
+- a live table as the only source of schema truth
+- app-specific request serializers that duplicate the CRUD contract
+- a second table resource for the same table
+- hidden ownership aliases other than the framework's explicit ownership field
+- durable receipts recording that this pattern was copied
+- changing an installed baseline migration instead of adding a new migration

package/skills/jskit/references/patterns/crud/crud-contract/example/bookResource.js

@@ -0,0 +1,74 @@
+import { defineTableResource } from "@jskit-ai/resource-core/shared/tableResource";
+import { defineCrudContract } from "@jskit-ai/resource-crud-core/shared/crudContract";
+
+const bookResource = defineTableResource({
+  name: "books",
+  tableName: "books",
+  ownership: "user",
+  schema: {
+    userId: {
+      type: "id",
+      required: true,
+      hidden: true
+    },
+    title: {
+      type: "string",
+      maxLength: 255,
+      required: true,
+      search: true
+    },
+    author: {
+      type: "string",
+      maxLength: 255,
+      required: true,
+      search: true
+    },
+    notes: {
+      type: "string",
+      maxLength: 65535,
+      nullable: true,
+      search: true
+    },
+    createdAt: {
+      type: "dateTime",
+      temporalPrecision: 0,
+      storage: { writeSerializer: "datetime-utc" }
+    },
+    updatedAt: {
+      type: "dateTime",
+      temporalPrecision: 0,
+      storage: { writeSerializer: "datetime-utc" }
+    }
+  },
+  searchSchema: {
+    q: {
+      type: "string",
+      oneOf: ["title", "author", "notes"],
+      filterOperator: "like",
+      splitBy: " ",
+      matchAll: true
+    }
+  },
+  defaultSort: ["-createdAt"]
+});
+
+const bookCrud = defineCrudContract(bookResource, {
+  namespace: "books",
+  apiAccess: "authenticated",
+  fields: {
+    title: { output: "required", create: "required", patch: "optional" },
+    author: { output: "required", create: "required", patch: "optional" },
+    notes: { output: "required", create: "optional", patch: "optional" },
+    createdAt: { output: "required" },
+    updatedAt: { output: "required" }
+  },
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Book saved.",
+    saveError: "Unable to save this book.",
+    deleteSuccess: "Book deleted.",
+    deleteError: "Unable to delete this book."
+  }
+});
+
+export { bookCrud, bookResource };

package/skills/jskit/references/patterns/crud/{json-api-resource-package → crud-feature-package}/PATTERN.md

@@ -1,19 +1,20 @@
 ---
-id: crud/json-api-resource-package
-title: JSON API CRUD resource package
-summary: Build a complete application-owned CRUD server package from a migration, resource contract, and one framework module declaration.
-keywords: actions, crud, database, json-api, migration, permissions, provider, repository, routes, service
-requires: @jskit-ai/crud-core, @jskit-ai/resource-crud-core
+id: crud/crud-feature-package
+title: CRUD feature package
+summary: Build a complete application-owned CRUD server package from a migration, a table resource with its CRUD contract, and one framework module declaration.
+keywords: actions, crud, database, defineCrudFeature, json-api, migration, owns, permissions, repository, routes, service, table resource
+requires: @jskit-ai/crud-core, @jskit-ai/resource-core, @jskit-ai/resource-crud-core
 ---
 
-# JSON API CRUD resource package
+# CRUD feature package
 
 ## Use when
 
 Use this pattern when a product entity needs conventional JSON API list, view,
 create, patch, and delete behavior. JSKIT owns the repeated repository, service,
 action, route, and provider mechanics. The application owns the migration,
-resource contract, access surface, ownership policy, and package composition.
+table resource, CRUD contract, access surface, ownership policy, and package
+composition.
 
 ## Do not use when
 
@@ -30,8 +31,10 @@ from a generator questionnaire or treat a live table as the sole contract.
 
 ## Invariants
 
-- Migration and resource storage metadata describe the same table.
-- `apiAccess`, surface access, and `autofilter` agree.
+- The migration and the table resource's storage metadata describe the same
+  table, and that table has no other table resource.
+- The CRUD contract's `apiAccess`, surface access, and the table resource's
+  `ownership` agree.
 - Public routes use public ownership only.
 - Workspace routes receive explicit scope validators and route-to-action input:
   workspaces-core's `WORKSPACE_CRUD_SCOPE`, never a copied scope literal.
@@ -55,10 +58,15 @@ from a generator questionnaire or treat a live table as the sole contract.
 
 ## Framework APIs
 
-Use `defineCrudResource()` from `@jskit-ai/resource-crud-core` and
-`defineCrudJsonApiFeature()` from `@jskit-ai/crud-core`. The latter composes the
-JSON REST resource, repository, service, standard CRUD actions with their
-record-changed events, route contracts, access policy, and HTTP routes.
+Use `defineTableResource()` from `@jskit-ai/resource-core`,
+`defineCrudContract()` from `@jskit-ai/resource-crud-core` and
+`defineCrudFeature()` from `@jskit-ai/crud-core`. The feature takes the CRUD
+contract as `crud` and owns its table resource: its repository is the table's
+handle, and it composes the CRUD service, standard CRUD actions with their
+record-changed events, route contracts, access policy, and HTTP routes. The
+routes' visibility and the rows each call reaches follow the table resource's
+`ownership`. More tables the feature owns go in `owns`, and so do the CRUD
+table's server-only extras (`{ resource: bookResource, rowPolicy, hooks }`).
 
 ## Example files
 
@@ -80,8 +88,8 @@ For a package-owned migration instead, declare its actual directory in
 `package.json#jskit.migrations.directories`, as described in the database-layer
 guide.
 
-`BooksFeature.js` is deliberately tiny: it binds the readable resource contract
-to the framework module and exports the resulting provider.
+`BooksFeature.js` is deliberately tiny: it binds the `bookCrud` contract to the
+framework module and exports the resulting provider.
 `types.js` declares the type of the `app.books` capability, for features that
 require it.
 
@@ -104,18 +112,17 @@ an unfiltered collection can satisfy a matching-row-only assertion.
 
 ## Variation points
 
-Change the package name, resource fields, table, surface, ownership filter,
+Change the package name, resource fields, table, ownership, surface,
 relative route, messages, and migration. Supply explicit permissions when the
 surface uses named policy. For workspace ownership, pass `scope:
 WORKSPACE_CRUD_SCOPE` (`@jskit-ai/workspaces-core/server/support/workspaceCrud`):
 the `/w/:workspaceSlug` route base, the workspace route and action validators
-and the slug input. A repository method of such a feature reads the workspace
-id with `resolveWorkspaceScopeValue(options.context)`
-(`@jskit-ai/json-rest-api-core/server/jsonRestApiHost`), and a
-hand-written workspace route's path is
+and the slug input. A repository method of such a feature passes the call's
+`options` on to its handle, which scopes every read and write to the caller's
+workspace, and a hand-written workspace route's path is
 `resolveWorkspaceRoutePath("relative-path")`
 (`@jskit-ai/workspaces-core/server/support/workspaceRoutePaths`). The feature exposes the
-operations declared by the resource. Use `operations` only to narrow that
+operations declared by the CRUD contract. Use `operations` only to narrow that
 surface further; do not register unused mutation actions and routes. Use
 `routes: false` only for an internal
 capability/action surface that deliberately has no HTTP API.
@@ -140,24 +147,29 @@ function of the action execution.
 
 When otherwise-standard CRUD earns product behavior, name the exact
 capabilities in `requires` and provide `decorateService({ service, repository,
-resource, ...dependencies })`. Retain the standard methods, override only the
-methods whose CRUD behavior changes, and add resource-related domain methods
-such as `confirmBooking()` or `sendReminder()` directly to that service. Those
-additional methods remain available through the resource capability. An
-overridden `createDocument()` returns the created record, with its id, as a
+crud, ...dependencies })`. Retain the standard methods (`list`, `view`,
+`create`, `patch`, `delete`), override only the methods whose CRUD behavior
+changes, and add resource-related domain methods such as `confirmBooking()` or
+`sendReminder()` directly to that service. Those additional methods remain
+available through the resource capability. An overridden `create()` returns
+the created record, with its id, as a
 tagged JSON:API result: a document result (`returnJsonApiDocument`), as the
 standard one does, or a data result (`returnJsonApiData(record)`). The create
 action's created and `record.changed` events read the record's id from it, and
 a create whose service returns an untagged document or record, or a result
 without the record's id, fails in every channel. When the
 product needs only a few additional queries or locking operations, provide
-`decorateRepository({ repository, database, http, jsonRestApi, resource,
-...dependencies })`; return the standard methods plus only those unique
-persistence operations instead of copying the CRUD repository.
+`decorateRepository({ repository, resources, crud, ...dependencies })`, where
+`repository` is the CRUD table's handle and `resources` holds the handle of
+every table the feature owns; return the handle's methods plus only those
+unique persistence operations, each taking the call's `options` last and
+passing them on untouched.
 
 Use `operationLifecycle` for behavior surrounding a standard operation. Its
 per-operation `before`, `execute`, and `after` phases share one repository
-transaction for create, update, and delete. An `execute` hook receives
+transaction for create, update, and delete: each receives `options`, the call
+options carrying the action context and that transaction, to pass on to every
+repository or service call it makes. An `execute` hook receives
 `standard(nextInput)` so it can retain the framework write while adjusting its
 input or coordinating other repository work, and returns what `standard()`
 returns: the operation's tagged JSON:API result (null for delete). A create's
@@ -173,7 +185,10 @@ service and repository its hooks call. Put durable external delivery behind an
 outbox written inside the transaction; do not make an email or webhook the
 arbiter of whether an already-committed request appears successful.
 
-Declare resource-related non-CRUD commands in `actions`. Each named action has
+Declare resource-related non-CRUD commands in `actions`. Each key is the
+action's name: lower case, starting with a letter, with only letters, digits,
+`_`, `.` and `-` (`cancel-day`, never `cancelDay`); its id is
+`crud.<namespace>.<name>`. Each named action has
 a normal JSKIT input, permission, audit, events, and `execute({ input, context,
 service, repository, ...dependencies })` contract. Type that argument with
 `CrudCustomActionInvocation` from `@jskit-ai/crud-core/server/types`. Its first
@@ -183,13 +198,15 @@ by local name; its third is the repository the action calls, when
 `decorateRepository` adds the method. Its optional `route`
 declares an HTTP method, path below the resource base, explicit route contract,
 status code, and optional request-to-action input mapper. This is the normal
-home for `confirm`, `publish`, `cancel`, `reorder`, or `sendReminder`. Move to a
+home for `confirm`, `publish`, `cancel`, `reorder`, or `send-reminder`. Move to a
 separate explicit feature only when the operation belongs to another domain or
 the resource is no longer principally CRUD.
 
 If a product-specific list filter needs additional transport validation and
 JSON API search mapping, pass its validator as `listFilterQueryValidator` and
-its storage mapping as `searchSchema`; keep that contract next to the feature.
+put its storage mapping in the table resource's `searchSchema` (or, when it is
+server-only, in the CRUD table's `owns` entry); keep that contract next to the
+feature.
 Use `operationInputs.create` or `operationInputs.update` when a standard CRUD
 operation intentionally accepts a small virtual product field that is handled
 by the service decorator rather than stored on the resource row.
@@ -234,15 +251,15 @@ function decorateBookingsService({ service, repository }) {
 ```
 
 ```js
-const BookingsFeature = defineCrudJsonApiFeature({
-  resource: bookingResource,
+const BookingsFeature = defineCrudFeature({
+  crud: bookingCrud,
   surface: "app",
   decorateRepository: decorateBookingsRepository,
   decorateService: decorateBookingsService,
   operationLifecycle: {
     update: {
-      async before({ input, service, trx, context }) {
-        await service.assertUpdateAllowed(input.recordId, { trx, context });
+      async before({ input, service, options }) {
+        await service.assertUpdateAllowed(input.recordId, options);
       },
       async afterCommit({ result, service, context }) {
         await service.recordUpdateCompleted(result.value.data.id, { context });
@@ -266,6 +283,21 @@ const BookingsFeature = defineCrudJsonApiFeature({
 });
 ```
 
+An action's `input` is one schema definition, `{ schema, mode }`, for
+everything it validates; its route contract names each part of the request it
+reads, `params`, `query` or `body`, each a schema definition, and the route
+hands the action their fields merged. A workspace scope adds `workspaceSlug` to
+both itself.
+
+```js
+import { createSchema } from "json-rest-schema";
+import { composeSchemaDefinitions, recordIdParamsValidator } from "@jskit-ai/kernel/shared/validators";
+
+const confirmBookingBody = { schema: createSchema({ note: { type: "string", maxLength: 500 } }), mode: "patch" };
+const confirmBookingInput = composeSchemaDefinitions([recordIdParamsValidator, confirmBookingBody], { mode: "patch" });
+const confirmBookingRouteContract = { params: recordIdParamsValidator, body: confirmBookingBody };
+```
+
 ## Verification
 
 - Rebuild the table from migrations in disposable MySQL and PostgreSQL databases

package/skills/jskit/references/patterns/crud/{json-api-resource-package → crud-feature-package}/example/packages/books/package.json

@@ -9,8 +9,9 @@
     "./shared": "./src/shared/index.js"
   },
   "dependencies": {
-    "@jskit-ai/crud-core": "0.2.14",
-    "@jskit-ai/resource-crud-core": "0.1.204"
+    "@jskit-ai/crud-core": "0.2.15",
+    "@jskit-ai/resource-core": "0.1.205",
+    "@jskit-ai/resource-crud-core": "0.1.205"
   },
   "jskit": {
     "kind": "runtime",
@@ -19,10 +20,10 @@
         "app.books"
       ],
       "requires": [
+        "crud.contracts",
         "runtime.http",
-        "runtime.json-rest-api",
         "runtime.actions",
-        "runtime.database"
+        "runtime.resources"
       ]
     },
     "runtime": {

package/skills/jskit/references/patterns/crud/crud-feature-package/example/packages/books/src/server/BooksFeature.js

@@ -0,0 +1,13 @@
+import { defineCrudFeature } from "@jskit-ai/crud-core/server/defineCrudFeature";
+import { bookCrud } from "../shared/bookResource.js";
+
+// Owns the books table and serves its CRUD contract.
+const BooksFeature = defineCrudFeature({
+  crud: bookCrud,
+  id: "app.books",
+  capability: "app.books",
+  surface: "app",
+  relativePath: "/books"
+});
+
+export { BooksFeature };