@jskit-ai/agent-docs 0.1.257 → 0.1.258

package/skills/jskit/references/patterns/connectors/source-scanning/PATTERN.md

@@ -18,7 +18,7 @@ The example wires that library to application-owned authority and snapshot looku
 ## Do not use when
 
 This is not an HTTP application-data connector, user login, a managed gateway,
-or an implementation of Vibe64's coding agents. It does not generate an app.
+or an implementation of a hosted editor's coding agents. It does not generate an app.
 Auth0 and native Windows execution are not implemented in the current runner.
 
 ## Product decisions
@@ -39,7 +39,15 @@ and whether a blocking verdict prevents a later operation.
 - Missing/invalid reports, cancellation and failed scans never become clean scans.
 - Provider credentials are isolated from coding-agent sessions and credentials.
 - The host supplies its own authorized provider credentials; editor edition does
-  not select a shared Vibe64 provider account.
+  not select a shared hosted provider account.
+- Each collaborator the composition receives (`authorize`, `resolveReference`
+  and `resolveScanTarget`) is a required parameter typed in a JSDoc `@param` and
+  called directly, without a `typeof` probe, a "requires x" guard or a no-op
+  default. `authorize` and `resolveReference` are typed with `ConnectorAuthorize`
+  and `ResolveReference` from `@jskit-ai/connectors-core/server/types`, and
+  `resolveScanTarget` with `WizScanTargetResolver` from
+  `@jskit-ai/connectors-catalog/server/types`. A server feature that uses it follows
+  [typed features](https://github.com/mobily-enterprises/jskit-ai/blob/main/packages/agent-docs/site/guide/framework/typed-features.md).
 
 ## Framework APIs
 
@@ -81,3 +89,6 @@ and findings require separately authorised provider acceptance.
 Do not infer workspace grants from a shared slot, return raw provider stderr,
 replay scans automatically, pass arbitrary CLI flags, use a mutable working tree
 as if it were a fixed revision, or substitute a generic API reader for source scans.
+
+Do not probe a collaborator, default one to `null`, `{}` or a no-op, fill a slot
+with a setter after construction, or keep a module-level registry.

package/skills/jskit/references/patterns/connectors/source-scanning/example/source-scanner.js

@@ -3,6 +3,15 @@ import { parseIntegrationConfiguration } from "@jskit-ai/connectors-core/shared/
 import { wizDefinition } from "@jskit-ai/connectors-catalog/shared";
 import { createWizScanner } from "@jskit-ai/connectors-catalog/server/wiz";
 
+/**
+ * @param {object} dependencies
+ * @param {string} [dependencies.configFile]
+ * @param {string} dependencies.installedWizCliPath
+ * @param {import("@jskit-ai/connectors-core/server/types").ConnectorAuthorize} dependencies.authorize The application's access policy.
+ * @param {import("@jskit-ai/connectors-core/server/types").ResolveReference} dependencies.resolveReference
+ * @param {import("@jskit-ai/connectors-catalog/server/types").WizScanTargetResolver} dependencies.resolveScanTarget
+ * @param {Record<string, string>} [dependencies.environment]
+ */
 export async function projectSourceScanner({ configFile = "integrations.json", installedWizCliPath,
   authorize, resolveReference, resolveScanTarget, environment }) {
   const configuration = parseIntegrationConfiguration(await readFile(configFile, "utf8"), {

package/skills/jskit/references/patterns/crud/json-api-resource-package/PATTERN.md

@@ -33,18 +33,32 @@ from a generator questionnaire or treat a live table as the sole contract.
 - Migration and resource storage metadata describe the same table.
 - `apiAccess`, surface access, and `autofilter` agree.
 - Public routes use public ownership only.
-- Workspace routes receive explicit scope validators and route-to-action input.
+- Workspace routes receive explicit scope validators and route-to-action input:
+  workspaces-core's `WORKSPACE_CRUD_SCOPE`, never a copied scope literal.
 - Application source contains one module declaration, not copied generic CRUD
   repository, service, action, route, and provider files.
 - Current migration/resource/source state is authoritative; there is no receipt,
   provenance marker, generator identity, or field-patching lane.
+- The package exports the type of the capability it provides:
+  `src/server/types.js` declares `AppBooks` (for `app.books`) as crud-core's
+  `CrudResourceApi`, exported as `./server/types`. A feature that requires
+  `app.books` names that type in a JSDoc `@param`; code given only its service
+  or repository names crud-core's `CrudService` or `CrudRepository`.
+- Code the declaration adds follows [typed features](https://github.com/mobily-enterprises/jskit-ai/blob/main/packages/agent-docs/site/guide/framework/typed-features.md):
+  `decorateService`, `decorateRepository`, `operationLifecycle` hooks and named
+  `actions` call the collaborators they receive directly, with no `typeof`
+  probe, optional call, absent default, slot setter or module-level registry.
+  Each action's `execute` is one call to one service method with the
+  validated input, and its argument is typed as crud-core's
+  `CrudCustomActionInvocation`. Keep one copy of each helper per package, files
+  under 750 lines and functions under 600.
 
 ## 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 events, standard CRUD actions, route
-contracts, access policy, and HTTP routes.
+JSON REST resource, repository, service, standard CRUD actions with their
+record-changed events, route contracts, access policy, and HTTP routes.
 
 ## Example files
 
@@ -55,6 +69,7 @@ Paths below are relative to this pattern directory:
 example/migrations/20260815000000_books.cjs
 example/packages/books/package.json
 example/packages/books/src/server/BooksFeature.js
+example/packages/books/src/server/types.js
 example/packages/books/src/shared/bookResource.js
 example/packages/books/src/shared/index.js
 ```
@@ -67,6 +82,8 @@ guide.
 
 `BooksFeature.js` is deliberately tiny: it binds the readable resource 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.
 
 ## List search is part of the initial composition
 
@@ -89,8 +106,15 @@ an unfiltered collection can satisfy a matching-row-only assertion.
 
 Change the package name, resource fields, table, surface, ownership filter,
 relative route, messages, and migration. Supply explicit permissions when the
-surface uses named policy. For workspace ownership, add the workspace route and
-action validators through the module's `scope` option. The feature exposes 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
+`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
 surface further; do not register unused mutation actions and routes. Use
 `routes: false` only for an internal
@@ -108,7 +132,13 @@ 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. When the
+additional methods remain available through the resource capability. An
+overridden `createDocument()` 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
@@ -118,14 +148,28 @@ 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
 `standard(nextInput)` so it can retain the framework write while adjusting its
-input or coordinating other repository work. `afterCommit` runs only after the
-mutation transaction succeeds. 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.
+input or coordinating other repository work, and returns what `standard()`
+returns: the operation's tagged JSON:API result (null for delete). A create's
+`execute` returns the created record with its id, as the document result
+`standard()` returns or as `returnJsonApiData(record)`, because the create's
+events read its id; a create that returns anything else fails inside its
+transaction. `after` and `afterCommit` receive that `result`, so a record id is
+`result.value.data.id` for a document result. `afterCommit` runs only after the
+mutation transaction succeeds. A hook's argument is `CrudLifecycleContext` from
+`@jskit-ai/crud-core/server/types`; type a lifecycle declared apart from its
+feature with `CrudOperationLifecycle`, whose type arguments are the decorated
+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
 a normal JSKIT input, permission, audit, events, and `execute({ input, context,
-service, repository, ...dependencies })` contract. Its optional `route`
+service, repository, ...dependencies })` contract. Type that argument with
+`CrudCustomActionInvocation` from `@jskit-ai/crud-core/server/types`. Its first
+type argument is the service the action calls, when `decorateService` adds the
+method; its second holds the types of required capabilities the action uses,
+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
@@ -139,25 +183,58 @@ 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.
 
+A decorator lives in a module of its own and returns its result frozen, with
+each added method a named function. Spreading belongs here only, over the CRUD
+service or repository, whose members are the contract's. `types.js` names the
+decorated types once:
+
+```js
+// bookingsService.js
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+
+/**
+ * The bookings service: the CRUD service plus booking confirmation and the
+ * checks and history its updates need.
+ * @param {object} dependencies
+ * @param {import("@jskit-ai/crud-core/server/types").CrudService} dependencies.service
+ * @param {import("./types.js").BookingsRepository} dependencies.repository
+ */
+function decorateBookingsService({ service, repository }) {
+  async function confirmBooking(recordId, options) {
+    return repository.confirmBooking(recordId, options);
+  }
+
+  async function assertUpdateAllowed(recordId, options) {
+    if (await repository.isBookingLocked(recordId, options)) {
+      throw new AppError(409, "This booking is locked.", { code: "bookings.locked" });
+    }
+  }
+
+  async function recordUpdateCompleted(recordId, options) {
+    return repository.addBookingHistoryEntry(recordId, "updated", options);
+  }
+
+  return Object.freeze({ ...service, confirmBooking, assertUpdateAllowed, recordUpdateCompleted });
+}
+
+// types.js
+/** @typedef {ReturnType<typeof import("./bookingsRepository.js").decorateBookingsRepository>} BookingsRepository */
+/** @typedef {ReturnType<typeof import("./bookingsService.js").decorateBookingsService>} BookingsService */
+```
+
 ```js
 const BookingsFeature = defineCrudJsonApiFeature({
   resource: bookingResource,
   surface: "app",
-  decorateService({ service, repository }) {
-    return {
-      ...service,
-      async confirmBooking(recordId, options) {
-        return repository.confirmBooking(recordId, options);
-      }
-    };
-  },
+  decorateRepository: decorateBookingsRepository,
+  decorateService: decorateBookingsService,
   operationLifecycle: {
     update: {
       async before({ input, service, trx, context }) {
         await service.assertUpdateAllowed(input.recordId, { trx, context });
       },
       async afterCommit({ result, service, context }) {
-        await service.recordUpdateCompleted(result.data.id, { context });
+        await service.recordUpdateCompleted(result.value.data.id, { context });
       }
     }
   },
@@ -165,9 +242,8 @@ const BookingsFeature = defineCrudJsonApiFeature({
     confirm: {
       input: confirmBookingInput,
       permission: { require: "all", permissions: ["bookings.confirm"] },
-      execute({ input, context, service }) {
-        return service.confirmBooking(input.recordId, { context });
-      },
+      /** @param {import("@jskit-ai/crud-core/server/types").CrudCustomActionInvocation<import("./types.js").BookingsService>} action */
+      execute: ({ input, context, service }) => service.confirmBooking(input.recordId, { context }),
       route: {
         method: "POST",
         path: "/:recordId/confirm",
@@ -203,3 +279,6 @@ const BookingsFeature = defineCrudJsonApiFeature({
 - public access combined with user or workspace ownership
 - implicit workspace route parameters or permissions
 - receipt, replay, provenance, ownership-marker, or scaffold-shape files
+- probing a collaborator, defaulting one to `null`, `{}` or a no-op, setters
+  that fill a slot after construction, and module-level registries in
+  decorators, lifecycle hooks or actions

package/skills/jskit/references/patterns/crud/json-api-resource-package/example/packages/books/package.json

@@ -5,11 +5,12 @@
   "type": "module",
   "exports": {
     "./server/BooksFeature": "./src/server/BooksFeature.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/crud/json-api-resource-package/example/packages/books/src/server/types.js

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

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

@@ -44,7 +44,9 @@ not from a JSKIT questionnaire.
 - User ownership is represented by a non-null `user_id` column.
 - The resource's hidden `userId` field maps to that ownership column.
 - `autofilter: "user"` is used only for genuine current-user ownership.
-- Output, create, and patch participation is explicit on each product field.
+- Each product field's output, create, and patch participation is its
+  `operations` block, or the default `defineCrudResource()` gives a field
+  without one (see Field operations and lookups below).
 - Temporal database values use the declared storage serializer.
 - The source-controlled migration and resource contract agree.
 - Server policy tests prove that one user cannot read or mutate another user's
@@ -60,6 +62,57 @@ 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
+
+A field's `operations` name 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`). A
+field that leaves `operations` out takes the default:
+
+| Field | Default `operations` |
+| --- | --- |
+| `primary: true` | `{}`: no operation; every record output already carries its `id` |
+| `hidden: true` | `{}`: no operation |
+| `readOnly: true` | `{ output: { required: true } }` |
+| any other field | `{ output: { required: true }, create: { required: <the field's required> }, patch: { required: false } }` |
+
+So a `required: true` field is required on create, and any other field is
+optional there. An `operations` block you write always wins, for example
+`operations: { output: {}, create: {}, patch: {} }` for a field that is
+optional everywhere. Write the block only where it differs from the default:
+
+```js
+schema: {
+  userId: { type: "id", required: true, hidden: true },
+  title: { type: "string", maxLength: 255, required: true, search: true },
+  notes: { type: "string", maxLength: 65535, nullable: true, search: true },
+  createdAt: { type: "dateTime", default: "now()", readOnly: true, storage: { writeSerializer: "datetime-utc" } }
+}
+```
+
+A field that looks up a record of another resource can name that resource's
+namespace with `lookup`:
+
+```js
+shelfId: { type: "id", nullable: true, search: true, lookup: "shelves" }
+```
+
+`defineCrudResource()` expands it, where `lookup` stood, to:
+
+```js
+relation: { kind: "lookup", namespace: "shelves", valueKey: "id" },
+belongsTo: "shelves",  // the namespace's JSON REST resource, camel-cased
+as: "shelf",           // the field key without its Id suffix
+ui: { formControl: "autocomplete" }
+```
+
+Keys you write beside `lookup` win: `belongsTo` and `as` replace the
+filled-in values, and `relation` and `ui` are merged over them, so
+`relation: { labelKey: "name" }` adds a label key and
+`ui: { formControl: "select" }` picks a select. A field whose key has no `Id`
+suffix must write `as`. The built resource equals one that writes the expanded
+keys out.
+
 ## Example files
 
 - `example/bookResource.js` is a complete resource contract for personal book

package/skills/jskit/references/patterns/database/mysql-application/PATTERN.md

@@ -38,7 +38,10 @@ decisions, not framework questions.
 ## Framework APIs
 
 Use `createKnexMigrationConfigFromApp()` from
-`@jskit-ai/database-runtime/server/knexMigrationConfig`. The running JSKIT
+`@jskit-ai/database-runtime/server/knexMigrationConfig`, and
+`prepareDatabaseFromApp()` from `@jskit-ai/database-runtime/server/databaseSetup`.
+Both take the dialect and the application's environment
+(`environment: process.env`), which they never read on their own. The running JSKIT
 application automatically selects the sole installed database driver, while
 Knex discovers package-owned migrations from the installed dependency graph.
 
@@ -50,6 +53,14 @@ Knex discovers package-owned migrations from the installed dependency graph.
 entrypoint for managed sessions and deployments. `example/.env.example` names
 the connection values and separate test databases without a secret.
 
+`example/.github/workflows/verify.yml` is a normal app-owned CI workflow with
+exactly one database service: `mariadb` (`mariadb:11.4`, `MARIADB_*`
+variables, port `3306`, a `healthcheck.sh` health check). Copy it whole from
+this pattern and adapt it as source rather than generating it from package
+metadata. Do not combine it with the PostgreSQL pattern's workflow: a MySQL
+application's workflow has no `postgres` service, `POSTGRES_*` variables, port
+`5432`, or `pg_isready` option.
+
 `example/tests/browser/database.js` is the application-owned browser preparation
 helper. It requires the exact `BROWSER_TEST_DB_NAME`, rejects the ordinary and
 disposable `TEST_DB_NAME` databases,
@@ -93,10 +104,9 @@ it as `seed` to `prepareDatabaseFromApp()`.
   foreign-key checks remain enabled, and the normal database is unchanged.
   Also prove that a new pending migration is applied. Keep this as a regression
   test when adapting the example; reject a harness that recreates the schema.
-
-`example/.github/workflows/verify.yml` is a normal app-owned CI workflow with
-an explicit MariaDB service. Adapt it as source rather than generating it from
-package metadata.
+- Confirm `.github/workflows/verify.yml` parses as YAML and declares only the
+  `mariadb` service. GitHub reports an unparseable workflow only as a failed
+  run with "no jobs were run".
 
 ## Avoid
 
@@ -104,4 +114,5 @@ package metadata.
 - generated `.env` secrets
 - depending on a live schema as the source contract
 - a second driver installed “just in case”
+- any file, service, port, or variable copied from the PostgreSQL pattern
 - migration receipts, provenance, replay logs, or generator ownership

package/skills/jskit/references/patterns/database/mysql-application/example/knexfile.js

@@ -1,11 +1,11 @@
 import { createKnexMigrationConfigFromApp } from "@jskit-ai/database-runtime/server/knexMigrationConfig";
 
 try {
-  process.loadEnvFile?.(".env");
+  process.loadEnvFile(".env");
 } catch (error) {
   if (error?.code !== "ENOENT") {
     throw error;
   }
 }
 
-export default await createKnexMigrationConfigFromApp({ client: "mysql2" });
+export default await createKnexMigrationConfigFromApp({ client: "mysql2", environment: process.env });

package/skills/jskit/references/patterns/database/mysql-application/example/package.json

@@ -8,6 +8,6 @@
     "db:migrate:status": "knex --knexfile ./knexfile.js migrate:list"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime-mysql": "0.1.250"
+    "@jskit-ai/database-runtime-mysql": "0.1.251"
   }
 }

package/skills/jskit/references/patterns/database/mysql-application/example/scripts/prepare-database.js

@@ -1,3 +1,3 @@
 import { prepareDatabaseFromApp } from "@jskit-ai/database-runtime/server/databaseSetup";
 
-await prepareDatabaseFromApp({ client: "mysql2" });
+await prepareDatabaseFromApp({ client: "mysql2", environment: process.env });

package/skills/jskit/references/patterns/database/postgres-application/PATTERN.md

@@ -38,7 +38,10 @@ decisions, not framework questions.
 ## Framework APIs
 
 Use `createKnexMigrationConfigFromApp()` from
-`@jskit-ai/database-runtime/server/knexMigrationConfig`. The running JSKIT
+`@jskit-ai/database-runtime/server/knexMigrationConfig`, and
+`prepareDatabaseFromApp()` from `@jskit-ai/database-runtime/server/databaseSetup`.
+Both take the dialect and the application's environment
+(`environment: process.env`), which they never read on their own. The running JSKIT
 application automatically selects the sole installed database driver, while
 Knex discovers package-owned migrations from the installed dependency graph.
 
@@ -50,6 +53,14 @@ dialect. `example/scripts/prepare-database.js` is the portable
 migrate-then-seed entrypoint for managed sessions and deployments.
 `example/.env.example` names the five connection values without a secret.
 
+`example/.github/workflows/verify.yml` is a normal app-owned CI workflow with
+exactly one database service: `postgres` (`postgres:17`, `POSTGRES_*`
+variables, port `5432`, a `pg_isready` health check). Copy it whole from this
+pattern and adapt it as source rather than generating it from package metadata.
+Do not combine it with the MySQL pattern's workflow: a PostgreSQL application's
+workflow has no `mariadb` service, `MARIADB_*` variables, port `3306`, or
+`healthcheck.sh` option.
+
 ## Variation points
 
 Change scripts, migration location, connection values, and secret injection to
@@ -66,10 +77,9 @@ it as `seed` to `prepareDatabaseFromApp()`.
 - Run `npm run db:migrate:status` and the application verification command.
 - Exercise one transaction and one negative connection case.
 - When a seed exists, run `db:prepare` twice and require the second run to be safe.
-
-`example/.github/workflows/verify.yml` is a normal app-owned CI workflow with
-an explicit PostgreSQL service. Adapt it as source rather than generating it
-from package metadata.
+- Confirm `.github/workflows/verify.yml` parses as YAML and declares only the
+  `postgres` service. GitHub reports an unparseable workflow only as a failed
+  run with "no jobs were run".
 
 ## Avoid
 
@@ -77,4 +87,5 @@ from package metadata.
 - generated `.env` secrets
 - depending on a live schema as the source contract
 - a second driver installed “just in case”
+- any file, service, port, or variable copied from the MySQL pattern
 - migration receipts, provenance, replay logs, or generator ownership

package/skills/jskit/references/patterns/database/postgres-application/example/knexfile.js

@@ -1,11 +1,11 @@
 import { createKnexMigrationConfigFromApp } from "@jskit-ai/database-runtime/server/knexMigrationConfig";
 
 try {
-  process.loadEnvFile?.(".env");
+  process.loadEnvFile(".env");
 } catch (error) {
   if (error?.code !== "ENOENT") {
     throw error;
   }
 }
 
-export default await createKnexMigrationConfigFromApp({ client: "pg" });
+export default await createKnexMigrationConfigFromApp({ client: "pg", environment: process.env });

package/skills/jskit/references/patterns/database/postgres-application/example/package.json

@@ -8,6 +8,6 @@
     "db:migrate:status": "knex --knexfile ./knexfile.js migrate:list"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime-postgres": "0.1.249"
+    "@jskit-ai/database-runtime-postgres": "0.1.250"
   }
 }

package/skills/jskit/references/patterns/database/postgres-application/example/scripts/prepare-database.js

@@ -1,3 +1,3 @@
 import { prepareDatabaseFromApp } from "@jskit-ai/database-runtime/server/databaseSetup";
 
-await prepareDatabaseFromApp({ client: "pg" });
+await prepareDatabaseFromApp({ client: "pg", environment: process.env });

package/skills/jskit/references/patterns/realtime/realtime-application/example/package.json

@@ -2,7 +2,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@jskit-ai/realtime": "0.2.6",
-    "@jskit-ai/shell-web": "0.2.3"
+    "@jskit-ai/realtime": "0.2.7",
+    "@jskit-ai/shell-web": "0.2.4"
   }
 }

package/skills/jskit/references/patterns/rewards/google-rewarded/example/GoogleRewardedDeliveryProvider.js

@@ -5,7 +5,7 @@ const GoogleRewardedDeliveryProvider = defineProvider({
   id: "app.rewarded.google",
   provides: { delivery: "client.rewarded-delivery" },
   setup() {
-    return { delivery: { launchReward: launchGoogleRewardedAd } };
+    return { delivery: Object.freeze({ launchReward: launchGoogleRewardedAd }) };
   }
 });
 

package/skills/jskit/references/patterns/rewards/google-rewarded/example/googlePublisherTag.js

@@ -71,14 +71,10 @@ function launchGoogleRewardedAd({
         let settled = false;
 
         const cleanup = () => {
-          if (typeof pubads.removeEventListener === "function") {
-            pubads.removeEventListener("rewardedSlotReady", handleReady);
-            pubads.removeEventListener("rewardedSlotGranted", handleGranted);
-            pubads.removeEventListener("rewardedSlotClosed", handleClosed);
-          }
-          if (typeof googletag.destroySlots === "function") {
-            googletag.destroySlots([slot]);
-          }
+          pubads.removeEventListener("rewardedSlotReady", handleReady);
+          pubads.removeEventListener("rewardedSlotGranted", handleGranted);
+          pubads.removeEventListener("rewardedSlotClosed", handleClosed);
+          googletag.destroySlots([slot]);
         };
 
         const handleReady = async (event) => {
@@ -87,9 +83,7 @@ function launchGoogleRewardedAd({
           }
           readySeen = true;
           await Promise.resolve(onReady?.());
-          if (typeof event.makeRewardedVisible === "function") {
-            event.makeRewardedVisible();
-          }
+          event.makeRewardedVisible();
         };
 
         const handleGranted = async (event) => {