@typeonce/ritmo 0.6.0 → 0.7.0

package/src/Decode.ts

@@ -188,7 +188,7 @@ export const struct = <const Fields extends Readonly<Record<string, Codec<any>>>
 /**
  * A stored entity handle for schema root `Root`, optionally with an intent
  * component. Decoding never proves the entity exists; resolve it with
- * `lookup.getHandle(...)` as usual.
+ * `queries.x.getHandle(...)` (through a declared query) as usual.
  */
 export const handle = <
   Root,

package/src/Descriptor.ts

@@ -16,8 +16,9 @@
  * 3. bind one `Game` with `Schema.bind(...)`
  *
  * Reach for this module first whenever you introduce a new component,
- * resource, event, or service to the game. Discrete modes whose transitions
- * matter are state machines (`Game.StateMachine(...)`), not descriptors.
+ * resource, event, or service to the game. A game-wide mode whose transitions
+ * matter is a state machine (`Game.StateMachine(...)`); a state each entity
+ * has on its own is a component (`Descriptor.EntityState(...)`).
  *
  * @module Descriptor
  * @docGroup core
@@ -311,70 +312,77 @@ export const Tag = <const Name extends string>(
 ): DecodableDescriptor<"component", Name, {}, {}, DecodeModule.DecodeError> =>
   ConstructedComponent(DecodeModule.struct({}))(name)
 
-/** One state of a {@link State} component: a string or number literal. */
-export type StateValue = string | number
+/** One state of a {@link EntityState} component: a string or number literal. */
+export type EntityStateValue = string | number
 
 /**
- * The allowed moves of a {@link State} component: for every state, the
+ * The allowed moves of a {@link EntityState} component: for every state, the
  * states it may move to (`[]` for a state with no way out).
  */
-export type StateTransitions<States extends readonly [StateValue, ...Array<StateValue>]> = {
+export type EntityStateTransitions<States extends readonly [EntityStateValue, ...Array<EntityStateValue>]> = {
   readonly [From in States[number]]: ReadonlyArray<States[number]>
 }
 
 /**
  * A component whose value is one of a closed set of states, with an optional
- * graph of allowed moves. Built with {@link State}.
+ * graph of allowed moves. Built with {@link EntityState}.
  */
-export interface StateDescriptor<
+export interface EntityStateDescriptor<
   out Name extends string,
-  in out States extends readonly [StateValue, ...Array<StateValue>],
-  in out Transitions extends StateTransitions<States> | undefined
+  in out States extends readonly [EntityStateValue, ...Array<EntityStateValue>],
+  in out Transitions extends EntityStateTransitions<States> | undefined
 > extends DecodableDescriptor<"component", Name, States[number], States[number], DecodeModule.DecodeError> {
   readonly states: States
   readonly transitions: Transitions
 }
 
 /**
- * Defines a state component: its value is one of `states`, validated (so
- * snapshots reject unknown states), and it behaves like any other component
- * (storage, change detection, rollback, traces).
+ * Defines a per-entity state: a component whose value is one of `states`,
+ * validated (so snapshots reject unknown states), that behaves like any other
+ * component (storage, change detection, rollback, traces).
+ *
+ * Use this when each entity has its own state: an enemy's attack windup, a
+ * door's open/closed, a unit's AI mode. Use `Game.StateMachine(...)` instead
+ * for one game-wide mode (menu, playing, paused, game over): machines change
+ * only at `applyStateTransitions(...)`, run `onEnter`/`onExit` schedules, and
+ * gate systems with `Game.Condition.inState(...)`. An entity state does none
+ * of that; it is data on an entity.
  *
  * With `transitions`, its write cell gains `transition(from, to)`: the pair
  * is checked against the graph at compile time, and at runtime the move
- * happens only if the current state is still `from`, otherwise it returns a
- * `StateMismatch` failure. Transitions are ordinary component writes:
+ * happens only if the current state is still `from`, otherwise it returns an
+ * `EntityStateMismatch` failure. Transitions are ordinary component writes:
  * immediate, visible to later systems, rolled back with a failed system.
  *
  * @example
  * ```ts
- * const Phase = Descriptor.State("Phase", ["ready", "windup", "active"] as const, {
+ * const Attack = Descriptor.EntityState("Attack", ["ready", "windup", "active"] as const, {
  *   transitions: { ready: ["windup"], windup: ["active", "ready"], active: ["ready"] }
  * })
- * // in a system with a write slot `phase`:
- * const moved = data.phase.transition("windup", "active")   // "ready" -> "active" does not compile
+ * // in a system with a write slot `attack`:
+ * const moved = data.attack.transition("windup", "active")   // "ready" -> "active" does not compile
  * ```
  */
-export const State = <
+export const EntityState = <
   const Name extends string,
-  const States extends readonly [StateValue, ...Array<StateValue>],
-  const Transitions extends StateTransitions<States> | undefined = undefined
+  const States extends readonly [EntityStateValue, ...Array<EntityStateValue>],
+  const Transitions extends EntityStateTransitions<States> | undefined = undefined
 >(
   name: Name,
   states: States,
   options?: {
     readonly transitions: Transitions & { readonly [Key in Exclude<keyof Transitions, States[number]>]: never }
   }
-): StateDescriptor<Name, States, Transitions> => ({
+): EntityStateDescriptor<Name, States, Transitions> => ({
   ...makeConstructedDescriptor("component", name, DecodeModule.literal(...states)),
   states,
   transitions: options?.transitions
-}) as unknown as StateDescriptor<Name, States, Transitions>
+}) as unknown as EntityStateDescriptor<Name, States, Transitions>
 
-/** Whether a descriptor was built with {@link State}. */
-export const isState = (
+/** Whether a descriptor was built with {@link EntityState}. */
+export const isEntityState = (
   descriptor: Descriptor.Any
-): descriptor is StateDescriptor<string, readonly [StateValue, ...Array<StateValue>], StateTransitions<readonly [StateValue, ...Array<StateValue>]> | undefined> =>
+): descriptor is EntityStateDescriptor<string, readonly [EntityStateValue, ...Array<EntityStateValue>], EntityStateTransitions<readonly [EntityStateValue, ...Array<EntityStateValue>]> | undefined> =>
   "states" in descriptor
 
 /**
@@ -568,7 +576,9 @@ export function constructorOf<D extends Descriptor.Any>(
  * `related` is the reverse collection maintained by the runtime.
  *
  * Use hierarchy when the relationship must support ordered children,
- * ancestor/descendant traversal, and linked recursive despawn.
+ * ancestor/descendant traversal, and linked recursive despawn. Use
+ * `Game.EntityScope(...)` instead when entities only share a lifetime (a
+ * level, a menu) and need no tree, order, or traversal.
  */
 export const Hierarchy = RelationModule.Hierarchy
 

package/src/Entity.ts

@@ -56,7 +56,8 @@ import * as Result from "./Result.ts"
  * @example
  * ```ts
  * const handle = Game.Entity.handle(playerId, Player)
- * const resolved = lookup.getHandle(handle, PlayerQuery)
+ * // `players` is a query the system declares: queries: { players: PlayerQuery }
+ * const resolved = queries.players.getHandle(handle)
  * if (!resolved.ok) return
  * ```
  */
@@ -167,11 +168,17 @@ export type StagedComponent = readonly [Descriptor<"component", string, any>, un
  *
  * Query execution is the main source of `EntityRef` values.
  */
-export interface EntityRef<S extends Schema.Any, out P extends ComponentProof, Root = unknown> {
+export interface EntityRef<S extends Schema.Any, out P extends ComponentProof, Root = unknown, out Proves = unknown> {
   /**
    * Runtime tag for debugging and pattern matching.
    */
   readonly kind: "EntityRef"
+  /**
+   * The component descriptors the query that produced this ref proves (its
+   * required slots and `with`): what `commands.despawn` checks against the
+   * system's `despawns` permission. Type-level only.
+   */
+  readonly __proves?: (_: never) => Proves
   /**
    * The schema-bound entity identity.
    */
@@ -193,12 +200,15 @@ export interface EntityMut<
   S extends Schema.Any,
   out P extends ComponentProof,
   out W extends ComponentProof,
-  Root = unknown
+  Root = unknown,
+  out Proves = unknown
 > {
   /**
    * Runtime tag for debugging and pattern matching.
    */
   readonly kind: "EntityMut"
+  /** The component descriptors the producing query proves; see `EntityRef`. */
+  readonly __proves?: (_: never) => Proves
   /**
    * The schema-bound entity identity.
    */
@@ -247,7 +257,7 @@ export type HandleTarget<S extends Schema.Any, Root = unknown> =
  * Converts a current entity into a durable handle for storage.
  *
  * The handle is storage-safe, not a proof of liveness: resolve it later with
- * `lookup.getHandle(...)`, which fails explicitly when the entity is gone.
+ * `queries.x.getHandle(...)` (through a declared query), which fails explicitly when the entity is gone.
  *
  * Pass an `intent` component when later code assumes a role such as "player"
  * or "damage source". An intent does not prove the component is still present;
@@ -283,7 +293,7 @@ export interface InvalidHandle {
  * handles, so restoring validates them like any other value.
  *
  * A handle only names an entity; it never proves the entity exists. Resolving
- * it with `lookup.getHandle(...)` stays the checked step, so any positive
+ * it with `queries.x.getHandle(...)` (through a declared query) stays the checked step, so any positive
  * integer id decodes. Object-shaped handles and other non-numeric values
  * are rejected.
  *

package/src/EntityScope.ts

@@ -7,6 +7,12 @@
  * build scenes without teaching the ECS runtime about menus, levels, overlays,
  * or any other game-specific scene model.
  *
+ * Use a scope when a set of entities shares one lifetime and nothing else: a
+ * level's walls, a menu's buttons. Membership is flat, unordered, and not
+ * queryable. Use `Descriptor.Hierarchy(...)` instead when entities form a
+ * parent-child tree: ordered children, `lookup.parent` / `descendants`
+ * traversal, and children despawned with their parent.
+ *
  * @module EntityScope
  * @docGroup core
  */

package/src/HostClock.ts

@@ -0,0 +1,64 @@
+/**
+ * The host's wall clock, as an injected contract.
+ *
+ * Core and the generic devtools modules never read a platform clock
+ * (`performance`, `Date`) themselves: whatever measures host time (debug
+ * trace durations, session timings, replay windows) takes a `HostClock`.
+ * Platform packages provide implementations (`BrowserHostClock.make(window)`
+ * in the browser package); `standard` works in every JavaScript engine, and
+ * `test()` is a manual clock for deterministic tests.
+ *
+ * Host time is for measuring the host (how long a tick took), never for game
+ * logic: simulation time is a resource the schedule advances.
+ *
+ * @example
+ * ```ts
+ * const runtime = Game.Runtime.make({ services, debug: { hostClock: HostClock.standard } })
+ * ```
+ *
+ * @module HostClock
+ * @docGroup runtime
+ */
+import * as Result from "./Result.ts"
+
+/** A host clock: `now()` in milliseconds, from an arbitrary origin. */
+export interface HostClock {
+  readonly now: () => number
+}
+
+/**
+ * `Date.now`, which every JavaScript engine provides. Its readings can jump
+ * (the system clock is adjusted, or the device sleeps), so a duration
+ * computed from two readings can be negative: consumers clamp durations to
+ * 0. Prefer a monotonic platform clock when there is one
+ * (`BrowserHostClock.make(window)`).
+ */
+export const standard: HostClock = { now: () => Date.now() }
+
+/** `adjust` must leave a finite clock reading and never move backwards. */
+export interface InvalidAdjustment {
+  readonly _tag: "InvalidAdjustment"
+  readonly ms: number
+}
+
+/** A manual clock for tests: starts at 0 and moves only through `adjust`. */
+export interface TestHostClock extends HostClock {
+  /** Moves the clock forward by `ms` (0 or more). */
+  readonly adjust: (ms: number) => Result.Result<void, InvalidAdjustment>
+}
+
+/** A test clock at 0. Every reading is the same until `adjust` moves it. */
+export const test = (): TestHostClock => {
+  let current = 0
+  return {
+    now: () => current,
+    adjust: (ms) => {
+      if (!Number.isFinite(ms) || ms < 0 || !Number.isFinite(current + ms)) return Result.failure({ _tag: "InvalidAdjustment", ms })
+      current += ms
+      return Result.success(undefined)
+    }
+  }
+}
+
+/** A duration between two readings, clamped to 0 when the clock went backwards. */
+export const elapsed = (from: number, to: number): number => Math.max(0, to - from)

package/src/Inspector.ts

@@ -6,6 +6,12 @@
  * They run on demand through `runtime.inspect(...)` and return a value without
  * advancing schedule visibility.
  *
+ * An inspector is the one typed read-only view of the world: tests, saves, UI,
+ * `Game.Condition.check(...)` projections, and devtools invariants
+ * (`Invariant.fromInspector(...)`) are all built from it. `runtime.inspect`
+ * rejects at compile time an inspector that reads a resource, service, or
+ * machine the runtime was not given.
+ *
  * @module Inspector
  * @docGroup runtime
  */
@@ -74,7 +80,7 @@ export interface InspectorDefinition<
 > {
   readonly kind: "inspector"
   readonly name: Name
-  readonly system: System.SystemDefinition<Spec, void, never, Root, Name, Needs>
+  readonly system: System.SystemDefinition<Spec, never, Root, Name, Needs>
   readonly requirements: ReadonlyArray<Needs>
   readonly read: (context: InspectorContext<Spec>) => Value
   readonly __schemaRoot?: Root | undefined
@@ -111,7 +117,6 @@ export const make = <
     () => undefined
   ) as unknown as System.SystemDefinition<
     System.SystemSpec<S, Access, Root>,
-    void,
     never,
     Root,
     Name,

package/src/Machine.ts

@@ -9,6 +9,10 @@
  * run around that boundary. Menus, rounds, encounter phases, pause flows, and
  * restart/reset pipelines are the canonical cases.
  *
+ * A machine holds one value for the whole game. A state that each entity has
+ * on its own (an enemy's attack windup, a door's open/closed) is not a
+ * machine: use a `Descriptor.EntityState(...)` component instead.
+ *
  * @example
  * ```ts
  * // Model a gameplay phase whose transition timing matters.
@@ -33,7 +37,7 @@
  * @groupDescription Functions
  * Public constructors for machines, conditions, and explicit transition bundles.
  */
-import type { Schedule } from "./Schedule.ts"
+import type { AnyScheduleOrder, Schedule } from "./Schedule.ts"
 import * as Requirement from "./Requirement.ts"
 import type { Schema } from "./Schema.ts"
 import type { SystemFailure } from "./System.ts"
@@ -235,13 +239,16 @@ export interface TransitionScheduleDefinition<
   M extends StateMachineDefinition = StateMachineDefinition,
   Needs extends Requirement.Requirement = Requirement.Requirement,
   Root = unknown,
-  Failure extends SystemFailure = never
+  Failure extends SystemFailure = never,
+  Order extends AnyScheduleOrder = AnyScheduleOrder
 > {
   readonly steps: ReadonlyArray<Schedule.Step>
   readonly systems: ReadonlyArray<unknown>
   readonly schema: S
   readonly requirements: ReadonlyArray<Needs>
   readonly __failure?: (_: never) => Failure
+  /** The plan's order, for `Game.System.thisTick` checks of the tick that applies it. */
+  readonly __order?: (_: never) => Order
   readonly __schemaRoot?: Root | undefined
   readonly transition: {
     readonly machine: M
@@ -293,7 +300,7 @@ export type MachineNeedsFromConditions<C extends ReadonlyArray<Condition>> =
   MachineNeedsFromCondition<C[number]>
 
 /**
- * Creates a schema-bound finite-state machine definition.
+ * Creates a schema-bound finite-state machine definition: one game-wide mode.
  *
  * This is the intended default for gameplay phases and other discrete modes
  * where the transition boundary itself matters.
@@ -304,6 +311,9 @@ export type MachineNeedsFromConditions<C extends ReadonlyArray<Condition>> =
  * - explicit `applyStateTransitions(...)`
  * - `inState(...)` gating
  * - transition events or enter/exit schedules
+ *
+ * Use `Descriptor.EntityState(...)` instead when every entity carries its own
+ * state (per-entity, written immediately, no enter/exit schedules).
  */
 export const StateMachine = <
   const Name extends string,

package/src/Query.ts

@@ -69,7 +69,7 @@
  * Query authoring helpers for selecting components and declaring explicit filters.
  */
 import type { DecodeError } from "./Decode.ts"
-import type { Descriptor, StateValue } from "./Descriptor.ts"
+import type { Descriptor, EntityStateValue } from "./Descriptor.ts"
 import type { EntityId, EntityMut, EntityRef } from "./Entity.ts"
 import type * as Result from "./Result.ts"
 import type * as Relation from "./Relation.ts"
@@ -384,6 +384,9 @@ export namespace Query {
     ? false
     : true
 
+  /** The component descriptors a query proves its matches have: required selection slots and `with`. */
+  export type Proven<T extends Any> = RequiredSelectionDescriptors<T> | T["with"][number]
+
   /**
    * The readable proof produced by a query.
    */
@@ -488,24 +491,20 @@ export interface ReadCell<T> {
  * A mutable cell returned from query or resource access.
  *
  * This gives a narrow mutation surface instead of exposing raw storage objects.
+ * Values written here are already valid. Data that still needs validation
+ * goes through its descriptor's own validator: declare the descriptor with
+ * `Descriptor.ConstructedComponent` / `ConstructedResource` and write with
+ * `setRaw` / `updateRaw` on its {@link ConstructedWriteCell}.
  */
 export interface WriteCell<T> extends ReadCell<T> {
   /**
    * Replaces the current value.
    */
   set(value: T): void
-  /**
-   * Replaces the current value from an explicit result.
-   */
-  setResult<E>(result: Result.Result<T, E>): Result.Result<void, E>
   /**
    * Updates the current value based on the previous one.
    */
   update(f: (current: ReadonlyValue<T>) => T): void
-  /**
-   * Updates the current value from an explicit result-producing callback.
-   */
-  updateResult<E>(f: (current: ReadonlyValue<T>) => Result.Result<T, E>): Result.Result<void, E>
 }
 
 /**
@@ -540,13 +539,13 @@ export interface ConstructedWriteCell<T, Raw, Error> extends WriteCell<T> {
 }
 
 /**
- * A `transition(from, to)` found the state component in another state, so
+ * A `transition(from, to)` found the entity state in another state, so
  * nothing was written.
  */
-export interface StateMismatchError<T> {
-  readonly _tag: "StateMismatch"
-  /** Name of the state component. */
-  readonly state: string
+export interface EntityStateMismatchError<T> {
+  readonly _tag: "EntityStateMismatch"
+  /** Name of the `Descriptor.EntityState` component. */
+  readonly component: string
   /** The `from` state the transition expected. */
   readonly expected: T
   /** The state the component was actually in. */
@@ -554,20 +553,20 @@ export interface StateMismatchError<T> {
 }
 
 /**
- * Writable cell for a state component (`Descriptor.State`).
+ * Writable cell for an entity state component (`Descriptor.EntityState`).
  *
  * `transition(from, to)` is a compare-and-set: it writes `to` only while the
- * current state is `from`, and otherwise returns `StateMismatch` without
+ * current state is `from`, and otherwise returns `EntityStateMismatch` without
  * writing. With a transition graph, `to` must be one of the moves the graph
  * allows from `from`; without one, any pair of states is accepted.
  */
-export interface StateWriteCell<T, Transitions> extends ConstructedWriteCell<T, T, DecodeError> {
+export interface EntityStateWriteCell<T, Transitions> extends ConstructedWriteCell<T, T, DecodeError> {
   /**
    * Moves from `from` to `to` if the component is still in `from`.
    *
    * @example
    * ```ts
-   * const moved = data.phase.transition("windup", "active")
+   * const moved = data.attack.transition("windup", "active")
    * if (!moved.ok) {
    *   // moved.error.actual is the state some earlier write left
    * }
@@ -575,19 +574,19 @@ export interface StateWriteCell<T, Transitions> extends ConstructedWriteCell<T,
    */
   transition<const From extends T & keyof Transitions>(
     from: From,
-    to: StateTarget<T, Transitions, From>
-  ): Result.Result<void, StateMismatchError<T>>
+    to: EntityStateTarget<T, Transitions, From>
+  ): Result.Result<void, EntityStateMismatchError<T>>
 }
 
-type StateTarget<T, Transitions, From extends keyof Transitions> =
+type EntityStateTarget<T, Transitions, From extends keyof Transitions> =
   Transitions[From] extends ReadonlyArray<infer To> ? To & T : never
 
 /**
  * Write-cell surface produced for one queried component descriptor.
  */
 export type WriteCellForDescriptor<D extends ComponentDescriptor> =
-  D extends import("./Descriptor.ts").StateDescriptor<string, infer States extends readonly [StateValue, ...Array<StateValue>], any>
-    ? StateWriteCell<States[number], D["transitions"] extends undefined ? { readonly [K in States[number]]: States } : D["transitions"]>
+  D extends import("./Descriptor.ts").EntityStateDescriptor<string, infer States extends readonly [EntityStateValue, ...Array<EntityStateValue>], any>
+    ? EntityStateWriteCell<States[number], D["transitions"] extends undefined ? { readonly [K in States[number]]: States } : D["transitions"]>
     : D extends import("./Descriptor.ts").ConstructedDescriptor<"component", string, infer Value, infer Raw, infer Error>
     ? ConstructedWriteCell<Value, Raw, Error>
     : WriteCell<Descriptor.Value<D>>
@@ -622,11 +621,11 @@ export type OptionalReadCell<T> = PresentOptionalReadCell<T> | AbsentOptionalRea
 export type QueryMatch<S extends Schema.Any, Q extends Query.Any> =
   keyof Query.WriteProof<Q> extends never
     ? {
-        readonly entity: EntityRef<S, Query.ReadProof<Q>, Query.Root<Q>>
+        readonly entity: EntityRef<S, Query.ReadProof<Q>, Query.Root<Q>, Query.Proven<Q>>
         readonly data: Query.Cells<Q>
       }
     : {
-        readonly entity: EntityMut<S, Query.ReadProof<Q>, Query.WriteProof<Q>, Query.Root<Q>>
+        readonly entity: EntityMut<S, Query.ReadProof<Q>, Query.WriteProof<Q>, Query.Root<Q>, Query.Proven<Q>>
         readonly data: Query.Cells<Q>
       }
 
@@ -685,6 +684,14 @@ export const multipleEntitiesError = (count: number): Query.MultipleEntitiesErro
  * })
  * ```
  */
+/**
+ * `T` itself, but not a place inference reads from: a list a query omits
+ * stays `[]` even when the call sits where a wider query type is expected
+ * (`queries: { ... }` in a spec). Unlike `NoInfer`, it prints as `T`.
+ */
+// `T` appears only as the check type, which inference never reads.
+export type Uninferred<T, Bound> = [T] extends [infer U extends Bound] ? U : never
+
 export const Query = <
   const Selection extends Record<string, SelectionAccess<any, Root>>,
   const With extends ReadonlyArray<ComponentDescriptor> = [],
@@ -704,14 +711,15 @@ export const Query = <
   readonly withoutRelations?: WithoutRelations
   readonly withRelated?: WithRelated
   readonly withoutRelated?: WithoutRelated
-}): QuerySpec<Selection, With, Without, Filters, WithRelations, WithoutRelations, WithRelated, WithoutRelated, Root> => ({
+  // Uninferred: an omitted list is `[]`, never inferred from the spec it is written in (`queries: { ... }`).
+}): QuerySpec<Selection, Uninferred<With, ReadonlyArray<ComponentDescriptor>>, Uninferred<Without, ReadonlyArray<ComponentDescriptor>>, Uninferred<Filters, ReadonlyArray<Filter<ComponentDescriptor>>>, Uninferred<WithRelations, ReadonlyArray<Relation.Relation.Any>>, Uninferred<WithoutRelations, ReadonlyArray<Relation.Relation.Any>>, Uninferred<WithRelated, ReadonlyArray<Relation.Relation.Any>>, Uninferred<WithoutRelated, ReadonlyArray<Relation.Relation.Any>>, Root> => ({
   selection: spec.selection,
-  with: (spec.with ?? []) as With,
-  without: (spec.without ?? []) as Without,
-  filters: (spec.filters ?? []) as Filters,
-  withRelations: (spec.withRelations ?? []) as WithRelations,
-  withoutRelations: (spec.withoutRelations ?? []) as WithoutRelations,
-  withRelated: (spec.withRelated ?? []) as WithRelated,
-  withoutRelated: (spec.withoutRelated ?? []) as WithoutRelated,
+  with: (spec.with ?? []) as unknown as Uninferred<With, ReadonlyArray<ComponentDescriptor>>,
+  without: (spec.without ?? []) as unknown as Uninferred<Without, ReadonlyArray<ComponentDescriptor>>,
+  filters: (spec.filters ?? []) as unknown as Uninferred<Filters, ReadonlyArray<Filter<ComponentDescriptor>>>,
+  withRelations: (spec.withRelations ?? []) as unknown as Uninferred<WithRelations, ReadonlyArray<Relation.Relation.Any>>,
+  withoutRelations: (spec.withoutRelations ?? []) as unknown as Uninferred<WithoutRelations, ReadonlyArray<Relation.Relation.Any>>,
+  withRelated: (spec.withRelated ?? []) as unknown as Uninferred<WithRelated, ReadonlyArray<Relation.Relation.Any>>,
+  withoutRelated: (spec.withoutRelated ?? []) as unknown as Uninferred<WithoutRelated, ReadonlyArray<Relation.Relation.Any>>,
   __schemaRoot: undefined as unknown as Root
 })