@spine-event-engine/server 2.0.0-snapshot.2 → 2.0.0-snapshot.20

package/dist/services/spine-services.js

@@ -26,11 +26,15 @@ import { EntityStateUpdateSchema, EntityUpdatesSchema, EventUpdatesSchema, Subsc
 import { SubscriptionService } from "@spine-event-engine/proto/client";
 import { AckSchema } from "@spine-event-engine/proto";
 import { ResponseSchema, StatusSchema, } from "@spine-event-engine/proto";
-import { RecordMask, TenantBoundary, } from "@spine-event-engine/storage";
+import {} from "@spine-event-engine/storage";
+import { TenantBoundary } from "@spine-event-engine/storage/provider";
 import { 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 { managedChildSubscriptionAccess } from "../server/managed-child-subscription.js";
 import { InMemorySubscriptionRegistry, } from "../stand/subscription-registry.js";
@@ -40,16 +44,19 @@ const serviceInstances = new WeakSet();
  * Small route registrar for the first public Spine gRPC service slice.
  *
  * `QueryService.Read` supports ID filters for any registered state route,
- * projection-state `include_all = true` reads, top-level equality filters over
- * declared projection `(column)` proto field names, field masks, ordering by
- * declared proto columns, and bounded result sets. An absent response format or
- * zero wire limit receives an implicit 1,000-row cap without requiring
- * ordering; a positive limit requires at least one ordering directive. Use
- * proto column names such as `open_task_count`, not generated TS local names
- * such as `openTaskCount`; undeclared columns return stable `INVALID_QUERY`
- * responses before Stand storage is read. Unsupported query operators and
- * shapes also return stable `INVALID_QUERY` responses before Stand storage is
- * read.
+ * projection-state `include_all = true` reads, and column filters with
+ * `EQUAL`, `GREATER_THAN`, `LESS_THAN`, `GREATER_OR_EQUAL`, or `LESS_OR_EQUAL`
+ * comparisons inside nested `ALL`/`EITHER` composites. Filter paths name one
+ * declared `(column)` proto field or supported system column, and values must
+ * match its type. Range comparisons and ordering require a string or numeric
+ * scalar column, `Timestamp`, or `version`; ordering accepts only `ASCENDING`
+ * or `DESCENDING`. An absent response format or zero
+ * wire limit receives an implicit 1,000-row cap without requiring ordering; a
+ * positive limit of at most 1,000 requires at least one ordering directive.
+ * Queries allow at most 100 IDs, 16 simple filters, 8 composites, and 8 orderings.
+ * Use proto column names such as `open_task_count`, not generated TS local names
+ * such as `openTaskCount`. Invalid columns, values, operators, and query shapes
+ * return stable `INVALID_QUERY` responses before Stand storage is read.
  *
  * `SubscriptionService.Subscribe` accepts known state targets with
  * `include_all` or validated ID/field filters and known event targets exposed
@@ -59,8 +66,8 @@ const serviceInstances = new WeakSet();
  * subscriptions attach to `Stand`, while
  * event subscriptions attach to a framework-internal `EventBus` listener.
  * Filtered state topics deliver matching states, emit `no_longer_matching`
- * when previous state matched and new state does not, and apply topic masks
- * only to delivered states. Event topics stream wire-level `event_updates`
+ * when previous state matched and new state does not, and deliver complete states.
+ * Event topics stream wire-level `event_updates`
  * containing cloned framework `Event` envelopes; rejection updates omit
  * rejected-command payload forms and stack trace from their client-facing
  * context.
@@ -91,31 +98,19 @@ export class SpineServices {
         this.#contexts = Object.freeze([...options.contexts]);
         this.#queueLimit = ServiceValues.positiveInteger(options.queueLimit ?? ServiceValues.defaultQueueLimit);
         this.#subscriptionLimit = ServiceValues.subscriptionLimit(options.subscriptionLimit ?? ServiceValues.defaultSubscriptionLimit);
+        this.#registerSignalRoutes();
+        this.#registerStateRoutes(new RegisteredTargets(this.#contexts));
+    }
+    /**
+     * Registers Command and Event routes exposed by the assembled contexts.
+     */
+    #registerSignalRoutes() {
         for (const context of this.#contexts) {
             for (const typeUrl of context.commandBus().acceptedCommandTypes()) {
                 if (!this.#commandRoutes.has(typeUrl)) {
                     this.#commandRoutes.set(typeUrl, { context, typeUrl });
                 }
             }
-            for (const repository of context.registeredRepositories()) {
-                const schema = repository.stateSchema;
-                const typeUrl = TypeUrls.derive(schema);
-                const declaredColumns = repository.metadata.columns.map((column) => column.name);
-                const systemColumns = ["version", "archived", "deleted"];
-                this.#stateRoutes.set(typeUrl, {
-                    allowedColumnNames: new Set([...declaredColumns, ...systemColumns]),
-                    columnFields: new Map(repository.metadata.columns.flatMap((column) => {
-                        const field = schema.fields.find((candidate) => candidate.name === column.name);
-                        return field === undefined ? [] : [[column.name, field]];
-                    })),
-                    context,
-                    entityFamily: repository.entityFamily,
-                    idField: ServiceValues.stateRouteIdField(schema, repository.idField),
-                    kind: "state",
-                    schema,
-                    typeUrl,
-                });
-            }
             for (const typeUrl of context.eventBus().acceptedEventTypes()) {
                 if (!this.#eventRoutes.has(typeUrl)) {
                     this.#eventRoutes.set(typeUrl, { context, kind: "event", typeUrl });
@@ -123,6 +118,31 @@ export class SpineServices {
             }
         }
     }
+    /**
+     * Registers state routes from the validated server-wide Entity lookup.
+     *
+     * @param targets Validated state registrations.
+     */
+    #registerStateRoutes(targets) {
+        for (const { context, repository, typeUrl } of targets.all()) {
+            const schema = repository.stateSchema;
+            const declaredColumns = repository.metadata.columns.map((column) => column.name);
+            const systemColumns = ["version", "archived", "deleted"];
+            this.#stateRoutes.set(typeUrl, {
+                allowedColumnNames: new Set([...declaredColumns, ...systemColumns]),
+                columnFields: new Map(repository.metadata.columns.flatMap((column) => {
+                    const field = schema.fields.find((candidate) => candidate.name === column.name);
+                    return field === undefined ? [] : [[column.name, field]];
+                })),
+                context,
+                entityFamily: repository.entityFamily,
+                idField: ServiceValues.stateRouteIdField(schema, repository.idField),
+                kind: "state",
+                schema,
+                typeUrl,
+            });
+        }
+    }
     /**
      * Registers CommandService, QueryService, and SubscriptionService routes.
      *
@@ -143,6 +163,12 @@ export class SpineServices {
         });
         return router;
     }
+    /**
+     * Resolves a public Command route before attempting dispatch.
+     *
+     * @param command Public Command request.
+     * @returns Acknowledgement for route validation or dispatch.
+     */
     async #post(command) {
         const messageId = command.id && AnyMessages.pack(CommandIdSchema, command.id, { validate: false });
         const typeUrl = command.message?.typeUrl;
@@ -181,6 +207,12 @@ export class SpineServices {
             });
         }
     }
+    /**
+     * Validates a public state query before reading its registered Stand.
+     *
+     * @param query Public query request.
+     * @returns States or a stable query error response.
+     */
     async #read(query) {
         const target = query.target;
         const route = this.#readRoute(target);
@@ -191,13 +223,26 @@ export class SpineServices {
         if (queryError !== undefined) {
             return ServiceValues.queryErrorResponse(queryError.type, queryError.message);
         }
+        return this.#readValidated(query, target, route);
+    }
+    /**
+     * Resolves the effective tenant and executes an already validated read.
+     *
+     * @param query Validated public query.
+     * @param target Registered query target.
+     * @param route Route containing the target Stand and schema.
+     * @returns States or a stable tenant/read error response.
+     */
+    async #readValidated(query, target, route) {
         const tenantId = ServiceValues.tenantValue(query.context?.tenantId);
         const tenantError = ServiceValues.tenantMismatch(route.context.isMultitenant, tenantId, "query");
         if (tenantError !== undefined) {
             return ServiceValues.queryErrorResponse(tenantError.type, tenantError.message);
         }
         try {
-            return await this.#query(route, ServiceValues.createReadPlan(target, query, route), tenantId);
+            const effective = EffectiveTenants.current(route.context.isMultitenant, tenantId);
+            const destination = EffectiveTenants.destination(effective, route.context.isMultitenant);
+            return await this.#query(route, ServiceValues.createReadPlan(target, query, route), destination);
         }
         catch {
             return ServiceValues.queryErrorResponse("QUERY_READ_ERROR", "Query read failed.");
@@ -207,13 +252,7 @@ export class SpineServices {
         return target === undefined ? undefined : this.#stateRoutes.get(target.type);
     }
     async #query(route, plan, tenantId) {
-        const boundedPlan = {
-            ...plan,
-            candidateLimit: ServiceValues.queryResultLimit,
-        };
-        const results = await route.context
-            .stand()
-            .queryPlanVersioned(route.schema, boundedPlan, ServiceValues.tenantOptions(tenantId));
+        const results = await QueryReader.read(route.context.stand(), route.schema, plan, tenantId, ServiceValues.queryResultLimit);
         return create(QueryResponseSchema, {
             response: ServiceValues.okResponse(),
             message: results.map((result) => ServiceValues.packVersionedState(route.schema, result)),
@@ -501,12 +540,23 @@ export class SpineServices {
  * @internal
  */
 export const spineServicesAccess = Object.freeze({
+    /**
+     * Clears the logger installed for a closed service adapter.
+     *
+     * @param services Adapter whose logger is removed.
+     */
     clearLogger(services) {
         if (!serviceInstances.has(services)) {
             throw new TypeError("SpineServices logger requires a SpineServices instance.");
         }
         serviceLoggers.delete(services);
     },
+    /**
+     * Sets the server logger for service diagnostics.
+     *
+     * @param services Adapter receiving the logger.
+     * @param logger Server logging layer.
+     */
     installLogger(services, logger) {
         if (!serviceInstances.has(services)) {
             throw new TypeError("SpineServices logger requires a SpineServices instance.");
@@ -514,21 +564,44 @@ export const spineServicesAccess = Object.freeze({
         serviceLoggers.set(services, logger);
     },
 });
+/**
+ * Buffers subscription updates and wakes active stream readers.
+ */
 class SubscriptionDelivery {
     #queue = [];
     #waiters = [];
     #queueLimit;
     #subscription;
     #closed = false;
+    /**
+     * Sets the bounded update queue capacity.
+     *
+     * @param queueLimit Maximum pending updates before closure.
+     */
     constructor(queueLimit) {
         this.#queueLimit = queueLimit;
     }
+    /**
+     * Checks whether a source attachment is active.
+     *
+     * @returns `true` after an attachment is installed.
+     */
     get active() {
         return this.#subscription !== undefined;
     }
+    /**
+     * Checks whether this delivery queue has closed.
+     *
+     * @returns `true` after closure.
+     */
     get closed() {
         return this.#closed;
     }
+    /**
+     * Attaches a source subscription or immediately removes it after close.
+     *
+     * @param subscription Source attachment to track.
+     */
     attach(subscription) {
         if (this.#closed) {
             subscription.unsubscribe();
@@ -536,6 +609,11 @@ class SubscriptionDelivery {
         }
         this.#subscription = subscription;
     }
+    /**
+     * Queues one update or wakes the next waiting stream reader.
+     *
+     * @param update State or Event update to deliver.
+     */
     push(update) {
         if (this.#closed) {
             return;
@@ -552,6 +630,11 @@ class SubscriptionDelivery {
             waiter(update);
         }
     }
+    /**
+     * Reads the next queued update, waiting while the stream is open and empty.
+     *
+     * @returns Next update, or `undefined` after closure.
+     */
     next() {
         const update = this.#queue.shift();
         if (update !== undefined || this.#closed) {
@@ -559,6 +642,9 @@ class SubscriptionDelivery {
         }
         return new Promise((resolve) => this.#waiters.push(resolve));
     }
+    /**
+     * Closes the source subscription and completes all waiting readers.
+     */
     close() {
         if (this.#closed) {
             return;
@@ -573,1014 +659,1006 @@ class SubscriptionDelivery {
     }
 }
 /**
- * Groups non-public service contract, query, and subscription operations.
+ * Builds an OK status for service responses.
  */
-const ServiceValues = (() => {
-    function okStatus() {
-        return create(StatusSchema, {
-            status: {
-                case: "ok",
-                value: create(EmptySchema),
-            },
-        });
-    }
-    function errorStatus(type, message, details) {
-        return create(StatusSchema, {
-            status: {
-                case: "error",
-                value: create(ErrorSchema, {
-                    type,
-                    message,
-                    ...(details === undefined ? {} : { details }),
-                }),
-            },
-        });
-    }
-    function okResponse() {
-        return create(ResponseSchema, { status: okStatus() });
+function okStatus() {
+    return create(StatusSchema, {
+        status: {
+            case: "ok",
+            value: create(EmptySchema),
+        },
+    });
+}
+function errorStatus(type, message, details) {
+    return create(StatusSchema, {
+        status: {
+            case: "error",
+            value: create(ErrorSchema, {
+                type,
+                message,
+                ...(details === undefined ? {} : { details }),
+            }),
+        },
+    });
+}
+function okResponse() {
+    return create(ResponseSchema, { status: okStatus() });
+}
+function errorResponse(type, message) {
+    return create(ResponseSchema, { status: errorStatus(type, message) });
+}
+function queryErrorResponse(type, message) {
+    return create(QueryResponseSchema, {
+        response: errorResponse(type, message),
+    });
+}
+function validateReadQuery(query, target, route) {
+    const formatError = formatReadError(query.format, route);
+    if (formatError !== undefined) {
+        return formatError;
+    }
+    switch (target.criterion.case) {
+        case "includeAll":
+            if (!target.criterion.value) {
+                return invalidCriterionError();
+            }
+            return undefined;
+        case "filters":
+            return validateFilters(target.criterion.value, route);
+        default:
+            return invalidCriterionError();
     }
-    function errorResponse(type, message) {
-        return create(ResponseSchema, { status: errorStatus(type, message) });
+}
+function validateFilters(filters, route) {
+    const idCount = filters.idFilter?.id.length ?? 0;
+    if (idCount > QueryLimits.idCount) {
+        return invalidQueryError("QueryService.Read id_filter may contain at most 100 IDs.");
     }
-    function queryErrorResponse(type, message) {
-        return create(QueryResponseSchema, {
-            response: errorResponse(type, message),
-        });
+    const idEntries = filters.idFilter?.id;
+    if (idEntries?.some((id) => id === undefined) === true) {
+        return invalidQueryError("QueryService.Read id_filter entries are required.");
     }
-    function validateReadQuery(query, target, route) {
-        const formatError = formatReadError(query.format, route);
-        if (formatError !== undefined) {
-            return formatError;
-        }
-        switch (target.criterion.case) {
-            case "includeAll":
-                if (!target.criterion.value) {
-                    return invalidCriterionError();
-                }
-                return undefined;
-            case "filters":
-                return validateFilters(target.criterion.value, route);
-            default:
-                return invalidCriterionError();
-        }
+    const idError = validateQueryIds(idEntries, route);
+    if (idError !== undefined) {
+        return idError;
     }
-    function validateFilters(filters, route) {
-        const idCount = filters.idFilter?.id.length ?? 0;
-        if (idCount > QueryLimits.idCount) {
-            return invalidQueryError("QueryService.Read id_filter may contain at most 100 IDs.");
-        }
-        const idEntries = filters.idFilter?.id;
-        if (idEntries?.some((id) => id === undefined) === true) {
-            return invalidQueryError("QueryService.Read id_filter entries are required.");
-        }
-        const idError = validateQueryIds(idEntries, route);
-        if (idError !== undefined) {
-            return idError;
-        }
-        if (filters.filter.length > QueryLimits.compositeCount) {
-            return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
-        }
-        const filterError = validateCompositeFilters(filters.filter, route);
-        if (filterError !== undefined) {
-            return filterError;
-        }
-        return idCount === 0 && countSimpleFilters(filters.filter) === 0
-            ? {
-                type: "INVALID_QUERY",
-                message: "QueryService.Read requires an ID filter or column filter.",
-            }
-            : undefined;
+    if (filters.filter.length > QueryLimits.compositeCount) {
+        return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
     }
-    function validateCompositeFilters(filters, route) {
-        const pending = filters.map((filter) => ({ filter, depth: 0 }));
-        const seen = new WeakSet();
-        let compositeCount = 0;
-        let simpleCount = 0;
-        while (pending.length > 0) {
-            const current = pending.pop();
-            if (current === undefined)
-                break;
-            const filter = current.filter;
-            if (seen.has(filter))
-                return unsupportedFilterError("QueryService.Read filters must not contain cycles.");
-            seen.add(filter);
-            compositeCount += 1;
-            simpleCount += filter.filter.length;
-            if (filter.filter.length === 0 && filter.compositeFilter.length === 0) {
-                return invalidQueryError("QueryService.Read composite filter must not be empty.");
-            }
-            if (compositeCount > QueryLimits.compositeCount || current.depth > 8) {
-                return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
-            }
-            if (simpleCount > QueryLimits.filterCount) {
-                return invalidQueryError("QueryService.Read may contain at most 16 simple column filters.");
-            }
-            if (compositeCount + pending.length + filter.compositeFilter.length >
-                QueryLimits.compositeCount) {
-                return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
-            }
-            if (current.depth >= 8 && filter.compositeFilter.length > 0) {
-                return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
-            }
-            const operator = filter.operator;
-            if (operator !== CompositeFilter_CompositeOperator.ALL &&
-                operator !== CompositeFilter_CompositeOperator.EITHER) {
-                return unsupportedFilterError("QueryService.Read composite operator must be ALL or EITHER.");
-            }
-            const simpleError = validateSimpleFilters(filter.filter, route);
-            if (simpleError !== undefined) {
-                return simpleError;
-            }
-            for (const child of filter.compositeFilter) {
-                pending.push({ filter: child, depth: current.depth + 1 });
-            }
-        }
-        return undefined;
+    const filterError = validateCompositeFilters(filters.filter, route);
+    if (filterError !== undefined) {
+        return filterError;
     }
-    function validateQueryIds(ids, route) {
-        const schema = route.idField.message;
-        if (schema === undefined || ids === undefined) {
-            return undefined;
-        }
-        if (ids.some((id) => id === undefined || AnyMessages.unpack(id, schema) === undefined)) {
-            return invalidQueryError(`QueryService.Read id_filter values must pack ${schema.typeName}.`);
+    return idCount === 0 && countSimpleFilters(filters.filter) === 0
+        ? {
+            type: "INVALID_QUERY",
+            message: "QueryService.Read requires an ID filter or column filter.",
         }
+        : undefined;
+}
+function validateCompositeFilters(filters, route) {
+    const pending = filters.map((filter) => ({ filter, depth: 0 }));
+    const seen = new WeakSet();
+    let compositeCount = 0;
+    let simpleCount = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        const filter = current.filter;
+        if (seen.has(filter))
+            return unsupportedFilterError("QueryService.Read filters must not contain cycles.");
+        seen.add(filter);
+        compositeCount += 1;
+        simpleCount += filter.filter.length;
+        const error = ServiceValues.validateCompositeNode(filter, current.depth, compositeCount, simpleCount, pending.length, route);
+        if (error !== undefined)
+            return error;
+        for (const child of filter.compositeFilter) {
+            pending.push({ filter: child, depth: current.depth + 1 });
+        }
+    }
+    return undefined;
+}
+function validateQueryIds(ids, route) {
+    const schema = route.idField.message;
+    if (schema === undefined || ids === undefined) {
         return undefined;
     }
-    function countSimpleFilters(filters) {
-        const pending = [...filters];
-        let count = 0;
-        while (pending.length > 0) {
-            const filter = pending.pop();
-            if (filter === undefined)
-                break;
-            count += filter.filter.length;
-            pending.push(...filter.compositeFilter);
-        }
-        return count;
-    }
-    function validateSimpleFilters(filters, route) {
-        for (const filter of filters) {
-            if (wireComparison(filter.operator) === undefined) {
-                return unsupportedFilterError("QueryService.Read comparison operator is not supported.");
-            }
-            const column = filter.fieldPath?.fieldName[0];
-            if (column === undefined || column.trim().length === 0) {
-                return unsupportedFilterError("QueryService.Read column filter field is required.");
-            }
-            if (filter.fieldPath?.fieldName.length !== 1) {
-                return unsupportedFilterError("QueryService.Read supports only top-level column filters.");
-            }
-            if (!route.allowedColumnNames.has(column)) {
-                return unsupportedFilterError(`QueryService.Read column filter "${column}" is not a declared column.`);
-            }
-            if (filter.value === undefined) {
-                return unsupportedFilterError("QueryService.Read column filter value is required.");
-            }
-            const field = route.columnFields.get(column);
-            if (field === undefined
-                ? !systemValueMatches(column, filter.value)
-                : !filterValueMatches(field, filter.value)) {
-                return unsupportedFilterError(`QueryService.Read column filter "${column}" has the wrong value type.`);
-            }
-            if (filter.operator !== Filter_Operator.EQUAL &&
-                (field === undefined ? column !== "version" : !supportsRange(field))) {
-                return unsupportedFilterError(`QueryService.Read column filter "${column}" does not support range comparison.`);
-            }
-        }
-        return undefined;
+    if (ids.some((id) => id === undefined || AnyMessages.unpack(id, schema) === undefined)) {
+        return invalidQueryError(`QueryService.Read id_filter values must pack ${schema.typeName}.`);
     }
-    function formatReadError(format, route) {
-        if (format === undefined) {
-            return undefined;
-        }
-        if (format.orderBy.length > QueryLimits.orderCount) {
-            return unsupportedFormatError("QueryService.Read order_by may contain at most 8 entries.");
-        }
-        if ((format.fieldMask?.paths.length ?? 0) > QueryLimits.maskPathCount) {
-            return unsupportedFormatError("QueryService.Read field_mask may contain at most 32 paths.");
-        }
-        if (format.fieldMask?.paths.some((path) => path.length > QueryLimits.maskPathLength) ?? false) {
-            return unsupportedFormatError("QueryService.Read field_mask paths may contain at most 128 characters.");
-        }
-        for (const path of format.fieldMask?.paths ?? []) {
-            if (resolveQueryMask(route.schema, path) === undefined) {
-                return unsupportedFormatError(`QueryService.Read field_mask path "${path}" is not a state field.`);
-            }
+    return undefined;
+}
+function countSimpleFilters(filters) {
+    const pending = [...filters];
+    let count = 0;
+    while (pending.length > 0) {
+        const filter = pending.pop();
+        if (filter === undefined)
+            break;
+        count += filter.filter.length;
+        pending.push(...filter.compositeFilter);
+    }
+    return count;
+}
+function validateSimpleFilters(filters, route) {
+    for (const filter of filters) {
+        if (wireComparison(filter.operator) === undefined) {
+            return unsupportedFilterError("QueryService.Read comparison operator is not supported.");
         }
-        if (format.limit > QueryLimits.resultCount) {
-            return {
-                type: "INVALID_QUERY",
-                message: "QueryService.Read limit may be at most 1000.",
-            };
+        const column = filter.fieldPath?.fieldName[0];
+        if (column === undefined || column.trim().length === 0) {
+            return unsupportedFilterError("QueryService.Read column filter field is required.");
         }
-        if (format.limit > 0 && format.orderBy.length === 0) {
-            return {
-                type: "INVALID_QUERY",
-                message: "QueryService.Read limit requires ordering.",
-            };
+        if (filter.fieldPath?.fieldName.length !== 1) {
+            return unsupportedFilterError("QueryService.Read supports only top-level column filters.");
         }
-        for (const order of format.orderBy) {
-            if (order.column.trim().length === 0) {
-                return unsupportedFormatError("QueryService.Read order_by column is required.");
-            }
-            if (!route.allowedColumnNames.has(order.column)) {
-                return unsupportedFormatError(`QueryService.Read order_by column "${order.column}" is not a declared column.`);
-            }
-            const field = route.columnFields.get(order.column);
-            if (field === undefined ? order.column !== "version" : !supportsRange(field)) {
-                return unsupportedFormatError(`QueryService.Read order_by column "${order.column}" is not orderable.`);
-            }
-            if (order.direction !== OrderBy_Direction.ASCENDING &&
-                order.direction !== OrderBy_Direction.DESCENDING) {
-                return unsupportedFormatError("QueryService.Read order_by direction must be ASCENDING or DESCENDING.");
-            }
+        if (!route.allowedColumnNames.has(column)) {
+            return unsupportedFilterError(`QueryService.Read column filter "${column}" is not a declared column.`);
         }
-        return undefined;
-    }
-    function createReadPlan(target, query, route) {
-        const predicate = target.criterion.case === "filters"
-            ? normalizedFilters(target.criterion.value, route)
-            : undefined;
-        const format = query.format;
-        return Object.freeze({
-            ...(predicate === undefined ? {} : { predicate }),
-            ...(format?.fieldMask === undefined
-                ? {}
-                : {
-                    mask: {
-                        paths: format.fieldMask.paths.map((path) => requiredQueryMask(route.schema, path)),
-                    },
-                }),
-            ...(format === undefined || format.orderBy.length === 0
-                ? {}
-                : {
-                    order: format.orderBy.map((order) => ({
-                        column: order.column,
-                        direction: order.direction === OrderBy_Direction.DESCENDING
-                            ? "desc"
-                            : "asc",
-                    })),
-                }),
-            ...(format === undefined || format.limit === 0 ? {} : { limit: format.limit }),
-        });
-    }
-    function normalizedFilters(filters, route) {
-        const predicates = [];
-        if (filters.idFilter !== undefined) {
-            predicates.push({
-                kind: "ids",
-                ids: filters.idFilter.id.map((id) => decodeQueryIdValue(id, route)),
-            });
-        }
-        predicates.push(...filters.filter.map((filter) => normalizedComposite(filter, route)));
-        const onlyPredicate = predicates[0];
-        return predicates.length === 1 && onlyPredicate !== undefined
-            ? onlyPredicate
-            : { kind: "all", predicates };
-    }
-    function decodeQueryIdValue(value, route) {
-        const schema = route.idField.message;
-        return schema === undefined ? decodeAnyValue(value) : AnyMessages.unpack(value, schema);
-    }
-    function normalizedComposite(filter, route) {
-        const predicates = [
-            ...filter.filter.map((child) => ({
-                kind: "comparison",
-                column: requiredFilterColumn(child),
-                operator: requiredComparison(child),
-                value: decodeColumnValue(child, route),
-            })),
-            ...filter.compositeFilter.map((child) => normalizedComposite(child, route)),
-        ];
-        return {
-            kind: filter.operator === CompositeFilter_CompositeOperator.EITHER ? "either" : "all",
-            predicates,
-        };
-    }
-    function requiredFilterColumn(filter) {
-        const column = filter.fieldPath?.fieldName[0];
-        if (column !== undefined)
-            return column;
-        throw new TypeError("Validated query filter has no column.");
-    }
-    function requiredComparison(filter) {
-        const operator = wireComparison(filter.operator);
-        if (operator !== undefined)
-            return operator;
-        throw new TypeError("Validated query filter has no supported comparison operator.");
-    }
-    function decodeColumnValue(filter, route) {
-        const column = filter.fieldPath?.fieldName[0] ?? "";
-        if (column === "version" && filter.value !== undefined) {
-            const value = AnyMessages.unpack(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);
-            if (value !== undefined)
-                return value.value;
-            throw new TypeError(`Validated query column "${column}" has an invalid value.`);
+        if (filter.value === undefined) {
+            return unsupportedFilterError("QueryService.Read column filter value is required.");
         }
         const field = route.columnFields.get(column);
-        return decodeAnyValue(filter.value, field?.fieldKind === "message" ? field.message : undefined);
-    }
-    function filterValueMatches(field, value) {
-        const schema = filterValueSchema(field);
-        if (schema === undefined || value.typeUrl !== TypeUrls.derive(schema))
-            return false;
-        const decoded = field.fieldKind === "message" ? decodeAnyValue(value, schema) : decodeAnyValue(value);
-        if (field.fieldKind === "message") {
-            return isMessage(decoded) && decoded.$typeName === field.message.typeName;
-        }
-        if (field.fieldKind === "enum")
-            return typeof decoded === "number" && Number.isInteger(decoded);
-        if (field.fieldKind !== "scalar")
-            return false;
-        if (field.scalar === ScalarType.BOOL)
-            return typeof decoded === "boolean";
-        if (field.scalar === ScalarType.BYTES)
-            return decoded instanceof Uint8Array;
-        if (field.scalar === ScalarType.STRING)
-            return typeof decoded === "string";
-        if (field.scalar === ScalarType.INT64 ||
-            field.scalar === ScalarType.UINT64 ||
-            field.scalar === ScalarType.SFIXED64 ||
-            field.scalar === ScalarType.FIXED64 ||
-            field.scalar === ScalarType.SINT64) {
-            return typeof decoded === "bigint";
-        }
-        return typeof decoded === "number" && Number.isFinite(decoded);
-    }
-    function filterValueSchema(field) {
-        if (field.fieldKind === "message")
-            return field.message;
-        if (field.fieldKind === "enum")
-            return Int32ValueSchema;
-        if (field.fieldKind !== "scalar")
-            return undefined;
-        if (field.scalar === ScalarType.BOOL)
-            return BoolValueSchema;
-        if (field.scalar === ScalarType.BYTES)
-            return BytesValueSchema;
-        if (field.scalar === ScalarType.DOUBLE)
-            return DoubleValueSchema;
-        if (field.scalar === ScalarType.FLOAT)
-            return FloatValueSchema;
-        if (field.scalar === ScalarType.INT64 ||
-            field.scalar === ScalarType.SFIXED64 ||
-            field.scalar === ScalarType.SINT64) {
-            return Int64ValueSchema;
-        }
-        if (field.scalar === ScalarType.UINT64 || field.scalar === ScalarType.FIXED64) {
-            return UInt64ValueSchema;
-        }
-        if (field.scalar === ScalarType.UINT32 || field.scalar === ScalarType.FIXED32) {
-            return UInt32ValueSchema;
-        }
-        if (field.scalar === ScalarType.STRING)
-            return StringValueSchema;
-        return Int32ValueSchema;
-    }
-    function systemValueMatches(column, value) {
-        if (column === "version") {
-            return (value.typeUrl === TypeUrls.derive(VersionSchema) &&
-                AnyMessages.unpack(value, VersionSchema) !== undefined);
+        if (field === undefined
+            ? !systemValueMatches(column, filter.value)
+            : !filterValueMatches(field, filter.value)) {
+            return unsupportedFilterError(`QueryService.Read column filter "${column}" has the wrong value type.`);
         }
-        if (column === "archived" || column === "deleted") {
-            return (value.typeUrl === TypeUrls.derive(BoolValueSchema) &&
-                AnyMessages.unpack(value, BoolValueSchema) !== undefined);
+        if (filter.operator !== Filter_Operator.EQUAL &&
+            (field === undefined ? column !== "version" : !supportsRange(field))) {
+            return unsupportedFilterError(`QueryService.Read column filter "${column}" does not support range comparison.`);
         }
-        return false;
     }
-    function supportsRange(field) {
-        if (field.fieldKind === "message") {
-            return (field.message.typeName === "google.protobuf.Timestamp" ||
-                field.message.typeName === "spine.core.Version");
-        }
-        return (field.fieldKind === "scalar" &&
-            field.scalar !== ScalarType.BOOL &&
-            field.scalar !== ScalarType.BYTES);
-    }
-    function wireComparison(operator) {
-        if (operator === Filter_Operator.EQUAL)
-            return "equal";
-        if (operator === Filter_Operator.GREATER_THAN)
-            return "greaterThan";
-        if (operator === Filter_Operator.LESS_THAN)
-            return "lessThan";
-        if (operator === Filter_Operator.GREATER_OR_EQUAL)
-            return "greaterOrEqual";
-        if (operator === Filter_Operator.LESS_OR_EQUAL)
-            return "lessOrEqual";
+    return undefined;
+}
+/**
+ * Checks query ordering and limits against the registered state route.
+ */
+function formatReadError(format, route) {
+    if (format === undefined) {
         return undefined;
     }
-    function resolveQueryMask(schema, path) {
-        let current = schema;
-        const local = [];
-        for (const segment of path.split(".")) {
-            const field = findMessageField(current, segment);
-            if (field === undefined)
-                return undefined;
-            local.push(field.localName);
-            current = field.message;
-        }
-        return local.join(".");
-    }
-    function requiredQueryMask(schema, path) {
-        const resolved = resolveQueryMask(schema, path);
-        if (resolved !== undefined)
-            return resolved;
-        throw new TypeError(`Validated query mask path "${path}" is invalid.`);
+    if (format.orderBy.length > QueryLimits.orderCount) {
+        return unsupportedFormatError("QueryService.Read order_by may contain at most 8 entries.");
     }
-    function unsupportedFilterError(message) {
-        return invalidQueryError(message);
-    }
-    function unsupportedFormatError(message) {
-        return invalidQueryError(message);
-    }
-    function invalidQueryError(message) {
+    if (format.limit > QueryLimits.resultCount) {
         return {
             type: "INVALID_QUERY",
-            message,
+            message: "QueryService.Read limit may be at most 1000.",
         };
     }
-    function invalidCriterionError() {
+    if (format.limit > 0 && format.orderBy.length === 0) {
         return {
             type: "INVALID_QUERY",
-            message: "QueryService.Read requires filters or include_all = true.",
+            message: "QueryService.Read limit requires ordering.",
         };
     }
-    const DEFAULT_QUEUE_LIMIT = 100;
-    const DEFAULT_SUBSCRIPTION_LIMIT = 100;
-    /**
-     * Holds bounded request limits for QueryService.
-     */
-    const QueryLimits = Object.freeze({
-        idCount: 100,
-        filterCount: 16,
-        compositeCount: 8,
-        orderCount: 8,
-        maskPathCount: 32,
-        maskPathLength: 128,
-        resultCount: 1_000,
-    });
-    /**
-     * Holds bounded request limits for SubscriptionService.
-     */
-    const SubscriptionLimits = Object.freeze({
-        idCount: QueryLimits.idCount,
-        compositeCount: 8,
-        filterCount: 16,
-        compositeDepth: 8,
-        maskPathCount: 32,
-        maskPathLength: 128,
-        pathComponentCount: 16,
-        pathSegmentLength: 128,
+    return ServiceValues.validateReadOrder(format.orderBy, route);
+}
+/**
+ * Converts an accepted wire query into a storage plan for complete states.
+ */
+function createReadPlan(target, query, route) {
+    const predicate = target.criterion.case === "filters"
+        ? normalizedFilters(target.criterion.value, route)
+        : undefined;
+    const format = query.format;
+    return Object.freeze({
+        ...(predicate === undefined ? {} : { predicate }),
+        ...(format === undefined || format.orderBy.length === 0
+            ? {}
+            : {
+                order: format.orderBy.map((order) => ({
+                    column: order.column,
+                    direction: order.direction === OrderBy_Direction.DESCENDING
+                        ? "desc"
+                        : "asc",
+                })),
+            }),
+        ...(format === undefined || format.limit === 0 ? {} : { limit: format.limit }),
     });
-    function positiveInteger(value) {
-        return Number.isFinite(value) && value > 0 ? Math.floor(value) : 1;
+}
+function normalizedFilters(filters, route) {
+    const predicates = [];
+    if (filters.idFilter !== undefined) {
+        predicates.push({
+            kind: "ids",
+            ids: filters.idFilter.id.map((id) => decodeQueryIdValue(id, route)),
+        });
     }
-    function subscriptionLimit(value) {
-        if (!Number.isSafeInteger(value) || value <= 0) {
-            throw new TypeError("SpineServices subscriptionLimit must be a positive safe integer.");
-        }
-        return value;
+    predicates.push(...filters.filter.map((filter) => normalizedComposite(filter, route)));
+    const onlyPredicate = predicates[0];
+    return predicates.length === 1 && onlyPredicate !== undefined
+        ? onlyPredicate
+        : { kind: "all", predicates };
+}
+function decodeQueryIdValue(value, route) {
+    const schema = route.idField.message;
+    return schema === undefined ? decodeAnyValue(value) : AnyMessages.unpack(value, schema);
+}
+function normalizedComposite(filter, route) {
+    const predicates = [
+        ...filter.filter.map((child) => ({
+            kind: "comparison",
+            column: requiredFilterColumn(child),
+            operator: requiredComparison(child),
+            value: decodeColumnValue(child, route),
+        })),
+        ...filter.compositeFilter.map((child) => normalizedComposite(child, route)),
+    ];
+    return {
+        kind: filter.operator === CompositeFilter_CompositeOperator.EITHER ? "either" : "all",
+        predicates,
+    };
+}
+function requiredFilterColumn(filter) {
+    const column = filter.fieldPath?.fieldName[0];
+    if (column !== undefined)
+        return column;
+    throw new TypeError("Validated query filter has no column.");
+}
+function requiredComparison(filter) {
+    const operator = wireComparison(filter.operator);
+    if (operator !== undefined)
+        return operator;
+    throw new TypeError("Validated query filter has no supported comparison operator.");
+}
+function decodeColumnValue(filter, route) {
+    const column = filter.fieldPath?.fieldName[0] ?? "";
+    if (column === "version" && filter.value !== undefined) {
+        const value = AnyMessages.unpack(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);
+        if (value !== undefined)
+            return value.value;
+        throw new TypeError(`Validated query column "${column}" has an invalid value.`);
+    }
+    const field = route.columnFields.get(column);
+    return decodeAnyValue(filter.value, field?.fieldKind === "message" ? field.message : undefined);
+}
+function filterValueMatches(field, value) {
+    const schema = filterValueSchema(field);
+    if (schema === undefined || value.typeUrl !== TypeUrls.derive(schema))
+        return false;
+    const decoded = field.fieldKind === "message" ? decodeAnyValue(value, schema) : decodeAnyValue(value);
+    if (field.fieldKind === "message") {
+        return isMessage(decoded) && decoded.$typeName === field.message.typeName;
     }
-    function createSubscriptionRecord(input) {
-        return {
-            id: input.id,
-            subscription: clone(SubscriptionSchema, input.subscription),
-            tenantId: input.tenantId === undefined ? undefined : clone(TenantIdSchema, input.tenantId),
-            delivery: new SubscriptionDelivery(input.queueLimit),
-            ...input.shape,
-        };
+    if (field.fieldKind === "enum")
+        return typeof decoded === "number" && Number.isInteger(decoded);
+    if (field.fieldKind !== "scalar")
+        return false;
+    if (field.scalar === ScalarType.BOOL)
+        return typeof decoded === "boolean";
+    if (field.scalar === ScalarType.BYTES)
+        return decoded instanceof Uint8Array;
+    if (field.scalar === ScalarType.STRING)
+        return typeof decoded === "string";
+    if (field.scalar === ScalarType.INT64 ||
+        field.scalar === ScalarType.UINT64 ||
+        field.scalar === ScalarType.SFIXED64 ||
+        field.scalar === ScalarType.FIXED64 ||
+        field.scalar === ScalarType.SINT64) {
+        return typeof decoded === "bigint";
+    }
+    return typeof decoded === "number" && Number.isFinite(decoded);
+}
+function filterValueSchema(field) {
+    if (field.fieldKind === "message")
+        return field.message;
+    if (field.fieldKind === "enum")
+        return Int32ValueSchema;
+    if (field.fieldKind !== "scalar")
+        return undefined;
+    if (field.scalar === ScalarType.BOOL)
+        return BoolValueSchema;
+    if (field.scalar === ScalarType.BYTES)
+        return BytesValueSchema;
+    if (field.scalar === ScalarType.DOUBLE)
+        return DoubleValueSchema;
+    if (field.scalar === ScalarType.FLOAT)
+        return FloatValueSchema;
+    if (field.scalar === ScalarType.INT64 ||
+        field.scalar === ScalarType.SFIXED64 ||
+        field.scalar === ScalarType.SINT64) {
+        return Int64ValueSchema;
+    }
+    if (field.scalar === ScalarType.UINT64 || field.scalar === ScalarType.FIXED64) {
+        return UInt64ValueSchema;
+    }
+    if (field.scalar === ScalarType.UINT32 || field.scalar === ScalarType.FIXED32) {
+        return UInt32ValueSchema;
+    }
+    if (field.scalar === ScalarType.STRING)
+        return StringValueSchema;
+    return Int32ValueSchema;
+}
+function systemValueMatches(column, value) {
+    if (column === "version") {
+        return (value.typeUrl === TypeUrls.derive(VersionSchema) &&
+            AnyMessages.unpack(value, VersionSchema) !== undefined);
     }
-    function createSubscriptionRemoval() {
-        let reject;
-        let resolve;
-        const settled = new Promise((settle, fail) => {
-            reject = fail;
-            resolve = () => {
-                settle();
-            };
-        });
-        return { reject, resolve, settled };
+    if (column === "archived" || column === "deleted") {
+        return (value.typeUrl === TypeUrls.derive(BoolValueSchema) &&
+            AnyMessages.unpack(value, BoolValueSchema) !== undefined);
     }
-    function uniqueContexts(contexts) {
-        return [...new Set(contexts)];
+    return false;
+}
+function supportsRange(field) {
+    if (field.fieldKind === "message") {
+        return (field.message.typeName === "google.protobuf.Timestamp" ||
+            field.message.typeName === "spine.core.Version");
+    }
+    return (field.fieldKind === "scalar" &&
+        field.scalar !== ScalarType.BOOL &&
+        field.scalar !== ScalarType.BYTES);
+}
+function wireComparison(operator) {
+    if (operator === Filter_Operator.EQUAL)
+        return "equal";
+    if (operator === Filter_Operator.GREATER_THAN)
+        return "greaterThan";
+    if (operator === Filter_Operator.LESS_THAN)
+        return "lessThan";
+    if (operator === Filter_Operator.GREATER_OR_EQUAL)
+        return "greaterOrEqual";
+    if (operator === Filter_Operator.LESS_OR_EQUAL)
+        return "lessOrEqual";
+    return undefined;
+}
+function unsupportedFilterError(message) {
+    return invalidQueryError(message);
+}
+function unsupportedFormatError(message) {
+    return invalidQueryError(message);
+}
+function invalidQueryError(message) {
+    return {
+        type: "INVALID_QUERY",
+        message,
+    };
+}
+function invalidCriterionError() {
+    return {
+        type: "INVALID_QUERY",
+        message: "QueryService.Read requires filters or include_all = true.",
+    };
+}
+const DEFAULT_QUEUE_LIMIT = 100;
+const DEFAULT_SUBSCRIPTION_LIMIT = 100;
+/**
+ * Holds bounded request limits for QueryService.
+ */
+const QueryLimits = Object.freeze({
+    idCount: 100,
+    filterCount: 16,
+    compositeCount: 8,
+    orderCount: 8,
+    resultCount: 1_000,
+});
+/**
+ * Holds bounded request limits for SubscriptionService.
+ */
+const SubscriptionLimits = Object.freeze({
+    idCount: QueryLimits.idCount,
+    compositeCount: 8,
+    filterCount: 16,
+    compositeDepth: 8,
+    pathComponentCount: 16,
+    pathSegmentLength: 128,
+});
+function positiveInteger(value) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 1;
+}
+function subscriptionLimit(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError("SpineServices subscriptionLimit must be a positive safe integer.");
     }
-    function validateTopic(topic) {
-        if (topic.id?.value === undefined || topic.id.value.trim().length === 0) {
-            throw new ConnectError("Subscription topic ID is required.", Code.InvalidArgument);
-        }
-        if (topic.context === undefined) {
-            throw new ConnectError("Subscription topic context is required.", Code.InvalidArgument);
-        }
-        if (topic.target?.criterion.case === undefined) {
-            throw new ConnectError("Subscription topic criterion is required.", Code.InvalidArgument);
-        }
+    return value;
+}
+function createSubscriptionRecord(input) {
+    return {
+        id: input.id,
+        subscription: clone(SubscriptionSchema, input.subscription),
+        tenantId: input.tenantId === undefined ? undefined : clone(TenantIdSchema, input.tenantId),
+        delivery: new SubscriptionDelivery(input.queueLimit),
+        ...input.shape,
+    };
+}
+function createSubscriptionRemoval() {
+    let reject;
+    let resolve;
+    const settled = new Promise((settle, fail) => {
+        reject = fail;
+        resolve = () => {
+            settle();
+        };
+    });
+    return { reject, resolve, settled };
+}
+function uniqueContexts(contexts) {
+    return [...new Set(contexts)];
+}
+function validateTopic(topic) {
+    if (topic.id?.value === undefined || topic.id.value.trim().length === 0) {
+        throw new ConnectError("Subscription topic ID is required.", Code.InvalidArgument);
     }
-    function createSubscriptionShape(topic, route) {
-        const target = topic.target;
-        if (target === undefined) {
-            throw new ConnectError("Subscription topic target is required.", Code.InvalidArgument);
-        }
-        if (route.kind === "event") {
-            validateEventSubscriptionTopic(topic, target);
-            return { kind: "event", route };
-        }
-        const fieldMask = subscriptionFieldMask(topic, route);
-        switch (target.criterion.case) {
-            case "includeAll":
-                if (!target.criterion.value) {
-                    throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
-                }
-                return { kind: "state", route, matcher: { fieldMask, match: () => "state" } };
-            case "filters":
-                return {
-                    kind: "state",
-                    route,
-                    matcher: createFilteredSubscriptionMatcher(target.criterion.value, route, fieldMask),
-                };
-            default:
+    if (topic.context === undefined) {
+        throw new ConnectError("Subscription topic context is required.", Code.InvalidArgument);
+    }
+    if (topic.target?.criterion.case === undefined) {
+        throw new ConnectError("Subscription topic criterion is required.", Code.InvalidArgument);
+    }
+}
+/**
+ * Validates a topic and prepares complete state or event delivery.
+ */
+function createSubscriptionShape(topic, route) {
+    const target = topic.target;
+    if (target === undefined) {
+        throw new ConnectError("Subscription topic target is required.", Code.InvalidArgument);
+    }
+    if (route.kind === "event") {
+        validateEventSubscriptionTopic(target);
+        return { kind: "event", route };
+    }
+    switch (target.criterion.case) {
+        case "includeAll":
+            if (!target.criterion.value) {
                 throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
-        }
+            }
+            return { kind: "state", route, matcher: { match: () => "state" } };
+        case "filters":
+            return {
+                kind: "state",
+                route,
+                matcher: createFilteredSubscriptionMatcher(target.criterion.value, route),
+            };
+        default:
+            throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
     }
-    function validateEventSubscriptionTopic(topic, target) {
-        if ((topic.fieldMask?.paths.length ?? 0) > 0) {
-            throw new ConnectError("SubscriptionService.Subscribe event topics do not support field_mask.", Code.InvalidArgument);
-        }
-        switch (target.criterion.case) {
-            case "includeAll":
-                if (!target.criterion.value) {
-                    throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
-                }
-                return;
-            case "filters":
-                throw new ConnectError("SubscriptionService.Subscribe event topics support only include_all in this runtime slice.", Code.InvalidArgument);
-            default:
+}
+/**
+ * Checks the supported event topic criteria.
+ */
+function validateEventSubscriptionTopic(target) {
+    switch (target.criterion.case) {
+        case "includeAll":
+            if (!target.criterion.value) {
                 throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
-        }
+            }
+            return;
+        case "filters":
+            throw new ConnectError("SubscriptionService.Subscribe event topics support only include_all in this runtime slice.", Code.InvalidArgument);
+        default:
+            throw new ConnectError("SubscriptionService.Subscribe requires filters or include_all = true.", Code.InvalidArgument);
     }
-    function createFilteredSubscriptionMatcher(filters, route, fieldMask) {
-        if (filters.idFilter?.id.length === 0) {
-            throw new ConnectError("SubscriptionService.Subscribe id_filter requires at least one ID.", Code.InvalidArgument);
-        }
-        if (filters.idFilter !== undefined && filters.idFilter.id.length > SubscriptionLimits.idCount) {
-            throw new ConnectError("SubscriptionService.Subscribe id_filter may contain at most 100 IDs.", Code.InvalidArgument);
-        }
-        if (filters.idFilter === undefined && filters.filter.length === 0) {
-            throw new ConnectError("SubscriptionService.Subscribe requires an ID filter or field filter.", Code.InvalidArgument);
-        }
-        validateSubscriptionFilterTree(filters.filter);
-        const idValues = filters.idFilter?.id.map((id) => decodeSubscriptionIdValue(id, route));
-        const statePredicate = createSubscriptionPredicate(filters.filter, route);
-        return {
-            fieldMask,
-            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";
-                }
+}
+/**
+ * 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;
-            },
-        };
-    }
-    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);
-        }
-        const stack = [];
-        for (const filter of filters) {
-            stack.push({ filter, depth: 0 });
-        }
-        const counts = {
-            compositeCount: 0,
-            simpleCount: 0,
-        };
-        while (stack.length > 0) {
-            const current = stack.pop();
-            if (current === undefined) {
-                continue;
             }
-            validateSubscriptionFilterNode(current.filter, current.depth, counts);
-            enqueueSubscriptionFilterChildren(current.filter, current.depth, stack);
-        }
+            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);
+    }
+    const stack = [];
+    for (const filter of filters) {
+        stack.push({ filter, depth: 0 });
+    }
+    const counts = {
+        compositeCount: 0,
+        simpleCount: 0,
+    };
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined) {
+            continue;
+        }
+        validateSubscriptionFilterNode(current.filter, current.depth, counts);
+        enqueueSubscriptionFilterChildren(current.filter, current.depth, stack);
     }
-    function validateSubscriptionFilterNode(filter, depth, counts) {
-        if (depth > SubscriptionLimits.compositeDepth) {
-            throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
-        }
-        switch (filter.operator) {
-            case CompositeFilter_CompositeOperator.ALL:
-            case CompositeFilter_CompositeOperator.EITHER:
-                break;
-            default:
-                throw new ConnectError("SubscriptionService.Subscribe supports only ALL or EITHER composite filters.", Code.InvalidArgument);
-        }
-        if (depth === SubscriptionLimits.compositeDepth && filter.compositeFilter.length > 0) {
-            throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
-        }
-        counts.compositeCount += 1;
-        if (counts.compositeCount > SubscriptionLimits.compositeCount) {
-            throw new ConnectError("SubscriptionService.Subscribe may contain at most 8 composite filters.", Code.InvalidArgument);
-        }
-        counts.simpleCount += filter.filter.length;
-        if (counts.simpleCount > SubscriptionLimits.filterCount) {
-            throw new ConnectError("SubscriptionService.Subscribe may contain at most 16 simple field filters.", Code.InvalidArgument);
-        }
-        if ((filter.compositeFilter.length > 1 || depth + 1 < SubscriptionLimits.compositeDepth) &&
-            counts.compositeCount + filter.compositeFilter.length > SubscriptionLimits.compositeCount) {
-            throw new ConnectError("SubscriptionService.Subscribe may contain at most 8 composite filters.", Code.InvalidArgument);
-        }
+}
+function validateSubscriptionFilterNode(filter, depth, counts) {
+    if (depth > SubscriptionLimits.compositeDepth) {
+        throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
     }
-    function enqueueSubscriptionFilterChildren(filter, depth, stack) {
-        for (const nested of filter.compositeFilter) {
-            if (depth + 1 > SubscriptionLimits.compositeDepth) {
-                throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
-            }
-            stack.push({ filter: nested, depth: depth + 1 });
-        }
+    switch (filter.operator) {
+        case CompositeFilter_CompositeOperator.ALL:
+        case CompositeFilter_CompositeOperator.EITHER:
+            break;
+        default:
+            throw new ConnectError("SubscriptionService.Subscribe supports only ALL or EITHER composite filters.", Code.InvalidArgument);
     }
-    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));
+    if (depth === SubscriptionLimits.compositeDepth && filter.compositeFilter.length > 0) {
+        throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
     }
-    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);
+    counts.compositeCount += 1;
+    if (counts.compositeCount > SubscriptionLimits.compositeCount) {
+        throw new ConnectError("SubscriptionService.Subscribe may contain at most 8 composite filters.", Code.InvalidArgument);
     }
-    function subscriptionFieldMask(topic, route) {
-        const paths = topic.fieldMask?.paths ?? [];
-        if (paths.length === 0) {
-            return undefined;
-        }
-        if (paths.length > SubscriptionLimits.maskPathCount) {
-            throw new ConnectError("SubscriptionService.Subscribe field_mask may contain at most 32 paths.", Code.InvalidArgument);
-        }
-        if (paths.some((path) => path.length > SubscriptionLimits.maskPathLength)) {
-            throw new ConnectError("SubscriptionService.Subscribe field_mask paths may contain at most 128 characters.", Code.InvalidArgument);
-        }
-        return paths.map((path) => {
-            const segments = path.split(".");
-            validateSubscriptionPath(segments, "field_mask");
-            return resolveMessagePath(route.schema, segments, "field_mask").localPath.join(".");
-        });
+    counts.simpleCount += filter.filter.length;
+    if (counts.simpleCount > SubscriptionLimits.filterCount) {
+        throw new ConnectError("SubscriptionService.Subscribe may contain at most 16 simple field filters.", Code.InvalidArgument);
     }
-    function validateSubscriptionPath(fieldPath, label) {
-        if (fieldPath.length === 0 || fieldPath.some((field) => field.trim().length === 0)) {
-            throw new ConnectError(`SubscriptionService.Subscribe ${label} path is required.`, Code.InvalidArgument);
-        }
-        if (fieldPath.length > SubscriptionLimits.pathComponentCount) {
-            throw new ConnectError(`SubscriptionService.Subscribe ${label} path may contain at most 16 components.`, Code.InvalidArgument);
-        }
-        if (fieldPath.some((field) => field.length > SubscriptionLimits.pathSegmentLength)) {
-            throw new ConnectError(`SubscriptionService.Subscribe ${label} path components may contain at most 128 characters.`, Code.InvalidArgument);
-        }
+    if ((filter.compositeFilter.length > 1 || depth + 1 < SubscriptionLimits.compositeDepth) &&
+        counts.compositeCount + filter.compositeFilter.length > SubscriptionLimits.compositeCount) {
+        throw new ConnectError("SubscriptionService.Subscribe may contain at most 8 composite filters.", Code.InvalidArgument);
     }
-    function decodeSubscriptionIdValue(value, route) {
-        if (!isAny(value)) {
-            throw new ConnectError("SubscriptionService.Subscribe id_filter values must be packed Any messages.", Code.InvalidArgument);
-        }
-        if (route.idField.message === undefined) {
-            return decodeAnyValue(value);
-        }
-        const decoded = AnyMessages.unpack(value, route.idField.message);
-        if (decoded === undefined) {
-            throw new ConnectError(`SubscriptionService.Subscribe id_filter values must pack ${route.idField.message.typeName}.`, Code.InvalidArgument);
+}
+function enqueueSubscriptionFilterChildren(filter, depth, stack) {
+    for (const nested of filter.compositeFilter) {
+        if (depth + 1 > SubscriptionLimits.compositeDepth) {
+            throw new ConnectError("SubscriptionService.Subscribe composite filters may nest at most 8 levels.", Code.InvalidArgument);
         }
-        return decoded;
+        stack.push({ filter: nested, depth: depth + 1 });
     }
-    function decodeFieldFilterValue(value, schema) {
-        if (value === undefined || schema === undefined) {
-            return decodeAnyValue(value);
-        }
-        const decoded = AnyMessages.unpack(value, schema);
-        if (decoded === undefined) {
-            throw new ConnectError(`SubscriptionService.Subscribe field filter value must pack ${schema.typeName}.`, Code.InvalidArgument);
-        }
-        return decoded;
+}
+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);
     }
-    function decodeAnyValue(value, schema) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (schema !== undefined) {
-            const decoded = AnyMessages.unpack(value, schema);
-            if (decoded !== undefined) {
-                return decoded;
-            }
-        }
-        for (const decoder of VALUE_DECODERS) {
-            const decoded = decoder(value);
-            if (decoded !== undefined) {
-                return decoded;
-            }
-        }
-        return value;
+    if (filter.value === undefined) {
+        throw new ConnectError("SubscriptionService.Subscribe field filter value is required.", Code.InvalidArgument);
     }
-    function resolveMessagePath(schema, fieldPath, label) {
-        const localPath = [];
-        let currentSchema = schema;
-        let leafSchema;
-        for (const [index, name] of fieldPath.entries()) {
-            const field = findMessageField(currentSchema, name);
-            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) {
-                throw new ConnectError(`SubscriptionService.Subscribe ${label} "${fieldPath.join(".")}" is not a message path.`, Code.InvalidArgument);
-            }
-        }
-        return Object.freeze({
-            localPath,
-            ...(leafSchema === undefined ? {} : { leafSchema }),
-        });
+    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.
+ */
+function validateSubscriptionPath(fieldPath, label) {
+    if (fieldPath.length === 0 || fieldPath.some((field) => field.trim().length === 0)) {
+        throw new ConnectError(`SubscriptionService.Subscribe ${label} path is required.`, Code.InvalidArgument);
     }
-    function findMessageField(schema, name) {
-        const fields = (schema?.fields ?? []);
-        return fields.find((field) => field.name === name || field.localName === name);
+    if (fieldPath.length > SubscriptionLimits.pathComponentCount) {
+        throw new ConnectError(`SubscriptionService.Subscribe ${label} path may contain at most 16 components.`, Code.InvalidArgument);
     }
-    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;
+    if (fieldPath.some((field) => field.length > SubscriptionLimits.pathSegmentLength)) {
+        throw new ConnectError(`SubscriptionService.Subscribe ${label} path components may contain at most 128 characters.`, Code.InvalidArgument);
     }
-    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 decodeSubscriptionIdValue(value, route) {
+    if (!isAny(value)) {
+        throw new ConnectError("SubscriptionService.Subscribe id_filter values must be packed Any messages.", Code.InvalidArgument);
     }
-    function isMessage(value) {
-        return typeof value === "object" && value !== null && "$typeName" in value;
+    if (route.idField.message === undefined) {
+        return decodeAnyValue(value);
     }
-    function isAny(value) {
-        return isMessage(value) && value.$typeName === "google.protobuf.Any";
+    const decoded = AnyMessages.unpack(value, route.idField.message);
+    if (decoded === undefined) {
+        throw new ConnectError(`SubscriptionService.Subscribe id_filter values must pack ${route.idField.message.typeName}.`, Code.InvalidArgument);
     }
-    function bytesEqual(left, right) {
-        return left.length === right.length && left.every((byte, index) => byte === right[index]);
+    return decoded;
+}
+function decodeFieldFilterValue(value, schema) {
+    if (value === undefined || schema === undefined) {
+        return decodeAnyValue(value);
     }
-    function packVersionedState(schema, result) {
-        return create(EntityStateVersionSchema, {
-            state: AnyMessages.pack(schema, result.state, { validate: false }),
-            version: result.version ?? create(VersionSchema),
-        });
+    const decoded = AnyMessages.unpack(value, schema);
+    if (decoded === undefined) {
+        throw new ConnectError(`SubscriptionService.Subscribe field filter value must pack ${schema.typeName}.`, Code.InvalidArgument);
     }
-    function commandTenant(command) {
-        return tenantValue(command.context?.actorContext?.tenantId);
+    return decoded;
+}
+function decodeAnyValue(value, schema) {
+    if (value === undefined) {
+        return undefined;
     }
-    function topicTenant(topic) {
-        return tenantValue(topic?.context?.tenantId);
+    if (schema !== undefined) {
+        const decoded = AnyMessages.unpack(value, schema);
+        if (decoded !== undefined) {
+            return decoded;
+        }
     }
-    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;
+    for (const decoder of VALUE_DECODERS) {
+        const decoded = decoder(value);
+        if (decoded !== undefined) {
+            return decoded;
         }
     }
-    function eventTenantMatches(record, event) {
-        const tenantId = eventTenant(event);
-        return (record.tenantId === undefined ||
-            (tenantId !== undefined &&
-                TenantBoundary.from(tenantId).key === TenantBoundary.from(record.tenantId).key));
+    return value;
+}
+/**
+ * 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()) {
+        const field = findMessageField(currentSchema, name);
+        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) {
+            throw new ConnectError(`SubscriptionService.Subscribe ${label} "${fieldPath.join(".")}" is not a message path.`, Code.InvalidArgument);
+        }
     }
-    function tenantValue(tenantId) {
-        if (tenantId === undefined)
+    return Object.freeze({
+        localPath,
+        ...(leafSchema === undefined ? {} : { leafSchema }),
+    });
+}
+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;
-        try {
-            return TenantBoundary.from(tenantId).tenantId;
         }
-        catch {
+        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.
+ *
+ * @typeParam Schema Generated state schema.
+ * @param schema Schema used to pack the state.
+ * @param result Stored state and its version.
+ * @returns Wire state/version pair.
+ */
+function packVersionedState(schema, result) {
+    return create(EntityStateVersionSchema, {
+        state: AnyMessages.pack(schema, result.state, { validate: false }),
+        version: result.version ?? create(VersionSchema),
+    });
+}
+function commandTenant(command) {
+    return tenantValue(command.context?.actorContext?.tenantId);
+}
+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 stateRouteIdField(schema, idField) {
-        const field = findMessageField(schema, idField?.name ?? "") ??
-            findMessageField(schema, idField?.localName ?? "") ??
-            schema.fields[0] ??
-            undefined;
-        if (field === undefined) {
-            throw new ConnectError("Subscription target ID field is not available.", Code.InvalidArgument);
-        }
-        return field;
+}
+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;
+    try {
+        return TenantBoundary.from(tenantId).tenantId;
     }
-    function tenantMismatch(multitenant, tenantId, subject) {
-        if (multitenant) {
-            return tenantId === undefined
-                ? {
-                    type: "TENANT_REQUIRED",
-                    message: `Tenant is required for this ${subject}.`,
-                }
-                : undefined;
-        }
+    catch {
+        return undefined;
+    }
+}
+function stateRouteIdField(schema, idField) {
+    const field = findMessageField(schema, idField?.name ?? "") ??
+        findMessageField(schema, idField?.localName ?? "") ??
+        schema.fields[0] ??
+        undefined;
+    if (field === undefined) {
+        throw new ConnectError("Subscription target ID field is not available.", Code.InvalidArgument);
+    }
+    return field;
+}
+function tenantMismatch(multitenant, tenantId, subject) {
+    if (multitenant) {
         return tenantId === undefined
-            ? undefined
-            : {
-                type: "TENANT_INAPPLICABLE",
-                message: `Tenant is not applicable for this ${subject}.`,
-            };
+            ? {
+                type: "TENANT_REQUIRED",
+                message: `Tenant is required for this ${subject}.`,
+            }
+            : undefined;
     }
-    function commandPostError(error) {
-        if (error instanceof TransitionValidationError) {
-            return {
-                type: error.type,
-                message: error.clientMessage,
-                details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
-                    validate: false,
-                }),
-            };
-        }
-        if (error instanceof CommandValidationError) {
-            return {
-                type: "COMMAND_VALIDATION_ERROR",
-                message: "Command payload validation failed.",
-                details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
-                    validate: false,
-                }),
-            };
-        }
+    return tenantId === undefined
+        ? undefined
+        : {
+            type: "TENANT_INAPPLICABLE",
+            message: `Tenant is not applicable for this ${subject}.`,
+        };
+}
+function commandPostError(error) {
+    if (error instanceof TransitionValidationError) {
         return {
-            type: "COMMAND_POST_ERROR",
-            message: "Command post failed.",
+            type: error.type,
+            message: error.clientMessage,
+            details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
+                validate: false,
+            }),
         };
     }
-    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,
-    ]);
-    function createEntityUpdate(record, update) {
-        const matcher = record.matcher;
-        if (matcher === undefined)
-            return undefined;
-        const match = matcher.match(update);
-        if (match === undefined) {
-            return undefined;
-        }
-        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: match === "state"
-                                ? {
-                                    case: "state",
-                                    value: AnyMessages.pack(record.route.schema, maskedState(record, update.state), {
-                                        validate: false,
-                                    }),
-                                }
-                                : {
-                                    case: "noLongerMatching",
-                                    value: true,
-                                },
-                        }),
-                    ],
-                }),
-            },
-        });
+    if (error instanceof CommandValidationError) {
+        return {
+            type: "COMMAND_VALIDATION_ERROR",
+            message: "Command payload validation failed.",
+            details: AnyMessages.pack(ValidationErrorSchema, error.validationError, {
+                validate: false,
+            }),
+        };
     }
-    function createEventUpdate(record, event) {
-        return create(SubscriptionUpdateSchema, {
-            subscription: clone(SubscriptionSchema, record.subscription),
-            response: okResponse(),
-            update: {
-                case: "eventUpdates",
-                value: create(EventUpdatesSchema, {
-                    event: [cloneClientEvent(event)],
-                }),
-            },
-        });
+    return {
+        type: "COMMAND_POST_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,
+]);
+/**
+ * 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)
+        return undefined;
+    const kind = match === "state"
+        ? {
+            case: "state",
+            value: AnyMessages.pack(record.route.schema, clone(record.route.schema, update.state), {
+                validate: false,
+            }),
+        }
+        : { 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:
+            return undefined;
     }
-    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 maskedState(record, state) {
-        return RecordMask.apply(clone(record.route.schema, state), record.matcher?.fieldMask);
-    }
-    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:
-                return undefined;
+}
+/**
+ * Groups non-public service contract, query, and subscription operations.
+ */
+const ServiceValues = Object.freeze({
+    /**
+     * Checks one composite query filter and its current traversal bounds.
+     *
+     * @param filter The composite filter being traversed.
+     * @param depth The nesting level of this filter.
+     * @param compositeCount The number of composites visited so far.
+     * @param simpleCount The number of simple filters visited so far.
+     * @param pendingCount The number of composites waiting to be checked.
+     * @param route The registered state type and columns used to validate filters.
+     * @returns The first invalid-query error, if the filter is invalid.
+     */
+    validateCompositeNode(filter, depth, compositeCount, simpleCount, pendingCount, route) {
+        if (filter.filter.length === 0 && filter.compositeFilter.length === 0)
+            return invalidQueryError("QueryService.Read composite filter must not be empty.");
+        if (compositeCount > QueryLimits.compositeCount || depth > 8)
+            return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
+        if (simpleCount > QueryLimits.filterCount)
+            return invalidQueryError("QueryService.Read may contain at most 16 simple column filters.");
+        if (compositeCount + pendingCount + filter.compositeFilter.length > QueryLimits.compositeCount)
+            return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
+        if (depth >= 8 && filter.compositeFilter.length > 0)
+            return invalidQueryError("QueryService.Read may contain at most 8 composite filters.");
+        if (filter.operator !== CompositeFilter_CompositeOperator.ALL &&
+            filter.operator !== CompositeFilter_CompositeOperator.EITHER)
+            return unsupportedFilterError("QueryService.Read composite operator must be ALL or EITHER.");
+        return validateSimpleFilters(filter.filter, route);
+    },
+    /**
+     * Checks that every wire ordering names a sortable registered column.
+     *
+     * @param orders The wire ordering clauses in request order.
+     * @param route The registered columns available to this state type.
+     * @returns The first unsupported-format error, if an ordering is invalid.
+     */
+    validateReadOrder(orders, route) {
+        for (const order of orders) {
+            if (order.column.trim().length === 0) {
+                return unsupportedFormatError("QueryService.Read order_by column is required.");
+            }
+            if (!route.allowedColumnNames.has(order.column)) {
+                return unsupportedFormatError(`QueryService.Read order_by column "${order.column}" is not a declared column.`);
+            }
+            const field = route.columnFields.get(order.column);
+            if (field === undefined ? order.column !== "version" : !supportsRange(field)) {
+                return unsupportedFormatError(`QueryService.Read order_by column "${order.column}" is not orderable.`);
+            }
+            if (order.direction !== OrderBy_Direction.ASCENDING &&
+                order.direction !== OrderBy_Direction.DESCENDING) {
+                return unsupportedFormatError("QueryService.Read order_by direction must be ASCENDING or DESCENDING.");
+            }
         }
-    }
-    return Object.freeze({
-        commandPostError,
-        commandTenant,
-        createEntityUpdate,
-        createEventUpdate,
-        createReadPlan,
-        createSubscriptionRecord,
-        createSubscriptionRemoval,
-        createSubscriptionShape,
-        defaultQueueLimit: DEFAULT_QUEUE_LIMIT,
-        defaultSubscriptionLimit: DEFAULT_SUBSCRIPTION_LIMIT,
-        errorStatus,
-        eventTenantMatches,
-        okResponse,
-        okStatus,
-        positiveInteger,
-        packVersionedState,
-        queryErrorResponse,
-        queryResultLimit: QueryLimits.resultCount,
-        stateRouteIdField,
-        subscriptionLimit,
-        tenantMismatch,
-        tenantOptions,
-        tenantValue,
-        topicTenant,
-        uniqueContexts,
-        validateReadQuery,
-        validateTopic,
-    });
-})();
+        return undefined;
+    },
+    /**
+     * Checks that a state topic has a usable ID or field filter.
+     *
+     * @param filters The ID and field criteria from the subscription topic.
+     */
+    validateSubscriptionFilters(filters) {
+        if (filters.idFilter?.id.length === 0) {
+            throw new ConnectError("SubscriptionService.Subscribe id_filter requires at least one ID.", Code.InvalidArgument);
+        }
+        if (filters.idFilter !== undefined && filters.idFilter.id.length > SubscriptionLimits.idCount) {
+            throw new ConnectError("SubscriptionService.Subscribe id_filter may contain at most 100 IDs.", Code.InvalidArgument);
+        }
+        if (filters.idFilter === undefined && filters.filter.length === 0) {
+            throw new ConnectError("SubscriptionService.Subscribe requires an ID filter or field filter.", Code.InvalidArgument);
+        }
+        validateSubscriptionFilterTree(filters.filter);
+    },
+    commandPostError,
+    commandTenant,
+    createEntityUpdate,
+    createEventUpdate,
+    createReadPlan,
+    createSubscriptionRecord,
+    createSubscriptionRemoval,
+    createSubscriptionShape,
+    defaultQueueLimit: DEFAULT_QUEUE_LIMIT,
+    defaultSubscriptionLimit: DEFAULT_SUBSCRIPTION_LIMIT,
+    errorStatus,
+    eventTenantMatches,
+    okResponse,
+    okStatus,
+    positiveInteger,
+    packVersionedState,
+    queryErrorResponse,
+    queryResultLimit: QueryLimits.resultCount,
+    stateRouteIdField,
+    subscriptionLimit,
+    tenantMismatch,
+    tenantOptions,
+    tenantValue,
+    topicTenant,
+    uniqueContexts,
+    validateReadQuery,
+    validateTopic,
+});
 //# sourceMappingURL=spine-services.js.map