@jskit-ai/agent-docs 0.1.257 → 0.1.258

package/skills/jskit/references/patterns/server/feature-package/PATTERN.md

@@ -42,8 +42,43 @@ questionnaire.
   the feature package.
 - `defineFeature()` receives only declared capabilities and returns only
   declared feature APIs.
-- Actions define the public operation contract and close over the feature APIs
-  they need. They never resolve arbitrary dependencies at execution time.
+- Each provided capability exports its type. A named `create<Name>` factory in
+  its own module builds the value `setup()` returns, and `types.js` declares
+  one `@typedef` per provided token, named after the token in PascalCase
+  (`feature.booking-engine` -> `BookingEngine`). A package exports it as
+  `./server/types`.
+- Every factory, action creator and hook that receives a collaborator names its
+  type in a JSDoc `@param`: `import("./types.js").<Name>` or
+  `ReturnType<typeof createX>` inside the package, the owner's `./server/types`
+  across packages; a Knex client is database-runtime's `RuntimeKnex`.
+- Collaborators are required. There is no `= null`, `= {}` or no-op default,
+  no `typeof` probe, no optional call and no "requires x" guard: the capability
+  runtime refuses to start without a required token.
+- An extension point is an `optional` token whose default the package names
+  in a module of its own and `setup()` resolves once with `??`, never a setter
+  that fills a slot later or a module-level registry. The token is typed
+  `X | null` only in `setup()`; what `setup()` builds receives it as required.
+- One `create<Name>Actions({ <api> })` per feature, destructured, in
+  `<name>Actions.js`, creates its actions and closes over the feature APIs they
+  need. Every definition and the list are frozen. Each definition spreads one
+  frozen constant of the fields its kind shares (`version`, `kind`,
+  `channels`, `surfaces`) first. Each id is a string literal or a module-level
+  constant, and `execute: (input, context) => api.method(input, { context })`
+  is one call, without `async`, a body, an envelope or a helper that builds or
+  strips it. Actions never resolve arbitrary dependencies at execution time.
+- Methods take the validated input as it is: no `input = {}` default, no
+  `input?.x` and no second normalization of fields the input schema already
+  checked. An options bag whose fields are optional by contract
+  (`options = {}` with `trx`) keeps its default.
+- The package reads the actor from an action context one way, with the
+  kernel's `resolveActorId(context)` or `resolveActor(context)`
+  (`@jskit-ai/kernel/server/actions/actionContributorHelpers`), and its actions
+  pass the context one way.
+- Every `create*` returns `Object.freeze({ … })` of named inner functions, and
+  exposes another factory's functions by name, never by spreading it.
+- A description sits inside its `/** */` block, never in a `//` line above it.
+- One copy of each pure helper per package, imported directly. Files stay under
+  750 lines and functions under 600, one concern per factory.
 - The service orchestrates the feature and does not issue SQL directly.
 - A repository owns persistence and accepts transaction/context options.
 - The normal persistence lane uses a public or documented high-level resource
@@ -68,20 +103,65 @@ The custom persistence variation uses `createWithTransaction()` from
 ## Example files
 
 `example/booking-engine/` is a concrete app-local package showing the preferred
-small-feature boundary. Its status query is deliberately small: product logic
-can grow inside the returned feature API without creating ceremonial layers.
-
-`example/variations/AvailabilityEngineProvider.js` and
+small-feature boundary:
+
+- `src/server/BookingEngineFeature.js` declares the feature, its optional
+  `feature.booking-engine.availability` slot and the engine it provides;
+- `src/server/bookingEngine.js` builds the engine with `createBookingEngine()`,
+  a frozen object of named functions, and reads who asked with the kernel's
+  `resolveActorId(context)`;
+- `src/server/bookingAvailability.js` names the slot's default,
+  `everyScopeOpen`;
+- `src/server/bookingEngineActions.js` creates its one-line, frozen actions
+  with `createBookingEngineActions({ bookingEngine })`, each spreading the
+  shared `BOOKING_QUERY` fields first;
+- `src/server/types.js` declares `BookingEngine` and
+  `BookingEngineAvailability`, exported as `./server/types`.
+
+Its status query is deliberately small: product logic can grow inside the
+returned feature API without creating ceremonial layers. The feature resolves
+the slot once:
+
+```js
+optional: {
+  availability: "feature.booking-engine.availability"
+},
+/** @param {{ availability: import("./types.js").BookingEngineAvailability | null }} capabilities */
+setup({ availability }) {
+  return { bookingEngine: createBookingEngine({ availability: availability ?? everyScopeOpen }) };
+},
+```
+
+Another package fills the slot by providing the token, never by calling a
+setter:
+
+```js
+const SeasonalAvailabilityFeature = defineFeature({
+  id: "feature.seasonal-availability",
+  provides: { availability: "feature.booking-engine.availability" },
+  setup: () => ({ availability: isInSeason })
+});
+```
+
+`example/variations/AvailabilityEngineFeature.js`,
+`example/variations/availabilityEngineActions.js` and
 `example/variations/orchestratorService.js` show the repository-free lane.
-`example/variations/InvoiceRollupProvider.js` and
+`example/variations/InvoiceRollupFeature.js`,
+`example/variations/invoiceRollupActions.js` and
 `example/variations/customKnexRepository.js` show the explicit custom
-persistence lane.
+persistence lane. `example/variations/types.js` declares the
+`AvailabilityEngine` and `InvoiceRollup` types.
+
+The [typed features guide](https://mobily-enterprises.github.io/jskit-ai/guide/framework/typed-features)
+explains each rule this example follows, with a good and a bad example, and
+`npm run lint` checks the ones a machine can see.
 
 ## Variation points
 
 Rename the package, capability id, actions, validators, and domain methods.
-Select the correct channels and surfaces in `actionDefaults`, overriding them
-only for exceptional actions. Add a service when orchestration is shared or
+Select the channels and surfaces in the shared-field constant each definition
+spreads first; a kind of action whose values differ gets a constant of its
+own. Add a service when orchestration is shared or
 stateful. Add a repository only when the feature owns persistence. Replace the
 illustrative status query with narrow product language before shipping.
 
@@ -104,5 +184,19 @@ illustrative status query with narrow product language before shipping.
 - a repository for an orchestration-only feature
 - generic `execute(anything)` operations in finished product code
 - `app.make()`, `scope.make()`, container tokens, or service-location helpers
+- probing a collaborator (`typeof x.method === "function"`, `x?.method?.()`)
+  before calling it
+- absent defaults on a collaborator or on the dependencies object (`= null`,
+  `= {}`, a no-op)
+- setters that fill a slot after construction, and module-level registries
+- a collaborator accepted in two shapes (`capability.service || capability`)
+- an `async` `execute`, an `execute` with a body, or a helper that builds an
+  action or strips its input
+- a hand-written `(...args: any[]) => Promise<any>` type instead of the
+  owner's type, and the same `ReturnType<…>` or indexed type spelled out in
+  several files
+- spreading an in-package factory's result into a provided value
+- unfrozen `create*` results and inline methods
+- a guard, default or comment that exists for a test double
 - metadata claiming which authoring tool or pattern created the package
 - field questionnaires, overwrite switches, or durable operation records

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/package.json

@@ -5,11 +5,12 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/kernel": "0.2.3",
+    "@jskit-ai/kernel": "0.2.4",
     "json-rest-schema": "^1.0.17"
   },
   "exports": {
-    "./server/actions": "./src/server/actions.js"
+    "./server/actions": "./src/server/bookingEngineActions.js",
+    "./server/types": "./src/server/types.js"
   },
   "jskit": {
     "kind": "runtime",
@@ -25,8 +26,8 @@
       "server": {
         "providers": [
           {
-            "entrypoint": "src/server/BookingEngineProvider.js",
-            "export": "BookingEngineProvider"
+            "entrypoint": "src/server/BookingEngineFeature.js",
+            "export": "BookingEngineFeature"
           }
         ]
       },
@@ -40,6 +41,10 @@
           {
             "subpath": "./server/actions",
             "summary": "Exports booking-engine action definitions."
+          },
+          {
+            "subpath": "./server/types",
+            "summary": "Types of the feature.booking-engine capability and its optional feature.booking-engine.availability slot."
           }
         ]
       }

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/BookingEngineFeature.js

@@ -0,0 +1,24 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { everyScopeOpen } from "./bookingAvailability.js";
+import { createBookingEngine } from "./bookingEngine.js";
+import { createBookingEngineActions } from "./bookingEngineActions.js";
+
+const BookingEngineFeature = defineFeature({
+  id: "feature.booking-engine",
+  domain: "booking",
+  optional: {
+    availability: "feature.booking-engine.availability"
+  },
+  provides: {
+    bookingEngine: "feature.booking-engine"
+  },
+  /** @param {{ availability: import("./types.js").BookingEngineAvailability | null }} capabilities */
+  setup({ availability }) {
+    return { bookingEngine: createBookingEngine({ availability: availability ?? everyScopeOpen }) };
+  },
+  actions({ bookingEngine }) {
+    return createBookingEngineActions({ bookingEngine });
+  }
+});
+
+export { BookingEngineFeature };

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/bookingAvailability.js

@@ -0,0 +1,10 @@
+/**
+ * The `feature.booking-engine.availability` default when no package provides
+ * one: every scope takes bookings.
+ * @type {import("./types.js").BookingEngineAvailability}
+ */
+async function everyScopeOpen() {
+  return true;
+}
+
+export { everyScopeOpen };

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/bookingEngine.js

@@ -0,0 +1,29 @@
+import { resolveActorId } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+/**
+ * The booking engine the feature provides as `feature.booking-engine`.
+ * @param {object} dependencies
+ * @param {import("./types.js").BookingEngineAvailability} dependencies.availability
+ */
+function createBookingEngine({ availability }) {
+  /**
+   * Reports, for the validated query, whether its scope takes bookings and who
+   * asked.
+   * @param {{ scope?: string, verbose?: boolean }} query
+   * @param {{ context: object }} options
+   */
+  async function readStatus({ scope = "default", verbose = false }, { context }) {
+    return {
+      ok: true,
+      feature: "booking-engine",
+      scope,
+      verbose,
+      open: await availability(scope),
+      requestedBy: resolveActorId(context)
+    };
+  }
+
+  return Object.freeze({ readStatus });
+}
+
+export { createBookingEngine };

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/bookingEngineActions.js

@@ -0,0 +1,26 @@
+import { statusQueryInputValidator } from "./inputSchemas.js";
+
+const ACTION_GET_STATUS = "feature.booking-engine.status.read";
+
+/** The fields every booking query shares, spread first into each definition. */
+const BOOKING_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["app"]
+});
+
+/** @param {{ bookingEngine: import("./types.js").BookingEngine }} dependencies */
+function createBookingEngineActions({ bookingEngine }) {
+  return Object.freeze([
+    Object.freeze({
+      ...BOOKING_QUERY,
+      id: ACTION_GET_STATUS,
+      input: statusQueryInputValidator,
+      output: null,
+      execute: (input, context) => bookingEngine.readStatus(input, { context })
+    })
+  ]);
+}
+
+export { ACTION_GET_STATUS, createBookingEngineActions };

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/inputSchemas.js

@@ -12,8 +12,7 @@ const statusQueryInputValidator = deepFreeze({
       type: "boolean",
       required: false
     }
-  }),
-  mode: "patch"
+  })
 });
 
 export { statusQueryInputValidator };

package/skills/jskit/references/patterns/server/feature-package/example/booking-engine/src/server/types.js

@@ -0,0 +1,12 @@
+// The types of the `feature.booking-engine` capability and of its optional
+// `feature.booking-engine.availability` slot.
+
+/** @typedef {ReturnType<typeof import("./bookingEngine.js").createBookingEngine>} BookingEngine */
+
+/**
+ * The `feature.booking-engine.availability` slot: answers whether a scope takes
+ * bookings. A package supplies it by providing that token.
+ * @typedef {(scope: string) => Promise<boolean>} BookingEngineAvailability
+ */
+
+export {};

package/skills/jskit/references/patterns/server/feature-package/example/variations/AvailabilityEngineFeature.js

@@ -0,0 +1,19 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createAvailabilityEngineActions } from "./availabilityEngineActions.js";
+import { createAvailabilityEngine } from "./orchestratorService.js";
+
+const AvailabilityEngineFeature = defineFeature({
+  id: "feature.availability-engine",
+  domain: "availability",
+  provides: {
+    availabilityEngine: "feature.availability-engine"
+  },
+  setup() {
+    return { availabilityEngine: createAvailabilityEngine() };
+  },
+  actions({ availabilityEngine }) {
+    return createAvailabilityEngineActions({ availabilityEngine });
+  }
+});
+
+export { AvailabilityEngineFeature };

package/skills/jskit/references/patterns/server/feature-package/example/variations/InvoiceRollupFeature.js

@@ -0,0 +1,23 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createInvoiceRollup } from "./customKnexRepository.js";
+import { createInvoiceRollupActions } from "./invoiceRollupActions.js";
+
+const InvoiceRollupFeature = defineFeature({
+  id: "feature.invoice-rollup",
+  domain: "invoices",
+  requires: {
+    database: "runtime.database"
+  },
+  provides: {
+    invoiceRollup: "feature.invoice-rollup"
+  },
+  /** @param {{ database: import("@jskit-ai/database-runtime/server/types").RuntimeDatabase }} capabilities */
+  setup({ database }) {
+    return { invoiceRollup: createInvoiceRollup({ knex: database.knex }) };
+  },
+  actions({ invoiceRollup }) {
+    return createInvoiceRollupActions({ invoiceRollup });
+  }
+});
+
+export { InvoiceRollupFeature };

package/skills/jskit/references/patterns/server/feature-package/example/variations/availabilityEngineActions.js

@@ -0,0 +1,26 @@
+import { emptyInputValidator } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+const ACTION_GET_AVAILABILITY_STATUS = "availability.status.read";
+
+/** The fields every availability query shares, spread first into each definition. */
+const AVAILABILITY_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["app"]
+});
+
+/** @param {{ availabilityEngine: import("./types.js").AvailabilityEngine }} dependencies */
+function createAvailabilityEngineActions({ availabilityEngine }) {
+  return Object.freeze([
+    Object.freeze({
+      ...AVAILABILITY_QUERY,
+      id: ACTION_GET_AVAILABILITY_STATUS,
+      input: emptyInputValidator,
+      output: null,
+      execute: (input) => availabilityEngine.getStatus(input)
+    })
+  ]);
+}
+
+export { ACTION_GET_AVAILABILITY_STATUS, createAvailabilityEngineActions };

package/skills/jskit/references/patterns/server/feature-package/example/variations/customKnexRepository.js

@@ -1,34 +1,40 @@
 import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
 
-function createRepository({ knex } = {}) {
-  if (!knex) {
-    throw new TypeError("createRepository requires knex.");
+/**
+ * The invoice rollup's persistence: a reviewed custom Knex repository.
+ * @param {{ knex: import("@jskit-ai/database-runtime/server/types").RuntimeKnex }} dependencies
+ */
+function createInvoiceRollup({ knex }) {
+  const withTransaction = createWithTransaction(knex);
+
+  async function getStatus(input, options = {}) {
+    return {
+      ok: true,
+      feature: "invoice-rollup",
+      persistence: "custom-knex",
+      tableName: "invoice_rollups",
+      hasTransaction: Boolean(options.trx),
+      input
+    };
+  }
+
+  async function execute(input, options = {}) {
+    return {
+      accepted: false,
+      feature: "invoice-rollup",
+      persistence: "custom-knex",
+      tableName: "invoice_rollups",
+      hasTransaction: Boolean(options.trx),
+      input,
+      message: "Replace this example with the reviewed domain-specific query."
+    };
   }
 
   return Object.freeze({
-    withTransaction: createWithTransaction(knex),
-    async getStatus(input = {}, options = {}) {
-      return {
-        ok: true,
-        feature: "invoice-rollup",
-        persistence: "custom-knex",
-        tableName: "invoice_rollups",
-        hasTransaction: Boolean(options.trx),
-        input
-      };
-    },
-    async execute(input = {}, options = {}) {
-      return {
-        accepted: false,
-        feature: "invoice-rollup",
-        persistence: "custom-knex",
-        tableName: "invoice_rollups",
-        hasTransaction: Boolean(options.trx),
-        input,
-        message: "Replace this example with the reviewed domain-specific query."
-      };
-    }
+    withTransaction,
+    getStatus,
+    execute
   });
 }
 
-export { createRepository };
+export { createInvoiceRollup };

package/skills/jskit/references/patterns/server/feature-package/example/variations/invoiceRollupActions.js

@@ -0,0 +1,26 @@
+import { emptyInputValidator } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+
+const ACTION_GET_ROLLUP_STATUS = "invoices.rollup.status.read";
+
+/** The fields every invoice rollup query shares, spread first into each definition: they run on the admin surface. */
+const ROLLUP_QUERY = Object.freeze({
+  version: 1,
+  kind: "query",
+  channels: ["api", "assistant", "internal"],
+  surfaces: ["admin"]
+});
+
+/** @param {{ invoiceRollup: import("./types.js").InvoiceRollup }} dependencies */
+function createInvoiceRollupActions({ invoiceRollup }) {
+  return Object.freeze([
+    Object.freeze({
+      ...ROLLUP_QUERY,
+      id: ACTION_GET_ROLLUP_STATUS,
+      input: emptyInputValidator,
+      output: null,
+      execute: (input, context) => invoiceRollup.getStatus(input, { context })
+    })
+  ]);
+}
+
+export { ACTION_GET_ROLLUP_STATUS, createInvoiceRollupActions };

package/skills/jskit/references/patterns/server/feature-package/example/variations/orchestratorService.js

@@ -1,23 +1,28 @@
-function createService() {
+/** The availability engine: orchestration with no persistence of its own. */
+function createAvailabilityEngine() {
+  async function getStatus(input) {
+    return {
+      ok: true,
+      feature: "availability-engine",
+      mode: "orchestrator",
+      input
+    };
+  }
+
+  async function execute(input) {
+    return {
+      accepted: false,
+      feature: "availability-engine",
+      mode: "orchestrator",
+      input,
+      message: "Replace this example with calls to the feature's injected collaborators."
+    };
+  }
+
   return Object.freeze({
-    async getStatus(input = {}) {
-      return {
-        ok: true,
-        feature: "availability-engine",
-        mode: "orchestrator",
-        input
-      };
-    },
-    async execute(input = {}) {
-      return {
-        accepted: false,
-        feature: "availability-engine",
-        mode: "orchestrator",
-        input,
-        message: "Replace this example with calls to the feature's injected collaborators."
-      };
-    }
+    getStatus,
+    execute
   });
 }
 
-export { createService };
+export { createAvailabilityEngine };

package/skills/jskit/references/patterns/server/feature-package/example/variations/types.js

@@ -0,0 +1,7 @@
+// The types of the `feature.availability-engine` and `feature.invoice-rollup`
+// capabilities, for features that require them.
+
+/** @typedef {ReturnType<typeof import("./orchestratorService.js").createAvailabilityEngine>} AvailabilityEngine */
+/** @typedef {ReturnType<typeof import("./customKnexRepository.js").createInvoiceRollup>} InvoiceRollup */
+
+export {};

package/skills/jskit/references/patterns/users/user-administration-server/PATTERN.md

@@ -38,12 +38,25 @@ and the resource contracts from `@jskit-ai/resource-crud-core`.
 - Shared profile persistence remains owned by `@jskit-ai/users-core`.
 - The resource is the field contract; the feature projects its repository,
   service, actions, and routes without app-local ceremony.
+- Each package exports the type of the capability it provides:
+  `src/server/types.js` declares `AppUsers` (for `app.users`) or
+  `AppUsersWorkspace` (for `app.users-workspace`) as crud-core's
+  `CrudResourceApi`, exported as `./server/types`. A feature that requires the
+  capability names that type in a JSDoc `@param`.
+- Code added to a declaration follows [typed features](https://github.com/mobily-enterprises/jskit-ai/blob/main/packages/agent-docs/site/guide/framework/typed-features.md):
+  decorators, lifecycle hooks and named actions call the collaborators they
+  receive directly, with no `typeof` probe, optional call, absent default,
+  slot setter or module-level registry, and each action's `execute` is one
+  call to one service method with the validated input. Keep one copy of each
+  helper per package, files under 750 lines and functions under 600.
 
 ## Example files
 
 `example/packages/users/` is a global administration package.
 `example/packages/users-workspace/` demonstrates the workspace route/action
-boundary while reusing the same service contract. Copy only the composition
+boundary, with workspaces-core's `WORKSPACE_CRUD_SCOPE`, while reusing the same
+service contract. Each package's
+`src/server/types.js` declares the type of the capability it provides. Copy only the composition
 that matches the product and adapt it as ordinary application source.
 
 ## Variation points
@@ -62,3 +75,5 @@ isolation, missing records, null/cleared fields, filtering, and pagination.
 - trusting route scope without repository scope
 - adding app-local mechanics already provided by `defineCrudJsonApiFeature()`
 - generator metadata or field questionnaires
+- probing a collaborator, defaulting one to `null`, `{}` or a no-op, setters
+  that fill a slot after construction, and module-level registries

package/skills/jskit/references/patterns/users/user-administration-server/example/packages/users/package.json

@@ -6,11 +6,12 @@
   "type": "module",
   "exports": {
     "./server/UsersFeature": "./src/server/UsersFeature.js",
+    "./server/types": "./src/server/types.js",
     "./shared": "./src/shared/index.js"
   },
   "dependencies": {
-    "@jskit-ai/crud-core": "0.2.3",
-    "@jskit-ai/resource-crud-core": "0.1.194"
+    "@jskit-ai/crud-core": "0.2.4",
+    "@jskit-ai/resource-crud-core": "0.1.195"
   },
   "jskit": {
     "kind": "runtime",

package/skills/jskit/references/patterns/users/user-administration-server/example/packages/users/src/server/types.js

@@ -0,0 +1,5 @@
+// The type of the `app.users` capability, for features that require it.
+
+/** @typedef {import("@jskit-ai/crud-core/server/types").CrudResourceApi} AppUsers */
+
+export {};

package/skills/jskit/references/patterns/users/user-administration-server/example/packages/users-workspace/package.json

@@ -6,12 +6,13 @@
   "type": "module",
   "exports": {
     "./server/UsersWorkspaceFeature": "./src/server/UsersWorkspaceFeature.js",
+    "./server/types": "./src/server/types.js",
     "./shared": "./src/shared/index.js"
   },
   "dependencies": {
-    "@jskit-ai/crud-core": "0.2.3",
-    "@jskit-ai/resource-crud-core": "0.1.194",
-    "@jskit-ai/workspaces-core": "0.2.4"
+    "@jskit-ai/crud-core": "0.2.4",
+    "@jskit-ai/resource-crud-core": "0.1.195",
+    "@jskit-ai/workspaces-core": "0.2.5"
   },
   "jskit": {
     "kind": "runtime",

package/skills/jskit/references/patterns/users/user-administration-server/example/packages/users-workspace/src/server/UsersWorkspaceFeature.js

@@ -1,6 +1,5 @@
 import { defineCrudJsonApiFeature } from "@jskit-ai/crud-core/server/defineCrudJsonApiFeature";
-import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/workspaces-core/server/support/workspaceRouteInput";
-import { workspaceSlugParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
+import { WORKSPACE_CRUD_SCOPE } from "@jskit-ai/workspaces-core/server/support/workspaceCrud";
 import { resource } from "../shared/userResource.js";
 
 const UsersWorkspaceFeature = defineCrudJsonApiFeature({
@@ -10,13 +9,7 @@ const UsersWorkspaceFeature = defineCrudJsonApiFeature({
   surface: "admin",
   ownershipFilter: "workspace",
   relativePath: "/users",
-  scope: {
-    routeBase: "/w/:workspaceSlug",
-    actionInputValidator: workspaceSlugParamsValidator,
-    routeParamsValidator: workspaceSlugParamsValidator,
-    inputKeys: ["workspaceSlug"],
-    input: (request) => buildWorkspaceInputFromRouteParams(request.input.params)
-  }
+  scope: WORKSPACE_CRUD_SCOPE
 });
 
 export { UsersWorkspaceFeature };

package/skills/jskit/references/patterns/users/user-administration-server/example/packages/users-workspace/src/server/types.js

@@ -0,0 +1,5 @@
+// The type of the `app.users-workspace` capability, for features that require it.
+
+/** @typedef {import("@jskit-ai/crud-core/server/types").CrudResourceApi} AppUsersWorkspace */
+
+export {};