@spine-event-engine/server 2.0.0-snapshot.23 → 2.0.0-snapshot.25

package/dist/services/spine-services.js

@@ -13,31 +13,33 @@
  */
 import { randomUUID } from "node:crypto";
 import { Code, ConnectError } from "@connectrpc/connect";
-import { clone, create, ScalarType, toBinary, } from "@bufbuild/protobuf";
+import { clone, create, ScalarType } from "@bufbuild/protobuf";
 import { AnySchema, BoolValueSchema, BytesValueSchema, DoubleValueSchema, EmptySchema, FloatValueSchema, Int32ValueSchema, Int64ValueSchema, StringValueSchema, UInt32ValueSchema, UInt64ValueSchema, } from "@bufbuild/protobuf/wkt";
-import { TypeUrls, AnyMessages } from "@spine-event-engine/core";
-import { CommandIdSchema, EventSchema, TenantIdSchema, ValidationErrorSchema, VersionSchema, } from "@spine-event-engine/proto";
+import { TypeUrls, AnyPacker } from "@spine-event-engine/core";
+import { CommandIdSchema, TenantIdSchema, ValidationErrorSchema, VersionSchema, } from "@spine-event-engine/proto";
 import { ErrorSchema } from "@spine-event-engine/proto";
 import { CommandService } from "@spine-event-engine/proto/client";
 import { CompositeFilter_CompositeOperator, Filter_Operator, } from "@spine-event-engine/proto/client";
 import { EntityStateWithVersionSchema as EntityStateVersionSchema, OrderBy_Direction, QueryResponseSchema, } from "@spine-event-engine/proto/client";
 import { QueryService } from "@spine-event-engine/proto/client";
-import { EntityStateUpdateSchema, EntityUpdatesSchema, EventUpdatesSchema, SubscriptionIdSchema, SubscriptionSchema, SubscriptionUpdateSchema, TopicSchema, } from "@spine-event-engine/proto/client";
+import { SubscriptionIdSchema, SubscriptionSchema, SubscriptionUpdateSchema, TopicSchema, } from "@spine-event-engine/proto/client";
 import { SubscriptionService } from "@spine-event-engine/proto/client";
+import { EventOriginFilters } from "../stand/event-origin-filter.js";
+import { TenantAdmissions, TenantUnknownError } from "../context/tenant-unknown-error.js";
 import { AckSchema } from "@spine-event-engine/proto";
 import { ResponseSchema, StatusSchema, } from "@spine-event-engine/proto";
 import {} from "@spine-event-engine/storage";
 import { TenantBoundary } from "@spine-event-engine/storage/provider";
-import { boundedContextAccess } from "../context/bounded-context.js";
+import { BoundedContext, boundedContextAccess } from "../context/bounded-context.js";
 import { EffectiveTenants } from "../context/effective-tenant.js";
 import { CommandValidationError } from "../bus/command-errors.js";
 import { TransitionValidationError } from "../repository/command-errors.js";
 import {} from "../stand/stand.js";
 import { QueryReader } from "./query-reader.js";
 import { RegisteredTargets } from "./registered-targets.js";
-import { emitServerWarning } from "../server/server-log.js";
+import { emitServerError, emitServerWarning } from "../server/server-log.js";
 import { managedChildSubscriptionAccess } from "../server/managed-child-subscription.js";
-import { InMemorySubscriptionRegistry, } from "../stand/subscription-registry.js";
+import {} from "../stand/subscription-registry.js";
 const serviceLoggers = new WeakMap();
 const serviceInstances = new WeakSet();
 /**
@@ -85,7 +87,6 @@ export class SpineServices {
     #activationTails = new Map();
     #removals = new Map();
     #unknownRemovals = new Set();
-    #testRegistries = new WeakMap();
     #queueLimit;
     #subscriptionLimit;
     /**
@@ -170,28 +171,14 @@ export class SpineServices {
      * @returns Acknowledgement for route validation or dispatch.
      */
     async #post(command) {
-        const messageId = command.id && AnyMessages.pack(CommandIdSchema, command.id, { validate: false });
+        const messageId = command.id && AnyPacker.pack(CommandIdSchema, command.id);
         const typeUrl = command.message?.typeUrl;
-        if (typeUrl === undefined || typeUrl.length === 0) {
-            return create(AckSchema, {
-                messageId,
-                status: ServiceValues.errorStatus("INVALID_COMMAND", "Command message type is required."),
-            });
-        }
-        const route = this.#commandRoutes.get(typeUrl);
-        if (route === undefined) {
-            return create(AckSchema, {
-                messageId,
-                status: ServiceValues.errorStatus("UNSUPPORTED_COMMAND", "No bounded context accepted the command."),
-            });
-        }
-        const tenantError = ServiceValues.tenantMismatch(route.context.isMultitenant, ServiceValues.commandTenant(command), "command");
-        if (tenantError !== undefined) {
-            return create(AckSchema, {
-                messageId,
-                status: ServiceValues.errorStatus(tenantError.type, tenantError.message),
-            });
-        }
+        if (typeUrl === undefined || typeUrl.length === 0)
+            return ServiceValues.commandErrorAck(messageId, "INVALID_COMMAND", "Command message type is required.");
+        const admission = this.#commandAdmission(command, messageId, typeUrl);
+        if ("ack" in admission)
+            return admission.ack;
+        const { route } = admission;
         try {
             await route.context.commandBus().post(command);
             return create(AckSchema, {
@@ -200,13 +187,61 @@ export class SpineServices {
             });
         }
         catch (error) {
+            if (error instanceof TenantUnknownError)
+                throw TenantStatuses.unknown(error);
             const postError = ServiceValues.commandPostError(error);
+            this.#logCommandPostFailure(route, command, error);
             return create(AckSchema, {
                 messageId,
                 status: ServiceValues.errorStatus(postError.type, postError.message, postError.details),
             });
         }
     }
+    /**
+     * Checks route and tenant admission before command dispatch.
+     *
+     * @param command The public Command request.
+     * @param messageId The packed Command ID returned in the Ack.
+     * @param typeUrl The validated Command message type.
+     * @returns A selected route or a stable rejection Ack.
+     */
+    #commandAdmission(command, messageId, typeUrl) {
+        const route = this.#commandRoutes.get(typeUrl);
+        if (route === undefined) {
+            return {
+                ack: ServiceValues.commandErrorAck(messageId, "UNSUPPORTED_COMMAND", "No bounded context accepted the command."),
+            };
+        }
+        const tenantError = ServiceValues.tenantMismatch(route.context.isMultitenant, ServiceValues.commandTenant(command), "command");
+        if (tenantError !== undefined) {
+            return {
+                ack: ServiceValues.commandErrorAck(messageId, tenantError.type, tenantError.message),
+            };
+        }
+        return { route };
+    }
+    /**
+     * Records one failed command post with safe correlation fields.
+     *
+     * @param route The selected bounded context and command type.
+     * @param command The failed Command envelope.
+     * @param error The internal failure, retained for diagnostic classification only.
+     */
+    #logCommandPostFailure(route, command, error) {
+        if (error instanceof TransitionValidationError || error instanceof CommandValidationError)
+            return;
+        const logger = serviceLoggers.get(this);
+        if (logger === undefined)
+            return;
+        emitServerError(logger, "Command post failed.", {
+            contextName: route.context.name.value,
+            commandId: command.id?.uuid,
+            commandType: route.typeUrl,
+            operation: "command.post",
+            errorName: InternalErrorFacts.name(error),
+            errorCode: InternalErrorFacts.code(error),
+        });
+    }
     /**
      * Validates a public state query before reading its registered Stand.
      *
@@ -244,7 +279,9 @@ export class SpineServices {
             const destination = EffectiveTenants.destination(effective, route.context.isMultitenant);
             return await this.#query(route, ServiceValues.createReadPlan(target, query, route), destination);
         }
-        catch {
+        catch (error) {
+            if (error instanceof TenantUnknownError)
+                throw TenantStatuses.unknown(error);
             return ServiceValues.queryErrorResponse("QUERY_READ_ERROR", "Query read failed.");
         }
     }
@@ -258,10 +295,16 @@ export class SpineServices {
             message: results.map((result) => ServiceValues.packVersionedState(route.schema, result)),
         });
     }
+    /**
+     * Validates a topic synchronously and checks live membership before registry creation.
+     *
+     * @param topic Requested subscription topic.
+     * @returns Created subscription after admission.
+     */
     #subscribe(topic) {
         const route = this.#subscriptionRoute(topic);
         ServiceValues.validateTopic(topic);
-        const shape = ServiceValues.createSubscriptionShape(topic, route);
+        ServiceValues.createSubscriptionShape(topic, route);
         const tenantId = ServiceValues.topicTenant(topic);
         const tenantError = ServiceValues.tenantMismatch(route.context.isMultitenant, tenantId, "subscription");
         if (tenantError !== undefined) {
@@ -275,53 +318,24 @@ export class SpineServices {
         if (id === undefined) {
             throw new ConnectError("Subscription ID is required.", Code.InvalidArgument);
         }
-        void shape;
-        const registry = this.#subscriptionRegistry(route.context);
-        if (registry === undefined) {
-            throw new ConnectError("Subscription registry is unavailable.", Code.FailedPrecondition);
-        }
-        return registry.create(subscription).then(() => clone(SubscriptionSchema, subscription));
+        const registry = boundedContextAccess.subscriptionRegistry(route.context);
+        return TenantStatuses.require(route.context, tenantId, async () => {
+            await registry.create(subscription);
+        }).then(() => clone(SubscriptionSchema, subscription));
     }
     async *#activate(subscription) {
         const id = subscription.id?.value;
         if (id === undefined) {
             return;
         }
-        let record;
-        await this.#serializeActivation(id, async () => {
-            const local = this.#subscriptions.get(id);
-            record = local ?? (await this.#findSubscription(id));
-            if (record === undefined)
-                return;
-            if (record.delivery.active) {
-                record = undefined;
-                return;
-            }
-            const activation = await this.#subscriptionRegistry(record.route.context)?.activate(create(SubscriptionIdSchema, { value: id }));
-            if (activation === undefined ||
-                activation.kind === "missing" ||
-                activation.kind === "expired" ||
-                record.delivery.closed) {
-                record = undefined;
-                return;
-            }
-            try {
-                this.#subscriptions.set(id, record);
-                await this.#activateRecord(record);
-            }
-            catch (error) {
-                try {
-                    await this.#removeSubscription(id);
-                }
-                catch (cleanupError) {
-                    throw new AggregateError([error, cleanupError], "Subscription activation and cleanup failed.");
-                }
-                throw error;
-            }
-        });
+        const record = await this.#activationRecord(id);
         if (record === undefined)
             return;
         try {
+            yield create(SubscriptionUpdateSchema, {
+                subscription: clone(SubscriptionSchema, record.subscription),
+                response: ServiceValues.okResponse(),
+            });
             for (;;) {
                 const update = await record.delivery.next();
                 if (update === undefined) {
@@ -336,6 +350,65 @@ export class SpineServices {
             }
         }
     }
+    /**
+     * Serializes one native activation and returns its attached record.
+     *
+     * @param id The logical subscription identifier.
+     * @returns The attached record, or undefined when admission fails.
+     */
+    async #activationRecord(id) {
+        let attached;
+        await this.#serializeActivation(id, async () => {
+            attached = await this.#startActivationRecord(id);
+        });
+        return attached;
+    }
+    /**
+     * Validates and attaches one retained subscription before acknowledging readiness.
+     *
+     * @param id The logical subscription identifier.
+     * @returns The attached record, or undefined when unavailable.
+     */
+    async #startActivationRecord(id) {
+        const record = this.#subscriptions.get(id) ?? (await this.#findSubscription(id));
+        if (record === undefined)
+            return undefined;
+        let attached;
+        await this.#requireSubscriptionTenant(record, async () => {
+            attached = await this.#activateKnownRecord(record, id);
+        });
+        return attached;
+    }
+    /**
+     * Activates and attaches one admitted record before its registry closes.
+     *
+     * @param record Discovered subscription record.
+     * @param id Canonical subscription ID.
+     * @returns Attached record, if activation remains eligible.
+     */
+    async #activateKnownRecord(record, id) {
+        if (record.delivery.active)
+            return undefined;
+        const activation = await boundedContextAccess
+            .subscriptionRegistry(record.route.context)
+            .activate(create(SubscriptionIdSchema, { value: id }));
+        if (activation.kind === "missing" || activation.kind === "expired" || record.delivery.closed)
+            return undefined;
+        try {
+            this.#subscriptions.set(id, record);
+            await this.#activateRecord(record);
+            return record;
+        }
+        catch (error) {
+            try {
+                await this.#removeSubscription(id);
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], "Subscription activation and cleanup failed.");
+            }
+            throw error;
+        }
+    }
     async #serializeActivation(id, work) {
         const previous = this.#activationTails.get(id) ?? Promise.resolve();
         let finish = () => undefined;
@@ -354,12 +427,41 @@ export class SpineServices {
                 this.#activationTails.delete(id);
         }
     }
+    /**
+     * Leaves an absent subscription ID inert and checks known records before removal.
+     *
+     * @param subscription Subscription identity supplied by the caller.
+     * @returns Cancellation response after any required membership check.
+     */
     #cancel(subscription) {
         const id = subscription.id?.value;
         if (id === undefined) {
             return ServiceValues.okResponse();
         }
-        return this.#removeSubscription(id).then(() => ServiceValues.okResponse());
+        return this.#cancelKnown(id);
+    }
+    /**
+     * Checks the canonical record's tenant before cancellation side effects.
+     *
+     * @param id Subscription ID with a possible shared-registry record.
+     * @returns Successful cancellation response after removal.
+     */
+    async #cancelKnown(id) {
+        const record = this.#subscriptions.get(id) ?? (await this.#findSubscription(id));
+        if (record === undefined)
+            await this.#removeSubscription(id);
+        else
+            await this.#requireSubscriptionTenant(record, () => this.#removeSubscription(id));
+        return ServiceValues.okResponse();
+    }
+    /**
+     * Checks the discovered subscription tenant before tenant-specific control work.
+     *
+     * @param record Canonical shared-registry subscription record.
+     * @param onReady Complete admitted one-shot mutation, if present.
+     */
+    async #requireSubscriptionTenant(record, onReady) {
+        await TenantStatuses.require(record.route.context, record.tenantId, onReady);
     }
     #subscriptionRoute(topic) {
         const target = topic.target;
@@ -372,60 +474,14 @@ export class SpineServices {
         return route;
     }
     async #activateRecord(record) {
-        const registry = this.#subscriptionRegistry(record.route.context);
-        if (registry === undefined) {
-            this.#createSubscriptionAttachment(record);
-            managedChildSubscriptionAccess.installed(record.id);
-            return;
-        }
-        try {
-            const consumer = await boundedContextAccess.consumeSubscription(record.route.context, record.id, (update) => {
-                record.delivery.push(update);
-                if (record.delivery.closed) {
-                    this.#removeDetachedSubscription(record.id);
-                }
-            });
-            record.delivery.attach(consumer);
-        }
-        catch (error) {
-            if (!(error instanceof TypeError) ||
-                (!error.message.includes("requires a Stand instance") &&
-                    !error.message.includes("requires a built BoundedContext instance"))) {
-                throw error;
-            }
-            this.#createSubscriptionAttachment(record);
-        }
+        const consumer = await boundedContextAccess.consumeSubscription(record.route.context, record.id, (update) => {
+            record.delivery.push(update);
+            if (record.delivery.closed)
+                this.#removeDetachedSubscription(record.id);
+        });
+        record.delivery.attach(consumer);
         managedChildSubscriptionAccess.installed(record.id);
     }
-    #createSubscriptionAttachment(record) {
-        if (record.kind === "event") {
-            const eventSubscription = boundedContextAccess.subscribeToEvent(record.route.context, record.route.typeUrl, {
-                onEvent: (event) => {
-                    if (!ServiceValues.eventTenantMatches(record, event)) {
-                        return;
-                    }
-                    record.delivery.push(ServiceValues.createEventUpdate(record, event));
-                    if (record.delivery.closed) {
-                        this.#removeDetachedSubscription(record.id);
-                    }
-                },
-            });
-            record.delivery.attach(eventSubscription);
-            return eventSubscription;
-        }
-        const stateRecord = record;
-        const standSubscription = stateRecord.route.context.stand().subscribe(stateRecord.route.schema, (update) => {
-            const subscriptionUpdate = ServiceValues.createEntityUpdate(stateRecord, update);
-            if (subscriptionUpdate !== undefined) {
-                stateRecord.delivery.push(subscriptionUpdate);
-            }
-            if (stateRecord.delivery.closed) {
-                this.#removeDetachedSubscription(stateRecord.id);
-            }
-        }, ServiceValues.tenantOptions(stateRecord.tenantId));
-        stateRecord.delivery.attach(standSubscription);
-        return standSubscription;
-    }
     #removeSubscription(id) {
         const existing = this.#removals.get(id);
         if (existing !== undefined) {
@@ -464,15 +520,12 @@ export class SpineServices {
     async #runRemoval(id, removal, record, unknown) {
         try {
             if (record !== undefined) {
-                await this.#subscriptionRegistry(record.route.context)?.delete(create(SubscriptionIdSchema, { value: id }));
+                await boundedContextAccess
+                    .subscriptionRegistry(record.route.context)
+                    .delete(create(SubscriptionIdSchema, { value: id }));
             }
             else {
-                await Promise.all(ServiceValues.uniqueContexts(this.#contexts).flatMap((context) => {
-                    const registry = this.#subscriptionRegistry(context);
-                    return registry === undefined
-                        ? []
-                        : [registry.delete(create(SubscriptionIdSchema, { value: id }))];
-                }));
+                await this.#deleteUnknownSubscription(id);
             }
             removal.resolve();
         }
@@ -488,10 +541,25 @@ export class SpineServices {
             }
         }
     }
+    /**
+     * Deletes an unknown subscription from every configured context registry.
+     *
+     * @param id Subscription ID to remove.
+     */
+    async #deleteUnknownSubscription(id) {
+        await Promise.all(ServiceValues.uniqueContexts(this.#contexts).map((context) => this.#registryOperation(context, async () => {
+            await boundedContextAccess
+                .subscriptionRegistry(context)
+                .delete(create(SubscriptionIdSchema, { value: id }));
+        })));
+    }
     async #findSubscription(id) {
         const subscriptionId = create(SubscriptionIdSchema, { value: id });
         for (const context of ServiceValues.uniqueContexts(this.#contexts)) {
-            const entry = await this.#subscriptionRegistry(context)?.get(subscriptionId);
+            let entry;
+            await this.#registryOperation(context, async () => {
+                entry = await boundedContextAccess.subscriptionRegistry(context).get(subscriptionId);
+            });
             const subscription = entry?.subscription;
             const topic = subscription?.topic;
             if (entry === undefined || subscription === undefined || topic === undefined)
@@ -514,24 +582,15 @@ export class SpineServices {
         }
         return undefined;
     }
-    #subscriptionRegistry(context) {
-        if (context === undefined) {
-            return undefined;
-        }
-        try {
-            return boundedContextAccess.subscriptionRegistry(context);
-        }
-        catch {
-            // Direct route tests may use structural context doubles. Production
-            // contexts always provide their configured registry through the access seam.
-            const key = context;
-            let registry = this.#testRegistries.get(key);
-            if (registry === undefined) {
-                registry = new InMemorySubscriptionRegistry();
-                this.#testRegistries.set(key, registry);
-            }
-            return registry;
-        }
+    /**
+     * Retains one short registry read or delete through the context close drain.
+     *
+     * @param context Context selected by the shared subscription route.
+     * @param onOperation Complete registry callback.
+     * @returns Completion before the selected registry may close.
+     */
+    #registryOperation(context, onOperation) {
+        return boundedContextAccess.admitServiceRegistryOperation(context, onOperation);
     }
 }
 /**
@@ -765,7 +824,8 @@ function validateQueryIds(ids, route) {
     if (schema === undefined || ids === undefined) {
         return undefined;
     }
-    if (ids.some((id) => id === undefined || AnyMessages.unpack(id, schema) === undefined)) {
+    if (ids.some((id) => id === undefined ||
+        (schema.typeName !== AnySchema.typeName && AnyPacker.tryUnpack(id, schema) === undefined))) {
         return invalidQueryError(`QueryService.Read id_filter values must pack ${schema.typeName}.`);
     }
     return undefined;
@@ -876,7 +936,7 @@ function normalizedFilters(filters, route) {
 }
 function decodeQueryIdValue(value, route) {
     const schema = route.idField.message;
-    return schema === undefined ? decodeAnyValue(value) : AnyMessages.unpack(value, schema);
+    return schema === undefined ? decodeAnyValue(value) : decodeAnyValue(value, schema);
 }
 function normalizedComposite(filter, route) {
     const predicates = [
@@ -908,13 +968,13 @@ function requiredComparison(filter) {
 function decodeColumnValue(filter, route) {
     const column = filter.fieldPath?.fieldName[0] ?? "";
     if (column === "version" && filter.value !== undefined) {
-        const value = AnyMessages.unpack(filter.value, VersionSchema);
+        const value = AnyPacker.tryUnpack(filter.value, VersionSchema);
         if (value !== undefined)
             return value;
         throw new TypeError('Validated query column "version" has an invalid value.');
     }
     if ((column === "archived" || column === "deleted") && filter.value !== undefined) {
-        const value = AnyMessages.unpack(filter.value, BoolValueSchema);
+        const value = AnyPacker.tryUnpack(filter.value, BoolValueSchema);
         if (value !== undefined)
             return value.value;
         throw new TypeError(`Validated query column "${column}" has an invalid value.`);
@@ -924,7 +984,8 @@ function decodeColumnValue(filter, route) {
 }
 function filterValueMatches(field, value) {
     const schema = filterValueSchema(field);
-    if (schema === undefined || value.typeUrl !== TypeUrls.derive(schema))
+    if (schema === undefined ||
+        (schema.typeName !== AnySchema.typeName && value.typeUrl !== TypeUrls.derive(schema)))
         return false;
     const decoded = field.fieldKind === "message" ? decodeAnyValue(value, schema) : decodeAnyValue(value);
     if (field.fieldKind === "message") {
@@ -982,11 +1043,11 @@ function filterValueSchema(field) {
 function systemValueMatches(column, value) {
     if (column === "version") {
         return (value.typeUrl === TypeUrls.derive(VersionSchema) &&
-            AnyMessages.unpack(value, VersionSchema) !== undefined);
+            AnyPacker.tryUnpack(value, VersionSchema) !== undefined);
     }
     if (column === "archived" || column === "deleted") {
         return (value.typeUrl === TypeUrls.derive(BoolValueSchema) &&
-            AnyMessages.unpack(value, BoolValueSchema) !== undefined);
+            AnyPacker.tryUnpack(value, BoolValueSchema) !== undefined);
     }
     return false;
 }
@@ -1097,7 +1158,7 @@ function validateTopic(topic) {
     }
 }
 /**
- * Validates a topic and prepares complete state or event delivery.
+ * Validates a topic and returns its state or Event subscription shape.
  */
 function createSubscriptionShape(topic, route) {
     const target = topic.target;
@@ -1113,13 +1174,10 @@ function createSubscriptionShape(topic, route) {
             if (!target.criterion.value) {
                 throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
             }
-            return { kind: "state", route, matcher: { match: () => "state" } };
+            return { kind: "state", route };
         case "filters":
-            return {
-                kind: "state",
-                route,
-                matcher: createFilteredSubscriptionMatcher(target.criterion.value, route),
-            };
+            ServiceValues.validateFilteredSubscriptionTopic(target.criterion.value, route);
+            return { kind: "state", route };
         default:
             throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
     }
@@ -1135,42 +1193,12 @@ function validateEventSubscriptionTopic(target) {
             }
             return;
         case "filters":
-            throw new ConnectError("SubscriptionService.Subscribe event topics support only include_all in this runtime slice.", Code.InvalidArgument);
+            EventOriginFilters.compile(target.criterion.value);
+            return;
         default:
             throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
     }
 }
-/**
- * Matches complete state updates against a topic's ID and field filters.
- */
-function createFilteredSubscriptionMatcher(filters, route) {
-    ServiceValues.validateSubscriptionFilters(filters);
-    const idValues = filters.idFilter?.id.map((id) => decodeSubscriptionIdValue(id, route));
-    const statePredicate = createSubscriptionPredicate(filters.filter, route);
-    return {
-        /**
-         * Matches one state update against the topic's ID and field filters.
-         *
-         * @param update State update to inspect.
-         * @returns Delivery kind, if the update changes a matching state.
-         */
-        match(update) {
-            if (idValues !== undefined &&
-                !idValues.some((id) => valuesEqual(update.id, id, route.idField.message))) {
-                return undefined;
-            }
-            if (statePredicate(update.state))
-                return "state";
-            if (update.previousState !== undefined && statePredicate(update.previousState))
-                return "noLongerMatching";
-            return undefined;
-        },
-    };
-}
-function createSubscriptionPredicate(filters, route) {
-    const predicates = filters.map((filter) => createCompositePredicate(filter, route));
-    return (state) => predicates.every((predicate) => predicate(state));
-}
 function validateSubscriptionFilterTree(filters) {
     if (filters.length > SubscriptionLimits.compositeCount) {
         throw new ConnectError("SubscriptionService.Subscribe may contain at most 8 composite filters.", Code.InvalidArgument);
@@ -1227,30 +1255,6 @@ function enqueueSubscriptionFilterChildren(filter, depth, stack) {
         stack.push({ filter: nested, depth: depth + 1 });
     }
 }
-function createCompositePredicate(filter, route) {
-    const children = [
-        ...filter.filter.map((simple) => createSimplePredicate(simple, route)),
-        ...filter.compositeFilter.map((nested) => createCompositePredicate(nested, route)),
-    ];
-    if (children.length === 0) {
-        return () => true;
-    }
-    return filter.operator === CompositeFilter_CompositeOperator.ALL
-        ? (state) => children.every((predicate) => predicate(state))
-        : (state) => children.some((predicate) => predicate(state));
-}
-function createSimplePredicate(filter, route) {
-    if (filter.operator !== Filter_Operator.EQUAL) {
-        throw new ConnectError("SubscriptionService.Subscribe supports only EQUAL field filters.", Code.InvalidArgument);
-    }
-    if (filter.value === undefined) {
-        throw new ConnectError("SubscriptionService.Subscribe field filter value is required.", Code.InvalidArgument);
-    }
-    validateSubscriptionPath(filter.fieldPath?.fieldName ?? [], "field filter");
-    const resolved = resolveMessagePath(route.schema, filter.fieldPath?.fieldName ?? [], "field filter");
-    const expected = decodeFieldFilterValue(filter.value, resolved.leafSchema);
-    return (state) => valuesEqual(readPathValue(state, resolved.localPath), expected, resolved.leafSchema);
-}
 /**
  * Checks a state filter path before resolving its fields.
  */
@@ -1272,7 +1276,9 @@ function decodeSubscriptionIdValue(value, route) {
     if (route.idField.message === undefined) {
         return decodeAnyValue(value);
     }
-    const decoded = AnyMessages.unpack(value, route.idField.message);
+    const decoded = route.idField.message.typeName === AnySchema.typeName
+        ? value
+        : AnyPacker.tryUnpack(value, route.idField.message);
     if (decoded === undefined) {
         throw new ConnectError(`SubscriptionService.Subscribe id_filter values must pack ${route.idField.message.typeName}.`, Code.InvalidArgument);
     }
@@ -1282,7 +1288,7 @@ function decodeFieldFilterValue(value, schema) {
     if (value === undefined || schema === undefined) {
         return decodeAnyValue(value);
     }
-    const decoded = AnyMessages.unpack(value, schema);
+    const decoded = schema.typeName === AnySchema.typeName ? value : AnyPacker.tryUnpack(value, schema);
     if (decoded === undefined) {
         throw new ConnectError(`SubscriptionService.Subscribe field filter value must pack ${schema.typeName}.`, Code.InvalidArgument);
     }
@@ -1293,7 +1299,9 @@ function decodeAnyValue(value, schema) {
         return undefined;
     }
     if (schema !== undefined) {
-        const decoded = AnyMessages.unpack(value, schema);
+        if (schema.typeName === AnySchema.typeName)
+            return value;
+        const decoded = AnyPacker.tryUnpack(value, schema);
         if (decoded !== undefined) {
             return decoded;
         }
@@ -1310,7 +1318,6 @@ function decodeAnyValue(value, schema) {
  * Resolves a state filter path to generated message fields.
  */
 function resolveMessagePath(schema, fieldPath, label) {
-    const localPath = [];
     let currentSchema = schema;
     let leafSchema;
     for (const [index, name] of fieldPath.entries()) {
@@ -1318,7 +1325,6 @@ function resolveMessagePath(schema, fieldPath, label) {
         if (field === undefined) {
             throw new ConnectError(`SubscriptionService.Subscribe ${label} "${fieldPath.join(".")}" is not a state field.`, Code.InvalidArgument);
         }
-        localPath.push(field.localName);
         leafSchema = field.message;
         currentSchema = index === fieldPath.length - 1 ? undefined : field.message;
         if (currentSchema === undefined && index < fieldPath.length - 1) {
@@ -1326,7 +1332,6 @@ function resolveMessagePath(schema, fieldPath, label) {
         }
     }
     return Object.freeze({
-        localPath,
         ...(leafSchema === undefined ? {} : { leafSchema }),
     });
 }
@@ -1334,37 +1339,12 @@ function findMessageField(schema, name) {
     const fields = (schema?.fields ?? []);
     return fields.find((field) => field.name === name || field.localName === name);
 }
-function readPathValue(value, path) {
-    let current = value;
-    for (const segment of path) {
-        if (typeof current !== "object" || current === null) {
-            return undefined;
-        }
-        current = Reflect.get(current, segment);
-    }
-    return current;
-}
-function valuesEqual(actual, expected, schema) {
-    if (schema !== undefined && isMessage(actual) && isMessage(expected)) {
-        return bytesEqual(toBinary(schema, actual), toBinary(schema, expected));
-    }
-    if (isAny(actual) && isAny(expected)) {
-        return bytesEqual(toBinary(AnySchema, actual), toBinary(AnySchema, expected));
-    }
-    if (actual instanceof Uint8Array && expected instanceof Uint8Array) {
-        return bytesEqual(actual, expected);
-    }
-    return Object.is(actual, expected);
-}
 function isMessage(value) {
     return typeof value === "object" && value !== null && "$typeName" in value;
 }
 function isAny(value) {
     return isMessage(value) && value.$typeName === "google.protobuf.Any";
 }
-function bytesEqual(left, right) {
-    return left.length === right.length && left.every((byte, index) => byte === right[index]);
-}
 /**
  * Packs a state snapshot and version for a public query result.
  *
@@ -1375,7 +1355,7 @@ function bytesEqual(left, right) {
  */
 function packVersionedState(schema, result) {
     return create(EntityStateVersionSchema, {
-        state: AnyMessages.pack(schema, result.state, { validate: false }),
+        state: AnyPacker.pack(schema, result.state),
         version: result.version ?? create(VersionSchema),
     });
 }
@@ -1385,22 +1365,6 @@ function commandTenant(command) {
 function topicTenant(topic) {
     return tenantValue(topic?.context?.tenantId);
 }
-function eventTenant(event) {
-    switch (event.context?.origin.case) {
-        case "importContext":
-            return tenantValue(event.context.origin.value.tenantId);
-        case "pastMessage":
-            return tenantValue(event.context.origin.value.actorContext?.tenantId);
-        default:
-            return undefined;
-    }
-}
-function eventTenantMatches(record, event) {
-    const tenantId = eventTenant(event);
-    return (record.tenantId === undefined ||
-        (tenantId !== undefined &&
-            TenantBoundary.from(tenantId).key === TenantBoundary.from(record.tenantId).key));
-}
 function tenantValue(tenantId) {
     if (tenantId === undefined)
         return undefined;
@@ -1421,6 +1385,53 @@ function stateRouteIdField(schema, idField) {
     }
     return field;
 }
+/**
+ * Maps confirmed tenant absence to native service errors.
+ */
+const TenantStatuses = Object.freeze({
+    /**
+     * Checks live membership and maps only confirmed missing membership to NotFound.
+     *
+     * @param context Receiving context and its selected index.
+     * @param tenantId Complete selected tenant identity.
+     * @param onReady Complete one-shot mutation after membership and preparation.
+     * @returns Completion after membership and any mutation settle.
+     */
+    async require(context, tenantId, onReady) {
+        try {
+            const runtimeContext = context;
+            if (runtimeContext instanceof BoundedContext)
+                await boundedContextAccess.admitServiceInput(runtimeContext, tenantId, () => TenantAdmissions.require(context.tenantIndex, context.name.value, context.isMultitenant, tenantId), onReady);
+            else {
+                await TenantAdmissions.require(context.tenantIndex, context.name.value, context.isMultitenant, tenantId);
+                await onReady?.();
+            }
+        }
+        catch (error) {
+            if (error instanceof TenantUnknownError)
+                throw TenantStatuses.unknown(error);
+            throw error;
+        }
+    },
+    /**
+     * Exposes a confirmed unknown tenant as a native NotFound RPC with Spine details.
+     *
+     * @param error Receiving-context membership failure.
+     * @returns Connect failure preserving its stable Spine error type.
+     */
+    unknown(error) {
+        return new ConnectError(error.message, Code.NotFound, undefined, [
+            {
+                desc: ErrorSchema,
+                value: create(ErrorSchema, {
+                    type: error.type,
+                    code: Code.NotFound,
+                    message: error.message,
+                }),
+            },
+        ], error);
+    },
+});
 function tenantMismatch(multitenant, tenantId, subject) {
     if (multitenant) {
         return tenantId === undefined
@@ -1442,18 +1453,14 @@ function commandPostError(error) {
         return {
             type: error.type,
             message: error.clientMessage,
-            details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
-                validate: false,
-            }),
+            details: AnyPacker.pack(ValidationErrorSchema, error.validationError),
         };
     }
     if (error instanceof CommandValidationError) {
         return {
             type: "COMMAND_VALIDATION_ERROR",
             message: "Command payload validation failed.",
-            details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
-                validate: false,
-            }),
+            details: AnyPacker.pack(ValidationErrorSchema, error.validationError),
         };
     }
     return {
@@ -1461,104 +1468,77 @@ function commandPostError(error) {
         message: "Command post failed.",
     };
 }
-function tenantOptions(tenantId) {
-    return tenantId === undefined ? {} : { tenantId: clone(TenantIdSchema, tenantId) };
-}
-const VALUE_DECODERS = Object.freeze([
-    (value) => AnyMessages.unpack(value, StringValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, BoolValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, Int32ValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, UInt32ValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, Int64ValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, UInt64ValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, FloatValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, DoubleValueSchema)?.value,
-    (value) => AnyMessages.unpack(value, BytesValueSchema)?.value,
+const recognizedSqlErrorCodes = new Set([
+    "40001",
+    "40P01",
+    "42703",
+    "42P01",
+    "23503",
+    "23505",
+    "P0001",
+    "08006",
+    "ER_BAD_FIELD_ERROR",
+    "ER_LOCK_DEADLOCK",
+    "ER_LOCK_WAIT_TIMEOUT",
+    "ER_SIGNAL_EXCEPTION",
 ]);
-/**
- * Builds a subscription update with a complete state or a removal signal.
- */
-function createEntityUpdate(record, update) {
-    const matcher = record.matcher;
-    if (matcher === undefined)
-        return undefined;
-    const match = matcher.match(update);
-    if (match === undefined)
+const InternalErrorFacts = Object.freeze({
+    /**
+     * Reads a recognized SQL code from an internal failure chain.
+     *
+     * @param error The internal failure.
+     * @returns A recognized code, if present.
+     */
+    code(error) {
+        const seen = new Set();
+        let current = error;
+        for (let depth = 0; depth < 8 && typeof current === "object" && current !== null; depth++) {
+            if (seen.has(current))
+                break;
+            seen.add(current);
+            try {
+                const code = Reflect.get(current, "code");
+                if (typeof code === "string" && recognizedSqlErrorCodes.has(code))
+                    return code;
+                current = Reflect.get(current, "cause");
+            }
+            catch {
+                return undefined;
+            }
+        }
         return undefined;
-    const kind = match === "state"
-        ? {
-            case: "state",
-            value: AnyMessages.pack(record.route.schema, clone(record.route.schema, update.state), {
-                validate: false,
-            }),
+    },
+    /**
+     * Reads a safe error class name without trusting a rejection's accessors.
+     *
+     * @param error The internal failure.
+     * @returns A known error name, if present.
+     */
+    name(error) {
+        try {
+            if (!(error instanceof Error))
+                return undefined;
+            const name = error.name;
+            return ["Error", "TypeError", "RangeError", "AggregateError"].includes(name)
+                ? name
+                : undefined;
         }
-        : { case: "noLongerMatching", value: true };
-    return create(SubscriptionUpdateSchema, {
-        subscription: clone(SubscriptionSchema, record.subscription),
-        response: okResponse(),
-        update: {
-            case: "entityUpdates",
-            value: create(EntityUpdatesSchema, {
-                update: [
-                    create(EntityStateUpdateSchema, {
-                        id: packEntityId(record.route, update.id),
-                        kind,
-                    }),
-                ],
-            }),
-        },
-    });
-}
-function createEventUpdate(record, event) {
-    return create(SubscriptionUpdateSchema, {
-        subscription: clone(SubscriptionSchema, record.subscription),
-        response: okResponse(),
-        update: {
-            case: "eventUpdates",
-            value: create(EventUpdatesSchema, {
-                event: [cloneClientEvent(event)],
-            }),
-        },
-    });
-}
-function cloneClientEvent(event) {
-    const clientEvent = clone(EventSchema, event);
-    const rejection = clientEvent.context?.rejection;
-    if (rejection !== undefined) {
-        rejection.command = undefined;
-        // Clear the legacy wire payload as part of client-side security redaction.
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
-        rejection.commandMessage = undefined;
-        rejection.stacktrace = "";
-    }
-    return clientEvent;
-}
-function packString(value) {
-    return AnyMessages.pack(StringValueSchema, create(StringValueSchema, { value }));
-}
-function packEntityId(route, id) {
-    if (isAny(id)) {
-        return clone(AnySchema, id);
-    }
-    if (route.idField.message !== undefined && isMessage(id)) {
-        return AnyMessages.pack(route.idField.message, id, { validate: false });
-    }
-    if (id instanceof Uint8Array) {
-        return AnyMessages.pack(BytesValueSchema, create(BytesValueSchema, { value: id }));
-    }
-    switch (typeof id) {
-        case "string":
-            return packString(id);
-        case "boolean":
-            return AnyMessages.pack(BoolValueSchema, create(BoolValueSchema, { value: id }));
-        case "number":
-            return AnyMessages.pack(DoubleValueSchema, create(DoubleValueSchema, { value: id }));
-        case "bigint":
-            return AnyMessages.pack(Int64ValueSchema, create(Int64ValueSchema, { value: id }));
-        default:
+        catch {
             return undefined;
-    }
-}
+        }
+    },
+});
+const VALUE_DECODERS = Object.freeze([
+    (value) => AnyPacker.tryUnpack(value, StringValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, BoolValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, Int32ValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, UInt32ValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, Int64ValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, UInt64ValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, FloatValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, DoubleValueSchema)?.value,
+    (value) => AnyPacker.tryUnpack(value, BytesValueSchema)?.value,
+]);
 /**
  * Groups non-public service contract, query, and subscription operations.
  */
@@ -1616,6 +1596,48 @@ const ServiceValues = Object.freeze({
         }
         return undefined;
     },
+    /**
+     * Validates state ID and field filters before storing the topic.
+     *
+     * @param filters The topic's declared filters.
+     * @param route The registered state route.
+     */
+    validateFilteredSubscriptionTopic(filters, route) {
+        ServiceValues.validateSubscriptionFilters(filters);
+        for (const id of filters.idFilter?.id ?? [])
+            decodeSubscriptionIdValue(id, route);
+        for (const filter of filters.filter)
+            ServiceValues.validateCompositeFilter(filter, route);
+    },
+    /**
+     * Validates nested state filter values without retaining an observer predicate.
+     *
+     * @param filter A validated composite filter.
+     * @param route The registered state route.
+     */
+    validateCompositeFilter(filter, route) {
+        for (const simple of filter.filter)
+            ServiceValues.validateSimpleFilter(simple, route);
+        for (const nested of filter.compositeFilter)
+            ServiceValues.validateCompositeFilter(nested, route);
+    },
+    /**
+     * Validates one field path and packed comparison value.
+     *
+     * @param filter A simple field filter.
+     * @param route The registered state route.
+     */
+    validateSimpleFilter(filter, route) {
+        if (filter.operator !== Filter_Operator.EQUAL) {
+            throw new ConnectError("SubscriptionService.Subscribe supports only EQUAL field filters.", Code.InvalidArgument);
+        }
+        if (filter.value === undefined) {
+            throw new ConnectError("SubscriptionService.Subscribe field filter value is required.", Code.InvalidArgument);
+        }
+        validateSubscriptionPath(filter.fieldPath?.fieldName ?? [], "field filter");
+        const resolved = resolveMessagePath(route.schema, filter.fieldPath?.fieldName ?? [], "field filter");
+        decodeFieldFilterValue(filter.value, resolved.leafSchema);
+    },
     /**
      * Checks that a state topic has a usable ID or field filter.
      *
@@ -1634,9 +1656,18 @@ const ServiceValues = Object.freeze({
         validateSubscriptionFilterTree(filters.filter);
     },
     commandPostError,
+    /**
+     * Builds a stable Command rejection acknowledgement.
+     *
+     * @param messageId The packed Command ID, if supplied.
+     * @param type The public error code.
+     * @param message The public error message.
+     * @returns A sanitized Ack.
+     */
+    commandErrorAck(messageId, type, message) {
+        return create(AckSchema, { messageId, status: errorStatus(type, message) });
+    },
     commandTenant,
-    createEntityUpdate,
-    createEventUpdate,
     createReadPlan,
     createSubscriptionRecord,
     createSubscriptionRemoval,
@@ -1644,7 +1675,6 @@ const ServiceValues = Object.freeze({
     defaultQueueLimit: DEFAULT_QUEUE_LIMIT,
     defaultSubscriptionLimit: DEFAULT_SUBSCRIPTION_LIMIT,
     errorStatus,
-    eventTenantMatches,
     okResponse,
     okStatus,
     positiveInteger,
@@ -1654,7 +1684,6 @@ const ServiceValues = Object.freeze({
     stateRouteIdField,
     subscriptionLimit,
     tenantMismatch,
-    tenantOptions,
     tenantValue,
     topicTenant,
     uniqueContexts,