@typeonce/ritmo 0.6.0 → 0.8.0

package/src/Schedule.ts

@@ -27,7 +27,7 @@
 import type { Condition, ConditionNeedsFromConditions, StateMachine } from "./Machine.ts"
 import * as Requirement from "./Requirement.ts"
 import type { Schema } from "./Schema.ts"
-import type { FailureOf as SystemFailureOf, SystemDefinition, SystemFailure } from "./System.ts"
+import type { FailureOf as SystemFailureOf, SystemDefinition, SystemFailure, ThisTick } from "./System.ts"
 
 export interface ApplyDeferredStep {
   readonly kind: "applyDeferred"
@@ -46,22 +46,375 @@ export type ScheduleMarkerStep =
   | ApplyDeferredStep
   | ApplyStateTransitionsStep<any, any>
 
-type AnySystem = SystemDefinition<any, any, any, any, any, any>
+type AnySystem = SystemDefinition<any, any, any, any, any>
 
 export type ScheduleStep = AnySystem | ScheduleMarkerStep
 
+/**
+ * What a schedule carries for `thisTick` checks: its entries in order, and
+ * whether any of them has a `Game.System.thisTick` read. Building a schedule
+ * computes only the flag; `runtime.tick(...)` walks the entries, and only
+ * when some read exists. Schedules never report order errors themselves.
+ *
+ * `ScheduleOrder`'s defaults claim no `thisTick` reads: `Schema.BoundSchedule`
+ * (an annotation) uses it, so a schedule with a read cannot be widened into
+ * one and lose its check. Schedule types default to `AnyScheduleOrder`, and a
+ * schedule whose order was erased that way fails at `tick` as "not
+ * statically known", never silently.
+ */
+export interface ScheduleOrder<
+  out Entries extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
+  out Reads extends boolean = false
+> {
+  readonly entries: Entries
+  readonly reads: Reads
+}
+
+/** Accepts a schedule with any order summary (constraint positions only). */
+export type AnyScheduleOrder = ScheduleOrder<ReadonlyArray<unknown>, boolean>
+
+/**
+ * One `thisTick` read whose writers do not all run earlier in the tick, as
+ * found at runtime by `tryTick` and the `this-tick-order` lint. `message` is
+ * the same text `runtime.tick(...)` reports at compile time.
+ */
+export interface OrderIssue {
+  /**
+   * `lateWriter`: the writer runs after the reader. `unflushedWriter`: a
+   * command writer runs before a query reader with no `applyDeferred()` in
+   * between.
+   */
+  readonly kind: "lateWriter" | "unflushedWriter"
+  readonly reader: string
+  /** The event or resource name, or `queries.<slot>` for a query read. */
+  readonly data: string
+  /** The writer at fault. */
+  readonly writer: string
+  readonly message: string
+}
+
+/** The message reported when the order of a tick cannot be known statically. */
+export type UnknownOrderError =
+  "the order of this tick is not statically known (a schedule or tick argument spread from a widened array) and it contains Game.System.thisTick reads: list the systems and schedules as literal arguments or an `as const` tuple"
+
+/** Plugin systems with an erased spec (`any`) take part in no order check. */
+type IsErased<T> = 0 extends 1 & T ? true : false
+
+type SpecAccessValues<Spec> =
+  Spec extends { readonly events: infer Events; readonly resources: infer Resources }
+    ? Events[keyof Events] | Resources[keyof Resources]
+    : never
+
+type SpecQueryValues<Spec> =
+  Spec extends { readonly queries: infer Queries } ? Queries[keyof Queries] : never
+
+type CarriedOrder<Entry> =
+  "__order" extends keyof Entry
+    ? Entry extends { readonly __order?: (_: never) => infer Order extends AnyScheduleOrder } ? Order : never
+    : never
+
+/** The order an entry carries: a schedule's, or the bundle of an `applyStateTransitions(...)` step. */
+type OrderOf<Entry> =
+  Entry extends { readonly kind: "applyStateTransitions"; readonly bundle?: infer Bundle }
+    ? CarriedOrder<NonNullable<Bundle>>
+    : CarriedOrder<Entry>
+
+/**
+ * Whether one entry has a `thisTick` read: a cheap flag, computed once per
+ * schedule. `"unknown"` is a nested schedule whose type was widened.
+ */
+type EntryHasReads<Entry> =
+  Entry extends AnySystem
+    ? IsErased<Entry["spec"]> extends true ? "no"
+      : [Extract<SpecAccessValues<Entry["spec"]> | SpecQueryValues<Entry["spec"]>, ThisTick>] extends [never] ? "no" : "yes"
+    : OrderOf<Entry>["reads"] extends infer Reads
+      ? boolean extends Reads ? "unknown" : Reads extends true ? "yes" : "no"
+      : "no"
+
+/** `true` when some entry reads `thisTick`, `boolean` when that cannot be known. */
+type HasReads<Entries extends ReadonlyArray<unknown>> =
+  EntryHasReads<Entries[number]> extends infer Flags
+    ? "unknown" extends Flags ? boolean : "yes" extends Flags ? true : false
+    : false
+
+/** The order summary of entries run in this order. */
+export type CompositionOrder<Entries extends ReadonlyArray<unknown>> = ScheduleOrder<Entries, HasReads<Entries>>
+
+// The detailed check below runs only from `TickOrderErrors`, for ticks with a
+// read. It never walks a tuple element by element: per read it finds the
+// reader's position at each nesting level, slices the entries after it once,
+// and looks for writers in the union of the systems there. A query read also
+// walks back from the reader to the nearest marker, which is usually close.
+
+/** An event or resource read. */
+interface DataRead<Kind, Key, Reader> {
+  readonly kind: Kind
+  readonly key: Key
+  readonly reader: Reader
+}
+
+/**
+ * A query read: the components its matches must have (`Required`), and every
+ * component it names (`Named`: selection slots, optional ones included,
+ * `with`, `without`, and filters).
+ */
+interface QueryRead<Slot, Required, Named, Reader> {
+  readonly kind: "query"
+  readonly slot: Slot
+  readonly required: Required
+  readonly named: Named
+  readonly reader: Reader
+}
+
+type DescriptorKind<D> = D extends { readonly kind: infer Kind } ? Kind : never
+
+type Names<D> = D extends { readonly name: infer Name extends string } ? Name : never
+
+type DescriptorsOf<Access> = Access extends { readonly descriptor: infer D } ? D : never
+
+/** Every system an entry runs, nested schedules and transition bundles included, as a union. */
+type SystemsIn<Entry> =
+  Entry extends AnySystem ? Entry
+  : OrderOf<Entry> extends infer Order extends AnyScheduleOrder
+    ? [Order] extends [never] ? never : SystemsIn<Order["entries"][number]>
+    : never
+
+type QueryReadOf<Slot, Q, Reader> =
+  Q extends { readonly selection: infer Selection; readonly with: infer With extends ReadonlyArray<unknown>; readonly without: infer Without extends ReadonlyArray<unknown>; readonly filters: infer Filters extends ReadonlyArray<unknown> }
+    ? QueryRead<
+        Slot,
+        Names<{ readonly [K in keyof Selection]: Selection[K] extends { readonly mode: "read" | "write"; readonly descriptor: infer D } ? D : never }[keyof Selection] | With[number]>,
+        Names<DescriptorsOf<Selection[keyof Selection]> | With[number] | Without[number] | DescriptorsOf<Filters[number]>>,
+        Reader
+      >
+    : never
+
+type SystemReads<Sys> =
+  Sys extends AnySystem
+    ? IsErased<Sys["spec"]> extends true ? never
+      :
+        | (Extract<SpecAccessValues<Sys["spec"]>, ThisTick> extends infer Access
+          ? Access extends { readonly descriptor: infer D extends { readonly name: string } }
+            ? DataRead<DescriptorKind<D>, D["name"], Sys["name"]>
+            : never
+          : never)
+        | (Sys["spec"] extends { readonly queries: infer Queries }
+          ? { readonly [K in keyof Queries]: Queries[K] extends ThisTick ? QueryReadOf<K, Queries[K], Sys["name"]> : never }[keyof Queries]
+          : never)
+    : never
+
+/** Names of the systems among `Systems` that write `Key` (other than `Reader`). */
+type WritersOf<Systems, Kind, Key, Reader> =
+  Systems extends AnySystem
+    ? IsErased<Systems["spec"]> extends true ? never
+      : Systems["name"] extends Reader ? never
+      : [Extract<SpecAccessValues<Systems["spec"]>, { readonly mode: "write"; readonly descriptor: { readonly kind: Kind; readonly name: Key } }>] extends [never]
+        ? never
+        : Systems["name"]
+    : never
+
+/**
+ * Whether declared command permissions can change what a query read sees:
+ * `spawns` covering every component it requires, or `inserts` / `removes` of
+ * any component it names. `despawns` never count.
+ */
+type CommandsCount<Commands, Required, Named> =
+  CommandNames<Commands> extends readonly [infer Spawns, infer Changes]
+    ? [Extract<Changes, Named>] extends [never]
+      ? [Spawns] extends [never] ? false
+        : [Exclude<Required, Spawns>] extends [never] ? true : false
+      : true
+    : false
+
+/** The component names a system may spawn, and may insert or remove: computed once per system, shared by every read. */
+type CommandNames<Commands> =
+  Commands extends { readonly __permissions?: (_: never) => readonly [infer Spawns, infer Inserts, infer Removes, ...Array<unknown>] }
+    ? readonly [Names<Spawns>, Names<Inserts | Removes>]
+    : readonly [never, never]
+
+/** Names of the systems among `Systems` whose commands count for a query read (other than its reader). */
+type CommandWritersOf<Systems, Required, Named, Reader> =
+  Systems extends AnySystem
+    ? IsErased<Systems["spec"]> extends true ? never
+      : Systems["name"] extends Reader ? never
+      : Systems["spec"] extends { readonly commands: infer Commands }
+        ? CommandsCount<Commands, Required, Named> extends true ? Systems["name"] : never
+        : never
+    : never
+
+type WritersFor<Systems, R> =
+  R extends QueryRead<any, infer Required, infer Named, infer Reader> ? CommandWritersOf<Systems, Required, Named, Reader>
+  : R extends DataRead<infer Kind, infer Key, infer Reader> ? WritersOf<Systems, Kind, Key, Reader>
+  : never
+
+/**
+ * Some level of the entries is a widened array that may contain a read.
+ * `MayRead` is the flag carried by the schedule holding them: a widened array
+ * no longer shows its elements, so the flag decides (`boolean`: unknown).
+ */
+type UnknownIn<Entries extends ReadonlyArray<unknown>, MayRead extends boolean> =
+  Entries extends unknown ? UnknownInOne<Entries, MayRead> : never
+
+type UnknownInOne<Entries extends ReadonlyArray<unknown>, MayRead extends boolean> =
+  number extends Entries["length"]
+    ? [MayRead] extends [false] ? never : UnknownOrderError
+    : NestedOrders<Entries[number]> extends infer Order
+      ? Order extends AnyScheduleOrder ? UnknownIn<Order["entries"], Order["reads"]> : never
+      : never
+
+type NestedOrders<Entry> = Entry extends AnySystem ? never : OrderOf<Entry>
+
+type NestedEntries<Entry> =
+  Entry extends AnySystem ? never
+  : OrderOf<Entry> extends infer Order extends AnyScheduleOrder
+    ? [Order] extends [never] ? never : Order["entries"]
+    : never
+
+type TupleOf<Length extends number, Out extends Array<unknown> = []> =
+  Out["length"] extends Length ? Out : TupleOf<Length, [...Out, unknown]>
+
+/** Literal names of the systems an entry runs; erased (`string`) names identify no one. */
+type NamesIn<Entry> =
+  SystemsIn<Entry> extends infer Sys
+    ? Sys extends AnySystem ? (string extends Sys["name"] ? never : Sys["name"]) : never
+    : never
+
+/** Indices (as numbers) of the entries that run the reader. */
+type ReaderIndices<Entries extends ReadonlyArray<unknown>, Reader> = {
+  readonly [I in keyof Entries]: Reader extends NamesIn<Entries[I]> ? I : never
+}[number] extends infer Index
+  ? Index extends `${infer N extends number}` ? N : never
+  : never
+
+type LateWriterError<R, Writer> =
+  Writer extends string
+    ? R extends QueryRead<infer Slot extends string, any, any, infer Reader extends string>
+      ? `${Writer} queues commands that ${Reader} needs this tick (queries.${Slot}), but it runs after ${Reader}: move ${Writer} before the applyDeferred() that precedes ${Reader}, or read queries.${Slot} without thisTick`
+      : R extends DataRead<any, infer Key extends string, infer Reader extends string>
+        ? `${Reader} needs ${Key} from this tick, but its writer ${Writer} runs after it: move ${Writer} before ${Reader}, or read ${Key} without thisTick`
+        : never
+    : never
+
+type UnflushedWriterError<R, Writer> =
+  Writer extends string
+    ? R extends QueryRead<infer Slot extends string, any, any, infer Reader extends string>
+      ? `${Reader} needs this tick's commands for queries.${Slot}, but ${Writer} queues them with no applyDeferred() in between: add Game.Schedule.applyDeferred() after ${Writer}`
+      : never
+    : never
+
+/** Writers of the read's data that run after its reader, at this level and inside the reader's own entry. */
+type LateWriters<Entries, R, Reader extends string> =
+  // Distributes over a union of schedules (a tick of one of several), then over each place the reader runs.
+  Entries extends ReadonlyArray<unknown> ? LateWritersAt<Entries, ReaderIndices<Entries, Reader>, R, Reader> : never
+
+type LateWritersAt<Entries extends ReadonlyArray<unknown>, Index, R, Reader extends string> =
+  Index extends number
+    ? Entries extends readonly [...TupleOf<Index>, infer At, ...infer Rest]
+      ? | LateWriterError<R, WritersFor<SystemsIn<Rest[number]>, R>>
+        | LateWriters<NestedEntries<At>, R, Reader>
+      : never
+    : never
+
+/**
+ * The systems that run between the last marker and the reader (their commands
+ * are still queued when it runs), and whether a marker was found:
+ * `[Systems, Flushed]`, one per place the reader runs.
+ */
+type Segment<Entries, Reader> =
+  Entries extends ReadonlyArray<unknown> ? SegmentAt<Entries, ReaderIndices<Entries, Reader>, Reader> : never
+
+type SegmentAt<Entries extends ReadonlyArray<unknown>, Index, Reader> =
+  Index extends number
+    ? InnerSegment<Entries[Index], Reader> extends readonly [infer Inner, infer Flushed]
+      ? Flushed extends true ? readonly [Inner, true]
+        : TailBefore<Entries, TupleOf<Index>> extends readonly [infer Outer, infer OuterFlushed]
+          ? readonly [Inner | Outer, OuterFlushed]
+          : never
+      : never
+    : never
+
+/**
+ * `TailSegment` of the entries before a position, walking back by index
+ * (`Count` holds one element per entry still to visit).
+ */
+type TailBefore<Entries extends ReadonlyArray<unknown>, Count extends ReadonlyArray<unknown>, Acc = never> =
+  Count extends readonly [unknown, ...infer Rest]
+    ? Entries[Rest["length"]] extends infer Last
+      ? Last extends ApplyDeferredStep ? readonly [Acc, true]
+        : Last extends AnySystem ? TailBefore<Entries, Rest, Acc | Last>
+        : Last extends { readonly kind: "applyStateTransitions" }
+          ? TailSegment<NestedEntries<Last>> extends readonly [infer Inner, any] ? readonly [Acc | Inner, true] : readonly [Acc, true]
+          : TailSegment<NestedEntries<Last>> extends readonly [infer Inner, infer Flushed]
+            ? Flushed extends true ? readonly [Acc | Inner, true] : TailBefore<Entries, Rest, Acc | Inner>
+            : TailBefore<Entries, Rest, Acc>
+      : never
+    : readonly [Acc, false]
+
+/** The segment inside the entry that runs the reader: none for the reader itself; a transition step flushes first. */
+type InnerSegment<At, Reader> =
+  At extends AnySystem ? readonly [never, false]
+  : At extends { readonly kind: "applyStateTransitions" }
+    ? Segment<NestedEntries<At>, Reader> extends readonly [infer Inner, any] ? readonly [Inner, true] : readonly [never, true]
+    : Segment<NestedEntries<At>, Reader>
+
+/** The systems after the last marker of `Entries` (walking back from the end), and whether a marker was found. */
+type TailSegment<Entries, Acc = never> =
+  Entries extends readonly [...infer Init, infer Last]
+    ? Last extends ApplyDeferredStep ? readonly [Acc, true]
+      : Last extends AnySystem ? TailSegment<Init, Acc | Last>
+      : Last extends { readonly kind: "applyStateTransitions" }
+        // Its bundle runs after its own flush; markers inside the bundle count too.
+        ? TailSegment<NestedEntries<Last>> extends readonly [infer Inner, any] ? readonly [Acc | Inner, true] : readonly [Acc, true]
+        : TailSegment<NestedEntries<Last>> extends readonly [infer Inner, infer Flushed]
+          ? Flushed extends true ? readonly [Acc | Inner, true] : TailSegment<Init, Acc | Inner>
+          : TailSegment<Init, Acc>
+    : readonly [Acc, false]
+
+type UnflushedWriters<Entries, R, Reader extends string> =
+  R extends QueryRead<any, any, any, any>
+    ? Segment<Entries, Reader> extends infer Found
+      ? Found extends readonly [infer Systems, any] ? UnflushedWriterError<R, WritersFor<Systems, R>> : never
+      : never
+    : never
+
+type ReadErrors<Entries extends ReadonlyArray<unknown>, Reads> =
+  Reads extends { readonly reader: infer Reader extends string }
+    ? LateWriters<Entries, Reads, Reader> | UnflushedWriters<Entries, Reads, Reader>
+    : never
+
+type CheckTick<Schedules extends ReadonlyArray<unknown>> =
+  [UnknownIn<Schedules, HasReads<Schedules>>] extends [never]
+    ? ReadErrors<Schedules, SystemReads<SystemsIn<Schedules[number]>>>
+    : UnknownOrderError
+
+/**
+ * Every `thisTick` error of one `runtime.tick(...)` call over its arguments
+ * in order: writers that run after their reader, command writers with no
+ * `applyDeferred()` before a query reader, and a call whose order is not
+ * statically known. Free when nothing has a read.
+ */
+export type TickOrderErrors<Schedules extends ReadonlyArray<unknown>> =
+  HasReads<Schedules> extends false ? never : CheckTick<Schedules>
+
 export interface TransitionBundleDefinition<
   S extends Schema.Any = Schema.Any,
   out Entries extends ReadonlyArray<StateMachine.AnyTransitionSchedule<S, any>> = ReadonlyArray<StateMachine.AnyTransitionSchedule<S, any>>,
   out Needs extends Requirement.Requirement = Requirement.Requirement,
   out Root = unknown,
   out CarriedNeeds extends Requirement.Requirement = Needs,
-  out Failure extends SystemFailure = never
+  out Failure extends SystemFailure = never,
+  out Order extends AnyScheduleOrder = AnyScheduleOrder
 > {
   readonly kind: "transitionBundle"
   readonly entries: Entries
   readonly requirements: ReadonlyArray<CarriedNeeds>
   readonly __failure?: (_: never) => Failure
+  /**
+   * The bundle's schedules in order, for `Game.System.thisTick` checks: they
+   * count at the position of the `applyStateTransitions(...)` step that
+   * applies the bundle, as if every one of them runs.
+   */
+  readonly __order?: (_: never) => Order
   readonly __schemaRoot?: Root | undefined
 }
 
@@ -70,7 +423,9 @@ export interface ExecutableScheduleDefinition<
   out Needs extends Requirement.Requirement = Requirement.Requirement,
   out Root = unknown,
   out CarriedNeeds extends Requirement.Requirement = Needs,
-  out Failure extends SystemFailure = never
+  out Failure extends SystemFailure = never,
+  // Any order by default, so a pattern that names five parameters (`infer S, any, ...`) matches every schedule.
+  out Order extends AnyScheduleOrder = AnyScheduleOrder
 > {
   readonly kind: "schedule"
   readonly steps: ReadonlyArray<ScheduleStep>
@@ -78,6 +433,8 @@ export interface ExecutableScheduleDefinition<
   readonly schema: S
   readonly requirements: ReadonlyArray<CarriedNeeds>
   readonly __failure?: (_: never) => Failure
+  /** Writes, `thisTick` reads, and order errors, checked by `runtime.tick(...)`. */
+  readonly __order?: (_: never) => Order
   readonly __schemaRoot?: Root | undefined
 }
 
@@ -86,8 +443,9 @@ export type ScheduleDefinition<
   Needs extends Requirement.Requirement = Requirement.Requirement,
   Root = unknown,
   CarriedNeeds extends Requirement.Requirement = Needs,
-  Failure extends SystemFailure = never
-> = ExecutableScheduleDefinition<S, Needs, Root, CarriedNeeds, Failure>
+  Failure extends SystemFailure = never,
+  Order extends AnyScheduleOrder = AnyScheduleOrder
+> = ExecutableScheduleDefinition<S, Needs, Root, CarriedNeeds, Failure, Order>
 
 export namespace Schedule {
   export type Definition<
@@ -114,11 +472,11 @@ export namespace Schedule {
  */
 export type ScheduleEntry =
   | ScheduleStep
-  | ScheduleDefinition<any, any, any, any, any>
+  | ScheduleDefinition<any, any, any, any, any, AnyScheduleOrder>
 
 type EntrySchema<Entry> =
   Entry extends { readonly schema: infer S extends Schema.Any } ? S
-  : Entry extends SystemDefinition<infer Spec, any, any, any, any, any> ? Spec["schema"]
+  : Entry extends SystemDefinition<infer Spec, any, any, any, any> ? Spec["schema"]
   : never
 
 type MarkerNeeds<Step> =
@@ -164,7 +522,8 @@ export type AnonymousScheduleBuildFor<
   CompositionExactRequirements<Entries>,
   Root,
   CompositionExactRequirements<Entries>,
-  CompositionFailure<Entries>
+  CompositionFailure<Entries>,
+  CompositionOrder<Entries>
 >
 
 /**
@@ -181,7 +540,8 @@ export type ConditionalScheduleBuildFor<
   CompositionExactRequirements<Entries> | ConditionNeedsFromConditions<Conditions>,
   Root,
   CompositionExactRequirements<Entries> | ConditionNeedsFromConditions<Conditions>,
-  CompositionFailure<Entries>
+  CompositionFailure<Entries>,
+  CompositionOrder<Entries>
 >
 
 export type TransitionBundleInput<S extends Schema.Any = Schema.Any, Root = unknown> =
@@ -221,7 +581,8 @@ export const transitions = <
   TransitionBundleRequirements<FlattenTransitionEntries<Entries>>,
   unknown,
   TransitionBundleRequirements<FlattenTransitionEntries<Entries>>,
-  TransitionBundleFailure<FlattenTransitionEntries<Entries>>
+  TransitionBundleFailure<FlattenTransitionEntries<Entries>>,
+  CompositionOrder<Entries>
 > => {
   const flattened = entries.flatMap((entry) =>
     "kind" in entry && entry.kind === "transitionBundle" ? [...entry.entries] : [entry]
@@ -237,7 +598,8 @@ export const transitions = <
     TransitionBundleRequirements<FlattenTransitionEntries<Entries>>,
     unknown,
     TransitionBundleRequirements<FlattenTransitionEntries<Entries>>,
-    TransitionBundleFailure<FlattenTransitionEntries<Entries>>
+    TransitionBundleFailure<FlattenTransitionEntries<Entries>>,
+    CompositionOrder<Entries>
   >
 }
 
@@ -287,6 +649,11 @@ export const make = <S extends Schema.Any, const Entries extends ReadonlyArray<S
  * system's `when`, for gating many systems on one mode (playing, paused,
  * a hit-stop) without repeating it on each.
  *
+ * Use this when the gated systems should drop the events published while
+ * they were gated (a mode change makes them stale). Use `pauseWhen` instead
+ * when they must read that backlog on resume (hit-stop, pause menu). For one
+ * system, put the same conditions in its spec's `when` / `pauseWhen`.
+ *
  * Conditions gate every system in `entries`, nested schedules included.
  * Marker steps (`applyDeferred`, `applyStateTransitions`) in the group still
  * run. A gated system is the same system as far as the runtime is concerned:
@@ -367,7 +734,7 @@ const gate = (system: AnySystem, when: ReadonlyArray<Condition>, pauseWhen: Read
 export const isSystemStep = (step: ScheduleStep | ScheduleEntry): step is AnySystem =>
   typeof step === "object" && step !== null && "spec" in step
 
-const isScheduleEntry = (entry: ScheduleEntry): entry is ScheduleDefinition<any, any, any, any, any> =>
+const isScheduleEntry = (entry: ScheduleEntry): entry is ScheduleDefinition<any, any, any, any, any, AnyScheduleOrder> =>
   typeof entry === "object" && entry !== null && "kind" in entry && entry.kind === "schedule"
 
 const describeValue = (value: unknown): string =>