@@ -0,0 +1,13 @@
+---
+'@objectstack/rest': patch
+---
+
+fix(rest): the transactional `POST /batch`, the `/meta` object-state and published reads, and the meta read gate's disabled-package check use the request's environment's data engine when one REST plugin fronts many environments
+
+Clause-②: no
+Metadata-protocol: none
+
+- **What was wrong.** On a host that mounts one `RestApiPlugin` in front of many environment kernels (the hosted runtime shape), the `objectql` provider read the HOST kernel's engine whatever environment it was asked for, and the unscoped (hostname-routed) mount asked it for no environment at all. `POST /batch` therefore opened its transaction on the host's engine and sent its update and delete ops through it, while its create ops went to the environment's own protocol, joined to the host's transaction. `GET /meta/object/:name/state/:field` judged the object by the host engine's registry, and `GET /meta/:type/:name/published` and the meta read gate asked the host engine's registry whether an environment's package is disabled. The request's execution context already read the environment's engine, so one request used two kernels.
+- **What changes.** Given an environment id and a registered `kernel-manager`, the `objectql` provider now reads `objectql` on that environment's kernel, the same environment-scoped seam the approvals, email, sharing, security and other providers use. Every route that reads it passes the id the shared request→environment resolution answered: the `/environments/:environmentId` param on the scoped mount, else the host's `kernel-resolver` (or the hostname / `X-Environment-Id` chain) on the unscoped one. The host's engine is no longer a fallback: an environment whose kernel carries no engine answers `POST /batch` with `501 NOT_IMPLEMENTED`.
+- **Unchanged.** A single-kernel deployment (no `kernel-manager`) reads the engine on the plugin's own kernel exactly as before, through the same factory-aware lookup: a factory that fails to build is still a loud `503`, and only an engine that was never registered reads as absent. The reserved `platform` id and a request the resolver places in no environment also read the plugin's own kernel.
+- **No migration.** No configuration, route, response shape or export changes.
@@ -81,6 +81,7 @@ export interface BatchRouteHost {
     readonly routeManager: RestServer['routeManager'];
     readonly protocol: RestServer['protocol'];
     readonly objectQLProvider: RestServer['objectQLProvider'];
+    resolveRequestEnvironmentId: RestServer['resolveRequestEnvironmentId'];
     resolveProtocol: RestServer['resolveProtocol'];
     resolveExecCtx: RestServer['resolveExecCtx'];
     enforceAuth: RestServer['enforceAuth'];
@@ -233,9 +234,17 @@ export function registerBatchEndpoints(this: BatchRouteHost, basePath: string):
                 // provider SYNCHRONOUSLY, so a host wiring a non-`async`
                 // provider — which the seam's declared type cannot prevent —
                 // reaches the same answer as one that rejects (commit add6a1b1c).
+                //
+                // [#30218] The engine is the REQUEST's environment's, through
+                // the shared resolver: the scoped param, else the host's
+                // resolver for a hostname-routed request. The raw `undefined`
+                // of the unscoped mount, and a provider that ignored the id,
+                // opened a hosted environment's transaction on the host
+                // kernel's engine while the create ops went to the
+                // environment's protocol.
                 const ql = await wiredEngineOrLoud(
                     Boolean(this.objectQLProvider),
-                    () => this.objectQLProvider!(environmentId),
+                    async () => this.objectQLProvider!(await this.resolveRequestEnvironmentId(environmentId, req)),
                 );
                 if (!ql || typeof ql.transaction !== 'function') {
                     // Typed like every other 501 on this server (clone/search,
 
@@ -129,9 +129,9 @@
  *   from it. The getter reads the field the handler read, when it read it:
  *   slice 2's batch shape, unbound, per the seat's provider ruling (no shipped
  *   provider reads `this`).
- * - The masker, the protocol, the read gate, the schema mask and the metadata
- *   service are each resolved per request by a METHOD of the class, and every
- *   method goes as a closure.
+ * - The masker, the protocol, the read gate, the schema mask, the metadata
+ *   service and [#30218] the request's environment are each resolved per
+ *   request by a METHOD of the class, and every method goes as a closure.
  * - The door names the requested type through the private static
  *   `metaTypeSingular`, which it used to call as
  *   `RestServer.metaTypeSingular(…)`; for the reason the section above gives,
@@ -1092,6 +1092,7 @@ export interface MetaItemPublishedRouteHost {
     metaItemReadGate: RestServer['metaItemReadGate'];
     maskObjectDocument: RestServer['maskObjectDocument'];
     readonly objectQLProvider: RestServer['objectQLProvider'];
+    resolveRequestEnvironmentId: RestServer['resolveRequestEnvironmentId'];
     resolveMetadataService: RestServer['resolveMetadataService'];
 }
 
@@ -1265,9 +1266,11 @@ export function registerMetaItemPublishedRoute(this: MetaItemPublishedRouteHost,
                     let withheld = false;
                     if (publishedMetaType !== 'object' && publishedMetaType !== 'package'
                         && typeof publishedProtocol?.getMetaItem === 'function') {
+                        // [#30218] The REQUEST's environment's engine,
+                        // through the shared resolver, never the host's.
                         const ql = await wiredEngineOrLoud(
                             Boolean(this.objectQLProvider),
-                            () => this.objectQLProvider!(environmentId),
+                            async () => this.objectQLProvider!(await this.resolveRequestEnvironmentId(environmentId, req)),
                         );
                         const registry = (ql as any)?.registry;
                         if (typeof registry?.isPackageDisabled === 'function') {
 
@@ -51,9 +51,9 @@
  *   registration could part from it. The getter reads the field the handler
  *   read, when it read it: slice 2's batch shape, unbound, per the seat's
  *   provider ruling (no shipped provider reads `this`).
- * - `resolveProtocol` is a METHOD, handed over as a closure that calls it on
- *   the server at call time, so a test double or spy set on the server is
- *   still the one the body reaches.
+ * - `resolveProtocol` and [#30218] `resolveRequestEnvironmentId` are METHODS,
+ *   each handed over as a closure that calls it on the server at call time, so
+ *   a test double or spy set on the server is still the one the body reaches.
  *
  * The inner method's head declares the bindings every `/meta` group reads and
  * hands them over as ONE parameter, {@link MetaRouteScope}, built once there;
@@ -94,6 +94,7 @@ import { wiredEngineOrLoud, type RestServer } from './rest-server.js';
 export interface MetaObjectStateRouteHost {
     readonly routeManager: RestServer['routeManager'];
     readonly objectQLProvider: RestServer['objectQLProvider'];
+    resolveRequestEnvironmentId: RestServer['resolveRequestEnvironmentId'];
     resolveProtocol: RestServer['resolveProtocol'];
 }
 
@@ -186,9 +187,13 @@ export function registerMetaObjectStateRoute(this: MetaObjectStateRouteHost, sco
                 // which the seam's declared type cannot prevent — reaches the
                 // same answer as one that rejects (commit add6a1b1c) instead of
                 // escaping past a `.catch` that never came into existence.
+                //
+                // [#30218] Asked for the REQUEST's environment, through the
+                // shared resolver, so a hosted environment's object is judged
+                // by its own engine's registry, not the host kernel's.
                 const ql = await wiredEngineOrLoud(
                     Boolean(this.objectQLProvider),
-                    () => this.objectQLProvider!(environmentId),
+                    async () => this.objectQLProvider!(await this.resolveRequestEnvironmentId(environmentId, req)),
                 );
                 // [#7557, #24210] The registry is a resolution reader and
                 // keeps serving a disabled package's object, so this API
 
@@ -102,7 +102,7 @@ const { createRestApiPlugin } = await import('./rest-api-plugin.js');
  */
 const PROVIDERS = [
   { index: 6, label: 'authServiceProvider', slot: 'auth', scope: 'environment' },
-  { index: 7, label: 'objectQLProvider', slot: 'objectql', scope: 'host' },
+  { index: 7, label: 'objectQLProvider', slot: 'objectql', scope: 'environment' },
   { index: 8, label: 'emailServiceProvider', slot: 'email', scope: 'environment' },
   { index: 9, label: 'sharingServiceProvider', slot: 'sharing', scope: 'environment' },
   { index: 11, label: 'approvalsServiceProvider', slot: 'approvals', scope: 'environment' },
@@ -130,7 +130,8 @@ const PROVIDERS = [
  * environment id AND a `kernel-manager`, read the slot on THAT environment's
  * kernel instead of this plugin's own — the slots whose occupants a hosted
  * environment's kernel mounts ([#30192] added `auth`, `i18n`, `settings`,
- * `security` and `metadata` to #30011's five). `host` rows read this plugin's
+ * `security` and `metadata` to #30011's five, and [#30218] the `objectql`
+ * engine). `host` rows read this plugin's
  * kernel whatever id they are handed. The hosted behaviour itself is pinned end to end in
  * `rest-environment-scoped-providers.test.ts`; this table only says which
  * kernel each provider asks, so the slot-identity cases below can ask the
@@ -420,9 +421,10 @@ describe('[#30011] a single-kernel deployment reads the environment-scoped slots
     const { args, ctx } = await boot(services);
 
     // [#30192] `auth`, `i18n`, `settings`, `security` and `metadata` joined
-    // the five #30011 scoped; `objectql` and `tenancy` stay on the host.
+    // the five #30011 scoped, and [#30218] `objectql`; `tenancy` stays on the
+    // host.
     expect(ENVIRONMENT_SCOPED.map((p) => p.slot)).toEqual([
-      'auth', 'email', 'sharing', 'approvals', 'sharingRules', 'i18n', 'analytics', 'settings', 'security', 'metadata',
+      'auth', 'objectql', 'email', 'sharing', 'approvals', 'sharingRules', 'i18n', 'analytics', 'settings', 'security', 'metadata',
     ]);
     for (const { index, label, slot } of ENVIRONMENT_SCOPED) {
       const provider = args[index] as (environmentId?: string) => Promise<unknown>;
 
@@ -344,6 +344,18 @@ export function createRestApiPlugin(config: RestApiPluginConfig = {}): Plugin {
             // ObjectQL resolver — single-kernel fallback so resolveExecCtx
             // can run sys_member / sys_user_permission_set lookups when
             // there is no kernelManager wired (e.g. `pnpm dev:crm`).
+            //
+            // [#30218] What is written below is the OWN-KERNEL leg only: the
+            // provider itself is `environmentScopedProvider('objectql', …)`,
+            // built after that seam is declared, so a request for an
+            // environment reads THAT environment's engine and never this
+            // plugin's. The hosted host kernel is a routing shell: the
+            // transactional `POST /batch`, the `/meta` object-state and
+            // published reads, and the meta read gate's disabled-package
+            // owner step all asked this kernel's engine for a request that
+            // resolved to an environment, while `computeExecCtx` read the
+            // environment's — two kernels, one request. The legs, the
+            // classification and the sync leg below are otherwise unchanged.
             // [#4251 B3] `IObjectQLEngine`, not `IDataEngine`: the `objectql`
             // slot is the SAME instance as `data` seen whole, and the consumer
             // (`resolveExecCtx`, and the `transaction` probe behind the batch
@@ -380,7 +392,7 @@ export function createRestApiPlugin(config: RestApiPluginConfig = {}): Plugin {
             // its accessor has exactly ONE fault to report — not registered —
             // and absorbing it is the same classification, not a second
             // collapse.
-            const objectQLProvider = async (_environmentId?: string): Promise<IObjectQLEngine | undefined> => {
+            const objectQLOnOwnKernel = async (): Promise<IObjectQLEngine | undefined> => {
                 const kernel = typeof ctx.getKernel === 'function' ? ctx.getKernel() : undefined;
                 if (kernel && typeof kernel.getServiceAsync === 'function') {
                     try {
@@ -396,8 +408,9 @@ export function createRestApiPlugin(config: RestApiPluginConfig = {}): Plugin {
             };
 
             // [#30011] The ENVIRONMENT-SCOPED provider seams: email, sharing,
-            // approvals, sharing rules and analytics — and [#30192] security,
-            // auth, settings, i18n and metadata. Each slot is filled by a
+            // approvals, sharing rules and analytics — [#30192] security,
+            // auth, settings, i18n and metadata — and [#30218] the `objectql`
+            // engine. Each slot is filled by a
             // plugin the ENVIRONMENT's kernel mounts. A host that fronts many
             // environment kernels with this one plugin (cloud's hosted runtime)
             // therefore holds the occupant a request needs on that request's
@@ -428,10 +441,16 @@ export function createRestApiPlugin(config: RestApiPluginConfig = {}): Plugin {
             //    own kernel, exactly as before.
             //
             // On the environment's kernel the classification is the registry's,
-            // as in `objectQLProvider` above: "never registered" (branded) is
+            // as in `objectQLOnOwnKernel` above: "never registered" (branded) is
             // `undefined`, and any other fault — a factory that threw — is
             // re-raised rather than folded into "not configured".
-            const environmentScopedProvider = <T>(slot: string) =>
+            //
+            // [#30218] `onOwnKernel` replaces the last leg for a seam whose
+            // own-kernel read is classified more strictly than `ctx.getService`'s
+            // catch-all — the `objectql` engine, whose own leg keeps its
+            // factory-aware async read and its `LiteKernel` sync leg. The
+            // environment leg is the same for every seam.
+            const environmentScopedProvider = <T>(slot: string, onOwnKernel?: () => Promise<T | undefined>) =>
                 async (environmentId?: string): Promise<T | undefined> => {
                     if (kernelManager && environmentId && environmentId !== 'platform') {
                         const kernel = await kernelManager.getOrCreate(environmentId);
@@ -442,11 +461,20 @@ export function createRestApiPlugin(config: RestApiPluginConfig = {}): Plugin {
                             throw err;
                         }
                     }
+                    if (onOwnKernel) return onOwnKernel();
                     try {
                         return ctx.getService<T>(slot);
                     } catch { return undefined; }
                 };
 
+            // [#30218] The data engine — `resolveExecCtx`'s single-kernel
+            // lookups, the transactional `POST /batch`, the `/meta` object-state
+            // and published reads, and the meta read gate's disabled-package
+            // owner step. Environment-scoped like the seams below: a request for
+            // environment A is answered by A's engine or by nothing, so a batch
+            // for A opens its transaction on A's store and writes nowhere else.
+            const objectQLProvider = environmentScopedProvider<IObjectQLEngine>('objectql', objectQLOnOwnKernel);
+
             // Email service resolver — used by POST /email/send.
             const emailServiceProvider = environmentScopedProvider<IEmailService>('email');