@jskit-ai/agent-docs 0.1.283 → 0.1.285

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.16",
+    "@jskit-ai/resource-core": "0.1.206",
+    "@jskit-ai/resource-crud-core": "0.1.206"
   },
   "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 };

package/skills/jskit/references/patterns/crud/crud-feature-package/example/packages/books/src/shared/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/crud-feature-package/example/packages/books/src/shared/index.js

@@ -0,0 +1 @@
+export { bookCrud, bookResource } from "./bookResource.js";

package/skills/jskit/references/patterns/crud/crud-screen-set/PATTERN.md

@@ -3,7 +3,7 @@ id: crud/crud-screen-set
 title: CRUD list, view, create, and edit screens
 summary: Build a routed CRUD user interface as thin application pages over JSKIT's shared screen components and composables.
 keywords: actions, add, crud, delete, edit, filters, list, material, routes, view, vue
-requires: @jskit-ai/http-web, @jskit-ai/resource-crud-core
+requires: @jskit-ai/http-web, @jskit-ai/resource-crud-core, @jskit-ai/resource-core
 ---
 
 # CRUD list, view, create, and edit screens
@@ -27,7 +27,7 @@ supporting detail content; those are public extension seams.
 
 Decide which operations exist, the route hierarchy, record title, visible
 fields, create/edit participation, destructive confirmation language, access
-surface, filters, and domain actions. The resource contract and product intent
+surface, filters, and domain actions. The CRUD contract and product intent
 are authoritative. Do not derive these decisions from a live table or a field
 questionnaire.
 
@@ -49,7 +49,7 @@ questionnaire.
   history entry, so neither Up nor Back reopens it.
 - View fields are two-line list items with the value first:
   `<v-list-item :title="record.author" subtitle="Author" />`.
-- Transport and validators come from the shared resource contract.
+- Transport and validators come from the shared CRUD contract.
 - Initial visible loading uses structure-matching skeletons; pending buttons use
   stable disabled labels, never spinners.
 - Resource-load errors stay inside the screen with retry. Command success and
@@ -71,15 +71,18 @@ questionnaire.
 Use `CrudListScreen`, `CrudViewScreen`, `CrudAddEditScreen`, and
 `CrudDeleteAction` with their matching composables from `@jskit-ai/http-web`.
 Use `defineCrudListFilters()`, `defineCrudListRowActions()`, and
-`defineCrudListBulkActions()` for optional list extensions. The resource comes
-from `defineCrudResource()` in `@jskit-ai/resource-crud-core`.
+`defineCrudListBulkActions()` for optional list extensions. Screens take the
+CRUD contract from `defineCrudContract()` in `@jskit-ai/resource-crud-core`,
+built on the table resource from `defineTableResource()` in
+`@jskit-ai/resource-core`.
 
 ## Example files
 
 `example/books/` contains concrete list, view, new, and edit pages for the
-owner-scoped `bookResource` pattern. `BookFormFields.vue` and `formFields.js`
-show the small product-owned form seam. `listExtensions.js` makes optional
-filters and actions explicit without adding empty screen machinery elsewhere.
+owner-scoped `bookResource` table resource and its `bookCrud` contract.
+`BookFormFields.vue` and `formFields.js` show the small product-owned form
+seam. `listExtensions.js` makes optional filters and actions explicit without
+adding empty screen machinery elsewhere.
 
 ## Variation points
 
@@ -166,6 +169,21 @@ through to Vuetify.
 Here `lookups` is the page's `createCrudLookupFieldRuntime()` result for the
 same form fields.
 
+### Linked records in a list
+
+A list that shows a field of a linked record asks for it by relationship name
+in `useCrudListScreen({ ..., requestQueryParams: { include: "service" } })`,
+and each row reads it from its `lookups`: `record.lookups.service.name`. The
+contract decides which of the linked record's fields arrive: its id, its
+relation's `labelKey`, and what `fields.serviceId.output.includeFields` names.
+
+```vue
+<template #table-row="{ record }">
+  <td>{{ record.title }}</td>
+  <td>{{ record.lookups?.service?.name }}</td>
+</template>
+```
+
 ## Verification
 
 - Mount each route with a representative resource response.

package/skills/jskit/references/patterns/crud/crud-screen-set/example/books/BookEditPage.vue

@@ -3,7 +3,7 @@ import { computed } from "vue";
 import { useRoute } from "vue-router";
 import CrudAddEditScreen from "@jskit-ai/http-web/client/components/CrudAddEditScreen";
 import { useCrudAddEditScreen } from "@jskit-ai/http-web/client/composables/useCrudAddEditScreen";
-import { bookResource } from "@local/books/shared";
+import { bookCrud } from "@local/books/shared";
 import BookFormFields from "./BookFormFields.vue";
 import { bookFormFields } from "./formFields.js";
 
@@ -17,7 +17,7 @@ const screen = useCrudAddEditScreen({
   saveLabel: "Save changes",
   cancelTo: "/books/:bookId",
   preserveCancelQuery: true,
-  resource: bookResource,
+  resource: bookCrud,
   operationName: "patch",
   formFields: bookFormFields,
   addEditOptions: {

package/skills/jskit/references/patterns/crud/crud-screen-set/example/books/BookListPage.vue

@@ -1,14 +1,14 @@
 <script setup>
 import CrudListScreen from "@jskit-ai/http-web/client/components/CrudListScreen";
 import { useCrudListScreen } from "@jskit-ai/http-web/client/composables/useCrudListScreen";
-import { bookResource } from "@local/books/shared";
+import { bookCrud } from "@local/books/shared";
 import { listBulkActions, listFilters, listRowActions } from "./listExtensions.js";
 
 // A main menu destination: the app bar shows its title and no Up arrow.
 definePage({ meta: { jskit: { title: "Books" } } });
 
 const screen = useCrudListScreen({
-  resource: bookResource,
+  resource: bookCrud,
   resourceNamespace: "books",
   apiSuffix: "/books",
   recordIdParam: "bookId",

package/skills/jskit/references/patterns/crud/crud-screen-set/example/books/BookNewPage.vue

@@ -1,7 +1,7 @@
 <script setup>
 import CrudAddEditScreen from "@jskit-ai/http-web/client/components/CrudAddEditScreen";
 import { useCrudAddEditScreen } from "@jskit-ai/http-web/client/composables/useCrudAddEditScreen";
-import { bookResource } from "@local/books/shared";
+import { bookCrud } from "@local/books/shared";
 import BookFormFields from "./BookFormFields.vue";
 import { bookFormFields } from "./formFields.js";
 
@@ -11,7 +11,7 @@ const screen = useCrudAddEditScreen({
   mode: "new",
   saveLabel: "Save book",
   cancelTo: "/books",
-  resource: bookResource,
+  resource: bookCrud,
   operationName: "create",
   formFields: bookFormFields,
   addEditOptions: {